@bytecodealliance/jco 1.13.0 → 1.13.1-rc.4

package/obj/wasm-tools.js

@@ -75,10 +75,580 @@ function rscTableRemove (table, handle) {
 
 let curResourceBorrows = [];
 
+let NEXT_TASK_ID = 0n;
+function startCurrentTask(componentIdx, isAsync, entryFnName) {
+  _debugLog('[startCurrentTask()] args', { componentIdx, isAsync });
+  if (componentIdx === undefined || componentIdx === null) {
+    throw new Error('missing/invalid component instance index while starting task');
+  }
+  const tasks = ASYNC_TASKS_BY_COMPONENT_IDX.get(componentIdx);
+  
+  const nextId = ++NEXT_TASK_ID;
+  const newTask = new AsyncTask({ id: nextId, componentIdx, isAsync, entryFnName });
+  const newTaskMeta = { id: nextId, componentIdx, task: newTask };
+  
+  ASYNC_CURRENT_TASK_ID = nextId;
+  ASYNC_CURRENT_COMPONENT_IDX = componentIdx;
+  
+  if (!tasks) {
+    ASYNC_TASKS_BY_COMPONENT_IDX.set(componentIdx, [newTaskMeta]);
+    return nextId;
+  } else {
+    tasks.push(newTaskMeta);
+  }
+  
+  return nextId;
+}
+
+function endCurrentTask(componentIdx, taskId) {
+  _debugLog('[endCurrentTask()] args', { componentIdx });
+  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 task(s) for component instance while ending task');
+  }
+  
+  if (taskId) {
+    const last = tasks[tasks.length - 1];
+    if (last.id !== taskId) {
+      throw new Error('current task does not match expected task ID');
+    }
+  }
+  
+  ASYNC_CURRENT_TASK_ID = null;
+  ASYNC_CURRENT_COMPONENT_IDX = null;
+  
+  return tasks.pop();
+}
+const ASYNC_TASKS_BY_COMPONENT_IDX = new Map();
+let ASYNC_CURRENT_TASK_ID = null;
+let ASYNC_CURRENT_COMPONENT_IDX = null;
+
+class AsyncTask {
+  static State = {
+    INITIAL: 'initial',
+    CANCELLED: 'cancelled',
+    CANCEL_PENDING: 'cancel-pending',
+    CANCEL_DELIVERED: 'cancel-delivered',
+    RESOLVED: 'resolved',
+  }
+  
+  static BlockResult = {
+    CANCELLED: 'block.cancelled',
+    NOT_CANCELLED: 'block.not-cancelled',
+  }
+  
+  #id;
+  #componentIdx;
+  #state;
+  #isAsync;
+  #onResolve = null;
+  #returnedResults = null;
+  #entryFnName = null;
+  
+  cancelled = false;
+  requested = false;
+  alwaysTaskReturn = false;
+  
+  returnCalls =  0;
+  storage = [0, 0];
+  borrowedHandles = {};
+  
+  awaitableResume = null;
+  awaitableCancel = null;
+  
+  constructor(opts) {
+    if (opts?.id === undefined) { throw new TypeError('missing task ID during task creation'); }
+    this.#id = opts.id;
+    if (opts?.componentIdx === undefined) {
+      throw new TypeError('missing component id during task creation');
+    }
+    this.#componentIdx = opts.componentIdx;
+    this.#state = AsyncTask.State.INITIAL;
+    this.#isAsync = opts?.isAsync ?? false;
+    this.#entryFnName = opts.entryFnName;
+    
+    this.#onResolve = (results) => {
+      this.#returnedResults = results;
+    }
+  }
+  
+  taskState() { return this.#state.slice(); }
+  id() { return this.#id; }
+  componentIdx() { return this.#componentIdx; }
+  isAsync() { return this.#isAsync; }
+  getEntryFnName() { return this.#entryFnName; }
+  
+  takeResults() {
+    const results = this.#returnedResults;
+    this.#returnedResults = null;
+    return results;
+  }
+  
+  mayEnter(task) {
+    const cstate = getOrCreateAsyncState(this.#componentIdx);
+    if (!cstate.backpressure) {
+      _debugLog('[AsyncTask#mayEnter()] disallowed due to backpressure', { taskID: this.#id });
+      return false;
+    }
+    if (!cstate.callingSyncImport()) {
+      _debugLog('[AsyncTask#mayEnter()] disallowed due to sync import call', { taskID: this.#id });
+      return false;
+    }
+    const callingSyncExportWithSyncPending = cstate.callingSyncExport && !task.isAsync;
+    if (!callingSyncExportWithSyncPending) {
+      _debugLog('[AsyncTask#mayEnter()] disallowed due to sync export w/ sync pending', { taskID: this.#id });
+      return false;
+    }
+    return true;
+  }
+  
+  async enter() {
+    _debugLog('[AsyncTask#enter()] args', { taskID: this.#id });
+    
+    // TODO: assert scheduler locked
+    // TODO: trap if on the stack
+    
+    const cstate = getOrCreateAsyncState(this.#componentIdx);
+    
+    let mayNotEnter = !this.mayEnter(this);
+    const componentHasPendingTasks = cstate.pendingTasks > 0;
+    if (mayNotEnter || componentHasPendingTasks) {
+      
+      throw new Error('in enter()'); // TODO: remove
+      cstate.pendingTasks.set(this.#id, new Awaitable(new Promise()));
+      
+      const blockResult = await this.onBlock(awaitable);
+      if (blockResult) {
+        // TODO: find this pending task in the component
+        const pendingTask = cstate.pendingTasks.get(this.#id);
+        if (!pendingTask) {
+          throw new Error('pending task [' + this.#id + '] not found for component instance');
+        }
+        cstate.pendingTasks.remove(this.#id);
+        this.#onResolve([]);
+        return false;
+      }
+      
+      mayNotEnter = !this.mayEnter(this);
+      if (!mayNotEnter || !cstate.startPendingTask) {
+        throw new Error('invalid component entrance/pending task resolution');
+      }
+      cstate.startPendingTask = false;
+    }
+    
+    if (!this.isAsync) { cstate.callingSyncExport = true; }
+    
+    return true;
+  }
+  
+  async waitForEvent(opts) {
+    const { waitableSetRep, isAsync } = opts;
+    _debugLog('[AsyncTask#waitForEvent()] args', { taskID: this.#id, waitableSetRep, isAsync });
+    
+    if (this.#isAsync !== isAsync) {
+      throw new Error('async waitForEvent called on non-async task');
+    }
+    
+    if (this.status === AsyncTask.State.CANCEL_PENDING) {
+      this.#state = AsyncTask.State.CANCEL_DELIVERED;
+      return {
+        code: ASYNC_EVENT_CODE.TASK_CANCELLED,
+        something: 0,
+        something: 0,
+      };
+    }
+    
+    const state = getOrCreateAsyncState(this.#componentIdx);
+    const waitableSet = state.waitableSets.get(waitableSetRep);
+    if (!waitableSet) { throw new Error('missing/invalid waitable set'); }
+    
+    waitableSet.numWaiting += 1;
+    let event = null;
+    
+    while (event == null) {
+      const awaitable = new Awaitable(waitableSet.getPendingEvent());
+      const waited = await this.blockOn({ awaitable, isAsync, isCancellable: true });
+      if (waited) {
+        if (this.#state !== AsyncTask.State.INITIAL) {
+          throw new Error('task should be in initial state found [' + this.#state + ']');
+        }
+        this.#state = AsyncTask.State.CANCELLED;
+        return {
+          code: ASYNC_EVENT_CODE.TASK_CANCELLED,
+          something: 0,
+          something: 0,
+        };
+      }
+      
+      event = waitableSet.poll();
+    }
+    
+    waitableSet.numWaiting -= 1;
+    return event;
+  }
+  
+  waitForEventSync(opts) {
+    throw new Error('AsyncTask#yieldSync() not implemented')
+  }
+  
+  async pollForEvent(opts) {
+    const { waitableSetRep, isAsync } = opts;
+    _debugLog('[AsyncTask#pollForEvent()] args', { taskID: this.#id, waitableSetRep, isAsync });
+    
+    if (this.#isAsync !== isAsync) {
+      throw new Error('async pollForEvent called on non-async task');
+    }
+    
+    throw new Error('AsyncTask#pollForEvent() not implemented');
+  }
+  
+  pollForEventSync(opts) {
+    throw new Error('AsyncTask#yieldSync() not implemented')
+  }
+  
+  async blockOn(opts) {
+    const { awaitable, isCancellable, forCallback } = opts;
+    _debugLog('[AsyncTask#blockOn()] args', { taskID: this.#id, awaitable, isCancellable, forCallback });
+    
+    if (awaitable.resolved() && !ASYNC_DETERMINISM && _coinFlip()) {
+      return AsyncTask.BlockResult.NOT_CANCELLED;
+    }
+    
+    const cstate = getOrCreateAsyncState(this.#componentIdx);
+    if (forCallback) { cstate.exclusiveRelease(); }
+    
+    let cancelled = await this.onBlock(awaitable);
+    if (cancelled === AsyncTask.BlockResult.CANCELLED && !isCancellable) {
+      const secondCancel = await this.onBlock(awaitable);
+      if (secondCancel !== AsyncTask.BlockResult.NOT_CANCELLED) {
+        throw new Error('uncancellable task was canceled despite second onBlock()');
+      }
+    }
+    
+    if (forCallback) {
+      const acquired = new Awaitable(cstate.exclusiveLock());
+      cancelled = await this.onBlock(acquired);
+      if (cancelled === AsyncTask.BlockResult.CANCELLED) {
+        const secondCancel = await this.onBlock(acquired);
+        if (secondCancel !== AsyncTask.BlockResult.NOT_CANCELLED) {
+          throw new Error('uncancellable callback task was canceled despite second onBlock()');
+        }
+      }
+    }
+    
+    if (cancelled === AsyncTask.BlockResult.CANCELLED) {
+      if (this.#state !== AsyncTask.State.INITIAL) {
+        throw new Error('cancelled task is not at initial state');
+      }
+      if (isCancellable) {
+        this.#state = AsyncTask.State.CANCELLED;
+        return AsyncTask.BlockResult.CANCELLED;
+      } else {
+        this.#state = AsyncTask.State.CANCEL_PENDING;
+        return AsyncTask.BlockResult.NOT_CANCELLED;
+      }
+    }
+    
+    return AsyncTask.BlockResult.NOT_CANCELLED;
+  }
+  
+  async onBlock(awaitable) {
+    _debugLog('[AsyncTask#onBlock()] args', { taskID: this.#id, awaitable });
+    if (!(awaitable instanceof Awaitable)) {
+      throw new Error('invalid awaitable during onBlock');
+    }
+    
+    // Build a promise that this task can await on which resolves when it is awoken
+    const { promise, resolve, reject } = Promise.withResolvers();
+    this.awaitableResume = () => {
+      _debugLog('[AsyncTask] resuming after onBlock', { taskID: this.#id });
+      resolve();
+    };
+    this.awaitableCancel = (err) => {
+      _debugLog('[AsyncTask] rejecting after onBlock', { taskID: this.#id, err });
+      reject(err);
+    };
+    
+    // Park this task/execution to be handled later
+    const state = getOrCreateAsyncState(this.#componentIdx);
+    state.parkTaskOnAwaitable({ awaitable, task: this });
+    
+    try {
+      await promise;
+      return AsyncTask.BlockResult.NOT_CANCELLED;
+    } catch (err) {
+      // rejection means task cancellation
+      return AsyncTask.BlockResult.CANCELLED;
+    }
+  }
+  
+  // NOTE: this should likely be moved to a SubTask class
+  async asyncOnBlock(awaitable) {
+    _debugLog('[AsyncTask#asyncOnBlock()] args', { taskID: this.#id, awaitable });
+    if (!(awaitable instanceof Awaitable)) {
+      throw new Error('invalid awaitable during onBlock');
+    }
+    // TODO: watch for waitable AND cancellation
+    // TODO: if it WAS cancelled:
+    // - return true
+    // - only once per subtask
+    // - do not wait on the scheduler
+    // - control flow should go to the subtask (only once)
+    // - Once subtask blocks/resolves, reqlinquishControl() will tehn resolve request_cancel_end (without scheduler lock release)
+    // - control flow goes back to request_cancel
+    //
+    // Subtask cancellation should work similarly to an async import call -- runs sync up until
+    // the subtask blocks or resolves
+    //
+    throw new Error('AsyncTask#asyncOnBlock() not yet implemented');
+  }
+  
+  async yield(opts) {
+    const { isCancellable, forCallback } = opts;
+    _debugLog('[AsyncTask#yield()] args', { taskID: this.#id, isCancellable, forCallback });
+    
+    if (isCancellable && this.status === AsyncTask.State.CANCEL_PENDING) {
+      this.#state = AsyncTask.State.CANCELLED;
+      return {
+        code: ASYNC_EVENT_CODE.TASK_CANCELLED,
+        payload: [0, 0],
+      };
+    }
+    
+    // TODO: Awaitables need to *always* trigger the parking mechanism when they're done...?
+    // TODO: Component async state should remember which awaitables are done and work to clear tasks waiting
+    
+    const blockResult = await this.blockOn({
+      awaitable: new Awaitable(new Promise(resolve => setTimeout(resolve, 0))),
+      isCancellable,
+      forCallback,
+    });
+    
+    if (blockResult === AsyncTask.BlockResult.CANCELLED) {
+      if (this.#state !== AsyncTask.State.INITIAL) {
+        throw new Error('task should be in initial state found [' + this.#state + ']');
+      }
+      this.#state = AsyncTask.State.CANCELLED;
+      return {
+        code: ASYNC_EVENT_CODE.TASK_CANCELLED,
+        payload: [0, 0],
+      };
+    }
+    
+    return {
+      code: ASYNC_EVENT_CODE.NONE,
+      payload: [0, 0],
+    };
+  }
+  
+  yieldSync(opts) {
+    throw new Error('AsyncTask#yieldSync() not implemented')
+  }
+  
+  cancel() {
+    _debugLog('[AsyncTask#cancel()] args', { });
+    if (!this.taskState() !== AsyncTask.State.CANCEL_DELIVERED) {
+      throw new Error('invalid task state for cancellation');
+    }
+    if (this.borrowedHandles.length > 0) { throw new Error('task still has borrow handles'); }
+    
+    this.#onResolve([]);
+    this.#state = AsyncTask.State.RESOLVED;
+  }
+  
+  resolve(result) {
+    if (this.#state === AsyncTask.State.RESOLVED) {
+      throw new Error('task is already resolved');
+    }
+    if (this.borrowedHandles.length > 0) { throw new Error('task still has borrow handles'); }
+    this.#onResolve(result);
+    this.#state = AsyncTask.State.RESOLVED;
+  }
+  
+  exit() {
+    // TODO: ensure there is only one task at a time (scheduler.lock() functionality)
+    if (this.#state !== AsyncTask.State.RESOLVED) {
+      throw new Error('task exited without resolution');
+    }
+    if (this.borrowedHandles > 0) {
+      throw new Error('task exited without clearing borrowed handles');
+    }
+    
+    const state = getOrCreateAsyncState(this.#componentIdx);
+    if (!state) { throw new Error('missing async state for component [' + this.#componentIdx + ']'); }
+    if (!this.#isAsync && !state.inSyncExportCall) {
+      throw new Error('sync task must be run from components known to be in a sync export call');
+    }
+    state.inSyncExportCall = false;
+    
+    this.startPendingTask();
+  }
+  
+  startPendingTask(opts) {
+    // TODO: implement
+  }
+  
+}
+
+function unpackCallbackResult(result) {
+  _debugLog('[unpackCallbackResult()] args', { result });
+  if (!(_typeCheckValidI32(result))) { throw new Error('invalid callback return value [' + result + '], not a valid i32'); }
+  const eventCode = result & 0xF;
+  if (eventCode < 0 || eventCode > 3) {
+    throw new Error('invalid async return value [' + eventCode + '], outside callback code range');
+  }
+  if (result < 0 || result >= 2**32) { throw new Error('invalid callback result'); }
+  // TODO: table max length check?
+  const waitableSetIdx = result >> 4;
+  return [eventCode, waitableSetIdx];
+}
+const ASYNC_STATE = new Map();
+
+function getOrCreateAsyncState(componentIdx, init) {
+  if (!ASYNC_STATE.has(componentIdx)) {
+    ASYNC_STATE.set(componentIdx, new ComponentAsyncState());
+  }
+  return ASYNC_STATE.get(componentIdx);
+}
+
+class ComponentAsyncState {
+  #callingAsyncImport = false;
+  #syncImportWait = Promise.withResolvers();
+  #lock = null;
+  
+  mayLeave = false;
+  waitableSets = new RepTable();
+  waitables = new RepTable();
+  
+  #parkedTasks = new Map();
+  
+  callingSyncImport(val) {
+    if (val === undefined) { return this.#callingAsyncImport; }
+    if (typeof val !== 'boolean') { throw new TypeError('invalid setting for async import'); }
+    const prev = this.#callingAsyncImport;
+    this.#callingAsyncImport = val;
+    if (prev === true && this.#callingAsyncImport === false) {
+      this.#notifySyncImportEnd();
+    }
+  }
+  
+  #notifySyncImportEnd() {
+    const existing = this.#syncImportWait;
+    this.#syncImportWait = Promise.withResolvers();
+    existing.resolve();
+  }
+  
+  async waitForSyncImportCallEnd() {
+    await this.#syncImportWait.promise;
+  }
+  
+  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();
+  }
+  
+  async exclusiveLock() {  // TODO: use atomics
+  if (this.#lock === null) {
+    this.#lock = { ticket: 0n };
+  }
+  
+  // Take a ticket for the next valid usage
+  const ticket = ++this.#lock.ticket;
+  
+  _debugLog('[ComponentAsyncState#exclusiveLock()] locking', {
+    currentTicket: ticket - 1n,
+    ticket
+  });
+  
+  // If there is an active promise, then wait for it
+  while (this.#lock.promise) {
+    const finishedTicket = await this.#lock.promise;
+    finishedTicket = await this.#lock.promise;
+    if (finishedTicket === ticket - 1n) { break; }
+  }
+  
+  const { promise, resolve } = Promise.withResolvers();
+  this.#lock = {
+    ticket,
+    promise,
+    resolve,
+  };
+  
+  return this.#lock.promise;
+}
+
+exclusiveRelease() {
+  _debugLog('[ComponentAsyncState#exclusiveRelease()] releasing', {
+    currentTicket: this.#lock === null ? 'none' : this.#lock.ticket,
+  });
+  
+  if (this.#lock === null) { return; }
+  
+  const existingLock = this.#lock;
+  this.#lock = null;
+  existingLock.resolve(existingLock.ticket);
+}
+
+isExclusivelyLocked() { return this.#lock !== null; }
+
+}
+
+if (!Promise.withResolvers) {
+  Promise.withResolvers = () => {
+    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 _coinFlip = () => { return Math.random() > 0.5; };
+const I32_MAX = 2_147_483_647;
+const I32_MIN = -2_147_483_648;
+const _typeCheckValidI32 = (n) => typeof n === 'number' && n >= I32_MIN && n <= I32_MAX;
 
 const base64Compile = str => WebAssembly.compile(typeof Buffer !== 'undefined' ? Buffer.from(str, 'base64') : Uint8Array.from(atob(str), b => b.charCodeAt(0)));
 
@@ -116,6 +686,54 @@ function getErrorPayload(e) {
   return e;
 }
 
+class RepTable {
+  #data = [0, null];
+  
+  insert(val) {
+    _debugLog('[RepTable#insert()] args', { val });
+    const freeIdx = this.#data[0];
+    if (freeIdx === 0) {
+      this.#data.push(val);
+      this.#data.push(null);
+      return (this.#data.length >> 1) - 1;
+    }
+    this.#data[0] = this.#data[freeIdx];
+    const newFreeIdx = freeIdx << 1;
+    this.#data[newFreeIdx] = val;
+    this.#data[newFreeIdx + 1] = null;
+    return free;
+  }
+  
+  get(rep) {
+    _debugLog('[RepTable#insert()] args', { rep });
+    const baseIdx = idx << 1;
+    const val = this.#data[baseIdx];
+    return val;
+  }
+  
+  contains(rep) {
+    _debugLog('[RepTable#insert()] args', { rep });
+    const baseIdx = idx << 1;
+    return !!this.#data[baseIdx];
+  }
+  
+  remove(rep) {
+    _debugLog('[RepTable#insert()] args', { idx });
+    if (this.#data.length === 2) { throw new Error('invalid'); }
+    
+    const baseIdx = idx << 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] = idx;
+    return val;
+  }
+  
+  clear() {
+    this.#data = [0, null];
+  }
+}
+
 function throwUninitialized() {
   throw new TypeError('Wasm uninitialized use `await $init` first');
 }
@@ -133,7 +751,10 @@ let captureCnt2 = 0;
 handleTables[2] = handleTable2;
 
 function trampoline5() {
+  _debugLog('[iface="wasi:cli/stderr@0.2.3", function="get-stderr"] [Instruction::CallInterface] (async? sync, @ enter)');
+  const _interface_call_currentTaskID = startCurrentTask(0, false, 'get-stderr');
   const ret = getStderr();
+  _debugLog('[iface="wasi:cli/stderr@0.2.3", function="get-stderr"] [Instruction::CallInterface] (sync, @ post-call)');
   if (!(ret instanceof OutputStream)) {
     throw new TypeError('Resource error: Not a valid "OutputStream" resource.');
   }
@@ -143,6 +764,11 @@ function trampoline5() {
     captureTable2.set(rep, ret);
     handle0 = rscTableCreateOwn(handleTable2, rep);
   }
+  _debugLog('[iface="wasi:cli/stderr@0.2.3", function="get-stderr"][Instruction::Return]', {
+    funcName: 'get-stderr',
+    paramCount: 1,
+    postReturn: false
+  });
   return handle0;
 }
 
@@ -152,7 +778,10 @@ let captureCnt1 = 0;
 handleTables[1] = handleTable1;
 
 function trampoline8() {
+  _debugLog('[iface="wasi:cli/stdin@0.2.3", function="get-stdin"] [Instruction::CallInterface] (async? sync, @ enter)');
+  const _interface_call_currentTaskID = startCurrentTask(0, false, 'get-stdin');
   const ret = getStdin();
+  _debugLog('[iface="wasi:cli/stdin@0.2.3", function="get-stdin"] [Instruction::CallInterface] (sync, @ post-call)');
   if (!(ret instanceof InputStream)) {
     throw new TypeError('Resource error: Not a valid "InputStream" resource.');
   }
@@ -162,12 +791,20 @@ function trampoline8() {
     captureTable1.set(rep, ret);
     handle0 = rscTableCreateOwn(handleTable1, rep);
   }
+  _debugLog('[iface="wasi:cli/stdin@0.2.3", function="get-stdin"][Instruction::Return]', {
+    funcName: 'get-stdin',
+    paramCount: 1,
+    postReturn: false
+  });
   return handle0;
 }
 
 
 function trampoline9() {
+  _debugLog('[iface="wasi:cli/stdout@0.2.3", function="get-stdout"] [Instruction::CallInterface] (async? sync, @ enter)');
+  const _interface_call_currentTaskID = startCurrentTask(0, false, 'get-stdout');
   const ret = getStdout();
+  _debugLog('[iface="wasi:cli/stdout@0.2.3", function="get-stdout"] [Instruction::CallInterface] (sync, @ post-call)');
   if (!(ret instanceof OutputStream)) {
     throw new TypeError('Resource error: Not a valid "OutputStream" resource.');
   }
@@ -177,6 +814,11 @@ function trampoline9() {
     captureTable2.set(rep, ret);
     handle0 = rscTableCreateOwn(handleTable2, rep);
   }
+  _debugLog('[iface="wasi:cli/stdout@0.2.3", function="get-stdout"][Instruction::Return]', {
+    funcName: 'get-stdout',
+    paramCount: 1,
+    postReturn: false
+  });
   return handle0;
 }
 
@@ -202,7 +844,15 @@ function trampoline10(arg0) {
       throw new TypeError('invalid variant discriminant for expected');
     }
   }
+  _debugLog('[iface="wasi:cli/exit@0.2.3", function="exit"] [Instruction::CallInterface] (async? sync, @ enter)');
+  const _interface_call_currentTaskID = startCurrentTask(0, false, 'exit');
   exit(variant0);
+  _debugLog('[iface="wasi:cli/exit@0.2.3", function="exit"] [Instruction::CallInterface] (sync, @ post-call)');
+  _debugLog('[iface="wasi:cli/exit@0.2.3", function="exit"][Instruction::Return]', {
+    funcName: 'exit',
+    paramCount: 0,
+    postReturn: false
+  });
 }
 
 let exports2;
@@ -210,7 +860,10 @@ let memory0;
 let realloc0;
 
 function trampoline11(arg0) {
+  _debugLog('[iface="wasi:cli/environment@0.2.3", function="get-environment"] [Instruction::CallInterface] (async? sync, @ enter)');
+  const _interface_call_currentTaskID = startCurrentTask(0, false, 'get-environment');
   const ret = getEnvironment();
+  _debugLog('[iface="wasi:cli/environment@0.2.3", function="get-environment"] [Instruction::CallInterface] (sync, @ post-call)');
   var vec3 = ret;
   var len3 = vec3.length;
   var result3 = realloc0(0, 0, 4, len3 * 16);
@@ -228,6 +881,11 @@ function trampoline11(arg0) {
   }
   dataView(memory0).setInt32(arg0 + 4, len3, true);
   dataView(memory0).setInt32(arg0 + 0, result3, true);
+  _debugLog('[iface="wasi:cli/environment@0.2.3", function="get-environment"][Instruction::Return]', {
+    funcName: 'get-environment',
+    paramCount: 0,
+    postReturn: false
+  });
 }
 
 const handleTable6 = [T_FLAG, 0];
@@ -245,12 +903,15 @@ function trampoline12(arg0, arg1) {
     Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
   }
   curResourceBorrows.push(rsc0);
+  _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.get-type"] [Instruction::CallInterface] (async? sync, @ enter)');
+  const _interface_call_currentTaskID = startCurrentTask(0, false, '[method]descriptor.get-type');
   let ret;
   try {
     ret = { tag: 'ok', val: rsc0.getType()};
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
+  _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.get-type"] [Instruction::CallInterface] (sync, @ post-call)');
   for (const rsc of curResourceBorrows) {
     rsc[symbolRscHandle] = undefined;
   }
@@ -475,6 +1136,11 @@ function trampoline12(arg0, arg1) {
       throw new TypeError('invalid variant specified for result');
     }
   }
+  _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.get-type"][Instruction::Return]', {
+    funcName: '[method]descriptor.get-type',
+    paramCount: 0,
+    postReturn: false
+  });
 }
 
 
@@ -488,12 +1154,15 @@ function trampoline13(arg0, arg1) {
     Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
   }
   curResourceBorrows.push(rsc0);
+  _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.metadata-hash"] [Instruction::CallInterface] (async? sync, @ enter)');
+  const _interface_call_currentTaskID = startCurrentTask(0, false, '[method]descriptor.metadata-hash');
   let ret;
   try {
     ret = { tag: 'ok', val: rsc0.metadataHash()};
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
+  _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.metadata-hash"] [Instruction::CallInterface] (sync, @ post-call)');
   for (const rsc of curResourceBorrows) {
     rsc[symbolRscHandle] = undefined;
   }
@@ -677,6 +1346,11 @@ function trampoline13(arg0, arg1) {
       throw new TypeError('invalid variant specified for result');
     }
   }
+  _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.metadata-hash"][Instruction::Return]', {
+    funcName: '[method]descriptor.metadata-hash',
+    paramCount: 0,
+    postReturn: false
+  });
 }
 
 const handleTable0 = [T_FLAG, 0];
@@ -694,7 +1368,10 @@ function trampoline14(arg0, arg1) {
     Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
   }
   curResourceBorrows.push(rsc0);
+  _debugLog('[iface="wasi:filesystem/types@0.2.3", function="filesystem-error-code"] [Instruction::CallInterface] (async? sync, @ enter)');
+  const _interface_call_currentTaskID = startCurrentTask(0, false, 'filesystem-error-code');
   const ret = filesystemErrorCode(rsc0);
+  _debugLog('[iface="wasi:filesystem/types@0.2.3", function="filesystem-error-code"] [Instruction::CallInterface] (sync, @ post-call)');
   for (const rsc of curResourceBorrows) {
     rsc[symbolRscHandle] = undefined;
   }
@@ -866,6 +1543,11 @@ function trampoline14(arg0, arg1) {
     }
     dataView(memory0).setInt8(arg1 + 1, enum3, true);
   }
+  _debugLog('[iface="wasi:filesystem/types@0.2.3", function="filesystem-error-code"][Instruction::Return]', {
+    funcName: 'filesystem-error-code',
+    paramCount: 0,
+    postReturn: false
+  });
 }
 
 
@@ -888,12 +1570,15 @@ function trampoline15(arg0, arg1, arg2, arg3, arg4) {
   var ptr4 = arg2;
   var len4 = arg3;
   var result4 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr4, len4));
+  _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.metadata-hash-at"] [Instruction::CallInterface] (async? sync, @ enter)');
+  const _interface_call_currentTaskID = startCurrentTask(0, false, '[method]descriptor.metadata-hash-at');
   let ret;
   try {
     ret = { tag: 'ok', val: rsc0.metadataHashAt(flags3, result4)};
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
+  _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.metadata-hash-at"] [Instruction::CallInterface] (sync, @ post-call)');
   for (const rsc of curResourceBorrows) {
     rsc[symbolRscHandle] = undefined;
   }
@@ -1077,6 +1762,11 @@ function trampoline15(arg0, arg1, arg2, arg3, arg4) {
       throw new TypeError('invalid variant specified for result');
     }
   }
+  _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.metadata-hash-at"][Instruction::Return]', {
+    funcName: '[method]descriptor.metadata-hash-at',
+    paramCount: 0,
+    postReturn: false
+  });
 }
 
 
@@ -1090,12 +1780,15 @@ function trampoline16(arg0, arg1, arg2) {
     Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
   }
   curResourceBorrows.push(rsc0);
+  _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.read-via-stream"] [Instruction::CallInterface] (async? sync, @ enter)');
+  const _interface_call_currentTaskID = startCurrentTask(0, false, '[method]descriptor.read-via-stream');
   let ret;
   try {
     ret = { tag: 'ok', val: rsc0.readViaStream(BigInt.asUintN(64, arg1))};
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
+  _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.read-via-stream"] [Instruction::CallInterface] (sync, @ post-call)');
   for (const rsc of curResourceBorrows) {
     rsc[symbolRscHandle] = undefined;
   }
@@ -1286,6 +1979,11 @@ function trampoline16(arg0, arg1, arg2) {
       throw new TypeError('invalid variant specified for result');
     }
   }
+  _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.read-via-stream"][Instruction::Return]', {
+    funcName: '[method]descriptor.read-via-stream',
+    paramCount: 0,
+    postReturn: false
+  });
 }
 
 
@@ -1299,12 +1997,15 @@ function trampoline17(arg0, arg1, arg2) {
     Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
   }
   curResourceBorrows.push(rsc0);
+  _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.write-via-stream"] [Instruction::CallInterface] (async? sync, @ enter)');
+  const _interface_call_currentTaskID = startCurrentTask(0, false, '[method]descriptor.write-via-stream');
   let ret;
   try {
     ret = { tag: 'ok', val: rsc0.writeViaStream(BigInt.asUintN(64, arg1))};
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
+  _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.write-via-stream"] [Instruction::CallInterface] (sync, @ post-call)');
   for (const rsc of curResourceBorrows) {
     rsc[symbolRscHandle] = undefined;
   }
@@ -1495,6 +2196,11 @@ function trampoline17(arg0, arg1, arg2) {
       throw new TypeError('invalid variant specified for result');
     }
   }
+  _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.write-via-stream"][Instruction::Return]', {
+    funcName: '[method]descriptor.write-via-stream',
+    paramCount: 0,
+    postReturn: false
+  });
 }
 
 
@@ -1508,12 +2214,15 @@ function trampoline18(arg0, arg1) {
     Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
   }
   curResourceBorrows.push(rsc0);
+  _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.append-via-stream"] [Instruction::CallInterface] (async? sync, @ enter)');
+  const _interface_call_currentTaskID = startCurrentTask(0, false, '[method]descriptor.append-via-stream');
   let ret;
   try {
     ret = { tag: 'ok', val: rsc0.appendViaStream()};
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
+  _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.append-via-stream"] [Instruction::CallInterface] (sync, @ post-call)');
   for (const rsc of curResourceBorrows) {
     rsc[symbolRscHandle] = undefined;
   }
@@ -1704,6 +2413,11 @@ function trampoline18(arg0, arg1) {
       throw new TypeError('invalid variant specified for result');
     }
   }
+  _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.append-via-stream"][Instruction::Return]', {
+    funcName: '[method]descriptor.append-via-stream',
+    paramCount: 0,
+    postReturn: false
+  });
 }
 
 const handleTable5 = [T_FLAG, 0];
@@ -1721,12 +2435,15 @@ function trampoline19(arg0, arg1) {
     Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
   }
   curResourceBorrows.push(rsc0);
+  _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.read-directory"] [Instruction::CallInterface] (async? sync, @ enter)');
+  const _interface_call_currentTaskID = startCurrentTask(0, false, '[method]descriptor.read-directory');
   let ret;
   try {
     ret = { tag: 'ok', val: rsc0.readDirectory()};
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
+  _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.read-directory"] [Instruction::CallInterface] (sync, @ post-call)');
   for (const rsc of curResourceBorrows) {
     rsc[symbolRscHandle] = undefined;
   }
@@ -1917,6 +2634,11 @@ function trampoline19(arg0, arg1) {
       throw new TypeError('invalid variant specified for result');
     }
   }
+  _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.read-directory"][Instruction::Return]', {
+    funcName: '[method]descriptor.read-directory',
+    paramCount: 0,
+    postReturn: false
+  });
 }
 
 
@@ -1930,12 +2652,15 @@ function trampoline20(arg0, arg1) {
     Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
   }
   curResourceBorrows.push(rsc0);
+  _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.stat"] [Instruction::CallInterface] (async? sync, @ enter)');
+  const _interface_call_currentTaskID = startCurrentTask(0, false, '[method]descriptor.stat');
   let ret;
   try {
     ret = { tag: 'ok', val: rsc0.stat()};
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
+  _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.stat"] [Instruction::CallInterface] (sync, @ post-call)');
   for (const rsc of curResourceBorrows) {
     rsc[symbolRscHandle] = undefined;
   }
@@ -2193,6 +2918,11 @@ function trampoline20(arg0, arg1) {
       throw new TypeError('invalid variant specified for result');
     }
   }
+  _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.stat"][Instruction::Return]', {
+    funcName: '[method]descriptor.stat',
+    paramCount: 0,
+    postReturn: false
+  });
 }
 
 
@@ -2215,12 +2945,15 @@ function trampoline21(arg0, arg1, arg2, arg3, arg4) {
   var ptr4 = arg2;
   var len4 = arg3;
   var result4 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr4, len4));
+  _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.stat-at"] [Instruction::CallInterface] (async? sync, @ enter)');
+  const _interface_call_currentTaskID = startCurrentTask(0, false, '[method]descriptor.stat-at');
   let ret;
   try {
     ret = { tag: 'ok', val: rsc0.statAt(flags3, result4)};
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
+  _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.stat-at"] [Instruction::CallInterface] (sync, @ post-call)');
   for (const rsc of curResourceBorrows) {
     rsc[symbolRscHandle] = undefined;
   }
@@ -2478,6 +3211,11 @@ function trampoline21(arg0, arg1, arg2, arg3, arg4) {
       throw new TypeError('invalid variant specified for result');
     }
   }
+  _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.stat-at"][Instruction::Return]', {
+    funcName: '[method]descriptor.stat-at',
+    paramCount: 0,
+    postReturn: false
+  });
 }
 
 
@@ -2520,12 +3258,15 @@ function trampoline22(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
     requestedWriteSync: Boolean(arg5 & 16),
     mutateDirectory: Boolean(arg5 & 32),
   };
+  _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.open-at"] [Instruction::CallInterface] (async? sync, @ enter)');
+  const _interface_call_currentTaskID = startCurrentTask(0, false, '[method]descriptor.open-at');
   let ret;
   try {
     ret = { tag: 'ok', val: rsc0.openAt(flags3, result4, flags5, flags6)};
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
+  _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.open-at"] [Instruction::CallInterface] (sync, @ post-call)');
   for (const rsc of curResourceBorrows) {
     rsc[symbolRscHandle] = undefined;
   }
@@ -2716,6 +3457,11 @@ function trampoline22(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
       throw new TypeError('invalid variant specified for result');
     }
   }
+  _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.open-at"][Instruction::Return]', {
+    funcName: '[method]descriptor.open-at',
+    paramCount: 0,
+    postReturn: false
+  });
 }
 
 
@@ -2729,12 +3475,15 @@ function trampoline23(arg0, arg1) {
     Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
   }
   curResourceBorrows.push(rsc0);
+  _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]directory-entry-stream.read-directory-entry"] [Instruction::CallInterface] (async? sync, @ enter)');
+  const _interface_call_currentTaskID = startCurrentTask(0, false, '[method]directory-entry-stream.read-directory-entry');
   let ret;
   try {
     ret = { tag: 'ok', val: rsc0.readDirectoryEntry()};
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
+  _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]directory-entry-stream.read-directory-entry"] [Instruction::CallInterface] (sync, @ post-call)');
   for (const rsc of curResourceBorrows) {
     rsc[symbolRscHandle] = undefined;
   }
@@ -2971,6 +3720,11 @@ function trampoline23(arg0, arg1) {
       throw new TypeError('invalid variant specified for result');
     }
   }
+  _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]directory-entry-stream.read-directory-entry"][Instruction::Return]', {
+    funcName: '[method]directory-entry-stream.read-directory-entry',
+    paramCount: 0,
+    postReturn: false
+  });
 }
 
 
@@ -2984,12 +3738,15 @@ function trampoline24(arg0, arg1, arg2) {
     Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
   }
   curResourceBorrows.push(rsc0);
+  _debugLog('[iface="wasi:io/streams@0.2.3", function="[method]input-stream.read"] [Instruction::CallInterface] (async? sync, @ enter)');
+  const _interface_call_currentTaskID = startCurrentTask(0, false, '[method]input-stream.read');
   let ret;
   try {
     ret = { tag: 'ok', val: rsc0.read(BigInt.asUintN(64, arg1))};
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
+  _debugLog('[iface="wasi:io/streams@0.2.3", function="[method]input-stream.read"] [Instruction::CallInterface] (sync, @ post-call)');
   for (const rsc of curResourceBorrows) {
     rsc[symbolRscHandle] = undefined;
   }
@@ -3042,6 +3799,11 @@ function trampoline24(arg0, arg1, arg2) {
       throw new TypeError('invalid variant specified for result');
     }
   }
+  _debugLog('[iface="wasi:io/streams@0.2.3", function="[method]input-stream.read"][Instruction::Return]', {
+    funcName: '[method]input-stream.read',
+    paramCount: 0,
+    postReturn: false
+  });
 }
 
 
@@ -3055,12 +3817,15 @@ function trampoline25(arg0, arg1, arg2) {
     Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
   }
   curResourceBorrows.push(rsc0);
+  _debugLog('[iface="wasi:io/streams@0.2.3", function="[method]input-stream.blocking-read"] [Instruction::CallInterface] (async? sync, @ enter)');
+  const _interface_call_currentTaskID = startCurrentTask(0, false, '[method]input-stream.blocking-read');
   let ret;
   try {
     ret = { tag: 'ok', val: rsc0.blockingRead(BigInt.asUintN(64, arg1))};
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
+  _debugLog('[iface="wasi:io/streams@0.2.3", function="[method]input-stream.blocking-read"] [Instruction::CallInterface] (sync, @ post-call)');
   for (const rsc of curResourceBorrows) {
     rsc[symbolRscHandle] = undefined;
   }
@@ -3113,6 +3878,11 @@ function trampoline25(arg0, arg1, arg2) {
       throw new TypeError('invalid variant specified for result');
     }
   }
+  _debugLog('[iface="wasi:io/streams@0.2.3", function="[method]input-stream.blocking-read"][Instruction::Return]', {
+    funcName: '[method]input-stream.blocking-read',
+    paramCount: 0,
+    postReturn: false
+  });
 }
 
 
@@ -3126,12 +3896,15 @@ function trampoline26(arg0, arg1) {
     Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
   }
   curResourceBorrows.push(rsc0);
+  _debugLog('[iface="wasi:io/streams@0.2.3", function="[method]output-stream.check-write"] [Instruction::CallInterface] (async? sync, @ enter)');
+  const _interface_call_currentTaskID = startCurrentTask(0, false, '[method]output-stream.check-write');
   let ret;
   try {
     ret = { tag: 'ok', val: rsc0.checkWrite()};
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
+  _debugLog('[iface="wasi:io/streams@0.2.3", function="[method]output-stream.check-write"] [Instruction::CallInterface] (sync, @ post-call)');
   for (const rsc of curResourceBorrows) {
     rsc[symbolRscHandle] = undefined;
   }
@@ -3178,6 +3951,11 @@ function trampoline26(arg0, arg1) {
       throw new TypeError('invalid variant specified for result');
     }
   }
+  _debugLog('[iface="wasi:io/streams@0.2.3", function="[method]output-stream.check-write"][Instruction::Return]', {
+    funcName: '[method]output-stream.check-write',
+    paramCount: 0,
+    postReturn: false
+  });
 }
 
 
