nginx-lint-plugin 0.10.1 → 0.10.2

package/wasm/parser/parser.js

@@ -1,115 +1,150 @@
 "use jco";
 
+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 };
+  }
+}
+
 const _debugLog = (...args) => {
   if (!globalThis?.process?.env?.JCO_DEBUG) { return; }
   console.debug(...args);
-}
+};
 const ASYNC_DETERMINISM = 'random';
+const GLOBAL_COMPONENT_MEMORY_MAP = new Map();
+const CURRENT_TASK_META = {};
 
-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);
+function _getGlobalCurrentTaskMeta(componentIdx) {
+  const v = CURRENT_TASK_META[componentIdx];
+  if (v === undefined) { return v; }
+  return { ...v };
+}
+
+function _setGlobalCurrentTaskMeta(args) {
+  if (!args) { throw new TypeError('args missing'); }
+  if (args.taskID === undefined) { throw new TypeError('missing task ID'); }
+  if (args.componentIdx === undefined) { throw new TypeError('missing component idx'); }
+  const { taskID, componentIdx } = args;
+  return CURRENT_TASK_META[componentIdx] = { taskID, componentIdx };
+}
+
+function _withGlobalCurrentTaskMeta(args) {
+  _debugLog('[_withGlobalCurrentTaskMeta()] args', args);
+  if (!args) { throw new TypeError('args missing'); }
+  if (args.taskID === undefined) { throw new TypeError('missing task ID'); }
+  if (args.componentIdx === undefined) { throw new TypeError('missing component idx'); }
+  if (!args.fn) { throw new TypeError('missing fn'); }
+  const { taskID, componentIdx, fn } = args;
+  
+  try {
+    CURRENT_TASK_META[componentIdx] = { taskID, componentIdx };
+    return fn();
+  } catch (err) {
+    _debugLog("error while executing sync callee/callback", {
+      ...args,
+      err,
+    });
+    throw err;
+  } finally {
+    CURRENT_TASK_META[componentIdx] = null;
+  }
+}
+
+async function _withGlobalCurrentTaskMetaAsync(args) {
+  _debugLog('[_withGlobalCurrentTaskMetaAsync()] args', args);
+  if (!args) { throw new TypeError('args missing'); }
+  if (args.taskID === undefined) { throw new TypeError('missing task ID'); }
+  if (args.componentIdx === undefined) { throw new TypeError('missing component idx'); }
+  if (!args.fn) { throw new TypeError('missing fn'); }
+  const { taskID, componentIdx, fn } = args;
+  
+  // If there is already an async task executing, we must wait for it
+  // to complete before we can can run the closure we were given
+  //
+  let current = CURRENT_TASK_META[componentIdx];
+  let cstate;
+  if (current && current.taskID !== taskID) {
+    cstate = getOrCreateAsyncState(componentIdx);
+    while (current && current.taskID !== taskID) {
+      const { promise, resolve } = Promise.withResolvers();
+      cstate.onNextExclusiveRelease(resolve);
+      await promise;
+      current = CURRENT_TASK_META[componentIdx];
     }
     
-    inner.set(qualifiedImportFn, fn);
+    // Since we've just waited for the component to not be locked, re-lock
+    // exclusivity so we can run the fn below (likely a callee/callback)
+    cstate.exclusiveLock();
   }
   
-  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);
-    };
+  try {
+    CURRENT_TASK_META[componentIdx] = { taskID, componentIdx };
+    return await fn();
+  } catch (err) {
+    _debugLog("error while executing async callee/callback", {
+      ...args,
+      err,
+    });
+    throw err;
+  } finally {
+    CURRENT_TASK_META[componentIdx] = null;
   }
 }
 
