11ty-plugin-giallo 0.1.0-alpha.0 → 0.1.0-alpha.1

package/dist/giallo_js.js

@@ -1,654 +1,639 @@
-import { environment, exit as exit$1, stderr, stdin, stdout } from '@bytecodealliance/preview2-shim/cli';
-import { preopens, types } from '@bytecodealliance/preview2-shim/filesystem';
-import { error, streams } from '@bytecodealliance/preview2-shim/io';
-import { insecureSeed as insecureSeed$1 } from '@bytecodealliance/preview2-shim/random';
-const { getEnvironment } = environment;
-const { exit } = exit$1;
-const { getStderr } = stderr;
-const { getStdin } = stdin;
-const { getStdout } = stdout;
-const { getDirectories } = preopens;
-const { Descriptor,
-  filesystemErrorCode } = types;
-const { Error: Error$1 } = error;
-const { InputStream,
-  OutputStream } = streams;
-const { insecureSeed } = insecureSeed$1;
-
-let dv = new DataView(new ArrayBuffer());
-const dataView = mem => dv.buffer === mem.buffer ? dv : dv = new DataView(mem.buffer);
-
-const toUint64 = val => BigInt.asUintN(64, BigInt(val));
-
-function toUint32(val) {
-  return val >>> 0;
-}
-
-const utf8Decoder = new TextDecoder();
-
-const utf8Encoder = new TextEncoder();
-let utf8EncodedLen = 0;
-function utf8Encode(s, realloc, memory) {
-  if (typeof s !== 'string') throw new TypeError('expected a string');
-  if (s.length === 0) {
-    utf8EncodedLen = 0;
-    return 1;
-  }
-  let buf = utf8Encoder.encode(s);
-  let ptr = realloc(0, 0, 1, buf.length);
-  new Uint8Array(memory.buffer).set(buf, ptr);
-  utf8EncodedLen = buf.length;
-  return ptr;
-}
-
-const T_FLAG = 1 << 30;
-
-function rscTableCreateOwn (table, rep) {
-  const free = table[0] & ~T_FLAG;
-  if (free === 0) {
-    table.push(0);
-    table.push(rep | T_FLAG);
-    return (table.length >> 1) - 1;
-  }
-  table[0] = table[free << 1];
-  table[free << 1] = 0;
-  table[(free << 1) + 1] = rep | T_FLAG;
-  return free;
-}
-
-function rscTableRemove (table, handle) {
-  const scope = table[handle << 1];
-  const val = table[(handle << 1) + 1];
-  const own = (val & T_FLAG) !== 0;
-  const rep = val & ~T_FLAG;
-  if (val === 0 || (scope & T_FLAG) !== 0) throw new TypeError('Invalid handle');
-  table[handle << 1] = table[0] | T_FLAG;
-  table[0] = handle | T_FLAG;
-  return { rep, scope, own };
-}
-
-let curResourceBorrows = [];
-
-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);
+export function instantiate(getCoreModule, imports, instantiateCore = (module, importObject) => new WebAssembly.Instance(module, importObject)) {
   
-  const nextId = ++NEXT_TASK_ID;
-  const newTask = new AsyncTask({ id: nextId, componentIdx, isAsync, entryFnName });
-  const newTaskMeta = { id: nextId, componentIdx, task: newTask };
+  let dv = new DataView(new ArrayBuffer());
+  const dataView = mem => dv.buffer === mem.buffer ? dv : dv = new DataView(mem.buffer);
   
-  ASYNC_CURRENT_TASK_IDS.push(nextId);
-  ASYNC_CURRENT_COMPONENT_IDXS.push(componentIdx);
+  const toUint64 = val => BigInt.asUintN(64, BigInt(val));
   
-  if (!tasks) {
-    ASYNC_TASKS_BY_COMPONENT_IDX.set(componentIdx, [newTaskMeta]);
-    return nextId;
-  } else {
-    tasks.push(newTaskMeta);
+  function toUint32(val) {
+    return val >>> 0;
   }
   
-  return nextId;
-}
-
-function endCurrentTask(componentIdx, taskId) {
-  _debugLog('[endCurrentTask()] args', { componentIdx });
-  componentIdx ??= ASYNC_CURRENT_COMPONENT_IDXS.at(-1);
-  taskId ??= ASYNC_CURRENT_TASK_IDS.at(-1);
-  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');
-  }
+  const utf8Decoder = new TextDecoder();
   
-  if (taskId) {
-    const last = tasks[tasks.length - 1];
-    if (last.id !== taskId) {
-      throw new Error('current task does not match expected task ID');
+  const utf8Encoder = new TextEncoder();
+  let utf8EncodedLen = 0;
+  function utf8Encode(s, realloc, memory) {
+    if (typeof s !== 'string') throw new TypeError('expected a string');
+    if (s.length === 0) {
+      utf8EncodedLen = 0;
+      return 1;
     }
+    let buf = utf8Encoder.encode(s);
+    let ptr = realloc(0, 0, 1, buf.length);
+    new Uint8Array(memory.buffer).set(buf, ptr);
+    utf8EncodedLen = buf.length;
+    return ptr;
   }
   
-  ASYNC_CURRENT_TASK_IDS.pop();
-  ASYNC_CURRENT_COMPONENT_IDXS.pop();
+  const T_FLAG = 1 << 30;
   
-  return tasks.pop();
-}
-const ASYNC_TASKS_BY_COMPONENT_IDX = new Map();
-const ASYNC_CURRENT_TASK_IDS = [];
-const ASYNC_CURRENT_COMPONENT_IDXS = [];
-
-class AsyncTask {
-  static State = {
-    INITIAL: 'initial',
-    CANCELLED: 'cancelled',
-    CANCEL_PENDING: 'cancel-pending',
-    CANCEL_DELIVERED: 'cancel-delivered',
-    RESOLVED: 'resolved',
+  function rscTableCreateOwn (table, rep) {
+    const free = table[0] & ~T_FLAG;
+    if (free === 0) {
+      table.push(0);
+      table.push(rep | T_FLAG);
+      return (table.length >> 1) - 1;
+    }
+    table[0] = table[free << 1];
+    table[free << 1] = 0;
+    table[(free << 1) + 1] = rep | T_FLAG;
+    return free;
   }
   
-  static BlockResult = {
-    CANCELLED: 'block.cancelled',
-    NOT_CANCELLED: 'block.not-cancelled',
+  function rscTableRemove (table, handle) {
+    const scope = table[handle << 1];
+    const val = table[(handle << 1) + 1];
+    const own = (val & T_FLAG) !== 0;
+    const rep = val & ~T_FLAG;
+    if (val === 0 || (scope & T_FLAG) !== 0) throw new TypeError('Invalid handle');
+    table[handle << 1] = table[0] | T_FLAG;
+    table[0] = handle | T_FLAG;
+    return { rep, scope, own };
   }
   
-  #id;
-  #componentIdx;
-  #state;
-  #isAsync;
-  #onResolve = null;
-  #entryFnName = null;
-  #subtasks = [];
-  #completionPromise = 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;
+  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 {
-      promise: completionPromise,
-      resolve: resolveCompletionPromise,
-      reject: rejectCompletionPromise,
-    } = Promise.withResolvers();
-    this.#completionPromise = completionPromise;
+    const nextId = ++NEXT_TASK_ID;
+    const newTask = new AsyncTask({ id: nextId, componentIdx, isAsync, entryFnName });
+    const newTaskMeta = { id: nextId, componentIdx, task: newTask };
     
-    this.#onResolve = (results) => {
-      // TODO: handle external facing cancellation (should likely be a rejection)
-      resolveCompletionPromise(results);
+    ASYNC_CURRENT_TASK_IDS.push(nextId);
+    ASYNC_CURRENT_COMPONENT_IDXS.push(componentIdx);
+    
+    if (!tasks) {
+      ASYNC_TASKS_BY_COMPONENT_IDX.set(componentIdx, [newTaskMeta]);
+      return nextId;
+    } else {
+      tasks.push(newTaskMeta);
     }
+    
+    return nextId;
   }
   
-  taskState() { return this.#state.slice(); }
-  id() { return this.#id; }
-  componentIdx() { return this.#componentIdx; }
-  isAsync() { return this.#isAsync; }
-  entryFnName() { return this.#entryFnName; }
-  completionPromise() { return this.#completionPromise; }
-  
-  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;
+  function endCurrentTask(componentIdx, taskId) {
+    _debugLog('[endCurrentTask()] args', { componentIdx });
+    componentIdx ??= ASYNC_CURRENT_COMPONENT_IDXS.at(-1);
+    taskId ??= ASYNC_CURRENT_TASK_IDS.at(-1);
+    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_IDS.pop();
+    ASYNC_CURRENT_COMPONENT_IDXS.pop();
+    
+    return tasks.pop();
   }
+  const ASYNC_TASKS_BY_COMPONENT_IDX = new Map();
+  const ASYNC_CURRENT_TASK_IDS = [];
+  const ASYNC_CURRENT_COMPONENT_IDXS = [];
   
-  async enter() {
-    _debugLog('[AsyncTask#enter()] args', { taskID: this.#id });
+  class AsyncTask {
+    static State = {
+      INITIAL: 'initial',
+      CANCELLED: 'cancelled',
+      CANCEL_PENDING: 'cancel-pending',
+      CANCEL_DELIVERED: 'cancel-delivered',
+      RESOLVED: 'resolved',
+    }
     
-    // TODO: assert scheduler locked
-    // TODO: trap if on the stack
+    static BlockResult = {
+      CANCELLED: 'block.cancelled',
+      NOT_CANCELLED: 'block.not-cancelled',
+    }
+    
+    #id;
+    #componentIdx;
+    #state;
+    #isAsync;
+    #onResolve = null;
+    #entryFnName = null;
+    #subtasks = [];
+    #completionPromise = null;
+    
+    cancelled = false;
+    requested = false;
+    alwaysTaskReturn = false;
+    
+    returnCalls =  0;
+    storage = [0, 0];
+    borrowedHandles = {};
     
-    const cstate = getOrCreateAsyncState(this.#componentIdx);
+    awaitableResume = null;
+    awaitableCancel = null;
     
-    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()));
+    
+    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;
       
-      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(new Error('failed enter'));
+      const {
+        promise: completionPromise,
+        resolve: resolveCompletionPromise,
+        reject: rejectCompletionPromise,
+      } = Promise.withResolvers();
+      this.#completionPromise = completionPromise;
+      
+      this.#onResolve = (results) => {
+        // TODO: handle external facing cancellation (should likely be a rejection)
+        resolveCompletionPromise(results);
+      }
+    }
+    
+    taskState() { return this.#state.slice(); }
+    id() { return this.#id; }
+    componentIdx() { return this.#componentIdx; }
+    isAsync() { return this.#isAsync; }
+    entryFnName() { return this.#entryFnName; }
+    completionPromise() { return this.#completionPromise; }
+    
+    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(new Error('failed enter'));
+          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');
+      }
       
-      mayNotEnter = !this.mayEnter(this);
-      if (!mayNotEnter || !cstate.startPendingTask) {
-        throw new Error('invalid component entrance/pending task resolution');
+      if (this.status === AsyncTask.State.CANCEL_PENDING) {
+        this.#state = AsyncTask.State.CANCEL_DELIVERED;
+        return {
+          code: ASYNC_EVENT_CODE.TASK_CANCELLED,
+        };
+      }
+      
+      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,
+          };
+        }
+        
+        event = waitableSet.poll();
       }
-      cstate.startPendingTask = false;
+      
+      waitableSet.numWaiting -= 1;
+      return event;
     }
     
-    if (!this.isAsync) { cstate.callingSyncExport = true; }
+    waitForEventSync(opts) {
+      throw new Error('AsyncTask#yieldSync() not implemented')
+    }
     
-    return true;
-  }
-  
-  async waitForEvent(opts) {
-    const { waitableSetRep, isAsync } = opts;
-    _debugLog('[AsyncTask#waitForEvent()] args', { taskID: this.#id, waitableSetRep, isAsync });
+    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');
+    }
     
-    if (this.#isAsync !== isAsync) {
-      throw new Error('async waitForEvent called on non-async task');
+    pollForEventSync(opts) {
+      throw new Error('AsyncTask#yieldSync() not implemented')
     }
     
-    if (this.status === AsyncTask.State.CANCEL_PENDING) {
-      this.#state = AsyncTask.State.CANCEL_DELIVERED;
-      return {
-        code: ASYNC_EVENT_CODE.TASK_CANCELLED,
-      };
+    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;
     }
     
-    const state = getOrCreateAsyncState(this.#componentIdx);
-    const waitableSet = state.waitableSets.get(waitableSetRep);
-    if (!waitableSet) { throw new Error('missing/invalid waitable set'); }
+    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;
+      }
+    }
     
-    waitableSet.numWaiting += 1;
-    let event = null;
+    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');
+    }
     
-    while (event == null) {
-      const awaitable = new Awaitable(waitableSet.getPendingEvent());
-      const waited = await this.blockOn({ awaitable, isAsync, isCancellable: true });
-      if (waited) {
+    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],
         };
       }
       
-      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');
+      return {
+        code: ASYNC_EVENT_CODE.NONE,
+        payload: [0, 0],
+      };
     }
     
-    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;
+    yieldSync(opts) {
+      throw new Error('AsyncTask#yieldSync() not implemented')
     }
     
-    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()');
+    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(new Error('cancelled'));
+      this.#state = AsyncTask.State.RESOLVED;
     }
     
-    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()');
-        }
+    resolve(results) {
+      _debugLog('[AsyncTask#resolve()] args', { results });
+      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(results.length === 1 ? results[0] : results);
+      this.#state = AsyncTask.State.RESOLVED;
     }
     
-    if (cancelled === AsyncTask.BlockResult.CANCELLED) {
-      if (this.#state !== AsyncTask.State.INITIAL) {
-        throw new Error('cancelled task is not at initial state');
+    exit() {
+      _debugLog('[AsyncTask#exit()] args', { });
+      
+      // 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 (isCancellable) {
-        this.#state = AsyncTask.State.CANCELLED;
-        return AsyncTask.BlockResult.CANCELLED;
-      } else {
-        this.#state = AsyncTask.State.CANCEL_PENDING;
-        return AsyncTask.BlockResult.NOT_CANCELLED;
+      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();
     }
     
-    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');
+    startPendingTask(args) {
+      _debugLog('[AsyncTask#startPendingTask()] args', args);
+      throw new Error('AsyncTask#startPendingTask() not implemented');
     }
     
-    // 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);
-    };
+    createSubtask(args) {
+      _debugLog('[AsyncTask#createSubtask()] args', args);
+      const newSubtask = new AsyncSubtask({
+        componentIdx: this.componentIdx(),
+        taskID: this.id(),
+        memoryIdx: args?.memoryIdx,
+      });
+      this.#subtasks.push(newSubtask);
+      return newSubtask;
+    }
     
-    // Park this task/execution to be handled later
-    const state = getOrCreateAsyncState(this.#componentIdx);
-    state.parkTaskOnAwaitable({ awaitable, task: this });
+    currentSubtask() {
+      _debugLog('[AsyncTask#currentSubtask()]');
+      if (this.#subtasks.length === 0) { throw new Error('no current subtask'); }
+      return this.#subtasks.at(-1);
+    }
     
-    try {
-      await promise;
-      return AsyncTask.BlockResult.NOT_CANCELLED;
-    } catch (err) {
-      // rejection means task cancellation
-      return AsyncTask.BlockResult.CANCELLED;
+    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;
     }
   }
   
-  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');
+  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();
   
-  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],
-      };
+  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;
     
-    // 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
+    mayLeave = true;
+    waitableSets = new RepTable();
+    waitables = new RepTable();
     
-    const blockResult = await this.blockOn({
-      awaitable: new Awaitable(new Promise(resolve => setTimeout(resolve, 0))),
-      isCancellable,
-      forCallback,
-    });
+    #parkedTasks = new Map();
     
-    if (blockResult === AsyncTask.BlockResult.CANCELLED) {
-      if (this.#state !== AsyncTask.State.INITIAL) {
-        throw new Error('task should be in initial state found [' + this.#state + ']');
+    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();
       }
-      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');
+    #notifySyncImportEnd() {
+      const existing = this.#syncImportWait;
+      this.#syncImportWait = Promise.withResolvers();
+      existing.resolve();
     }
-    if (this.borrowedHandles.length > 0) { throw new Error('task still has borrow handles'); }
     
-    this.#onResolve(new Error('cancelled'));
-    this.#state = AsyncTask.State.RESOLVED;
-  }
-  
-  resolve(results) {
-    _debugLog('[AsyncTask#resolve()] args', { results });
-    if (this.#state === AsyncTask.State.RESOLVED) {
-      throw new Error('task is already resolved');
+    async waitForSyncImportCallEnd() {
+      await this.#syncImportWait.promise;
     }
-    if (this.borrowedHandles.length > 0) { throw new Error('task still has borrow handles'); }
-    this.#onResolve(results.length === 1 ? results[0] : 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) {
-      throw new Error('task exited without resolution');
-    }
-    if (this.borrowedHandles > 0) {
-      throw new Error('task exited without clearing borrowed handles');
+    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);
     }
     
-    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');
+    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();
     }
-    state.inSyncExportCall = false;
     
-    this.startPendingTask();
-  }
-  
-  startPendingTask(args) {
-    _debugLog('[AsyncTask#startPendingTask()] args', args);
-    throw new Error('AsyncTask#startPendingTask() not implemented');
-  }
-  
-  createSubtask(args) {
-    _debugLog('[AsyncTask#createSubtask()] args', args);
-    const newSubtask = new AsyncSubtask({
-      componentIdx: this.componentIdx(),
-      taskID: this.id(),
-      memoryIdx: args?.memoryIdx,
-    });
-    this.#subtasks.push(newSubtask);
-    return newSubtask;
-  }
-  
-  currentSubtask() {
-    _debugLog('[AsyncTask#currentSubtask()]');
-    if (this.#subtasks.length === 0) { throw new Error('no current subtask'); }
-    return this.#subtasks.at(-1);
-  }
-  
-  endCurrentSubtask() {
-    _debugLog('[AsyncTask#endCurrentSubtask()]');
-    if (this.#subtasks.length === 0) { throw new Error('cannot end current subtask: no current subtask'); }
-    const subtask = this.#subtasks.pop();
-    subtask.drop();
-    return subtask;
-  }
-}
-
-function unpackCallbackResult(result) {
-  _debugLog('[unpackCallbackResult()] args', { result });
-  if (!(_typeCheckValidI32(result))) { throw new Error('invalid callback return value [' + result + '], not a valid i32'); }
-  const eventCode = result & 0xF;
-  if (eventCode < 0 || eventCode > 3) {
-    throw new Error('invalid async return value [' + eventCode + '], outside callback code range');
-  }
-  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 = true;
-  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();
+    async exclusiveLock() {  // TODO: use atomics
+    if (this.#lock === null) {
+      this.#lock = { ticket: 0n };
     }
-  }
-  
-  #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);
+    // Take a ticket for the next valid usage
+    const ticket = ++this.#lock.ticket;
     
-    this.wakeNextTaskForAwaitable(awaitable);
-  }
-  
-  wakeNextTaskForAwaitable(awaitable) {
-    if (!awaitable) { throw new TypeError('missing awaitable when waking next task'); }
-    const awaitableID = awaitable.id();
+    _debugLog('[ComponentAsyncState#exclusiveLock()] locking', {
+      currentTicket: ticket - 1n,
+      ticket
+    });
     
-    const taskList = this.#parkedTasks.get(awaitableID);
-    if (!taskList || taskList.length === 0) {
-      _debugLog('[ComponentAsyncState] no tasks waiting for awaitable', { awaitableID: awaitable.id() });
-      return;
+    // If there is an active promise, then wait for it
+    let finishedTicket;
+    while (this.#lock.promise) {
+      finishedTicket = await this.#lock.promise;
+      if (finishedTicket === ticket - 1n) { break; }
     }
     
-    let task = taskList.shift(); // todo(perf)
-    if (!task) { throw new Error('no task in parked list despite previous check'); }
+    const { promise, resolve } = Promise.withResolvers();
+    this.#lock = {
+      ticket,
+      promise,
+      resolve,
+    };
     
-    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 };
+    return this.#lock.promise;
   }
   
-  // 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
-  let finishedTicket;
-  while (this.#lock.promise) {
-    finishedTicket = await this.#lock.promise;
-    if (finishedTicket === ticket - 1n) { break; }
+  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);
   }
   
-  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; }
+  isExclusivelyLocked() { return this.#lock !== null; }
   
-  const existingLock = this.#lock;
-  this.#lock = null;
-  existingLock.resolve(existingLock.ticket);
-}
-
-isExclusivelyLocked() { return this.#lock !== null; }
-
 }
 
 function prepareCall(memoryIdx) {
@@ -712,18 +697,6 @@ 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)));
-
-const isNode = typeof process !== 'undefined' && process.versions && process.versions.node;
-let _fs;
-async function fetchCompile (url) {
-  if (isNode) {
-    _fs = _fs || await import('node:fs/promises');
-    return WebAssembly.compile(await _fs.readFile(url));
-  }
-  return fetch(url).then(WebAssembly.compileStreaming);
-}
-
 const symbolCabiDispose = Symbol.for('cabiDispose');
 
 const symbolRscHandle = Symbol('handle');
@@ -801,689 +774,485 @@ class RepTable {
 
 const hasOwnProperty = Object.prototype.hasOwnProperty;
 
-const instantiateCore = WebAssembly.instantiate;
-
 
-let exports0;
-const handleTable1 = [T_FLAG, 0];
-const captureTable1= new Map();
-let captureCnt1 = 0;
-handleTables[1] = handleTable1;
-
-function trampoline2() {
-  _debugLog('[iface="wasi:cli/stderr@0.2.6", 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.6", function="get-stderr"] [Instruction::CallInterface] (sync, @ post-call)');
-  endCurrentTask(0);
-  if (!(ret instanceof OutputStream)) {
-    throw new TypeError('Resource error: Not a valid "OutputStream" resource.');
+const module0 = getCoreModule('giallo_js.core.wasm');
+const module1 = getCoreModule('giallo_js.core2.wasm');
+const module2 = getCoreModule('giallo_js.core3.wasm');
+const module3 = getCoreModule('giallo_js.core4.wasm');
+
+const { getEnvironment } = imports['wasi:cli/environment'];
+const { exit } = imports['wasi:cli/exit'];
+const { getStderr } = imports['wasi:cli/stderr'];
+const { getStdin } = imports['wasi:cli/stdin'];
+const { getStdout } = imports['wasi:cli/stdout'];
+const { getDirectories } = imports['wasi:filesystem/preopens'];
+const { Descriptor, filesystemErrorCode } = imports['wasi:filesystem/types'];
+const { Error: Error$1 } = imports['wasi:io/error'];
+const { InputStream, OutputStream } = imports['wasi:io/streams'];
+const { insecureSeed } = imports['wasi:random/insecure-seed'];
+let gen = (function* _initGenerator () {
+  let exports0;
+  const handleTable1 = [T_FLAG, 0];
+  const captureTable1= new Map();
+  let captureCnt1 = 0;
+  handleTables[1] = handleTable1;
+  
+  function trampoline2() {
+    _debugLog('[iface="wasi:cli/stderr@0.2.6", 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.6", function="get-stderr"] [Instruction::CallInterface] (sync, @ post-call)');
+    endCurrentTask(0);
+    if (!(ret instanceof OutputStream)) {
+      throw new TypeError('Resource error: Not a valid "OutputStream" resource.');
+    }
+    var handle0 = ret[symbolRscHandle];
+    if (!handle0) {
+      const rep = ret[symbolRscRep] || ++captureCnt1;
+      captureTable1.set(rep, ret);
+      handle0 = rscTableCreateOwn(handleTable1, rep);
+    }
+    _debugLog('[iface="wasi:cli/stderr@0.2.6", function="get-stderr"][Instruction::Return]', {
+      funcName: 'get-stderr',
+      paramCount: 1,
+      async: false,
+      postReturn: false
+    });
+    return handle0;
+  }
+  
+  let exports1;
+  const handleTable2 = [T_FLAG, 0];
+  const captureTable2= new Map();
+  let captureCnt2 = 0;
+  handleTables[2] = handleTable2;
+  
+  function trampoline6() {
+    _debugLog('[iface="wasi:cli/stdin@0.2.6", 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.6", function="get-stdin"] [Instruction::CallInterface] (sync, @ post-call)');
+    endCurrentTask(0);
+    if (!(ret instanceof InputStream)) {
+      throw new TypeError('Resource error: Not a valid "InputStream" resource.');
+    }
+    var handle0 = ret[symbolRscHandle];
+    if (!handle0) {
+      const rep = ret[symbolRscRep] || ++captureCnt2;
+      captureTable2.set(rep, ret);
+      handle0 = rscTableCreateOwn(handleTable2, rep);
+    }
+    _debugLog('[iface="wasi:cli/stdin@0.2.6", function="get-stdin"][Instruction::Return]', {
+      funcName: 'get-stdin',
+      paramCount: 1,
+      async: false,
+      postReturn: false
+    });
+    return handle0;
+  }
+  
+  
+  function trampoline7() {
+    _debugLog('[iface="wasi:cli/stdout@0.2.6", 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.6", function="get-stdout"] [Instruction::CallInterface] (sync, @ post-call)');
+    endCurrentTask(0);
+    if (!(ret instanceof OutputStream)) {
+      throw new TypeError('Resource error: Not a valid "OutputStream" resource.');
+    }
+    var handle0 = ret[symbolRscHandle];
+    if (!handle0) {
+      const rep = ret[symbolRscRep] || ++captureCnt1;
+      captureTable1.set(rep, ret);
+      handle0 = rscTableCreateOwn(handleTable1, rep);
+    }
+    _debugLog('[iface="wasi:cli/stdout@0.2.6", function="get-stdout"][Instruction::Return]', {
+      funcName: 'get-stdout',
+      paramCount: 1,
+      async: false,
+      postReturn: false
+    });
+    return handle0;
   }
-  var handle0 = ret[symbolRscHandle];
-  if (!handle0) {
-    const rep = ret[symbolRscRep] || ++captureCnt1;
-    captureTable1.set(rep, ret);
-    handle0 = rscTableCreateOwn(handleTable1, rep);
-  }
-  _debugLog('[iface="wasi:cli/stderr@0.2.6", function="get-stderr"][Instruction::Return]', {
-    funcName: 'get-stderr',
-    paramCount: 1,
-    async: false,
-    postReturn: false
-  });
-  return handle0;
-}
-
-let exports1;
-const handleTable2 = [T_FLAG, 0];
-const captureTable2= new Map();
-let captureCnt2 = 0;
-handleTables[2] = handleTable2;
-
-function trampoline6() {
-  _debugLog('[iface="wasi:cli/stdin@0.2.6", 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.6", function="get-stdin"] [Instruction::CallInterface] (sync, @ post-call)');
-  endCurrentTask(0);
-  if (!(ret instanceof InputStream)) {
-    throw new TypeError('Resource error: Not a valid "InputStream" resource.');
-  }
-  var handle0 = ret[symbolRscHandle];
-  if (!handle0) {
-    const rep = ret[symbolRscRep] || ++captureCnt2;
-    captureTable2.set(rep, ret);
-    handle0 = rscTableCreateOwn(handleTable2, rep);
-  }
-  _debugLog('[iface="wasi:cli/stdin@0.2.6", function="get-stdin"][Instruction::Return]', {
-    funcName: 'get-stdin',
-    paramCount: 1,
-    async: false,
-    postReturn: false
-  });
-  return handle0;
-}
-
-
-function trampoline7() {
-  _debugLog('[iface="wasi:cli/stdout@0.2.6", 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.6", function="get-stdout"] [Instruction::CallInterface] (sync, @ post-call)');
-  endCurrentTask(0);
-  if (!(ret instanceof OutputStream)) {
-    throw new TypeError('Resource error: Not a valid "OutputStream" resource.');
-  }
-  var handle0 = ret[symbolRscHandle];
-  if (!handle0) {
-    const rep = ret[symbolRscRep] || ++captureCnt1;
-    captureTable1.set(rep, ret);
-    handle0 = rscTableCreateOwn(handleTable1, rep);
-  }
-  _debugLog('[iface="wasi:cli/stdout@0.2.6", function="get-stdout"][Instruction::Return]', {
-    funcName: 'get-stdout',
-    paramCount: 1,
-    async: false,
-    postReturn: false
-  });
-  return handle0;
-}
-
-
-function trampoline8(arg0) {
-  let variant0;
-  switch (arg0) {
-    case 0: {
-      variant0= {
-        tag: 'ok',
-        val: undefined
-      };
-      break;
-    }
-    case 1: {
-      variant0= {
-        tag: 'err',
-        val: undefined
-      };
-      break;
-    }
-    default: {
-      throw new TypeError('invalid variant discriminant for expected');
-    }
-  }
-  _debugLog('[iface="wasi:cli/exit@0.2.6", function="exit"] [Instruction::CallInterface] (async? sync, @ enter)');
-  const _interface_call_currentTaskID = startCurrentTask(0, false, 'exit');
-  exit(variant0);
-  _debugLog('[iface="wasi:cli/exit@0.2.6", function="exit"] [Instruction::CallInterface] (sync, @ post-call)');
-  endCurrentTask(0);
-  _debugLog('[iface="wasi:cli/exit@0.2.6", function="exit"][Instruction::Return]', {
-    funcName: 'exit',
-    paramCount: 0,
-    async: false,
-    postReturn: false
-  });
-}
-
-let exports2;
-let memory0;
-let realloc0;
-let realloc1;
-const handleTable0 = [T_FLAG, 0];
-const captureTable0= new Map();
-let captureCnt0 = 0;
-handleTables[0] = handleTable0;
-
-function trampoline9(arg0, arg1) {
-  var handle1 = arg0;
-  var rep2 = handleTable0[(handle1 << 1) + 1] & ~T_FLAG;
-  var rsc0 = captureTable0.get(rep2);
-  if (!rsc0) {
-    rsc0 = Object.create(Error$1.prototype);
-    Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
-    Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
-  }
-  curResourceBorrows.push(rsc0);
-  _debugLog('[iface="wasi:io/error@0.2.6", function="[method]error.to-debug-string"] [Instruction::CallInterface] (async? sync, @ enter)');
-  const _interface_call_currentTaskID = startCurrentTask(0, false, '[method]error.to-debug-string');
-  const ret = rsc0.toDebugString();
-  _debugLog('[iface="wasi:io/error@0.2.6", function="[method]error.to-debug-string"] [Instruction::CallInterface] (sync, @ post-call)');
-  for (const rsc of curResourceBorrows) {
-    rsc[symbolRscHandle] = undefined;
-  }
-  curResourceBorrows = [];
-  endCurrentTask(0);
-  var ptr3 = utf8Encode(ret, realloc0, memory0);
-  var len3 = utf8EncodedLen;
-  dataView(memory0).setUint32(arg1 + 4, len3, true);
-  dataView(memory0).setUint32(arg1 + 0, ptr3, true);
-  _debugLog('[iface="wasi:io/error@0.2.6", function="[method]error.to-debug-string"][Instruction::Return]', {
-    funcName: '[method]error.to-debug-string',
-    paramCount: 0,
-    async: false,
-    postReturn: false
-  });
-}
-
-
-function trampoline10(arg0, arg1, arg2, arg3) {
-  var handle1 = arg0;
-  var rep2 = handleTable1[(handle1 << 1) + 1] & ~T_FLAG;
-  var rsc0 = captureTable1.get(rep2);
-  if (!rsc0) {
-    rsc0 = Object.create(OutputStream.prototype);
-    Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
-    Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
-  }
-  curResourceBorrows.push(rsc0);
-  var ptr3 = arg1;
-  var len3 = arg2;
-  var result3 = new Uint8Array(memory0.buffer.slice(ptr3, ptr3 + len3 * 1));
-  _debugLog('[iface="wasi:io/streams@0.2.6", 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.6", function="[method]output-stream.blocking-write-and-flush"] [Instruction::CallInterface] (sync, @ post-call)');
-  for (const rsc of curResourceBorrows) {
-    rsc[symbolRscHandle] = undefined;
-  }
-  curResourceBorrows = [];
-  endCurrentTask(0);
-  var variant6 = ret;
-  switch (variant6.tag) {
-    case 'ok': {
-      const e = variant6.val;
-      dataView(memory0).setInt8(arg3 + 0, 0, true);
-      break;
-    }
-    case 'err': {
-      const e = variant6.val;
-      dataView(memory0).setInt8(arg3 + 0, 1, true);
-      var variant5 = e;
-      switch (variant5.tag) {
-        case 'last-operation-failed': {
-          const e = variant5.val;
-          dataView(memory0).setInt8(arg3 + 4, 0, true);
-          if (!(e instanceof Error$1)) {
-            throw new TypeError('Resource error: Not a valid "Error" resource.');
-          }
-          var handle4 = e[symbolRscHandle];
-          if (!handle4) {
-            const rep = e[symbolRscRep] || ++captureCnt0;
-            captureTable0.set(rep, e);
-            handle4 = rscTableCreateOwn(handleTable0, rep);
-          }
-          dataView(memory0).setInt32(arg3 + 8, handle4, true);
-          break;
-        }
-        case 'closed': {
-          dataView(memory0).setInt8(arg3 + 4, 1, true);
-          break;
-        }
-        default: {
-          throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant5.tag)}\` (received \`${variant5}\`) specified for \`StreamError\``);
-        }
-      }
-      break;
-    }
-    default: {
-      throw new TypeError('invalid variant specified for result');
-    }
-  }
-  _debugLog('[iface="wasi:io/streams@0.2.6", function="[method]output-stream.blocking-write-and-flush"][Instruction::Return]', {
-    funcName: '[method]output-stream.blocking-write-and-flush',
-    paramCount: 0,
-    async: false,
-    postReturn: false
-  });
-}
-
-
-function trampoline11(arg0) {
-  _debugLog('[iface="wasi:random/insecure-seed@0.2.6", function="insecure-seed"] [Instruction::CallInterface] (async? sync, @ enter)');
-  const _interface_call_currentTaskID = startCurrentTask(0, false, 'insecure-seed');
-  const ret = insecureSeed();
-  _debugLog('[iface="wasi:random/insecure-seed@0.2.6", function="insecure-seed"] [Instruction::CallInterface] (sync, @ post-call)');
-  endCurrentTask(0);
-  var [tuple0_0, tuple0_1] = ret;
-  dataView(memory0).setBigInt64(arg0 + 0, toUint64(tuple0_0), true);
-  dataView(memory0).setBigInt64(arg0 + 8, toUint64(tuple0_1), true);
-  _debugLog('[iface="wasi:random/insecure-seed@0.2.6", function="insecure-seed"][Instruction::Return]', {
-    funcName: 'insecure-seed',
-    paramCount: 0,
-    async: false,
-    postReturn: false
-  });
-}
-
-
-function trampoline12(arg0) {
-  _debugLog('[iface="wasi:cli/environment@0.2.6", 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.6", function="get-environment"] [Instruction::CallInterface] (sync, @ post-call)');
-  endCurrentTask(0);
-  var vec3 = ret;
-  var len3 = vec3.length;
-  var result3 = realloc1(0, 0, 4, len3 * 16);
-  for (let i = 0; i < vec3.length; i++) {
-    const e = vec3[i];
-    const base = result3 + i * 16;var [tuple0_0, tuple0_1] = e;
-    var ptr1 = utf8Encode(tuple0_0, realloc1, memory0);
-    var len1 = utf8EncodedLen;
-    dataView(memory0).setUint32(base + 4, len1, true);
-    dataView(memory0).setUint32(base + 0, ptr1, true);
-    var ptr2 = utf8Encode(tuple0_1, realloc1, memory0);
-    var len2 = utf8EncodedLen;
-    dataView(memory0).setUint32(base + 12, len2, true);
-    dataView(memory0).setUint32(base + 8, ptr2, true);
-  }
-  dataView(memory0).setUint32(arg0 + 4, len3, true);
-  dataView(memory0).setUint32(arg0 + 0, result3, true);
-  _debugLog('[iface="wasi:cli/environment@0.2.6", function="get-environment"][Instruction::Return]', {
-    funcName: 'get-environment',
-    paramCount: 0,
-    async: false,
-    postReturn: false
-  });
-}
-
-
-function trampoline13(arg0, arg1) {
-  var handle1 = arg0;
-  var rep2 = handleTable0[(handle1 << 1) + 1] & ~T_FLAG;
-  var rsc0 = captureTable0.get(rep2);
-  if (!rsc0) {
-    rsc0 = Object.create(Error$1.prototype);
-    Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
-    Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
-  }
-  curResourceBorrows.push(rsc0);
-  _debugLog('[iface="wasi:filesystem/types@0.2.6", 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.6", function="filesystem-error-code"] [Instruction::CallInterface] (sync, @ post-call)');
-  for (const rsc of curResourceBorrows) {
-    rsc[symbolRscHandle] = undefined;
-  }
-  curResourceBorrows = [];
-  endCurrentTask(0);
-  var variant4 = ret;
-  if (variant4 === null || variant4=== undefined) {
-    dataView(memory0).setInt8(arg1 + 0, 0, true);
-  } else {
-    const e = variant4;
-    dataView(memory0).setInt8(arg1 + 0, 1, true);
-    var val3 = e;
-    let enum3;
-    switch (val3) {
-      case 'access': {
-        enum3 = 0;
-        break;
-      }
-      case 'would-block': {
-        enum3 = 1;
-        break;
-      }
-      case 'already': {
-        enum3 = 2;
-        break;
-      }
-      case 'bad-descriptor': {
-        enum3 = 3;
-        break;
-      }
-      case 'busy': {
-        enum3 = 4;
-        break;
-      }
-      case 'deadlock': {
-        enum3 = 5;
-        break;
-      }
-      case 'quota': {
-        enum3 = 6;
-        break;
-      }
-      case 'exist': {
-        enum3 = 7;
-        break;
-      }
-      case 'file-too-large': {
-        enum3 = 8;
-        break;
-      }
-      case 'illegal-byte-sequence': {
-        enum3 = 9;
-        break;
-      }
-      case 'in-progress': {
-        enum3 = 10;
-        break;
-      }
-      case 'interrupted': {
-        enum3 = 11;
-        break;
-      }
-      case 'invalid': {
-        enum3 = 12;
-        break;
-      }
-      case 'io': {
-        enum3 = 13;
-        break;
-      }
-      case 'is-directory': {
-        enum3 = 14;
-        break;
-      }
-      case 'loop': {
-        enum3 = 15;
-        break;
-      }
-      case 'too-many-links': {
-        enum3 = 16;
-        break;
-      }
-      case 'message-size': {
-        enum3 = 17;
-        break;
-      }
-      case 'name-too-long': {
-        enum3 = 18;
-        break;
-      }
-      case 'no-device': {
-        enum3 = 19;
-        break;
-      }
-      case 'no-entry': {
-        enum3 = 20;
-        break;
-      }
-      case 'no-lock': {
-        enum3 = 21;
-        break;
-      }
-      case 'insufficient-memory': {
-        enum3 = 22;
-        break;
-      }
-      case 'insufficient-space': {
-        enum3 = 23;
-        break;
-      }
-      case 'not-directory': {
-        enum3 = 24;
-        break;
-      }
-      case 'not-empty': {
-        enum3 = 25;
-        break;
-      }
-      case 'not-recoverable': {
-        enum3 = 26;
-        break;
-      }
-      case 'unsupported': {
-        enum3 = 27;
-        break;
-      }
-      case 'no-tty': {
-        enum3 = 28;
-        break;
-      }
-      case 'no-such-device': {
-        enum3 = 29;
-        break;
-      }
-      case 'overflow': {
-        enum3 = 30;
-        break;
-      }
-      case 'not-permitted': {
-        enum3 = 31;
-        break;
-      }
-      case 'pipe': {
-        enum3 = 32;
-        break;
-      }
-      case 'read-only': {
-        enum3 = 33;
+  
+  
+  function trampoline8(arg0) {
+    let variant0;
+    switch (arg0) {
+      case 0: {
+        variant0= {
+          tag: 'ok',
+          val: undefined
+        };
         break;
       }
-      case 'invalid-seek': {
-        enum3 = 34;
+      case 1: {
+        variant0= {
+          tag: 'err',
+          val: undefined
+        };
         break;
       }
-      case 'text-file-busy': {
-        enum3 = 35;
+      default: {
+        throw new TypeError('invalid variant discriminant for expected');
+      }
+    }
+    _debugLog('[iface="wasi:cli/exit@0.2.6", function="exit"] [Instruction::CallInterface] (async? sync, @ enter)');
+    const _interface_call_currentTaskID = startCurrentTask(0, false, 'exit');
+    exit(variant0);
+    _debugLog('[iface="wasi:cli/exit@0.2.6", function="exit"] [Instruction::CallInterface] (sync, @ post-call)');
+    endCurrentTask(0);
+    _debugLog('[iface="wasi:cli/exit@0.2.6", function="exit"][Instruction::Return]', {
+      funcName: 'exit',
+      paramCount: 0,
+      async: false,
+      postReturn: false
+    });
+  }
+  
+  let exports2;
+  let memory0;
+  let realloc0;
+  let realloc1;
+  const handleTable0 = [T_FLAG, 0];
+  const captureTable0= new Map();
+  let captureCnt0 = 0;
+  handleTables[0] = handleTable0;
+  
+  function trampoline9(arg0, arg1) {
+    var handle1 = arg0;
+    var rep2 = handleTable0[(handle1 << 1) + 1] & ~T_FLAG;
+    var rsc0 = captureTable0.get(rep2);
+    if (!rsc0) {
+      rsc0 = Object.create(Error$1.prototype);
+      Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
+      Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
+    }
+    curResourceBorrows.push(rsc0);
+    _debugLog('[iface="wasi:io/error@0.2.6", function="[method]error.to-debug-string"] [Instruction::CallInterface] (async? sync, @ enter)');
+    const _interface_call_currentTaskID = startCurrentTask(0, false, '[method]error.to-debug-string');
+    const ret = rsc0.toDebugString();
+    _debugLog('[iface="wasi:io/error@0.2.6", function="[method]error.to-debug-string"] [Instruction::CallInterface] (sync, @ post-call)');
+    for (const rsc of curResourceBorrows) {
+      rsc[symbolRscHandle] = undefined;
+    }
+    curResourceBorrows = [];
+    endCurrentTask(0);
+    var ptr3 = utf8Encode(ret, realloc0, memory0);
+    var len3 = utf8EncodedLen;
+    dataView(memory0).setUint32(arg1 + 4, len3, true);
+    dataView(memory0).setUint32(arg1 + 0, ptr3, true);
+    _debugLog('[iface="wasi:io/error@0.2.6", function="[method]error.to-debug-string"][Instruction::Return]', {
+      funcName: '[method]error.to-debug-string',
+      paramCount: 0,
+      async: false,
+      postReturn: false
+    });
+  }
+  
+  
+  function trampoline10(arg0, arg1, arg2, arg3) {
+    var handle1 = arg0;
+    var rep2 = handleTable1[(handle1 << 1) + 1] & ~T_FLAG;
+    var rsc0 = captureTable1.get(rep2);
+    if (!rsc0) {
+      rsc0 = Object.create(OutputStream.prototype);
+      Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
+      Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
+    }
+    curResourceBorrows.push(rsc0);
+    var ptr3 = arg1;
+    var len3 = arg2;
+    var result3 = new Uint8Array(memory0.buffer.slice(ptr3, ptr3 + len3 * 1));
+    _debugLog('[iface="wasi:io/streams@0.2.6", 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.6", function="[method]output-stream.blocking-write-and-flush"] [Instruction::CallInterface] (sync, @ post-call)');
+    for (const rsc of curResourceBorrows) {
+      rsc[symbolRscHandle] = undefined;
+    }
+    curResourceBorrows = [];
+    endCurrentTask(0);
+    var variant6 = ret;
+    switch (variant6.tag) {
+      case 'ok': {
+        const e = variant6.val;
+        dataView(memory0).setInt8(arg3 + 0, 0, true);
         break;
       }
-      case 'cross-device': {
-        enum3 = 36;
+      case 'err': {
+        const e = variant6.val;
+        dataView(memory0).setInt8(arg3 + 0, 1, true);
+        var variant5 = e;
+        switch (variant5.tag) {
+          case 'last-operation-failed': {
+            const e = variant5.val;
+            dataView(memory0).setInt8(arg3 + 4, 0, true);
+            if (!(e instanceof Error$1)) {
+              throw new TypeError('Resource error: Not a valid "Error" resource.');
+            }
+            var handle4 = e[symbolRscHandle];
+            if (!handle4) {
+              const rep = e[symbolRscRep] || ++captureCnt0;
+              captureTable0.set(rep, e);
+              handle4 = rscTableCreateOwn(handleTable0, rep);
+            }
+            dataView(memory0).setInt32(arg3 + 8, handle4, true);
+            break;
+          }
+          case 'closed': {
+            dataView(memory0).setInt8(arg3 + 4, 1, true);
+            break;
+          }
+          default: {
+            throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant5.tag)}\` (received \`${variant5}\`) specified for \`StreamError\``);
+          }
+        }
         break;
       }
       default: {
-        if ((e) instanceof Error) {
-          console.error(e);
-        }
-        
-        throw new TypeError(`"${val3}" is not one of the cases of error-code`);
+        throw new TypeError('invalid variant specified for result');
       }
     }
-    dataView(memory0).setInt8(arg1 + 1, enum3, true);
-  }
-  _debugLog('[iface="wasi:filesystem/types@0.2.6", function="filesystem-error-code"][Instruction::Return]', {
-    funcName: 'filesystem-error-code',
-    paramCount: 0,
-    async: false,
-    postReturn: false
-  });
-}
-
-const handleTable4 = [T_FLAG, 0];
-const captureTable4= new Map();
-let captureCnt4 = 0;
-handleTables[4] = handleTable4;
-
-function trampoline14(arg0, arg1, arg2) {
-  var handle1 = arg0;
-  var rep2 = handleTable4[(handle1 << 1) + 1] & ~T_FLAG;
-  var rsc0 = captureTable4.get(rep2);
-  if (!rsc0) {
-    rsc0 = Object.create(Descriptor.prototype);
-    Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
-    Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
+    _debugLog('[iface="wasi:io/streams@0.2.6", function="[method]output-stream.blocking-write-and-flush"][Instruction::Return]', {
+      funcName: '[method]output-stream.blocking-write-and-flush',
+      paramCount: 0,
+      async: false,
+      postReturn: false
+    });
   }
-  curResourceBorrows.push(rsc0);
-  _debugLog('[iface="wasi:filesystem/types@0.2.6", 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) };
+  
+  
+  function trampoline11(arg0) {
+    _debugLog('[iface="wasi:random/insecure-seed@0.2.6", function="insecure-seed"] [Instruction::CallInterface] (async? sync, @ enter)');
+    const _interface_call_currentTaskID = startCurrentTask(0, false, 'insecure-seed');
+    const ret = insecureSeed();
+    _debugLog('[iface="wasi:random/insecure-seed@0.2.6", function="insecure-seed"] [Instruction::CallInterface] (sync, @ post-call)');
+    endCurrentTask(0);
+    var [tuple0_0, tuple0_1] = ret;
+    dataView(memory0).setBigInt64(arg0 + 0, toUint64(tuple0_0), true);
+    dataView(memory0).setBigInt64(arg0 + 8, toUint64(tuple0_1), true);
+    _debugLog('[iface="wasi:random/insecure-seed@0.2.6", function="insecure-seed"][Instruction::Return]', {
+      funcName: 'insecure-seed',
+      paramCount: 0,
+      async: false,
+      postReturn: false
+    });
   }
-  _debugLog('[iface="wasi:filesystem/types@0.2.6", function="[method]descriptor.write-via-stream"] [Instruction::CallInterface] (sync, @ post-call)');
-  for (const rsc of curResourceBorrows) {
-    rsc[symbolRscHandle] = undefined;
+  
+  
+  function trampoline12(arg0) {
+    _debugLog('[iface="wasi:cli/environment@0.2.6", 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.6", function="get-environment"] [Instruction::CallInterface] (sync, @ post-call)');
+    endCurrentTask(0);
+    var vec3 = ret;
+    var len3 = vec3.length;
+    var result3 = realloc1(0, 0, 4, len3 * 16);
+    for (let i = 0; i < vec3.length; i++) {
+      const e = vec3[i];
+      const base = result3 + i * 16;var [tuple0_0, tuple0_1] = e;
+      var ptr1 = utf8Encode(tuple0_0, realloc1, memory0);
+      var len1 = utf8EncodedLen;
+      dataView(memory0).setUint32(base + 4, len1, true);
+      dataView(memory0).setUint32(base + 0, ptr1, true);
+      var ptr2 = utf8Encode(tuple0_1, realloc1, memory0);
+      var len2 = utf8EncodedLen;
+      dataView(memory0).setUint32(base + 12, len2, true);
+      dataView(memory0).setUint32(base + 8, ptr2, true);
+    }
+    dataView(memory0).setUint32(arg0 + 4, len3, true);
+    dataView(memory0).setUint32(arg0 + 0, result3, true);
+    _debugLog('[iface="wasi:cli/environment@0.2.6", function="get-environment"][Instruction::Return]', {
+      funcName: 'get-environment',
+      paramCount: 0,
+      async: false,
+      postReturn: false
+    });
   }
-  curResourceBorrows = [];
-  endCurrentTask(0);
-  var variant5 = ret;
-  switch (variant5.tag) {
-    case 'ok': {
-      const e = variant5.val;
-      dataView(memory0).setInt8(arg2 + 0, 0, true);
-      if (!(e instanceof OutputStream)) {
-        throw new TypeError('Resource error: Not a valid "OutputStream" resource.');
-      }
-      var handle3 = e[symbolRscHandle];
-      if (!handle3) {
-        const rep = e[symbolRscRep] || ++captureCnt1;
-        captureTable1.set(rep, e);
-        handle3 = rscTableCreateOwn(handleTable1, rep);
-      }
-      dataView(memory0).setInt32(arg2 + 4, handle3, true);
-      break;
-    }
-    case 'err': {
-      const e = variant5.val;
-      dataView(memory0).setInt8(arg2 + 0, 1, true);
-      var val4 = e;
-      let enum4;
-      switch (val4) {
+  
+  
+  function trampoline13(arg0, arg1) {
+    var handle1 = arg0;
+    var rep2 = handleTable0[(handle1 << 1) + 1] & ~T_FLAG;
+    var rsc0 = captureTable0.get(rep2);
+    if (!rsc0) {
+      rsc0 = Object.create(Error$1.prototype);
+      Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
+      Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
+    }
+    curResourceBorrows.push(rsc0);
+    _debugLog('[iface="wasi:filesystem/types@0.2.6", 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.6", function="filesystem-error-code"] [Instruction::CallInterface] (sync, @ post-call)');
+    for (const rsc of curResourceBorrows) {
+      rsc[symbolRscHandle] = undefined;
+    }
+    curResourceBorrows = [];
+    endCurrentTask(0);
+    var variant4 = ret;
+    if (variant4 === null || variant4=== undefined) {
+      dataView(memory0).setInt8(arg1 + 0, 0, true);
+    } else {
+      const e = variant4;
+      dataView(memory0).setInt8(arg1 + 0, 1, true);
+      var val3 = e;
+      let enum3;
+      switch (val3) {
         case 'access': {
-          enum4 = 0;
+          enum3 = 0;
           break;
         }
         case 'would-block': {
-          enum4 = 1;
+          enum3 = 1;
           break;
         }
         case 'already': {
-          enum4 = 2;
+          enum3 = 2;
           break;
         }
         case 'bad-descriptor': {
-          enum4 = 3;
+          enum3 = 3;
           break;
         }
         case 'busy': {
-          enum4 = 4;
+          enum3 = 4;
           break;
         }
         case 'deadlock': {
-          enum4 = 5;
+          enum3 = 5;
           break;
         }
         case 'quota': {
-          enum4 = 6;
+          enum3 = 6;
           break;
         }
         case 'exist': {
-          enum4 = 7;
+          enum3 = 7;
           break;
         }
         case 'file-too-large': {
-          enum4 = 8;
+          enum3 = 8;
           break;
         }
         case 'illegal-byte-sequence': {
-          enum4 = 9;
+          enum3 = 9;
           break;
         }
         case 'in-progress': {
-          enum4 = 10;
+          enum3 = 10;
           break;
         }
         case 'interrupted': {
-          enum4 = 11;
+          enum3 = 11;
           break;
         }
         case 'invalid': {
-          enum4 = 12;
+          enum3 = 12;
           break;
         }
         case 'io': {
-          enum4 = 13;
+          enum3 = 13;
           break;
         }
         case 'is-directory': {
-          enum4 = 14;
+          enum3 = 14;
           break;
         }
         case 'loop': {
-          enum4 = 15;
+          enum3 = 15;
           break;
         }
         case 'too-many-links': {
-          enum4 = 16;
+          enum3 = 16;
           break;
         }
         case 'message-size': {
-          enum4 = 17;
+          enum3 = 17;
           break;
         }
         case 'name-too-long': {
-          enum4 = 18;
+          enum3 = 18;
           break;
         }
         case 'no-device': {
-          enum4 = 19;
+          enum3 = 19;
           break;
         }
         case 'no-entry': {
-          enum4 = 20;
+          enum3 = 20;
           break;
         }
         case 'no-lock': {
-          enum4 = 21;
+          enum3 = 21;
           break;
         }
         case 'insufficient-memory': {
-          enum4 = 22;
+          enum3 = 22;
           break;
         }
         case 'insufficient-space': {
-          enum4 = 23;
+          enum3 = 23;
           break;
         }
         case 'not-directory': {
-          enum4 = 24;
+          enum3 = 24;
           break;
         }
         case 'not-empty': {
-          enum4 = 25;
+          enum3 = 25;
           break;
         }
         case 'not-recoverable': {
-          enum4 = 26;
+          enum3 = 26;
           break;
         }
         case 'unsupported': {
-          enum4 = 27;
+          enum3 = 27;
           break;
         }
         case 'no-tty': {
-          enum4 = 28;
+          enum3 = 28;
           break;
         }
         case 'no-such-device': {
-          enum4 = 29;
+          enum3 = 29;
           break;
         }
         case 'overflow': {
-          enum4 = 30;
+          enum3 = 30;
           break;
         }
         case 'not-permitted': {
-          enum4 = 31;
+          enum3 = 31;
           break;
         }
         case 'pipe': {
-          enum4 = 32;
+          enum3 = 32;
           break;
         }
         case 'read-only': {
-          enum4 = 33;
+          enum3 = 33;
           break;
         }
         case 'invalid-seek': {
-          enum4 = 34;
+          enum3 = 34;
           break;
         }
         case 'text-file-busy': {
-          enum4 = 35;
+          enum3 = 35;
           break;
         }
         case 'cross-device': {
-          enum4 = 36;
+          enum3 = 36;
           break;
         }
         default: {
@@ -1491,1317 +1260,1526 @@ function trampoline14(arg0, arg1, arg2) {
             console.error(e);
           }
           
-          throw new TypeError(`"${val4}" is not one of the cases of error-code`);
+          throw new TypeError(`"${val3}" is not one of the cases of error-code`);
         }
       }
-      dataView(memory0).setInt8(arg2 + 4, enum4, true);
-      break;
-    }
-    default: {
-      throw new TypeError('invalid variant specified for result');
+      dataView(memory0).setInt8(arg1 + 1, enum3, true);
     }
+    _debugLog('[iface="wasi:filesystem/types@0.2.6", function="filesystem-error-code"][Instruction::Return]', {
+      funcName: 'filesystem-error-code',
+      paramCount: 0,
+      async: false,
+      postReturn: false
+    });
   }
-  _debugLog('[iface="wasi:filesystem/types@0.2.6", function="[method]descriptor.write-via-stream"][Instruction::Return]', {
-    funcName: '[method]descriptor.write-via-stream',
-    paramCount: 0,
-    async: false,
-    postReturn: false
-  });
-}
-
-
-function trampoline15(arg0, arg1) {
-  var handle1 = arg0;
-  var rep2 = handleTable4[(handle1 << 1) + 1] & ~T_FLAG;
-  var rsc0 = captureTable4.get(rep2);
-  if (!rsc0) {
-    rsc0 = Object.create(Descriptor.prototype);
-    Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
-    Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
-  }
-  curResourceBorrows.push(rsc0);
-  _debugLog('[iface="wasi:filesystem/types@0.2.6", 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.6", function="[method]descriptor.append-via-stream"] [Instruction::CallInterface] (sync, @ post-call)');
-  for (const rsc of curResourceBorrows) {
-    rsc[symbolRscHandle] = undefined;
-  }
-  curResourceBorrows = [];
-  endCurrentTask(0);
-  var variant5 = ret;
-  switch (variant5.tag) {
-    case 'ok': {
-      const e = variant5.val;
-      dataView(memory0).setInt8(arg1 + 0, 0, true);
-      if (!(e instanceof OutputStream)) {
-        throw new TypeError('Resource error: Not a valid "OutputStream" resource.');
+  
+  const handleTable4 = [T_FLAG, 0];
+  const captureTable4= new Map();
+  let captureCnt4 = 0;
+  handleTables[4] = handleTable4;
+  
+  function trampoline14(arg0, arg1, arg2) {
+    var handle1 = arg0;
+    var rep2 = handleTable4[(handle1 << 1) + 1] & ~T_FLAG;
+    var rsc0 = captureTable4.get(rep2);
+    if (!rsc0) {
+      rsc0 = Object.create(Descriptor.prototype);
+      Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
+      Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
+    }
+    curResourceBorrows.push(rsc0);
+    _debugLog('[iface="wasi:filesystem/types@0.2.6", 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.6", function="[method]descriptor.write-via-stream"] [Instruction::CallInterface] (sync, @ post-call)');
+    for (const rsc of curResourceBorrows) {
+      rsc[symbolRscHandle] = undefined;
+    }
+    curResourceBorrows = [];
+    endCurrentTask(0);
+    var variant5 = ret;
+    switch (variant5.tag) {
+      case 'ok': {
+        const e = variant5.val;
+        dataView(memory0).setInt8(arg2 + 0, 0, true);
+        if (!(e instanceof OutputStream)) {
+          throw new TypeError('Resource error: Not a valid "OutputStream" resource.');
+        }
+        var handle3 = e[symbolRscHandle];
+        if (!handle3) {
+          const rep = e[symbolRscRep] || ++captureCnt1;
+          captureTable1.set(rep, e);
+          handle3 = rscTableCreateOwn(handleTable1, rep);
+        }
+        dataView(memory0).setInt32(arg2 + 4, handle3, true);
+        break;
+      }
+      case 'err': {
+        const e = variant5.val;
+        dataView(memory0).setInt8(arg2 + 0, 1, true);
+        var val4 = e;
+        let enum4;
+        switch (val4) {
+          case 'access': {
+            enum4 = 0;
+            break;
+          }
+          case 'would-block': {
+            enum4 = 1;
+            break;
+          }
+          case 'already': {
+            enum4 = 2;
+            break;
+          }
+          case 'bad-descriptor': {
+            enum4 = 3;
+            break;
+          }
+          case 'busy': {
+            enum4 = 4;
+            break;
+          }
+          case 'deadlock': {
+            enum4 = 5;
+            break;
+          }
+          case 'quota': {
+            enum4 = 6;
+            break;
+          }
+          case 'exist': {
+            enum4 = 7;
+            break;
+          }
+          case 'file-too-large': {
+            enum4 = 8;
+            break;
+          }
+          case 'illegal-byte-sequence': {
+            enum4 = 9;
+            break;
+          }
+          case 'in-progress': {
+            enum4 = 10;
+            break;
+          }
+          case 'interrupted': {
+            enum4 = 11;
+            break;
+          }
+          case 'invalid': {
+            enum4 = 12;
+            break;
+          }
+          case 'io': {
+            enum4 = 13;
+            break;
+          }
+          case 'is-directory': {
+            enum4 = 14;
+            break;
+          }
+          case 'loop': {
+            enum4 = 15;
+            break;
+          }
+          case 'too-many-links': {
+            enum4 = 16;
+            break;
+          }
+          case 'message-size': {
+            enum4 = 17;
+            break;
+          }
+          case 'name-too-long': {
+            enum4 = 18;
+            break;
+          }
+          case 'no-device': {
+            enum4 = 19;
+            break;
+          }
+          case 'no-entry': {
+            enum4 = 20;
+            break;
+          }
+          case 'no-lock': {
+            enum4 = 21;
+            break;
+          }
+          case 'insufficient-memory': {
+            enum4 = 22;
+            break;
+          }
+          case 'insufficient-space': {
+            enum4 = 23;
+            break;
+          }
+          case 'not-directory': {
+            enum4 = 24;
+            break;
+          }
+          case 'not-empty': {
+            enum4 = 25;
+            break;
+          }
+          case 'not-recoverable': {
+            enum4 = 26;
+            break;
+          }
+          case 'unsupported': {
+            enum4 = 27;
+            break;
+          }
+          case 'no-tty': {
+            enum4 = 28;
+            break;
+          }
+          case 'no-such-device': {
+            enum4 = 29;
+            break;
+          }
+          case 'overflow': {
+            enum4 = 30;
+            break;
+          }
+          case 'not-permitted': {
+            enum4 = 31;
+            break;
+          }
+          case 'pipe': {
+            enum4 = 32;
+            break;
+          }
+          case 'read-only': {
+            enum4 = 33;
+            break;
+          }
+          case 'invalid-seek': {
+            enum4 = 34;
+            break;
+          }
+          case 'text-file-busy': {
+            enum4 = 35;
+            break;
+          }
+          case 'cross-device': {
+            enum4 = 36;
+            break;
+          }
+          default: {
+            if ((e) instanceof Error) {
+              console.error(e);
+            }
+            
+            throw new TypeError(`"${val4}" is not one of the cases of error-code`);
+          }
+        }
+        dataView(memory0).setInt8(arg2 + 4, enum4, true);
+        break;
       }
-      var handle3 = e[symbolRscHandle];
-      if (!handle3) {
-        const rep = e[symbolRscRep] || ++captureCnt1;
-        captureTable1.set(rep, e);
-        handle3 = rscTableCreateOwn(handleTable1, rep);
+      default: {
+        throw new TypeError('invalid variant specified for result');
       }
-      dataView(memory0).setInt32(arg1 + 4, handle3, true);
-      break;
     }
-    case 'err': {
-      const e = variant5.val;
-      dataView(memory0).setInt8(arg1 + 0, 1, true);
-      var val4 = e;
-      let enum4;
-      switch (val4) {
-        case 'access': {
-          enum4 = 0;
-          break;
-        }
-        case 'would-block': {
-          enum4 = 1;
-          break;
-        }
-        case 'already': {
-          enum4 = 2;
-          break;
-        }
-        case 'bad-descriptor': {
-          enum4 = 3;
-          break;
-        }
-        case 'busy': {
-          enum4 = 4;
-          break;
-        }
-        case 'deadlock': {
-          enum4 = 5;
-          break;
-        }
-        case 'quota': {
-          enum4 = 6;
-          break;
-        }
-        case 'exist': {
-          enum4 = 7;
-          break;
-        }
-        case 'file-too-large': {
-          enum4 = 8;
-          break;
-        }
-        case 'illegal-byte-sequence': {
-          enum4 = 9;
-          break;
-        }
-        case 'in-progress': {
-          enum4 = 10;
-          break;
-        }
-        case 'interrupted': {
-          enum4 = 11;
-          break;
-        }
-        case 'invalid': {
-          enum4 = 12;
-          break;
-        }
-        case 'io': {
-          enum4 = 13;
-          break;
-        }
-        case 'is-directory': {
-          enum4 = 14;
-          break;
-        }
-        case 'loop': {
-          enum4 = 15;
-          break;
-        }
-        case 'too-many-links': {
-          enum4 = 16;
-          break;
-        }
-        case 'message-size': {
-          enum4 = 17;
-          break;
-        }
-        case 'name-too-long': {
-          enum4 = 18;
-          break;
-        }
-        case 'no-device': {
-          enum4 = 19;
-          break;
-        }
-        case 'no-entry': {
-          enum4 = 20;
-          break;
-        }
-        case 'no-lock': {
-          enum4 = 21;
-          break;
-        }
-        case 'insufficient-memory': {
-          enum4 = 22;
-          break;
-        }
-        case 'insufficient-space': {
-          enum4 = 23;
-          break;
-        }
-        case 'not-directory': {
-          enum4 = 24;
-          break;
-        }
-        case 'not-empty': {
-          enum4 = 25;
-          break;
-        }
-        case 'not-recoverable': {
-          enum4 = 26;
-          break;
-        }
-        case 'unsupported': {
-          enum4 = 27;
-          break;
-        }
-        case 'no-tty': {
-          enum4 = 28;
-          break;
-        }
-        case 'no-such-device': {
-          enum4 = 29;
-          break;
-        }
-        case 'overflow': {
-          enum4 = 30;
-          break;
-        }
-        case 'not-permitted': {
-          enum4 = 31;
-          break;
-        }
-        case 'pipe': {
-          enum4 = 32;
-          break;
-        }
-        case 'read-only': {
-          enum4 = 33;
-          break;
-        }
-        case 'invalid-seek': {
-          enum4 = 34;
-          break;
-        }
-        case 'text-file-busy': {
-          enum4 = 35;
-          break;
-        }
-        case 'cross-device': {
-          enum4 = 36;
-          break;
-        }
-        default: {
-          if ((e) instanceof Error) {
-            console.error(e);
-          }
-          
-          throw new TypeError(`"${val4}" is not one of the cases of error-code`);
-        }
-      }
-      dataView(memory0).setInt8(arg1 + 4, enum4, true);
-      break;
-    }
-    default: {
-      throw new TypeError('invalid variant specified for result');
-    }
-  }
-  _debugLog('[iface="wasi:filesystem/types@0.2.6", function="[method]descriptor.append-via-stream"][Instruction::Return]', {
-    funcName: '[method]descriptor.append-via-stream',
-    paramCount: 0,
-    async: false,
-    postReturn: false
-  });
-}
-
-
-function trampoline16(arg0, arg1) {
-  var handle1 = arg0;
-  var rep2 = handleTable4[(handle1 << 1) + 1] & ~T_FLAG;
-  var rsc0 = captureTable4.get(rep2);
-  if (!rsc0) {
-    rsc0 = Object.create(Descriptor.prototype);
-    Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
-    Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
-  }
-  curResourceBorrows.push(rsc0);
-  _debugLog('[iface="wasi:filesystem/types@0.2.6", 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.6", function="[method]descriptor.get-type"] [Instruction::CallInterface] (sync, @ post-call)');
-  for (const rsc of curResourceBorrows) {
-    rsc[symbolRscHandle] = undefined;
+    _debugLog('[iface="wasi:filesystem/types@0.2.6", function="[method]descriptor.write-via-stream"][Instruction::Return]', {
+      funcName: '[method]descriptor.write-via-stream',
+      paramCount: 0,
+      async: false,
+      postReturn: false
+    });
   }
-  curResourceBorrows = [];
-  endCurrentTask(0);
-  var variant5 = ret;
-  switch (variant5.tag) {
-    case 'ok': {
-      const e = variant5.val;
-      dataView(memory0).setInt8(arg1 + 0, 0, true);
-      var val3 = e;
-      let enum3;
-      switch (val3) {
-        case 'unknown': {
-          enum3 = 0;
-          break;
-        }
-        case 'block-device': {
-          enum3 = 1;
-          break;
-        }
-        case 'character-device': {
-          enum3 = 2;
-          break;
-        }
-        case 'directory': {
-          enum3 = 3;
-          break;
-        }
-        case 'fifo': {
-          enum3 = 4;
-          break;
-        }
-        case 'symbolic-link': {
-          enum3 = 5;
-          break;
-        }
-        case 'regular-file': {
-          enum3 = 6;
-          break;
-        }
-        case 'socket': {
-          enum3 = 7;
-          break;
-        }
-        default: {
-          if ((e) instanceof Error) {
-            console.error(e);
-          }
-          
-          throw new TypeError(`"${val3}" is not one of the cases of descriptor-type`);
-        }
-      }
-      dataView(memory0).setInt8(arg1 + 1, enum3, true);
-      break;
+  
+  
+  function trampoline15(arg0, arg1) {
+    var handle1 = arg0;
+    var rep2 = handleTable4[(handle1 << 1) + 1] & ~T_FLAG;
+    var rsc0 = captureTable4.get(rep2);
+    if (!rsc0) {
+      rsc0 = Object.create(Descriptor.prototype);
+      Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
+      Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
     }
-    case 'err': {
-      const e = variant5.val;
-      dataView(memory0).setInt8(arg1 + 0, 1, true);
-      var val4 = e;
-      let enum4;
-      switch (val4) {
-        case 'access': {
-          enum4 = 0;
-          break;
-        }
-        case 'would-block': {
-          enum4 = 1;
-          break;
-        }
-        case 'already': {
-          enum4 = 2;
-          break;
-        }
-        case 'bad-descriptor': {
-          enum4 = 3;
-          break;
-        }
-        case 'busy': {
-          enum4 = 4;
-          break;
-        }
-        case 'deadlock': {
-          enum4 = 5;
-          break;
-        }
-        case 'quota': {
-          enum4 = 6;
-          break;
-        }
-        case 'exist': {
-          enum4 = 7;
-          break;
-        }
-        case 'file-too-large': {
-          enum4 = 8;
-          break;
-        }
-        case 'illegal-byte-sequence': {
-          enum4 = 9;
-          break;
-        }
-        case 'in-progress': {
-          enum4 = 10;
-          break;
-        }
-        case 'interrupted': {
-          enum4 = 11;
-          break;
-        }
-        case 'invalid': {
-          enum4 = 12;
-          break;
-        }
-        case 'io': {
-          enum4 = 13;
-          break;
-        }
-        case 'is-directory': {
-          enum4 = 14;
-          break;
-        }
-        case 'loop': {
-          enum4 = 15;
-          break;
-        }
-        case 'too-many-links': {
-          enum4 = 16;
-          break;
-        }
-        case 'message-size': {
-          enum4 = 17;
-          break;
-        }
-        case 'name-too-long': {
-          enum4 = 18;
-          break;
-        }
-        case 'no-device': {
-          enum4 = 19;
-          break;
-        }
-        case 'no-entry': {
-          enum4 = 20;
-          break;
-        }
-        case 'no-lock': {
-          enum4 = 21;
-          break;
-        }
-        case 'insufficient-memory': {
-          enum4 = 22;
-          break;
-        }
-        case 'insufficient-space': {
-          enum4 = 23;
-          break;
-        }
-        case 'not-directory': {
-          enum4 = 24;
-          break;
-        }
-        case 'not-empty': {
-          enum4 = 25;
-          break;
-        }
-        case 'not-recoverable': {
-          enum4 = 26;
-          break;
-        }
-        case 'unsupported': {
-          enum4 = 27;
-          break;
-        }
-        case 'no-tty': {
-          enum4 = 28;
-          break;
-        }
-        case 'no-such-device': {
-          enum4 = 29;
-          break;
-        }
-        case 'overflow': {
-          enum4 = 30;
-          break;
-        }
-        case 'not-permitted': {
-          enum4 = 31;
-          break;
-        }
-        case 'pipe': {
-          enum4 = 32;
-          break;
-        }
-        case 'read-only': {
-          enum4 = 33;
-          break;
-        }
-        case 'invalid-seek': {
-          enum4 = 34;
-          break;
-        }
-        case 'text-file-busy': {
-          enum4 = 35;
-          break;
-        }
-        case 'cross-device': {
-          enum4 = 36;
-          break;
-        }
-        default: {
-          if ((e) instanceof Error) {
-            console.error(e);
+    curResourceBorrows.push(rsc0);
+    _debugLog('[iface="wasi:filesystem/types@0.2.6", 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.6", function="[method]descriptor.append-via-stream"] [Instruction::CallInterface] (sync, @ post-call)');
+    for (const rsc of curResourceBorrows) {
+      rsc[symbolRscHandle] = undefined;
+    }
+    curResourceBorrows = [];
+    endCurrentTask(0);
+    var variant5 = ret;
+    switch (variant5.tag) {
+      case 'ok': {
+        const e = variant5.val;
+        dataView(memory0).setInt8(arg1 + 0, 0, true);
+        if (!(e instanceof OutputStream)) {
+          throw new TypeError('Resource error: Not a valid "OutputStream" resource.');
+        }
+        var handle3 = e[symbolRscHandle];
+        if (!handle3) {
+          const rep = e[symbolRscRep] || ++captureCnt1;
+          captureTable1.set(rep, e);
+          handle3 = rscTableCreateOwn(handleTable1, rep);
+        }
+        dataView(memory0).setInt32(arg1 + 4, handle3, true);
+        break;
+      }
+      case 'err': {
+        const e = variant5.val;
+        dataView(memory0).setInt8(arg1 + 0, 1, true);
+        var val4 = e;
+        let enum4;
+        switch (val4) {
+          case 'access': {
+            enum4 = 0;
+            break;
+          }
+          case 'would-block': {
+            enum4 = 1;
+            break;
+          }
+          case 'already': {
+            enum4 = 2;
+            break;
+          }
+          case 'bad-descriptor': {
+            enum4 = 3;
+            break;
+          }
+          case 'busy': {
+            enum4 = 4;
+            break;
+          }
+          case 'deadlock': {
+            enum4 = 5;
+            break;
+          }
+          case 'quota': {
+            enum4 = 6;
+            break;
+          }
+          case 'exist': {
+            enum4 = 7;
+            break;
+          }
+          case 'file-too-large': {
+            enum4 = 8;
+            break;
+          }
+          case 'illegal-byte-sequence': {
+            enum4 = 9;
+            break;
+          }
+          case 'in-progress': {
+            enum4 = 10;
+            break;
+          }
+          case 'interrupted': {
+            enum4 = 11;
+            break;
+          }
+          case 'invalid': {
+            enum4 = 12;
+            break;
+          }
+          case 'io': {
+            enum4 = 13;
+            break;
+          }
+          case 'is-directory': {
+            enum4 = 14;
+            break;
+          }
+          case 'loop': {
+            enum4 = 15;
+            break;
+          }
+          case 'too-many-links': {
+            enum4 = 16;
+            break;
+          }
+          case 'message-size': {
+            enum4 = 17;
+            break;
+          }
+          case 'name-too-long': {
+            enum4 = 18;
+            break;
+          }
+          case 'no-device': {
+            enum4 = 19;
+            break;
+          }
+          case 'no-entry': {
+            enum4 = 20;
+            break;
+          }
+          case 'no-lock': {
+            enum4 = 21;
+            break;
+          }
+          case 'insufficient-memory': {
+            enum4 = 22;
+            break;
+          }
+          case 'insufficient-space': {
+            enum4 = 23;
+            break;
+          }
+          case 'not-directory': {
+            enum4 = 24;
+            break;
+          }
+          case 'not-empty': {
+            enum4 = 25;
+            break;
+          }
+          case 'not-recoverable': {
+            enum4 = 26;
+            break;
+          }
+          case 'unsupported': {
+            enum4 = 27;
+            break;
+          }
+          case 'no-tty': {
+            enum4 = 28;
+            break;
+          }
+          case 'no-such-device': {
+            enum4 = 29;
+            break;
+          }
+          case 'overflow': {
+            enum4 = 30;
+            break;
+          }
+          case 'not-permitted': {
+            enum4 = 31;
+            break;
+          }
+          case 'pipe': {
+            enum4 = 32;
+            break;
+          }
+          case 'read-only': {
+            enum4 = 33;
+            break;
+          }
+          case 'invalid-seek': {
+            enum4 = 34;
+            break;
+          }
+          case 'text-file-busy': {
+            enum4 = 35;
+            break;
+          }
+          case 'cross-device': {
+            enum4 = 36;
+            break;
+          }
+          default: {
+            if ((e) instanceof Error) {
+              console.error(e);
+            }
+            
+            throw new TypeError(`"${val4}" is not one of the cases of error-code`);
           }
-          
-          throw new TypeError(`"${val4}" is not one of the cases of error-code`);
         }
+        dataView(memory0).setInt8(arg1 + 4, enum4, true);
+        break;
+      }
+      default: {
+        throw new TypeError('invalid variant specified for result');
       }
-      dataView(memory0).setInt8(arg1 + 1, enum4, true);
-      break;
-    }
-    default: {
-      throw new TypeError('invalid variant specified for result');
     }
+    _debugLog('[iface="wasi:filesystem/types@0.2.6", function="[method]descriptor.append-via-stream"][Instruction::Return]', {
+      funcName: '[method]descriptor.append-via-stream',
+      paramCount: 0,
+      async: false,
+      postReturn: false
+    });
   }
-  _debugLog('[iface="wasi:filesystem/types@0.2.6", function="[method]descriptor.get-type"][Instruction::Return]', {
-    funcName: '[method]descriptor.get-type',
-    paramCount: 0,
-    async: false,
-    postReturn: false
-  });
-}
-
-
-function trampoline17(arg0, arg1) {
-  var handle1 = arg0;
-  var rep2 = handleTable4[(handle1 << 1) + 1] & ~T_FLAG;
-  var rsc0 = captureTable4.get(rep2);
-  if (!rsc0) {
-    rsc0 = Object.create(Descriptor.prototype);
-    Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
-    Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
-  }
-  curResourceBorrows.push(rsc0);
-  _debugLog('[iface="wasi:filesystem/types@0.2.6", 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.6", function="[method]descriptor.stat"] [Instruction::CallInterface] (sync, @ post-call)');
-  for (const rsc of curResourceBorrows) {
-    rsc[symbolRscHandle] = undefined;
-  }
-  curResourceBorrows = [];
-  endCurrentTask(0);
-  var variant12 = ret;
-  switch (variant12.tag) {
-    case 'ok': {
-      const e = variant12.val;
-      dataView(memory0).setInt8(arg1 + 0, 0, true);
-      var {type: v3_0, linkCount: v3_1, size: v3_2, dataAccessTimestamp: v3_3, dataModificationTimestamp: v3_4, statusChangeTimestamp: v3_5 } = e;
-      var val4 = v3_0;
-      let enum4;
-      switch (val4) {
-        case 'unknown': {
-          enum4 = 0;
-          break;
-        }
-        case 'block-device': {
-          enum4 = 1;
-          break;
-        }
-        case 'character-device': {
-          enum4 = 2;
-          break;
-        }
-        case 'directory': {
-          enum4 = 3;
-          break;
-        }
-        case 'fifo': {
-          enum4 = 4;
-          break;
-        }
-        case 'symbolic-link': {
-          enum4 = 5;
-          break;
-        }
-        case 'regular-file': {
-          enum4 = 6;
-          break;
-        }
-        case 'socket': {
-          enum4 = 7;
-          break;
-        }
-        default: {
-          if ((v3_0) instanceof Error) {
-            console.error(v3_0);
+  
+  
+  function trampoline16(arg0, arg1) {
+    var handle1 = arg0;
+    var rep2 = handleTable4[(handle1 << 1) + 1] & ~T_FLAG;
+    var rsc0 = captureTable4.get(rep2);
+    if (!rsc0) {
+      rsc0 = Object.create(Descriptor.prototype);
+      Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
+      Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
+    }
+    curResourceBorrows.push(rsc0);
+    _debugLog('[iface="wasi:filesystem/types@0.2.6", 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.6", function="[method]descriptor.get-type"] [Instruction::CallInterface] (sync, @ post-call)');
+    for (const rsc of curResourceBorrows) {
+      rsc[symbolRscHandle] = undefined;
+    }
+    curResourceBorrows = [];
+    endCurrentTask(0);
+    var variant5 = ret;
+    switch (variant5.tag) {
+      case 'ok': {
+        const e = variant5.val;
+        dataView(memory0).setInt8(arg1 + 0, 0, true);
+        var val3 = e;
+        let enum3;
+        switch (val3) {
+          case 'unknown': {
+            enum3 = 0;
+            break;
+          }
+          case 'block-device': {
+            enum3 = 1;
+            break;
+          }
+          case 'character-device': {
+            enum3 = 2;
+            break;
+          }
+          case 'directory': {
+            enum3 = 3;
+            break;
+          }
+          case 'fifo': {
+            enum3 = 4;
+            break;
+          }
+          case 'symbolic-link': {
+            enum3 = 5;
+            break;
+          }
+          case 'regular-file': {
+            enum3 = 6;
+            break;
+          }
+          case 'socket': {
+            enum3 = 7;
+            break;
+          }
+          default: {
+            if ((e) instanceof Error) {
+              console.error(e);
+            }
+            
+            throw new TypeError(`"${val3}" is not one of the cases of descriptor-type`);
           }
-          
-          throw new TypeError(`"${val4}" is not one of the cases of descriptor-type`);
-        }
-      }
-      dataView(memory0).setInt8(arg1 + 8, enum4, true);
-      dataView(memory0).setBigInt64(arg1 + 16, toUint64(v3_1), true);
-      dataView(memory0).setBigInt64(arg1 + 24, toUint64(v3_2), true);
-      var variant6 = v3_3;
-      if (variant6 === null || variant6=== undefined) {
-        dataView(memory0).setInt8(arg1 + 32, 0, true);
-      } else {
-        const e = variant6;
-        dataView(memory0).setInt8(arg1 + 32, 1, true);
-        var {seconds: v5_0, nanoseconds: v5_1 } = e;
-        dataView(memory0).setBigInt64(arg1 + 40, toUint64(v5_0), true);
-        dataView(memory0).setInt32(arg1 + 48, toUint32(v5_1), true);
-      }
-      var variant8 = v3_4;
-      if (variant8 === null || variant8=== undefined) {
-        dataView(memory0).setInt8(arg1 + 56, 0, true);
-      } else {
-        const e = variant8;
-        dataView(memory0).setInt8(arg1 + 56, 1, true);
-        var {seconds: v7_0, nanoseconds: v7_1 } = e;
-        dataView(memory0).setBigInt64(arg1 + 64, toUint64(v7_0), true);
-        dataView(memory0).setInt32(arg1 + 72, toUint32(v7_1), true);
-      }
-      var variant10 = v3_5;
-      if (variant10 === null || variant10=== undefined) {
-        dataView(memory0).setInt8(arg1 + 80, 0, true);
-      } else {
-        const e = variant10;
-        dataView(memory0).setInt8(arg1 + 80, 1, true);
-        var {seconds: v9_0, nanoseconds: v9_1 } = e;
-        dataView(memory0).setBigInt64(arg1 + 88, toUint64(v9_0), true);
-        dataView(memory0).setInt32(arg1 + 96, toUint32(v9_1), true);
-      }
-      break;
-    }
-    case 'err': {
-      const e = variant12.val;
-      dataView(memory0).setInt8(arg1 + 0, 1, true);
-      var val11 = e;
-      let enum11;
-      switch (val11) {
-        case 'access': {
-          enum11 = 0;
-          break;
-        }
-        case 'would-block': {
-          enum11 = 1;
-          break;
-        }
-        case 'already': {
-          enum11 = 2;
-          break;
-        }
-        case 'bad-descriptor': {
-          enum11 = 3;
-          break;
-        }
-        case 'busy': {
-          enum11 = 4;
-          break;
-        }
-        case 'deadlock': {
-          enum11 = 5;
-          break;
-        }
-        case 'quota': {
-          enum11 = 6;
-          break;
-        }
-        case 'exist': {
-          enum11 = 7;
-          break;
-        }
-        case 'file-too-large': {
-          enum11 = 8;
-          break;
-        }
-        case 'illegal-byte-sequence': {
-          enum11 = 9;
-          break;
-        }
-        case 'in-progress': {
-          enum11 = 10;
-          break;
-        }
-        case 'interrupted': {
-          enum11 = 11;
-          break;
-        }
-        case 'invalid': {
-          enum11 = 12;
-          break;
-        }
-        case 'io': {
-          enum11 = 13;
-          break;
-        }
-        case 'is-directory': {
-          enum11 = 14;
-          break;
-        }
-        case 'loop': {
-          enum11 = 15;
-          break;
-        }
-        case 'too-many-links': {
-          enum11 = 16;
-          break;
-        }
-        case 'message-size': {
-          enum11 = 17;
-          break;
-        }
-        case 'name-too-long': {
-          enum11 = 18;
-          break;
-        }
-        case 'no-device': {
-          enum11 = 19;
-          break;
-        }
-        case 'no-entry': {
-          enum11 = 20;
-          break;
-        }
-        case 'no-lock': {
-          enum11 = 21;
-          break;
-        }
-        case 'insufficient-memory': {
-          enum11 = 22;
-          break;
-        }
-        case 'insufficient-space': {
-          enum11 = 23;
-          break;
-        }
-        case 'not-directory': {
-          enum11 = 24;
-          break;
-        }
-        case 'not-empty': {
-          enum11 = 25;
-          break;
-        }
-        case 'not-recoverable': {
-          enum11 = 26;
-          break;
-        }
-        case 'unsupported': {
-          enum11 = 27;
-          break;
-        }
-        case 'no-tty': {
-          enum11 = 28;
-          break;
-        }
-        case 'no-such-device': {
-          enum11 = 29;
-          break;
-        }
-        case 'overflow': {
-          enum11 = 30;
-          break;
-        }
-        case 'not-permitted': {
-          enum11 = 31;
-          break;
-        }
-        case 'pipe': {
-          enum11 = 32;
-          break;
-        }
-        case 'read-only': {
-          enum11 = 33;
-          break;
-        }
-        case 'invalid-seek': {
-          enum11 = 34;
-          break;
-        }
-        case 'text-file-busy': {
-          enum11 = 35;
-          break;
-        }
-        case 'cross-device': {
-          enum11 = 36;
-          break;
         }
-        default: {
-          if ((e) instanceof Error) {
-            console.error(e);
+        dataView(memory0).setInt8(arg1 + 1, enum3, true);
+        break;
+      }
+      case 'err': {
+        const e = variant5.val;
+        dataView(memory0).setInt8(arg1 + 0, 1, true);
+        var val4 = e;
+        let enum4;
+        switch (val4) {
+          case 'access': {
+            enum4 = 0;
+            break;
+          }
+          case 'would-block': {
+            enum4 = 1;
+            break;
+          }
+          case 'already': {
+            enum4 = 2;
+            break;
+          }
+          case 'bad-descriptor': {
+            enum4 = 3;
+            break;
+          }
+          case 'busy': {
+            enum4 = 4;
+            break;
+          }
+          case 'deadlock': {
+            enum4 = 5;
+            break;
+          }
+          case 'quota': {
+            enum4 = 6;
+            break;
+          }
+          case 'exist': {
+            enum4 = 7;
+            break;
+          }
+          case 'file-too-large': {
+            enum4 = 8;
+            break;
+          }
+          case 'illegal-byte-sequence': {
+            enum4 = 9;
+            break;
+          }
+          case 'in-progress': {
+            enum4 = 10;
+            break;
+          }
+          case 'interrupted': {
+            enum4 = 11;
+            break;
+          }
+          case 'invalid': {
+            enum4 = 12;
+            break;
+          }
+          case 'io': {
+            enum4 = 13;
+            break;
+          }
+          case 'is-directory': {
+            enum4 = 14;
+            break;
+          }
+          case 'loop': {
+            enum4 = 15;
+            break;
+          }
+          case 'too-many-links': {
+            enum4 = 16;
+            break;
+          }
+          case 'message-size': {
+            enum4 = 17;
+            break;
+          }
+          case 'name-too-long': {
+            enum4 = 18;
+            break;
+          }
+          case 'no-device': {
+            enum4 = 19;
+            break;
+          }
+          case 'no-entry': {
+            enum4 = 20;
+            break;
+          }
+          case 'no-lock': {
+            enum4 = 21;
+            break;
+          }
+          case 'insufficient-memory': {
+            enum4 = 22;
+            break;
+          }
+          case 'insufficient-space': {
+            enum4 = 23;
+            break;
+          }
+          case 'not-directory': {
+            enum4 = 24;
+            break;
+          }
+          case 'not-empty': {
+            enum4 = 25;
+            break;
+          }
+          case 'not-recoverable': {
+            enum4 = 26;
+            break;
+          }
+          case 'unsupported': {
+            enum4 = 27;
+            break;
+          }
+          case 'no-tty': {
+            enum4 = 28;
+            break;
+          }
+          case 'no-such-device': {
+            enum4 = 29;
+            break;
+          }
+          case 'overflow': {
+            enum4 = 30;
+            break;
+          }
+          case 'not-permitted': {
+            enum4 = 31;
+            break;
+          }
+          case 'pipe': {
+            enum4 = 32;
+            break;
+          }
+          case 'read-only': {
+            enum4 = 33;
+            break;
+          }
+          case 'invalid-seek': {
+            enum4 = 34;
+            break;
+          }
+          case 'text-file-busy': {
+            enum4 = 35;
+            break;
+          }
+          case 'cross-device': {
+            enum4 = 36;
+            break;
+          }
+          default: {
+            if ((e) instanceof Error) {
+              console.error(e);
+            }
+            
+            throw new TypeError(`"${val4}" is not one of the cases of error-code`);
           }
-          
-          throw new TypeError(`"${val11}" is not one of the cases of error-code`);
         }
+        dataView(memory0).setInt8(arg1 + 1, enum4, true);
+        break;
+      }
+      default: {
+        throw new TypeError('invalid variant specified for result');
       }
-      dataView(memory0).setInt8(arg1 + 8, enum11, true);
-      break;
-    }
-    default: {
-      throw new TypeError('invalid variant specified for result');
     }
+    _debugLog('[iface="wasi:filesystem/types@0.2.6", function="[method]descriptor.get-type"][Instruction::Return]', {
+      funcName: '[method]descriptor.get-type',
+      paramCount: 0,
+      async: false,
+      postReturn: false
+    });
   }
-  _debugLog('[iface="wasi:filesystem/types@0.2.6", function="[method]descriptor.stat"][Instruction::Return]', {
-    funcName: '[method]descriptor.stat',
-    paramCount: 0,
-    async: false,
-    postReturn: false
-  });
-}
-
-
-function trampoline18(arg0, arg1) {
-  var handle1 = arg0;
-  var rep2 = handleTable1[(handle1 << 1) + 1] & ~T_FLAG;
-  var rsc0 = captureTable1.get(rep2);
-  if (!rsc0) {
-    rsc0 = Object.create(OutputStream.prototype);
-    Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
-    Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
-  }
-  curResourceBorrows.push(rsc0);
-  _debugLog('[iface="wasi:io/streams@0.2.6", 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.6", function="[method]output-stream.check-write"] [Instruction::CallInterface] (sync, @ post-call)');
-  for (const rsc of curResourceBorrows) {
-    rsc[symbolRscHandle] = undefined;
-  }
-  curResourceBorrows = [];
-  endCurrentTask(0);
-  var variant5 = ret;
-  switch (variant5.tag) {
-    case 'ok': {
-      const e = variant5.val;
-      dataView(memory0).setInt8(arg1 + 0, 0, true);
-      dataView(memory0).setBigInt64(arg1 + 8, toUint64(e), true);
-      break;
+  
+  
+  function trampoline17(arg0, arg1) {
+    var handle1 = arg0;
+    var rep2 = handleTable4[(handle1 << 1) + 1] & ~T_FLAG;
+    var rsc0 = captureTable4.get(rep2);
+    if (!rsc0) {
+      rsc0 = Object.create(Descriptor.prototype);
+      Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
+      Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
     }
-    case 'err': {
-      const e = variant5.val;
-      dataView(memory0).setInt8(arg1 + 0, 1, true);
-      var variant4 = e;
-      switch (variant4.tag) {
-        case 'last-operation-failed': {
-          const e = variant4.val;
-          dataView(memory0).setInt8(arg1 + 8, 0, true);
-          if (!(e instanceof Error$1)) {
-            throw new TypeError('Resource error: Not a valid "Error" resource.');
-          }
-          var handle3 = e[symbolRscHandle];
-          if (!handle3) {
-            const rep = e[symbolRscRep] || ++captureCnt0;
-            captureTable0.set(rep, e);
-            handle3 = rscTableCreateOwn(handleTable0, rep);
-          }
-          dataView(memory0).setInt32(arg1 + 12, handle3, true);
-          break;
+    curResourceBorrows.push(rsc0);
+    _debugLog('[iface="wasi:filesystem/types@0.2.6", 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.6", function="[method]descriptor.stat"] [Instruction::CallInterface] (sync, @ post-call)');
+    for (const rsc of curResourceBorrows) {
+      rsc[symbolRscHandle] = undefined;
+    }
+    curResourceBorrows = [];
+    endCurrentTask(0);
+    var variant12 = ret;
+    switch (variant12.tag) {
+      case 'ok': {
+        const e = variant12.val;
+        dataView(memory0).setInt8(arg1 + 0, 0, true);
+        var {type: v3_0, linkCount: v3_1, size: v3_2, dataAccessTimestamp: v3_3, dataModificationTimestamp: v3_4, statusChangeTimestamp: v3_5 } = e;
+        var val4 = v3_0;
+        let enum4;
+        switch (val4) {
+          case 'unknown': {
+            enum4 = 0;
+            break;
+          }
+          case 'block-device': {
+            enum4 = 1;
+            break;
+          }
+          case 'character-device': {
+            enum4 = 2;
+            break;
+          }
+          case 'directory': {
+            enum4 = 3;
+            break;
+          }
+          case 'fifo': {
+            enum4 = 4;
+            break;
+          }
+          case 'symbolic-link': {
+            enum4 = 5;
+            break;
+          }
+          case 'regular-file': {
+            enum4 = 6;
+            break;
+          }
+          case 'socket': {
+            enum4 = 7;
+            break;
+          }
+          default: {
+            if ((v3_0) instanceof Error) {
+              console.error(v3_0);
+            }
+            
+            throw new TypeError(`"${val4}" is not one of the cases of descriptor-type`);
+          }
         }
-        case 'closed': {
-          dataView(memory0).setInt8(arg1 + 8, 1, true);
-          break;
+        dataView(memory0).setInt8(arg1 + 8, enum4, true);
+        dataView(memory0).setBigInt64(arg1 + 16, toUint64(v3_1), true);
+        dataView(memory0).setBigInt64(arg1 + 24, toUint64(v3_2), true);
+        var variant6 = v3_3;
+        if (variant6 === null || variant6=== undefined) {
+          dataView(memory0).setInt8(arg1 + 32, 0, true);
+        } else {
+          const e = variant6;
+          dataView(memory0).setInt8(arg1 + 32, 1, true);
+          var {seconds: v5_0, nanoseconds: v5_1 } = e;
+          dataView(memory0).setBigInt64(arg1 + 40, toUint64(v5_0), true);
+          dataView(memory0).setInt32(arg1 + 48, toUint32(v5_1), true);
+        }
+        var variant8 = v3_4;
+        if (variant8 === null || variant8=== undefined) {
+          dataView(memory0).setInt8(arg1 + 56, 0, true);
+        } else {
+          const e = variant8;
+          dataView(memory0).setInt8(arg1 + 56, 1, true);
+          var {seconds: v7_0, nanoseconds: v7_1 } = e;
+          dataView(memory0).setBigInt64(arg1 + 64, toUint64(v7_0), true);
+          dataView(memory0).setInt32(arg1 + 72, toUint32(v7_1), true);
+        }
+        var variant10 = v3_5;
+        if (variant10 === null || variant10=== undefined) {
+          dataView(memory0).setInt8(arg1 + 80, 0, true);
+        } else {
+          const e = variant10;
+          dataView(memory0).setInt8(arg1 + 80, 1, true);
+          var {seconds: v9_0, nanoseconds: v9_1 } = e;
+          dataView(memory0).setBigInt64(arg1 + 88, toUint64(v9_0), true);
+          dataView(memory0).setInt32(arg1 + 96, toUint32(v9_1), true);
         }
-        default: {
-          throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant4.tag)}\` (received \`${variant4}\`) specified for \`StreamError\``);
+        break;
+      }
+      case 'err': {
+        const e = variant12.val;
+        dataView(memory0).setInt8(arg1 + 0, 1, true);
+        var val11 = e;
+        let enum11;
+        switch (val11) {
+          case 'access': {
+            enum11 = 0;
+            break;
+          }
+          case 'would-block': {
+            enum11 = 1;
+            break;
+          }
+          case 'already': {
+            enum11 = 2;
+            break;
+          }
+          case 'bad-descriptor': {
+            enum11 = 3;
+            break;
+          }
+          case 'busy': {
+            enum11 = 4;
+            break;
+          }
+          case 'deadlock': {
+            enum11 = 5;
+            break;
+          }
+          case 'quota': {
+            enum11 = 6;
+            break;
+          }
+          case 'exist': {
+            enum11 = 7;
+            break;
+          }
+          case 'file-too-large': {
+            enum11 = 8;
+            break;
+          }
+          case 'illegal-byte-sequence': {
+            enum11 = 9;
+            break;
+          }
+          case 'in-progress': {
+            enum11 = 10;
+            break;
+          }
+          case 'interrupted': {
+            enum11 = 11;
+            break;
+          }
+          case 'invalid': {
+            enum11 = 12;
+            break;
+          }
+          case 'io': {
+            enum11 = 13;
+            break;
+          }
+          case 'is-directory': {
+            enum11 = 14;
+            break;
+          }
+          case 'loop': {
+            enum11 = 15;
+            break;
+          }
+          case 'too-many-links': {
+            enum11 = 16;
+            break;
+          }
+          case 'message-size': {
+            enum11 = 17;
+            break;
+          }
+          case 'name-too-long': {
+            enum11 = 18;
+            break;
+          }
+          case 'no-device': {
+            enum11 = 19;
+            break;
+          }
+          case 'no-entry': {
+            enum11 = 20;
+            break;
+          }
+          case 'no-lock': {
+            enum11 = 21;
+            break;
+          }
+          case 'insufficient-memory': {
+            enum11 = 22;
+            break;
+          }
+          case 'insufficient-space': {
+            enum11 = 23;
+            break;
+          }
+          case 'not-directory': {
+            enum11 = 24;
+            break;
+          }
+          case 'not-empty': {
+            enum11 = 25;
+            break;
+          }
+          case 'not-recoverable': {
+            enum11 = 26;
+            break;
+          }
+          case 'unsupported': {
+            enum11 = 27;
+            break;
+          }
+          case 'no-tty': {
+            enum11 = 28;
+            break;
+          }
+          case 'no-such-device': {
+            enum11 = 29;
+            break;
+          }
+          case 'overflow': {
+            enum11 = 30;
+            break;
+          }
+          case 'not-permitted': {
+            enum11 = 31;
+            break;
+          }
+          case 'pipe': {
+            enum11 = 32;
+            break;
+          }
+          case 'read-only': {
+            enum11 = 33;
+            break;
+          }
+          case 'invalid-seek': {
+            enum11 = 34;
+            break;
+          }
+          case 'text-file-busy': {
+            enum11 = 35;
+            break;
+          }
+          case 'cross-device': {
+            enum11 = 36;
+            break;
+          }
+          default: {
+            if ((e) instanceof Error) {
+              console.error(e);
+            }
+            
+            throw new TypeError(`"${val11}" is not one of the cases of error-code`);
+          }
         }
+        dataView(memory0).setInt8(arg1 + 8, enum11, true);
+        break;
+      }
+      default: {
+        throw new TypeError('invalid variant specified for result');
       }
-      break;
-    }
-    default: {
-      throw new TypeError('invalid variant specified for result');
     }
+    _debugLog('[iface="wasi:filesystem/types@0.2.6", function="[method]descriptor.stat"][Instruction::Return]', {
+      funcName: '[method]descriptor.stat',
+      paramCount: 0,
+      async: false,
+      postReturn: false
+    });
   }
-  _debugLog('[iface="wasi:io/streams@0.2.6", function="[method]output-stream.check-write"][Instruction::Return]', {
-    funcName: '[method]output-stream.check-write',
-    paramCount: 0,
-    async: false,
-    postReturn: false
-  });
-}
-
-
-function trampoline19(arg0, arg1, arg2, arg3) {
-  var handle1 = arg0;
-  var rep2 = handleTable1[(handle1 << 1) + 1] & ~T_FLAG;
-  var rsc0 = captureTable1.get(rep2);
-  if (!rsc0) {
-    rsc0 = Object.create(OutputStream.prototype);
-    Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
-    Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
-  }
-  curResourceBorrows.push(rsc0);
-  var ptr3 = arg1;
-  var len3 = arg2;
-  var result3 = new Uint8Array(memory0.buffer.slice(ptr3, ptr3 + len3 * 1));
-  _debugLog('[iface="wasi:io/streams@0.2.6", 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.6", function="[method]output-stream.write"] [Instruction::CallInterface] (sync, @ post-call)');
-  for (const rsc of curResourceBorrows) {
-    rsc[symbolRscHandle] = undefined;
-  }
-  curResourceBorrows = [];
-  endCurrentTask(0);
-  var variant6 = ret;
-  switch (variant6.tag) {
-    case 'ok': {
-      const e = variant6.val;
-      dataView(memory0).setInt8(arg3 + 0, 0, true);
-      break;
-    }
-    case 'err': {
-      const e = variant6.val;
-      dataView(memory0).setInt8(arg3 + 0, 1, true);
-      var variant5 = e;
-      switch (variant5.tag) {
-        case 'last-operation-failed': {
-          const e = variant5.val;
-          dataView(memory0).setInt8(arg3 + 4, 0, true);
-          if (!(e instanceof Error$1)) {
-            throw new TypeError('Resource error: Not a valid "Error" resource.');
-          }
-          var handle4 = e[symbolRscHandle];
-          if (!handle4) {
-            const rep = e[symbolRscRep] || ++captureCnt0;
-            captureTable0.set(rep, e);
-            handle4 = rscTableCreateOwn(handleTable0, rep);
-          }
-          dataView(memory0).setInt32(arg3 + 8, handle4, true);
-          break;
-        }
-        case 'closed': {
-          dataView(memory0).setInt8(arg3 + 4, 1, true);
-          break;
-        }
-        default: {
-          throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant5.tag)}\` (received \`${variant5}\`) specified for \`StreamError\``);
+  
+  
+  function trampoline18(arg0, arg1) {
+    var handle1 = arg0;
+    var rep2 = handleTable1[(handle1 << 1) + 1] & ~T_FLAG;
+    var rsc0 = captureTable1.get(rep2);
+    if (!rsc0) {
+      rsc0 = Object.create(OutputStream.prototype);
+      Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
+      Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
+    }
+    curResourceBorrows.push(rsc0);
+    _debugLog('[iface="wasi:io/streams@0.2.6", 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.6", function="[method]output-stream.check-write"] [Instruction::CallInterface] (sync, @ post-call)');
+    for (const rsc of curResourceBorrows) {
+      rsc[symbolRscHandle] = undefined;
+    }
+    curResourceBorrows = [];
+    endCurrentTask(0);
+    var variant5 = ret;
+    switch (variant5.tag) {
+      case 'ok': {
+        const e = variant5.val;
+        dataView(memory0).setInt8(arg1 + 0, 0, true);
+        dataView(memory0).setBigInt64(arg1 + 8, toUint64(e), true);
+        break;
+      }
+      case 'err': {
+        const e = variant5.val;
+        dataView(memory0).setInt8(arg1 + 0, 1, true);
+        var variant4 = e;
+        switch (variant4.tag) {
+          case 'last-operation-failed': {
+            const e = variant4.val;
+            dataView(memory0).setInt8(arg1 + 8, 0, true);
+            if (!(e instanceof Error$1)) {
+              throw new TypeError('Resource error: Not a valid "Error" resource.');
+            }
+            var handle3 = e[symbolRscHandle];
+            if (!handle3) {
+              const rep = e[symbolRscRep] || ++captureCnt0;
+              captureTable0.set(rep, e);
+              handle3 = rscTableCreateOwn(handleTable0, rep);
+            }
+            dataView(memory0).setInt32(arg1 + 12, handle3, true);
+            break;
+          }
+          case 'closed': {
+            dataView(memory0).setInt8(arg1 + 8, 1, true);
+            break;
+          }
+          default: {
+            throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant4.tag)}\` (received \`${variant4}\`) specified for \`StreamError\``);
+          }
         }
+        break;
+      }
+      default: {
+        throw new TypeError('invalid variant specified for result');
       }
-      break;
-    }
-    default: {
-      throw new TypeError('invalid variant specified for result');
     }
+    _debugLog('[iface="wasi:io/streams@0.2.6", function="[method]output-stream.check-write"][Instruction::Return]', {
+      funcName: '[method]output-stream.check-write',
+      paramCount: 0,
+      async: false,
+      postReturn: false
+    });
   }
-  _debugLog('[iface="wasi:io/streams@0.2.6", function="[method]output-stream.write"][Instruction::Return]', {
-    funcName: '[method]output-stream.write',
-    paramCount: 0,
-    async: false,
-    postReturn: false
-  });
-}
-
-
-function trampoline20(arg0, arg1) {
-  var handle1 = arg0;
-  var rep2 = handleTable1[(handle1 << 1) + 1] & ~T_FLAG;
-  var rsc0 = captureTable1.get(rep2);
-  if (!rsc0) {
-    rsc0 = Object.create(OutputStream.prototype);
-    Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
-    Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
-  }
-  curResourceBorrows.push(rsc0);
-  _debugLog('[iface="wasi:io/streams@0.2.6", 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.6", function="[method]output-stream.blocking-flush"] [Instruction::CallInterface] (sync, @ post-call)');
-  for (const rsc of curResourceBorrows) {
-    rsc[symbolRscHandle] = undefined;
-  }
-  curResourceBorrows = [];
-  endCurrentTask(0);
-  var variant5 = ret;
-  switch (variant5.tag) {
-    case 'ok': {
-      const e = variant5.val;
-      dataView(memory0).setInt8(arg1 + 0, 0, true);
-      break;
+  
+  
+  function trampoline19(arg0, arg1, arg2, arg3) {
+    var handle1 = arg0;
+    var rep2 = handleTable1[(handle1 << 1) + 1] & ~T_FLAG;
+    var rsc0 = captureTable1.get(rep2);
+    if (!rsc0) {
+      rsc0 = Object.create(OutputStream.prototype);
+      Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
+      Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
     }
-    case 'err': {
-      const e = variant5.val;
-      dataView(memory0).setInt8(arg1 + 0, 1, true);
-      var variant4 = e;
-      switch (variant4.tag) {
-        case 'last-operation-failed': {
-          const e = variant4.val;
-          dataView(memory0).setInt8(arg1 + 4, 0, true);
-          if (!(e instanceof Error$1)) {
-            throw new TypeError('Resource error: Not a valid "Error" resource.');
-          }
-          var handle3 = e[symbolRscHandle];
-          if (!handle3) {
-            const rep = e[symbolRscRep] || ++captureCnt0;
-            captureTable0.set(rep, e);
-            handle3 = rscTableCreateOwn(handleTable0, rep);
-          }
-          dataView(memory0).setInt32(arg1 + 8, handle3, true);
-          break;
-        }
-        case 'closed': {
-          dataView(memory0).setInt8(arg1 + 4, 1, true);
-          break;
-        }
-        default: {
-          throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant4.tag)}\` (received \`${variant4}\`) specified for \`StreamError\``);
+    curResourceBorrows.push(rsc0);
+    var ptr3 = arg1;
+    var len3 = arg2;
+    var result3 = new Uint8Array(memory0.buffer.slice(ptr3, ptr3 + len3 * 1));
+    _debugLog('[iface="wasi:io/streams@0.2.6", 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.6", function="[method]output-stream.write"] [Instruction::CallInterface] (sync, @ post-call)');
+    for (const rsc of curResourceBorrows) {
+      rsc[symbolRscHandle] = undefined;
+    }
+    curResourceBorrows = [];
+    endCurrentTask(0);
+    var variant6 = ret;
+    switch (variant6.tag) {
+      case 'ok': {
+        const e = variant6.val;
+        dataView(memory0).setInt8(arg3 + 0, 0, true);
+        break;
+      }
+      case 'err': {
+        const e = variant6.val;
+        dataView(memory0).setInt8(arg3 + 0, 1, true);
+        var variant5 = e;
+        switch (variant5.tag) {
+          case 'last-operation-failed': {
+            const e = variant5.val;
+            dataView(memory0).setInt8(arg3 + 4, 0, true);
+            if (!(e instanceof Error$1)) {
+              throw new TypeError('Resource error: Not a valid "Error" resource.');
+            }
+            var handle4 = e[symbolRscHandle];
+            if (!handle4) {
+              const rep = e[symbolRscRep] || ++captureCnt0;
+              captureTable0.set(rep, e);
+              handle4 = rscTableCreateOwn(handleTable0, rep);
+            }
+            dataView(memory0).setInt32(arg3 + 8, handle4, true);
+            break;
+          }
+          case 'closed': {
+            dataView(memory0).setInt8(arg3 + 4, 1, true);
+            break;
+          }
+          default: {
+            throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant5.tag)}\` (received \`${variant5}\`) specified for \`StreamError\``);
+          }
         }
+        break;
+      }
+      default: {
+        throw new TypeError('invalid variant specified for result');
       }
-      break;
-    }
-    default: {
-      throw new TypeError('invalid variant specified for result');
     }
+    _debugLog('[iface="wasi:io/streams@0.2.6", function="[method]output-stream.write"][Instruction::Return]', {
+      funcName: '[method]output-stream.write',
+      paramCount: 0,
+      async: false,
+      postReturn: false
+    });
   }
-  _debugLog('[iface="wasi:io/streams@0.2.6", function="[method]output-stream.blocking-flush"][Instruction::Return]', {
-    funcName: '[method]output-stream.blocking-flush',
-    paramCount: 0,
-    async: false,
-    postReturn: false
-  });
-}
-
-
-function trampoline21(arg0) {
-  _debugLog('[iface="wasi:filesystem/preopens@0.2.6", 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.6", function="get-directories"] [Instruction::CallInterface] (sync, @ post-call)');
-  endCurrentTask(0);
-  var vec3 = ret;
-  var len3 = vec3.length;
-  var result3 = realloc1(0, 0, 4, len3 * 12);
-  for (let i = 0; i < vec3.length; i++) {
-    const e = vec3[i];
-    const base = result3 + i * 12;var [tuple0_0, tuple0_1] = e;
-    if (!(tuple0_0 instanceof Descriptor)) {
-      throw new TypeError('Resource error: Not a valid "Descriptor" resource.');
-    }
-    var handle1 = tuple0_0[symbolRscHandle];
-    if (!handle1) {
-      const rep = tuple0_0[symbolRscRep] || ++captureCnt4;
-      captureTable4.set(rep, tuple0_0);
-      handle1 = rscTableCreateOwn(handleTable4, rep);
-    }
-    dataView(memory0).setInt32(base + 0, handle1, true);
-    var ptr2 = utf8Encode(tuple0_1, realloc1, memory0);
-    var len2 = utf8EncodedLen;
-    dataView(memory0).setUint32(base + 8, len2, true);
-    dataView(memory0).setUint32(base + 4, ptr2, true);
-  }
-  dataView(memory0).setUint32(arg0 + 4, len3, true);
-  dataView(memory0).setUint32(arg0 + 0, result3, true);
-  _debugLog('[iface="wasi:filesystem/preopens@0.2.6", function="get-directories"][Instruction::Return]', {
-    funcName: 'get-directories',
-    paramCount: 0,
-    async: false,
-    postReturn: false
-  });
-}
-
-let exports3;
-let postReturn0;
-function trampoline0(handle) {
-  const handleEntry = rscTableRemove(handleTable0, handle);
-  if (handleEntry.own) {
-    
-    const rsc = captureTable0.get(handleEntry.rep);
-    if (rsc) {
-      if (rsc[symbolDispose]) rsc[symbolDispose]();
-      captureTable0.delete(handleEntry.rep);
-    } else if (Error$1[symbolCabiDispose]) {
-      Error$1[symbolCabiDispose](handleEntry.rep);
+  
+  
+  function trampoline20(arg0, arg1) {
+    var handle1 = arg0;
+    var rep2 = handleTable1[(handle1 << 1) + 1] & ~T_FLAG;
+    var rsc0 = captureTable1.get(rep2);
+    if (!rsc0) {
+      rsc0 = Object.create(OutputStream.prototype);
+      Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
+      Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
     }
-  }
-}
-function trampoline1(handle) {
-  const handleEntry = rscTableRemove(handleTable1, handle);
-  if (handleEntry.own) {
-    
-    const rsc = captureTable1.get(handleEntry.rep);
-    if (rsc) {
-      if (rsc[symbolDispose]) rsc[symbolDispose]();
-      captureTable1.delete(handleEntry.rep);
-    } else if (OutputStream[symbolCabiDispose]) {
-      OutputStream[symbolCabiDispose](handleEntry.rep);
+    curResourceBorrows.push(rsc0);
+    _debugLog('[iface="wasi:io/streams@0.2.6", 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.6", function="[method]output-stream.blocking-flush"] [Instruction::CallInterface] (sync, @ post-call)');
+    for (const rsc of curResourceBorrows) {
+      rsc[symbolRscHandle] = undefined;
+    }
+    curResourceBorrows = [];
+    endCurrentTask(0);
+    var variant5 = ret;
+    switch (variant5.tag) {
+      case 'ok': {
+        const e = variant5.val;
+        dataView(memory0).setInt8(arg1 + 0, 0, true);
+        break;
+      }
+      case 'err': {
+        const e = variant5.val;
+        dataView(memory0).setInt8(arg1 + 0, 1, true);
+        var variant4 = e;
+        switch (variant4.tag) {
+          case 'last-operation-failed': {
+            const e = variant4.val;
+            dataView(memory0).setInt8(arg1 + 4, 0, true);
+            if (!(e instanceof Error$1)) {
+              throw new TypeError('Resource error: Not a valid "Error" resource.');
+            }
+            var handle3 = e[symbolRscHandle];
+            if (!handle3) {
+              const rep = e[symbolRscRep] || ++captureCnt0;
+              captureTable0.set(rep, e);
+              handle3 = rscTableCreateOwn(handleTable0, rep);
+            }
+            dataView(memory0).setInt32(arg1 + 8, handle3, true);
+            break;
+          }
+          case 'closed': {
+            dataView(memory0).setInt8(arg1 + 4, 1, true);
+            break;
+          }
+          default: {
+            throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant4.tag)}\` (received \`${variant4}\`) specified for \`StreamError\``);
+          }
+        }
+        break;
+      }
+      default: {
+        throw new TypeError('invalid variant specified for result');
+      }
     }
+    _debugLog('[iface="wasi:io/streams@0.2.6", function="[method]output-stream.blocking-flush"][Instruction::Return]', {
+      funcName: '[method]output-stream.blocking-flush',
+      paramCount: 0,
+      async: false,
+      postReturn: false
+    });
   }
-}
-const handleTable3 = [T_FLAG, 0];
-const captureTable3= new Map();
-let captureCnt3 = 0;
-handleTables[3] = handleTable3;
-function trampoline3(handle) {
-  const handleEntry = rscTableRemove(handleTable3, handle);
-  if (handleEntry.own) {
-    throw new TypeError('unreachable trampoline for resource [ResourceIndex(3)]')
+  
+  
+  function trampoline21(arg0) {
+    _debugLog('[iface="wasi:filesystem/preopens@0.2.6", 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.6", function="get-directories"] [Instruction::CallInterface] (sync, @ post-call)');
+    endCurrentTask(0);
+    var vec3 = ret;
+    var len3 = vec3.length;
+    var result3 = realloc1(0, 0, 4, len3 * 12);
+    for (let i = 0; i < vec3.length; i++) {
+      const e = vec3[i];
+      const base = result3 + i * 12;var [tuple0_0, tuple0_1] = e;
+      if (!(tuple0_0 instanceof Descriptor)) {
+        throw new TypeError('Resource error: Not a valid "Descriptor" resource.');
+      }
+      var handle1 = tuple0_0[symbolRscHandle];
+      if (!handle1) {
+        const rep = tuple0_0[symbolRscRep] || ++captureCnt4;
+        captureTable4.set(rep, tuple0_0);
+        handle1 = rscTableCreateOwn(handleTable4, rep);
+      }
+      dataView(memory0).setInt32(base + 0, handle1, true);
+      var ptr2 = utf8Encode(tuple0_1, realloc1, memory0);
+      var len2 = utf8EncodedLen;
+      dataView(memory0).setUint32(base + 8, len2, true);
+      dataView(memory0).setUint32(base + 4, ptr2, true);
+    }
+    dataView(memory0).setUint32(arg0 + 4, len3, true);
+    dataView(memory0).setUint32(arg0 + 0, result3, true);
+    _debugLog('[iface="wasi:filesystem/preopens@0.2.6", function="get-directories"][Instruction::Return]', {
+      funcName: 'get-directories',
+      paramCount: 0,
+      async: false,
+      postReturn: false
+    });
   }
-}
-function trampoline4(handle) {
-  const handleEntry = rscTableRemove(handleTable4, handle);
-  if (handleEntry.own) {
-    
-    const rsc = captureTable4.get(handleEntry.rep);
-    if (rsc) {
-      if (rsc[symbolDispose]) rsc[symbolDispose]();
-      captureTable4.delete(handleEntry.rep);
-    } else if (Descriptor[symbolCabiDispose]) {
-      Descriptor[symbolCabiDispose](handleEntry.rep);
+  
+  let exports3;
+  let postReturn0;
+  function trampoline0(handle) {
+    const handleEntry = rscTableRemove(handleTable0, handle);
+    if (handleEntry.own) {
+      
+      const rsc = captureTable0.get(handleEntry.rep);
+      if (rsc) {
+        if (rsc[symbolDispose]) rsc[symbolDispose]();
+        captureTable0.delete(handleEntry.rep);
+      } else if (Error$1[symbolCabiDispose]) {
+        Error$1[symbolCabiDispose](handleEntry.rep);
+      }
     }
   }
-}
-function trampoline5(handle) {
-  const handleEntry = rscTableRemove(handleTable2, handle);
-  if (handleEntry.own) {
-    
-    const rsc = captureTable2.get(handleEntry.rep);
-    if (rsc) {
-      if (rsc[symbolDispose]) rsc[symbolDispose]();
-      captureTable2.delete(handleEntry.rep);
-    } else if (InputStream[symbolCabiDispose]) {
-      InputStream[symbolCabiDispose](handleEntry.rep);
+  function trampoline1(handle) {
+    const handleEntry = rscTableRemove(handleTable1, handle);
+    if (handleEntry.own) {
+      
+      const rsc = captureTable1.get(handleEntry.rep);
+      if (rsc) {
+        if (rsc[symbolDispose]) rsc[symbolDispose]();
+        captureTable1.delete(handleEntry.rep);
+      } else if (OutputStream[symbolCabiDispose]) {
+        OutputStream[symbolCabiDispose](handleEntry.rep);
+      }
     }
   }
-}
-let syntaxHighlighter001RenderHighlighted;
-
-function renderHighlighted(arg0, arg1, arg2, arg3) {
-  var ptr0 = utf8Encode(arg0, realloc0, memory0);
-  var len0 = utf8EncodedLen;
-  var ptr1 = utf8Encode(arg1, realloc0, memory0);
-  var len1 = utf8EncodedLen;
-  var ptr2 = utf8Encode(arg2, realloc0, memory0);
-  var len2 = utf8EncodedLen;
-  var ptr3 = utf8Encode(arg3, realloc0, memory0);
-  var len3 = utf8EncodedLen;
-  _debugLog('[iface="docs:giallo-js/syntax-highlighter@0.0.1", function="render-highlighted"][Instruction::CallWasm] enter', {
-    funcName: 'render-highlighted',
-    paramCount: 8,
-    async: false,
-    postReturn: true,
-  });
-  const _wasm_call_currentTaskID = startCurrentTask(0, false, 'syntaxHighlighter001RenderHighlighted');
-  const ret = syntaxHighlighter001RenderHighlighted(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
-  endCurrentTask(0);
-  let variant6;
-  switch (dataView(memory0).getUint8(ret + 0, true)) {
-    case 0: {
-      var ptr4 = dataView(memory0).getUint32(ret + 4, true);
-      var len4 = dataView(memory0).getUint32(ret + 8, true);
-      var result4 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr4, len4));
-      variant6= {
-        tag: 'ok',
-        val: result4
-      };
-      break;
-    }
-    case 1: {
-      var ptr5 = dataView(memory0).getUint32(ret + 4, true);
-      var len5 = dataView(memory0).getUint32(ret + 8, true);
-      var result5 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr5, len5));
-      variant6= {
-        tag: 'err',
-        val: result5
-      };
-      break;
-    }
-    default: {
-      throw new TypeError('invalid variant discriminant for expected');
+  const handleTable3 = [T_FLAG, 0];
+  const captureTable3= new Map();
+  let captureCnt3 = 0;
+  handleTables[3] = handleTable3;
+  function trampoline3(handle) {
+    const handleEntry = rscTableRemove(handleTable3, handle);
+    if (handleEntry.own) {
+      throw new TypeError('unreachable trampoline for resource [ResourceIndex(3)]')
     }
   }
-  _debugLog('[iface="docs:giallo-js/syntax-highlighter@0.0.1", function="render-highlighted"][Instruction::Return]', {
-    funcName: 'render-highlighted',
-    paramCount: 1,
-    async: false,
-    postReturn: true
-  });
-  const retCopy = variant6;
-  
-  let cstate = getOrCreateAsyncState(0);
-  cstate.mayLeave = false;
-  postReturn0(ret);
-  cstate.mayLeave = true;
-  
-  
-  
-  if (typeof retCopy === 'object' && retCopy.tag === 'err') {
-    throw new ComponentError(retCopy.val);
+  function trampoline4(handle) {
+    const handleEntry = rscTableRemove(handleTable4, handle);
+    if (handleEntry.own) {
+      
+      const rsc = captureTable4.get(handleEntry.rep);
+      if (rsc) {
+        if (rsc[symbolDispose]) rsc[symbolDispose]();
+        captureTable4.delete(handleEntry.rep);
+      } else if (Descriptor[symbolCabiDispose]) {
+        Descriptor[symbolCabiDispose](handleEntry.rep);
+      }
+    }
   }
-  return retCopy.val;
-  
-}
-
-const $init = (() => {
-  let gen = (function* _initGenerator () {
-    const module0 = fetchCompile(new URL('./giallo_js.core.wasm', import.meta.url));
-    const module1 = fetchCompile(new URL('./giallo_js.core2.wasm', import.meta.url));
-    const module2 = base64Compile('AGFzbQEAAAABPQpgAn9/AGAEf39/fwBgAX8AYAJ/fwF/YAF/AX9gA39/fwF/YAR/fn9/AX9gBH9/f38Bf2ABfwBgA39+fwADFxYAAQIDAwQDBQYHCAIACQAAAAABAAECBAUBcAEWFgdwFwEwAAABMQABATIAAgEzAAMBNAAEATUABQE2AAYBNwAHATgACAE5AAkCMTAACgIxMQALAjEyAAwCMTMADQIxNAAOAjE1AA8CMTYAEAIxNwARAjE4ABICMTkAEwIyMAAUAjIxABUIJGltcG9ydHMBAAqXAhYLACAAIAFBABEAAAsPACAAIAEgAiADQQERAQALCQAgAEECEQIACwsAIAAgAUEDEQMACwsAIAAgAUEEEQMACwkAIABBBREEAAsLACAAIAFBBhEDAAsNACAAIAEgAkEHEQUACw8AIAAgASACIANBCBEGAAsPACAAIAEgAiADQQkRBwALCQAgAEEKEQgACwkAIABBCxECAAsLACAAIAFBDBEAAAsNACAAIAEgAkENEQkACwsAIAAgAUEOEQAACwsAIAAgAUEPEQAACwsAIAAgAUEQEQAACwsAIAAgAUEREQAACw8AIAAgASACIANBEhEBAAsLACAAIAFBExEAAAsPACAAIAEgAiADQRQRAQALCQAgAEEVEQIACwAvCXByb2R1Y2VycwEMcHJvY2Vzc2VkLWJ5AQ13aXQtY29tcG9uZW50BzAuMjQxLjI');
-    const module3 = base64Compile('AGFzbQEAAAABPQpgAn9/AGAEf39/fwBgAX8AYAJ/fwF/YAF/AX9gA39/fwF/YAR/fn9/AX9gBH9/f38Bf2ABfwBgA39+fwACigEXAAEwAAAAATEAAQABMgACAAEzAAMAATQAAwABNQAEAAE2AAMAATcABQABOAAGAAE5AAcAAjEwAAgAAjExAAIAAjEyAAAAAjEzAAkAAjE0AAAAAjE1AAAAAjE2AAAAAjE3AAAAAjE4AAEAAjE5AAAAAjIwAAEAAjIxAAIACCRpbXBvcnRzAXABFhYJHAEAQQALFgABAgMEBQYHCAkKCwwNDg8QERITFBUALwlwcm9kdWNlcnMBDHByb2Nlc3NlZC1ieQENd2l0LWNvbXBvbmVudAcwLjI0MS4y');
-    ({ exports: exports0 } = yield instantiateCore(yield module2));
-    ({ exports: exports1 } = yield instantiateCore(yield module0, {
-      'wasi:cli/stderr@0.2.4': {
-        'get-stderr': trampoline2,
-      },
-      'wasi:io/error@0.2.4': {
-        '[method]error.to-debug-string': exports0['0'],
-        '[resource-drop]error': trampoline0,
-      },
-      'wasi:io/streams@0.2.4': {
-        '[method]output-stream.blocking-write-and-flush': exports0['1'],
-        '[resource-drop]output-stream': trampoline1,
-      },
-      'wasi:random/insecure-seed@0.2.4': {
-        'insecure-seed': exports0['2'],
-      },
-      wasi_snapshot_preview1: {
-        environ_get: exports0['3'],
-        environ_sizes_get: exports0['4'],
-        fd_close: exports0['5'],
-        fd_prestat_dir_name: exports0['7'],
-        fd_prestat_get: exports0['6'],
-        fd_seek: exports0['8'],
-        fd_write: exports0['9'],
-        proc_exit: exports0['10'],
-      },
-    }));
-    ({ exports: exports2 } = yield instantiateCore(yield module1, {
-      __main_module__: {
-        cabi_realloc: exports1.cabi_realloc,
-      },
-      env: {
-        memory: exports1.memory,
-      },
-      'wasi:cli/environment@0.2.6': {
-        'get-environment': exports0['11'],
-      },
-      'wasi:cli/exit@0.2.6': {
-        exit: trampoline8,
-      },
-      'wasi:cli/stderr@0.2.6': {
-        'get-stderr': trampoline2,
-      },
-      'wasi:cli/stdin@0.2.6': {
-        'get-stdin': trampoline6,
-      },
-      'wasi:cli/stdout@0.2.6': {
-        'get-stdout': trampoline7,
-      },
-      'wasi:filesystem/preopens@0.2.6': {
-        'get-directories': exports0['21'],
-      },
-      'wasi:filesystem/types@0.2.6': {
-        '[method]descriptor.append-via-stream': exports0['14'],
-        '[method]descriptor.get-type': exports0['15'],
-        '[method]descriptor.stat': exports0['16'],
-        '[method]descriptor.write-via-stream': exports0['13'],
-        '[resource-drop]descriptor': trampoline4,
-        '[resource-drop]directory-entry-stream': trampoline3,
-        'filesystem-error-code': exports0['12'],
-      },
-      'wasi:io/error@0.2.6': {
-        '[resource-drop]error': trampoline0,
-      },
-      'wasi:io/streams@0.2.6': {
-        '[method]output-stream.blocking-flush': exports0['19'],
-        '[method]output-stream.blocking-write-and-flush': exports0['20'],
-        '[method]output-stream.check-write': exports0['17'],
-        '[method]output-stream.write': exports0['18'],
-        '[resource-drop]input-stream': trampoline5,
-        '[resource-drop]output-stream': trampoline1,
-      },
-    }));
-    memory0 = exports1.memory;
-    realloc0 = exports1.cabi_realloc;
-    realloc1 = exports2.cabi_import_realloc;
-    ({ exports: exports3 } = yield instantiateCore(yield module3, {
-      '': {
-        $imports: exports0.$imports,
-        '0': trampoline9,
-        '1': trampoline10,
-        '10': exports2.proc_exit,
-        '11': trampoline12,
-        '12': trampoline13,
-        '13': trampoline14,
-        '14': trampoline15,
-        '15': trampoline16,
-        '16': trampoline17,
-        '17': trampoline18,
-        '18': trampoline19,
-        '19': trampoline20,
-        '2': trampoline11,
-        '20': trampoline10,
-        '21': trampoline21,
-        '3': exports2.environ_get,
-        '4': exports2.environ_sizes_get,
-        '5': exports2.fd_close,
-        '6': exports2.fd_prestat_get,
-        '7': exports2.fd_prestat_dir_name,
-        '8': exports2.fd_seek,
-        '9': exports2.fd_write,
-      },
-    }));
-    postReturn0 = exports1['cabi_post_docs:giallo-js/syntax-highlighter@0.0.1#render-highlighted'];
-    syntaxHighlighter001RenderHighlighted = exports1['docs:giallo-js/syntax-highlighter@0.0.1#render-highlighted'];
-  })();
-  let promise, resolve, reject;
-  function runNext (value) {
-    try {
-      let done;
-      do {
-        ({ value, done } = gen.next(value));
-      } while (!(value instanceof Promise) && !done);
-      if (done) {
-        if (resolve) resolve(value);
-        else return value;
+  function trampoline5(handle) {
+    const handleEntry = rscTableRemove(handleTable2, handle);
+    if (handleEntry.own) {
+      
+      const rsc = captureTable2.get(handleEntry.rep);
+      if (rsc) {
+        if (rsc[symbolDispose]) rsc[symbolDispose]();
+        captureTable2.delete(handleEntry.rep);
+      } else if (InputStream[symbolCabiDispose]) {
+        InputStream[symbolCabiDispose](handleEntry.rep);
+      }
+    }
+  }
+  ({ exports: exports0 } = instantiateCore(module2));
+  ({ exports: exports1 } = instantiateCore(module0, {
+    'wasi:cli/stderr@0.2.4': {
+      'get-stderr': trampoline2,
+    },
+    'wasi:io/error@0.2.4': {
+      '[method]error.to-debug-string': exports0['0'],
+      '[resource-drop]error': trampoline0,
+    },
+    'wasi:io/streams@0.2.4': {
+      '[method]output-stream.blocking-write-and-flush': exports0['1'],
+      '[resource-drop]output-stream': trampoline1,
+    },
+    'wasi:random/insecure-seed@0.2.4': {
+      'insecure-seed': exports0['2'],
+    },
+    wasi_snapshot_preview1: {
+      environ_get: exports0['3'],
+      environ_sizes_get: exports0['4'],
+      fd_close: exports0['5'],
+      fd_prestat_dir_name: exports0['7'],
+      fd_prestat_get: exports0['6'],
+      fd_seek: exports0['8'],
+      fd_write: exports0['9'],
+      proc_exit: exports0['10'],
+    },
+  }));
+  ({ exports: exports2 } = instantiateCore(module1, {
+    __main_module__: {
+      cabi_realloc: exports1.cabi_realloc,
+    },
+    env: {
+      memory: exports1.memory,
+    },
+    'wasi:cli/environment@0.2.6': {
+      'get-environment': exports0['11'],
+    },
+    'wasi:cli/exit@0.2.6': {
+      exit: trampoline8,
+    },
+    'wasi:cli/stderr@0.2.6': {
+      'get-stderr': trampoline2,
+    },
+    'wasi:cli/stdin@0.2.6': {
+      'get-stdin': trampoline6,
+    },
+    'wasi:cli/stdout@0.2.6': {
+      'get-stdout': trampoline7,
+    },
+    'wasi:filesystem/preopens@0.2.6': {
+      'get-directories': exports0['21'],
+    },
+    'wasi:filesystem/types@0.2.6': {
+      '[method]descriptor.append-via-stream': exports0['14'],
+      '[method]descriptor.get-type': exports0['15'],
+      '[method]descriptor.stat': exports0['16'],
+      '[method]descriptor.write-via-stream': exports0['13'],
+      '[resource-drop]descriptor': trampoline4,
+      '[resource-drop]directory-entry-stream': trampoline3,
+      'filesystem-error-code': exports0['12'],
+    },
+    'wasi:io/error@0.2.6': {
+      '[resource-drop]error': trampoline0,
+    },
+    'wasi:io/streams@0.2.6': {
+      '[method]output-stream.blocking-flush': exports0['19'],
+      '[method]output-stream.blocking-write-and-flush': exports0['20'],
+      '[method]output-stream.check-write': exports0['17'],
+      '[method]output-stream.write': exports0['18'],
+      '[resource-drop]input-stream': trampoline5,
+      '[resource-drop]output-stream': trampoline1,
+    },
+  }));
+  memory0 = exports1.memory;
+  realloc0 = exports1.cabi_realloc;
+  realloc1 = exports2.cabi_import_realloc;
+  ({ exports: exports3 } = instantiateCore(module3, {
+    '': {
+      $imports: exports0.$imports,
+      '0': trampoline9,
+      '1': trampoline10,
+      '10': exports2.proc_exit,
+      '11': trampoline12,
+      '12': trampoline13,
+      '13': trampoline14,
+      '14': trampoline15,
+      '15': trampoline16,
+      '16': trampoline17,
+      '17': trampoline18,
+      '18': trampoline19,
+      '19': trampoline20,
+      '2': trampoline11,
+      '20': trampoline10,
+      '21': trampoline21,
+      '3': exports2.environ_get,
+      '4': exports2.environ_sizes_get,
+      '5': exports2.fd_close,
+      '6': exports2.fd_prestat_get,
+      '7': exports2.fd_prestat_dir_name,
+      '8': exports2.fd_seek,
+      '9': exports2.fd_write,
+    },
+  }));
+  postReturn0 = exports1['cabi_post_docs:giallo-js/syntax-highlighter@0.0.1#render-highlighted'];
+  let syntaxHighlighter001RenderHighlighted;
+  
+  function renderHighlighted(arg0, arg1, arg2, arg3) {
+    var ptr0 = utf8Encode(arg0, realloc0, memory0);
+    var len0 = utf8EncodedLen;
+    var ptr1 = utf8Encode(arg1, realloc0, memory0);
+    var len1 = utf8EncodedLen;
+    var ptr2 = utf8Encode(arg2, realloc0, memory0);
+    var len2 = utf8EncodedLen;
+    var ptr3 = utf8Encode(arg3, realloc0, memory0);
+    var len3 = utf8EncodedLen;
+    _debugLog('[iface="docs:giallo-js/syntax-highlighter@0.0.1", function="render-highlighted"][Instruction::CallWasm] enter', {
+      funcName: 'render-highlighted',
+      paramCount: 8,
+      async: false,
+      postReturn: true,
+    });
+    const _wasm_call_currentTaskID = startCurrentTask(0, false, 'syntaxHighlighter001RenderHighlighted');
+    const ret = syntaxHighlighter001RenderHighlighted(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+    endCurrentTask(0);
+    let variant6;
+    switch (dataView(memory0).getUint8(ret + 0, true)) {
+      case 0: {
+        var ptr4 = dataView(memory0).getUint32(ret + 4, true);
+        var len4 = dataView(memory0).getUint32(ret + 8, true);
+        var result4 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr4, len4));
+        variant6= {
+          tag: 'ok',
+          val: result4
+        };
+        break;
+      }
+      case 1: {
+        var ptr5 = dataView(memory0).getUint32(ret + 4, true);
+        var len5 = dataView(memory0).getUint32(ret + 8, true);
+        var result5 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr5, len5));
+        variant6= {
+          tag: 'err',
+          val: result5
+        };
+        break;
+      }
+      default: {
+        throw new TypeError('invalid variant discriminant for expected');
       }
-      if (!promise) promise = new Promise((_resolve, _reject) => (resolve = _resolve, reject = _reject));
-      value.then(runNext, reject);
     }
-    catch (e) {
-      if (reject) reject(e);
-      else throw e;
+    _debugLog('[iface="docs:giallo-js/syntax-highlighter@0.0.1", function="render-highlighted"][Instruction::Return]', {
+      funcName: 'render-highlighted',
+      paramCount: 1,
+      async: false,
+      postReturn: true
+    });
+    const retCopy = variant6;
+    
+    let cstate = getOrCreateAsyncState(0);
+    cstate.mayLeave = false;
+    postReturn0(ret);
+    cstate.mayLeave = true;
+    
+    
+    
+    if (typeof retCopy === 'object' && retCopy.tag === 'err') {
+      throw new ComponentError(retCopy.val);
     }
+    return retCopy.val;
+    
   }
-  const maybeSyncReturn = runNext(null);
-  return promise || maybeSyncReturn;
-})();
-
-await $init;
-const syntaxHighlighter001 = {
-  renderHighlighted: renderHighlighted,
+  syntaxHighlighter001RenderHighlighted = exports1['docs:giallo-js/syntax-highlighter@0.0.1#render-highlighted'];
+  const syntaxHighlighter001 = {
+    renderHighlighted: renderHighlighted,
+    
+  };
   
-};
-
-export { syntaxHighlighter001 as syntaxHighlighter, syntaxHighlighter001 as 'docs:giallo-js/syntax-highlighter@0.0.1',  }
+  return { syntaxHighlighter: syntaxHighlighter001, 'docs:giallo-js/syntax-highlighter@0.0.1': syntaxHighlighter001,  };
+})();
+let promise, resolve, reject;
+function runNext (value) {
+  try {
+    let done;
+    do {
+      ({ value, done } = gen.next(value));
+    } while (!(value instanceof Promise) && !done);
+    if (done) {
+      if (resolve) return resolve(value);
+      else return value;
+    }
+    if (!promise) promise = new Promise((_resolve, _reject) => (resolve = _resolve, reject = _reject));
+    value.then(nextVal => done ? resolve() : runNext(nextVal), reject);
+  }
+  catch (e) {
+    if (reject) reject(e);
+    else throw e;
+  }
+}
+const maybeSyncReturn = runNext(null);
+return promise || maybeSyncReturn;
+}