@@ -3194,12 +3972,15 @@ function trampoline27(arg0, arg1, arg2, arg3) {
   var ptr3 = arg1;
   var len3 = arg2;
   var result3 = new Uint8Array(memory0.buffer.slice(ptr3, ptr3 + len3 * 1));
+  _debugLog('[iface="wasi:io/streams@0.2.3", function="[method]output-stream.write"] [Instruction::CallInterface] (async? sync, @ enter)');
+  const _interface_call_currentTaskID = startCurrentTask(0, false, '[method]output-stream.write');
   let ret;
   try {
     ret = { tag: 'ok', val: rsc0.write(result3)};
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
+  _debugLog('[iface="wasi:io/streams@0.2.3", function="[method]output-stream.write"] [Instruction::CallInterface] (sync, @ post-call)');
   for (const rsc of curResourceBorrows) {
     rsc[symbolRscHandle] = undefined;
   }
@@ -3245,6 +4026,11 @@ function trampoline27(arg0, arg1, arg2, arg3) {
       throw new TypeError('invalid variant specified for result');
     }
   }
+  _debugLog('[iface="wasi:io/streams@0.2.3", function="[method]output-stream.write"][Instruction::Return]', {
+    funcName: '[method]output-stream.write',
+    paramCount: 0,
+    postReturn: false
+  });
 }
 
 
