@spade-lang/spade 0.9.0-dev.899bf3-1ce864

package/gen/bundle.js

@@ -0,0 +1,3209 @@
+// node_modules/@yowasp/runtime/lib/fetch.js
+var fetch;
+if (typeof process === "object" && process.release?.name === "node") {
+  fetch = async function(url, options) {
+    if (url.protocol === "file:") {
+      const { readFile } = await import("fs/promises");
+      let contentType = "application/octet-stream";
+      if (url.pathname.endsWith(".wasm"))
+        contentType = "application/wasm";
+      return new Response(await readFile(url), { headers: { "Content-Type": contentType } });
+    } else {
+      return globalThis.fetch(url, options);
+    }
+  };
+} else {
+  fetch = globalThis.fetch;
+}
+var fetch_default = fetch;
+
+// node_modules/@yowasp/runtime/lib/wasi-virt.js
+var Exit = class extends Error {
+  constructor(code = 0) {
+    super(`Exited with status ${code}`);
+    this.code = code;
+  }
+};
+function monotonicNow() {
+  return BigInt(Math.floor(performance.now() * 1e6));
+}
+function wallClockNow() {
+  let now = Date.now();
+  const seconds = BigInt(Math.floor(now / 1e3));
+  const nanoseconds = now % 1e3 * 1e6;
+  return { seconds, nanoseconds };
+}
+var Xoroshiro128StarStar = class {
+  constructor(seed) {
+    if (BigInt(seed) === 0n) {
+      throw new Error("xoroshiro128** must be seeded with a non-zero state");
+    }
+    this.s = [BigInt(seed) & 0xffffffffffffffffn, BigInt(seed) >> 64n & 0xffffffffffffffffn];
+  }
+  next() {
+    function trunc64(x) {
+      return x & 0xffffffffffffffffn;
+    }
+    function rotl(x, k) {
+      return x << k | x >> 64n - k;
+    }
+    let [s0, s1] = this.s;
+    const r = trunc64(rotl(s0 * 5n, 7n) * 9n);
+    s1 ^= s0;
+    s0 = trunc64(rotl(s0, 24n) ^ s1 ^ s1 << 16n);
+    s1 = trunc64(rotl(s1, 37n));
+    this.s = [s0, s1];
+    return r;
+  }
+  getBytes(length) {
+    return Uint8Array.from({ length }, () => Number(BigInt.asUintN(8, this.next() >> 32n)));
+  }
+};
+var IoError = class extends Error {
+};
+var InputStream = class {
+  read(_len) {
+    throw { tag: "closed" };
+  }
+  blockingRead(len) {
+    return this.read(len);
+  }
+};
+var OutputStream = class {
+  checkWrite() {
+    throw { tag: "closed" };
+  }
+  write(_contents) {
+    this.checkWrite();
+  }
+  flush() {
+  }
+  blockingFlush() {
+    this.flush();
+  }
+  blockingWriteAndFlush(contents) {
+    this.write(contents);
+    this.blockingFlush();
+  }
+};
+var CallbackInputStream = class extends InputStream {
+  constructor(callback = null) {
+    super();
+    this.callback = callback;
+  }
+  read(len) {
+    if (this.callback === null)
+      throw { tag: "closed" };
+    let contents = this.callback(Number(len));
+    if (contents === null)
+      throw { tag: "closed" };
+    return contents;
+  }
+};
+var CallbackOutputStream = class extends OutputStream {
+  constructor(callback = null) {
+    super();
+    this.callback = callback;
+  }
+  checkWrite() {
+    return 4096;
+  }
+  write(contents) {
+    if (this.callback !== null)
+      this.callback(contents);
+  }
+  flush() {
+    if (this.callback !== null)
+      this.callback(null);
+  }
+};
+var TerminalInput = class {
+};
+var TerminalOutput = class {
+};
+var File = class {
+  constructor(data = "") {
+    if (data instanceof Uint8Array) {
+      this.data = data;
+    } else if (typeof data === "string") {
+      this.data = new TextEncoder().encode(data);
+    } else {
+      throw new Error(`Cannot construct a file from ${typeof data}`);
+    }
+  }
+  get size() {
+    return this.data.length;
+  }
+};
+var ReadStream = class extends InputStream {
+  constructor(file, offset) {
+    super();
+    this.file = file;
+    this.offset = offset;
+  }
+  read(len) {
+    const data = this.file.data.subarray(Number(this.offset), Number(this.offset + len));
+    this.offset += len;
+    return data;
+  }
+};
+var WriteStream = class extends OutputStream {
+  constructor(file, offset) {
+    super();
+    this.file = file;
+    this.offset = offset;
+  }
+  write(contents) {
+    const newData = new Uint8Array(this.file.data.length + contents.length);
+    newData.set(this.file.data);
+    newData.subarray(Number(this.offset)).set(contents);
+    this.file.data = newData;
+    this.offset += BigInt(contents.length);
+  }
+};
+var Directory = class _Directory {
+  constructor(files = {}) {
+    this.files = files;
+  }
+  get size() {
+    return Object.keys(this.files).length;
+  }
+  traverse(path, flags = { create: false, remove: false }) {
+    let entry = this;
+    let separatorAt = -1;
+    do {
+      if (entry instanceof File)
+        throw "not-directory";
+      const files = entry.files;
+      separatorAt = path.indexOf("/");
+      const segment = separatorAt === -1 ? path : path.substring(0, separatorAt);
+      if (separatorAt === -1 && flags.remove)
+        delete files[segment];
+      else if (segment === "" || segment === ".")
+        ;
+      else if (segment === "..")
+        ;
+      else if (Object.hasOwn(files, segment))
+        entry = files[segment];
+      else if (flags.create === "directory" || flags.create === "file" && separatorAt !== -1)
+        entry = files[segment] = new _Directory({});
+      else if (flags.create === "file")
+        entry = files[segment] = new File(new Uint8Array());
+      else
+        throw "no-entry";
+      path = path.substring(separatorAt + 1);
+    } while (separatorAt !== -1);
+    return entry;
+  }
+};
+var Descriptor = class _Descriptor {
+  constructor(entry) {
+    this.entry = entry;
+  }
+  getType() {
+    if (this.entry instanceof Directory)
+      return "directory";
+    if (this.entry instanceof File)
+      return "regular-file";
+  }
+  getFlags() {
+    return {};
+  }
+  metadataHash() {
+    return { upper: 0, lower: 0 };
+  }
+  metadataHashAt(_pathFlags, path) {
+    if (!(this.entry instanceof Directory))
+      throw "invalid";
+    const pathEntry = this.entry.traverse(path);
+    return new _Descriptor(pathEntry).metadataHash();
+  }
+  stat() {
+    let type;
+    if (this.entry instanceof Directory)
+      type = "directory";
+    if (this.entry instanceof File)
+      type = "regular-file";
+    return {
+      type,
+      linkCount: 1,
+      size: this.entry.size,
+      dataAccessTimestamp: null,
+      dataModificationTimestamp: null,
+      statusChangeTimestamp: null
+    };
+  }
+  statAt(_pathFlags, path) {
+    if (!(this.entry instanceof Directory))
+      throw "invalid";
+    const pathEntry = this.entry.traverse(path);
+    return new _Descriptor(pathEntry).stat();
+  }
+  openAt(_pathFlags, path, openFlags, _descriptorFlags) {
+    if (!(this.entry instanceof Directory))
+      throw "invalid";
+    const openEntry = this.entry.traverse(path, { create: openFlags.create ? "file" : false });
+    if (openFlags.directory) {
+      if (!(openEntry instanceof Directory))
+        throw "not-directory";
+    } else {
+      if (openEntry instanceof Directory)
+        throw "is-directory";
+      if (openFlags.truncate)
+        openEntry.data = new Uint8Array();
+    }
+    return new _Descriptor(openEntry);
+  }
+  read(length, offset) {
+    if (this.entry instanceof Directory)
+      throw "is-directory";
+    [length, offset] = [Number(length), Number(offset)];
+    return [this.entry.data.subarray(offset, offset + length), offset + length >= this.entry.data.byteLength];
+  }
+  readViaStream(offset) {
+    return new ReadStream(this.entry, offset);
+  }
+  write(_buffer, _offset) {
+    if (this.entry instanceof Directory)
+      throw "is-directory";
+    console.error("Descriptor.write not implemented");
+    throw "unsupported";
+  }
+  writeViaStream(offset) {
+    return new WriteStream(this.entry, offset);
+  }
+  readDirectory() {
+    return new DirectoryEntryStream(this.entry);
+  }
+  createDirectoryAt(path) {
+    this.entry.traverse(path, { create: "directory" });
+  }
+  unlinkFileAt(path) {
+    const pathEntry = this.entry.traverse(path);
+    if (pathEntry instanceof Directory)
+      return "is-directory";
+    this.entry.traverse(path, { remove: true });
+  }
+  removeDirectoryAt(path) {
+    const pathEntry = this.entry.traverse(path);
+    if (!(pathEntry instanceof Directory))
+      return "not-directory";
+    this.entry.traverse(path, { remove: true });
+  }
+};
+var DirectoryEntryStream = class {
+  constructor(directory) {
+    this.entries = Object.entries(directory.files);
+    this.index = 0;
+  }
+  readDirectoryEntry() {
+    if (this.index === this.entries.length)
+      return null;
+    const [name, entry] = this.entries[this.index++];
+    let type;
+    if (entry instanceof Directory)
+      type = "directory";
+    if (entry instanceof File)
+      type = "regular-file";
+    return { name, type };
+  }
+};
+function directoryFromTree(tree) {
+  const files = {};
+  for (const [filename, data] of Object.entries(tree)) {
+    if (typeof data === "string" || data instanceof Uint8Array)
+      files[filename] = new File(tree[filename]);
+    else
+      files[filename] = directoryFromTree(tree[filename]);
+  }
+  return new Directory(files);
+}
+function directoryIntoTree(directory, { decodeASCII = true } = {}) {
+  function isASCII(buffer) {
+    for (const byte of buffer)
+      if (byte < 32 && byte !== 9 && byte !== 10 && byte !== 13 || byte >= 127)
+        return false;
+    return true;
+  }
+  const tree = {};
+  for (const [filename, entry] of Object.entries(directory.files)) {
+    if (entry instanceof File)
+      tree[filename] = decodeASCII && isASCII(entry.data) ? new TextDecoder().decode(entry.data) : entry.data;
+    if (entry instanceof Directory)
+      tree[filename] = directoryIntoTree(entry, { decodeASCII });
+  }
+  return tree;
+}
+var Environment = class {
+  vars = {};
+  args = [];
+  root = new Directory({});
+  constructor() {
+    this.prng = new Xoroshiro128StarStar(1n);
+    this.standardInputStream = new CallbackInputStream();
+    this.standardOutputStream = new CallbackOutputStream();
+    this.standardErrorStream = new CallbackOutputStream();
+    this.terminalInput = new TerminalInput();
+    this.terminalOutput = new TerminalOutput();
+    const $this = this;
+    this.exports = {
+      monotonicClock: {
+        now: monotonicNow
+      },
+      wallClock: {
+        now: wallClockNow
+      },
+      random: {
+        getRandomBytes(length) {
+          return $this.prng.getBytes(Number(length));
+        }
+      },
+      io: {
+        Error: IoError,
+        InputStream,
+        OutputStream
+      },
+      cli: {
+        exit(status) {
+          throw new Exit(status.tag === "ok" ? 0 : 1);
+        },
+        getEnvironment() {
+          return $this.vars;
+        },
+        getArguments() {
+          return $this.args;
+        },
+        getStdin() {
+          return $this.standardInputStream;
+        },
+        getStdout() {
+          return $this.standardOutputStream;
+        },
+        getStderr() {
+          return $this.standardErrorStream;
+        },
+        getTerminalStdin() {
+          return $this.terminalInput;
+        },
+        getTerminalStdout() {
+          return $this.terminalOutput;
+        },
+        getTerminalStderr() {
+          return $this.terminalOutput;
+        },
+        TerminalInput,
+        TerminalOutput
+      },
+      fs: {
+        Descriptor,
+        DirectoryEntryStream,
+        filesystemErrorCode() {
+        },
+        getDirectories() {
+          if ($this.root === null)
+            return [];
+          return [[new Descriptor($this.root), "/"]];
+        }
+      }
+    };
+  }
+  get stdin() {
+    return this.standardInputStream.callback;
+  }
+  set stdin(callback) {
+    this.standardInputStream.callback = callback;
+  }
+  get stdout() {
+    return this.standardOutputStream.callback;
+  }
+  set stdout(callback) {
+    this.standardOutputStream.callback = callback;
+  }
+  get stderr() {
+    return this.standardErrorStream.callback;
+  }
+  set stderr(callback) {
+    this.standardErrorStream.callback = callback;
+  }
+};
+
+// node_modules/@yowasp/runtime/lib/util.js
+function lineBuffered(processLine) {
+  let buffer = new Uint8Array();
+  return (bytes) => {
+    if (bytes === null)
+      return;
+    let newBuffer = new Uint8Array(buffer.length + bytes.length);
+    newBuffer.set(buffer);
+    newBuffer.set(bytes, buffer.length);
+    buffer = newBuffer;
+    let newlineAt = -1;
+    while (true) {
+      const nextNewlineAt = buffer.indexOf(10, newlineAt + 1);
+      if (nextNewlineAt === -1)
+        break;
+      processLine(new TextDecoder().decode(buffer.subarray(newlineAt + 1, nextNewlineAt)));
+      newlineAt = nextNewlineAt;
+    }
+    buffer = buffer.subarray(newlineAt + 1);
+  };
+}
+
+// node_modules/@yowasp/runtime/lib/api.js
+async function fetchObject(obj, fetchFn) {
+  const promises = [];
+  for (const [key, value] of Object.entries(obj)) {
+    if (typeof value === "string" || value instanceof Uint8Array) {
+      promises.push(Promise.resolve([key, value]));
+    } else if (value instanceof URL) {
+      promises.push(fetchFn(value).then((fetched) => [key, fetched]));
+    } else {
+      promises.push(fetchObject(value, fetchFn).then((fetched) => [key, fetched]));
+    }
+  }
+  for (const [key, value] of await Promise.all(promises))
+    obj[key] = value;
+  return obj;
+}
+function fetchWebAssembly(url) {
+  return fetch_default(url).then(WebAssembly.compileStreaming);
+}
+function fetchUint8Array(url) {
+  return fetch_default(url).then((resp) => resp.arrayBuffer()).then((buf) => new Uint8Array(buf));
+}
+function fetchResources({ modules, filesystem }) {
+  return Promise.all([
+    fetchObject(modules, fetchWebAssembly),
+    fetchObject(filesystem, fetchUint8Array)
+  ]).then(([modules2, filesystem2]) => {
+    return { modules: modules2, filesystem: filesystem2 };
+  });
+}
+var Application = class {
+  constructor(resources, instantiate2, argv0) {
+    this.resources = resources;
+    this.resourceData = null;
+    this.instantiate = instantiate2;
+    this.argv0 = argv0;
+  }
+  async preload() {
+    if (this.resourceData === null)
+      this.resourceData = await this.resources().then(fetchResources);
+  }
+  // The `printLine` option is deprecated and not documented but still accepted for compatibility.
+  execute(args, files = {}, { stdin, stdout, stderr, decodeASCII = true, printLine } = {}) {
+    const environment = new Environment();
+    environment.args = [this.argv0].concat(args);
+    environment.root = directoryFromTree(files);
+    for (const [dirName, dirContents] of Object.entries(this.resourceData.filesystem))
+      environment.root.files[dirName] = directoryFromTree(dirContents);
+    const lineBufferedConsole = lineBuffered(printLine ?? console.log);
+    environment.stdin = stdin === void 0 ? null : stdin;
+    environment.stdout = stdout === void 0 ? lineBufferedConsole : stdout;
+    environment.stderr = stderr === void 0 ? lineBufferedConsole : stderr;
+    const wasmCommand = this.instantiate(
+      (filename) => this.resourceData.modules[filename],
+      { runtime: environment.exports },
+      // workaround for bytecodealliance/jco#374
+      (module, imports) => new WebAssembly.Instance(module, imports)
+    );
+    let error = null;
+    try {
+      wasmCommand.run.run();
+    } catch (e) {
+      if (!(e instanceof Exit))
+        throw e;
+      if (e instanceof Exit && e.code !== 0)
+        error = e;
+    }
+    for (const dirName of Object.keys(this.resourceData.filesystem))
+      delete environment.root.files[dirName];
+    files = directoryIntoTree(environment.root, { decodeASCII });
+    if (error !== null) {
+      error.files = files;
+      throw error;
+    } else {
+      return files;
+    }
+  }
+  run(args = null, files = {}, options = {}) {
+    if (this.resourceData === null)
+      return this.preload().then((_) => this.run(args, files, options));
+    if (args === null)
+      return;
+    return this.execute(args, files, options);
+  }
+};
+
+// gen/spade.js
+var ComponentError = class extends Error {
+  constructor(value) {
+    const enumerable = typeof value !== "string";
+    super(enumerable ? `${String(value)} (see error.payload)` : value);
+    Object.defineProperty(this, "payload", { value, enumerable });
+  }
+};
+var dv = new DataView(new ArrayBuffer());
+var dataView = (mem) => dv.buffer === mem.buffer ? dv : dv = new DataView(mem.buffer);
+function getErrorPayload(e) {
+  if (e && hasOwnProperty.call(e, "payload"))
+    return e.payload;
+  return e;
+}
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+var resourceHandleSymbol = Symbol("resource");
+var symbolDispose = Symbol.dispose || Symbol.for("dispose");
+var toUint64 = (val) => BigInt.asUintN(64, BigInt(val));
+function toUint32(val) {
+  return val >>> 0;
+}
+var utf8Decoder = new TextDecoder();
+var utf8Encoder = new TextEncoder();
+var 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 allocLen = 0;
+  let ptr = 0;
+  let writtenTotal = 0;
+  while (s.length > 0) {
+    ptr = realloc(ptr, allocLen, 1, allocLen += s.length * 2);
+    const { read, written } = utf8Encoder.encodeInto(
+      s,
+      new Uint8Array(memory.buffer, ptr + writtenTotal, allocLen - writtenTotal)
+    );
+    writtenTotal += written;
+    s = s.slice(read);
+  }
+  utf8EncodedLen = writtenTotal;
+  return ptr;
+}
+function instantiate(getCoreModule, imports, instantiateCore = WebAssembly.Instance) {
+  const module0 = getCoreModule("spade.core.wasm");
+  const module1 = getCoreModule("spade.core2.wasm");
+  const module2 = getCoreModule("spade.core3.wasm");
+  const module3 = getCoreModule("spade.core4.wasm");
+  const { cli, fs, io, monotonicClock, random, wallClock } = imports.runtime;
+  const {
+    TerminalInput: TerminalInput2,
+    TerminalOutput: TerminalOutput2,
+    exit,
+    getArguments,
+    getEnvironment,
+    getStderr,
+    getStdin,
+    getStdout,
+    getTerminalStderr,
+    getTerminalStdin,
+    getTerminalStdout
+  } = cli;
+  const {
+    Descriptor: Descriptor2,
+    DirectoryEntryStream: DirectoryEntryStream2,
+    filesystemErrorCode,
+    getDirectories
+  } = fs;
+  const {
+    Error: Error$1,
+    InputStream: InputStream2,
+    OutputStream: OutputStream2
+  } = io;
+  const { now } = monotonicClock;
+  const { getRandomBytes } = random;
+  const { now: now$1 } = wallClock;
+  let exports0;
+  let exports1;
+  function trampoline0() {
+    const ret = now();
+    return toUint64(ret);
+  }
+  function trampoline8() {
+    const ret = getStderr();
+    if (!(ret instanceof OutputStream2)) {
+      throw new Error('Resource error: Not a valid "OutputStream" resource.');
+    }
+    var handle0 = handleCnt2++;
+    handleTable2.set(handle0, { rep: ret, own: true });
+    return handle0;
+  }
+  function trampoline9(arg0) {
+    let variant0;
+    switch (arg0) {
+      case 0: {
+        variant0 = {
+          tag: "ok",
+          val: void 0
+        };
+        break;
+      }
+      case 1: {
+        variant0 = {
+          tag: "err",
+          val: void 0
+        };
+        break;
+      }
+      default: {
+        throw new TypeError("invalid variant discriminant for expected");
+      }
+    }
+    exit(variant0);
+  }
+  function trampoline10() {
+    const ret = getStdin();
+    if (!(ret instanceof InputStream2)) {
+      throw new Error('Resource error: Not a valid "InputStream" resource.');
+    }
+    var handle0 = handleCnt1++;
+    handleTable1.set(handle0, { rep: ret, own: true });
+    return handle0;
+  }
+  function trampoline11() {
+    const ret = getStdout();
+    if (!(ret instanceof OutputStream2)) {
+      throw new Error('Resource error: Not a valid "OutputStream" resource.');
+    }
+    var handle0 = handleCnt2++;
+    handleTable2.set(handle0, { rep: ret, own: true });
+    return handle0;
+  }
+  let exports2;
+  function trampoline12(arg0) {
+    const ret = getDirectories();
+    var vec3 = ret;
+    var len3 = vec3.length;
+    var result3 = realloc0(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 Descriptor2)) {
+        throw new Error('Resource error: Not a valid "Descriptor" resource.');
+      }
+      var handle1 = handleCnt5++;
+      handleTable5.set(handle1, { rep: tuple0_0, own: true });
+      dataView(memory0).setInt32(base + 0, handle1, true);
+      var ptr2 = utf8Encode(tuple0_1, realloc0, memory0);
+      var len2 = utf8EncodedLen;
+      dataView(memory0).setInt32(base + 8, len2, true);
+      dataView(memory0).setInt32(base + 4, ptr2, true);
+    }
+    dataView(memory0).setInt32(arg0 + 4, len3, true);
+    dataView(memory0).setInt32(arg0 + 0, result3, true);
+  }
+  let memory0;
+  let realloc0;
+  function trampoline13(arg0) {
+    const ret = now$1();
+    var { seconds: v0_0, nanoseconds: v0_1 } = ret;
+    dataView(memory0).setBigInt64(arg0 + 0, toUint64(v0_0), true);
+    dataView(memory0).setInt32(arg0 + 8, toUint32(v0_1), true);
+  }
+  function trampoline14(arg0, arg1, arg2) {
+    var handle1 = arg0;
+    var rsc0 = handleTable5.get(handle1).rep;
+    let ret;
+    try {
+      ret = { tag: "ok", val: Descriptor2.prototype.readViaStream.call(rsc0, BigInt.asUintN(64, arg1)) };
+    } catch (e) {
+      ret = { tag: "err", val: getErrorPayload(e) };
+    }
+    var variant4 = ret;
+    switch (variant4.tag) {
+      case "ok": {
+        const e = variant4.val;
+        dataView(memory0).setInt8(arg2 + 0, 0, true);
+        if (!(e instanceof InputStream2)) {
+          throw new Error('Resource error: Not a valid "InputStream" resource.');
+        }
+        var handle2 = handleCnt1++;
+        handleTable1.set(handle2, { rep: e, own: true });
+        dataView(memory0).setInt32(arg2 + 4, handle2, true);
+        break;
+      }
+      case "err": {
+        const e = variant4.val;
+        dataView(memory0).setInt8(arg2 + 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;
+            break;
+          }
+          case "invalid-seek": {
+            enum3 = 34;
+            break;
+          }
+          case "text-file-busy": {
+            enum3 = 35;
+            break;
+          }
+          case "cross-device": {
+            enum3 = 36;
+            break;
+          }
+          default: {
+            if (e instanceof Error) {
+              console.error(e);
+            }
+            throw new TypeError(`"${val3}" is not one of the cases of error-code`);
+          }
+        }
+        dataView(memory0).setInt8(arg2 + 4, enum3, true);
+        break;
+      }
+      default: {
+        throw new TypeError("invalid variant specified for result");
+      }
+    }
+  }
+  function trampoline15(arg0, arg1, arg2) {
+    var handle1 = arg0;
+    var rsc0 = handleTable5.get(handle1).rep;
+    let ret;
+    try {
+      ret = { tag: "ok", val: Descriptor2.prototype.writeViaStream.call(rsc0, BigInt.asUintN(64, arg1)) };
+    } catch (e) {
+      ret = { tag: "err", val: getErrorPayload(e) };
+    }
+    var variant4 = ret;
+    switch (variant4.tag) {
+      case "ok": {
+        const e = variant4.val;
+        dataView(memory0).setInt8(arg2 + 0, 0, true);
+        if (!(e instanceof OutputStream2)) {
+          throw new Error('Resource error: Not a valid "OutputStream" resource.');
+        }
+        var handle2 = handleCnt2++;
+        handleTable2.set(handle2, { rep: e, own: true });
+        dataView(memory0).setInt32(arg2 + 4, handle2, true);
+        break;
+      }
+      case "err": {
+        const e = variant4.val;
+        dataView(memory0).setInt8(arg2 + 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;
+            break;
+          }
+          case "invalid-seek": {
+            enum3 = 34;
+            break;
+          }
+          case "text-file-busy": {
+            enum3 = 35;
+            break;
+          }
+          case "cross-device": {
+            enum3 = 36;
+            break;
+          }
+          default: {
+            if (e instanceof Error) {
+              console.error(e);
+            }
+            throw new TypeError(`"${val3}" is not one of the cases of error-code`);
+          }
+        }
+        dataView(memory0).setInt8(arg2 + 4, enum3, true);
+        break;
+      }
+      default: {
+        throw new TypeError("invalid variant specified for result");
+      }
+    }
+  }
+  function trampoline16(arg0, arg1) {
+    var handle1 = arg0;
+    var rsc0 = handleTable5.get(handle1).rep;
+    let ret;
+    try {
+      ret = { tag: "ok", val: Descriptor2.prototype.appendViaStream.call(rsc0) };
+    } catch (e) {
+      ret = { tag: "err", val: getErrorPayload(e) };
+    }
+    var variant4 = ret;
+    switch (variant4.tag) {
+      case "ok": {
+        const e = variant4.val;
+        dataView(memory0).setInt8(arg1 + 0, 0, true);
+        if (!(e instanceof OutputStream2)) {
+          throw new Error('Resource error: Not a valid "OutputStream" resource.');
+        }
+        var handle2 = handleCnt2++;
+        handleTable2.set(handle2, { rep: e, own: true });
+        dataView(memory0).setInt32(arg1 + 4, handle2, true);
+        break;
+      }
+      case "err": {
+        const e = variant4.val;
+        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;
+            break;
+          }
+          case "invalid-seek": {
+            enum3 = 34;
+            break;
+          }
+          case "text-file-busy": {
+            enum3 = 35;
+            break;
+          }
+          case "cross-device": {
+            enum3 = 36;
+            break;
+          }
+          default: {
+            if (e instanceof Error) {
+              console.error(e);
+            }
+            throw new TypeError(`"${val3}" is not one of the cases of error-code`);
+          }
+        }
+        dataView(memory0).setInt8(arg1 + 4, enum3, true);
+        break;
+      }
+      default: {
+        throw new TypeError("invalid variant specified for result");
+      }
+    }
+  }
+  function trampoline17(arg0, arg1) {
+    var handle1 = arg0;
+    var rsc0 = handleTable5.get(handle1).rep;
+    let ret;
+    try {
+      ret = { tag: "ok", val: Descriptor2.prototype.getFlags.call(rsc0) };
+    } catch (e) {
+      ret = { tag: "err", val: getErrorPayload(e) };
+    }
+    var variant4 = ret;
+    switch (variant4.tag) {
+      case "ok": {
+        const e = variant4.val;
+        dataView(memory0).setInt8(arg1 + 0, 0, true);
+        let flags2 = 0;
+        if (typeof e === "object" && e !== null) {
+          flags2 = Boolean(e.read) << 0 | Boolean(e.write) << 1 | Boolean(e.fileIntegritySync) << 2 | Boolean(e.dataIntegritySync) << 3 | Boolean(e.requestedWriteSync) << 4 | Boolean(e.mutateDirectory) << 5;
+        } else if (e !== null && e !== void 0) {
+          throw new TypeError("only an object, undefined or null can be converted to flags");
+        }
+        dataView(memory0).setInt8(arg1 + 1, flags2, true);
+        break;
+      }
+      case "err": {
+        const e = variant4.val;
+        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;
+            break;
+          }
+          case "invalid-seek": {
+            enum3 = 34;
+            break;
+          }
+          case "text-file-busy": {
+            enum3 = 35;
+            break;
+          }
+          case "cross-device": {
+            enum3 = 36;
+            break;
+          }
+          default: {
+            if (e instanceof Error) {
+              console.error(e);
+            }
+            throw new TypeError(`"${val3}" is not one of the cases of error-code`);
+          }
+        }
+        dataView(memory0).setInt8(arg1 + 1, enum3, true);
+        break;
+      }
+      default: {
+        throw new TypeError("invalid variant specified for result");
+      }
+    }
+  }
+  function trampoline18(arg0, arg1) {
+    var handle1 = arg0;
+    var rsc0 = handleTable5.get(handle1).rep;
+    let ret;
+    try {
+      ret = { tag: "ok", val: Descriptor2.prototype.getType.call(rsc0) };
+    } catch (e) {
+      ret = { tag: "err", val: getErrorPayload(e) };
+    }
+    var variant4 = ret;
+    switch (variant4.tag) {
+      case "ok": {
+        const e = variant4.val;
+        dataView(memory0).setInt8(arg1 + 0, 0, true);
+        var val2 = e;
+        let enum2;
+        switch (val2) {
+          case "unknown": {
+            enum2 = 0;
+            break;
+          }
+          case "block-device": {
+            enum2 = 1;
+            break;
+          }
+          case "character-device": {
+            enum2 = 2;
+            break;
+          }
+          case "directory": {
+            enum2 = 3;
+            break;
+          }
+          case "fifo": {
+            enum2 = 4;
+            break;
+          }
+          case "symbolic-link": {
+            enum2 = 5;
+            break;
+          }
+          case "regular-file": {
+            enum2 = 6;
+            break;
+          }
+          case "socket": {
+            enum2 = 7;
+            break;
+          }
+          default: {
+            if (e instanceof Error) {
+              console.error(e);
+            }
+            throw new TypeError(`"${val2}" is not one of the cases of descriptor-type`);
+          }
+        }
+        dataView(memory0).setInt8(arg1 + 1, enum2, true);
+        break;
+      }
+      case "err": {
+        const e = variant4.val;
+        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;
+            break;
+          }
+          case "invalid-seek": {
+            enum3 = 34;
+            break;
+          }
+          case "text-file-busy": {
+            enum3 = 35;
+            break;
+          }
+          case "cross-device": {
+            enum3 = 36;
+            break;
+          }
+          default: {
+            if (e instanceof Error) {
+              console.error(e);
+            }
+            throw new TypeError(`"${val3}" is not one of the cases of error-code`);
+          }
+        }
+        dataView(memory0).setInt8(arg1 + 1, enum3, true);
+        break;
+      }
+      default: {
+        throw new TypeError("invalid variant specified for result");
+      }
+    }
+  }
+  function trampoline19(arg0, arg1) {
+    var handle1 = arg0;
+    var rsc0 = handleTable5.get(handle1).rep;
+    let ret;
+    try {
+      ret = { tag: "ok", val: Descriptor2.prototype.stat.call(rsc0) };
+    } catch (e) {
+      ret = { tag: "err", val: getErrorPayload(e) };
+    }
+    var variant11 = ret;
+    switch (variant11.tag) {
+      case "ok": {
+        const e = variant11.val;
+        dataView(memory0).setInt8(arg1 + 0, 0, true);
+        var { type: v2_0, linkCount: v2_1, size: v2_2, dataAccessTimestamp: v2_3, dataModificationTimestamp: v2_4, statusChangeTimestamp: v2_5 } = e;
+        var val3 = v2_0;
+        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 (v2_0 instanceof Error) {
+              console.error(v2_0);
+            }
+            throw new TypeError(`"${val3}" is not one of the cases of descriptor-type`);
+          }
+        }
+        dataView(memory0).setInt8(arg1 + 8, enum3, true);
+        dataView(memory0).setBigInt64(arg1 + 16, toUint64(v2_1), true);
+        dataView(memory0).setBigInt64(arg1 + 24, toUint64(v2_2), true);
+        var variant5 = v2_3;
+        if (variant5 === null || variant5 === void 0) {
+          dataView(memory0).setInt8(arg1 + 32, 0, true);
+        } else {
+          const e2 = variant5;
+          dataView(memory0).setInt8(arg1 + 32, 1, true);
+          var { seconds: v4_0, nanoseconds: v4_1 } = e2;
+          dataView(memory0).setBigInt64(arg1 + 40, toUint64(v4_0), true);
+          dataView(memory0).setInt32(arg1 + 48, toUint32(v4_1), true);
+        }
+        var variant7 = v2_4;
+        if (variant7 === null || variant7 === void 0) {
+          dataView(memory0).setInt8(arg1 + 56, 0, true);
+        } else {
+          const e2 = variant7;
+          dataView(memory0).setInt8(arg1 + 56, 1, true);
+          var { seconds: v6_0, nanoseconds: v6_1 } = e2;
+          dataView(memory0).setBigInt64(arg1 + 64, toUint64(v6_0), true);
+          dataView(memory0).setInt32(arg1 + 72, toUint32(v6_1), true);
+        }
+        var variant9 = v2_5;
+        if (variant9 === null || variant9 === void 0) {
+          dataView(memory0).setInt8(arg1 + 80, 0, true);
+        } else {
+          const e2 = variant9;
+          dataView(memory0).setInt8(arg1 + 80, 1, true);
+          var { seconds: v8_0, nanoseconds: v8_1 } = e2;
+          dataView(memory0).setBigInt64(arg1 + 88, toUint64(v8_0), true);
+          dataView(memory0).setInt32(arg1 + 96, toUint32(v8_1), true);
+        }
+        break;
+      }
+      case "err": {
+        const e = variant11.val;
+        dataView(memory0).setInt8(arg1 + 0, 1, true);
+        var val10 = e;
+        let enum10;
+        switch (val10) {
+          case "access": {
+            enum10 = 0;
+            break;
+          }
+          case "would-block": {
+            enum10 = 1;
+            break;
+          }
+          case "already": {
+            enum10 = 2;
+            break;
+          }
+          case "bad-descriptor": {
+            enum10 = 3;
+            break;
+          }
+          case "busy": {
+            enum10 = 4;
+            break;
+          }
+          case "deadlock": {
+            enum10 = 5;
+            break;
+          }
+          case "quota": {
+            enum10 = 6;
+            break;
+          }
+          case "exist": {
+            enum10 = 7;
+            break;
+          }
+          case "file-too-large": {
+            enum10 = 8;
+            break;
+          }
+          case "illegal-byte-sequence": {
+            enum10 = 9;
+            break;
+          }
+          case "in-progress": {
+            enum10 = 10;
+            break;
+          }
+          case "interrupted": {
+            enum10 = 11;
+            break;
+          }
+          case "invalid": {
+            enum10 = 12;
+            break;
+          }
+          case "io": {
+            enum10 = 13;
+            break;
+          }
+          case "is-directory": {
+            enum10 = 14;
+            break;
+          }
+          case "loop": {
+            enum10 = 15;
+            break;
+          }
+          case "too-many-links": {
+            enum10 = 16;
+            break;
+          }
+          case "message-size": {
+            enum10 = 17;
+            break;
+          }
+          case "name-too-long": {
+            enum10 = 18;
+            break;
+          }
+          case "no-device": {
+            enum10 = 19;
+            break;
+          }
+          case "no-entry": {
+            enum10 = 20;
+            break;
+          }
+          case "no-lock": {
+            enum10 = 21;
+            break;
+          }
+          case "insufficient-memory": {
+            enum10 = 22;
+            break;
+          }
+          case "insufficient-space": {
+            enum10 = 23;
+            break;
+          }
+          case "not-directory": {
+            enum10 = 24;
+            break;
+          }
+          case "not-empty": {
+            enum10 = 25;
+            break;
+          }
+          case "not-recoverable": {
+            enum10 = 26;
+            break;
+          }
+          case "unsupported": {
+            enum10 = 27;
+            break;
+          }
+          case "no-tty": {
+            enum10 = 28;
+            break;
+          }
+          case "no-such-device": {
+            enum10 = 29;
+            break;
+          }
+          case "overflow": {
+            enum10 = 30;
+            break;
+          }
+          case "not-permitted": {
+            enum10 = 31;
+            break;
+          }
+          case "pipe": {
+            enum10 = 32;
+            break;
+          }
+          case "read-only": {
+            enum10 = 33;
+            break;
+          }
+          case "invalid-seek": {
+            enum10 = 34;
+            break;
+          }
+          case "text-file-busy": {
+            enum10 = 35;
+            break;
+          }
+          case "cross-device": {
+            enum10 = 36;
+            break;
+          }
+          default: {
+            if (e instanceof Error) {
+              console.error(e);
+            }
+            throw new TypeError(`"${val10}" is not one of the cases of error-code`);
+          }
+        }
+        dataView(memory0).setInt8(arg1 + 8, enum10, true);
+        break;
+      }
+      default: {
+        throw new TypeError("invalid variant specified for result");
+      }
+    }
+  }
+  function trampoline20(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
+    var handle1 = arg0;
+    var rsc0 = handleTable5.get(handle1).rep;
+    if ((arg1 & 4294967294) !== 0) {
+      throw new TypeError("flags have extraneous bits set");
+    }
+    var flags2 = {
+      symlinkFollow: Boolean(arg1 & 1)
+    };
+    var ptr3 = arg2;
+    var len3 = arg3;
+    var result3 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr3, len3));
+    if ((arg4 & 4294967280) !== 0) {
+      throw new TypeError("flags have extraneous bits set");
+    }
+    var flags4 = {
+      create: Boolean(arg4 & 1),
+      directory: Boolean(arg4 & 2),
+      exclusive: Boolean(arg4 & 4),
+      truncate: Boolean(arg4 & 8)
+    };
+    if ((arg5 & 4294967232) !== 0) {
+      throw new TypeError("flags have extraneous bits set");
+    }
+    var flags5 = {
+      read: Boolean(arg5 & 1),
+      write: Boolean(arg5 & 2),
+      fileIntegritySync: Boolean(arg5 & 4),
+      dataIntegritySync: Boolean(arg5 & 8),
+      requestedWriteSync: Boolean(arg5 & 16),
+      mutateDirectory: Boolean(arg5 & 32)
+    };
+    let ret;
+    try {
+      ret = { tag: "ok", val: Descriptor2.prototype.openAt.call(rsc0, flags2, result3, flags4, flags5) };
+    } catch (e) {
+      ret = { tag: "err", val: getErrorPayload(e) };
+    }
+    var variant8 = ret;
+    switch (variant8.tag) {
+      case "ok": {
+        const e = variant8.val;
+        dataView(memory0).setInt8(arg6 + 0, 0, true);
+        if (!(e instanceof Descriptor2)) {
+          throw new Error('Resource error: Not a valid "Descriptor" resource.');
+        }
+        var handle6 = handleCnt5++;
+        handleTable5.set(handle6, { rep: e, own: true });
+        dataView(memory0).setInt32(arg6 + 4, handle6, true);
+        break;
+      }
+      case "err": {
+        const e = variant8.val;
+        dataView(memory0).setInt8(arg6 + 0, 1, true);
+        var val7 = e;
+        let enum7;
+        switch (val7) {
+          case "access": {
+            enum7 = 0;
+            break;
+          }
+          case "would-block": {
+            enum7 = 1;
+            break;
+          }
+          case "already": {
+            enum7 = 2;
+            break;
+          }
+          case "bad-descriptor": {
+            enum7 = 3;
+            break;
+          }
+          case "busy": {
+            enum7 = 4;
+            break;
+          }
+          case "deadlock": {
+            enum7 = 5;
+            break;
+          }
+          case "quota": {
+            enum7 = 6;
+            break;
+          }
+          case "exist": {
+            enum7 = 7;
+            break;
+          }
+          case "file-too-large": {
+            enum7 = 8;
+            break;
+          }
+          case "illegal-byte-sequence": {
+            enum7 = 9;
+            break;
+          }
+          case "in-progress": {
+            enum7 = 10;
+            break;
+          }
+          case "interrupted": {
+            enum7 = 11;
+            break;
+          }
+          case "invalid": {
+            enum7 = 12;
+            break;
+          }
+          case "io": {
+            enum7 = 13;
+            break;
+          }
+          case "is-directory": {
+            enum7 = 14;
+            break;
+          }
+          case "loop": {
+            enum7 = 15;
+            break;
+          }
+          case "too-many-links": {
+            enum7 = 16;
+            break;
+          }
+          case "message-size": {
+            enum7 = 17;
+            break;
+          }
+          case "name-too-long": {
+            enum7 = 18;
+            break;
+          }
+          case "no-device": {
+            enum7 = 19;
+            break;
+          }
+          case "no-entry": {
+            enum7 = 20;
+            break;
+          }
+          case "no-lock": {
+            enum7 = 21;
+            break;
+          }
+          case "insufficient-memory": {
+            enum7 = 22;
+            break;
+          }
+          case "insufficient-space": {
+            enum7 = 23;
+            break;
+          }
+          case "not-directory": {
+            enum7 = 24;
+            break;
+          }
+          case "not-empty": {
+            enum7 = 25;
+            break;
+          }
+          case "not-recoverable": {
+            enum7 = 26;
+            break;
+          }
+          case "unsupported": {
+            enum7 = 27;
+            break;
+          }
+          case "no-tty": {
+            enum7 = 28;
+            break;
+          }
+          case "no-such-device": {
+            enum7 = 29;
+            break;
+          }
+          case "overflow": {
+            enum7 = 30;
+            break;
+          }
+          case "not-permitted": {
+            enum7 = 31;
+            break;
+          }
+          case "pipe": {
+            enum7 = 32;
+            break;
+          }
+          case "read-only": {
+            enum7 = 33;
+            break;
+          }
+          case "invalid-seek": {
+            enum7 = 34;
+            break;
+          }
+          case "text-file-busy": {
+            enum7 = 35;
+            break;
+          }
+          case "cross-device": {
+            enum7 = 36;
+            break;
+          }
+          default: {
+            if (e instanceof Error) {
+              console.error(e);
+            }
+            throw new TypeError(`"${val7}" is not one of the cases of error-code`);
+          }
+        }
+        dataView(memory0).setInt8(arg6 + 4, enum7, true);
+        break;
+      }
+      default: {
+        throw new TypeError("invalid variant specified for result");
+      }
+    }
+  }
+  function trampoline21(arg0, arg1) {
+    var handle1 = arg0;
+    var rsc0 = handleTable5.get(handle1).rep;
+    let ret;
+    try {
+      ret = { tag: "ok", val: Descriptor2.prototype.metadataHash.call(rsc0) };
+    } catch (e) {
+      ret = { tag: "err", val: getErrorPayload(e) };
+    }
+    var variant4 = ret;
+    switch (variant4.tag) {
+      case "ok": {
+        const e = variant4.val;
+        dataView(memory0).setInt8(arg1 + 0, 0, true);
+        var { lower: v2_0, upper: v2_1 } = e;
+        dataView(memory0).setBigInt64(arg1 + 8, toUint64(v2_0), true);
+        dataView(memory0).setBigInt64(arg1 + 16, toUint64(v2_1), true);
+        break;
+      }
+      case "err": {
+        const e = variant4.val;
+        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;
+            break;
+          }
+          case "invalid-seek": {
+            enum3 = 34;
+            break;
+          }
+          case "text-file-busy": {
+            enum3 = 35;
+            break;
+          }
+          case "cross-device": {
+            enum3 = 36;
+            break;
+          }
+          default: {
+            if (e instanceof Error) {
+              console.error(e);
+            }
+            throw new TypeError(`"${val3}" is not one of the cases of error-code`);
+          }
+        }
+        dataView(memory0).setInt8(arg1 + 8, enum3, true);
+        break;
+      }
+      default: {
+        throw new TypeError("invalid variant specified for result");
+      }
+    }
+  }
+  function trampoline22(arg0, arg1) {
+    var handle1 = arg0;
+    var rsc0 = handleTable0.get(handle1).rep;
+    const ret = filesystemErrorCode(rsc0);
+    var variant3 = ret;
+    if (variant3 === null || variant3 === void 0) {
+      dataView(memory0).setInt8(arg1 + 0, 0, true);
+    } else {
+      const e = variant3;
+      dataView(memory0).setInt8(arg1 + 0, 1, true);
+      var val2 = e;
+      let enum2;
+      switch (val2) {
+        case "access": {
+          enum2 = 0;
+          break;
+        }
+        case "would-block": {
+          enum2 = 1;
+          break;
+        }
+        case "already": {
+          enum2 = 2;
+          break;
+        }
+        case "bad-descriptor": {
+          enum2 = 3;
+          break;
+        }
+        case "busy": {
+          enum2 = 4;
+          break;
+        }
+        case "deadlock": {
+          enum2 = 5;
+          break;
+        }
+        case "quota": {
+          enum2 = 6;
+          break;
+        }
+        case "exist": {
+          enum2 = 7;
+          break;
+        }
+        case "file-too-large": {
+          enum2 = 8;
+          break;
+        }
+        case "illegal-byte-sequence": {
+          enum2 = 9;
+          break;
+        }
+        case "in-progress": {
+          enum2 = 10;
+          break;
+        }
+        case "interrupted": {
+          enum2 = 11;
+          break;
+        }
+        case "invalid": {
+          enum2 = 12;
+          break;
+        }
+        case "io": {
+          enum2 = 13;
+          break;
+        }
+        case "is-directory": {
+          enum2 = 14;
+          break;
+        }
+        case "loop": {
+          enum2 = 15;
+          break;
+        }
+        case "too-many-links": {
+          enum2 = 16;
+          break;
+        }
+        case "message-size": {
+          enum2 = 17;
+          break;
+        }
+        case "name-too-long": {
+          enum2 = 18;
+          break;
+        }
+        case "no-device": {
+          enum2 = 19;
+          break;
+        }
+        case "no-entry": {
+          enum2 = 20;
+          break;
+        }
+        case "no-lock": {
+          enum2 = 21;
+          break;
+        }
+        case "insufficient-memory": {
+          enum2 = 22;
+          break;
+        }
+        case "insufficient-space": {
+          enum2 = 23;
+          break;
+        }
+        case "not-directory": {
+          enum2 = 24;
+          break;
+        }
+        case "not-empty": {
+          enum2 = 25;
+          break;
+        }
+        case "not-recoverable": {
+          enum2 = 26;
+          break;
+        }
+        case "unsupported": {
+          enum2 = 27;
+          break;
+        }
+        case "no-tty": {
+          enum2 = 28;
+          break;
+        }
+        case "no-such-device": {
+          enum2 = 29;
+          break;
+        }
+        case "overflow": {
+          enum2 = 30;
+          break;
+        }
+        case "not-permitted": {
+          enum2 = 31;
+          break;
+        }
+        case "pipe": {
+          enum2 = 32;
+          break;
+        }
+        case "read-only": {
+          enum2 = 33;
+          break;
+        }
+        case "invalid-seek": {
+          enum2 = 34;
+          break;
+        }
+        case "text-file-busy": {
+          enum2 = 35;
+          break;
+        }
+        case "cross-device": {
+          enum2 = 36;
+          break;
+        }
+        default: {
+          if (e instanceof Error) {
+            console.error(e);
+          }
+          throw new TypeError(`"${val2}" is not one of the cases of error-code`);
+        }
+      }
+      dataView(memory0).setInt8(arg1 + 1, enum2, true);
+    }
+  }
+  function trampoline23(arg0, arg1, arg2) {
+    var handle1 = arg0;
+    var rsc0 = handleTable1.get(handle1).rep;
+    let ret;
+    try {
+      ret = { tag: "ok", val: InputStream2.prototype.read.call(rsc0, BigInt.asUintN(64, arg1)) };
+    } catch (e) {
+      ret = { tag: "err", val: getErrorPayload(e) };
+    }
+    var variant5 = ret;
+    switch (variant5.tag) {
+      case "ok": {
+        const e = variant5.val;
+        dataView(memory0).setInt8(arg2 + 0, 0, true);
+        var val2 = e;
+        var len2 = val2.byteLength;
+        var ptr2 = realloc0(0, 0, 1, len2 * 1);
+        var src2 = new Uint8Array(val2.buffer || val2, val2.byteOffset, len2 * 1);
+        new Uint8Array(memory0.buffer, ptr2, len2 * 1).set(src2);
+        dataView(memory0).setInt32(arg2 + 8, len2, true);
+        dataView(memory0).setInt32(arg2 + 4, ptr2, true);
+        break;
+      }
+      case "err": {
+        const e = variant5.val;
+        dataView(memory0).setInt8(arg2 + 0, 1, true);
+        var variant4 = e;
+        switch (variant4.tag) {
+          case "last-operation-failed": {
+            const e2 = variant4.val;
+            dataView(memory0).setInt8(arg2 + 4, 0, true);
+            if (!(e2 instanceof Error$1)) {
+              throw new Error('Resource error: Not a valid "Error" resource.');
+            }
+            var handle3 = handleCnt0++;
+            handleTable0.set(handle3, { rep: e2, own: true });
+            dataView(memory0).setInt32(arg2 + 8, handle3, true);
+            break;
+          }
+          case "closed": {
+            dataView(memory0).setInt8(arg2 + 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");
+      }
+    }
+  }
+  function trampoline24(arg0, arg1, arg2) {
+    var handle1 = arg0;
+    var rsc0 = handleTable1.get(handle1).rep;
+    let ret;
+    try {
+      ret = { tag: "ok", val: InputStream2.prototype.blockingRead.call(rsc0, BigInt.asUintN(64, arg1)) };
+    } catch (e) {
+      ret = { tag: "err", val: getErrorPayload(e) };
+    }
+    var variant5 = ret;
+    switch (variant5.tag) {
+      case "ok": {
+        const e = variant5.val;
+        dataView(memory0).setInt8(arg2 + 0, 0, true);
+        var val2 = e;
+        var len2 = val2.byteLength;
+        var ptr2 = realloc0(0, 0, 1, len2 * 1);
+        var src2 = new Uint8Array(val2.buffer || val2, val2.byteOffset, len2 * 1);
+        new Uint8Array(memory0.buffer, ptr2, len2 * 1).set(src2);
+        dataView(memory0).setInt32(arg2 + 8, len2, true);
+        dataView(memory0).setInt32(arg2 + 4, ptr2, true);
+        break;
+      }
+      case "err": {
+        const e = variant5.val;
+        dataView(memory0).setInt8(arg2 + 0, 1, true);
+        var variant4 = e;
+        switch (variant4.tag) {
+          case "last-operation-failed": {
+            const e2 = variant4.val;
+            dataView(memory0).setInt8(arg2 + 4, 0, true);
+            if (!(e2 instanceof Error$1)) {
+              throw new Error('Resource error: Not a valid "Error" resource.');
+            }
+            var handle3 = handleCnt0++;
+            handleTable0.set(handle3, { rep: e2, own: true });
+            dataView(memory0).setInt32(arg2 + 8, handle3, true);
+            break;
+          }
+          case "closed": {
+            dataView(memory0).setInt8(arg2 + 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");
+      }
+    }
+  }
+  function trampoline25(arg0, arg1) {
+    var handle1 = arg0;
+    var rsc0 = handleTable2.get(handle1).rep;
+    let ret;
+    try {
+      ret = { tag: "ok", val: OutputStream2.prototype.checkWrite.call(rsc0) };
+    } catch (e) {
+      ret = { tag: "err", val: getErrorPayload(e) };
+    }
+    var variant4 = ret;
+    switch (variant4.tag) {
+      case "ok": {
+        const e = variant4.val;
+        dataView(memory0).setInt8(arg1 + 0, 0, true);
+        dataView(memory0).setBigInt64(arg1 + 8, toUint64(e), true);
+        break;
+      }
+      case "err": {
+        const e = variant4.val;
+        dataView(memory0).setInt8(arg1 + 0, 1, true);
+        var variant3 = e;
+        switch (variant3.tag) {
+          case "last-operation-failed": {
+            const e2 = variant3.val;
+            dataView(memory0).setInt8(arg1 + 8, 0, true);
+            if (!(e2 instanceof Error$1)) {
+              throw new Error('Resource error: Not a valid "Error" resource.');
+            }
+            var handle2 = handleCnt0++;
+            handleTable0.set(handle2, { rep: e2, own: true });
+            dataView(memory0).setInt32(arg1 + 12, handle2, true);
+            break;
+          }
+          case "closed": {
+            dataView(memory0).setInt8(arg1 + 8, 1, true);
+            break;
+          }
+          default: {
+            throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant3.tag)}\` (received \`${variant3}\`) specified for \`StreamError\``);
+          }
+        }
+        break;
+      }
+      default: {
+        throw new TypeError("invalid variant specified for result");
+      }
+    }
+  }
+  function trampoline26(arg0, arg1, arg2, arg3) {
+    var handle1 = arg0;
+    var rsc0 = handleTable2.get(handle1).rep;
+    var ptr2 = arg1;
+    var len2 = arg2;
+    var result2 = new Uint8Array(memory0.buffer.slice(ptr2, ptr2 + len2 * 1));
+    let ret;
+    try {
+      ret = { tag: "ok", val: OutputStream2.prototype.write.call(rsc0, result2) };
+    } catch (e) {
+      ret = { tag: "err", val: getErrorPayload(e) };
+    }
+    var variant5 = ret;
+    switch (variant5.tag) {
+      case "ok": {
+        const e = variant5.val;
+        dataView(memory0).setInt8(arg3 + 0, 0, true);
+        break;
+      }
+      case "err": {
+        const e = variant5.val;
+        dataView(memory0).setInt8(arg3 + 0, 1, true);
+        var variant4 = e;
+        switch (variant4.tag) {
+          case "last-operation-failed": {
+            const e2 = variant4.val;
+            dataView(memory0).setInt8(arg3 + 4, 0, true);
+            if (!(e2 instanceof Error$1)) {
+              throw new Error('Resource error: Not a valid "Error" resource.');
+            }
+            var handle3 = handleCnt0++;
+            handleTable0.set(handle3, { rep: e2, own: true });
+            dataView(memory0).setInt32(arg3 + 8, handle3, true);
+            break;
+          }
+          case "closed": {
+            dataView(memory0).setInt8(arg3 + 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");
+      }
+    }
+  }
+  function trampoline27(arg0, arg1, arg2, arg3) {
+    var handle1 = arg0;
+    var rsc0 = handleTable2.get(handle1).rep;
+    var ptr2 = arg1;
+    var len2 = arg2;
+    var result2 = new Uint8Array(memory0.buffer.slice(ptr2, ptr2 + len2 * 1));
+    let ret;
+    try {
+      ret = { tag: "ok", val: OutputStream2.prototype.blockingWriteAndFlush.call(rsc0, result2) };
+    } catch (e) {
+      ret = { tag: "err", val: getErrorPayload(e) };
+    }
+    var variant5 = ret;
+    switch (variant5.tag) {
+      case "ok": {
+        const e = variant5.val;
+        dataView(memory0).setInt8(arg3 + 0, 0, true);
+        break;
+      }
+      case "err": {
+        const e = variant5.val;
+        dataView(memory0).setInt8(arg3 + 0, 1, true);
+        var variant4 = e;
+        switch (variant4.tag) {
+          case "last-operation-failed": {
+            const e2 = variant4.val;
+            dataView(memory0).setInt8(arg3 + 4, 0, true);
+            if (!(e2 instanceof Error$1)) {
+              throw new Error('Resource error: Not a valid "Error" resource.');
+            }
+            var handle3 = handleCnt0++;
+            handleTable0.set(handle3, { rep: e2, own: true });
+            dataView(memory0).setInt32(arg3 + 8, handle3, true);
+            break;
+          }
+          case "closed": {
+            dataView(memory0).setInt8(arg3 + 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");
+      }
+    }
+  }
+  function trampoline28(arg0, arg1) {
+    var handle1 = arg0;
+    var rsc0 = handleTable2.get(handle1).rep;
+    let ret;
+    try {
+      ret = { tag: "ok", val: OutputStream2.prototype.blockingFlush.call(rsc0) };
+    } catch (e) {
+      ret = { tag: "err", val: getErrorPayload(e) };
+    }
+    var variant4 = ret;
+    switch (variant4.tag) {
+      case "ok": {
+        const e = variant4.val;
+        dataView(memory0).setInt8(arg1 + 0, 0, true);
+        break;
+      }
+      case "err": {
+        const e = variant4.val;
+        dataView(memory0).setInt8(arg1 + 0, 1, true);
+        var variant3 = e;
+        switch (variant3.tag) {
+          case "last-operation-failed": {
+            const e2 = variant3.val;
+            dataView(memory0).setInt8(arg1 + 4, 0, true);
+            if (!(e2 instanceof Error$1)) {
+              throw new Error('Resource error: Not a valid "Error" resource.');
+            }
+            var handle2 = handleCnt0++;
+            handleTable0.set(handle2, { rep: e2, own: true });
+            dataView(memory0).setInt32(arg1 + 8, handle2, true);
+            break;
+          }
+          case "closed": {
+            dataView(memory0).setInt8(arg1 + 4, 1, true);
+            break;
+          }
+          default: {
+            throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant3.tag)}\` (received \`${variant3}\`) specified for \`StreamError\``);
+          }
+        }
+        break;
+      }
+      default: {
+        throw new TypeError("invalid variant specified for result");
+      }
+    }
+  }
+  function trampoline29(arg0, arg1) {
+    const ret = getRandomBytes(BigInt.asUintN(64, arg0));
+    var val0 = ret;
+    var len0 = val0.byteLength;
+    var ptr0 = realloc0(0, 0, 1, len0 * 1);
+    var src0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, len0 * 1);
+    new Uint8Array(memory0.buffer, ptr0, len0 * 1).set(src0);
+    dataView(memory0).setInt32(arg1 + 4, len0, true);
+    dataView(memory0).setInt32(arg1 + 0, ptr0, true);
+  }
+  function trampoline30(arg0) {
+    const ret = getEnvironment();
+    var vec3 = ret;
+    var len3 = vec3.length;
+    var result3 = realloc0(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, realloc0, memory0);
+      var len1 = utf8EncodedLen;
+      dataView(memory0).setInt32(base + 4, len1, true);
+      dataView(memory0).setInt32(base + 0, ptr1, true);
+      var ptr2 = utf8Encode(tuple0_1, realloc0, memory0);
+      var len2 = utf8EncodedLen;
+      dataView(memory0).setInt32(base + 12, len2, true);
+      dataView(memory0).setInt32(base + 8, ptr2, true);
+    }
+    dataView(memory0).setInt32(arg0 + 4, len3, true);
+    dataView(memory0).setInt32(arg0 + 0, result3, true);
+  }
+  function trampoline31(arg0) {
+    const ret = getArguments();
+    var vec1 = ret;
+    var len1 = vec1.length;
+    var result1 = realloc0(0, 0, 4, len1 * 8);
+    for (let i = 0; i < vec1.length; i++) {
+      const e = vec1[i];
+      const base = result1 + i * 8;
+      var ptr0 = utf8Encode(e, realloc0, memory0);
+      var len0 = utf8EncodedLen;
+      dataView(memory0).setInt32(base + 4, len0, true);
+      dataView(memory0).setInt32(base + 0, ptr0, true);
+    }
+    dataView(memory0).setInt32(arg0 + 4, len1, true);
+    dataView(memory0).setInt32(arg0 + 0, result1, true);
+  }
+  function trampoline32(arg0) {
+    const ret = getTerminalStdin();
+    var variant1 = ret;
+    if (variant1 === null || variant1 === void 0) {
+      dataView(memory0).setInt8(arg0 + 0, 0, true);
+    } else {
+      const e = variant1;
+      dataView(memory0).setInt8(arg0 + 0, 1, true);
+      if (!(e instanceof TerminalInput2)) {
+        throw new Error('Resource error: Not a valid "TerminalInput" resource.');
+      }
+      var handle0 = handleCnt3++;
+      handleTable3.set(handle0, { rep: e, own: true });
+      dataView(memory0).setInt32(arg0 + 4, handle0, true);
+    }
+  }
+  function trampoline33(arg0) {
+    const ret = getTerminalStdout();
+    var variant1 = ret;
+    if (variant1 === null || variant1 === void 0) {
+      dataView(memory0).setInt8(arg0 + 0, 0, true);
+    } else {
+      const e = variant1;
+      dataView(memory0).setInt8(arg0 + 0, 1, true);
+      if (!(e instanceof TerminalOutput2)) {
+        throw new Error('Resource error: Not a valid "TerminalOutput" resource.');
+      }
+      var handle0 = handleCnt4++;
+      handleTable4.set(handle0, { rep: e, own: true });
+      dataView(memory0).setInt32(arg0 + 4, handle0, true);
+    }
+  }
+  function trampoline34(arg0) {
+    const ret = getTerminalStderr();
+    var variant1 = ret;
+    if (variant1 === null || variant1 === void 0) {
+      dataView(memory0).setInt8(arg0 + 0, 0, true);
+    } else {
+      const e = variant1;
+      dataView(memory0).setInt8(arg0 + 0, 1, true);
+      if (!(e instanceof TerminalOutput2)) {
+        throw new Error('Resource error: Not a valid "TerminalOutput" resource.');
+      }
+      var handle0 = handleCnt4++;
+      handleTable4.set(handle0, { rep: e, own: true });
+      dataView(memory0).setInt32(arg0 + 4, handle0, true);
+    }
+  }
+  let exports3;
+  function trampoline1(handle) {
+    const handleEntry = handleTable6.get(handle);
+    if (!handleEntry) {
+      throw new Error(`Resource error: Invalid handle ${handle}`);
+    }
+    handleTable6.delete(handle);
+    if (handleEntry.own && handleEntry.rep[symbolDispose]) {
+      handleEntry.rep[symbolDispose]();
+    }
+  }
+  function trampoline2(handle) {
+    const handleEntry = handleTable0.get(handle);
+    if (!handleEntry) {
+      throw new Error(`Resource error: Invalid handle ${handle}`);
+    }
+    handleTable0.delete(handle);
+    if (handleEntry.own && handleEntry.rep[symbolDispose]) {
+      handleEntry.rep[symbolDispose]();
+    }
+  }
+  function trampoline3(handle) {
+    const handleEntry = handleTable1.get(handle);
+    if (!handleEntry) {
+      throw new Error(`Resource error: Invalid handle ${handle}`);
+    }
+    handleTable1.delete(handle);
+    if (handleEntry.own && handleEntry.rep[symbolDispose]) {
+      handleEntry.rep[symbolDispose]();
+    }
+  }
+  function trampoline4(handle) {
+    const handleEntry = handleTable2.get(handle);
+    if (!handleEntry) {
+      throw new Error(`Resource error: Invalid handle ${handle}`);
+    }
+    handleTable2.delete(handle);
+    if (handleEntry.own && handleEntry.rep[symbolDispose]) {
+      handleEntry.rep[symbolDispose]();
+    }
+  }
+  function trampoline5(handle) {
+    const handleEntry = handleTable5.get(handle);
+    if (!handleEntry) {
+      throw new Error(`Resource error: Invalid handle ${handle}`);
+    }
+    handleTable5.delete(handle);
+    if (handleEntry.own && handleEntry.rep[symbolDispose]) {
+      handleEntry.rep[symbolDispose]();
+    }
+  }
+  function trampoline6(handle) {
+    const handleEntry = handleTable4.get(handle);
+    if (!handleEntry) {
+      throw new Error(`Resource error: Invalid handle ${handle}`);
+    }
+    handleTable4.delete(handle);
+    if (handleEntry.own && handleEntry.rep[symbolDispose]) {
+      handleEntry.rep[symbolDispose]();
+    }
+  }
+  function trampoline7(handle) {
+    const handleEntry = handleTable3.get(handle);
+    if (!handleEntry) {
+      throw new Error(`Resource error: Invalid handle ${handle}`);
+    }
+    handleTable3.delete(handle);
+    if (handleEntry.own && handleEntry.rep[symbolDispose]) {
+      handleEntry.rep[symbolDispose]();
+    }
+  }
+  ({ exports: exports0 } = instantiateCore(module2));
+  ({ exports: exports1 } = instantiateCore(module0, {
+    wasi_snapshot_preview1: {
+      args_get: exports0["23"],
+      args_sizes_get: exports0["24"],
+      clock_time_get: exports0["25"],
+      environ_get: exports0["33"],
+      environ_sizes_get: exports0["34"],
+      fd_close: exports0["35"],
+      fd_fdstat_get: exports0["36"],
+      fd_filestat_get: exports0["26"],
+      fd_prestat_dir_name: exports0["38"],
+      fd_prestat_get: exports0["37"],
+      fd_read: exports0["27"],
+      fd_seek: exports0["28"],
+      fd_write: exports0["29"],
+      path_open: exports0["30"],
+      proc_exit: exports0["39"],
+      random_get: exports0["32"],
+      sched_yield: exports0["31"]
+    }
+  }));
+  ({ exports: exports2 } = instantiateCore(module1, {
+    __main_module__: {
+      _start: exports1._start
+    },
+    env: {
+      memory: exports1.memory
+    },
+    "wasi:cli/environment@0.2.0": {
+      "get-arguments": exports0["19"],
+      "get-environment": exports0["18"]
+    },
+    "wasi:cli/exit@0.2.0": {
+      exit: trampoline9
+    },
+    "wasi:cli/stderr@0.2.0": {
+      "get-stderr": trampoline8
+    },
+    "wasi:cli/stdin@0.2.0": {
+      "get-stdin": trampoline10
+    },
+    "wasi:cli/stdout@0.2.0": {
+      "get-stdout": trampoline11
+    },
+    "wasi:cli/terminal-input@0.2.0": {
+      "[resource-drop]terminal-input": trampoline7
+    },
+    "wasi:cli/terminal-output@0.2.0": {
+      "[resource-drop]terminal-output": trampoline6
+    },
+    "wasi:cli/terminal-stderr@0.2.0": {
+      "get-terminal-stderr": exports0["22"]
+    },
+    "wasi:cli/terminal-stdin@0.2.0": {
+      "get-terminal-stdin": exports0["20"]
+    },
+    "wasi:cli/terminal-stdout@0.2.0": {
+      "get-terminal-stdout": exports0["21"]
+    },
+    "wasi:clocks/monotonic-clock@0.2.0": {
+      now: trampoline0
+    },
+    "wasi:clocks/wall-clock@0.2.0": {
+      now: exports0["1"]
+    },
+    "wasi:filesystem/preopens@0.2.0": {
+      "get-directories": exports0["0"]
+    },
+    "wasi:filesystem/types@0.2.0": {
+      "[method]descriptor.append-via-stream": exports0["4"],
+      "[method]descriptor.get-flags": exports0["5"],
+      "[method]descriptor.get-type": exports0["6"],
+      "[method]descriptor.metadata-hash": exports0["9"],
+      "[method]descriptor.open-at": exports0["8"],
+      "[method]descriptor.read-via-stream": exports0["2"],
+      "[method]descriptor.stat": exports0["7"],
+      "[method]descriptor.write-via-stream": exports0["3"],
+      "[resource-drop]descriptor": trampoline5,
+      "[resource-drop]directory-entry-stream": trampoline1,
+      "filesystem-error-code": exports0["10"]
+    },
+    "wasi:io/error@0.2.0": {
+      "[resource-drop]error": trampoline2
+    },
+    "wasi:io/streams@0.2.0": {
+      "[method]input-stream.blocking-read": exports0["12"],
+      "[method]input-stream.read": exports0["11"],
+      "[method]output-stream.blocking-flush": exports0["16"],
+      "[method]output-stream.blocking-write-and-flush": exports0["15"],
+      "[method]output-stream.check-write": exports0["13"],
+      "[method]output-stream.write": exports0["14"],
+      "[resource-drop]input-stream": trampoline3,
+      "[resource-drop]output-stream": trampoline4
+    },
+    "wasi:random/random@0.2.0": {
+      "get-random-bytes": exports0["17"]
+    }
+  }));
+  memory0 = exports1.memory;
+  realloc0 = exports2.cabi_import_realloc;
+  ({ exports: exports3 } = instantiateCore(module3, {
+    "": {
+      $imports: exports0.$imports,
+      "0": trampoline12,
+      "1": trampoline13,
+      "10": trampoline22,
+      "11": trampoline23,
+      "12": trampoline24,
+      "13": trampoline25,
+      "14": trampoline26,
+      "15": trampoline27,
+      "16": trampoline28,
+      "17": trampoline29,
+      "18": trampoline30,
+      "19": trampoline31,
+      "2": trampoline14,
+      "20": trampoline32,
+      "21": trampoline33,
+      "22": trampoline34,
+      "23": exports2.args_get,
+      "24": exports2.args_sizes_get,
+      "25": exports2.clock_time_get,
+      "26": exports2.fd_filestat_get,
+      "27": exports2.fd_read,
+      "28": exports2.fd_seek,
+      "29": exports2.fd_write,
+      "3": trampoline15,
+      "30": exports2.path_open,
+      "31": exports2.sched_yield,
+      "32": exports2.random_get,
+      "33": exports2.environ_get,
+      "34": exports2.environ_sizes_get,
+      "35": exports2.fd_close,
+      "36": exports2.fd_fdstat_get,
+      "37": exports2.fd_prestat_get,
+      "38": exports2.fd_prestat_dir_name,
+      "39": exports2.proc_exit,
+      "4": trampoline16,
+      "5": trampoline17,
+      "6": trampoline18,
+      "7": trampoline19,
+      "8": trampoline20,
+      "9": trampoline21
+    }
+  }));
+  function run() {
+    const ret = exports2["wasi:cli/run@0.2.0#run"]();
+    let variant0;
+    switch (ret) {
+      case 0: {
+        variant0 = {
+          tag: "ok",
+          val: void 0
+        };
+        break;
+      }
+      case 1: {
+        variant0 = {
+          tag: "err",
+          val: void 0
+        };
+        break;
+      }
+      default: {
+        throw new TypeError("invalid variant discriminant for expected");
+      }
+    }
+    if (variant0.tag === "err") {
+      throw new ComponentError(variant0.val);
+    }
+    return variant0.val;
+  }
+  const handleTable0 = /* @__PURE__ */ new Map();
+  let handleCnt0 = 0;
+  const handleTable1 = /* @__PURE__ */ new Map();
+  let handleCnt1 = 0;
+  const handleTable2 = /* @__PURE__ */ new Map();
+  let handleCnt2 = 0;
+  const handleTable3 = /* @__PURE__ */ new Map();
+  let handleCnt3 = 0;
+  const handleTable4 = /* @__PURE__ */ new Map();
+  let handleCnt4 = 0;
+  const handleTable5 = /* @__PURE__ */ new Map();
+  let handleCnt5 = 0;
+  const handleTable6 = /* @__PURE__ */ new Map();
+  let handleCnt6 = 0;
+  const run0_2_0 = {
+    run
+  };
+  return { run: run0_2_0, "wasi:cli/run@0.2.0": run0_2_0 };
+}
+
+// lib/api.js
+var spade = new Application(() => import("./resources-spade.js"), instantiate, "yowasp-spade");
+var runSpade = spade.run.bind(spade);
+var commands = { "spade": runSpade };
+export {
+  Exit,
+  commands,
+  runSpade
+};