-class GlobalAsyncParamLowers {
-  static map = new Map();
+async function _clearCurrentTask(args) {
+  _debugLog('[_clearCurrentTask()] args', args);
+  if (!args) { throw new TypeError('args missing'); }
+  if (args.taskID === undefined) { throw new TypeError('missing task ID'); }
+  if (args.componentIdx === undefined) { throw new TypeError('missing component idx'); }
+  const { taskID, componentIdx } = args;
   
-  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 meta = CURRENT_TASK_META[componentIdx];
+  if (!meta) { throw new Error(`missing current task meta for component idx [${componentIdx}]`); }
   
-  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);
+  if (meta.taskID !== taskID) {
+    throw new Error(`task ID [${meta.taskID}] != requested ID [${taskID}]`);
   }
-  
-  static lookup(args) {
-    const { componentIdx, iface, fnName } = args;
-    const key = GlobalAsyncParamLowers.generateKey(args);
-    return GlobalAsyncParamLowers.map.get(key);
+  if (meta.componentIdx !== componentIdx) {
+    throw new Error(`component idx [${meta.componentIdx}] != requested idx [${componentIdx}]`);
   }
+  
+  CURRENT_TASK_META[componentIdx] = null;
 }
 
-class GlobalComponentMemories {
-  static map = new Map();
+function lookupMemoriesForComponent(args) {
+  const { componentIdx } = args ?? {};
+  if (args.componentIdx === undefined) { throw new TypeError("missing component idx"); }
   
-  constructor() { throw new Error('GlobalComponentMemories should not be constructed'); }
+  const metas = GLOBAL_COMPONENT_MEMORY_MAP.get(componentIdx);
+  if (!metas) { return []; }
   
-  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 (args.memoryIdx === undefined) {
+    return Object.values(metas);
   }
   
-  static getMemoriesForComponentIdx(componentIdx) {
-    const metas = GlobalComponentMemories.map.get(componentIdx);
-    return metas.map(meta => meta.memory);
+  const meta = metas[args.memoryIdx];
+  return meta?.memory;
+}
+
+function registerGlobalMemoryForComponent(args) {
+  const { componentIdx, memory, memoryIdx } = args ?? {};
+  if (componentIdx === undefined) { throw new TypeError('missing component idx'); }
+  if (memory === undefined && memoryIdx === undefined) { throw new TypeError('missing both memory & memory idx'); }
+  let inner = GLOBAL_COMPONENT_MEMORY_MAP.get(componentIdx);
+  if (!inner) {
+    inner = {};
+    GLOBAL_COMPONENT_MEMORY_MAP.set(componentIdx, inner);
   }
   
-  static getMemory(componentIdx, idx) {
-    const metas = GlobalComponentMemories.map.get(componentIdx);
-    return metas.find(meta => meta.idx === idx)?.memory;
-  }
+  inner[memoryIdx] = { memory, memoryIdx, componentIdx };
 }
 
 class RepTable {
@@ -120,23 +155,30 @@ class RepTable {
     this.target = args?.target;
   }
   
+  data() { return this.#data; }
+  
   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;
+      const rep = (this.#data.length >> 1) - 1;
+      _debugLog('[RepTable#insert()] inserted', { val, target: this.target, rep });
+      return rep;
     }
     this.#data[0] = this.#data[freeIdx << 1];
     const placementIdx = freeIdx << 1;
     this.#data[placementIdx] = val;
     this.#data[placementIdx + 1] = null;
+    _debugLog('[RepTable#insert()] inserted', { val, target: this.target, rep: freeIdx });
     return freeIdx;
   }
   
   get(rep) {
     _debugLog('[RepTable#get()] args', { rep, target: this.target });
+    if (rep === 0) { throw new Error('invalid resource rep during get, (cannot be 0)'); }
+    
     const baseIdx = rep << 1;
     const val = this.#data[baseIdx];
     return val;
@@ -144,17 +186,19 @@ class RepTable {
   
   contains(rep) {
     _debugLog('[RepTable#contains()] args', { rep, target: this.target });
+    if (rep === 0) { throw new Error('invalid resource rep during contains, (cannot be 0)'); }
+    
     const baseIdx = rep << 1;
     return !!this.#data[baseIdx];
   }
   
   remove(rep) {
     _debugLog('[RepTable#remove()] args', { rep, target: this.target });
+    if (rep === 0) { throw new Error('invalid resource rep during remove, (cannot be 0)'); }
     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;
@@ -178,11 +222,41 @@ const _typeCheckAsyncFn= (f) => {
 };
 
 const ASYNC_FN_CTOR = (async () => {}).constructor;
+
+function clearCurrentTask(componentIdx, taskID) {
+  _debugLog('[clearCurrentTask()] args', { componentIdx, taskID });
+  
+  if (componentIdx === undefined || componentIdx === null) {
+    throw new Error('missing/invalid component instance index while ending current task');
+  }
+  
+  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 tasks for component instance [${componentIdx}] while ending task`);
+  }
+  
+  if (taskID !== undefined) {
+    const last = tasks[tasks.length - 1];
+    if (last.id !== taskID) {
+      // throw new Error('current task does not match expected task ID');
+      return;
+    }
+  }
+  
+  ASYNC_CURRENT_TASK_IDS.pop();
+  ASYNC_CURRENT_COMPONENT_IDXS.pop();
+  
+  const taskMeta = tasks.pop();
+  return taskMeta.task;
+}
+const CURRENT_TASK_MAY_BLOCK = new WebAssembly.Global({ value: 'i32', mutable: true }, 0);
 const ASYNC_CURRENT_TASK_IDS = [];
 const ASYNC_CURRENT_COMPONENT_IDXS = [];
 
 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) {
@@ -194,17 +268,345 @@ function unpackCallbackResult(result) {
   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;
+class AsyncSubtask {
+  static _ID = 0n;
+  
+  static State = {
+    STARTING: 0,
+    STARTED: 1,
+    RETURNED: 2,
+    CANCELLED_BEFORE_STARTED: 3,
+    CANCELLED_BEFORE_RETURNED: 4,
+  };
+  
+  #id;
+  #state = AsyncSubtask.State.STARTING;
+  #componentIdx;
+  
+  #parentTask;
+  #childTask = null;
+  
+  #dropped = false;
+  #cancelRequested = false;
+  
+  #memoryIdx = null;
+  #lenders = null;
+  
+  #waitable = null;
+  
+  #callbackFn = null;
+  #callbackFnName = null;
+  
+  #postReturnFn = null;
+  #onProgressFn = null;
+  #pendingEventFn = null;
+  
+  #callMetadata = {};
+  
+  #resolved = false;
+  
+  #onResolveHandlers = [];
+  #onStartHandlers = [];
+  
+  #result = null;
+  #resultSet = false;
+  
+  fnName;
+  target;
+  isAsync;
+  isManualAsync;
+  
+  constructor(args) {
+    if (typeof args.componentIdx !== 'number') {
+      throw new Error('invalid componentIdx for subtask creation');
+    }
+    this.#componentIdx = args.componentIdx;
+    
+    this.#id = ++AsyncSubtask._ID;
+    this.fnName = args.fnName;
+    
+    if (!args.parentTask) { throw new Error('missing parent task during subtask creation'); }
+    this.#parentTask = args.parentTask;
+    
+    if (args.childTask) { this.#childTask = args.childTask; }
+    
+    if (args.memoryIdx) { this.#memoryIdx = args.memoryIdx; }
+    
+    if (!args.waitable) { throw new Error("missing/invalid waitable"); }
+    this.#waitable = args.waitable;
+    
+    if (args.callMetadata) { this.#callMetadata = args.callMetadata; }
+    
+    this.#lenders = [];
+    this.target = args.target;
+    this.isAsync = args.isAsync;
+    this.isManualAsync = args.isManualAsync;
+  }
+  
+  id() { return this.#id; }
+  parentTaskID() { return this.#parentTask?.id(); }
+  childTaskID() { return this.#childTask?.id(); }
+  state() { return this.#state; }
+  
+  waitable() { return this.#waitable; }
+  waitableRep() { return this.#waitable.idx(); }
+  
+  join() { return this.#waitable.join(...arguments); }
+  getPendingEvent() { return this.#waitable.getPendingEvent(...arguments); }
+  hasPendingEvent() { return this.#waitable.hasPendingEvent(...arguments); }
+  setPendingEvent() { return this.#waitable.setPendingEvent(...arguments); }
+  
+  setTarget(tgt) { this.target = tgt; }
+  
+  getResult() {
+    if (!this.#resultSet) { throw new Error("subtask result has not been set") }
+    return this.#result;
+  }
+  setResult(v) {
+    if (this.#resultSet) { throw new Error("subtask result has already been set"); }
+    this.#result = v;
+    this.#resultSet = true;
+  }
+  
+  componentIdx() { return this.#componentIdx; }
+  
+  setChildTask(t) {
+    if (!t) { throw new Error('cannot set missing/invalid child task on subtask'); }
+    if (this.#childTask) { throw new Error('child task is already set on subtask'); }
+    if (this.#parentTask === t) { throw new Error("parent cannot be child"); }
+    this.#childTask = t;
+  }
+  getChildTask(t) { return this.#childTask; }
+  
+  getParentTask() { return this.#parentTask; }
+  
+  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.#callbackFn) { return undefined; }
+    return this.#callbackFn.name;
+  }
+  
+  setPostReturnFn(f) {
+    if (!f) { return; }
+    if (this.#postReturnFn) { throw new Error('postReturn fn can only be set once'); }
+    this.#postReturnFn = f;
+  }
+  
+  setOnProgressFn(f) {
+    if (this.#onProgressFn) { throw new Error('on progress fn can only be set once'); }
+    this.#onProgressFn = f;
+  }
+  
+  isNotStarted() {
+    return this.#state == AsyncSubtask.State.STARTING;
+  }
+  
+  registerOnStartHandler(f) {
+    this.#onStartHandlers.push(f);
+  }
+  
+  onStart(args) {
+    _debugLog('[AsyncSubtask#onStart()] args', {
+      componentIdx: this.#componentIdx,
+      subtaskID: this.#id,
+      parentTaskID: this.parentTaskID(),
+      fnName: this.fnName,
     });
-    return { promise, resolve, reject };
+    
+    if (this.#onProgressFn) { this.#onProgressFn(); }
+    
+    this.#state = AsyncSubtask.State.STARTED;
+    
+    let result;
+    
+    // If we have been provided a helper start function as a result of
+    // component fusion performed by wasmtime tooling, then we can call that helper and lifts/lowers will
+    // be performed for us.
+    //
+    // See also documentation on `HostIntrinsic::PrepareCall`
+    //
+    if (this.#callMetadata.startFn) {
+      result = this.#callMetadata.startFn.apply(null, args?.startFnParams ?? []);
+    }
+    
+    return result;
+  }
+  
+  
+  registerOnResolveHandler(f) {
+    this.#onResolveHandlers.push(f);
+  }
+  
+  reject(subtaskErr) {
+    this.#childTask?.reject(subtaskErr);
+  }
+  
+  onResolve(subtaskValue) {
+    _debugLog('[AsyncSubtask#onResolve()] args', {
+      componentIdx: this.#componentIdx,
+      subtaskID: this.#id,
+      isAsync: this.isAsync,
+      childTaskID: this.childTaskID(),
+      parentTaskID: this.parentTaskID(),
+      parentTaskFnName: this.#parentTask?.entryFnName(),
+      fnName: this.fnName,
+    });
+    
+    if (this.#resolved) {
+      throw new Error('subtask has already been resolved');
+    }
+    
+    if (this.#onProgressFn) { this.#onProgressFn(); }
+    
+    if (subtaskValue === null) {
+      if (this.#cancelRequested) {
+        throw new Error('cancel was not requested, but no value present at return');
+      }
+      
+      if (this.#state === AsyncSubtask.State.STARTING) {
+        this.#state = AsyncSubtask.State.CANCELLED_BEFORE_STARTED;
+      } else {
+        if (this.#state !== AsyncSubtask.State.STARTED) {
+          throw new Error('resolved subtask must have been started before cancellation');
+        }
+        this.#state = AsyncSubtask.State.CANCELLED_BEFORE_RETURNED;
+      }
+    } else {
+      if (this.#state !== AsyncSubtask.State.STARTED) {
+        throw new Error('resolved subtask must have been started before completion');
+      }
+      this.#state = AsyncSubtask.State.RETURNED;
+    }
+    
+    this.setResult(subtaskValue);
+    
+    for (const f of this.#onResolveHandlers) {
+      try {
+        f(subtaskValue);
+      } catch (err) {
+        console.error("error during subtask resolve handler", err);
+        throw err;
+      }
+    }
+    
+    const callMetadata = this.getCallMetadata();
+    
+    // TODO(fix): we should be able to easily have the caller's meomry
+    // to lower into here, but it's not present in PrepareCall
+    const memory = callMetadata.memory ?? this.#parentTask?.getReturnMemory() ?? lookupMemoriesForComponent({ componentIdx: this.#parentTask?.componentIdx() })[0];
+    if (callMetadata && !callMetadata.returnFn && this.isAsync && callMetadata.resultPtr && memory) {
+      const { resultPtr, realloc } = callMetadata;
+      const lowers = callMetadata.lowers; // may have been updated in task.return of the child
+      if (lowers && lowers.length > 0) {
+        lowers[0]({
+          componentIdx: this.#componentIdx,
+          memory,
+          realloc,
+          vals: [subtaskValue],
+          storagePtr: resultPtr,
+        });
+      }
+    }
+    
+    this.#resolved = true;
+    this.#parentTask.removeSubtask(this);
+  }
+  
+  getStateNumber() { return this.#state; }
+  isReturned() { return this.#state === AsyncSubtask.State.RETURNED; }
+  
+  getCallMetadata() { return this.#callMetadata; }
+  
+  isResolved() {
+    if (this.#state === AsyncSubtask.State.STARTING
+    || this.#state === AsyncSubtask.State.STARTED) {
+      return false;
+    }
+    if (this.#state === AsyncSubtask.State.RETURNED
+    || this.#state === AsyncSubtask.State.CANCELLED_BEFORE_STARTED
+    || this.#state === AsyncSubtask.State.CANCELLED_BEFORE_RETURNED) {
+      return true;
+    }
+    throw new Error('unrecognized internal Subtask state [' + this.#state + ']');
+  }
+  
+  addLender(handle) {
+    _debugLog('[AsyncSubtask#addLender()] args', { handle });
+    if (!Number.isNumber(handle)) { throw new Error('missing/invalid lender handle [' + handle + ']'); }
+    
+    if (this.#lenders.length === 0 || this.isResolved()) {
+      throw new Error('subtask has no lendors or has already been resolved');
+    }
+    
+    handle.lends++;
+    this.#lenders.push(handle);
+  }
+  
+  deliverResolve() {
+    _debugLog('[AsyncSubtask#deliverResolve()] args', {
+      lenders: this.#lenders,
+      parentTaskID: this.parentTaskID(),
+      subtaskID: this.#id,
+      childTaskID: this.childTaskID(),
+      resolved: this.isResolved(),
+      resolveDelivered: this.resolveDelivered(),
+    });
+    
+    const cannotDeliverResolve = this.resolveDelivered() || !this.isResolved();
+    if (cannotDeliverResolve) {
+      throw new Error('subtask cannot deliver resolution twice, and the subtask must be resolved');
+    }
+    
+    for (const lender of this.#lenders) {
+      lender.lends--;
+    }
+    
+    this.#lenders = null;
+  }
+  
+  resolveDelivered() {
+    _debugLog('[AsyncSubtask#resolveDelivered()] args', { });
+    if (this.#lenders === null && !this.isResolved()) {
+      throw new Error('invalid subtask state, lenders missing and subtask has not been resolved');
+    }
+    return this.#lenders === null;
+  }
+  
+  drop() {
+    _debugLog('[AsyncSubtask#drop()] args', {
+      componentIdx: this.#componentIdx,
+      parentTaskID: this.#parentTask?.id(),
+      parentTaskFnName: this.#parentTask?.entryFnName(),
+      childTaskID: this.#childTask?.id(),
+      childTaskFnName: this.#childTask?.entryFnName(),
+      subtaskFnName: this.fnName,
+    });
+    if (!this.#waitable) { throw new Error('missing/invalid inner waitable'); }
+    if (!this.resolveDelivered()) {
+      throw new Error('cannot drop subtask before resolve is delivered');
+    }
+    if (this.#waitable) { this.#waitable.drop() }
+    this.#dropped = true;
+  }
+  
+  #getComponentState() {
+    const state = getOrCreateAsyncState(this.#componentIdx);
+    if (!state) {
+      throw new Error('invalid/missing async state for component [' + componentIdx + ']');
+    }
+    return state;
+  }
+  
+  getWaitableHandleIdx() {
+    _debugLog('[AsyncSubtask#getWaitableHandleIdx()] args', { });
+    if (!this.#waitable) { throw new Error('missing/invalid waitable'); }
+    return this.waitableRep();
   }
 }
 
@@ -213,46 +615,40 @@ memoryIdx,
 getMemoryFn,
 startFn,
 returnFn,
-callerInstanceIdx,
-calleeInstanceIdx,
+callerComponentIdx,
+calleeComponentIdx,
 taskReturnTypeIdx,
-isCalleeAsyncInt,
+calleeIsAsyncInt,
 stringEncoding,
 resultCountOrAsync,
 ) {
   _debugLog('[_prepareCall()]', {
-    callerInstanceIdx,
-    calleeInstanceIdx,
+    memoryIdx,
+    callerComponentIdx,
+    calleeComponentIdx,
     taskReturnTypeIdx,
-    isCalleeAsyncInt,
+    calleeIsAsyncInt,
     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
+  // value passed in *may* be as large as u32::MAX which may be mangled into -2
+  resultCountOrAsync >>>= 0;
+  
   let isAsync = false;
   let hasResultPointer = false;
-  if (resultCountOrAsync === -1) {
+  if (resultCountOrAsync === 2**32 - 1) {
+    // prepare async with no result (u32::MAX)
     isAsync = true;
     hasResultPointer = false;
-  } else if (resultCountOrAsync === -2) {
+  } else if (resultCountOrAsync === 2**32 - 2) {
+    // prepare async with result (u32::MAX - 1)
     isAsync = true;
     hasResultPointer = true;
   }
   
-  const currentCallerTaskMeta = getCurrentTask(callerInstanceIdx);
+  const currentCallerTaskMeta = getCurrentTask(callerComponentIdx);
   if (!currentCallerTaskMeta) {
     throw new Error('invalid/missing current task for caller during prepare call');
   }
@@ -262,18 +658,19 @@ resultCountOrAsync,
     throw new Error('unexpectedly missing task in meta for caller during prepare call');
   }
   
-  if (currentCallerTask.componentIdx() !== callerInstanceIdx) {
-    throw new Error(`task component idx [${ currentCallerTask.componentIdx() }] !== [${ callerInstanceIdx }] (callee ${ calleeInstanceIdx })`);
+  if (currentCallerTask.componentIdx() !== callerComponentIdx) {
+    throw new Error(`task component idx [${ currentCallerTask.componentIdx() }] !== [${ callerComponentIdx }] (callee ${ calleeComponentIdx })`);
   }
   
   let getCalleeParamsFn;
   let resultPtr = null;
+  let directParamsArr;
   if (hasResultPointer) {
-    const directParamsArr = argArray.slice(11);
+    directParamsArr = argArray.slice(10, argArray.length - 1);
     getCalleeParamsFn = () => directParamsArr;
-    resultPtr = argArray[10];
+    resultPtr = argArray[argArray.length - 1];
   } else {
-    const directParamsArr = argArray.slice(10);
+    directParamsArr = argArray.slice(10);
     getCalleeParamsFn = () => directParamsArr;
   }
   
@@ -292,21 +689,12 @@ resultCountOrAsync,
     throw new Error(`unrecognized string encoding enum [${stringEncoding}]`);
   }
   
-  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,
-  });
-  
   const subtask = currentCallerTask.createSubtask({
-    componentIdx: callerInstanceIdx,
+    componentIdx: callerComponentIdx,
     parentTask: currentCallerTask,
-    childTask: newTask,
+    isAsync,
     callMetadata: {
-      memory: getMemoryFn(),
+      getMemoryFn,
       memoryIdx,
       resultPtr,
       returnFn,
@@ -314,26 +702,75 @@ resultCountOrAsync,
     }
   });
   
+  const [newTask, newTaskID] = createNewCurrentTask({
+    componentIdx: calleeComponentIdx,
+    isAsync,
+    getCalleeParamsFn,
+    entryFnName: [
+    'task',
+    subtask.getParentTask().id(),
+    'subtask',
+    subtask.id(),
+    'new-prepared-async-task'
+    ].join('/'),
+    stringEncoding,
+  });
   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);
+  newTask.setReturnMemory(getMemoryFn);
+  subtask.setChildTask(newTask);
+  
+  newTask.subtaskMeta = {
+    subtask,
+    calleeComponentIdx,
+    callerComponentIdx,
+    getCalleeParamsFn,
+    stringEncoding,
+    isAsync,
+  };
+  
+  _setGlobalCurrentTaskMeta({
+    taskID: newTask.id(),
+    componentIdx: newTask.componentIdx(),
+  });
 }
 
 function _asyncStartCall(args, callee, paramCount, resultCount, flags) {
-  const { getCallbackFn, callbackIdx, getPostReturnFn, postReturnIdx } = args;
-  _debugLog('[_asyncStartCall()] args', args);
+  const componentIdx = ASYNC_CURRENT_COMPONENT_IDXS.at(-1);
   
-  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'); }
+  const globalTaskMeta = _getGlobalCurrentTaskMeta(componentIdx);
+  if (!globalTaskMeta) { throw new Error('missing global current task globalTaskMeta'); }
+  const taskID = globalTaskMeta.taskID;
   
-  const argArray = [...arguments];
+  _debugLog('[_asyncStartCall()] args', { args, componentIdx });
+  const { getCallbackFn, callbackIdx, getPostReturnFn, postReturnIdx } = args;
   
-  // 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'); }
+  const preparedTaskMeta = getCurrentTask(componentIdx, taskID);
+  if (!preparedTaskMeta) { throw new Error('unexpectedly missing current task'); }
+  
+  const preparedTask = preparedTaskMeta.task;
+  if (!preparedTask) { throw new Error('unexpectedly missing current task'); }
+  if (!preparedTask.subtaskMeta) { throw new Error('missing subtask meta from prepare'); }
+  
+  const {
+    subtask,
+    returnMemoryIdx,
+    getReturnMemoryFn,
+    callerComponentIdx,
+    calleeComponentIdx,
+    getCalleeParamsFn,
+    isAsync,
+    stringEncoding,
+  } = preparedTask.subtaskMeta;
+  if (!subtask) { throw new Error("missing subtask from cstate during async start call"); }
+  if (calleeComponentIdx !== preparedTask.componentIdx()) {
+    throw new Error(`meta callee idx [${calleeComponentIdx}] != current task idx [${preparedTask.componentIdx()}] during async start call`);
+  }
+  if (calleeComponentIdx !== componentIdx) {
+    throw new Error("mismatched componentIdx for async start call (does not match prepare)");
+  }
+  
+  const argArray = [...arguments];
   
   if (resultCount < 0 || resultCount > 1) { throw new Error('invalid/unsupported result count'); }
   
@@ -342,34 +779,16 @@ function _asyncStartCall(args, callee, paramCount, resultCount, flags) {
   preparedTask.setCallbackFn(callbackFn, callbackFnName);
   preparedTask.setPostReturnFn(getPostReturnFn());
   
-  const subtask = preparedTask.getParentSubtask();
-  
-  if (resultCount < 0 || resultCount > 1) { throw new Error(`unsupported result count [${ resultCount }]`); }
+  if (resultCount < 0 || resultCount > 1) {
+    throw new Error(`unsupported result count [${ resultCount }]`);
+  }
   
   const params = preparedTask.getCalleeParams();
   if (paramCount !== params.length) {
     throw new Error(`unexpected callee param count [${ params.length }], _asyncStartCall invocation expected [${ paramCount }]`);
   }
   
-  subtask.setOnProgressFn(() => {
-    subtask.setPendingEventFn(() => {
-      if (subtask.resolved()) { subtask.deliverResolve(); }
-      return {
-        code: ASYNC_EVENT_CODE.SUBTASK,
-        index: rep,
-        result: subtask.getStateNumber(),
-      }
-    });
-  });
-  
-  const subtaskState = subtask.getStateNumber();
-  if (subtaskState < 0 || subtaskState > 2**5) {
-    throw new Error('invalid subtask state, out of valid range');
-  }
-  
   const callerComponentState = getOrCreateAsyncState(subtask.componentIdx());
-  const rep = callerComponentState.subtasks.insert(subtask);
-  subtask.setRep(rep);
   
   const calleeComponentState = getOrCreateAsyncState(preparedTask.componentIdx());
   const calleeBackpressure = calleeComponentState.hasBackpressure();
@@ -380,6 +799,7 @@ function _asyncStartCall(args, callee, paramCount, resultCount, flags) {
   // 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,
@@ -397,8 +817,13 @@ function _asyncStartCall(args, callee, paramCount, resultCount, flags) {
     
     // 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)');
+    if (subtaskCallMeta && subtaskCallMeta.returnFn) {
+      _debugLog('[_asyncStartCall()] return function present while handling subtask result, returning early (skipping lower)');
+      
+      // TODO: centralize calling of returnFn to *one place* (if possible)
+      if (subtaskCallMeta.returnFnCalled) { return; }
+      
+      subtaskCallMeta.returnFn.apply(null, [subtaskCallMeta.resultPtr]);
       return;
     }
     
@@ -409,27 +834,31 @@ function _asyncStartCall(args, callee, paramCount, resultCount, flags) {
     }
     
     let callerMemory;
-    if (callerMemoryIdx) {
-      callerMemory = GlobalComponentMemories.getMemory(callerComponentIdx, callerMemoryIdx);
+    if (callerMemoryIdx !== null && callerMemoryIdx !== undefined) {
+      callerMemory = lookupMemoriesForComponent({ componentIdx: callerComponentIdx, memoryIdx: callerMemoryIdx });
     } else {
-      const callerMemories = GlobalComponentMemories.getMemoriesForComponentIdx(callerComponentIdx);
-      if (callerMemories.length != 1) { throw new Error(`unsupported amount of caller memories`); }
+      const callerMemories = lookupMemoriesForComponent({ componentIdx: callerComponentIdx });
+      if (callerMemories.length !== 1) { throw new Error(`unsupported amount of caller memories`); }
       callerMemory = callerMemories[0];
     }
     
     if (!callerMemory) {
+      _debugLog('[_asyncStartCall()] missing memory', { subtaskID: subtask.id(), res });
       throw new Error(`missing memory for to guest->guest call result (subtask [${subtask.id()}])`);
     }
     
     const lowerFns = calleeTask.getReturnLowerFns();
     if (!lowerFns || lowerFns.length === 0) {
-      throw new Error(`missing result lower metadata for guest->guests call (subtask [${subtask.id()}])`);
+      _debugLog('[_asyncStartCall()] missing result lower metadata for guest->guest call', { subtaskID: subtask.id() });
+      throw new Error(`missing result lower metadata for guest->guest call (subtask [${subtask.id()}])`);
     }
     
     if (lowerFns.length !== 1) {
+      _debugLog('[_asyncStartCall()] only single result reportetd for guest->guest call', { subtaskID: subtask.id() });
       throw new Error(`only single result supported for guest->guest calls (subtask [${subtask.id()}])`);
     }
     
+    _debugLog('[_asyncStartCall()] lowering results', { subtaskID: subtask.id() });
     lowerFns[0]({
       realloc: undefined,
       memory: callerMemory,
@@ -440,115 +869,96 @@ function _asyncStartCall(args, callee, paramCount, resultCount, flags) {
     
   });
   
-  // 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);
-  }
-  
-  preparedTask.registerOnResolveHandler((res) => {
-    _debugLog('[_asyncStartCall()] signaling subtask completion due to task completion', {
-      childTaskID: preparedTask.id(),
-      subtaskID: subtask.id(),
-      parentTaskID: subtask.getParentTask().id(),
+  subtask.setOnProgressFn(() => {
+    subtask.setPendingEvent(() => {
+      if (subtask.isResolved()) { subtask.deliverResolve(); }
+      const event = {
+        code: ASYNC_EVENT_CODE.SUBTASK,
+        payload0: subtask.waitableRep(),
+        payload1: subtask.getStateNumber(),
+      };
+      return event;
     });
-    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(),
+  // Start the (event) driver loop that will resolve the task
+  queueMicrotask(async () => {
+    let startRes = subtask.onStart({ startFnParams: params });
+    startRes = Array.isArray(startRes) ? startRes : [startRes];
+    
+    await calleeComponentState.suspendTask({
+      task: preparedTask,
+      readyFn: () => !calleeComponentState.isExclusivelyLocked(),
     });
     
-    // 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;
+    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;
     }
     
-    doSubtaskResolve();
-    return AsyncSubtask.State.RETURNED;
-  }
-  
-  // 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(),
+    let callbackResult;
+    try {
+      let jspiCallee = WebAssembly.promising(callee);
+      callbackResult = await _withGlobalCurrentTaskMetaAsync({
+        taskID: preparedTask.id(),
+        componentIdx: preparedTask.componentIdx(),
+        fn: () => {
+          return jspiCallee.apply(null, startRes);
+        }
       });
+    } catch(err) {
+      _debugLog("[_asyncStartCall()] initial subtask callee run failed", err);
+      // NOTE: a good place to rejectt the parent task, if rejection API is enabled
+      // subtask.reject(err);
+      // subtask.getParentTask().reject(err);
+      
+      subtask.getParentTask().setErrored(err);
+      
       return;
     }
     
-    const started = await preparedTask.enter();
-    if (!started) {
-      _debugLog('[_asyncStartCall()] task failed early', {
+    // If there was no callback function, we're dealing with a sync function
+    // that was lifted as async without one, there is only the callee.
+    if (!callbackFn) {
+      _debugLog("[_asyncStartCall()] no callback, resolving w/ callee result", {
         taskID: preparedTask.id(),
-        subtaskID: subtask.id(),
+        componentIdx: preparedTask.componentIdx(),
+        preparedTask,
+        stateNumber: preparedTask.taskState(),
+        isResolved: preparedTask.isResolved(),
+        callbackFn,
       });
-      throw new Error("task failed to start");
+      preparedTask.resolve([callbackResult]);
       return;
     }
     
-    // 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("");
+    let fnName = callbackFn.fnName;
+    if (!fnName) {
+      fnName = [
+      '<task ',
+      subtask.parentTaskID(),
+      '/subtask ',
+      subtask.id(),
+      '/task ',
+      preparedTask.id(),
+      '>',
+      ].join("");
+    }
     
     try {
-      _debugLog("[_asyncStartCall()] starting driver loop", { fnName, componentIdx: preparedTask.componentIdx(), });
+      _debugLog("[_asyncStartCall()] starting driver loop", {
+        fnName,
+        componentIdx: preparedTask.componentIdx(),
+        subtaskID: subtask.id(),
+        childTaskID: subtask.childTaskID(),
+        parentTaskID: subtask.parentTaskID(),
+      });
+      
       await _driverLoop({
         componentState: calleeComponentState,
         task: preparedTask,
@@ -564,6 +974,18 @@ function _asyncStartCall(args, callee, paramCount, resultCount, flags) {
     
   });
   
+  const subtaskState = subtask.getStateNumber();
+  if (subtaskState < 0 || subtaskState > 2**5) {
+    throw new Error('invalid subtask state, out of valid range');
+  }
+  
+  _debugLog('[_asyncStartCall()] returning subtask rep & state', {
+    subtask: {
+      rep: subtask.waitableRep(),
+      state: subtaskState,
+    }
+  });
+  
   return Number(subtask.waitableRep()) << 4 | subtaskState;
 }
 
@@ -572,612 +994,822 @@ function _syncStartCall(callbackIdx) {
   throw new Error('synchronous start call not implemented!');
 }
 
-let dv = new DataView(new ArrayBuffer());
-const dataView = mem => dv.buffer === mem.buffer ? dv : dv = new DataView(mem.buffer);
-const TEXT_DECODER_UTF8 = new TextDecoder();
-const TEXT_ENCODER_UTF8 = new TextEncoder();
-
-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 };
-}
-
-
-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');
-  }
-  const taskMetas = ASYNC_TASKS_BY_COMPONENT_IDX.get(componentIdx);
-  const callbackFn = getCallbackFn ? getCallbackFn() : null;
+class Waitable {
+  #componentIdx;
   
-  const newTask = new AsyncTask({
-    componentIdx,
-    isAsync,
-    entryFnName,
-    callbackFn,
-    callbackFnName,
-    stringEncoding,
-    getCalleeParamsFn,
-    resultPtr,
-    errHandling,
-  });
+  #pendingEventFn = null;
   
-  const newTaskID = newTask.id();
-  const newTaskMeta = { id: newTaskID, componentIdx, task: newTask };
+  #promise;
+  #resolve;
+  #reject;
   
-  ASYNC_CURRENT_TASK_IDS.push(newTaskID);
-  ASYNC_CURRENT_COMPONENT_IDXS.push(componentIdx);
+  #waitableSet = null;
   
-  if (!taskMetas) {
-    ASYNC_TASKS_BY_COMPONENT_IDX.set(componentIdx, [newTaskMeta]);
-  } else {
-    taskMetas.push(newTaskMeta);
-  }
+  #idx = null; // to component-global waitables
   
-  return [newTask, newTaskID];
-}
-
-function endCurrentTask(componentIdx, taskID) {
-  componentIdx ??= ASYNC_CURRENT_COMPONENT_IDXS.at(-1);
-  taskID ??= ASYNC_CURRENT_TASK_IDS.at(-1);
-  _debugLog('[endCurrentTask()] args', { componentIdx, taskID });
+  target;
   
-  if (componentIdx === undefined || componentIdx === null) {
-    throw new Error('missing/invalid component instance index while ending current task');
+  constructor(args) {
+    const { componentIdx, target } = args;
+    this.#componentIdx = componentIdx;
+    this.target = args.target;
+    this.#resetPromise();
   }
   
-  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');
-  }
+  componentIdx() { return this.#componentIdx; }
+  isInSet() { return this.#waitableSet !== null; }
   
-  if (taskID) {
-    const last = tasks[tasks.length - 1];
-    if (last.id !== taskID) {
-      // throw new Error('current task does not match expected task ID');
-      return;
-    }
+  idx() { return this.#idx; }
+  setIdx(idx) {
+    if (idx === 0) { throw new Error("waitable idx cannot be zero"); }
+    this.#idx = idx;
   }
   
-  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();
-
-class AsyncTask {
-  static _ID = 0n;
-  
-  static State = {
-    INITIAL: 'initial',
-    CANCELLED: 'cancelled',
-    CANCEL_PENDING: 'cancel-pending',
-    CANCEL_DELIVERED: 'cancel-delivered',
-    RESOLVED: 'resolved',
-  }
+  setTarget(tgt) { this.target = tgt; }
   
-  static BlockResult = {
-    CANCELLED: 'block.cancelled',
-    NOT_CANCELLED: 'block.not-cancelled',
+  #resetPromise() {
+    const { promise, resolve, reject } = promiseWithResolvers()
+    this.#promise = promise;
+    this.#resolve = resolve;
+    this.#reject = reject;
   }
   
-  #id;
-  #componentIdx;
-  #state;
-  #isAsync;
-  #entryFnName = null;
-  #subtasks = [];
-  
-  #onResolveHandlers = [];
-  #completionPromise = null;
-  
-  #memoryIdx = null;
-  
-  #callbackFn = null;
-  #callbackFnName = null;
-  
-  #postReturnFn = null;
-  
-  #getCalleeParamsFn = null;
-  
-  #stringEncoding = null;
-  
-  #parentSubtask = null;
+  resolve() { this.#resolve(); }
+  reject(err) { this.#reject(err); }
+  promise() { return this.#promise; }
   
-  #needsExclusiveLock = false;
-  
-  #errHandling;
+  hasPendingEvent() {
+    // _debugLog('[Waitable#hasPendingEvent()]', {
+      //     componentIdx: this.#componentIdx,
+      //     waitable: this,
+      //     waitableSet: this.#waitableSet,
+      //     hasPendingEvent: this.#pendingEventFn !== null,
+      // });
+      return this.#pendingEventFn !== null;
+    }
+    
+    setPendingEvent(fn) {
+      _debugLog('[Waitable#setPendingEvent()] args', {
+        waitable: this,
+        inSet: this.#waitableSet,
+      });
+      this.#pendingEventFn = fn;
+    }
+    
+    getPendingEvent() {
+      _debugLog('[Waitable#getPendingEvent()] args', {
+        waitable: this,
+        inSet: this.#waitableSet,
+        hasPendingEvent: this.#pendingEventFn !== null,
+      });
+      if (this.#pendingEventFn === null) { return null; }
+      const eventFn = this.#pendingEventFn;
+      this.#pendingEventFn = null;
+      const e = eventFn();
+      this.#resetPromise();
+      return e;
+    }
+    
+    join(waitableSet) {
+      _debugLog('[Waitable#join()] args', {
+        waitable: this,
+        waitableSet: waitableSet,
+      });
+      if (this.#waitableSet) { this.#waitableSet.removeWaitable(this); }
+      if (!waitableSet) {
+        this.#waitableSet = null;
+        return;
+      }
+      waitableSet.addWaitable(this);
+      this.#waitableSet = waitableSet;
+    }
+    
+    drop() {
+      _debugLog('[Waitable#drop()] args', {
+        componentIdx: this.#componentIdx,
+        waitable: this,
+      });
+      if (this.hasPendingEvent()) {
+        throw new Error('waitables with pending events cannot be dropped');
+      }
+      this.join(null);
+    }
+    
+  }
   
-  #backpressurePromise;
-  #backpressureWaiters = 0n;
+  const ERR_CTX_TABLES = {};
   
-  #returnLowerFns = null;
+  let dv = new DataView(new ArrayBuffer());
+  const dataView = mem => dv.buffer === mem.buffer ? dv : dv = new DataView(mem.buffer);
+  const TEXT_DECODER_UTF8 = new TextDecoder();
+  const TEXT_ENCODER_UTF8 = new TextEncoder();
   
-  cancelled = false;
-  requested = false;
-  alwaysTaskReturn = false;
+  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);
+    const res = { ptr, len: buf.length, codepoints: [...s].length };
+    return res;
+  }
   
-  returnCalls =  0;
-  storage = [0, 0];
-  borrowedHandles = {};
   
-  awaitableResume = null;
-  awaitableCancel = null;
+  function createNewCurrentTask(args) {
+    _debugLog('[createNewCurrentTask()] args', args);
+    const {
+      componentIdx,
+      isAsync,
+      isManualAsync,
+      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');
+    }
+    let taskMetas = ASYNC_TASKS_BY_COMPONENT_IDX.get(componentIdx);
+    const callbackFn = getCallbackFn ? getCallbackFn() : null;
+    
+    const newTask = new AsyncTask({
+      componentIdx,
+      isAsync,
+      isManualAsync,
+      entryFnName,
+      callbackFn,
+      callbackFnName,
+      stringEncoding,
+      getCalleeParamsFn,
+      resultPtr,
+      errHandling,
+    });
+    
+    const newTaskID = newTask.id();
+    const newTaskMeta = { id: newTaskID, componentIdx, task: newTask };
+    
+    // NOTE: do not track host tasks
+    ASYNC_CURRENT_TASK_IDS.push(newTaskID);
+    ASYNC_CURRENT_COMPONENT_IDXS.push(componentIdx);
+    
+    if (!taskMetas) {
+      taskMetas = [newTaskMeta];
+      ASYNC_TASKS_BY_COMPONENT_IDX.set(componentIdx, [newTaskMeta]);
+    } else {
+      taskMetas.push(newTaskMeta);
+    }
+    
+    return [newTask, newTaskID];
+  }
+  const ASYNC_TASKS_BY_COMPONENT_IDX = new Map();
   
-  constructor(opts) {
-    this.#id = ++AsyncTask._ID;
+  class AsyncTask {
+    static _ID = 0n;
     
-    if (opts?.componentIdx === undefined) {
-      throw new TypeError('missing component id during task creation');
+    static State = {
+      INITIAL: 'initial',
+      CANCELLED: 'cancelled',
+      CANCEL_PENDING: 'cancel-pending',
+      CANCEL_DELIVERED: 'cancel-delivered',
+      RESOLVED: 'resolved',
     }
-    this.#componentIdx = opts.componentIdx;
     
-    this.#state = AsyncTask.State.INITIAL;
-    this.#isAsync = opts?.isAsync ?? false;
-    this.#entryFnName = opts.entryFnName;
+    static BlockResult = {
+      CANCELLED: 'block.cancelled',
+      NOT_CANCELLED: 'block.not-cancelled',
+    }
     
-    const {
-      promise: completionPromise,
-      resolve: resolveCompletionPromise,
-      reject: rejectCompletionPromise,
-    } = promiseWithResolvers();
-    this.#completionPromise = completionPromise;
+    #id;
+    #componentIdx;
+    #state;
+    #isAsync;
+    #isManualAsync;
+    #entryFnName = null;
     
-    this.#onResolveHandlers.push((results) => {
-      resolveCompletionPromise(results);
-    })
+    #onResolveHandlers = [];
+    #completionPromise = null;
+    #rejected = false;
     
-    if (opts.callbackFn) { this.#callbackFn = opts.callbackFn; }
-    if (opts.callbackFnName) { this.#callbackFnName = opts.callbackFnName; }
+    #exitPromise = null;
+    #onExitHandlers = [];
     
-    if (opts.getCalleeParamsFn) { this.#getCalleeParamsFn = opts.getCalleeParamsFn; }
+    #memoryIdx = null;
+    #memory = null;
     
-    if (opts.stringEncoding) { this.#stringEncoding = opts.stringEncoding; }
+    #callbackFn = null;
+    #callbackFnName = null;
     
-    if (opts.parentSubtask) { this.#parentSubtask = opts.parentSubtask; }
+    #postReturnFn = null;
     
-    this.#needsExclusiveLock = this.isSync() || !this.hasCallback();
+    #getCalleeParamsFn = null;
     
-    if (opts.errHandling) { this.#errHandling = opts.errHandling; }
-  }
-  
-  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();
+    #stringEncoding = null;
+    
+    #parentSubtask = null;
+    
+    #needsExclusiveLock = false;
+    
+    #errHandling;
+    
+    #backpressurePromise;
+    #backpressureWaiters = 0n;
+    
+    #returnLowerFns = null;
+    
+    #subtasks = [];
+    
+    #entered = false;
+    #exited = false;
+    #errored = null;
+    
+    cancelled = false;
+    cancelRequested = false;
+    alwaysTaskReturn = false;
+    
+    returnCalls =  0;
+    storage = [0, 0];
+    borrowedHandles = {};
+    
+    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.#isManualAsync = opts?.isManualAsync ?? false;
+      this.#entryFnName = opts.entryFnName;
+      
+      const {
+        promise: completionPromise,
+        resolve: resolveCompletionPromise,
+        reject: rejectCompletionPromise,
+      } = promiseWithResolvers();
+      this.#completionPromise = completionPromise;
+      
+      this.#onResolveHandlers.push((results) => {
+        if (this.#errored !== null) {
+          rejectCompletionPromise(this.#errored);
+          return;
+        } else if (this.#rejected) {
+          rejectCompletionPromise(results);
+          return;
+        }
+        resolveCompletionPromise(results);
+      });
+      
+      const {
+        promise: exitPromise,
+        resolve: resolveExitPromise,
+        reject: rejectExitPromise,
+      } = promiseWithResolvers();
+      this.#exitPromise = exitPromise;
+      
+      this.#onExitHandlers.push(() => {
+        resolveExitPromise();
+      });
+      
+      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; }
     }
-    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;
+    
+    taskState() { return this.#state; }
+    id() { return this.#id; }
+    componentIdx() { return this.#componentIdx; }
+    entryFnName() { return this.#entryFnName; }
+    
+    completionPromise() { return this.#completionPromise; }
+    exitPromise() { return this.#exitPromise; }
+    
+    isAsync() { return this.#isAsync; }
+    isSync() { return !this.isAsync(); }
+    
+    getErrHandling() { return this.#errHandling; }
+    
+    hasCallback() { return this.#callbackFn !== null; }
+    
+    getReturnMemoryIdx() { return this.#memoryIdx; }
+    setReturnMemoryIdx(idx) {
+      if (idx === null) { return; }
+      this.#memoryIdx = idx;
     }
-    if (!cstate.callingSyncImport()) {
-      _debugLog('[AsyncTask#mayEnter()] disallowed due to sync import call', { taskID: this.#id });
-      return false;
+    
+    getReturnMemory() { return this.#memory; }
+    setReturnMemory(m) {
+      if (m === null) { return; }
+      this.#memory = m;
     }
-    const callingSyncExportWithSyncPending = cstate.callingSyncExport && !task.isAsync;
-    if (!callingSyncExportWithSyncPending) {
-      _debugLog('[AsyncTask#mayEnter()] disallowed due to sync export w/ sync pending', { taskID: this.#id });
-      return false;
+    
+    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;
+    }
+    
+    async runCallbackFn(...args) {
+      if (!this.#callbackFn) { throw new Error('on callback function has been set for task'); }
+      return await this.#callbackFn.apply(null, args);
+    }
+    
+    getCalleeParams() {
+      if (!this.#getCalleeParamsFn) { throw new Error('missing/invalid getCalleeParamsFn'); }
+      return this.#getCalleeParamsFn();
+    }
+    
+    mayBlock() { return this.isAsync() || this.isResolvedState() }
+    
+    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;
+    }
+    
+    enterSync() {
+      if (this.needsExclusiveLock()) {
+        const cstate = getOrCreateAsyncState(this.#componentIdx);
+        cstate.exclusiveLock();
+      }
+      return true;
+    }
+    
+    async enter(opts) {
+      _debugLog('[AsyncTask#enter()] args', {
+        taskID: this.#id,
+        componentIdx: this.#componentIdx,
+        subtaskID: this.getParentSubtask()?.id(),
+      });
+      
+      if (this.#entered) {
+        throw new Error(`task with ID [${this.#id}] should not be entered twice`);
+      }
+      
+      const cstate = getOrCreateAsyncState(this.#componentIdx);
+      
+      // If a task is either synchronous or host-provided (e.g. a host import, whether sync or async)
+      // then we can avoid component-relevant tracking and immediately enter
+      if (this.isSync() || opts?.isHost) {
+        this.#entered = true;
+        
+        // TODO(breaking): remove once manually-spccifying async fns is removed
+        // It is currently possible for an actually sync export to be specified
+        // as async via JSPI
+        if (this.#isManualAsync) {
+          if (this.needsExclusiveLock()) { cstate.exclusiveLock(); }
+        }
+        
+        return this.#entered;
+      }
+      
+      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(); }
+      
+      this.#entered = true;
+      return this.#entered;
     }
-    return true;
-  }
-  
-  async enter() {
-    _debugLog('[AsyncTask#enter()] args', { taskID: this.#id });
-    const cstate = getOrCreateAsyncState(this.#componentIdx);
     
-    if (this.isSync()) { return true; }
+    isRunningState() { return this.#state !== AsyncTask.State.RESOLVED; }
+    isResolvedState() { return this.#state === AsyncTask.State.RESOLVED; }
+    isResolved() { return this.#state === AsyncTask.State.RESOLVED; }
     
-    if (cstate.hasBackpressure()) {
-      cstate.addBackpressureWaiter();
+    async waitUntil(opts) {
+      const { readyFn, waitableSetRep, cancellable } = opts;
+      _debugLog('[AsyncTask#waitUntil()] args', { taskID: this.#id, waitableSetRep, cancellable });
       
-      const result = await this.waitUntil({
-        readyFn: () => !cstate.hasBackpressure(),
-        cancellable: true,
-      });
+      const state = getOrCreateAsyncState(this.#componentIdx);
+      const wset = state.handles.get(waitableSetRep);
       
-      cstate.removeBackpressureWaiter();
+      let event;
       
-      if (result === AsyncTask.BlockResult.CANCELLED) {
-        this.cancel();
-        return false;
+      wset.incrementNumWaiting();
+      
+      const keepGoing = await this.suspendUntil({
+        readyFn: () => {
+          const hasPendingEvent = wset.hasPendingEvent();
+          const ready = readyFn();
+          return ready && hasPendingEvent;
+        },
+        cancellable,
+      });
+      
+      if (keepGoing) {
+        event = wset.getPendingEvent();
+      } else {
+        event = {
+          code: ASYNC_EVENT_CODE.TASK_CANCELLED,
+          payload0: 0,
+          payload1: 0,
+        };
       }
+      
+      wset.decrementNumWaiting();
+      
+      return event;
     }
     
-    if (this.needsExclusiveLock()) { cstate.exclusiveLock(); }
+    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.NONE,
+          payload0: 0,
+          payload1: 0,
+        };
+      }
+      
+      return {
+        code: ASYNC_EVENT_CODE.TASK_CANCELLED,
+        payload0: 0,
+        payload1: 0,
+      };
+    }
     
-    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 });
+    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;
+    }
     
-    const state = getOrCreateAsyncState(this.#componentIdx);
-    const wset = state.waitableSets.get(waitableSetRep);
+    // 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 === 'random') {
+        const coinFlip = _coinFlip();
+        if (coinFlip) { return true }
+      }
+      
+      const keepGoing = await this.immediateSuspend({ cancellable, readyFn });
+      return keepGoing;
+    }
     
-    let event;
+    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 });
     
-    wset.incrementNumWaiting();
+    const pendingCancelled = this.deliverPendingCancel({ cancellable });
+    if (pendingCancelled) { return false; }
     
-    const keepGoing = await this.suspendUntil({
-      readyFn: () => {
-        const hasPendingEvent = wset.hasPendingEvent();
-        return readyFn() && hasPendingEvent;
-      },
-      cancellable,
-    });
+    const cstate = getOrCreateAsyncState(this.#componentIdx);
+    const keepGoing = await cstate.suspendTask({ task: this, readyFn });
+    return keepGoing;
+  }
+  
+  deliverPendingCancel(opts) {
+    const { cancellable } = opts;
+    _debugLog('[AsyncTask#deliverPendingCancel()] args', { cancellable });
     
-    if (keepGoing) {
-      event = wset.getPendingEvent();
-    } else {
-      event = {
-        code: ASYNC_EVENT_CODE.TASK_CANCELLED,
-        index: 0,
-        result: 0,
-      };
+    if (cancellable && this.#state === AsyncTask.State.PENDING_CANCEL) {
+      this.#state = AsyncTask.State.CANCEL_DELIVERED;
+      return true;
     }
     
-    wset.decrementNumWaiting();
-    
-    return event;
+    return false;
+  }
+  
+  isCancelled() { return this.cancelled }
+  
+  cancel(args) {
+    _debugLog('[AsyncTask#cancel()] args', { });
+    if (this.taskState() !== AsyncTask.State.CANCEL_DELIVERED) {
+      throw new Error(`(component [${this.#componentIdx}]) task [${this.#id}] invalid task state [${this.taskState()}] for cancellation`);
+    }
+    if (this.borrowedHandles.length > 0) { throw new Error('task still has borrow handles'); }
+    this.cancelled = true;
+    this.onResolve(args?.error ?? new Error('task cancelled'));
+    this.#state = AsyncTask.State.RESOLVED;
   }
   
-  async onBlock(awaitable) {
-    _debugLog('[AsyncTask#onBlock()] args', { taskID: this.#id, awaitable });
-    if (!(awaitable instanceof Awaitable)) {
-      throw new Error('invalid awaitable during onBlock');
+  onResolve(taskValue) {
+    const handlers = this.#onResolveHandlers;
+    this.#onResolveHandlers = [];
+    for (const f of handlers) {
+      try {
+        // TODO(fix): resolve handlers getting called a ton?
+        f(taskValue);
+      } catch (err) {
+        _debugLog("[AsyncTask#onResolve] error during task resolve handler", err);
+        throw err;
+      }
     }
     
-    // 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);
-    };
+    if (this.#parentSubtask) {
+      const meta = this.#parentSubtask.getCallMetadata();
+      // Run the rturn fn if it has not already been called -- this *should* have happened in
+      // `task.return`, but some paths do not go through task.return (e.g. async lower of sync fn
+      // which goes through prepare + async-start-call)
+      if (meta.returnFn && !meta.returnFnCalled) {
+        _debugLog('[AsyncTask#onResolve()] running returnFn', {
+          componentIdx: this.#componentIdx,
+          taskID: this.#id,
+          subtaskID: this.#parentSubtask.id(),
+        });
+        const memory = meta.getMemoryFn();
+        meta.returnFn.apply(null, [taskValue, meta.resultPtr]);
+        meta.returnFnCalled = true;
+      }
+    }
     
-    // Park this task/execution to be handled later
-    const state = getOrCreateAsyncState(this.#componentIdx);
-    state.parkTaskOnAwaitable({ awaitable, task: this });
+    if (this.#postReturnFn) {
+      _debugLog('[AsyncTask#onResolve()] running post return ', {
+        componentIdx: this.#componentIdx,
+        taskID: this.#id,
+      });
+      try {
+        this.#postReturnFn(taskValue);
+      } catch (err) {
+        _debugLog("[AsyncTask#onResolve] error during task resolve handler", err);
+        throw err;
+      }
+    }
     
-    try {
-      await promise;
-      return AsyncTask.BlockResult.NOT_CANCELLED;
-    } catch (err) {
-      // rejection means task cancellation
-      return AsyncTask.BlockResult.CANCELLED;
+    if (this.#parentSubtask) {
+      this.#parentSubtask.onResolve(taskValue);
     }
   }
   
-  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');
+  registerOnResolveHandler(f) {
+    this.#onResolveHandlers.push(f);
+  }
+  
+  isRejected() { return this.#rejected; }
+  
+  setErrored(err) {
+    this.#errored = err;
   }
   
-  async yieldUntil(opts) {
-    const { readyFn, cancellable } = opts;
-    _debugLog('[AsyncTask#yieldUntil()] args', { taskID: this.#id, cancellable });
+  reject(taskErr) {
+    _debugLog('[AsyncTask#reject()] args', {
+      componentIdx: this.#componentIdx,
+      taskID: this.#id,
+      parentSubtask: this.#parentSubtask,
+      parentSubtaskID: this.#parentSubtask?.id(),
+      entryFnName: this.entryFnName(),
+      callbackFnName: this.#callbackFnName,
+      errMsg: taskErr.message,
+    });
     
-    const keepGoing = await this.suspendUntil({ readyFn, cancellable });
-    if (!keepGoing) {
-      return {
-        code: ASYNC_EVENT_CODE.TASK_CANCELLED,
-        index: 0,
-        result: 0,
-      };
+    if (this.isResolvedState() || this.#rejected) { return; }
+    
+    for (const subtask of this.#subtasks) {
+      subtask.reject(taskErr);
     }
     
-    return {
-      code: ASYNC_EVENT_CODE.NONE,
-      index: 0,
-      result: 0,
-    };
-  }
-  
-  async suspendUntil(opts) {
-    const { cancellable, readyFn } = opts;
-    _debugLog('[AsyncTask#suspendUntil()] args', { cancellable });
+    this.#rejected = true;
+    this.cancelRequested = true;
+    this.#state = AsyncTask.State.PENDING_CANCEL;
+    const cancelled = this.deliverPendingCancel({ cancellable: true });
+    
+    // TODO: do cleanup here to reset the machinery so we can run again?
     
-    const pendingCancelled = this.deliverPendingCancel({ cancellable });
-    if (pendingCancelled) { return false; }
     
-    const completed = await this.immediateSuspendUntil({ readyFn, cancellable });
-    return completed;
+    this.cancel({ error: taskErr });
   }
   
-  // TODO(threads): equivalent to thread.suspend_until()
-  async immediateSuspendUntil(opts) {
-    const { cancellable, readyFn } = opts;
-    _debugLog('[AsyncTask#immediateSuspendUntil()] args', { cancellable, readyFn });
+  resolve(results) {
+    _debugLog('[AsyncTask#resolve()] args', {
+      componentIdx: this.#componentIdx,
+      taskID: this.#id,
+      entryFnName: this.entryFnName(),
+      callbackFnName: this.#callbackFnName,
+    });
     
-    const ready = readyFn();
-    if (ready && !ASYNC_DETERMINISM && _coinFlip()) {
-      return true;
+    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?)`);
     }
     
-    const cstate = getOrCreateAsyncState(this.#componentIdx);
-    cstate.addPendingTask(this);
+    if (this.borrowedHandles.length > 0) {
+      throw new Error('task still has borrow handles');
+    }
     
-    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;
+    this.#state = AsyncTask.State.RESOLVED;
+    
+    switch (results.length) {
+      case 0:
+      this.onResolve(undefined);
+      break;
+      case 1:
+      this.onResolve(results[0]);
+      break;
+      default:
+      _debugLog('[AsyncTask#resolve()] unexpected number of results', {
+        componentIdx: this.#componentIdx,
+        results,
+        taskID: this.#id,
+        subtaskID: this.#parentSubtask?.id(),
+        entryFnName: this.#entryFnName,
+        callbackFnName: this.#callbackFnName,
+      });
+      throw new Error('unexpected number of results');
     }
   }
   
-  if (this.#postReturnFn) {
-    _debugLog('[AsyncTask#onResolve()] running post return ', {
+  exit() {
+    _debugLog('[AsyncTask#exit()]', {
       componentIdx: this.#componentIdx,
       taskID: this.#id,
     });
-    this.#postReturnFn();
+    
+    if (this.#exited)  { throw new Error("task has already exited"); }
+    
+    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 + ']'); }
+    
+    // Exempt the host from exclusive lock check
+    if (this.#componentIdx !== -1 && this.needsExclusiveLock() && !state.isExclusivelyLocked()) {
+      throw new Error(`task [${this.#id}] exit: component [${this.#componentIdx}] should have been exclusively locked`);
+    }
+    
+    state.exclusiveRelease();
+    
+    for (const f of this.#onExitHandlers) {
+      try {
+        f();
+      } catch (err) {
+        console.error("error during task exit handler", err);
+        throw err;
+      }
+    }
+    
+    this.#exited = true;
+    clearCurrentTask(this.#componentIdx, this.id());
   }
-}
-
-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?)`);
+  needsExclusiveLock() {
+    return !this.#isAsync || this.hasCallback();
   }
-  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');
-  }
-  this.#state = AsyncTask.State.RESOLVED;
-}
-
-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', {
+  createSubtask(args) {
+    _debugLog('[AsyncTask#createSubtask()] args', args);
+    const { componentIdx, childTask, callMetadata, fnName, isAsync, isManualAsync } = args;
+    
+    const cstate = getOrCreateAsyncState(this.#componentIdx);
+    if (!cstate) {
+      throw new Error(`invalid/missing async state for component idx [${componentIdx}]`);
+    }
+    
+    const waitable = new Waitable({
       componentIdx: this.#componentIdx,
-      taskID: this.#id,
-      subtask: this.getParentSubtask(),
-      subtaskID: this.getParentSubtask()?.id(),
+      target: `subtask (internal ID [${this.#id}])`,
     });
-    this.#state = AsyncTask.State.RESOLVED;
+    
+    const newSubtask = new AsyncSubtask({
+      componentIdx,
+      childTask,
+      parentTask: this,
+      callMetadata,
+      isAsync,
+      isManualAsync,
+      fnName,
+      waitable,
+    });
+    this.#subtasks.push(newSubtask);
+    newSubtask.setTarget(`subtask (internal ID [${newSubtask.id()}], waitable [${waitable.idx()}], component [${componentIdx}])`);
+    waitable.setIdx(cstate.handles.insert(newSubtask));
+    waitable.setTarget(`waitable for subtask (waitable id [${waitable.idx()}], subtask internal ID [${newSubtask.id()}])`);
+    
+    return newSubtask;
   }
   
-  if (this.borrowedHandles > 0) {
-    throw new Error('task [${this.#id}] exited without clearing borrowed handles');
+  getLatestSubtask() {
+    return this.#subtasks.at(-1);
   }
   
-  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');
+  getSubtaskByWaitableRep(rep) {
+    if (rep === undefined) { throw new TypeError('missing rep'); }
+    return this.#subtasks.find(s => s.waitableRep() === rep);
   }
-  state.inSyncExportCall = false;
   
-  if (this.needsExclusiveLock() && !state.isExclusivelyLocked()) {
-    throw new Error('task [' + this.#id + '] exit: component [' + this.#componentIdx + '] should have been exclusively locked');
+  currentSubtask() {
+    _debugLog('[AsyncTask#currentSubtask()]');
+    if (this.#subtasks.length === 0) { return undefined; }
+    return this.#subtasks.at(-1);
   }
   
-  state.exclusiveRelease();
-}
-
-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;
-}
-
-getLatestSubtask() { return this.#subtasks.at(-1); }
-
-currentSubtask() {
-  _debugLog('[AsyncTask#currentSubtask()]');
-  if (this.#subtasks.length === 0) { return undefined; }
-  return this.#subtasks.at(-1);
+  removeSubtask(subtask) {
+    if (this.#subtasks.length === 0) { throw new Error('cannot end current subtask: no current subtask'); }
+    this.#subtasks = this.#subtasks.filter(t => t !== subtask);
+    return subtask;
+  }
 }
 
-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;
-}
-}
+const STREAMS = new RepTable({ target: 'global stream map' });
 const ASYNC_STATE = new Map();
 
 function getOrCreateAsyncState(componentIdx, init) {
@@ -1198,7 +1830,6 @@ class ComponentAsyncState {
   #parkedTasks = new Map();
   #suspendedTasksByTaskID = new Map();
   #suspendedTaskIDs = [];
-  #pendingTasks = [];
   #errored = null;
   
   #backpressure = 0;
@@ -1207,24 +1838,23 @@ class ComponentAsyncState {
   #handlerMap = new Map();
   #nextHandlerID = 0n;
   
-  mayLeave = true;
+  #tickLoop = null;
+  #tickLoopInterval = null;
+  
+  #onExclusiveReleaseHandlers = [];
   
-  #streams;
+  mayLeave = true;
   
-  waitableSets;
-  waitables;
+  handles;
   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.handles = new RepTable({ target: `component [${this.#componentIdx}] handles (waitable objects)` });
     this.subtasks = new RepTable({ target: `component [${this.#componentIdx}] subtasks` });
-    this.#streams = new Map();
   };
   
   componentIdx() { return this.#componentIdx; }
-  streams() { return this.#streams; }
   
   errored() { return this.#errored !== null; }
   setErrored(err) {
@@ -1257,15 +1887,34 @@ class ComponentAsyncState {
     await this.#syncImportWait.promise;
   }
   
-  setBackpressure(v) { this.#backpressure = v; }
-  getBackpressure(v) { return this.#backpressure; }
+  setBackpressure(v) {
+    this.#backpressure = v;
+    return this.#backpressure
+  }
+  getBackpressure() { return this.#backpressure; }
+  
   incrementBackpressure() {
+    const current = this.#backpressure;
+    if (current < 0 || current > 2**16) {
+      throw new Error(`invalid current backpressure value [${current}]`);
+    }
     const newValue = this.getBackpressure() + 1;
-    if (newValue > 2**16) { throw new Error("invalid backpressure value, overflow"); }
-    this.setBackpressure(newValue);
+    if (newValue >= 2**16) {
+      throw new Error(`invalid new backpressure value [${newValue}], overflow`);
+    }
+    return this.setBackpressure(newValue);
   }
+  
   decrementBackpressure() {
-    this.setBackpressure(Math.max(0, this.getBackpressure() - 1));
+    const current = this.#backpressure;
+    if (current < 0 || current > 2**16) {
+      throw new Error(`invalid current backpressure value [${current}]`);
+    }
+    const newValue = Math.max(0, current - 1);
+    if (newValue < 0) {
+      throw new Error(`invalid new backpressure value [${newValue}], underflow`);
+    }
+    return this.setBackpressure(newValue);
   }
   hasBackpressure() { return this.#backpressure > 0; }
   
@@ -1330,55 +1979,44 @@ class ComponentAsyncState {
     }
   }
   
-  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);
-    }
-    taskList.push(task);
-    
-    this.wakeNextTaskForAwaitable(awaitable);
-  }
-  
-  wakeNextTaskForAwaitable(awaitable) {
-    if (!awaitable) { throw new TypeError('missing awaitable when waking next task'); }
-    const awaitableID = awaitable.id();
-    
-    const taskList = this.#parkedTasks.get(awaitableID);
-    if (!taskList || taskList.length === 0) {
-      _debugLog('[ComponentAsyncState] no tasks waiting for awaitable', { awaitableID: awaitable.id() });
-      return;
-    }
-    
-    let task = taskList.shift(); // todo(perf)
-    if (!task) { throw new Error('no task in parked list despite previous check'); }
-    
-    if (!task.awaitableResume) {
-      throw new Error('task ready due to awaitable is missing resume', { taskID: task.id(), awaitableID });
-    }
-    task.awaitableResume();
+  isExclusivelyLocked() { return this.#locked === true; }
+  setLocked(locked) {
+    this.#locked = locked;
   }
   
-  // TODO: we might want to check for pre-locked status here
+  // TODO(fix): we might want to check for pre-locked status here, we should be deterministically
+  // going from locked -> unlocked and vice versa
   exclusiveLock() {
-    this.#locked = true;
+    _debugLog('[ComponentAsyncState#exclusiveLock()]', {
+      locked: this.#locked,
+      componentIdx: this.#componentIdx,
+    });
+    this.setLocked(true);
   }
   
   exclusiveRelease() {
-    _debugLog('[ComponentAsyncState#exclusiveRelease()] releasing', {
+    _debugLog('[ComponentAsyncState#exclusiveRelease()] args', {
       locked: this.#locked,
       componentIdx: this.#componentIdx,
     });
-    
-    this.#locked = false
+    this.setLocked(false);
+    
+    this.#onExclusiveReleaseHandlers = this.#onExclusiveReleaseHandlers.filter(v => !!v);
+    for (const [idx, f] of this.#onExclusiveReleaseHandlers.entries()) {
+      try {
+        this.#onExclusiveReleaseHandlers[idx] = null;
+        f();
+      } catch (err) {
+        _debugLog("error while executing handler for next exclusive release", err);
+        throw err;
+      }
+    }
   }
   
-  isExclusivelyLocked() { return this.#locked === true; }
+  onNextExclusiveRelease(fn) {
+    _debugLog('[ComponentAsyncState#()onNextExclusiveRelease] registering');
+    this.#onExclusiveReleaseHandlers.push(fn);
+  }
   
   #getSuspendedTaskMeta(taskID) {
     return this.#suspendedTasksByTaskID.get(taskID);
@@ -1403,17 +2041,22 @@ class ComponentAsyncState {
     }
   }
   
+  // TODO(threads): readyFn is normally on the thread
   suspendTask(args) {
-    // TODO(threads): readyFn is normally on the thread
     const { task, readyFn } = args;
     const taskID = task.id();
-    _debugLog('[ComponentAsyncState#suspendTask()]', { taskID });
+    _debugLog('[ComponentAsyncState#suspendTask()]', {
+      taskID,
+      componentIdx: this.#componentIdx,
+      taskEntryFnName: task.entryFnName(),
+      subtask: task.getParentSubtask(),
+    });
     
     if (this.#getSuspendedTaskMeta(taskID)) {
-      throw new Error('task [' + taskID + '] already suspended');
+      throw new Error(`task [${taskID}] already suspended`);
     }
     
-    const { promise, resolve } = Promise.withResolvers();
+    const { promise, resolve, reject } = promiseWithResolvers();
     this.#addSuspendedTaskMeta({
       task,
       taskID,
@@ -1425,6 +2068,8 @@ class ComponentAsyncState {
       },
     });
     
+    this.runTickLoop();
+    
     return promise;
   }
   
@@ -1435,8 +2080,22 @@ class ComponentAsyncState {
     meta.resume();
   }
   
+  async runTickLoop() {
+    if (this.#tickLoop !== null) { return; }
+    this.#tickLoop = 1;
+    setTimeout(async () => {
+      let done = this.tick();
+      while (!done) {
+        await new Promise((resolve) => setTimeout(resolve, 30));
+        done = this.tick();
+      }
+      this.#tickLoop = null;
+    }, 10);
+  }
+  
   tick() {
-    _debugLog('[ComponentAsyncState#tick()]', { suspendedTaskIDs: this.#suspendedTaskIDs });
+    // _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);
@@ -1444,6 +2103,14 @@ class ComponentAsyncState {
         throw new Error(`missing/invalid task despite ID [${taskID}] being present`);
       }
       
+      // If the task failed via any means, allow the task to resume because
+      // it's been cancelled -- the callback should immediately exit as well
+      if (meta.task.isRejected()) {
+        _debugLog('[ComponentAsyncState#suspendTask()] detected task rejection, leaving early', { meta });
+        this.resumeTaskByID(taskID);
+        return;
+      }
+      
       const isReady = meta.readyFn();
       if (!isReady) { continue; }
       
@@ -1453,22 +2120,37 @@ class ComponentAsyncState {
     return this.#suspendedTaskIDs.filter(t => t !== null).length === 0;
   }
   
-  addPendingTask(task) {
-    this.#pendingTasks.push(task);
-  }
-  
-  addStreamEnd(args) {
+  addStreamEndToTable(args) {
     _debugLog('[ComponentAsyncState#addStreamEnd()] args', args);
     const { tableIdx, streamEnd } = args;
+    if (typeof streamEnd === 'number') { throw new Error("INSERTING BAD STREAMEND"); }
     
-    let tbl = this.#streams.get(tableIdx);
-    if (!tbl) {
-      tbl = new RepTable({ target: `component [${this.#componentIdx}] streams` });
-      this.#streams.set(tableIdx, tbl);
+    let { table, componentIdx } = STREAM_TABLES[tableIdx];
+    if (componentIdx === undefined || !table) {
+      throw new Error(`invalid global stream table state for table [${tableIdx}]`);
     }
     
-    const streamIdx = tbl.insert(streamEnd);
-    return streamIdx;
+    const handle = table.insert(streamEnd);
+    streamEnd.setHandle(handle);
+    streamEnd.setStreamTableIdx(tableIdx);
+    
+    const cstate = getOrCreateAsyncState(componentIdx);
+    const waitableIdx = cstate.handles.insert(streamEnd);
+    streamEnd.setWaitableIdx(waitableIdx);
+    
+    _debugLog('[ComponentAsyncState#addStreamEnd()] added stream end', {
+      tableIdx,
+      table,
+      handle,
+      streamEnd,
+      destComponentIdx: componentIdx,
+    });
+    
+    return { handle, waitableIdx };
+  }
+  
+  createWaitable(args) {
+    return new Waitable({ target: args?.target, });
   }
   
   createStream(args) {
@@ -1477,63 +2159,143 @@ class ComponentAsyncState {
     if (tableIdx === undefined) { throw new Error("missing table idx while adding stream"); }
     if (elemMeta === undefined) { throw new Error("missing element metadata while adding stream"); }
     
-    let tbl = this.#streams.get(tableIdx);
-    if (!tbl) {
-      tbl = new RepTable({ target: `component [${this.#componentIdx}] streams` });
-      this.#streams.set(tableIdx, tbl);
+    const { table: localStreamTable, componentIdx } = STREAM_TABLES[tableIdx];
+    if (!localStreamTable) {
+      throw new Error(`missing global stream table lookup for table [${tableIdx}] while creating stream`);
     }
+    if (componentIdx !== this.#componentIdx) {
+      throw new Error('component idx mismatch while creating stream');
+    }
+    
+    const readWaitable = this.createWaitable();
+    const writeWaitable = this.createWaitable();
     
     const stream = new InternalStream({
       tableIdx,
       componentIdx: this.#componentIdx,
       elemMeta,
+      readWaitable,
+      writeWaitable,
     });
-    const writeEndIdx = tbl.insert(stream.getWriteEnd());
-    stream.setWriteEndIdx(writeEndIdx);
-    const readEndIdx = tbl.insert(stream.getReadEnd());
-    stream.setReadEndIdx(readEndIdx);
+    stream.setGlobalStreamMapRep(STREAMS.insert(stream));
+    
+    const writeEnd = stream.writeEnd();
+    writeEnd.setWaitableIdx(this.handles.insert(writeEnd));
+    writeEnd.setHandle(localStreamTable.insert(writeEnd));
+    if (writeEnd.streamTableIdx() !== tableIdx) { throw new Error("unexpectedly mismatched stream table"); }
+    
+    const writeEndWaitableIdx = writeEnd.waitableIdx();
+    const writeEndHandle = writeEnd.handle();
+    writeWaitable.setTarget(`waitable for stream write end (waitable [${writeEndWaitableIdx}])`);
+    writeEnd.setTarget(`stream write end (waitable [${writeEndWaitableIdx}])`);
     
-    const rep = STREAMS.insert(stream);
-    stream.setRep(rep);
+    const readEnd = stream.readEnd();
+    readEnd.setWaitableIdx(this.handles.insert(readEnd));
+    readEnd.setHandle(localStreamTable.insert(readEnd));
+    if (readEnd.streamTableIdx() !== tableIdx) { throw new Error("unexpectedly mismatched stream table"); }
     
-    return { writeEndIdx, readEndIdx };
+    const readEndWaitableIdx = readEnd.waitableIdx();
+    const readEndHandle = readEnd.handle();
+    readWaitable.setTarget(`waitable for read end (waitable [${readEndWaitableIdx}])`);
+    readEnd.setTarget(`stream read end (waitable [${readEndWaitableIdx}])`);
+    
+    return {
+      writeEndWaitableIdx,
+      writeEndHandle,
+      readEndWaitableIdx,
+      readEndHandle,
+    };
   }
   
   getStreamEnd(args) {
     _debugLog('[ComponentAsyncState#getStreamEnd()] args', args);
-    const { tableIdx, 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 { tableIdx, streamEndHandle, streamEndWaitableIdx } = args;
+    if (tableIdx === undefined) { throw new Error('missing table idx while getting stream end'); }
+    
+    const { table, componentIdx } = STREAM_TABLES[tableIdx];
+    const cstate = getOrCreateAsyncState(componentIdx);
+    
+    let streamEnd;
+    if (streamEndWaitableIdx !== undefined) {
+      streamEnd = cstate.handles.get(streamEndWaitableIdx);
+    } else if (streamEndHandle !== undefined) {
+      if (!table) { throw new Error(`missing/invalid table [${tableIdx}] while getting stream end`); }
+      streamEnd = table.get(streamEndHandle);
+    } else {
+      throw new TypeError("must specify either waitable idx or handle to retrieve stream");
+    }
+    
+    if (!streamEnd) {
+      throw new Error(`missing stream end (tableIdx [${tableIdx}], handle [${streamEndHandle}], waitableIdx [${streamEndWaitableIdx}])`);
+    }
+    if (tableIdx && streamEnd.streamTableIdx() !== tableIdx) {
+      throw new Error(`stream end table idx [${streamEnd.streamTableIdx()}] does not match [${tableIdx}]`);
+    }
+    
+    return streamEnd;
+  }
+  
+  deleteStreamEnd(args) {
+    _debugLog('[ComponentAsyncState#deleteStreamEnd()] args', args);
+    const { tableIdx, streamEndWaitableIdx } = args;
+    if (tableIdx === undefined) { throw new Error("missing table idx while removing stream end"); }
+    if (streamEndWaitableIdx === undefined) { throw new Error("missing stream idx while removing stream end"); }
     
-    const tbl = this.#streams.get(tableIdx);
-    if (!tbl) {
-      throw new Error(`missing stream table [${tableIdx}] in component [${this.#componentIdx}] while getting stream`);
+    const { table, componentIdx } = STREAM_TABLES[tableIdx];
+    const cstate = getOrCreateAsyncState(componentIdx);
+    
+    const streamEnd = cstate.handles.get(streamEndWaitableIdx);
+    if (!streamEnd) {
+      throw new Error(`missing stream end [${streamEndWaitableIdx}] in component handles while deleting stream`);
+    }
+    if (streamEnd.streamTableIdx() !== tableIdx) {
+      throw new Error(`stream end table idx [${streamEnd.streamTableIdx()}] does not match [${tableIdx}]`);
+    }
+    
+    let removed = cstate.handles.remove(streamEnd.waitableIdx());
+    if (!removed) {
+      throw new Error(`failed to remove stream end [${streamEndWaitableIdx}] waitable obj in component [${componentIdx}]`);
+    }
+    
+    removed = table.remove(streamEnd.handle());
+    if (!removed) {
+      throw new Error(`failed to remove stream end with handle [${streamEnd.handle()}] from stream table [${tableIdx}] in component [${componentIdx}]`);
     }
     
-    const stream = tbl.get(streamIdx);
-    return stream;
+    return streamEnd;
   }
   
-  removeStreamEnd(args) {
-    _debugLog('[ComponentAsyncState#removeStreamEnd()] args', args);
-    const { tableIdx, streamIdx } = args;
+  removeStreamEndFromTable(args) {
+    _debugLog('[ComponentAsyncState#removeStreamEndFromTable()] args', args);
+    
+    const { tableIdx, streamWaitableIdx } = args;
     if (tableIdx === undefined) { throw new Error("missing table idx while removing stream end"); }
-    if (streamIdx === undefined) { throw new Error("missing stream idx while removing stream end"); }
+    if (streamWaitableIdx === undefined) {
+      throw new Error("missing stream end waitable idx while removing stream end");
+    }
+    
+    const { table, componentIdx } = STREAM_TABLES[tableIdx];
+    if (!table) { throw new Error(`missing/invalid table [${tableIdx}] while removing stream end`); }
+    
+    const cstate = getOrCreateAsyncState(componentIdx);
     
-    const tbl = this.#streams.get(tableIdx);
-    if (!tbl) {
-      throw new Error(`missing stream table [${tableIdx}] in component [${this.#componentIdx}] while removing stream end`);
+    const streamEnd = cstate.handles.get(streamWaitableIdx);
+    if (!streamEnd) {
+      throw new Error(`missing stream end (handle [${streamWaitableIdx}], table [${tableIdx}])`);
     }
+    const handle = streamEnd.handle();
     
-    const stream = tbl.get(streamIdx);
-    if (!stream) { throw new Error(`component [${this.#componentIdx}] missing stream [${streamIdx}]`); }
+    let removed = cstate.handles.remove(streamWaitableIdx);
+    if (!removed) {
+      throw new Error(`failed to remove streamEnd from handles (waitable idx [${streamWaitableIdx}]), component [${componentIdx}])`);
+    }
     
-    const removed = tbl.remove(streamIdx);
+    removed = table.remove(handle);
     if (!removed) {
-      throw new Error(`missing stream [${streamIdx}] (table [${tableIdx}]) in component [${this.#componentIdx}] while removing stream end`);
+      throw new Error(`failed to remove streamEnd from table (handle [${handle}]), table [${tableIdx}], component [${componentIdx}])`);
     }
     
-    return stream;
+    return streamEnd;
   }
 }
 
@@ -1565,7 +2327,9 @@ const instantiateCore = WebAssembly.instantiate;
 let exports0;
 let memory0;
 let realloc0;
+let realloc0Async;
 let postReturn0;
+let postReturn0Async;
 let exports0ParseConfig;
 
 function parseConfig(arg0, arg1) {
@@ -1598,6 +2362,7 @@ function parseConfig(arg0, arg1) {
   const [task, _wasm_call_currentTaskID] = createNewCurrentTask({
     componentIdx: 0,
     isAsync: false,
+    isManualAsync: false,
     entryFnName: 'exports0ParseConfig',
     getCallbackFn: () => null,
     callbackFnName: 'null',
@@ -1605,8 +2370,15 @@ function parseConfig(arg0, arg1) {
     callingWasmExport: true,
   });
   
-  let ret = exports0ParseConfig(ptr0, len0, result2, len2);
-  endCurrentTask(0);
+  const started = task.enterSync();
+  task.setReturnMemoryIdx(0);
+  task.setReturnMemory(memory0);
+  let ret =   _withGlobalCurrentTaskMeta({
+    taskID: task.id(),
+    componentIdx: task.componentIdx(),
+    fn: () => exports0ParseConfig(ptr0, len0, result2, len2),
+  });
+  
   let variant60;
   switch (dataView(memory0).getUint8(ret + 0, true)) {
     case 0: {
@@ -2124,11 +2896,13 @@ function parseConfig(arg0, arg1) {
     postReturn: true
   });
   const retCopy = variant60;
+  task.resolve([retCopy.val]);
   
   let cstate = getOrCreateAsyncState(0);
   cstate.mayLeave = false;
   postReturn0(ret);
   cstate.mayLeave = true;
+  task.exit();
   
   
   
@@ -2144,9 +2918,22 @@ const $init = (() => {
     const module0 = fetchCompile(new URL('./parser.core.wasm', import.meta.url));
     ({ exports: exports0 } = yield instantiateCore(yield module0));
     memory0 = exports0.memory;
-    GlobalComponentMemories.save({ idx: 0, componentIdx: 0, memory: memory0 });
     realloc0 = exports0.cabi_realloc;
+    
+    try {
+      realloc0Async = WebAssembly.promising(exports0.cabi_realloc);
+    } catch(err) {
+      realloc0Async = exports0.cabi_realloc;
+    }
+    
     postReturn0 = exports0['cabi_post_parse-config'];
+    
+    try {
+      postReturn0Async = WebAssembly.promising(exports0['cabi_post_parse-config']);
+    } catch(err) {
+      postReturn0Async = exports0['cabi_post_parse-config'];
+    }
+    
     exports0ParseConfig = exports0['parse-config'];
   })();
   let promise, resolve, reject;