@@ -3261,12 +4047,15 @@ function trampoline28(arg0, arg1, arg2, arg3) {
   var ptr3 = arg1;
   var len3 = arg2;
   var result3 = new Uint8Array(memory0.buffer.slice(ptr3, ptr3 + len3 * 1));
+  _debugLog('[iface="wasi:io/streams@0.2.3", function="[method]output-stream.blocking-write-and-flush"] [Instruction::CallInterface] (async? sync, @ enter)');
+  const _interface_call_currentTaskID = startCurrentTask(0, false, '[method]output-stream.blocking-write-and-flush');
   let ret;
   try {
     ret = { tag: 'ok', val: rsc0.blockingWriteAndFlush(result3)};
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
+  _debugLog('[iface="wasi:io/streams@0.2.3", function="[method]output-stream.blocking-write-and-flush"] [Instruction::CallInterface] (sync, @ post-call)');
   for (const rsc of curResourceBorrows) {
     rsc[symbolRscHandle] = undefined;
   }
@@ -3312,6 +4101,11 @@ function trampoline28(arg0, arg1, arg2, arg3) {
       throw new TypeError('invalid variant specified for result');
     }
   }
+  _debugLog('[iface="wasi:io/streams@0.2.3", function="[method]output-stream.blocking-write-and-flush"][Instruction::Return]', {
+    funcName: '[method]output-stream.blocking-write-and-flush',
+    paramCount: 0,
+    postReturn: false
+  });
 }
 
 
