@bytecodealliance/jco 1.16.1 → 1.17.0

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

@@ -1,4 +1,5 @@
-"use jco";import { environment, exit as exit$1, stderr, stdin, stdout, terminalInput, terminalOutput, terminalStderr, terminalStdin, terminalStdout } from '@bytecodealliance/preview2-shim/cli';
+"use jco";
+import { environment, exit as exit$1, stderr, stdin, stdout, terminalInput, terminalOutput, terminalStderr, terminalStdin, terminalStdout } from '@bytecodealliance/preview2-shim/cli';
 import { preopens, types } from '@bytecodealliance/preview2-shim/filesystem';
 import { error, streams } from '@bytecodealliance/preview2-shim/io';
 import { random } from '@bytecodealliance/preview2-shim/random';
@@ -165,1791 +166,2102 @@ if (getRandomBytes=== undefined) {
 }
 
 
-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 toUint32(val) {
-  return val >>> 0;
+const _debugLog = (...args) => {
+  if (!globalThis?.process?.env?.JCO_DEBUG) { return; }
+  console.debug(...args);
 }
-const TEXT_DECODER_UTF8 = new TextDecoder();
-const TEXT_ENCODER_UTF8 = new TextEncoder();
+const ASYNC_DETERMINISM = 'random';
 
-function _utf8AllocateAndEncode(s, realloc, memory) {
-  if (typeof s !== 'string') {
-    throw new TypeError('expected a string, received [' + typeof s + ']');
+class GlobalComponentAsyncLowers {
+  static map = new Map();
+  
+  constructor() { throw new Error('GlobalComponentAsyncLowers should not be constructed'); }
+  
+  static define(args) {
+    const { componentIdx, qualifiedImportFn, fn } = args;
+    let inner = GlobalComponentAsyncLowers.map.get(componentIdx);
+    if (!inner) {
+      inner = new Map();
+      GlobalComponentAsyncLowers.map.set(componentIdx, inner);
+    }
+    
+    inner.set(qualifiedImportFn, fn);
   }
-  if (s.length === 0) { return { ptr: 1, len: 0 }; }
-  let buf = TEXT_ENCODER_UTF8.encode(s);
-  let ptr = realloc(0, 0, 1, buf.length);
-  new Uint8Array(memory.buffer).set(buf, ptr);
-  return { ptr, len: buf.length, codepoints: [...s].length };
-}
-
-
-const T_FLAG = 1 << 30;
-
-function rscTableCreateOwn (table, rep) {
-  const free = table[0] & ~T_FLAG;
-  if (free === 0) {
-    table.push(0);
-    table.push(rep | T_FLAG);
-    return (table.length >> 1) - 1;
+  
+  static lookup(componentIdx, qualifiedImportFn) {
+    let inner = GlobalComponentAsyncLowers.map.get(componentIdx);
+    if (!inner) {
+      inner = new Map();
+      GlobalComponentAsyncLowers.map.set(componentIdx, inner);
+    }
+    
+    const found = inner.get(qualifiedImportFn);
+    if (found) { return found; }
+    
+    // In some cases, async lowers are *not* host provided, and
+    // but contain/will call an async function in the host.
+    //
+    // One such case is `stream.write`/`stream.read` trampolines which are
+    // actually re-exported through a patch up container *before*
+    // they call the relevant async host trampoline.
+    //
+    // So the path of execution from a component export would be:
+    //
+    // async guest export --> stream.write import (host wired) -> guest export (patch component) -> async host trampoline
+    //
+    // On top of all this, the trampoline that is eventually called is async,
+    // so we must await the patched guest export call.
+    //
+    if (qualifiedImportFn.includes("[stream-write-") || qualifiedImportFn.includes("[stream-read-")) {
+      return async (...args) => {
+        const [originalFn, ...params] = args;
+        return await originalFn(...params);
+      };
+    }
+    
+    // All other cases can call the registered function directly
+    return (...args) => {
+      const [originalFn, ...params] = args;
+      return originalFn(...params);
+    };
   }
-  table[0] = table[free << 1];
-  table[free << 1] = 0;
-  table[(free << 1) + 1] = rep | T_FLAG;
-  return free;
-}
-
-function rscTableRemove (table, handle) {
-  const scope = table[handle << 1];
-  const val = table[(handle << 1) + 1];
-  const own = (val & T_FLAG) !== 0;
-  const rep = val & ~T_FLAG;
-  if (val === 0 || (scope & T_FLAG) !== 0) throw new TypeError('Invalid handle');
-  table[handle << 1] = table[0] | T_FLAG;
-  table[0] = handle | T_FLAG;
-  return { rep, scope, own };
 }
 
-let curResourceBorrows = [];
-
-function getCurrentTask(componentIdx) {
-  if (componentIdx === undefined || componentIdx === null) {
-    throw new Error('missing/invalid component instance index [' + componentIdx + '] while getting current task');
+class GlobalAsyncParamLowers {
+  static map = new Map();
+  
+  static generateKey(args) {
+    const { componentIdx, iface, fnName } = args;
+    if (componentIdx === undefined) { throw new TypeError("missing component idx"); }
+    if (iface === undefined) { throw new TypeError("missing iface name"); }
+    if (fnName === undefined) { throw new TypeError("missing function name"); }
+    return `${componentIdx}-${iface}-${fnName}`;
   }
-  const tasks = ASYNC_TASKS_BY_COMPONENT_IDX.get(componentIdx);
-  if (tasks === undefined) { return undefined; }
-  if (tasks.length === 0) { return undefined; }
-  return tasks[tasks.length - 1];
-}
-
-function createNewCurrentTask(args) {
-  _debugLog('[createNewCurrentTask()] args', args);
-  const {
-    componentIdx,
-    isAsync,
-    entryFnName,
-    parentSubtaskID,
-    callbackFnName,
-    getCallbackFn,
-    getParamsFn,
-    stringEncoding,
-    errHandling,
-    getCalleeParamsFn,
-    resultPtr,
-    callingWasmExport,
-  } = args;
-  if (componentIdx === undefined || componentIdx === null) {
-    throw new Error('missing/invalid component instance index while starting task');
+  
+  static define(args) {
+    const { componentIdx, iface, fnName, fn } = args;
+    if (!fn) { throw new TypeError('missing function'); }
+    const key = GlobalAsyncParamLowers.generateKey(args);
+    GlobalAsyncParamLowers.map.set(key, fn);
   }
-  const taskMetas = ASYNC_TASKS_BY_COMPONENT_IDX.get(componentIdx);
-  const callbackFn = getCallbackFn ? getCallbackFn() : null;
   
-  const newTask = new AsyncTask({
-    componentIdx,
-    isAsync,
-    entryFnName,
-    callbackFn,
-    callbackFnName,
-    stringEncoding,
-    getCalleeParamsFn,
-    resultPtr,
-    errHandling,
-  });
+  static lookup(args) {
+    const { componentIdx, iface, fnName } = args;
+    const key = GlobalAsyncParamLowers.generateKey(args);
+    return GlobalAsyncParamLowers.map.get(key);
+  }
+}
+
+class GlobalComponentMemories {
+  static map = new Map();
   
-  const newTaskID = newTask.id();
-  const newTaskMeta = { id: newTaskID, componentIdx, task: newTask };
+  constructor() { throw new Error('GlobalComponentMemories should not be constructed'); }
   
-  ASYNC_CURRENT_TASK_IDS.push(newTaskID);
-  ASYNC_CURRENT_COMPONENT_IDXS.push(componentIdx);
+  static save(args) {
+    const { idx, componentIdx, memory } = args;
+    let inner = GlobalComponentMemories.map.get(componentIdx);
+    if (!inner) {
+      inner = [];
+      GlobalComponentMemories.map.set(componentIdx, inner);
+    }
+    inner.push({ memory, idx });
+  }
   
-  if (!taskMetas) {
-    ASYNC_TASKS_BY_COMPONENT_IDX.set(componentIdx, [newTaskMeta]);
-  } else {
-    taskMetas.push(newTaskMeta);
+  static getMemoriesForComponentIdx(componentIdx) {
+    const metas = GlobalComponentMemories.map.get(componentIdx);
+    return metas.map(meta => meta.memory);
   }
   
-  return [newTask, newTaskID];
+  static getMemory(componentIdx, idx) {
+    const metas = GlobalComponentMemories.map.get(componentIdx);
+    return metas.find(meta => meta.idx === idx)?.memory;
+  }
 }
 
-function endCurrentTask(componentIdx, taskID) {
-  componentIdx ??= ASYNC_CURRENT_COMPONENT_IDXS.at(-1);
-  taskID ??= ASYNC_CURRENT_TASK_IDS.at(-1);
-  _debugLog('[endCurrentTask()] args', { componentIdx, taskID });
+class RepTable {
+  #data = [0, null];
+  #target;
   
-  if (componentIdx === undefined || componentIdx === null) {
-    throw new Error('missing/invalid component instance index while ending current task');
+  constructor(args) {
+    this.target = args?.target;
   }
   
-  const tasks = ASYNC_TASKS_BY_COMPONENT_IDX.get(componentIdx);
-  if (!tasks || !Array.isArray(tasks)) {
-    throw new Error('missing/invalid tasks for component instance while ending task');
+  insert(val) {
+    _debugLog('[RepTable#insert()] args', { val, target: this.target });
+    const freeIdx = this.#data[0];
+    if (freeIdx === 0) {
+      this.#data.push(val);
+      this.#data.push(null);
+      return (this.#data.length >> 1) - 1;
+    }
+    this.#data[0] = this.#data[freeIdx << 1];
+    const placementIdx = freeIdx << 1;
+    this.#data[placementIdx] = val;
+    this.#data[placementIdx + 1] = null;
+    return freeIdx;
   }
-  if (tasks.length == 0) {
-    throw new Error('no current task(s) for component instance while ending task');
+  
+  get(rep) {
+    _debugLog('[RepTable#get()] args', { rep, target: this.target });
+    const baseIdx = rep << 1;
+    const val = this.#data[baseIdx];
+    return val;
   }
   
-  if (taskID) {
-    const last = tasks[tasks.length - 1];
-    if (last.id !== taskID) {
-      // throw new Error('current task does not match expected task ID');
-      return;
-    }
+  contains(rep) {
+    _debugLog('[RepTable#contains()] args', { rep, target: this.target });
+    const baseIdx = rep << 1;
+    return !!this.#data[baseIdx];
   }
   
-  ASYNC_CURRENT_TASK_IDS.pop();
-  ASYNC_CURRENT_COMPONENT_IDXS.pop();
+  remove(rep) {
+    _debugLog('[RepTable#remove()] args', { rep, target: this.target });
+    if (this.#data.length === 2) { throw new Error('invalid'); }
+    
+    const baseIdx = rep << 1;
+    const val = this.#data[baseIdx];
+    if (val === 0) { throw new Error('invalid resource rep (cannot be 0)'); }
+    
+    this.#data[baseIdx] = this.#data[0];
+    this.#data[0] = rep;
+    
+    return val;
+  }
   
-  const taskMeta = tasks.pop();
-  return taskMeta.task;
+  clear() {
+    _debugLog('[RepTable#clear()] args', { rep, target: this.target });
+    this.#data = [0, null];
+  }
 }
-const ASYNC_TASKS_BY_COMPONENT_IDX = new Map();
+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;
+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;
 const ASYNC_CURRENT_TASK_IDS = [];
 const ASYNC_CURRENT_COMPONENT_IDXS = [];
 
-class AsyncTask {
-  static _ID = 0n;
-  
-  static State = {
-    INITIAL: 'initial',
-    CANCELLED: 'cancelled',
-    CANCEL_PENDING: 'cancel-pending',
-    CANCEL_DELIVERED: 'cancel-delivered',
-    RESOLVED: 'resolved',
-  }
-  
-  static BlockResult = {
-    CANCELLED: 'block.cancelled',
-    NOT_CANCELLED: 'block.not-cancelled',
+function unpackCallbackResult(result) {
+  _debugLog('[unpackCallbackResult()] args', { result });
+  if (!(_typeCheckValidI32(result))) { throw new Error('invalid callback return value [' + result + '], not a valid i32'); }
+  const eventCode = result & 0xF;
+  if (eventCode < 0 || eventCode > 3) {
+    throw new Error('invalid async return value [' + eventCode + '], outside callback code range');
   }
+  if (result < 0 || result >= 2**32) { throw new Error('invalid callback result'); }
+  // TODO: table max length check?
+  const waitableSetRep = result >> 4;
+  return [eventCode, waitableSetRep];
+}
+
+function promiseWithResolvers() {
+  if (Promise.withResolvers) {
+    return Promise.withResolvers();
+  } else {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    return { promise, resolve, reject };
+  }
+}
+
+function _prepareCall(
+memoryIdx,
+getMemoryFn,
+startFn,
+returnFn,
+callerInstanceIdx,
+calleeInstanceIdx,
+taskReturnTypeIdx,
+isCalleeAsyncInt,
+stringEncoding,
+resultCountOrAsync,
+) {
+  _debugLog('[_prepareCall()]', {
+    callerInstanceIdx,
+    calleeInstanceIdx,
+    taskReturnTypeIdx,
+    isCalleeAsyncInt,
+    stringEncoding,
+    resultCountOrAsync,
+  });
+  const argArray = [...arguments];
   
-  #id;
-  #componentIdx;
-  #state;
-  #isAsync;
-  #entryFnName = null;
-  #subtasks = [];
-  
-  #onResolveHandlers = [];
-  #completionPromise = null;
-  
-  #memoryIdx = null;
-  
-  #callbackFn = null;
-  #callbackFnName = null;
-  
-  #postReturnFn = null;
-  
-  #getCalleeParamsFn = null;
-  
-  #stringEncoding = null;
+  // Since Rust will happily pass large u32s over, resultCountOrAsync should be one of:
+  // (a) u32 max size     => callee is async fn with no result
+  // (b) u32 max size - 1 => callee is async fn with result
+  // (c) any other value  => callee is sync with the given result count
+  //
+  // Due to JS handling the value as 2s complement, the `resultCountOrAsync` ends up being:
+  // (a) -1 as u32 max size
+  // (b) -2 as u32 max size - 1
+  // (c) x
+  //
+  // Due to JS mishandling the value as 2s complement, the actual values we get are:
+  // see. https://github.com/wasm-bindgen/wasm-bindgen/issues/1388
+  let isAsync = false;
+  let hasResultPointer = false;
+  if (resultCountOrAsync === -1) {
+    isAsync = true;
+    hasResultPointer = false;
+  } else if (resultCountOrAsync === -2) {
+    isAsync = true;
+    hasResultPointer = true;
+  }
   
-  #parentSubtask = null;
+  const currentCallerTaskMeta = getCurrentTask(callerInstanceIdx);
+  if (!currentCallerTaskMeta) {
+    throw new Error('invalid/missing current task for caller during prepare call');
+  }
   
-  #needsExclusiveLock = false;
+  const currentCallerTask = currentCallerTaskMeta.task;
+  if (!currentCallerTask) {
+    throw new Error('unexpectedly missing task in meta for caller during prepare call');
+  }
   
-  #errHandling;
+  if (currentCallerTask.componentIdx() !== callerInstanceIdx) {
+    throw new Error(`task component idx [${ currentCallerTask.componentIdx() }] !== [${ callerInstanceIdx }] (callee ${ calleeInstanceIdx })`);
+  }
   
-  #backpressurePromise;
-  #backpressureWaiters = 0n;
+  let getCalleeParamsFn;
+  let resultPtr = null;
+  if (hasResultPointer) {
+    const directParamsArr = argArray.slice(11);
+    getCalleeParamsFn = () => directParamsArr;
+    resultPtr = argArray[10];
+  } else {
+    const directParamsArr = argArray.slice(10);
+    getCalleeParamsFn = () => directParamsArr;
+  }
   
-  #returnLowerFns = null;
+  let encoding;
+  switch (stringEncoding) {
+    case 0:
+    encoding = 'utf8';
+    break;
+    case 1:
+    encoding = 'utf16';
+    break;
+    case 2:
+    encoding = 'compact-utf16';
+    break;
+    default:
+    throw new Error(`unrecognized string encoding enum [${stringEncoding}]`);
+  }
   
-  cancelled = false;
-  requested = false;
-  alwaysTaskReturn = false;
+  const [newTask, newTaskID] = createNewCurrentTask({
+    componentIdx: calleeInstanceIdx,
+    isAsync: isCalleeAsyncInt !== 0,
+    getCalleeParamsFn,
+    // TODO: find a way to pass the import name through here
+    entryFnName: 'task/' + currentCallerTask.id() + '/new-prepare-task',
+    stringEncoding,
+  });
   
-  returnCalls =  0;
-  storage = [0, 0];
-  borrowedHandles = {};
+  const subtask = currentCallerTask.createSubtask({
+    componentIdx: callerInstanceIdx,
+    parentTask: currentCallerTask,
+    childTask: newTask,
+    callMetadata: {
+      memory: getMemoryFn(),
+      memoryIdx,
+      resultPtr,
+      returnFn,
+      startFn,
+    }
+  });
   
-  awaitableResume = null;
-  awaitableCancel = null;
+  newTask.setParentSubtask(subtask);
+  // NOTE: This isn't really a return memory idx for the caller, it's for checking
+  // against the task.return (which will be called from the callee)
+  newTask.setReturnMemoryIdx(memoryIdx);
+}
+
+function _asyncStartCall(args, callee, paramCount, resultCount, flags) {
+  const { getCallbackFn, callbackIdx, getPostReturnFn, postReturnIdx } = args;
+  _debugLog('[_asyncStartCall()] args', args);
   
-  constructor(opts) {
-    this.#id = ++AsyncTask._ID;
-    
-    if (opts?.componentIdx === undefined) {
-      throw new TypeError('missing component id during task creation');
-    }
-    this.#componentIdx = opts.componentIdx;
-    
-    this.#state = AsyncTask.State.INITIAL;
-    this.#isAsync = opts?.isAsync ?? false;
-    this.#entryFnName = opts.entryFnName;
-    
-    const {
-      promise: completionPromise,
-      resolve: resolveCompletionPromise,
-      reject: rejectCompletionPromise,
-    } = promiseWithResolvers();
-    this.#completionPromise = completionPromise;
-    
-    this.#onResolveHandlers.push((results) => {
-      resolveCompletionPromise(results);
-    })
-    
-    if (opts.callbackFn) { this.#callbackFn = opts.callbackFn; }
-    if (opts.callbackFnName) { this.#callbackFnName = opts.callbackFnName; }
-    
-    if (opts.getCalleeParamsFn) { this.#getCalleeParamsFn = opts.getCalleeParamsFn; }
-    
-    if (opts.stringEncoding) { this.#stringEncoding = opts.stringEncoding; }
-    
-    if (opts.parentSubtask) { this.#parentSubtask = opts.parentSubtask; }
-    
-    this.#needsExclusiveLock = this.isSync() || !this.hasCallback();
-    
-    if (opts.errHandling) { this.#errHandling = opts.errHandling; }
-  }
+  const taskMeta = getCurrentTask(ASYNC_CURRENT_COMPONENT_IDXS.at(-1), ASYNC_CURRENT_TASK_IDS.at(-1));
+  if (!taskMeta) { throw new Error('invalid/missing current async task meta during prepare call'); }
   
-  taskState() { return this.#state; }
-  id() { return this.#id; }
-  componentIdx() { return this.#componentIdx; }
-  isAsync() { return this.#isAsync; }
-  entryFnName() { return this.#entryFnName; }
-  completionPromise() { return this.#completionPromise; }
+  const argArray = [...arguments];
   
-  isAsync() { return this.#isAsync; }
-  isSync() { return !this.isAsync(); }
+  // NOTE: at this point we know the current task is the one that was started
+  // in PrepareCall, so we *should* be able to pop it back off and be left with
+  // the previous task
+  const preparedTask = taskMeta.task;
+  if (!preparedTask) { throw new Error('unexpectedly missing task in task meta during prepare call'); }
   
-  getErrHandling() { return this.#errHandling; }
+  if (resultCount < 0 || resultCount > 1) { throw new Error('invalid/unsupported result count'); }
   
-  hasCallback() { return this.#callbackFn !== null; }
+  const callbackFnName = 'callback_' + callbackIdx;
+  const callbackFn = getCallbackFn();
+  preparedTask.setCallbackFn(callbackFn, callbackFnName);
+  preparedTask.setPostReturnFn(getPostReturnFn());
   
-  setReturnMemoryIdx(idx) { this.#memoryIdx = idx; }
-  getReturnMemoryIdx() { return this.#memoryIdx; }
+  const subtask = preparedTask.getParentSubtask();
   
-  setReturnLowerFns(fns) { this.#returnLowerFns = fns; }
-  getReturnLowerFns() { return this.#returnLowerFns; }
+  if (resultCount < 0 || resultCount > 1) { throw new Error(`unsupported result count [${ resultCount }]`); }
   
-  setParentSubtask(subtask) {
-    if (!subtask || !(subtask instanceof AsyncSubtask)) { return }
-    if (this.#parentSubtask) { throw new Error('parent subtask can only be set once'); }
-    this.#parentSubtask = subtask;
+  const params = preparedTask.getCalleeParams();
+  if (paramCount !== params.length) {
+    throw new Error(`unexpected callee param count [${ params.length }], _asyncStartCall invocation expected [${ paramCount }]`);
   }
   
-  getParentSubtask() { return this.#parentSubtask; }
+  subtask.setOnProgressFn(() => {
+    subtask.setPendingEventFn(() => {
+      if (subtask.resolved()) { subtask.deliverResolve(); }
+      return {
+        code: ASYNC_EVENT_CODE.SUBTASK,
+        index: rep,
+        result: subtask.getStateNumber(),
+      }
+    });
+  });
   
-  // TODO(threads): this is very inefficient, we can pass along a root task,
-  // and ideally do not need this once thread support is in place
-  getRootTask() {
-    let currentSubtask = this.getParentSubtask();
-    let task = this;
-    while (currentSubtask) {
-      task = currentSubtask.getParentTask();
-      currentSubtask = task.getParentSubtask();
-    }
-    return task;
+  const subtaskState = subtask.getStateNumber();
+  if (subtaskState < 0 || subtaskState > 2**5) {
+    throw new Error('invalid subtask state, out of valid range');
   }
   
-  setPostReturnFn(f) {
-    if (!f) { return; }
-    if (this.#postReturnFn) { throw new Error('postReturn fn can only be set once'); }
-    this.#postReturnFn = f;
-  }
-  
-  setCallbackFn(f, name) {
-    if (!f) { return; }
-    if (this.#callbackFn) { throw new Error('callback fn can only be set once'); }
-    this.#callbackFn = f;
-    this.#callbackFnName = name;
-  }
-  
-  getCallbackFnName() {
-    if (!this.#callbackFnName) { return undefined; }
-    return this.#callbackFnName;
-  }
-  
-  runCallbackFn(...args) {
-    if (!this.#callbackFn) { throw new Error('on callback function has been set for task'); }
-    return this.#callbackFn.apply(null, args);
-  }
+  const callerComponentState = getOrCreateAsyncState(subtask.componentIdx());
+  const rep = callerComponentState.subtasks.insert(subtask);
+  subtask.setRep(rep);
   
-  getCalleeParams() {
-    if (!this.#getCalleeParamsFn) { throw new Error('missing/invalid getCalleeParamsFn'); }
-    return this.#getCalleeParamsFn();
-  }
+  const calleeComponentState = getOrCreateAsyncState(preparedTask.componentIdx());
+  const calleeBackpressure = calleeComponentState.hasBackpressure();
   
-  mayEnter(task) {
-    const cstate = getOrCreateAsyncState(this.#componentIdx);
-    if (cstate.hasBackpressure()) {
-      _debugLog('[AsyncTask#mayEnter()] disallowed due to backpressure', { taskID: this.#id });
-      return false;
+  // Set up a handler on subtask completion to lower results from the call into the caller's memory region.
+  //
+  // NOTE: during fused guest->guest calls this handler is triggered, but does not actually perform
+  // lowering manually, as fused modules provider helper functions that can
+  subtask.registerOnResolveHandler((res) => {
+    _debugLog('[_asyncStartCall()] handling subtask result', { res, subtaskID: subtask.id() });
+    let subtaskCallMeta = subtask.getCallMetadata();
+    
+    // NOTE: in the case of guest -> guest async calls, there may be no memory/realloc present,
+    // as the host will intermediate the value storage/movement between calls.
+    //
+    // We can simply take the value and lower it as a parameter
+    if (subtaskCallMeta.memory || subtaskCallMeta.realloc) {
+      throw new Error("call metadata unexpectedly contains memory/realloc for guest->guest call");
     }
-    if (!cstate.callingSyncImport()) {
-      _debugLog('[AsyncTask#mayEnter()] disallowed due to sync import call', { taskID: this.#id });
-      return false;
+    
+    const callerTask = subtask.getParentTask();
+    const calleeTask = preparedTask;
+    const callerMemoryIdx = callerTask.getReturnMemoryIdx();
+    const callerComponentIdx = callerTask.componentIdx();
+    
+    // If a helper function was provided we are likely in a fused guest->guest call,
+    // and the result will be delivered (lift/lowered) via helper function
+    if (subtaskCallMeta.returnFn) {
+      _debugLog('[_asyncStartCall()] return function present while ahndling subtask result, returning early (skipping lower)');
+      return;
     }
-    const callingSyncExportWithSyncPending = cstate.callingSyncExport && !task.isAsync;
-    if (!callingSyncExportWithSyncPending) {
-      _debugLog('[AsyncTask#mayEnter()] disallowed due to sync export w/ sync pending', { taskID: this.#id });
-      return false;
+    
+    // If there is no where to lower the results, exit early
+    if (!subtaskCallMeta.resultPtr) {
+      _debugLog('[_asyncStartCall()] no result ptr during subtask result handling, returning early (skipping lower)');
+      return;
     }
-    return true;
-  }
-  
-  async enter() {
-    _debugLog('[AsyncTask#enter()] args', { taskID: this.#id });
-    const cstate = getOrCreateAsyncState(this.#componentIdx);
     
-    if (this.isSync()) { return true; }
+    let callerMemory;
+    if (callerMemoryIdx) {
+      callerMemory = GlobalComponentMemories.getMemory(callerComponentIdx, callerMemoryIdx);
+    } else {
+      const callerMemories = GlobalComponentMemories.getMemoriesForComponentIdx(callerComponentIdx);
+      if (callerMemories.length != 1) { throw new Error(`unsupported amount of caller memories`); }
+      callerMemory = callerMemories[0];
+    }
     
-    if (cstate.hasBackpressure()) {
-      cstate.addBackpressureWaiter();
-      
-      const result = await this.waitUntil({
-        readyFn: () => !cstate.hasBackpressure(),
-        cancellable: true,
-      });
-      
-      cstate.removeBackpressureWaiter();
-      
-      if (result === AsyncTask.BlockResult.CANCELLED) {
-        this.cancel();
-        return false;
-      }
+    if (!callerMemory) {
+      throw new Error(`missing memory for to guest->guest call result (subtask [${subtask.id()}])`);
     }
     
-    if (this.needsExclusiveLock()) { cstate.exclusiveLock(); }
+    const lowerFns = calleeTask.getReturnLowerFns();
+    if (!lowerFns || lowerFns.length === 0) {
+      throw new Error(`missing result lower metadata for guest->guests call (subtask [${subtask.id()}])`);
+    }
     
-    return true;
-  }
+    if (lowerFns.length !== 1) {
+      throw new Error(`only single result supported for guest->guest calls (subtask [${subtask.id()}])`);
+    }
+    
+    lowerFns[0]({
+      realloc: undefined,
+      memory: callerMemory,
+      vals: [res],
+      storagePtr: subtaskCallMeta.resultPtr,
+      componentIdx: callerComponentIdx
+    });
+    
+  });
   
-  isRunning() {
-    return this.#state !== AsyncTask.State.RESOLVED;
+  // Build call params
+  const subtaskCallMeta = subtask.getCallMetadata();
+  let startFnParams = [];
+  let calleeParams = [];
+  if (subtaskCallMeta.startFn && subtaskCallMeta.resultPtr) {
+    // If we're using a fused component start fn  and a result pointer is present,
+    // then we need to pass the result pointer and other params to the start fn
+    startFnParams.push(subtaskCallMeta.resultPtr, ...params);
+  } else {
+    // if not we need to pass params to the callee instead
+    startFnParams.push(...params);
+    calleeParams.push(...params);
   }
   
-  async waitUntil(opts) {
-    const { readyFn, waitableSetRep, cancellable } = opts;
-    _debugLog('[AsyncTask#waitUntil()] args', { taskID: this.#id, waitableSetRep, cancellable });
-    
-    const state = getOrCreateAsyncState(this.#componentIdx);
-    const wset = state.waitableSets.get(waitableSetRep);
-    
-    let event;
-    
-    wset.incrementNumWaiting();
-    
-    const keepGoing = await this.suspendUntil({
-      readyFn: () => {
-        const hasPendingEvent = wset.hasPendingEvent();
-        return readyFn() && hasPendingEvent;
-      },
-      cancellable,
+  preparedTask.registerOnResolveHandler((res) => {
+    _debugLog('[_asyncStartCall()] signaling subtask completion due to task completion', {
+      childTaskID: preparedTask.id(),
+      subtaskID: subtask.id(),
+      parentTaskID: subtask.getParentTask().id(),
+    });
+    subtask.onResolve(res);
+  });
+  
+  // TODO(fix): start fns sometimes produce results, how should they be used?
+  // the result should theoretically be used for flat lowering, but fused components do
+  // this automatically!
+  subtask.onStart({ startFnParams });
+  
+  _debugLog("[_asyncStartCall()] initial call", {
+    task: preparedTask.id(),
+    subtaskID: subtask.id(),
+    calleeFnName: callee.name,
+  });
+  
+  const callbackResult = callee.apply(null, calleeParams);
+  
+  _debugLog("[_asyncStartCall()] after initial call", {
+    task: preparedTask.id(),
+    subtaskID: subtask.id(),
+    calleeFnName: callee.name,
+  });
+  
+  const doSubtaskResolve = () => {
+    subtask.deliverResolve();
+  };
+  
+  // If a single call resolved the subtask and there is no backpressure in the guest,
+  // we can return immediately
+  if (subtask.resolved() && !calleeBackpressure) {
+    _debugLog("[_asyncStartCall()] instantly resolved", {
+      calleeComponentIdx: preparedTask.componentIdx(),
+      task: preparedTask.id(),
+      subtaskID: subtask.id(),
+      callerComponentIdx: subtask.componentIdx(),
     });
     
-    if (keepGoing) {
-      event = wset.getPendingEvent();
-    } else {
-      event = {
-        code: ASYNC_EVENT_CODE.TASK_CANCELLED,
-        index: 0,
-        result: 0,
-      };
+    // If a fused component return function was specified for the subtask,
+    // we've likely already called it during resolution of the task.
+    //
+    // In this case, we do not want to actually return 2 AKA "RETURNED",
+    // but the normal started task state, because the fused component expects to get
+    // the waitable + the original subtask state (0 AKA "STARTING")
+    //
+    if (subtask.getCallMetadata().returnFn) {
+      return Number(subtask.waitableRep()) << 4 | subtaskState;
     }
     
-    wset.decrementNumWaiting();
-    
-    return event;
+    doSubtaskResolve();
+    return AsyncSubtask.State.RETURNED;
   }
   
-  async onBlock(awaitable) {
-    _debugLog('[AsyncTask#onBlock()] args', { taskID: this.#id, awaitable });
-    if (!(awaitable instanceof Awaitable)) {
-      throw new Error('invalid awaitable during onBlock');
+  // Start the (event) driver loop that will resolve the task
+  new Promise(async (resolve, reject) => {
+    if (subtask.resolved() && calleeBackpressure) {
+      await calleeComponentState.waitForBackpressure();
+      
+      _debugLog("[_asyncStartCall()] instantly resolved after cleared backpressure", {
+        calleeComponentIdx: preparedTask.componentIdx(),
+        task: preparedTask.id(),
+        subtaskID: subtask.id(),
+        callerComponentIdx: subtask.componentIdx(),
+      });
+      return;
     }
     
-    // Build a promise that this task can await on which resolves when it is awoken
-    const { promise, resolve, reject } = promiseWithResolvers();
-    this.awaitableResume = () => {
-      _debugLog('[AsyncTask] resuming after onBlock', { taskID: this.#id });
-      resolve();
-    };
-    this.awaitableCancel = (err) => {
-      _debugLog('[AsyncTask] rejecting after onBlock', { taskID: this.#id, err });
-      reject(err);
-    };
-    
-    // Park this task/execution to be handled later
-    const state = getOrCreateAsyncState(this.#componentIdx);
-    state.parkTaskOnAwaitable({ awaitable, task: this });
+    const started = await preparedTask.enter();
+    if (!started) {
+      _debugLog('[_asyncStartCall()] task failed early', {
+        taskID: preparedTask.id(),
+        subtaskID: subtask.id(),
+      });
+      throw new Error("task failed to start");
+      return;
+    }
     
-    try {
-      await promise;
-      return AsyncTask.BlockResult.NOT_CANCELLED;
-    } catch (err) {
-      // rejection means task cancellation
-      return AsyncTask.BlockResult.CANCELLED;
-    }
-  }
-  
-  async asyncOnBlock(awaitable) {
-    _debugLog('[AsyncTask#asyncOnBlock()] args', { taskID: this.#id, awaitable });
-    if (!(awaitable instanceof Awaitable)) {
-      throw new Error('invalid awaitable during onBlock');
-    }
-    // TODO: watch for waitable AND cancellation
-    // TODO: if it WAS cancelled:
-    // - return true
-    // - only once per subtask
-    // - do not wait on the scheduler
-    // - control flow should go to the subtask (only once)
-    // - Once subtask blocks/resolves, reqlinquishControl() will tehn resolve request_cancel_end (without scheduler lock release)
-    // - control flow goes back to request_cancel
-    //
-    // Subtask cancellation should work similarly to an async import call -- runs sync up until
-    // the subtask blocks or resolves
-    //
-    throw new Error('AsyncTask#asyncOnBlock() not yet implemented');
-  }
-  
-  async yieldUntil(opts) {
-    const { readyFn, cancellable } = opts;
-    _debugLog('[AsyncTask#yield()] args', { taskID: this.#id, cancellable });
-    
-    const keepGoing = await this.suspendUntil({ readyFn, cancellable });
-    if (!keepGoing) {
-      return {
-        code: ASYNC_EVENT_CODE.TASK_CANCELLED,
-        index: 0,
-        result: 0,
-      };
-    }
-    
-    return {
-      code: ASYNC_EVENT_CODE.NONE,
-      index: 0,
-      result: 0,
-    };
-  }
-  
-  async suspendUntil(opts) {
-    const { cancellable, readyFn } = opts;
-    _debugLog('[AsyncTask#suspendUntil()] args', { cancellable });
-    
-    const pendingCancelled = this.deliverPendingCancel({ cancellable });
-    if (pendingCancelled) { return false; }
-    
-    const completed = await this.immediateSuspendUntil({ readyFn, cancellable });
-    return completed;
-  }
-  
-  // TODO(threads): equivalent to thread.suspend_until()
-  async immediateSuspendUntil(opts) {
-    const { cancellable, readyFn } = opts;
-    _debugLog('[AsyncTask#immediateSuspendUntil()] args', { cancellable, readyFn });
+    // TODO: retrieve/pass along actual fn name the callback corresponds to
+    // (at least something like `<lifted fn name>_callback`)
+    const fnName = [
+    '<task ',
+    subtask.parentTaskID(),
+    '/subtask ',
+    subtask.id(),
+    '/task ',
+    preparedTask.id(),
+    '>',
+    ].join("");
     
-    const ready = readyFn();
-    if (ready && !ASYNC_DETERMINISM && _coinFlip()) {
-      return true;
+    try {
+      _debugLog("[_asyncStartCall()] starting driver loop", { fnName, componentIdx: preparedTask.componentIdx(), });
+      await _driverLoop({
+        componentState: calleeComponentState,
+        task: preparedTask,
+        fnName,
+        isAsync: true,
+        callbackResult,
+        resolve,
+        reject
+      });
+    } catch (err) {
+      _debugLog("[AsyncStartCall] drive loop call failure", { err });
     }
     
-    const cstate = getOrCreateAsyncState(this.#componentIdx);
-    cstate.addPendingTask(this);
-    
-    const keepGoing = await this.immediateSuspend({ cancellable, readyFn });
-    return keepGoing;
-  }
-  
-  async immediateSuspend(opts) { // NOTE: equivalent to thread.suspend()
-  // TODO(threads): store readyFn on the thread
-  const { cancellable, readyFn } = opts;
-  _debugLog('[AsyncTask#immediateSuspend()] args', { cancellable, readyFn });
-  
-  const pendingCancelled = this.deliverPendingCancel({ cancellable });
-  if (pendingCancelled) { return false; }
-  
-  const cstate = getOrCreateAsyncState(this.#componentIdx);
+  });
   
-  setTimeout(() => cstate.tick(), 0);
-  const taskWait = await cstate.suspendTask({ task: this, readyFn });
-  const keepGoing = await taskWait;
-  return keepGoing;
+  return Number(subtask.waitableRep()) << 4 | subtaskState;
 }
 
-deliverPendingCancel(opts) {
-  const { cancellable } = opts;
-  _debugLog('[AsyncTask#deliverPendingCancel()] args', { cancellable });
-  
-  if (cancellable && this.#state === AsyncTask.State.PENDING_CANCEL) {
-    this.#state = Task.State.CANCEL_DELIVERED;
-    return true;
-  }
-  
-  return false;
+function _syncStartCall(callbackIdx) {
+  _debugLog('[_syncStartCall()] args', { callbackIdx });
+  throw new Error('synchronous start call not implemented!');
 }
 
-isCancelled() { return this.cancelled }
+let dv = new DataView(new ArrayBuffer());
+const dataView = mem => dv.buffer === mem.buffer ? dv : dv = new DataView(mem.buffer);
 
-cancel() {
-  _debugLog('[AsyncTask#cancel()] args', { });
-  if (!this.taskState() !== AsyncTask.State.CANCEL_DELIVERED) {
-    throw new Error(`(component [${this.#componentIdx}]) task [${this.#id}] invalid task state for cancellation`);
-  }
-  if (this.borrowedHandles.length > 0) { throw new Error('task still has borrow handles'); }
-  this.cancelled = true;
-  this.onResolve(new Error('cancelled'));
-  this.#state = AsyncTask.State.RESOLVED;
+const toUint64 = val => BigInt.asUintN(64, BigInt(val));
+
+function toUint32(val) {
+  return val >>> 0;
 }
+const TEXT_DECODER_UTF8 = new TextDecoder();
+const TEXT_ENCODER_UTF8 = new TextEncoder();
 
-onResolve(taskValue) {
-  for (const f of this.#onResolveHandlers) {
-    try {
-      f(taskValue);
-    } catch (err) {
-      console.error("error during task resolve handler", err);
-      throw err;
-    }
-  }
-  
-  if (this.#postReturnFn) {
-    _debugLog('[AsyncTask#onResolve()] running post return ', {
-      componentIdx: this.#componentIdx,
-      taskID: this.#id,
-    });
-    this.#postReturnFn();
+function _utf8AllocateAndEncode(s, realloc, memory) {
+  if (typeof s !== 'string') {
+    throw new TypeError('expected a string, received [' + typeof s + ']');
   }
+  if (s.length === 0) { return { ptr: 1, len: 0 }; }
+  let buf = TEXT_ENCODER_UTF8.encode(s);
+  let ptr = realloc(0, 0, 1, buf.length);
+  new Uint8Array(memory.buffer).set(buf, ptr);
+  return { ptr, len: buf.length, codepoints: [...s].length };
 }
 
-registerOnResolveHandler(f) {
-  this.#onResolveHandlers.push(f);
-}
 
-resolve(results) {
-  _debugLog('[AsyncTask#resolve()] args', {
-    results,
-    componentIdx: this.#componentIdx,
-    taskID: this.#id,
-  });
-  
-  if (this.#state === AsyncTask.State.RESOLVED) {
-    throw new Error(`(component [${this.#componentIdx}]) task [${this.#id}]  is already resolved (did you forget to wait for an import?)`);
-  }
-  if (this.borrowedHandles.length > 0) { throw new Error('task still has borrow handles'); }
-  switch (results.length) {
-    case 0:
-    this.onResolve(undefined);
-    break;
-    case 1:
-    this.onResolve(results[0]);
-    break;
-    default:
-    throw new Error('unexpected number of results');
+const T_FLAG = 1 << 30;
+
+function rscTableCreateOwn(table, rep) {
+  const free = table[0] & ~T_FLAG;
+  if (free === 0) {
+    table.push(0);
+    table.push(rep | T_FLAG);
+    return (table.length >> 1) - 1;
   }
-  this.#state = AsyncTask.State.RESOLVED;
+  table[0] = table[free << 1];
+  table[free << 1] = 0;
+  table[(free << 1) + 1] = rep | T_FLAG;
+  return free;
 }
 
-exit() {
-  _debugLog('[AsyncTask#exit()] args', { });
-  
-  // TODO: ensure there is only one task at a time (scheduler.lock() functionality)
-  if (this.#state !== AsyncTask.State.RESOLVED) {
-    // TODO(fix): only fused, manually specified post returns seem to break this invariant,
-    // as the TaskReturn trampoline is not activated it seems.
-    //
-    // see: test/p3/ported/wasmtime/component-async/post-return.js
-    //
-    // We *should* be able to upgrade this to be more strict and throw at some point,
-    // which may involve rewriting the upstream test to surface task return manually somehow.
-    //
-    //throw new Error(`(component [${this.#componentIdx}]) task [${this.#id}] exited without resolution`);
-    _debugLog('[AsyncTask#exit()] task exited without resolution', {
-      componentIdx: this.#componentIdx,
-      taskID: this.#id,
-      subtask: this.getParentSubtask(),
-      subtaskID: this.getParentSubtask()?.id(),
-    });
-    this.#state = AsyncTask.State.RESOLVED;
-  }
-  
-  if (this.borrowedHandles > 0) {
-    throw new Error('task [${this.#id}] exited without clearing borrowed handles');
-  }
-  
-  const state = getOrCreateAsyncState(this.#componentIdx);
-  if (!state) { throw new Error('missing async state for component [' + this.#componentIdx + ']'); }
-  if (!this.#isAsync && !state.inSyncExportCall) {
-    throw new Error('sync task must be run from components known to be in a sync export call');
-  }
-  state.inSyncExportCall = false;
-  
-  if (this.needsExclusiveLock() && !state.isExclusivelyLocked()) {
-    throw new Error('task [' + this.#id + '] exit: component [' + this.#componentIdx + '] should have been exclusively locked');
+function rscTableRemove(table, handle) {
+  const scope = table[handle << 1];
+  const val = table[(handle << 1) + 1];
+  const own = (val & T_FLAG) !== 0;
+  const rep = val & ~T_FLAG;
+  if (val === 0 || (scope & T_FLAG) !== 0) {
+    throw new TypeError("Invalid handle");
   }
-  
-  state.exclusiveRelease();
+  table[handle << 1] = table[0] | T_FLAG;
+  table[0] = handle | T_FLAG;
+  return { rep, scope, own };
 }
 
-needsExclusiveLock() { return this.#needsExclusiveLock; }
+let curResourceBorrows = [];
 
-createSubtask(args) {
-  _debugLog('[AsyncTask#createSubtask()] args', args);
-  const { componentIdx, childTask, callMetadata } = args;
-  const newSubtask = new AsyncSubtask({
-    componentIdx,
-    childTask,
-    parentTask: this,
-    callMetadata,
-  });
-  this.#subtasks.push(newSubtask);
-  return newSubtask;
-}
-
-getLatestSubtask() { return this.#subtasks.at(-1); }
-
-currentSubtask() {
-  _debugLog('[AsyncTask#currentSubtask()]');
-  if (this.#subtasks.length === 0) { return undefined; }
-  return this.#subtasks.at(-1);
-}
-
-endCurrentSubtask() {
-  _debugLog('[AsyncTask#endCurrentSubtask()]');
-  if (this.#subtasks.length === 0) { throw new Error('cannot end current subtask: no current subtask'); }
-  const subtask = this.#subtasks.pop();
-  subtask.drop();
-  return subtask;
-}
-}
-
-function unpackCallbackResult(result) {
-  _debugLog('[unpackCallbackResult()] args', { result });
-  if (!(_typeCheckValidI32(result))) { throw new Error('invalid callback return value [' + result + '], not a valid i32'); }
-  const eventCode = result & 0xF;
-  if (eventCode < 0 || eventCode > 3) {
-    throw new Error('invalid async return value [' + eventCode + '], outside callback code range');
+function getCurrentTask(componentIdx) {
+  if (componentIdx === undefined || componentIdx === null) {
+    throw new Error('missing/invalid component instance index [' + componentIdx + '] while getting current task');
   }
-  if (result < 0 || result >= 2**32) { throw new Error('invalid callback result'); }
-  // TODO: table max length check?
-  const waitableSetRep = result >> 4;
-  return [eventCode, waitableSetRep];
+  const tasks = ASYNC_TASKS_BY_COMPONENT_IDX.get(componentIdx);
+  if (tasks === undefined) { return undefined; }
+  if (tasks.length === 0) { return undefined; }
+  return tasks[tasks.length - 1];
 }
 
-function _lowerImport(args, exportFn) {
-  const params = [...arguments].slice(2);
-  _debugLog('[_lowerImport()] args', { args, params, exportFn });
+function createNewCurrentTask(args) {
+  _debugLog('[createNewCurrentTask()] args', args);
   const {
-    functionIdx,
     componentIdx,
     isAsync,
-    paramLiftFns,
-    resultLowerFns,
-    metadata,
-    memoryIdx,
-    getMemoryFn,
-    getReallocFn,
+    entryFnName,
+    parentSubtaskID,
+    callbackFnName,
+    getCallbackFn,
+    getParamsFn,
+    stringEncoding,
+    errHandling,
+    getCalleeParamsFn,
+    resultPtr,
+    callingWasmExport,
   } = args;
+  if (componentIdx === undefined || componentIdx === null) {
+    throw new Error('missing/invalid component instance index while starting task');
+  }
+  const taskMetas = ASYNC_TASKS_BY_COMPONENT_IDX.get(componentIdx);
+  const callbackFn = getCallbackFn ? getCallbackFn() : null;
   
-  const parentTaskMeta = getCurrentTask(componentIdx);
-  const parentTask = parentTaskMeta?.task;
-  if (!parentTask) { throw new Error('missing parent task during lower of import'); }
-  
-  const cstate = getOrCreateAsyncState(componentIdx);
-  
-  const subtask = parentTask.createSubtask({
+  const newTask = new AsyncTask({
     componentIdx,
-    parentTask,
-    callMetadata: {
-      memoryIdx,
-      memory: getMemoryFn(),
-      realloc: getReallocFn(),
-      resultPtr: params[0],
-    }
+    isAsync,
+    entryFnName,
+    callbackFn,
+    callbackFnName,
+    stringEncoding,
+    getCalleeParamsFn,
+    resultPtr,
+    errHandling,
   });
-  parentTask.setReturnMemoryIdx(memoryIdx);
-  
-  const rep = cstate.subtasks.insert(subtask);
-  subtask.setRep(rep);
   
-  subtask.setOnProgressFn(() => {
-    subtask.setPendingEventFn(() => {
-      if (subtask.resolved()) { subtask.deliverResolve(); }
-      return {
-        code: ASYNC_EVENT_CODE.SUBTASK,
-        index: rep,
-        result: subtask.getStateNumber(),
-      }
-    });
-  });
+  const newTaskID = newTask.id();
+  const newTaskMeta = { id: newTaskID, componentIdx, task: newTask };
   
-  // Set up a handler on subtask completion to lower results from the call into the caller's memory region.
-  subtask.registerOnResolveHandler((res) => {
-    _debugLog('[_lowerImport()] handling subtask result', { res, subtaskID: subtask.id() });
-    const { memory, resultPtr, realloc } = subtask.getCallMetadata();
-    resultLowerFns[0]({ componentIdx, memory, realloc, vals: [res], storagePtr: resultPtr });
-  });
+  ASYNC_CURRENT_TASK_IDS.push(newTaskID);
+  ASYNC_CURRENT_COMPONENT_IDXS.push(componentIdx);
   
-  const subtaskState = subtask.getStateNumber();
-  if (subtaskState < 0 || subtaskState > 2**5) {
-    throw new Error('invalid subtask state, out of valid range');
+  if (!taskMetas) {
+    ASYNC_TASKS_BY_COMPONENT_IDX.set(componentIdx, [newTaskMeta]);
+  } else {
+    taskMetas.push(newTaskMeta);
   }
   
-  // NOTE: we must wait a bit before calling the export function,
-  // to ensure the subtask state is not modified before the lower call return
-  //
-  // TODO: we should trigger via subtask state changing, rather than a static wait?
-  setTimeout(async () => {
-    try {
-      _debugLog('[_lowerImport()] calling lowered import', { exportFn, params });
-      exportFn.apply(null, params);
-      
-      const task = subtask.getChildTask();
-      task.registerOnResolveHandler((res) => {
-        _debugLog('[_lowerImport()] cascading subtask completion', {
-          childTaskID: task.id(),
-          subtaskID: subtask.id(),
-          parentTaskID: parentTask.id(),
-        });
-        
-        subtask.onResolve(res);
-        
-        cstate.tick();
-      });
-    } catch (err) {
-      console.error("post-lower import fn error:", err);
-      throw err;
-    }
-  }, 100);
-  
-  return Number(subtask.waitableRep()) << 4 | subtaskState;
+  return [newTask, newTaskID];
 }
 
-function _liftFlatU8(ctx) {
-  _debugLog('[_liftFlatU8()] args', { ctx });
+function endCurrentTask(componentIdx, taskID) {
+  componentIdx ??= ASYNC_CURRENT_COMPONENT_IDXS.at(-1);
+  taskID ??= ASYNC_CURRENT_TASK_IDS.at(-1);
+  _debugLog('[endCurrentTask()] args', { componentIdx, taskID });
   
-  let val;
-  if (ctx.useDirectParams) {
-    if (ctx.params.length === 0) { throw new Error('expected at least a single i32 argument'); }
-    val = ctx.params[0];
-    ctx.params = ctx.params.slice(1);
-  } else {
-    if (ctx.storageLen < ctx.storagePtr + 1) { throw new Error('not enough storage remaining for lift'); }
-    val = new DataView(ctx.memory.buffer).getUint8(ctx.storagePtr);
-    ctx.storagePtr += 1;
-    ctx.storageLen -= 1;
+  if (componentIdx === undefined || componentIdx === null) {
+    throw new Error('missing/invalid component instance index while ending current task');
   }
   
-  return [val, ctx];
-}
-
-function _liftFlatU16(ctx) {
-  _debugLog('[_liftFlatU16()] args', { ctx });
+  const tasks = ASYNC_TASKS_BY_COMPONENT_IDX.get(componentIdx);
+  if (!tasks || !Array.isArray(tasks)) {
+    throw new Error('missing/invalid tasks for component instance while ending task');
+  }
+  if (tasks.length == 0) {
+    throw new Error('no current task(s) for component instance while ending task');
+  }
   
-  let val;
-  if (ctx.useDirectParams) {
-    if (params.length === 0) { throw new Error('expected at least a single i32 argument'); }
-    val = ctx.params[0];
-    ctx.params = ctx.params.slice(1);
-  } else {
-    if (ctx.storageLen < ctx.storagePtr + 2) { throw new Error('not enough storage remaining for lift'); }
-    val = new DataView(ctx.memory.buffer).getUint16(ctx.storagePtr);
-    ctx.storagePtr += 2;
-    ctx.storageLen -= 2;
+  if (taskID) {
+    const last = tasks[tasks.length - 1];
+    if (last.id !== taskID) {
+      // throw new Error('current task does not match expected task ID');
+      return;
+    }
   }
   
-  return [val, ctx];
+  ASYNC_CURRENT_TASK_IDS.pop();
+  ASYNC_CURRENT_COMPONENT_IDXS.pop();
+  
+  const taskMeta = tasks.pop();
+  return taskMeta.task;
 }
+const ASYNC_TASKS_BY_COMPONENT_IDX = new Map();
 
-function _liftFlatU32(ctx) {
-  _debugLog('[_liftFlatU32()] args', { ctx });
+class AsyncTask {
+  static _ID = 0n;
   
-  let val;
-  if (ctx.useDirectParams) {
-    if (ctx.params.length === 0) { throw new Error('expected at least a single i34 argument'); }
-    val = ctx.params[0];
-    ctx.params = ctx.params.slice(1);
-  } else {
-    if (ctx.storageLen < ctx.storagePtr + 4) { throw new Error('not enough storage remaining for lift'); }
-    val = new DataView(ctx.memory.buffer).getUint32(ctx.storagePtr);
-    ctx.storagePtr += 4;
-    ctx.storageLen -= 4;
+  static State = {
+    INITIAL: 'initial',
+    CANCELLED: 'cancelled',
+    CANCEL_PENDING: 'cancel-pending',
+    CANCEL_DELIVERED: 'cancel-delivered',
+    RESOLVED: 'resolved',
   }
   
-  return [val, ctx];
-}
-
-function _liftFlatU64(ctx) {
-  _debugLog('[_liftFlatU64()] args', { ctx });
-  
-  let val;
-  if (ctx.useDirectParams) {
-    if (ctx.params.length === 0) { throw new Error('expected at least one single i64 argument'); }
-    if (typeof ctx.params[0] !== 'bigint') { throw new Error('expected bigint'); }
-    val = ctx.params[0];
-    ctx.params = ctx.params.slice(1);
-  } else {
-    if (ctx.storageLen < ctx.storagePtr + 8) { throw new Error('not enough storage remaining for lift'); }
-    val = new DataView(ctx.memory.buffer).getUint64(ctx.storagePtr);
-    ctx.storagePtr += 8;
-    ctx.storageLen -= 8;
+  static BlockResult = {
+    CANCELLED: 'block.cancelled',
+    NOT_CANCELLED: 'block.not-cancelled',
   }
   
-  return [val, ctx];
-}
-
-function _liftFlatStringUTF8(ctx) {
-  _debugLog('[_liftFlatStringUTF8()] args', { ctx });
+  #id;
+  #componentIdx;
+  #state;
+  #isAsync;
+  #entryFnName = null;
+  #subtasks = [];
   
-  let val;
-  if (ctx.useDirectParams) {
-    if (ctx.params.length < 2) { throw new Error('expected at least two u32 arguments'); }
-    const offset = ctx.params[0];
-    if (!Number.isSafeInteger(offset)) {  throw new Error('invalid offset'); }
-    const len = ctx.params[1];
-    if (!Number.isSafeInteger(len)) {  throw new Error('invalid len'); }
-    val = TEXT_DECODER_UTF8.decode(new DataView(ctx.memory.buffer, offset, len));
-    ctx.params = ctx.params.slice(2);
-  } else {
-    const start = new DataView(ctx.memory.buffer).getUint32(ctx.storagePtr, params[0], true);
-    const codeUnits = new DataView(memory.buffer).getUint32(ctx.storagePtr, params[0] + 4, true);
-    val = TEXT_DECODER_UTF8.decode(new Uint8Array(ctx.memory.buffer, start, codeUnits));
-    ctx.storagePtr += codeUnits;
-    ctx.storageLen -= codeUnits;
-  }
+  #onResolveHandlers = [];
+  #completionPromise = null;
   
-  return [val, ctx];
-}
-
-function _liftFlatVariant(casesAndLiftFns) {
-  return function _liftFlatVariantInner(ctx) {
-    _debugLog('[_liftFlatVariant()] args', { ctx });
-    
-    const origUseParams = ctx.useDirectParams;
+  #memoryIdx = null;
+  
+  #callbackFn = null;
+  #callbackFnName = null;
+  
+  #postReturnFn = null;
+  
+  #getCalleeParamsFn = null;
+  
+  #stringEncoding = null;
+  
+  #parentSubtask = null;
+  
+  #needsExclusiveLock = false;
+  
+  #errHandling;
+  
+  #backpressurePromise;
+  #backpressureWaiters = 0n;
+  
+  #returnLowerFns = null;
+  
+  cancelled = false;
+  requested = false;
+  alwaysTaskReturn = false;
+  
+  returnCalls =  0;
+  storage = [0, 0];
+  borrowedHandles = {};
+  
+  awaitableResume = null;
+  awaitableCancel = null;
+  
+  constructor(opts) {
+    this.#id = ++AsyncTask._ID;
     
-    let caseIdx;
-    if (casesAndLiftFns.length < 256) {
-      let discriminantByteLen = 1;
-      const [idx, newCtx] = _liftFlatU8(ctx);
-      caseIdx = idx;
-      ctx = newCtx;
-    } else if (casesAndLiftFns.length > 256 && discriminantByteLen < 65536) {
-      discriminantByteLen = 2;
-      const [idx, newCtx] = _liftFlatU16(ctx);
-      caseIdx = idx;
-      ctx = newCtx;
-    } else if (casesAndLiftFns.length > 65536 && discriminantByteLen < 4_294_967_296) {
-      discriminantByteLen = 4;
-      const [idx, newCtx] = _liftFlatU32(ctx);
-      caseIdx = idx;
-      ctx = newCtx;
-    } else {
-      throw new Error('unsupported number of cases [' + casesAndLIftFns.legnth + ']');
+    if (opts?.componentIdx === undefined) {
+      throw new TypeError('missing component id during task creation');
     }
+    this.#componentIdx = opts.componentIdx;
     
-    const [ tag, liftFn, size32, alignment32 ] = casesAndLiftFns[caseIdx];
+    this.#state = AsyncTask.State.INITIAL;
+    this.#isAsync = opts?.isAsync ?? false;
+    this.#entryFnName = opts.entryFnName;
     
-    let val;
-    if (liftFn === null) {
-      val = { tag };
-      return [val, ctx];
-    }
+    const {
+      promise: completionPromise,
+      resolve: resolveCompletionPromise,
+      reject: rejectCompletionPromise,
+    } = promiseWithResolvers();
+    this.#completionPromise = completionPromise;
     
-    const [newVal, newCtx] = liftFn(ctx);
-    ctx = newCtx;
-    val = { tag, val: newVal };
+    this.#onResolveHandlers.push((results) => {
+      resolveCompletionPromise(results);
+    })
     
-    return [val, ctx];
+    if (opts.callbackFn) { this.#callbackFn = opts.callbackFn; }
+    if (opts.callbackFnName) { this.#callbackFnName = opts.callbackFnName; }
+    
+    if (opts.getCalleeParamsFn) { this.#getCalleeParamsFn = opts.getCalleeParamsFn; }
+    
+    if (opts.stringEncoding) { this.#stringEncoding = opts.stringEncoding; }
+    
+    if (opts.parentSubtask) { this.#parentSubtask = opts.parentSubtask; }
+    
+    this.#needsExclusiveLock = this.isSync() || !this.hasCallback();
+    
+    if (opts.errHandling) { this.#errHandling = opts.errHandling; }
   }
-}
-
-function _liftFlatList(elemLiftFn, alignment32, knownLen) {
-  function _liftFlatListInner(ctx) {
-    _debugLog('[_liftFlatList()] args', { ctx });
+  
+  taskState() { return this.#state; }
+  id() { return this.#id; }
+  componentIdx() { return this.#componentIdx; }
+  isAsync() { return this.#isAsync; }
+  entryFnName() { return this.#entryFnName; }
+  completionPromise() { return this.#completionPromise; }
+  
+  isAsync() { return this.#isAsync; }
+  isSync() { return !this.isAsync(); }
+  
+  getErrHandling() { return this.#errHandling; }
+  
+  hasCallback() { return this.#callbackFn !== null; }
+  
+  setReturnMemoryIdx(idx) { this.#memoryIdx = idx; }
+  getReturnMemoryIdx() { return this.#memoryIdx; }
+  
+  setReturnLowerFns(fns) { this.#returnLowerFns = fns; }
+  getReturnLowerFns() { return this.#returnLowerFns; }
+  
+  setParentSubtask(subtask) {
+    if (!subtask || !(subtask instanceof AsyncSubtask)) { return }
+    if (this.#parentSubtask) { throw new Error('parent subtask can only be set once'); }
+    this.#parentSubtask = subtask;
+  }
+  
+  getParentSubtask() { return this.#parentSubtask; }
+  
+  // TODO(threads): this is very inefficient, we can pass along a root task,
+  // and ideally do not need this once thread support is in place
+  getRootTask() {
+    let currentSubtask = this.getParentSubtask();
+    let task = this;
+    while (currentSubtask) {
+      task = currentSubtask.getParentTask();
+      currentSubtask = task.getParentSubtask();
+    }
+    return task;
+  }
+  
+  setPostReturnFn(f) {
+    if (!f) { return; }
+    if (this.#postReturnFn) { throw new Error('postReturn fn can only be set once'); }
+    this.#postReturnFn = f;
+  }
+  
+  setCallbackFn(f, name) {
+    if (!f) { return; }
+    if (this.#callbackFn) { throw new Error('callback fn can only be set once'); }
+    this.#callbackFn = f;
+    this.#callbackFnName = name;
+  }
+  
+  getCallbackFnName() {
+    if (!this.#callbackFnName) { return undefined; }
+    return this.#callbackFnName;
+  }
+  
+  runCallbackFn(...args) {
+    if (!this.#callbackFn) { throw new Error('on callback function has been set for task'); }
+    return this.#callbackFn.apply(null, args);
+  }
+  
+  getCalleeParams() {
+    if (!this.#getCalleeParamsFn) { throw new Error('missing/invalid getCalleeParamsFn'); }
+    return this.#getCalleeParamsFn();
+  }
+  
+  mayEnter(task) {
+    const cstate = getOrCreateAsyncState(this.#componentIdx);
+    if (cstate.hasBackpressure()) {
+      _debugLog('[AsyncTask#mayEnter()] disallowed due to backpressure', { taskID: this.#id });
+      return false;
+    }
+    if (!cstate.callingSyncImport()) {
+      _debugLog('[AsyncTask#mayEnter()] disallowed due to sync import call', { taskID: this.#id });
+      return false;
+    }
+    const callingSyncExportWithSyncPending = cstate.callingSyncExport && !task.isAsync;
+    if (!callingSyncExportWithSyncPending) {
+      _debugLog('[AsyncTask#mayEnter()] disallowed due to sync export w/ sync pending', { taskID: this.#id });
+      return false;
+    }
+    return true;
+  }
+  
+  async enter() {
+    _debugLog('[AsyncTask#enter()] args', { taskID: this.#id });
+    const cstate = getOrCreateAsyncState(this.#componentIdx);
     
-    let metaPtr;
-    let dataPtr;
-    let len;
-    if (ctx.useDirectParams) {
-      if (knownLen) {
-        dataPtr = _liftFlatU32(ctx);
-      } else {
-        metaPtr = _liftFlatU32(ctx);
+    if (this.isSync()) { return true; }
+    
+    if (cstate.hasBackpressure()) {
+      cstate.addBackpressureWaiter();
+      
+      const result = await this.waitUntil({
+        readyFn: () => !cstate.hasBackpressure(),
+        cancellable: true,
+      });
+      
+      cstate.removeBackpressureWaiter();
+      
+      if (result === AsyncTask.BlockResult.CANCELLED) {
+        this.cancel();
+        return false;
       }
+    }
+    
+    if (this.needsExclusiveLock()) { cstate.exclusiveLock(); }
+    
+    return true;
+  }
+  
+  isRunning() {
+    return this.#state !== AsyncTask.State.RESOLVED;
+  }
+  
+  async waitUntil(opts) {
+    const { readyFn, waitableSetRep, cancellable } = opts;
+    _debugLog('[AsyncTask#waitUntil()] args', { taskID: this.#id, waitableSetRep, cancellable });
+    
+    const state = getOrCreateAsyncState(this.#componentIdx);
+    const wset = state.waitableSets.get(waitableSetRep);
+    
+    let event;
+    
+    wset.incrementNumWaiting();
+    
+    const keepGoing = await this.suspendUntil({
+      readyFn: () => {
+        const hasPendingEvent = wset.hasPendingEvent();
+        return readyFn() && hasPendingEvent;
+      },
+      cancellable,
+    });
+    
+    if (keepGoing) {
+      event = wset.getPendingEvent();
     } else {
-      if (knownLen) {
-        dataPtr = _liftFlatU32(ctx);
-      } else {
-        metaPtr = _liftFlatU32(ctx);
-      }
+      event = {
+        code: ASYNC_EVENT_CODE.TASK_CANCELLED,
+        index: 0,
+        result: 0,
+      };
     }
     
-    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);
-      }
+    wset.decrementNumWaiting();
+    
+    return event;
+  }
+  
+  async onBlock(awaitable) {
+    _debugLog('[AsyncTask#onBlock()] args', { taskID: this.#id, awaitable });
+    if (!(awaitable instanceof Awaitable)) {
+      throw new Error('invalid awaitable during onBlock');
     }
     
-    const val = [];
-    for (var i = 0; i < len; i++) {
-      ctx.storagePtr = Math.ceil(ctx.storagePtr / alignment32) * alignment32;
-      const [res, nextCtx] = elemLiftFn(ctx);
-      val.push(res);
-      ctx = nextCtx;
+    // Build a promise that this task can await on which resolves when it is awoken
+    const { promise, resolve, reject } = promiseWithResolvers();
+    this.awaitableResume = () => {
+      _debugLog('[AsyncTask] resuming after onBlock', { taskID: this.#id });
+      resolve();
+    };
+    this.awaitableCancel = (err) => {
+      _debugLog('[AsyncTask] rejecting after onBlock', { taskID: this.#id, err });
+      reject(err);
+    };
+    
+    // Park this task/execution to be handled later
+    const state = getOrCreateAsyncState(this.#componentIdx);
+    state.parkTaskOnAwaitable({ awaitable, task: this });
+    
+    try {
+      await promise;
+      return AsyncTask.BlockResult.NOT_CANCELLED;
+    } catch (err) {
+      // rejection means task cancellation
+      return AsyncTask.BlockResult.CANCELLED;
+    }
+  }
+  
+  async asyncOnBlock(awaitable) {
+    _debugLog('[AsyncTask#asyncOnBlock()] args', { taskID: this.#id, awaitable });
+    if (!(awaitable instanceof Awaitable)) {
+      throw new Error('invalid awaitable during onBlock');
+    }
+    // TODO: watch for waitable AND cancellation
+    // TODO: if it WAS cancelled:
+    // - return true
+    // - only once per subtask
+    // - do not wait on the scheduler
+    // - control flow should go to the subtask (only once)
+    // - Once subtask blocks/resolves, reqlinquishControl() will tehn resolve request_cancel_end (without scheduler lock release)
+    // - control flow goes back to request_cancel
+    //
+    // Subtask cancellation should work similarly to an async import call -- runs sync up until
+    // the subtask blocks or resolves
+    //
+    throw new Error('AsyncTask#asyncOnBlock() not yet implemented');
+  }
+  
+  async yieldUntil(opts) {
+    const { readyFn, cancellable } = opts;
+    _debugLog('[AsyncTask#yieldUntil()] args', { taskID: this.#id, cancellable });
+    
+    const keepGoing = await this.suspendUntil({ readyFn, cancellable });
+    if (!keepGoing) {
+      return {
+        code: ASYNC_EVENT_CODE.TASK_CANCELLED,
+        index: 0,
+        result: 0,
+      };
     }
     
-    return [val, ctx];
+    return {
+      code: ASYNC_EVENT_CODE.NONE,
+      index: 0,
+      result: 0,
+    };
+  }
+  
+  async suspendUntil(opts) {
+    const { cancellable, readyFn } = opts;
+    _debugLog('[AsyncTask#suspendUntil()] args', { cancellable });
+    
+    const pendingCancelled = this.deliverPendingCancel({ cancellable });
+    if (pendingCancelled) { return false; }
+    
+    const completed = await this.immediateSuspendUntil({ readyFn, cancellable });
+    return completed;
+  }
+  
+  // TODO(threads): equivalent to thread.suspend_until()
+  async immediateSuspendUntil(opts) {
+    const { cancellable, readyFn } = opts;
+    _debugLog('[AsyncTask#immediateSuspendUntil()] args', { cancellable, readyFn });
+    
+    const ready = readyFn();
+    if (ready && !ASYNC_DETERMINISM && _coinFlip()) {
+      return true;
+    }
+    
+    const cstate = getOrCreateAsyncState(this.#componentIdx);
+    cstate.addPendingTask(this);
+    
+    const keepGoing = await this.immediateSuspend({ cancellable, readyFn });
+    return keepGoing;
+  }
+  
+  async immediateSuspend(opts) { // NOTE: equivalent to thread.suspend()
+  // TODO(threads): store readyFn on the thread
+  const { cancellable, readyFn } = opts;
+  _debugLog('[AsyncTask#immediateSuspend()] args', { cancellable, readyFn });
+  
+  const pendingCancelled = this.deliverPendingCancel({ cancellable });
+  if (pendingCancelled) { return false; }
+  
+  const cstate = getOrCreateAsyncState(this.#componentIdx);
+  
+  // TODO(fix): update this to tick until there is no more action to take.
+  setTimeout(() => cstate.tick(), 0);
+  
+  const taskWait = await cstate.suspendTask({ task: this, readyFn });
+  const keepGoing = await taskWait;
+  return keepGoing;
+}
+
+deliverPendingCancel(opts) {
+  const { cancellable } = opts;
+  _debugLog('[AsyncTask#deliverPendingCancel()] args', { cancellable });
+  
+  if (cancellable && this.#state === AsyncTask.State.PENDING_CANCEL) {
+    this.#state = Task.State.CANCEL_DELIVERED;
+    return true;
+  }
+  
+  return false;
+}
+
+isCancelled() { return this.cancelled }
+
+cancel() {
+  _debugLog('[AsyncTask#cancel()] args', { });
+  if (!this.taskState() !== AsyncTask.State.CANCEL_DELIVERED) {
+    throw new Error(`(component [${this.#componentIdx}]) task [${this.#id}] invalid task state for cancellation`);
+  }
+  if (this.borrowedHandles.length > 0) { throw new Error('task still has borrow handles'); }
+  this.cancelled = true;
+  this.onResolve(new Error('cancelled'));
+  this.#state = AsyncTask.State.RESOLVED;
+}
+
+onResolve(taskValue) {
+  for (const f of this.#onResolveHandlers) {
+    try {
+      f(taskValue);
+    } catch (err) {
+      console.error("error during task resolve handler", err);
+      throw err;
+    }
+  }
+  
+  if (this.#postReturnFn) {
+    _debugLog('[AsyncTask#onResolve()] running post return ', {
+      componentIdx: this.#componentIdx,
+      taskID: this.#id,
+    });
+    this.#postReturnFn();
   }
 }
 
-function _liftFlatFlags(cases) {
-  return function _liftFlatFlagsInner(ctx) {
-    _debugLog('[_liftFlatFlags()] args', { ctx });
-    throw new Error('flat lift for flags not yet implemented!');
-  }
+registerOnResolveHandler(f) {
+  this.#onResolveHandlers.push(f);
 }
 
-function _liftFlatResult(casesAndLiftFns) {
-  return function _liftFlatResultInner(ctx) {
-    _debugLog('[_liftFlatResult()] args', { ctx });
-    return _liftFlatVariant(casesAndLiftFns)(ctx);
+resolve(results) {
+  _debugLog('[AsyncTask#resolve()] args', {
+    results,
+    componentIdx: this.#componentIdx,
+    taskID: this.#id,
+  });
+  
+  if (this.#state === AsyncTask.State.RESOLVED) {
+    throw new Error(`(component [${this.#componentIdx}]) task [${this.#id}]  is already resolved (did you forget to wait for an import?)`);
   }
-}
-
-function _liftFlatOwn(componentTableIdx, size, memory, vals, storagePtr, storageLen) {
-  _debugLog('[_liftFlatOwn()] args', { size, memory, vals, storagePtr, storageLen });
-  throw new Error('flat lift for owned 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 (this.borrowedHandles.length > 0) { throw new Error('task still has borrow handles'); }
+  switch (results.length) {
+    case 0:
+    this.onResolve(undefined);
+    break;
+    case 1:
+    this.onResolve(results[0]);
+    break;
+    default:
+    throw new Error('unexpected number of results');
   }
-  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 1;
+  this.#state = AsyncTask.State.RESOLVED;
 }
 
-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)');
+exit() {
+  _debugLog('[AsyncTask#exit()] args', { });
+  
+  // TODO: ensure there is only one task at a time (scheduler.lock() functionality)
+  if (this.#state !== AsyncTask.State.RESOLVED) {
+    // TODO(fix): only fused, manually specified post returns seem to break this invariant,
+    // as the TaskReturn trampoline is not activated it seems.
+    //
+    // see: test/p3/ported/wasmtime/component-async/post-return.js
+    //
+    // We *should* be able to upgrade this to be more strict and throw at some point,
+    // which may involve rewriting the upstream test to surface task return manually somehow.
+    //
+    //throw new Error(`(component [${this.#componentIdx}]) task [${this.#id}] exited without resolution`);
+    _debugLog('[AsyncTask#exit()] task exited without resolution', {
+      componentIdx: this.#componentIdx,
+      taskID: this.#id,
+      subtask: this.getParentSubtask(),
+      subtaskID: this.getParentSubtask()?.id(),
+    });
+    this.#state = AsyncTask.State.RESOLVED;
   }
-  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(fix): fix misaligned writes properly
-  const rem = ctx.storagePtr % 4;
-  if (rem !== 0) { ctx.storagePtr += (4 - rem); }
+  if (this.borrowedHandles > 0) {
+    throw new Error('task [${this.#id}] exited without clearing borrowed handles');
+  }
   
-  new DataView(memory.buffer).setUint32(storagePtr, vals[0], true);
-  return 4;
+  const state = getOrCreateAsyncState(this.#componentIdx);
+  if (!state) { throw new Error('missing async state for component [' + this.#componentIdx + ']'); }
+  if (!this.#isAsync && !state.inSyncExportCall) {
+    throw new Error('sync task must be run from components known to be in a sync export call');
+  }
+  state.inSyncExportCall = false;
+  
+  if (this.needsExclusiveLock() && !state.isExclusivelyLocked()) {
+    throw new Error('task [' + this.#id + '] exit: component [' + this.#componentIdx + '] should have been exclusively locked');
+  }
+  
+  state.exclusiveRelease();
 }
 
-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;
+needsExclusiveLock() { return this.#needsExclusiveLock; }
+
+createSubtask(args) {
+  _debugLog('[AsyncTask#createSubtask()] args', args);
+  const { componentIdx, childTask, callMetadata } = args;
+  const newSubtask = new AsyncSubtask({
+    componentIdx,
+    childTask,
+    parentTask: this,
+    callMetadata,
+  });
+  this.#subtasks.push(newSubtask);
+  return newSubtask;
 }
 
-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;
-  }
+getLatestSubtask() { return this.#subtasks.at(-1); }
+
+currentSubtask() {
+  _debugLog('[AsyncTask#currentSubtask()]');
+  if (this.#subtasks.length === 0) { return undefined; }
+  return this.#subtasks.at(-1);
 }
 
-function _lowerFlatVariant(metadata, extra) {
-  const { discriminantSizeBytes, lowerMetas } = metadata;
+endCurrentSubtask() {
+  _debugLog('[AsyncTask#endCurrentSubtask()]');
+  if (this.#subtasks.length === 0) { throw new Error('cannot end current subtask: no current subtask'); }
+  const subtask = this.#subtasks.pop();
+  subtask.drop();
+  return subtask;
+}
+}
+
+function _lowerImport(args, exportFn) {
+  const params = [...arguments].slice(2);
+  _debugLog('[_lowerImport()] args', { args, params, exportFn });
+  const {
+    functionIdx,
+    componentIdx,
+    isAsync,
+    paramLiftFns,
+    resultLowerFns,
+    metadata,
+    memoryIdx,
+    getMemoryFn,
+    getReallocFn,
+  } = args;
   
-  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 variant = lowerMetas.find(vm => vm.tag === tag);
-    if (!variant) { throw new Error(`missing/invalid variant, no tag matches [${tag}] (options were ${variantMetas.map(vm => vm.tag)})`); }
-    if (!variant.discriminant) { throw new Error(`missing/invalid discriminant for variant [${variant}]`); }
-    
-    let bytesWritten;
-    let discriminantLowerArgs = { memory, realloc, vals: [variant.discriminant], storagePtr, componentIdx }
-    switch (discriminantSizeBytes) {
-      case 1:
-      bytesWritten = _lowerFlatU8(discriminantLowerArgs);
-      break;
-      case 2:
-      bytesWritten = _lowerFlatU16(discriminantLowerArgs);
-      break;
-      case 4:
-      bytesWritten = _lowerFlatU32(discriminantLowerArgs);
-      break;
-      default:
-      throw new Error(`unexpected discriminant size bytes [${discriminantSizeBytes}]`);
+  const parentTaskMeta = getCurrentTask(componentIdx);
+  const parentTask = parentTaskMeta?.task;
+  if (!parentTask) { throw new Error('missing parent task during lower of import'); }
+  
+  const cstate = getOrCreateAsyncState(componentIdx);
+  
+  const subtask = parentTask.createSubtask({
+    componentIdx,
+    parentTask,
+    callMetadata: {
+      memoryIdx,
+      memory: getMemoryFn(),
+      realloc: getReallocFn(),
+      resultPtr: params[0],
     }
-    if (bytesWritten !== discriminantSizeBytes) {
-      throw new Error("unexpectedly wrote more bytes than discriminant");
+  });
+  parentTask.setReturnMemoryIdx(memoryIdx);
+  
+  const rep = cstate.subtasks.insert(subtask);
+  subtask.setRep(rep);
+  
+  subtask.setOnProgressFn(() => {
+    subtask.setPendingEventFn(() => {
+      if (subtask.resolved()) { subtask.deliverResolve(); }
+      return {
+        code: ASYNC_EVENT_CODE.SUBTASK,
+        index: rep,
+        result: subtask.getStateNumber(),
+      }
+    });
+  });
+  
+  // Set up a handler on subtask completion to lower results from the call into the caller's memory region.
+  subtask.registerOnResolveHandler((res) => {
+    _debugLog('[_lowerImport()] handling subtask result', { res, subtaskID: subtask.id() });
+    const { memory, resultPtr, realloc } = subtask.getCallMetadata();
+    if (resultLowerFns.length === 0) { return; }
+    resultLowerFns[0]({ componentIdx, memory, realloc, vals: [res], storagePtr: resultPtr });
+  });
+  
+  const subtaskState = subtask.getStateNumber();
+  if (subtaskState < 0 || subtaskState > 2**5) {
+    throw new Error('invalid subtask state, out of valid range');
+  }
+  
+  // NOTE: we must wait a bit before calling the export function,
+  // to ensure the subtask state is not modified before the lower call return
+  //
+  // TODO: we should trigger via subtask state changing, rather than a static wait?
+  setTimeout(async () => {
+    try {
+      _debugLog('[_lowerImport()] calling lowered import', { exportFn, params });
+      exportFn.apply(null, params);
+      
+      const task = subtask.getChildTask();
+      task.registerOnResolveHandler((res) => {
+        _debugLog('[_lowerImport()] cascading subtask completion', {
+          childTaskID: task.id(),
+          subtaskID: subtask.id(),
+          parentTaskID: parentTask.id(),
+        });
+        
+        subtask.onResolve(res);
+        
+        cstate.tick();
+      });
+    } catch (err) {
+      console.error("post-lower import fn error:", err);
+      throw err;
     }
-    storagePtr += bytesWritten;
-    
-    bytesWritten += variant.lowerFn({ memory, realloc, vals: [val], storagePtr, storageLen, componentIdx });
-    
-    return bytesWritten;
-  }
+  }, 100);
+  
+  return Number(subtask.waitableRep()) << 4 | subtaskState;
 }
 
-function _lowerFlatList(size, memory, vals, storagePtr, storageLen) {
-  _debugLog('[_lowerFlatList()] args', { size, memory, vals, storagePtr, storageLen });
-  let [start, len] = vals;
-  const totalSizeBytes = len * size;
-  if (storageLen !== undefined && totalSizeBytes > storageLen) {
-    throw new Error('not enough storage remaining for list flat lower');
+function _liftFlatU8(ctx) {
+  _debugLog('[_liftFlatU8()] args', { ctx });
+  let val;
+  
+  if (ctx.useDirectParams) {
+    if (ctx.params.length === 0) { throw new Error('expected at least a single i32 argument'); }
+    val = ctx.params[0];
+    ctx.params = ctx.params.slice(1);
+    return [val, ctx];
   }
-  const data = new Uint8Array(memory.buffer, start, totalSizeBytes);
-  new Uint8Array(memory.buffer, storagePtr, totalSizeBytes).set(data);
-  return data.byteLength;
-}
-
-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');
+  
+  if (ctx.storageLen !== undefined && ctx.storageLen < ctx.storagePtr + 1) {
+    throw new Error('not enough storage remaining for lift');
   }
-  const data = new Uint8Array(memory.buffer, start, size);
-  new Uint8Array(memory.buffer, storagePtr, size).set(data);
-  return data.byteLength;
+  val = new DataView(ctx.memory.buffer).getUint8(ctx.storagePtr, true);
+  ctx.storagePtr += 1;
+  if (ctx.storageLen !== undefined) { ctx.storageLen -= 1; }
+  
+  return [val, ctx];
 }
 
-function _lowerFlatOption(size, memory, vals, storagePtr, storageLen) {
-  _debugLog('[_lowerFlatOption()] args', { size, memory, vals, storagePtr, storageLen });
-  let [start] = vals;
-  if (storageLen !== undefined && size !== undefined && size > storageLen) {
-    throw new Error('not enough storage remaining for option flat lower');
+function _liftFlatU16(ctx) {
+  _debugLog('[_liftFlatU16()] args', { ctx });
+  let val;
+  
+  if (ctx.useDirectParams) {
+    if (params.length === 0) { throw new Error('expected at least a single i32 argument'); }
+    val = ctx.params[0];
+    ctx.params = ctx.params.slice(1);
+    return [val, ctx];
   }
-  const data = new Uint8Array(memory.buffer, start, size);
-  new Uint8Array(memory.buffer, storagePtr, size).set(data);
-  return data.byteLength;
-}
-
-function _lowerFlatResult(lowerMetas) {
-  const invalidTag = lowerMetas.find(t => t.tag !== 'ok' && t.tag !== 'error')
-  if (invalidTag) { throw new Error(`invalid variant tag [${invalidTag}] found for result`); }
   
-  return function _lowerFlatResultInner() {
-    _debugLog('[_lowerFlatResult()] args', { lowerMetas });
-    let lowerFn = _lowerFlatVariant({ discriminantSizeBytes: 1, lowerMetas }, { forResult: true });
-    return lowerFn.apply(null, arguments);
-  };
-}
-
-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 ASYNC_STATE = new Map();
-
-function getOrCreateAsyncState(componentIdx, init) {
-  if (!ASYNC_STATE.has(componentIdx)) {
-    const newState = new ComponentAsyncState({ componentIdx });
-    ASYNC_STATE.set(componentIdx, newState);
+  if (ctx.storageLen !== undefined && ctx.storageLen < ctx.storagePtr + 2) {
+    throw new Error('not enough storage remaining for lift');
   }
-  return ASYNC_STATE.get(componentIdx);
+  val = new DataView(ctx.memory.buffer).getUint16(ctx.storagePtr, true);
+  ctx.storagePtr += 2;
+  if (ctx.storageLen !== undefined) { ctx.storageLen -= 2; }
+  
+  return [val, ctx];
 }
 
-class ComponentAsyncState {
-  static EVENT_HANDLER_EVENTS = [ 'backpressure-change' ];
-  
-  #componentIdx;
-  #callingAsyncImport = false;
-  #syncImportWait = promiseWithResolvers();
-  #locked = false;
-  #parkedTasks = new Map();
-  #suspendedTasksByTaskID = new Map();
-  #suspendedTaskIDs = [];
-  #pendingTasks = [];
-  #errored = null;
-  
-  #backpressure = 0;
-  #backpressureWaiters = 0n;
-  
-  #handlerMap = new Map();
-  #nextHandlerID = 0n;
-  
-  mayLeave = true;
-  
-  waitableSets;
-  waitables;
-  subtasks;
-  
-  constructor(args) {
-    this.#componentIdx = args.componentIdx;
-    this.waitableSets = new RepTable({ target: `component [${this.#componentIdx}] waitable sets` });
-    this.waitables = new RepTable({ target: `component [${this.#componentIdx}] waitables` });
-    this.subtasks = new RepTable({ target: `component [${this.#componentIdx}] subtasks` });
-  };
-  
-  componentIdx() { return this.#componentIdx; }
+function _liftFlatU32(ctx) {
+  _debugLog('[_liftFlatU32()] args', { ctx });
+  let val;
   
-  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;
+  if (ctx.useDirectParams) {
+    if (ctx.params.length === 0) { throw new Error('expected at least a single i34 argument'); }
+    val = ctx.params[0];
+    ctx.params = ctx.params.slice(1);
+    return [val, 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();
-    }
+  if (ctx.storageLen !== undefined && ctx.storageLen < ctx.storagePtr + 4) {
+    throw new Error('not enough storage remaining for lift');
   }
+  val = new DataView(ctx.memory.buffer).getUint32(ctx.storagePtr, true);
+  ctx.storagePtr += 4;
+  if (ctx.storageLen !== undefined) { ctx.storageLen -= 4; }
   
-  #notifySyncImportEnd() {
-    const existing = this.#syncImportWait;
-    this.#syncImportWait = promiseWithResolvers();
-    existing.resolve();
-  }
+  return [val, ctx];
+}
+
+function _liftFlatU64(ctx) {
+  _debugLog('[_liftFlatU64()] args', { ctx });
+  let val;
   
-  async waitForSyncImportCallEnd() {
-    await this.#syncImportWait.promise;
+  if (ctx.useDirectParams) {
+    if (ctx.params.length === 0) { throw new Error('expected at least one single i64 argument'); }
+    if (typeof ctx.params[0] !== 'bigint') { throw new Error('expected bigint'); }
+    val = ctx.params[0];
+    ctx.params = ctx.params.slice(1);
+    return [val, ctx];
   }
   
-  setBackpressure(v) { this.#backpressure = v; }
-  getBackpressure(v) { return this.#backpressure; }
-  incrementBackpressure() {
-    const newValue = this.getBackpressure() + 1;
-    if (newValue > 2**16) { throw new Error("invalid backpressure value, overflow"); }
-    this.setBackpressure(newValue);
-  }
-  decrementBackpressure() {
-    this.setBackpressure(Math.max(0, this.getBackpressure() - 1));
+  if (ctx.storageLen !== undefined && ctx.storageLen < ctx.storagePtr + 8) {
+    throw new Error('not enough storage remaining for lift');
   }
-  hasBackpressure() { return this.#backpressure > 0; }
+  val = new DataView(ctx.memory.buffer).getUint64(ctx.storagePtr, true);
+  ctx.storagePtr += 8;
+  if (ctx.storageLen !== undefined) { ctx.storageLen -= 8; }
   
-  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);
-    });
-  }
+  return [val, ctx];
+}
+
+function _liftFlatStringUTF8(ctx) {
+  _debugLog('[_liftFlatStringUTF8()] args', { ctx });
+  let val;
   
-  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 handlerID = this.#nextHandlerID++;
-    let handlers = this.#handlerMap.get(event);
-    if (!handlers) {
-      handlers = [];
-      this.#handlerMap.set(event, handlers)
-    }
-    
-    handlers.push({ id: handlerID, fn, event });
-    return handlerID;
+  if (ctx.useDirectParams) {
+    if (ctx.params.length < 2) { throw new Error('expected at least two u32 arguments'); }
+    const offset = ctx.params[0];
+    if (!Number.isSafeInteger(offset)) {  throw new Error('invalid offset'); }
+    const len = ctx.params[1];
+    if (!Number.isSafeInteger(len)) {  throw new Error('invalid len'); }
+    val = TEXT_DECODER_UTF8.decode(new DataView(ctx.memory.buffer, offset, len));
+    ctx.params = ctx.params.slice(2);
+    return [val, ctx];
   }
   
-  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));
-  }
+  const start = new DataView(ctx.memory.buffer).getUint32(ctx.storagePtr, params[0], true);
+  const codeUnits = new DataView(memory.buffer).getUint32(ctx.storagePtr, params[0] + 4, true);
+  val = TEXT_DECODER_UTF8.decode(new Uint8Array(ctx.memory.buffer, start, codeUnits));
+  ctx.storagePtr += codeUnits;
+  if (ctx.storageLen !== undefined) { ctx.storageLen -= codeUnits; }
   
-  getBackpressureWaiters() { return this.#backpressureWaiters; }
-  addBackpressureWaiter() { this.#backpressureWaiters++; }
-  removeBackpressureWaiter() {
-    this.#backpressureWaiters--;
-    if (this.#backpressureWaiters < 0) {
-      throw new Error("unexepctedly negative number of backpressure waiters");
+  return [val, ctx];
+}
+
+function _liftFlatVariant(casesAndLiftFns) {
+  return function _liftFlatVariantInner(ctx) {
+    _debugLog('[_liftFlatVariant()] args', { ctx });
+    
+    const origUseParams = ctx.useDirectParams;
+    
+    let caseIdx;
+    if (casesAndLiftFns.length < 256) {
+      let discriminantByteLen = 1;
+      const [idx, newCtx] = _liftFlatU8(ctx);
+      caseIdx = idx;
+      ctx = newCtx;
+    } else if (casesAndLiftFns.length > 256 && discriminantByteLen < 65536) {
+      discriminantByteLen = 2;
+      const [idx, newCtx] = _liftFlatU16(ctx);
+      caseIdx = idx;
+      ctx = newCtx;
+    } else if (casesAndLiftFns.length > 65536 && discriminantByteLen < 4_294_967_296) {
+      discriminantByteLen = 4;
+      const [idx, newCtx] = _liftFlatU32(ctx);
+      caseIdx = idx;
+      ctx = newCtx;
+    } else {
+      throw new Error('unsupported number of cases [' + casesAndLIftFns.legnth + ']');
     }
-  }
-  
-  parkTaskOnAwaitable(args) {
-    if (!args.awaitable) { throw new TypeError('missing awaitable when trying to park'); }
-    if (!args.task) { throw new TypeError('missing task when trying to park'); }
-    const { awaitable, task } = args;
     
-    let taskList = this.#parkedTasks.get(awaitable.id());
-    if (!taskList) {
-      taskList = [];
-      this.#parkedTasks.set(awaitable.id(), taskList);
+    const [ tag, liftFn, size32, alignment32 ] = casesAndLiftFns[caseIdx];
+    
+    let val;
+    if (liftFn === null) {
+      val = { tag };
+      return [val, ctx];
     }
-    taskList.push(task);
     
-    this.wakeNextTaskForAwaitable(awaitable);
+    const [newVal, newCtx] = liftFn(ctx);
+    ctx = newCtx;
+    val = { tag, val: newVal };
+    
+    return [val, ctx];
   }
-  
-  wakeNextTaskForAwaitable(awaitable) {
-    if (!awaitable) { throw new TypeError('missing awaitable when waking next task'); }
-    const awaitableID = awaitable.id();
+}
+
+function _liftFlatList(elemLiftFn, alignment32, knownLen) {
+  function _liftFlatListInner(ctx) {
+    _debugLog('[_liftFlatList()] args', { ctx });
     
-    const taskList = this.#parkedTasks.get(awaitableID);
-    if (!taskList || taskList.length === 0) {
-      _debugLog('[ComponentAsyncState] no tasks waiting for awaitable', { awaitableID: awaitable.id() });
-      return;
+    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);
+      }
     }
     
-    let task = taskList.shift(); // todo(perf)
-    if (!task) { throw new Error('no task in parked list despite previous check'); }
+    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);
+      }
+    }
     
-    if (!task.awaitableResume) {
-      throw new Error('task ready due to awaitable is missing resume', { taskID: task.id(), awaitableID });
+    const val = [];
+    for (var i = 0; i < len; i++) {
+      ctx.storagePtr = Math.ceil(ctx.storagePtr / alignment32) * alignment32;
+      const [res, nextCtx] = elemLiftFn(ctx);
+      val.push(res);
+      ctx = nextCtx;
     }
-    task.awaitableResume();
+    
+    return [val, ctx];
   }
-  
-  // TODO: we might want to check for pre-locked status here
-  exclusiveLock() {
-    this.#locked = true;
+}
+
+function _liftFlatFlags(cases) {
+  return function _liftFlatFlagsInner(ctx) {
+    _debugLog('[_liftFlatFlags()] args', { ctx });
+    throw new Error('flat lift for flags not yet implemented!');
   }
-  
-  exclusiveRelease() {
-    _debugLog('[ComponentAsyncState#exclusiveRelease()] releasing', {
-      locked: this.#locked,
-      componentIdx: this.#componentIdx,
-    });
-    
-    this.#locked = false
+}
+
+function _liftFlatResult(casesAndLiftFns) {
+  return function _liftFlatResultInner(ctx) {
+    _debugLog('[_liftFlatResult()] args', { ctx });
+    return _liftFlatVariant(casesAndLiftFns)(ctx);
   }
-  
-  isExclusivelyLocked() { return this.#locked === true; }
-  
-  #getSuspendedTaskMeta(taskID) {
-    return this.#suspendedTasksByTaskID.get(taskID);
+}
+
+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)');
   }
-  
-  #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 (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 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'); }
   
-  #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(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 _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;
   }
+}
+
+function _lowerFlatVariant(metadata, extra) {
+  const { discriminantSizeBytes, lowerMetas } = metadata;
   
-  suspendTask(args) {
-    // TODO(threads): readyFn is normally on the thread
-    const { task, readyFn } = args;
-    const taskID = task.id();
-    _debugLog('[ComponentAsyncState#suspendTask()]', { taskID });
+  return function _lowerFlatVariantInner(ctx) {
+    _debugLog('[_lowerFlatVariant()] args', ctx);
+    const { memory, realloc, vals, storageLen, componentIdx } = ctx;
+    let storagePtr = ctx.storagePtr;
     
-    if (this.#getSuspendedTaskMeta(taskID)) {
-      throw new Error('task [' + taskID + '] already suspended');
+    const { tag, val } = vals[0];
+    const variant = lowerMetas.find(vm => vm.tag === tag);
+    if (!variant) { throw new Error(`missing/invalid variant, no tag matches [${tag}] (options were ${variantMetas.map(vm => vm.tag)})`); }
+    if (!variant.discriminant) { throw new Error(`missing/invalid discriminant for variant [${variant}]`); }
+    
+    let bytesWritten;
+    let discriminantLowerArgs = { memory, realloc, vals: [variant.discriminant], storagePtr, componentIdx }
+    switch (discriminantSizeBytes) {
+      case 1:
+      bytesWritten = _lowerFlatU8(discriminantLowerArgs);
+      break;
+      case 2:
+      bytesWritten = _lowerFlatU16(discriminantLowerArgs);
+      break;
+      case 4:
+      bytesWritten = _lowerFlatU32(discriminantLowerArgs);
+      break;
+      default:
+      throw new Error(`unexpected discriminant size bytes [${discriminantSizeBytes}]`);
+    }
+    if (bytesWritten !== discriminantSizeBytes) {
+      throw new Error("unexpectedly wrote more bytes than discriminant");
     }
+    storagePtr += bytesWritten;
     
-    const { promise, resolve } = Promise.withResolvers();
-    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());
-      },
-    });
+    bytesWritten += variant.lowerFn({ memory, realloc, vals: [val], storagePtr, storageLen, componentIdx });
     
-    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();
+    return bytesWritten;
   }
+}
+
+function _lowerFlatList(args) {
+  const { elemLowerFn } = args;
+  if (!elemLowerFn) { throw new TypeError("missing/invalid element lower fn for list"); }
   
-  tick() {
-    _debugLog('[ComponentAsyncState#tick()]', { suspendedTaskIDs: this.#suspendedTaskIDs });
-    let resumedTask = false;
-    for (const taskID of this.#suspendedTaskIDs.filter(t => t !== null)) {
-      const meta = this.#suspendedTasksByTaskID.get(taskID);
-      if (!meta || !meta.readyFn) {
-        throw new Error('missing/invalid task despite ID [' + taskID + '] being present');
+  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);
       }
-      if (!meta.readyFn()) { continue; }
-      resumedTask = true;
-      this.resumeTaskByID(taskID);
+      
+      const bytesLowered = elemLowerCtx.storagePtr - ctx.storagePtr;
+      ctx.storagePtr = elemLowerCtx.storagePtr;
+      return bytesLowered;
     }
-    return resumedTask;
-  }
-  
-  addPendingTask(task) {
-    this.#pendingTasks.push(task);
+    
+    
+    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;
   }
 }
 
-function _prepareCall(
-memoryIdx,
-getMemoryFn,
-startFn,
-returnFn,
-callerInstanceIdx,
-calleeInstanceIdx,
-taskReturnTypeIdx,
-isCalleeAsyncInt,
-stringEncoding,
-resultCountOrAsync,
-) {
-  _debugLog('[_prepareCall()]', {
-    callerInstanceIdx,
-    calleeInstanceIdx,
-    taskReturnTypeIdx,
-    isCalleeAsyncInt,
-    stringEncoding,
-    resultCountOrAsync,
-  });
-  const argArray = [...arguments];
-  
-  // Since Rust will happily pass large u32s over, resultCountOrAsync should be one of:
-  // (a) u32 max size     => callee is async fn with no result
-  // (b) u32 max size - 1 => callee is async fn with result
-  // (c) any other value  => callee is sync with the given result count
-  //
-  // Due to JS handling the value as 2s complement, the `resultCountOrAsync` ends up being:
-  // (a) -1 as u32 max size
-  // (b) -2 as u32 max size - 1
-  // (c) x
-  //
-  // Due to JS mishandling the value as 2s complement, the actual values we get are:
-  // see. https://github.com/wasm-bindgen/wasm-bindgen/issues/1388
-  let isAsync = false;
-  let hasResultPointer = false;
-  if (resultCountOrAsync === -1) {
-    isAsync = true;
-    hasResultPointer = false;
-  } else if (resultCountOrAsync === -2) {
-    isAsync = true;
-    hasResultPointer = true;
+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 currentCallerTaskMeta = getCurrentTask(callerInstanceIdx);
-  if (!currentCallerTaskMeta) {
-    throw new Error('invalid/missing current task for caller during prepare call');
+  const data = new Uint8Array(memory.buffer, start, len);
+  new Uint8Array(memory.buffer, storagePtr, len).set(data);
+  return data.byteLength;
+}
+
+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 currentCallerTask = currentCallerTaskMeta.task;
-  if (!currentCallerTask) {
-    throw new Error('unexpectedly missing task in meta for caller during prepare call');
+  const data = new Uint8Array(memory.buffer, start, size);
+  new Uint8Array(memory.buffer, storagePtr, size).set(data);
+  return data.byteLength;
+}
+
+function _lowerFlatOption(size, memory, vals, storagePtr, storageLen) {
+  _debugLog('[_lowerFlatOption()] args', { size, memory, vals, storagePtr, storageLen });
+  let [start] = vals;
+  if (storageLen !== undefined && size !== undefined && size > storageLen) {
+    throw new Error('not enough storage remaining for option flat lower');
   }
+  const data = new Uint8Array(memory.buffer, start, size);
+  new Uint8Array(memory.buffer, storagePtr, size).set(data);
+  return data.byteLength;
+}
+
+function _lowerFlatResult(lowerMetas) {
+  const invalidTag = lowerMetas.find(t => t.tag !== 'ok' && t.tag !== 'error')
+  if (invalidTag) { throw new Error(`invalid variant tag [${invalidTag}] found for result`); }
   
-  if (currentCallerTask.componentIdx() !== callerInstanceIdx) {
-    throw new Error(`task component idx [${ currentCallerTask.componentIdx() }] !== [${ callerInstanceIdx }] (callee ${ calleeInstanceIdx })`);
+  return function _lowerFlatResultInner() {
+    _debugLog('[_lowerFlatResult()] args', { lowerMetas });
+    let lowerFn = _lowerFlatVariant({ discriminantSizeBytes: 1, lowerMetas }, { forResult: true });
+    return lowerFn.apply(null, arguments);
+  };
+}
+
+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 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' ];
   
-  let getCalleeParamsFn;
-  let resultPtr = null;
-  if (hasResultPointer) {
-    const directParamsArr = argArray.slice(11);
-    getCalleeParamsFn = () => directParamsArr;
-    resultPtr = argArray[10];
-  } else {
-    const directParamsArr = argArray.slice(10);
-    getCalleeParamsFn = () => directParamsArr;
-  }
+  #componentIdx;
+  #callingAsyncImport = false;
+  #syncImportWait = promiseWithResolvers();
+  #locked = false;
+  #parkedTasks = new Map();
+  #suspendedTasksByTaskID = new Map();
+  #suspendedTaskIDs = [];
+  #pendingTasks = [];
+  #errored = null;
   
-  let encoding;
-  switch (stringEncoding) {
-    case 0:
-    encoding = 'utf8';
-    break;
-    case 1:
-    encoding = 'utf16';
-    break;
-    case 2:
-    encoding = 'compact-utf16';
-    break;
-    default:
-    throw new Error(`unrecognized string encoding enum [${stringEncoding}]`);
-  }
+  #backpressure = 0;
+  #backpressureWaiters = 0n;
   
-  const [newTask, newTaskID] = createNewCurrentTask({
-    componentIdx: calleeInstanceIdx,
-    isAsync: isCalleeAsyncInt !== 0,
-    getCalleeParamsFn,
-    // TODO: find a way to pass the import name through here
-    entryFnName: 'task/' + currentCallerTask.id() + '/new-prepare-task',
-    stringEncoding,
-  });
+  #handlerMap = new Map();
+  #nextHandlerID = 0n;
   
-  const subtask = currentCallerTask.createSubtask({
-    componentIdx: callerInstanceIdx,
-    parentTask: currentCallerTask,
-    childTask: newTask,
-    callMetadata: {
-      memory: getMemoryFn(),
-      memoryIdx,
-      resultPtr,
-      returnFn,
-      startFn,
-    }
-  });
+  mayLeave = true;
   
-  newTask.setParentSubtask(subtask);
-  // NOTE: This isn't really a return memory idx for the caller, it's for checking
-  // against the task.return (which will be called from the callee)
-  newTask.setReturnMemoryIdx(memoryIdx);
-}
-
-function _asyncStartCall(args, callee, paramCount, resultCount, flags) {
-  const { getCallbackFn, callbackIdx, getPostReturnFn, postReturnIdx } = args;
-  _debugLog('[_asyncStartCall()] args', args);
+  #streams;
   
-  const taskMeta = getCurrentTask(ASYNC_CURRENT_COMPONENT_IDXS.at(-1), ASYNC_CURRENT_TASK_IDS.at(-1));
-  if (!taskMeta) { throw new Error('invalid/missing current async task meta during prepare call'); }
+  waitableSets;
+  waitables;
+  subtasks;
   
-  const argArray = [...arguments];
+  constructor(args) {
+    this.#componentIdx = args.componentIdx;
+    this.waitableSets = new RepTable({ target: `component [${this.#componentIdx}] waitable sets` });
+    this.waitables = new RepTable({ target: `component [${this.#componentIdx}] waitables` });
+    this.subtasks = new RepTable({ target: `component [${this.#componentIdx}] subtasks` });
+    this.#streams = new Map();
+  };
   
-  // NOTE: at this point we know the current task is the one that was started
-  // in PrepareCall, so we *should* be able to pop it back off and be left with
-  // the previous task
-  const preparedTask = taskMeta.task;
-  if (!preparedTask) { throw new Error('unexpectedly missing task in task meta during prepare call'); }
+  componentIdx() { return this.#componentIdx; }
+  streams() { return this.#streams; }
   
-  if (resultCount < 0 || resultCount > 1) { throw new Error('invalid/unsupported result count'); }
+  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;
+  }
   
-  const callbackFnName = 'callback_' + callbackIdx;
-  const callbackFn = getCallbackFn();
-  preparedTask.setCallbackFn(callbackFn, callbackFnName);
-  preparedTask.setPostReturnFn(getPostReturnFn());
+  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();
+    }
+  }
   
-  const subtask = preparedTask.getParentSubtask();
+  #notifySyncImportEnd() {
+    const existing = this.#syncImportWait;
+    this.#syncImportWait = promiseWithResolvers();
+    existing.resolve();
+  }
   
-  if (resultCount < 0 || resultCount > 1) { throw new Error(`unsupported result count [${ resultCount }]`); }
+  async waitForSyncImportCallEnd() {
+    await this.#syncImportWait.promise;
+  }
   
-  const params = preparedTask.getCalleeParams();
-  if (paramCount !== params.length) {
-    throw new Error(`unexpected callee param count [${ params.length }], _asyncStartCall invocation expected [${ paramCount }]`);
+  setBackpressure(v) { this.#backpressure = v; }
+  getBackpressure(v) { return this.#backpressure; }
+  incrementBackpressure() {
+    const newValue = this.getBackpressure() + 1;
+    if (newValue > 2**16) { throw new Error("invalid backpressure value, overflow"); }
+    this.setBackpressure(newValue);
   }
+  decrementBackpressure() {
+    this.setBackpressure(Math.max(0, this.getBackpressure() - 1));
+  }
+  hasBackpressure() { return this.#backpressure > 0; }
   
-  subtask.setOnProgressFn(() => {
-    subtask.setPendingEventFn(() => {
-      if (subtask.resolved()) { subtask.deliverResolve(); }
-      return {
-        code: ASYNC_EVENT_CODE.SUBTASK,
-        index: rep,
-        result: subtask.getStateNumber(),
+  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);
+    });
+  }
   
-  const subtaskState = subtask.getStateNumber();
-  if (subtaskState < 0 || subtaskState > 2**5) {
-    throw new Error('invalid subtask state, out of valid range');
+  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 handlerID = this.#nextHandlerID++;
+    let handlers = this.#handlerMap.get(event);
+    if (!handlers) {
+      handlers = [];
+      this.#handlerMap.set(event, handlers)
+    }
+    
+    handlers.push({ id: handlerID, fn, event });
+    return handlerID;
   }
   
-  const callerComponentState = getOrCreateAsyncState(subtask.componentIdx());
-  const rep = callerComponentState.subtasks.insert(subtask);
-  subtask.setRep(rep);
+  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));
+  }
   
-  const calleeComponentState = getOrCreateAsyncState(preparedTask.componentIdx());
-  const calleeBackpressure = calleeComponentState.hasBackpressure();
+  getBackpressureWaiters() { return this.#backpressureWaiters; }
+  addBackpressureWaiter() { this.#backpressureWaiters++; }
+  removeBackpressureWaiter() {
+    this.#backpressureWaiters--;
+    if (this.#backpressureWaiters < 0) {
+      throw new Error("unexepctedly negative number of backpressure waiters");
+    }
+  }
   
-  // Set up a handler on subtask completion to lower results from the call into the caller's memory region.
-  //
-  // NOTE: during fused guest->guest calls this handler is triggered, but does not actually perform
-  // lowering manually, as fused modules provider helper functions that can
-  subtask.registerOnResolveHandler((res) => {
-    _debugLog('[_asyncStartCall()] handling subtask result', { res, subtaskID: subtask.id() });
-    let subtaskCallMeta = subtask.getCallMetadata();
+  parkTaskOnAwaitable(args) {
+    if (!args.awaitable) { throw new TypeError('missing awaitable when trying to park'); }
+    if (!args.task) { throw new TypeError('missing task when trying to park'); }
+    const { awaitable, task } = args;
     
-    // NOTE: in the case of guest -> guest async calls, there may be no memory/realloc present,
-    // as the host will intermediate the value storage/movement between calls.
-    //
-    // We can simply take the value and lower it as a parameter
-    if (subtaskCallMeta.memory || subtaskCallMeta.realloc) {
-      throw new Error("call metadata unexpectedly contains memory/realloc for guest->guest call");
+    let taskList = this.#parkedTasks.get(awaitable.id());
+    if (!taskList) {
+      taskList = [];
+      this.#parkedTasks.set(awaitable.id(), taskList);
     }
+    taskList.push(task);
     
-    const callerTask = subtask.getParentTask();
-    const calleeTask = preparedTask;
-    const callerMemoryIdx = callerTask.getReturnMemoryIdx();
-    const callerComponentIdx = callerTask.componentIdx();
-    
-    // If a helper function was provided we are likely in a fused guest->guest call,
-    // and the result will be delivered (lift/lowered) via helper function
-    if (subtaskCallMeta.returnFn) {
-      _debugLog('[_asyncStartCall()] return function present while ahndling subtask result, returning early (skipping lower)');
-      return;
-    }
+    this.wakeNextTaskForAwaitable(awaitable);
+  }
+  
+  wakeNextTaskForAwaitable(awaitable) {
+    if (!awaitable) { throw new TypeError('missing awaitable when waking next task'); }
+    const awaitableID = awaitable.id();
     
-    // If there is no where to lower the results, exit early
-    if (!subtaskCallMeta.resultPtr) {
-      _debugLog('[_asyncStartCall()] no result ptr during subtask result handling, returning early (skipping lower)');
+    const taskList = this.#parkedTasks.get(awaitableID);
+    if (!taskList || taskList.length === 0) {
+      _debugLog('[ComponentAsyncState] no tasks waiting for awaitable', { awaitableID: awaitable.id() });
       return;
     }
     
-    let callerMemory;
-    if (callerMemoryIdx) {
-      callerMemory = GlobalComponentMemories.getMemory(callerComponentIdx, callerMemoryIdx);
-    } else {
-      const callerMemories = GlobalComponentMemories.getMemoriesForComponentIdx(callerComponentIdx);
-      if (callerMemories.length != 1) { throw new Error(`unsupported amount of caller memories`); }
-      callerMemory = callerMemories[0];
-    }
+    let task = taskList.shift(); // todo(perf)
+    if (!task) { throw new Error('no task in parked list despite previous check'); }
     
-    if (!callerMemory) {
-      throw new Error(`missing memory for to guest->guest call result (subtask [${subtask.id()}])`);
+    if (!task.awaitableResume) {
+      throw new Error('task ready due to awaitable is missing resume', { taskID: task.id(), awaitableID });
     }
+    task.awaitableResume();
+  }
+  
+  // TODO: we might want to check for pre-locked status here
+  exclusiveLock() {
+    this.#locked = true;
+  }
+  
+  exclusiveRelease() {
+    _debugLog('[ComponentAsyncState#exclusiveRelease()] releasing', {
+      locked: this.#locked,
+      componentIdx: this.#componentIdx,
+    });
     
-    const lowerFns = calleeTask.getReturnLowerFns();
-    if (!lowerFns || lowerFns.length === 0) {
-      throw new Error(`missing result lower metadata for guest->guests call (subtask [${subtask.id()}])`);
+    this.#locked = false
+  }
+  
+  isExclusivelyLocked() { return this.#locked === true; }
+  
+  #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);
     }
+  }
+  
+  suspendTask(args) {
+    // TODO(threads): readyFn is normally on the thread
+    const { task, readyFn } = args;
+    const taskID = task.id();
+    _debugLog('[ComponentAsyncState#suspendTask()]', { taskID });
     
-    if (lowerFns.length !== 1) {
-      throw new Error(`only single result supported for guest->guest calls (subtask [${subtask.id()}])`);
+    if (this.#getSuspendedTaskMeta(taskID)) {
+      throw new Error('task [' + taskID + '] already suspended');
     }
     
-    lowerFns[0]({
-      realloc: undefined,
-      memory: callerMemory,
-      vals: [res],
-      storagePtr: subtaskCallMeta.resultPtr,
-      componentIdx: callerComponentIdx
+    const { promise, resolve } = Promise.withResolvers();
+    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());
+      },
     });
     
-  });
-  
-  // Build call params
-  const subtaskCallMeta = subtask.getCallMetadata();
-  let startFnParams = [];
-  let calleeParams = [];
-  if (subtaskCallMeta.startFn && subtaskCallMeta.resultPtr) {
-    // If we're using a fused component start fn  and a result pointer is present,
-    // then we need to pass the result pointer and other params to the start fn
-    startFnParams.push(subtaskCallMeta.resultPtr, ...params);
-  } else {
-    // if not we need to pass params to the callee instead
-    startFnParams.push(...params);
-    calleeParams.push(...params);
+    return promise;
   }
   
-  preparedTask.registerOnResolveHandler((res) => {
-    _debugLog('[_asyncStartCall()] signaling subtask completion due to task completion', {
-      childTaskID: preparedTask.id(),
-      subtaskID: subtask.id(),
-      parentTaskID: subtask.getParentTask().id(),
-    });
-    subtask.onResolve(res);
-  });
-  
-  // TODO(fix): start fns sometimes produce results, how should they be used?
-  // the result should theoretically be used for flat lowering, but fused components do
-  // this automatically!
-  subtask.onStart({ startFnParams });
-  
-  _debugLog("[_asyncStartCall()] initial call", {
-    task: preparedTask.id(),
-    subtaskID: subtask.id(),
-    calleeFnName: callee.name,
-  });
+  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 callbackResult = callee.apply(null, calleeParams);
+  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 isReady = meta.readyFn();
+      if (!isReady) { continue; }
+      
+      this.resumeTaskByID(taskID);
+    }
+    
+    return this.#suspendedTaskIDs.filter(t => t !== null).length === 0;
+  }
   
-  _debugLog("[_asyncStartCall()] after initial call", {
-    task: preparedTask.id(),
-    subtaskID: subtask.id(),
-    calleeFnName: callee.name,
-  });
+  addPendingTask(task) {
+    this.#pendingTasks.push(task);
+  }
   
-  const doSubtaskResolve = () => {
-    subtask.deliverResolve();
-  };
+  addStreamEnd(args) {
+    _debugLog('[ComponentAsyncState#addStreamEnd()] args', args);
+    const { tableIdx, streamEnd } = args;
+    
+    let tbl = this.#streams.get(tableIdx);
+    if (!tbl) {
+      tbl = new RepTable({ target: `component [${this.#componentIdx}] streams` });
+      this.#streams.set(tableIdx, tbl);
+    }
+    
+    const streamIdx = tbl.insert(streamEnd);
+    return streamIdx;
+  }
   
-  // If a single call resolved the subtask and there is no backpressure in the guest,
-  // we can return immediately
-  if (subtask.resolved() && !calleeBackpressure) {
-    _debugLog("[_asyncStartCall()] instantly resolved", {
-      calleeComponentIdx: preparedTask.componentIdx(),
-      task: preparedTask.id(),
-      subtaskID: subtask.id(),
-      callerComponentIdx: subtask.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"); }
     
-    // If a fused component return function was specified for the subtask,
-    // we've likely already called it during resolution of the task.
-    //
-    // In this case, we do not want to actually return 2 AKA "RETURNED",
-    // but the normal started task state, because the fused component expects to get
-    // the waitable + the original subtask state (0 AKA "STARTING")
-    //
-    if (subtask.getCallMetadata().returnFn) {
-      return Number(subtask.waitableRep()) << 4 | subtaskState;
+    let tbl = this.#streams.get(tableIdx);
+    if (!tbl) {
+      tbl = new RepTable({ target: `component [${this.#componentIdx}] streams` });
+      this.#streams.set(tableIdx, tbl);
     }
     
-    doSubtaskResolve();
-    return AsyncSubtask.State.RETURNED;
+    const stream = new InternalStream({
+      tableIdx,
+      componentIdx: this.#componentIdx,
+      elemMeta,
+    });
+    const writeEndIdx = tbl.insert(stream.getWriteEnd());
+    stream.setWriteEndIdx(writeEndIdx);
+    const readEndIdx = tbl.insert(stream.getReadEnd());
+    stream.setReadEndIdx(readEndIdx);
+    
+    const rep = STREAMS.insert(stream);
+    stream.setRep(rep);
+    
+    return { writeEndIdx, readEndIdx };
   }
   
-  // Start the (event) driver loop that will resolve the task
-  new Promise(async (resolve, reject) => {
-    if (subtask.resolved() && calleeBackpressure) {
-      await calleeComponentState.waitForBackpressure();
-      
-      _debugLog("[_asyncStartCall()] instantly resolved after cleared backpressure", {
-        calleeComponentIdx: preparedTask.componentIdx(),
-        task: preparedTask.id(),
-        subtaskID: subtask.id(),
-        callerComponentIdx: subtask.componentIdx(),
-      });
-      return;
+  getStreamEnd(args) {
+    _debugLog('[ComponentAsyncState#getStreamEnd()] args', args);
+    const { tableIdx, streamIdx } = args;
+    if (tableIdx === undefined) { throw new Error('missing table idx while retrieveing stream end'); }
+    if (streamIdx === undefined) { throw new Error('missing stream idx while retrieveing stream end'); }
+    
+    const tbl = this.#streams.get(tableIdx);
+    if (!tbl) {
+      throw new Error(`missing stream table [${tableIdx}] in component [${this.#componentIdx}] while getting stream`);
     }
     
-    const started = await preparedTask.enter();
-    if (!started) {
-      _debugLog('[_asyncStartCall()] task failed early', {
-        taskID: preparedTask.id(),
-        subtaskID: subtask.id(),
-      });
-      throw new Error("task failed to start");
-      return;
+    const stream = tbl.get(streamIdx);
+    return stream;
+  }
+  
+  removeStreamEnd(args) {
+    _debugLog('[ComponentAsyncState#removeStreamEnd()] args', args);
+    const { tableIdx, streamIdx } = args;
+    if (tableIdx === undefined) { throw new Error("missing table idx while removing stream end"); }
+    if (streamIdx === undefined) { throw new Error("missing stream idx while removing stream end"); }
+    
+    const tbl = this.#streams.get(tableIdx);
+    if (!tbl) {
+      throw new Error(`missing stream table [${tableIdx}] in component [${this.#componentIdx}] while removing stream end`);
     }
     
-    // TODO: retrieve/pass along actual fn name the callback corresponds to
-    // (at least something like `<lifted fn name>_callback`)
-    const fnName = [
-    '<task ',
-    subtask.parentTaskID(),
-    '/subtask ',
-    subtask.id(),
-    '/task ',
-    preparedTask.id(),
-    '>',
-    ].join("");
+    const stream = tbl.get(streamIdx);
+    if (!stream) { throw new Error(`component [${this.#componentIdx}] missing stream [${streamIdx}]`); }
     
-    try {
-      _debugLog("[_asyncStartCall()] starting driver loop", { fnName, componentIdx: preparedTask.componentIdx(), });
-      await _driverLoop({
-        componentState: calleeComponentState,
-        task: preparedTask,
-        fnName,
-        isAsync: true,
-        callbackResult,
-        resolve,
-        reject
-      });
-    } catch (err) {
-      _debugLog("[AsyncStartCall] drive loop call failure", { err });
+    const removed = tbl.remove(streamIdx);
+    if (!removed) {
+      throw new Error(`missing stream [${streamIdx}] (table [${tableIdx}]) in component [${this.#componentIdx}] while removing stream end`);
     }
     
-  });
-  
-  return Number(subtask.waitableRep()) << 4 | subtaskState;
-}
-
-function _syncStartCall(callbackIdx) {
-  _debugLog('[_syncStartCall()] args', { callbackIdx });
-  throw new Error('synchronous start call not implemented!');
-}
-
-function promiseWithResolvers() {
-  if (Promise.withResolvers) {
-    return Promise.withResolvers();
-  } else {
-    let resolve;
-    let reject;
-    const promise = new Promise((res, rej) => {
-      resolve = res;
-      reject = rej;
-    });
-    return { promise, resolve, reject };
+    return stream;
   }
 }
 
-const _debugLog = (...args) => {
-  if (!globalThis?.process?.env?.JCO_DEBUG) { return; }
-  console.debug(...args);
-}
-const ASYNC_DETERMINISM = 'random';
-const _coinFlip = () => { return Math.random() > 0.5; };
-const I32_MAX = 2_147_483_647;
-const I32_MIN = -2_147_483_648;
-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;
-
 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;
@@ -1986,62 +2298,6 @@ function getErrorPayload(e) {
   return e;
 }
 
-class RepTable {
-  #data = [0, null];
-  #target;
-  
-  constructor(args) {
-    if (args?.target) { this.target = args.target }
-  }
-  
-  insert(val) {
-    _debugLog('[RepTable#insert()] args', { val, target: this.target });
-    const freeIdx = this.#data[0];
-    if (freeIdx === 0) {
-      this.#data.push(val);
-      this.#data.push(null);
-      return (this.#data.length >> 1) - 1;
-    }
-    this.#data[0] = this.#data[freeIdx << 1];
-    const placementIdx = freeIdx << 1;
-    this.#data[placementIdx] = val;
-    this.#data[placementIdx + 1] = null;
-    return freeIdx;
-  }
-  
-  get(rep) {
-    _debugLog('[RepTable#get()] args', { rep, target: this.target });
-    const baseIdx = rep << 1;
-    const val = this.#data[baseIdx];
-    return val;
-  }
-  
-  contains(rep) {
-    _debugLog('[RepTable#contains()] args', { rep, target: this.target });
-    const baseIdx = rep << 1;
-    return !!this.#data[baseIdx];
-  }
-  
-  remove(rep) {
-    _debugLog('[RepTable#remove()] args', { rep, target: this.target });
-    if (this.#data.length === 2) { throw new Error('invalid'); }
-    
-    const baseIdx = rep << 1;
-    const val = this.#data[baseIdx];
-    if (val === 0) { throw new Error('invalid resource rep (cannot be 0)'); }
-    
-    this.#data[baseIdx] = this.#data[0];
-    this.#data[0] = rep;
-    
-    return val;
-  }
-  
-  clear() {
-    _debugLog('[RepTable#clear()] args', { rep, target: this.target });
-    this.#data = [0, null];
-  }
-}
-
 function throwUninitialized() {
   throw new TypeError('Wasm uninitialized use `await $init` first');
 }
@@ -2050,65 +2306,6 @@ const hasOwnProperty = Object.prototype.hasOwnProperty;
 
 const instantiateCore = WebAssembly.instantiate;
 
-class GlobalComponentAsyncLowers {
-  static map = new Map();
-  
-  constructor() { throw new Error('GlobalComponentAsyncLowers should not be constructed'); }
-  
-  static define(args) {
-    const { componentIdx, qualifiedImportFn, fn } = args;
-    let inner = GlobalComponentAsyncLowers.map.get(componentIdx);
-    if (!inner) {
-      inner = new Map();
-      GlobalComponentAsyncLowers.map.set(componentIdx, inner);
-    }
-    
-    inner.set(qualifiedImportFn, fn);
-  }
-  
-  static lookup(componentIdx, qualifiedImportFn) {
-    let inner = GlobalComponentAsyncLowers.map.get(componentIdx);
-    if (!inner) {
-      inner = new Map();
-      GlobalComponentAsyncLowers.map.set(componentIdx, inner);
-    }
-    
-    const found = inner.get(qualifiedImportFn);
-    if (found) { return found; }
-    
-    return (...args) => {
-      const [originalFn, ...params] = args;
-      return originalFn(...params);
-    };
-  }
-}
-
-class GlobalComponentMemories {
-  static map = new Map();
-  
-  constructor() { throw new Error('GlobalComponentMemories should not be constructed'); }
-  
-  static save(args) {
-    const { idx, componentIdx, memory } = args;
-    let inner = GlobalComponentMemories.map.get(componentIdx);
-    if (!inner) {
-      inner = [];
-      GlobalComponentMemories.map.set(componentIdx, inner);
-    }
-    inner.push({ memory, idx });
-  }
-  
-  static getMemoriesForComponentIdx(componentIdx) {
-    const metas = GlobalComponentMemories.map.get(componentIdx);
-    return metas.map(meta => meta.memory);
-  }
-  
-  static getMemory(componentIdx, idx) {
-    const metas = GlobalComponentMemories.map.get(componentIdx);
-    return metas.find(meta => meta.idx === idx)?.memory;
-  }
-}
-
 
 let exports0;
 let exports1;
@@ -2125,7 +2322,8 @@ handleTables[2] = handleTable2;
 
 function trampoline5() {
   _debugLog('[iface="wasi:cli/stderr@0.2.3", function="get-stderr"] [Instruction::CallInterface] (sync, @ enter)');
-  const hostProvided = getStderr._isHostProvided;
+  let hostProvided = false;
+  hostProvided = getStderr?._isHostProvided;
   
   let parentTask;
   let task;
@@ -2197,7 +2395,8 @@ handleTables[1] = handleTable1;
 
 function trampoline8() {
   _debugLog('[iface="wasi:cli/stdin@0.2.3", function="get-stdin"] [Instruction::CallInterface] (sync, @ enter)');
-  const hostProvided = getStdin._isHostProvided;
+  let hostProvided = false;
+  hostProvided = getStdin?._isHostProvided;
   
   let parentTask;
   let task;
@@ -2265,7 +2464,8 @@ let lowered_import_2_metadata = {
 
 function trampoline9() {
   _debugLog('[iface="wasi:cli/stdout@0.2.3", function="get-stdout"] [Instruction::CallInterface] (sync, @ enter)');
-  const hostProvided = getStdout._isHostProvided;
+  let hostProvided = false;
+  hostProvided = getStdout?._isHostProvided;
   
   let parentTask;
   let task;
@@ -2353,7 +2553,8 @@ function trampoline10(arg0) {
     }
   }
   _debugLog('[iface="wasi:cli/exit@0.2.3", function="exit"] [Instruction::CallInterface] (sync, @ enter)');
-  const hostProvided = exit._isHostProvided;
+  let hostProvided = false;
+  hostProvided = exit?._isHostProvided;
   
   let parentTask;
   let task;
@@ -2414,7 +2615,8 @@ let lowered_import_4_metadata = {
 
 function trampoline11(arg0) {
   _debugLog('[iface="wasi:cli/environment@0.2.3", function="get-environment"] [Instruction::CallInterface] (sync, @ enter)');
-  const hostProvided = getEnvironment._isHostProvided;
+  let hostProvided = false;
+  hostProvided = getEnvironment?._isHostProvided;
   
   let parentTask;
   let task;
@@ -2508,7 +2710,8 @@ function trampoline12(arg0, arg1) {
   }
   curResourceBorrows.push(rsc0);
   _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.get-type"] [Instruction::CallInterface] (sync, @ enter)');
-  const hostProvided = rsc0.getType._isHostProvided;
+  let hostProvided = false;
+  hostProvided = rsc0.getType?._isHostProvided;
   
   let parentTask;
   let task;
@@ -2806,7 +3009,8 @@ function trampoline13(arg0, arg1) {
   }
   curResourceBorrows.push(rsc0);
   _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.metadata-hash"] [Instruction::CallInterface] (sync, @ enter)');
-  const hostProvided = rsc0.metadataHash._isHostProvided;
+  let hostProvided = false;
+  hostProvided = rsc0.metadataHash?._isHostProvided;
   
   let parentTask;
   let task;
@@ -3067,7 +3271,8 @@ function trampoline14(arg0, arg1) {
   }
   curResourceBorrows.push(rsc0);
   _debugLog('[iface="wasi:filesystem/types@0.2.3", function="filesystem-error-code"] [Instruction::CallInterface] (sync, @ enter)');
-  const hostProvided = filesystemErrorCode._isHostProvided;
+  let hostProvided = false;
+  hostProvided = filesystemErrorCode?._isHostProvided;
   
   let parentTask;
   let task;
@@ -3314,7 +3519,8 @@ function trampoline15(arg0, arg1, arg2, arg3, arg4) {
   var len4 = arg3;
   var result4 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr4, len4));
   _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.metadata-hash-at"] [Instruction::CallInterface] (sync, @ enter)');
-  const hostProvided = rsc0.metadataHashAt._isHostProvided;
+  let hostProvided = false;
+  hostProvided = rsc0.metadataHashAt?._isHostProvided;
   
   let parentTask;
   let task;
@@ -3571,7 +3777,8 @@ function trampoline16(arg0, arg1, arg2) {
   }
   curResourceBorrows.push(rsc0);
   _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.read-via-stream"] [Instruction::CallInterface] (sync, @ enter)');
-  const hostProvided = rsc0.readViaStream._isHostProvided;
+  let hostProvided = false;
+  hostProvided = rsc0.readViaStream?._isHostProvided;
   
   let parentTask;
   let task;
@@ -3835,7 +4042,8 @@ function trampoline17(arg0, arg1, arg2) {
   }
   curResourceBorrows.push(rsc0);
   _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.write-via-stream"] [Instruction::CallInterface] (sync, @ enter)');
-  const hostProvided = rsc0.writeViaStream._isHostProvided;
+  let hostProvided = false;
+  hostProvided = rsc0.writeViaStream?._isHostProvided;
   
   let parentTask;
   let task;
@@ -4099,7 +4307,8 @@ function trampoline18(arg0, arg1) {
   }
   curResourceBorrows.push(rsc0);
   _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.append-via-stream"] [Instruction::CallInterface] (sync, @ enter)');
-  const hostProvided = rsc0.appendViaStream._isHostProvided;
+  let hostProvided = false;
+  hostProvided = rsc0.appendViaStream?._isHostProvided;
   
   let parentTask;
   let task;
@@ -4367,7 +4576,8 @@ function trampoline19(arg0, arg1) {
   }
   curResourceBorrows.push(rsc0);
   _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.read-directory"] [Instruction::CallInterface] (sync, @ enter)');
-  const hostProvided = rsc0.readDirectory._isHostProvided;
+  let hostProvided = false;
+  hostProvided = rsc0.readDirectory?._isHostProvided;
   
   let parentTask;
   let task;
@@ -4631,7 +4841,8 @@ function trampoline20(arg0, arg1) {
   }
   curResourceBorrows.push(rsc0);
   _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.stat"] [Instruction::CallInterface] (sync, @ enter)');
-  const hostProvided = rsc0.stat._isHostProvided;
+  let hostProvided = false;
+  hostProvided = rsc0.stat?._isHostProvided;
   
   let parentTask;
   let task;
@@ -4971,7 +5182,8 @@ function trampoline21(arg0, arg1, arg2, arg3, arg4) {
   var len4 = arg3;
   var result4 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr4, len4));
   _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.stat-at"] [Instruction::CallInterface] (sync, @ enter)');
-  const hostProvided = rsc0.statAt._isHostProvided;
+  let hostProvided = false;
+  hostProvided = rsc0.statAt?._isHostProvided;
   
   let parentTask;
   let task;
@@ -5331,7 +5543,8 @@ function trampoline22(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
     mutateDirectory: Boolean(arg5 & 32),
   };
   _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.open-at"] [Instruction::CallInterface] (sync, @ enter)');
-  const hostProvided = rsc0.openAt._isHostProvided;
+  let hostProvided = false;
+  hostProvided = rsc0.openAt?._isHostProvided;
   
   let parentTask;
   let task;
@@ -5595,7 +5808,8 @@ function trampoline23(arg0, arg1) {
   }
   curResourceBorrows.push(rsc0);
   _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]directory-entry-stream.read-directory-entry"] [Instruction::CallInterface] (sync, @ enter)');
-  const hostProvided = rsc0.readDirectoryEntry._isHostProvided;
+  let hostProvided = false;
+  hostProvided = rsc0.readDirectoryEntry?._isHostProvided;
   
   let parentTask;
   let task;
@@ -5908,7 +6122,8 @@ function trampoline24(arg0, arg1, arg2) {
   }
   curResourceBorrows.push(rsc0);
   _debugLog('[iface="wasi:io/streams@0.2.3", function="[method]input-stream.read"] [Instruction::CallInterface] (sync, @ enter)');
-  const hostProvided = rsc0.read._isHostProvided;
+  let hostProvided = false;
+  hostProvided = rsc0.read?._isHostProvided;
   
   let parentTask;
   let task;
@@ -5968,8 +6183,24 @@ function trampoline24(arg0, arg1, arg2) {
       var val3 = e;
       var len3 = val3.byteLength;
       var ptr3 = realloc0(0, 0, 1, len3 * 1);
-      var src3 = new Uint8Array(val3.buffer || val3, val3.byteOffset, len3 * 1);
-      (new Uint8Array(memory0.buffer, ptr3, len3 * 1)).set(src3);
+      
+      let valData3;
+      const valLenBytes3 = len3 * 1;
+      if (Array.isArray(val3)) {
+        // Regular array likely containing numbers, write values to memory
+        let offset = 0;
+        const dv3 = new DataView(memory0.buffer);
+        for (const v of val3) {
+          dv3.setUint8(ptr3+ offset, v, true);
+          offset += 1;
+        }
+      } else {
+        // TypedArray / ArrayBuffer-like, direct copy
+        valData3 = new Uint8Array(val3.buffer || val3, val3.byteOffset, valLenBytes3);
+        const out3 = new Uint8Array(memory0.buffer, ptr3,valLenBytes3);
+        out3.set(valData3);
+      }
+      
       dataView(memory0).setUint32(arg2 + 8, len3, true);
       dataView(memory0).setUint32(arg2 + 4, ptr3, true);
       break;
@@ -6034,7 +6265,8 @@ function trampoline25(arg0, arg1, arg2) {
   }
   curResourceBorrows.push(rsc0);
   _debugLog('[iface="wasi:io/streams@0.2.3", function="[method]input-stream.blocking-read"] [Instruction::CallInterface] (sync, @ enter)');
-  const hostProvided = rsc0.blockingRead._isHostProvided;
+  let hostProvided = false;
+  hostProvided = rsc0.blockingRead?._isHostProvided;
   
   let parentTask;
   let task;
@@ -6094,8 +6326,24 @@ function trampoline25(arg0, arg1, arg2) {
       var val3 = e;
       var len3 = val3.byteLength;
       var ptr3 = realloc0(0, 0, 1, len3 * 1);
-      var src3 = new Uint8Array(val3.buffer || val3, val3.byteOffset, len3 * 1);
-      (new Uint8Array(memory0.buffer, ptr3, len3 * 1)).set(src3);
+      
+      let valData3;
+      const valLenBytes3 = len3 * 1;
+      if (Array.isArray(val3)) {
+        // Regular array likely containing numbers, write values to memory
+        let offset = 0;
+        const dv3 = new DataView(memory0.buffer);
+        for (const v of val3) {
+          dv3.setUint8(ptr3+ offset, v, true);
+          offset += 1;
+        }
+      } else {
+        // TypedArray / ArrayBuffer-like, direct copy
+        valData3 = new Uint8Array(val3.buffer || val3, val3.byteOffset, valLenBytes3);
+        const out3 = new Uint8Array(memory0.buffer, ptr3,valLenBytes3);
+        out3.set(valData3);
+      }
+      
       dataView(memory0).setUint32(arg2 + 8, len3, true);
       dataView(memory0).setUint32(arg2 + 4, ptr3, true);
       break;
@@ -6160,7 +6408,8 @@ function trampoline26(arg0, arg1) {
   }
   curResourceBorrows.push(rsc0);
   _debugLog('[iface="wasi:io/streams@0.2.3", function="[method]output-stream.check-write"] [Instruction::CallInterface] (sync, @ enter)');
-  const hostProvided = rsc0.checkWrite._isHostProvided;
+  let hostProvided = false;
+  hostProvided = rsc0.checkWrite?._isHostProvided;
   
   let parentTask;
   let task;
@@ -6283,7 +6532,8 @@ function trampoline27(arg0, arg1, arg2, arg3) {
   var len3 = arg2;
   var result3 = new Uint8Array(memory0.buffer.slice(ptr3, ptr3 + len3 * 1));
   _debugLog('[iface="wasi:io/streams@0.2.3", function="[method]output-stream.write"] [Instruction::CallInterface] (sync, @ enter)');
-  const hostProvided = rsc0.write._isHostProvided;
+  let hostProvided = false;
+  hostProvided = rsc0.write?._isHostProvided;
   
   let parentTask;
   let task;
@@ -6405,7 +6655,8 @@ function trampoline28(arg0, arg1, arg2, arg3) {
   var len3 = arg2;
   var result3 = new Uint8Array(memory0.buffer.slice(ptr3, ptr3 + len3 * 1));
   _debugLog('[iface="wasi:io/streams@0.2.3", function="[method]output-stream.blocking-write-and-flush"] [Instruction::CallInterface] (sync, @ enter)');
-  const hostProvided = rsc0.blockingWriteAndFlush._isHostProvided;
+  let hostProvided = false;
+  hostProvided = rsc0.blockingWriteAndFlush?._isHostProvided;
   
   let parentTask;
   let task;
@@ -6524,7 +6775,8 @@ function trampoline29(arg0, arg1) {
   }
   curResourceBorrows.push(rsc0);
   _debugLog('[iface="wasi:io/streams@0.2.3", function="[method]output-stream.blocking-flush"] [Instruction::CallInterface] (sync, @ enter)');
-  const hostProvided = rsc0.blockingFlush._isHostProvided;
+  let hostProvided = false;
+  hostProvided = rsc0.blockingFlush?._isHostProvided;
   
   let parentTask;
   let task;
@@ -6634,7 +6886,8 @@ let lowered_import_23_metadata = {
 
 function trampoline30(arg0, arg1) {
   _debugLog('[iface="wasi:random/random@0.2.3", function="get-random-bytes"] [Instruction::CallInterface] (sync, @ enter)');
-  const hostProvided = getRandomBytes._isHostProvided;
+  let hostProvided = false;
+  hostProvided = getRandomBytes?._isHostProvided;
   
   let parentTask;
   let task;
@@ -6678,8 +6931,24 @@ function trampoline30(arg0, arg1) {
   var val0 = ret;
   var len0 = val0.byteLength;
   var ptr0 = realloc0(0, 0, 1, len0 * 1);
-  var src0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, len0 * 1);
-  (new Uint8Array(memory0.buffer, ptr0, len0 * 1)).set(src0);
+  
+  let valData0;
+  const valLenBytes0 = len0 * 1;
+  if (Array.isArray(val0)) {
+    // Regular array likely containing numbers, write values to memory
+    let offset = 0;
+    const dv0 = new DataView(memory0.buffer);
+    for (const v of val0) {
+      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);
+    out0.set(valData0);
+  }
+  
   dataView(memory0).setUint32(arg1 + 4, len0, true);
   dataView(memory0).setUint32(arg1 + 0, ptr0, true);
   _debugLog('[iface="wasi:random/random@0.2.3", function="get-random-bytes"][Instruction::Return]', {
@@ -6699,7 +6968,8 @@ let lowered_import_24_metadata = {
 
 function trampoline31(arg0) {
   _debugLog('[iface="wasi:filesystem/preopens@0.2.3", function="get-directories"] [Instruction::CallInterface] (sync, @ enter)');
-  const hostProvided = getDirectories._isHostProvided;
+  let hostProvided = false;
+  hostProvided = getDirectories?._isHostProvided;
   
   let parentTask;
   let task;
@@ -6787,7 +7057,8 @@ handleTables[3] = handleTable3;
 
 function trampoline32(arg0) {
   _debugLog('[iface="wasi:cli/terminal-stdin@0.2.3", function="get-terminal-stdin"] [Instruction::CallInterface] (sync, @ enter)');
-  const hostProvided = getTerminalStdin._isHostProvided;
+  let hostProvided = false;
+  hostProvided = getTerminalStdin?._isHostProvided;
   
   let parentTask;
   let task;
@@ -6866,7 +7137,8 @@ handleTables[4] = handleTable4;
 
 function trampoline33(arg0) {
   _debugLog('[iface="wasi:cli/terminal-stdout@0.2.3", function="get-terminal-stdout"] [Instruction::CallInterface] (sync, @ enter)');
-  const hostProvided = getTerminalStdout._isHostProvided;
+  let hostProvided = false;
+  hostProvided = getTerminalStdout?._isHostProvided;
   
   let parentTask;
   let task;
@@ -6941,7 +7213,8 @@ let lowered_import_27_metadata = {
 
 function trampoline34(arg0) {
   _debugLog('[iface="wasi:cli/terminal-stderr@0.2.3", function="get-terminal-stderr"] [Instruction::CallInterface] (sync, @ enter)');
-  const hostProvided = getTerminalStderr._isHostProvided;
+  let hostProvided = false;
+  hostProvided = getTerminalStderr?._isHostProvided;
   
   let parentTask;
   let task;
@@ -7206,7 +7479,7 @@ GlobalComponentAsyncLowers.define({
     isAsync: false,
     paramLiftFns: [],
     metadata: lowered_import_4_metadata,
-    resultLowerFns: [_lowerFlatList.bind(null, 0)],
+    resultLowerFns: [_lowerFlatList({ elemLowerFn: _lowerFlatTuple.bind(null, 0), typeIdx: 0 })],
     getCallbackFn: () => null,
     getPostReturnFn: () => null,
     isCancellable: false,
@@ -7227,7 +7500,7 @@ GlobalComponentAsyncLowers.define({
     trampolineIdx: 12,
     componentIdx: 0,
     isAsync: false,
-    paramLiftFns: [_liftFlatOwn.bind(null, 6)],
+    paramLiftFns: [_liftFlatBorrow.bind(null, 6)],
     metadata: lowered_import_5_metadata,
     resultLowerFns: [_lowerFlatResult([{ discriminant: 0, tag: 'ok', lowerFn: _lowerFlatEnum.bind(null, 0), align32: 1 },{ discriminant: 1, tag: 'error', lowerFn: _lowerFlatEnum.bind(null, 1), align32: 1 },])],
     getCallbackFn: () => null,
@@ -7250,7 +7523,7 @@ GlobalComponentAsyncLowers.define({
     trampolineIdx: 13,
     componentIdx: 0,
     isAsync: false,
-    paramLiftFns: [_liftFlatOwn.bind(null, 6)],
+    paramLiftFns: [_liftFlatBorrow.bind(null, 6)],
     metadata: lowered_import_6_metadata,
     resultLowerFns: [_lowerFlatResult([{ discriminant: 0, tag: 'ok', lowerFn: _lowerFlatRecord([{ field: 'lower', lowerFn: _lowerFlatU64, align32: 8 },{ field: 'upper', lowerFn: _lowerFlatU64, align32: 8 },]), align32: 8 },{ discriminant: 1, tag: 'error', lowerFn: _lowerFlatEnum.bind(null, 1), align32: 1 },])],
     getCallbackFn: () => null,
@@ -7273,7 +7546,7 @@ GlobalComponentAsyncLowers.define({
     trampolineIdx: 14,
     componentIdx: 0,
     isAsync: false,
-    paramLiftFns: [_liftFlatOwn.bind(null, 0)],
+    paramLiftFns: [_liftFlatBorrow.bind(null, 0)],
     metadata: lowered_import_7_metadata,
     resultLowerFns: [_lowerFlatOption.bind(null, 4)],
     getCallbackFn: () => null,
@@ -7296,7 +7569,7 @@ GlobalComponentAsyncLowers.define({
     trampolineIdx: 15,
     componentIdx: 0,
     isAsync: false,
-    paramLiftFns: [_liftFlatOwn.bind(null, 6),_liftFlatFlags.bind(null, 0),_liftFlatStringUTF8],
+    paramLiftFns: [_liftFlatBorrow.bind(null, 6),_liftFlatFlags.bind(null, 0),_liftFlatStringUTF8],
     metadata: lowered_import_8_metadata,
     resultLowerFns: [_lowerFlatResult([{ discriminant: 0, tag: 'ok', lowerFn: _lowerFlatRecord([{ field: 'lower', lowerFn: _lowerFlatU64, align32: 8 },{ field: 'upper', lowerFn: _lowerFlatU64, align32: 8 },]), align32: 8 },{ discriminant: 1, tag: 'error', lowerFn: _lowerFlatEnum.bind(null, 1), align32: 1 },])],
     getCallbackFn: () => null,
@@ -7319,7 +7592,7 @@ GlobalComponentAsyncLowers.define({
     trampolineIdx: 16,
     componentIdx: 0,
     isAsync: false,
-    paramLiftFns: [_liftFlatOwn.bind(null, 6),_liftFlatU64],
+    paramLiftFns: [_liftFlatBorrow.bind(null, 6),_liftFlatU64],
     metadata: lowered_import_9_metadata,
     resultLowerFns: [_lowerFlatResult([{ discriminant: 0, tag: 'ok', lowerFn: _lowerFlatOwn.bind(null, 1), align32: 4 },{ discriminant: 1, tag: 'error', lowerFn: _lowerFlatEnum.bind(null, 1), align32: 1 },])],
     getCallbackFn: () => null,
@@ -7342,7 +7615,7 @@ GlobalComponentAsyncLowers.define({
     trampolineIdx: 17,
     componentIdx: 0,
     isAsync: false,
-    paramLiftFns: [_liftFlatOwn.bind(null, 6),_liftFlatU64],
+    paramLiftFns: [_liftFlatBorrow.bind(null, 6),_liftFlatU64],
     metadata: lowered_import_10_metadata,
     resultLowerFns: [_lowerFlatResult([{ discriminant: 0, tag: 'ok', lowerFn: _lowerFlatOwn.bind(null, 2), align32: 4 },{ discriminant: 1, tag: 'error', lowerFn: _lowerFlatEnum.bind(null, 1), align32: 1 },])],
     getCallbackFn: () => null,
@@ -7365,7 +7638,7 @@ GlobalComponentAsyncLowers.define({
     trampolineIdx: 18,
     componentIdx: 0,
     isAsync: false,
-    paramLiftFns: [_liftFlatOwn.bind(null, 6)],
+    paramLiftFns: [_liftFlatBorrow.bind(null, 6)],
     metadata: lowered_import_11_metadata,
     resultLowerFns: [_lowerFlatResult([{ discriminant: 0, tag: 'ok', lowerFn: _lowerFlatOwn.bind(null, 2), align32: 4 },{ discriminant: 1, tag: 'error', lowerFn: _lowerFlatEnum.bind(null, 1), align32: 1 },])],
     getCallbackFn: () => null,
@@ -7388,7 +7661,7 @@ GlobalComponentAsyncLowers.define({
     trampolineIdx: 19,
     componentIdx: 0,
     isAsync: false,
-    paramLiftFns: [_liftFlatOwn.bind(null, 6)],
+    paramLiftFns: [_liftFlatBorrow.bind(null, 6)],
     metadata: lowered_import_12_metadata,
     resultLowerFns: [_lowerFlatResult([{ discriminant: 0, tag: 'ok', lowerFn: _lowerFlatOwn.bind(null, 5), align32: 4 },{ discriminant: 1, tag: 'error', lowerFn: _lowerFlatEnum.bind(null, 1), align32: 1 },])],
     getCallbackFn: () => null,
@@ -7411,7 +7684,7 @@ GlobalComponentAsyncLowers.define({
     trampolineIdx: 20,
     componentIdx: 0,
     isAsync: false,
-    paramLiftFns: [_liftFlatOwn.bind(null, 6)],
+    paramLiftFns: [_liftFlatBorrow.bind(null, 6)],
     metadata: lowered_import_13_metadata,
     resultLowerFns: [_lowerFlatResult([{ discriminant: 0, tag: 'ok', lowerFn: _lowerFlatRecord([{ field: 'type', lowerFn: _lowerFlatEnum.bind(null, 0), align32: 8 },{ field: 'link-count', lowerFn: _lowerFlatU64, align32: 8 },{ field: 'size', lowerFn: _lowerFlatU64, align32: 8 },{ field: 'data-access-timestamp', lowerFn: _lowerFlatOption.bind(null, 2), align32: 8 },{ field: 'data-modification-timestamp', lowerFn: _lowerFlatOption.bind(null, 2), align32: 8 },{ field: 'status-change-timestamp', lowerFn: _lowerFlatOption.bind(null, 2), align32: 8 },]), align32: 8 },{ discriminant: 1, tag: 'error', lowerFn: _lowerFlatEnum.bind(null, 1), align32: 1 },])],
     getCallbackFn: () => null,
@@ -7434,7 +7707,7 @@ GlobalComponentAsyncLowers.define({
     trampolineIdx: 21,
     componentIdx: 0,
     isAsync: false,
-    paramLiftFns: [_liftFlatOwn.bind(null, 6),_liftFlatFlags.bind(null, 0),_liftFlatStringUTF8],
+    paramLiftFns: [_liftFlatBorrow.bind(null, 6),_liftFlatFlags.bind(null, 0),_liftFlatStringUTF8],
     metadata: lowered_import_14_metadata,
     resultLowerFns: [_lowerFlatResult([{ discriminant: 0, tag: 'ok', lowerFn: _lowerFlatRecord([{ field: 'type', lowerFn: _lowerFlatEnum.bind(null, 0), align32: 8 },{ field: 'link-count', lowerFn: _lowerFlatU64, align32: 8 },{ field: 'size', lowerFn: _lowerFlatU64, align32: 8 },{ field: 'data-access-timestamp', lowerFn: _lowerFlatOption.bind(null, 2), align32: 8 },{ field: 'data-modification-timestamp', lowerFn: _lowerFlatOption.bind(null, 2), align32: 8 },{ field: 'status-change-timestamp', lowerFn: _lowerFlatOption.bind(null, 2), align32: 8 },]), align32: 8 },{ discriminant: 1, tag: 'error', lowerFn: _lowerFlatEnum.bind(null, 1), align32: 1 },])],
     getCallbackFn: () => null,
@@ -7457,7 +7730,7 @@ GlobalComponentAsyncLowers.define({
     trampolineIdx: 22,
     componentIdx: 0,
     isAsync: false,
-    paramLiftFns: [_liftFlatOwn.bind(null, 6),_liftFlatFlags.bind(null, 0),_liftFlatStringUTF8,_liftFlatFlags.bind(null, 1),_liftFlatFlags.bind(null, 2)],
+    paramLiftFns: [_liftFlatBorrow.bind(null, 6),_liftFlatFlags.bind(null, 0),_liftFlatStringUTF8,_liftFlatFlags.bind(null, 1),_liftFlatFlags.bind(null, 2)],
     metadata: lowered_import_15_metadata,
     resultLowerFns: [_lowerFlatResult([{ discriminant: 0, tag: 'ok', lowerFn: _lowerFlatOwn.bind(null, 6), align32: 4 },{ discriminant: 1, tag: 'error', lowerFn: _lowerFlatEnum.bind(null, 1), align32: 1 },])],
     getCallbackFn: () => null,
@@ -7480,7 +7753,7 @@ GlobalComponentAsyncLowers.define({
     trampolineIdx: 23,
     componentIdx: 0,
     isAsync: false,
-    paramLiftFns: [_liftFlatOwn.bind(null, 5)],
+    paramLiftFns: [_liftFlatBorrow.bind(null, 5)],
     metadata: lowered_import_16_metadata,
     resultLowerFns: [_lowerFlatResult([{ discriminant: 0, tag: 'ok', lowerFn: _lowerFlatOption.bind(null, 3), align32: 4 },{ discriminant: 1, tag: 'error', lowerFn: _lowerFlatEnum.bind(null, 1), align32: 1 },])],
     getCallbackFn: () => null,
@@ -7503,9 +7776,9 @@ GlobalComponentAsyncLowers.define({
     trampolineIdx: 24,
     componentIdx: 0,
     isAsync: false,
-    paramLiftFns: [_liftFlatOwn.bind(null, 1),_liftFlatU64],
+    paramLiftFns: [_liftFlatBorrow.bind(null, 1),_liftFlatU64],
     metadata: lowered_import_17_metadata,
-    resultLowerFns: [_lowerFlatResult([{ discriminant: 0, tag: 'ok', lowerFn: _lowerFlatList.bind(null, 1), align32: 4 },{ discriminant: 1, tag: 'error', lowerFn: _lowerFlatVariant({ discriminantSizeBytes: 1, lowerMetas: [{ discriminant: 0, tag: 'last-operation-failed', lowerFn: _lowerFlatOwn.bind(null, 0), align32: 4, },{ discriminant: 1, tag: 'closed', lowerFn: null, align32: null, },] }), align32: 4 },])],
+    resultLowerFns: [_lowerFlatResult([{ discriminant: 0, tag: 'ok', lowerFn: _lowerFlatList({ elemLowerFn: _lowerFlatU8, typeIdx: 1 }), align32: 4 },{ discriminant: 1, tag: 'error', lowerFn: _lowerFlatVariant({ discriminantSizeBytes: 1, lowerMetas: [{ discriminant: 0, tag: 'last-operation-failed', lowerFn: _lowerFlatOwn.bind(null, 0), align32: 4, },{ discriminant: 1, tag: 'closed', lowerFn: null, align32: null, },] }), align32: 4 },])],
     getCallbackFn: () => null,
     getPostReturnFn: () => null,
     isCancellable: false,
@@ -7526,9 +7799,9 @@ GlobalComponentAsyncLowers.define({
     trampolineIdx: 25,
     componentIdx: 0,
     isAsync: false,
-    paramLiftFns: [_liftFlatOwn.bind(null, 1),_liftFlatU64],
+    paramLiftFns: [_liftFlatBorrow.bind(null, 1),_liftFlatU64],
     metadata: lowered_import_18_metadata,
-    resultLowerFns: [_lowerFlatResult([{ discriminant: 0, tag: 'ok', lowerFn: _lowerFlatList.bind(null, 1), align32: 4 },{ discriminant: 1, tag: 'error', lowerFn: _lowerFlatVariant({ discriminantSizeBytes: 1, lowerMetas: [{ discriminant: 0, tag: 'last-operation-failed', lowerFn: _lowerFlatOwn.bind(null, 0), align32: 4, },{ discriminant: 1, tag: 'closed', lowerFn: null, align32: null, },] }), align32: 4 },])],
+    resultLowerFns: [_lowerFlatResult([{ discriminant: 0, tag: 'ok', lowerFn: _lowerFlatList({ elemLowerFn: _lowerFlatU8, typeIdx: 1 }), align32: 4 },{ discriminant: 1, tag: 'error', lowerFn: _lowerFlatVariant({ discriminantSizeBytes: 1, lowerMetas: [{ discriminant: 0, tag: 'last-operation-failed', lowerFn: _lowerFlatOwn.bind(null, 0), align32: 4, },{ discriminant: 1, tag: 'closed', lowerFn: null, align32: null, },] }), align32: 4 },])],
     getCallbackFn: () => null,
     getPostReturnFn: () => null,
     isCancellable: false,
@@ -7549,7 +7822,7 @@ GlobalComponentAsyncLowers.define({
     trampolineIdx: 26,
     componentIdx: 0,
     isAsync: false,
-    paramLiftFns: [_liftFlatOwn.bind(null, 2)],
+    paramLiftFns: [_liftFlatBorrow.bind(null, 2)],
     metadata: lowered_import_19_metadata,
     resultLowerFns: [_lowerFlatResult([{ discriminant: 0, tag: 'ok', lowerFn: _lowerFlatU64, align32: 8 },{ discriminant: 1, tag: 'error', lowerFn: _lowerFlatVariant({ discriminantSizeBytes: 1, lowerMetas: [{ discriminant: 0, tag: 'last-operation-failed', lowerFn: _lowerFlatOwn.bind(null, 0), align32: 4, },{ discriminant: 1, tag: 'closed', lowerFn: null, align32: null, },] }), align32: 4 },])],
     getCallbackFn: () => null,
@@ -7572,7 +7845,7 @@ GlobalComponentAsyncLowers.define({
     trampolineIdx: 27,
     componentIdx: 0,
     isAsync: false,
-    paramLiftFns: [_liftFlatOwn.bind(null, 2),_liftFlatList.bind(null, 1)],
+    paramLiftFns: [_liftFlatBorrow.bind(null, 2),_liftFlatList.bind(null, 1)],
     metadata: lowered_import_20_metadata,
     resultLowerFns: [_lowerFlatResult([{ discriminant: 0, tag: 'ok', lowerFn: null, align32: null },{ discriminant: 1, tag: 'error', lowerFn: _lowerFlatVariant({ discriminantSizeBytes: 1, lowerMetas: [{ discriminant: 0, tag: 'last-operation-failed', lowerFn: _lowerFlatOwn.bind(null, 0), align32: 4, },{ discriminant: 1, tag: 'closed', lowerFn: null, align32: null, },] }), align32: 4 },])],
     getCallbackFn: () => null,
@@ -7595,7 +7868,7 @@ GlobalComponentAsyncLowers.define({
     trampolineIdx: 28,
     componentIdx: 0,
     isAsync: false,
-    paramLiftFns: [_liftFlatOwn.bind(null, 2),_liftFlatList.bind(null, 1)],
+    paramLiftFns: [_liftFlatBorrow.bind(null, 2),_liftFlatList.bind(null, 1)],
     metadata: lowered_import_21_metadata,
     resultLowerFns: [_lowerFlatResult([{ discriminant: 0, tag: 'ok', lowerFn: null, align32: null },{ discriminant: 1, tag: 'error', lowerFn: _lowerFlatVariant({ discriminantSizeBytes: 1, lowerMetas: [{ discriminant: 0, tag: 'last-operation-failed', lowerFn: _lowerFlatOwn.bind(null, 0), align32: 4, },{ discriminant: 1, tag: 'closed', lowerFn: null, align32: null, },] }), align32: 4 },])],
     getCallbackFn: () => null,
@@ -7618,7 +7891,7 @@ GlobalComponentAsyncLowers.define({
     trampolineIdx: 29,
     componentIdx: 0,
     isAsync: false,
-    paramLiftFns: [_liftFlatOwn.bind(null, 2)],
+    paramLiftFns: [_liftFlatBorrow.bind(null, 2)],
     metadata: lowered_import_22_metadata,
     resultLowerFns: [_lowerFlatResult([{ discriminant: 0, tag: 'ok', lowerFn: null, align32: null },{ discriminant: 1, tag: 'error', lowerFn: _lowerFlatVariant({ discriminantSizeBytes: 1, lowerMetas: [{ discriminant: 0, tag: 'last-operation-failed', lowerFn: _lowerFlatOwn.bind(null, 0), align32: 4, },{ discriminant: 1, tag: 'closed', lowerFn: null, align32: null, },] }), align32: 4 },])],
     getCallbackFn: () => null,
@@ -7643,7 +7916,7 @@ GlobalComponentAsyncLowers.define({
     isAsync: false,
     paramLiftFns: [_liftFlatU64],
     metadata: lowered_import_23_metadata,
-    resultLowerFns: [_lowerFlatList.bind(null, 1)],
+    resultLowerFns: [_lowerFlatList({ elemLowerFn: _lowerFlatU8, typeIdx: 1 })],
     getCallbackFn: () => null,
     getPostReturnFn: () => null,
     isCancellable: false,
@@ -7666,7 +7939,7 @@ GlobalComponentAsyncLowers.define({
     isAsync: false,
     paramLiftFns: [],
     metadata: lowered_import_24_metadata,
-    resultLowerFns: [_lowerFlatList.bind(null, 2)],
+    resultLowerFns: [_lowerFlatList({ elemLowerFn: _lowerFlatTuple.bind(null, 29), typeIdx: 2 })],
     getCallbackFn: () => null,
     getPostReturnFn: () => null,
     isCancellable: false,
@@ -7754,8 +8027,24 @@ function generate(arg0, arg1) {
   var val1 = arg0;
   var len1 = val1.byteLength;
   var ptr1 = realloc1(0, 0, 1, len1 * 1);
-  var src1 = new Uint8Array(val1.buffer || val1, val1.byteOffset, len1 * 1);
-  (new Uint8Array(memory0.buffer, ptr1, len1 * 1)).set(src1);
+  
+  let valData1;
+  const valLenBytes1 = len1 * 1;
+  if (Array.isArray(val1)) {
+    // Regular array likely containing numbers, write values to memory
+    let offset = 0;
+    const dv1 = new DataView(memory0.buffer);
+    for (const v of val1) {
+      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);
+    out1.set(valData1);
+  }
+  
   dataView(memory0).setUint32(ptr0 + 4, len1, true);
   dataView(memory0).setUint32(ptr0 + 0, ptr1, true);
   var {name: v2_0, noTypescript: v2_1, instantiation: v2_2, importBindings: v2_3, map: v2_4, compat: v2_5, noNodejsCompat: v2_6, base64Cutoff: v2_7, tlaCompat: v2_8, validLiftingOptimization: v2_9, tracing: v2_10, noNamespacedExports: v2_11, guest: v2_12, multiMemory: v2_13, asyncMode: v2_14 } = arg1;
@@ -8127,8 +8416,24 @@ function generateTypes(arg0, arg1) {
       var val4 = e;
       var len4 = val4.byteLength;
       var ptr4 = realloc1(0, 0, 1, len4 * 1);
-      var src4 = new Uint8Array(val4.buffer || val4, val4.byteOffset, len4 * 1);
-      (new Uint8Array(memory0.buffer, ptr4, len4 * 1)).set(src4);
+      
+      let valData4;
+      const valLenBytes4 = len4 * 1;
+      if (Array.isArray(val4)) {
+        // Regular array likely containing numbers, write values to memory
+        let offset = 0;
+        const dv4 = new DataView(memory0.buffer);
+        for (const v of val4) {
+          dv4.setUint8(ptr4+ offset, v, true);
+          offset += 1;
+        }
+      } else {
+        // TypedArray / ArrayBuffer-like, direct copy
+        valData4 = new Uint8Array(val4.buffer || val4, val4.byteOffset, valLenBytes4);
+        const out4 = new Uint8Array(memory0.buffer, ptr4,valLenBytes4);
+        out4.set(valData4);
+      }
+      
       dataView(memory0).setUint32(ptr0 + 16, len4, true);
       dataView(memory0).setUint32(ptr0 + 12, ptr4, true);
       break;