@@ -3325,12 +4119,15 @@ function trampoline29(arg0, arg1) {
     Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
   }
   curResourceBorrows.push(rsc0);
+  _debugLog('[iface="wasi:io/streams@0.2.3", function="[method]output-stream.blocking-flush"] [Instruction::CallInterface] (async? sync, @ enter)');
+  const _interface_call_currentTaskID = startCurrentTask(0, false, '[method]output-stream.blocking-flush');
   let ret;
   try {
     ret = { tag: 'ok', val: rsc0.blockingFlush()};
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
+  _debugLog('[iface="wasi:io/streams@0.2.3", function="[method]output-stream.blocking-flush"] [Instruction::CallInterface] (sync, @ post-call)');
   for (const rsc of curResourceBorrows) {
     rsc[symbolRscHandle] = undefined;
   }
@@ -3376,11 +4173,19 @@ function trampoline29(arg0, arg1) {
       throw new TypeError('invalid variant specified for result');
     }
   }
+  _debugLog('[iface="wasi:io/streams@0.2.3", function="[method]output-stream.blocking-flush"][Instruction::Return]', {
+    funcName: '[method]output-stream.blocking-flush',
+    paramCount: 0,
+    postReturn: false
+  });
 }
 
 
 function trampoline30(arg0, arg1) {
+  _debugLog('[iface="wasi:random/random@0.2.3", function="get-random-bytes"] [Instruction::CallInterface] (async? sync, @ enter)');
+  const _interface_call_currentTaskID = startCurrentTask(0, false, 'get-random-bytes');
   const ret = getRandomBytes(BigInt.asUintN(64, arg0));
+  _debugLog('[iface="wasi:random/random@0.2.3", function="get-random-bytes"] [Instruction::CallInterface] (sync, @ post-call)');
   var val0 = ret;
   var len0 = val0.byteLength;
   var ptr0 = realloc0(0, 0, 1, len0 * 1);
@@ -3388,11 +4193,19 @@ function trampoline30(arg0, arg1) {
   (new Uint8Array(memory0.buffer, ptr0, len0 * 1)).set(src0);
   dataView(memory0).setInt32(arg1 + 4, len0, true);
   dataView(memory0).setInt32(arg1 + 0, ptr0, true);
+  _debugLog('[iface="wasi:random/random@0.2.3", function="get-random-bytes"][Instruction::Return]', {
+    funcName: 'get-random-bytes',
+    paramCount: 0,
+    postReturn: false
+  });
 }
 
 
 function trampoline31(arg0) {
+  _debugLog('[iface="wasi:filesystem/preopens@0.2.3", function="get-directories"] [Instruction::CallInterface] (async? sync, @ enter)');
+  const _interface_call_currentTaskID = startCurrentTask(0, false, 'get-directories');
   const ret = getDirectories();
+  _debugLog('[iface="wasi:filesystem/preopens@0.2.3", function="get-directories"] [Instruction::CallInterface] (sync, @ post-call)');
   var vec3 = ret;
   var len3 = vec3.length;
   var result3 = realloc0(0, 0, 4, len3 * 12);
@@ -3416,6 +4229,11 @@ function trampoline31(arg0) {
   }
   dataView(memory0).setInt32(arg0 + 4, len3, true);
   dataView(memory0).setInt32(arg0 + 0, result3, true);
+  _debugLog('[iface="wasi:filesystem/preopens@0.2.3", function="get-directories"][Instruction::Return]', {
+    funcName: 'get-directories',
+    paramCount: 0,
+    postReturn: false
+  });
 }
 
 const handleTable3 = [T_FLAG, 0];
@@ -3424,7 +4242,10 @@ let captureCnt3 = 0;
 handleTables[3] = handleTable3;
 
 function trampoline32(arg0) {
+  _debugLog('[iface="wasi:cli/terminal-stdin@0.2.3", function="get-terminal-stdin"] [Instruction::CallInterface] (async? sync, @ enter)');
+  const _interface_call_currentTaskID = startCurrentTask(0, false, 'get-terminal-stdin');
   const ret = getTerminalStdin();
+  _debugLog('[iface="wasi:cli/terminal-stdin@0.2.3", function="get-terminal-stdin"] [Instruction::CallInterface] (sync, @ post-call)');
   var variant1 = ret;
   if (variant1 === null || variant1=== undefined) {
     dataView(memory0).setInt8(arg0 + 0, 0, true);
@@ -3442,6 +4263,11 @@ function trampoline32(arg0) {
     }
     dataView(memory0).setInt32(arg0 + 4, handle0, true);
   }
+  _debugLog('[iface="wasi:cli/terminal-stdin@0.2.3", function="get-terminal-stdin"][Instruction::Return]', {
+    funcName: 'get-terminal-stdin',
+    paramCount: 0,
+    postReturn: false
+  });
 }
 
 const handleTable4 = [T_FLAG, 0];
@@ -3450,7 +4276,10 @@ let captureCnt4 = 0;
 handleTables[4] = handleTable4;
 
 function trampoline33(arg0) {
+  _debugLog('[iface="wasi:cli/terminal-stdout@0.2.3", function="get-terminal-stdout"] [Instruction::CallInterface] (async? sync, @ enter)');
+  const _interface_call_currentTaskID = startCurrentTask(0, false, 'get-terminal-stdout');
   const ret = getTerminalStdout();
+  _debugLog('[iface="wasi:cli/terminal-stdout@0.2.3", function="get-terminal-stdout"] [Instruction::CallInterface] (sync, @ post-call)');
   var variant1 = ret;
   if (variant1 === null || variant1=== undefined) {
     dataView(memory0).setInt8(arg0 + 0, 0, true);
@@ -3468,11 +4297,19 @@ function trampoline33(arg0) {
     }
     dataView(memory0).setInt32(arg0 + 4, handle0, true);
   }
+  _debugLog('[iface="wasi:cli/terminal-stdout@0.2.3", function="get-terminal-stdout"][Instruction::Return]', {
+    funcName: 'get-terminal-stdout',
+    paramCount: 0,
+    postReturn: false
+  });
 }
 
 
 function trampoline34(arg0) {
+  _debugLog('[iface="wasi:cli/terminal-stderr@0.2.3", function="get-terminal-stderr"] [Instruction::CallInterface] (async? sync, @ enter)');
+  const _interface_call_currentTaskID = startCurrentTask(0, false, 'get-terminal-stderr');
   const ret = getTerminalStderr();
+  _debugLog('[iface="wasi:cli/terminal-stderr@0.2.3", function="get-terminal-stderr"] [Instruction::CallInterface] (sync, @ post-call)');
   var variant1 = ret;
   if (variant1 === null || variant1=== undefined) {
     dataView(memory0).setInt8(arg0 + 0, 0, true);
@@ -3490,6 +4327,11 @@ function trampoline34(arg0) {
     }
     dataView(memory0).setInt32(arg0 + 4, handle0, true);
   }
+  _debugLog('[iface="wasi:cli/terminal-stderr@0.2.3", function="get-terminal-stderr"][Instruction::Return]', {
+    funcName: 'get-terminal-stderr',
+    paramCount: 0,
+    postReturn: false
+  });
 }
 
 let exports3;
@@ -3593,7 +4435,10 @@ function parse(arg0) {
   if (!_initialized) throwUninitialized();
   var ptr0 = utf8Encode(arg0, realloc1, memory0);
   var len0 = utf8EncodedLen;
+  _debugLog('[iface="local:wasm-tools/tools", function="parse"] [Instruction::CallWasm] (async? false, @ enter)');
+  const _wasm_call_currentTaskID = startCurrentTask(0, false, 'toolsParse');
   const ret = toolsParse(ptr0, len0);
+  endCurrentTask(0);
   let variant3;
   switch (dataView(memory0).getUint8(ret + 0, true)) {
     case 0: {
@@ -3620,12 +4465,25 @@ function parse(arg0) {
       throw new TypeError('invalid variant discriminant for expected');
     }
   }
-  const retVal = variant3;
+  _debugLog('[iface="local:wasm-tools/tools", function="parse"][Instruction::Return]', {
+    funcName: 'parse',
+    paramCount: 1,
+    postReturn: true
+  });
+  const retCopy = variant3;
+  
+  let cstate = getOrCreateAsyncState(0);
+  cstate.mayLeave = false;
   postReturn0(ret);
-  if (typeof retVal === 'object' && retVal.tag === 'err') {
-    throw new ComponentError(retVal.val);
+  cstate.mayLeave = true;
+  
+  
+  
+  if (typeof retCopy === 'object' && retCopy.tag === 'err') {
+    throw new ComponentError(retCopy.val);
   }
-  return retVal.val;
+  return retCopy.val;
+  
 }
 let toolsPrint;
 
@@ -3636,7 +4494,10 @@ function print(arg0) {
   var ptr0 = realloc1(0, 0, 1, len0 * 1);
   var src0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, len0 * 1);
   (new Uint8Array(memory0.buffer, ptr0, len0 * 1)).set(src0);
+  _debugLog('[iface="local:wasm-tools/tools", function="print"] [Instruction::CallWasm] (async? false, @ enter)');
+  const _wasm_call_currentTaskID = startCurrentTask(0, false, 'toolsPrint');
   const ret = toolsPrint(ptr0, len0);
+  endCurrentTask(0);
   let variant3;
   switch (dataView(memory0).getUint8(ret + 0, true)) {
     case 0: {
@@ -3663,12 +4524,25 @@ function print(arg0) {
       throw new TypeError('invalid variant discriminant for expected');
     }
   }
-  const retVal = variant3;
+  _debugLog('[iface="local:wasm-tools/tools", function="print"][Instruction::Return]', {
+    funcName: 'print',
+    paramCount: 1,
+    postReturn: true
+  });
+  const retCopy = variant3;
+  
+  let cstate = getOrCreateAsyncState(0);
+  cstate.mayLeave = false;
   postReturn0(ret);
-  if (typeof retVal === 'object' && retVal.tag === 'err') {
-    throw new ComponentError(retVal.val);
+  cstate.mayLeave = true;
+  
+  
+  
+  if (typeof retCopy === 'object' && retCopy.tag === 'err') {
+    throw new ComponentError(retCopy.val);
   }
-  return retVal.val;
+  return retCopy.val;
+  
 }
 let toolsComponentNew;
 
@@ -3711,7 +4585,10 @@ function componentNew(arg0, arg1) {
     variant5_1 = result4;
     variant5_2 = len4;
   }
+  _debugLog('[iface="local:wasm-tools/tools", function="component-new"] [Instruction::CallWasm] (async? false, @ enter)');
+  const _wasm_call_currentTaskID = startCurrentTask(0, false, 'toolsComponentNew');
   const ret = toolsComponentNew(ptr0, len0, variant5_0, variant5_1, variant5_2);
+  endCurrentTask(0);
   let variant8;
   switch (dataView(memory0).getUint8(ret + 0, true)) {
     case 0: {
@@ -3738,12 +4615,25 @@ function componentNew(arg0, arg1) {
       throw new TypeError('invalid variant discriminant for expected');
     }
   }
-  const retVal = variant8;
+  _debugLog('[iface="local:wasm-tools/tools", function="component-new"][Instruction::Return]', {
+    funcName: 'component-new',
+    paramCount: 1,
+    postReturn: true
+  });
+  const retCopy = variant8;
+  
+  let cstate = getOrCreateAsyncState(0);
+  cstate.mayLeave = false;
   postReturn0(ret);
-  if (typeof retVal === 'object' && retVal.tag === 'err') {
-    throw new ComponentError(retVal.val);
+  cstate.mayLeave = true;
+  
+  
+  
+  if (typeof retCopy === 'object' && retCopy.tag === 'err') {
+    throw new ComponentError(retCopy.val);
   }
-  return retVal.val;
+  return retCopy.val;
+  
 }
 let toolsComponentWit;
 
@@ -3754,7 +4644,10 @@ function componentWit(arg0) {
   var ptr0 = realloc1(0, 0, 1, len0 * 1);
   var src0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, len0 * 1);
   (new Uint8Array(memory0.buffer, ptr0, len0 * 1)).set(src0);
+  _debugLog('[iface="local:wasm-tools/tools", function="component-wit"] [Instruction::CallWasm] (async? false, @ enter)');
+  const _wasm_call_currentTaskID = startCurrentTask(0, false, 'toolsComponentWit');
   const ret = toolsComponentWit(ptr0, len0);
+  endCurrentTask(0);
   let variant3;
   switch (dataView(memory0).getUint8(ret + 0, true)) {
     case 0: {
@@ -3781,12 +4674,25 @@ function componentWit(arg0) {
       throw new TypeError('invalid variant discriminant for expected');
     }
   }
-  const retVal = variant3;
+  _debugLog('[iface="local:wasm-tools/tools", function="component-wit"][Instruction::Return]', {
+    funcName: 'component-wit',
+    paramCount: 1,
+    postReturn: true
+  });
+  const retCopy = variant3;
+  
+  let cstate = getOrCreateAsyncState(0);
+  cstate.mayLeave = false;
   postReturn0(ret);
-  if (typeof retVal === 'object' && retVal.tag === 'err') {
-    throw new ComponentError(retVal.val);
+  cstate.mayLeave = true;
+  
+  
+  
+  if (typeof retCopy === 'object' && retCopy.tag === 'err') {
+    throw new ComponentError(retCopy.val);
   }
-  return retVal.val;
+  return retCopy.val;
+  
 }
 let toolsComponentEmbed;
 
@@ -3951,7 +4857,10 @@ function componentEmbed(arg0) {
       }
     }
   }
+  _debugLog('[iface="local:wasm-tools/tools", function="component-embed"] [Instruction::CallWasm] (async? false, @ enter)');
+  const _wasm_call_currentTaskID = startCurrentTask(0, false, 'toolsComponentEmbed');
   const ret = toolsComponentEmbed(ptr0);
+  endCurrentTask(0);
   let variant27;
   switch (dataView(memory0).getUint8(ret + 0, true)) {
     case 0: {
@@ -3978,12 +4887,25 @@ function componentEmbed(arg0) {
       throw new TypeError('invalid variant discriminant for expected');
     }
   }
-  const retVal = variant27;
+  _debugLog('[iface="local:wasm-tools/tools", function="component-embed"][Instruction::Return]', {
+    funcName: 'component-embed',
+    paramCount: 1,
+    postReturn: true
+  });
+  const retCopy = variant27;
+  
+  let cstate = getOrCreateAsyncState(0);
+  cstate.mayLeave = false;
   postReturn0(ret);
-  if (typeof retVal === 'object' && retVal.tag === 'err') {
-    throw new ComponentError(retVal.val);
+  cstate.mayLeave = true;
+  
+  
+  
+  if (typeof retCopy === 'object' && retCopy.tag === 'err') {
+    throw new ComponentError(retCopy.val);
   }
-  return retVal.val;
+  return retCopy.val;
+  
 }
 let toolsMetadataShow;
 
@@ -3994,7 +4916,10 @@ function metadataShow(arg0) {
   var ptr0 = realloc1(0, 0, 1, len0 * 1);
   var src0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, len0 * 1);
   (new Uint8Array(memory0.buffer, ptr0, len0 * 1)).set(src0);
+  _debugLog('[iface="local:wasm-tools/tools", function="metadata-show"] [Instruction::CallWasm] (async? false, @ enter)');
+  const _wasm_call_currentTaskID = startCurrentTask(0, false, 'toolsMetadataShow');
   const ret = toolsMetadataShow(ptr0, len0);
+  endCurrentTask(0);
   let variant12;
   switch (dataView(memory0).getUint8(ret + 0, true)) {
     case 0: {
@@ -4104,12 +5029,25 @@ function metadataShow(arg0) {
       throw new TypeError('invalid variant discriminant for expected');
     }
   }
-  const retVal = variant12;
+  _debugLog('[iface="local:wasm-tools/tools", function="metadata-show"][Instruction::Return]', {
+    funcName: 'metadata-show',
+    paramCount: 1,
+    postReturn: true
+  });
+  const retCopy = variant12;
+  
+  let cstate = getOrCreateAsyncState(0);
+  cstate.mayLeave = false;
   postReturn1(ret);
-  if (typeof retVal === 'object' && retVal.tag === 'err') {
-    throw new ComponentError(retVal.val);
+  cstate.mayLeave = true;
+  
+  
+  
+  if (typeof retCopy === 'object' && retCopy.tag === 'err') {
+    throw new ComponentError(retCopy.val);
   }
-  return retVal.val;
+  return retCopy.val;
+  
 }
 let toolsMetadataAdd;
 
@@ -4148,7 +5086,10 @@ function metadataAdd(arg0, arg1) {
     dataView(memory0).setInt32(base + 12, len6, true);
     dataView(memory0).setInt32(base + 8, result6, true);
   }
+  _debugLog('[iface="local:wasm-tools/tools", function="metadata-add"] [Instruction::CallWasm] (async? false, @ enter)');
+  const _wasm_call_currentTaskID = startCurrentTask(0, false, 'toolsMetadataAdd');
   const ret = toolsMetadataAdd(ptr0, len0, result7, len7);
+  endCurrentTask(0);
   let variant10;
   switch (dataView(memory0).getUint8(ret + 0, true)) {
     case 0: {
@@ -4175,12 +5116,25 @@ function metadataAdd(arg0, arg1) {
       throw new TypeError('invalid variant discriminant for expected');
     }
   }
-  const retVal = variant10;
+  _debugLog('[iface="local:wasm-tools/tools", function="metadata-add"][Instruction::Return]', {
+    funcName: 'metadata-add',
+    paramCount: 1,
+    postReturn: true
+  });
+  const retCopy = variant10;
+  
+  let cstate = getOrCreateAsyncState(0);
+  cstate.mayLeave = false;
   postReturn0(ret);
-  if (typeof retVal === 'object' && retVal.tag === 'err') {
-    throw new ComponentError(retVal.val);
+  cstate.mayLeave = true;
+  
+  
+  
+  if (typeof retCopy === 'object' && retCopy.tag === 'err') {
+    throw new ComponentError(retCopy.val);
   }
-  return retVal.val;
+  return retCopy.val;
+  
 }
 
 let _initialized = false;
@@ -4188,8 +5142,8 @@ export const $init = (() => {
   let gen = (function* init () {
     const module0 = fetchCompile(new URL('./wasm-tools.core.wasm', import.meta.url));
     const module1 = fetchCompile(new URL('./wasm-tools.core2.wasm', import.meta.url));
-    const module2 = base64Compile('AGFzbQEAAAABZw5gAn9/AGABfwBgAn9/AX9gA39+fwBgBH9/f38Bf2AFf39/f38AYAR/f39/AGAJf39/f39+fn9/AX9gBX9/f35/AX9gBX9/f39/AX9gAX8Bf2ADf39/AX9gB39/f39/f38AYAJ+fwADJiUHCAkCAgQEAgIKAgsBAQAAAAUDAwAAAAUMAAMDAAYGAA0BAQEBBAUBcAElJQe7ASYBMAAAATEAAQEyAAIBMwADATQABAE1AAUBNgAGATcABwE4AAgBOQAJAjEwAAoCMTEACwIxMgAMAjEzAA0CMTQADgIxNQAPAjE2ABACMTcAEQIxOAASAjE5ABMCMjAAFAIyMQAVAjIyABYCMjMAFwIyNAAYAjI1ABkCMjYAGgIyNwAbAjI4ABwCMjkAHQIzMAAeAjMxAB8CMzIAIAIzMwAhAjM0ACICMzUAIwIzNgAkCCRpbXBvcnRzAQAK+QMlGQAgACABIAIgAyAEIAUgBiAHIAhBABEHAAsRACAAIAEgAiADIARBAREIAAsRACAAIAEgAiADIARBAhEJAAsLACAAIAFBAxECAAsLACAAIAFBBBECAAsPACAAIAEgAiADQQURBAALDwAgACABIAIgA0EGEQQACwsAIAAgAUEHEQIACwsAIAAgAUEIEQIACwkAIABBCREKAAsLACAAIAFBChECAAsNACAAIAEgAkELEQsACwkAIABBDBEBAAsJACAAQQ0RAQALCwAgACABQQ4RAAALCwAgACABQQ8RAAALCwAgACABQRARAAALEQAgACABIAIgAyAEQRERBQALDQAgACABIAJBEhEDAAsNACAAIAEgAkETEQMACwsAIAAgAUEUEQAACwsAIAAgAUEVEQAACwsAIAAgAUEWEQAACxEAIAAgASACIAMgBEEXEQUACxUAIAAgASACIAMgBCAFIAZBGBEMAAsLACAAIAFBGREAAAsNACAAIAEgAkEaEQMACw0AIAAgASACQRsRAwALCwAgACABQRwRAAALDwAgACABIAIgA0EdEQYACw8AIAAgASACIANBHhEGAAsLACAAIAFBHxEAAAsLACAAIAFBIBENAAsJACAAQSERAQALCQAgAEEiEQEACwkAIABBIxEBAAsJACAAQSQRAQALAC8JcHJvZHVjZXJzAQxwcm9jZXNzZWQtYnkBDXdpdC1jb21wb25lbnQHMC4yMzAuMA');
-    const module3 = base64Compile('AGFzbQEAAAABZw5gAn9/AGABfwBgAn9/AX9gA39+fwBgBH9/f38Bf2AFf39/f38AYAR/f39/AGAJf39/f39+fn9/AX9gBX9/f35/AX9gBX9/f39/AX9gAX8Bf2ADf39/AX9gB39/f39/f38AYAJ+fwAC5AEmAAEwAAcAATEACAABMgAJAAEzAAIAATQAAgABNQAEAAE2AAQAATcAAgABOAACAAE5AAoAAjEwAAIAAjExAAsAAjEyAAEAAjEzAAEAAjE0AAAAAjE1AAAAAjE2AAAAAjE3AAUAAjE4AAMAAjE5AAMAAjIwAAAAAjIxAAAAAjIyAAAAAjIzAAUAAjI0AAwAAjI1AAAAAjI2AAMAAjI3AAMAAjI4AAAAAjI5AAYAAjMwAAYAAjMxAAAAAjMyAA0AAjMzAAEAAjM0AAEAAjM1AAEAAjM2AAEACCRpbXBvcnRzAXABJSUJKwEAQQALJQABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQALwlwcm9kdWNlcnMBDHByb2Nlc3NlZC1ieQENd2l0LWNvbXBvbmVudAcwLjIzMC4w');
+    const module2 = base64Compile('AGFzbQEAAAABZw5gAn9/AGABfwBgAn9/AX9gA39+fwBgBH9/f38Bf2AFf39/f38AYAR/f39/AGAJf39/f39+fn9/AX9gBX9/f35/AX9gBX9/f39/AX9gAX8Bf2ADf39/AX9gB39/f39/f38AYAJ+fwADJiUHCAkCAgQEAgIKAgsBAQAAAAUDAwAAAAUMAAMDAAYGAA0BAQEBBAUBcAElJQe7ASYBMAAAATEAAQEyAAIBMwADATQABAE1AAUBNgAGATcABwE4AAgBOQAJAjEwAAoCMTEACwIxMgAMAjEzAA0CMTQADgIxNQAPAjE2ABACMTcAEQIxOAASAjE5ABMCMjAAFAIyMQAVAjIyABYCMjMAFwIyNAAYAjI1ABkCMjYAGgIyNwAbAjI4ABwCMjkAHQIzMAAeAjMxAB8CMzIAIAIzMwAhAjM0ACICMzUAIwIzNgAkCCRpbXBvcnRzAQAK+QMlGQAgACABIAIgAyAEIAUgBiAHIAhBABEHAAsRACAAIAEgAiADIARBAREIAAsRACAAIAEgAiADIARBAhEJAAsLACAAIAFBAxECAAsLACAAIAFBBBECAAsPACAAIAEgAiADQQURBAALDwAgACABIAIgA0EGEQQACwsAIAAgAUEHEQIACwsAIAAgAUEIEQIACwkAIABBCREKAAsLACAAIAFBChECAAsNACAAIAEgAkELEQsACwkAIABBDBEBAAsJACAAQQ0RAQALCwAgACABQQ4RAAALCwAgACABQQ8RAAALCwAgACABQRARAAALEQAgACABIAIgAyAEQRERBQALDQAgACABIAJBEhEDAAsNACAAIAEgAkETEQMACwsAIAAgAUEUEQAACwsAIAAgAUEVEQAACwsAIAAgAUEWEQAACxEAIAAgASACIAMgBEEXEQUACxUAIAAgASACIAMgBCAFIAZBGBEMAAsLACAAIAFBGREAAAsNACAAIAEgAkEaEQMACw0AIAAgASACQRsRAwALCwAgACABQRwRAAALDwAgACABIAIgA0EdEQYACw8AIAAgASACIANBHhEGAAsLACAAIAFBHxEAAAsLACAAIAFBIBENAAsJACAAQSERAQALCQAgAEEiEQEACwkAIABBIxEBAAsJACAAQSQRAQALAC8JcHJvZHVjZXJzAQxwcm9jZXNzZWQtYnkBDXdpdC1jb21wb25lbnQHMC4yMzUuMA');
+    const module3 = base64Compile('AGFzbQEAAAABZw5gAn9/AGABfwBgAn9/AX9gA39+fwBgBH9/f38Bf2AFf39/f38AYAR/f39/AGAJf39/f39+fn9/AX9gBX9/f35/AX9gBX9/f39/AX9gAX8Bf2ADf39/AX9gB39/f39/f38AYAJ+fwAC5AEmAAEwAAcAATEACAABMgAJAAEzAAIAATQAAgABNQAEAAE2AAQAATcAAgABOAACAAE5AAoAAjEwAAIAAjExAAsAAjEyAAEAAjEzAAEAAjE0AAAAAjE1AAAAAjE2AAAAAjE3AAUAAjE4AAMAAjE5AAMAAjIwAAAAAjIxAAAAAjIyAAAAAjIzAAUAAjI0AAwAAjI1AAAAAjI2AAMAAjI3AAMAAjI4AAAAAjI5AAYAAjMwAAYAAjMxAAAAAjMyAA0AAjMzAAEAAjM0AAEAAjM1AAEAAjM2AAEACCRpbXBvcnRzAXABJSUJKwEAQQALJQABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQALwlwcm9kdWNlcnMBDHByb2Nlc3NlZC1ieQENd2l0LWNvbXBvbmVudAcwLjIzNS4w');
     ({ exports: exports0 } = yield instantiateCore(yield module2));
     ({ exports: exports1 } = yield instantiateCore(yield module0, {
       wasi_snapshot_preview1: {