@ziex/cli 0.1.0-dev.865 → 0.1.0-test.1

package/index.js

@@ -1,739 +0,0 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-
-// src/runtime.ts
-var exports_runtime = {};
-__export(exports_runtime, {
-  run: () => run,
-  buildWsImports: () => buildWsImports,
-  attachWebSocket: () => attachWebSocket
-});
-
-// src/wasm/wasi.ts
-var decoder = new TextDecoder;
-var encoder = new TextEncoder;
-
-class ZxWasiBridge {
-  #alloc;
-  #fetchCompleteHandler;
-  #memory;
-  #cb;
-  #intervals = new Map;
-  #memView = null;
-  #memBuf = null;
-  constructor(exports) {
-    this.#memory = exports.memory;
-    this.#alloc = exports.__zx_alloc;
-    this.#fetchCompleteHandler = exports.__zx_fetch_complete;
-    this.#cb = exports.__zx_cb;
-  }
-  #view() {
-    const buf = this.#memory.buffer;
-    if (buf !== this.#memBuf) {
-      this.#memBuf = buf;
-      this.#memView = new Uint8Array(buf);
-    }
-    return this.#memView;
-  }
-  #readString(ptr, len) {
-    return decoder.decode(this.#view().subarray(ptr, ptr + len));
-  }
-  #writeBytes(ptr, data) {
-    this.#view().set(data, ptr);
-  }
-  log(level, ptr, len) {
-    const msg = decoder.decode(this.#view().subarray(ptr, ptr + len));
-    switch (level) {
-      case 0:
-        console.error(msg);
-        break;
-      case 1:
-        console.warn(msg);
-        break;
-      case 3:
-        console.debug(msg);
-        break;
-      default:
-        console.log(msg);
-        break;
-    }
-  }
-  fetchAsync(urlPtr, urlLen, methodPtr, methodLen, headersPtr, headersLen, bodyPtr, bodyLen, timeoutMs, fetchId) {
-    const url = this.#readString(urlPtr, urlLen);
-    const method = methodLen > 0 ? this.#readString(methodPtr, methodLen) : "GET";
-    const headersJson = headersLen > 0 ? this.#readString(headersPtr, headersLen) : "{}";
-    const body = bodyLen > 0 ? this.#readString(bodyPtr, bodyLen) : undefined;
-    let headers = {};
-    try {
-      headers = JSON.parse(headersJson);
-    } catch {
-      for (const line of headersJson.split(`
-`)) {
-        const i = line.indexOf(":");
-        if (i > 0)
-          headers[line.slice(0, i)] = line.slice(i + 1);
-      }
-    }
-    const controller = new AbortController;
-    const timeout = timeoutMs > 0 ? setTimeout(() => controller.abort(), timeoutMs) : null;
-    fetch(url, {
-      method,
-      headers: Object.keys(headers).length > 0 ? headers : undefined,
-      body: method !== "GET" && method !== "HEAD" ? body : undefined,
-      signal: controller.signal
-    }).then(async (res) => {
-      if (timeout)
-        clearTimeout(timeout);
-      this.#notifyFetchComplete(fetchId, res.status, await res.text(), false);
-    }).catch((err) => {
-      if (timeout)
-        clearTimeout(timeout);
-      const msg = err.name === "AbortError" ? "Request timeout" : err.message ?? "Fetch failed";
-      this.#notifyFetchComplete(fetchId, 0, msg, true);
-    });
-  }
-  #notifyFetchComplete(fetchId, status, body, isError) {
-    const encoded = encoder.encode(body);
-    const ptr = this.#alloc(encoded.length);
-    this.#writeBytes(ptr, encoded);
-    this.#fetchCompleteHandler(fetchId, status, ptr, encoded.length, isError ? 1 : 0);
-  }
-  setTimeout(callbackId, delayMs) {
-    setTimeout(() => this.#cb?.(3, callbackId, 0n), delayMs);
-  }
-  setInterval(callbackId, intervalMs) {
-    const handle = setInterval(() => this.#cb?.(4, callbackId, 0n), intervalMs);
-    this.#intervals.set(callbackId, handle);
-  }
-  clearInterval(callbackId) {
-    const handle = this.#intervals.get(callbackId);
-    if (handle !== undefined) {
-      clearInterval(handle);
-      this.#intervals.delete(callbackId);
-    }
-  }
-  static createImportObject(bridgeRef) {
-    return {
-      __zx: {
-        _log: (level, ptr, len) => {
-          bridgeRef.current?.log(level, ptr, len);
-        },
-        _fetchAsync: (urlPtr, urlLen, methodPtr, methodLen, headersPtr, headersLen, bodyPtr, bodyLen, timeoutMs, fetchId) => {
-          bridgeRef.current?.fetchAsync(urlPtr, urlLen, methodPtr, methodLen, headersPtr, headersLen, bodyPtr, bodyLen, timeoutMs, fetchId);
-        },
-        _setTimeout: (callbackId, delayMs) => {
-          bridgeRef.current?.setTimeout(callbackId, delayMs);
-        },
-        _setInterval: (callbackId, intervalMs) => {
-          bridgeRef.current?.setInterval(callbackId, intervalMs);
-        },
-        _clearInterval: (callbackId) => {
-          bridgeRef.current?.clearInterval(callbackId);
-        }
-      }
-    };
-  }
-}
-
-// src/kv.ts
-var exports_kv = {};
-__export(exports_kv, {
-  createMemoryKV: () => createMemoryKV,
-  createKVImports: () => createKVImports
-});
-function createMemoryKV() {
-  const store = new Map;
-  return {
-    async get(key) {
-      return store.get(key) ?? null;
-    },
-    async put(key, value) {
-      store.set(key, value);
-    },
-    async delete(key) {
-      store.delete(key);
-    },
-    async list(options) {
-      const keys = [...store.keys()].filter((k) => !options?.prefix || k.startsWith(options.prefix)).map((name) => ({ name }));
-      return { keys };
-    }
-  };
-}
-function createKVImports(bindings, getMemory) {
-  const encoder2 = new TextEncoder;
-  const decoder2 = new TextDecoder;
-  function readStr(ptr, len) {
-    return decoder2.decode(new Uint8Array(getMemory().buffer, ptr, len));
-  }
-  function writeBytes(buf_ptr, buf_max, data) {
-    if (data.length > buf_max)
-      return -2;
-    new Uint8Array(getMemory().buffer, buf_ptr, data.length).set(data);
-    return data.length;
-  }
-  function binding(ns) {
-    return bindings[ns] ?? bindings["default"] ?? null;
-  }
-  const Suspending = WebAssembly.Suspending;
-  if (typeof Suspending !== "function") {
-    return {
-      kv_get: (_ns, _nsLen, _key, _keyLen, _buf, _max) => -1,
-      kv_put: (_ns, _nsLen, _key, _keyLen, _val, _valLen) => 0,
-      kv_delete: (_ns, _nsLen, _key, _keyLen) => 0,
-      kv_list: (_ns, _nsLen, _pfx, _pfxLen, buf_ptr, buf_max) => writeBytes(buf_ptr, buf_max, encoder2.encode("[]"))
-    };
-  }
-  return {
-    kv_get: new Suspending(async (ns_ptr, ns_len, key_ptr, key_len, buf_ptr, buf_max) => {
-      const b = binding(readStr(ns_ptr, ns_len));
-      if (!b)
-        return -1;
-      const value = await b.get(readStr(key_ptr, key_len));
-      if (value === null)
-        return -1;
-      return writeBytes(buf_ptr, buf_max, encoder2.encode(value));
-    }),
-    kv_put: new Suspending(async (ns_ptr, ns_len, key_ptr, key_len, val_ptr, val_len) => {
-      const b = binding(readStr(ns_ptr, ns_len));
-      if (!b)
-        return -1;
-      await b.put(readStr(key_ptr, key_len), readStr(val_ptr, val_len));
-      return 0;
-    }),
-    kv_delete: new Suspending(async (ns_ptr, ns_len, key_ptr, key_len) => {
-      const b = binding(readStr(ns_ptr, ns_len));
-      if (!b)
-        return -1;
-      await b.delete(readStr(key_ptr, key_len));
-      return 0;
-    }),
-    kv_list: new Suspending(async (ns_ptr, ns_len, prefix_ptr, prefix_len, buf_ptr, buf_max) => {
-      const b = binding(readStr(ns_ptr, ns_len));
-      if (!b)
-        return writeBytes(buf_ptr, buf_max, encoder2.encode("[]"));
-      const prefix = readStr(prefix_ptr, prefix_len);
-      const result = await b.list(prefix.length > 0 ? { prefix } : undefined);
-      return writeBytes(buf_ptr, buf_max, encoder2.encode(JSON.stringify(result.keys.map((k) => k.name))));
-    })
-  };
-}
-
-// src/wasi.ts
-class ProcExit extends Error {
-  code;
-  constructor(code) {
-    super(`proc_exit(${code})`);
-    this.code = code;
-  }
-}
-function createWasiImports({
-  request,
-  stdinData,
-  onStdout
-}) {
-  const encoder2 = new TextEncoder;
-  const url = new URL(request.url);
-  const argStrings = [
-    "wasm",
-    "--pathname",
-    url.pathname,
-    "--method",
-    request.method,
-    "--search",
-    url.search
-  ];
-  request.headers.forEach((value, name) => {
-    if (value)
-      argStrings.push("--header", `${name}:${value}`);
-  });
-  const encodedArgs = argStrings.map((a) => encoder2.encode(a + "\x00"));
-  const argBufSize = encodedArgs.reduce((s, a) => s + a.length, 0);
-  let wasmMemory = null;
-  const setMemory = (m2) => {
-    wasmMemory = m2;
-  };
-  const stdoutChunks = [];
-  let stderrMeta = "";
-  let stderrPartial = "";
-  const stderrDecoder = new TextDecoder("utf-8", { fatal: false, ignoreBOM: true });
-  function processStderrChunk(chunk) {
-    const text = stderrDecoder.decode(chunk, { stream: true });
-    const lines = (stderrPartial + text).split(`
-`);
-    stderrPartial = lines.pop() ?? "";
-    for (const line of lines) {
-      if (line.startsWith("__EDGE_META__:")) {
-        stderrMeta += line + `
-`;
-      } else if (line.length > 0) {
-        console.error("[ziex]", line);
-      }
-    }
-  }
-  let stdinOffset = 0;
-  function v() {
-    return new DataView(wasmMemory.buffer);
-  }
-  function m() {
-    return new Uint8Array(wasmMemory.buffer);
-  }
-  const wasiImport = {
-    args_sizes_get(argc_ptr, argv_buf_size_ptr) {
-      v().setUint32(argc_ptr, encodedArgs.length, true);
-      v().setUint32(argv_buf_size_ptr, argBufSize, true);
-      return 0;
-    },
-    args_get(argv_ptr, argv_buf_ptr) {
-      const dv = v();
-      const mem = m();
-      let offset = argv_buf_ptr;
-      for (const arg of encodedArgs) {
-        dv.setUint32(argv_ptr, offset, true);
-        mem.set(arg, offset);
-        argv_ptr += 4;
-        offset += arg.length;
-      }
-      return 0;
-    },
-    environ_sizes_get(count_ptr, buf_size_ptr) {
-      v().setUint32(count_ptr, 0, true);
-      v().setUint32(buf_size_ptr, 0, true);
-      return 0;
-    },
-    environ_get(_environ_ptr, _environ_buf_ptr) {
-      return 0;
-    },
-    fd_write(fd, iovs_ptr, iovs_len, nwritten_ptr) {
-      const dv = v();
-      const mem = m();
-      let written = 0;
-      for (let i = 0;i < iovs_len; i++) {
-        const buf_ptr = dv.getUint32(iovs_ptr + i * 8, true);
-        const buf_len = dv.getUint32(iovs_ptr + i * 8 + 4, true);
-        const chunk = mem.slice(buf_ptr, buf_ptr + buf_len);
-        if (fd === 1) {
-          if (onStdout)
-            onStdout(chunk);
-          else
-            stdoutChunks.push(chunk);
-        } else if (fd === 2)
-          processStderrChunk(chunk);
-        written += buf_len;
-      }
-      dv.setUint32(nwritten_ptr, written, true);
-      return 0;
-    },
-    fd_read(fd, iovs_ptr, iovs_len, nread_ptr) {
-      const dv = v();
-      const mem = m();
-      const stdin = stdinData ?? new Uint8Array(0);
-      let totalRead = 0;
-      for (let i = 0;i < iovs_len; i++) {
-        const buf_ptr = dv.getUint32(iovs_ptr + i * 8, true);
-        const buf_len = dv.getUint32(iovs_ptr + i * 8 + 4, true);
-        if (fd === 0 && stdinOffset < stdin.length) {
-          const toRead = Math.min(buf_len, stdin.length - stdinOffset);
-          mem.set(stdin.subarray(stdinOffset, stdinOffset + toRead), buf_ptr);
-          stdinOffset += toRead;
-          totalRead += toRead;
-        }
-      }
-      dv.setUint32(nread_ptr, totalRead, true);
-      return 0;
-    },
-    fd_fdstat_get(_fd, fdstat_ptr) {
-      const dv = v();
-      dv.setUint8(fdstat_ptr, 2);
-      dv.setUint8(fdstat_ptr + 1, 0);
-      dv.setUint16(fdstat_ptr + 2, 0, true);
-      dv.setUint32(fdstat_ptr + 4, 0, true);
-      dv.setBigUint64(fdstat_ptr + 8, 0n, true);
-      dv.setBigUint64(fdstat_ptr + 16, 0n, true);
-      return 0;
-    },
-    fd_prestat_get(_fd, _bufptr) {
-      return 8;
-    },
-    fd_prestat_dir_name(_fd, _path, _path_len) {
-      return 8;
-    },
-    fd_close(_fd) {
-      return 0;
-    },
-    fd_pread(_fd, _iovs, _iovs_len, _offset, nread_ptr) {
-      v().setUint32(nread_ptr, 0, true);
-      return 0;
-    },
-    fd_pwrite(_fd, _iovs, _iovs_len, _offset, nwritten_ptr) {
-      v().setUint32(nwritten_ptr, 0, true);
-      return 0;
-    },
-    fd_filestat_get(_fd, filestat_ptr) {
-      const dv = v();
-      dv.setBigUint64(filestat_ptr, 0n, true);
-      dv.setBigUint64(filestat_ptr + 8, 0n, true);
-      dv.setUint8(filestat_ptr + 16, 2);
-      dv.setBigUint64(filestat_ptr + 24, 1n, true);
-      dv.setBigUint64(filestat_ptr + 32, 0n, true);
-      dv.setBigUint64(filestat_ptr + 40, 0n, true);
-      dv.setBigUint64(filestat_ptr + 48, 0n, true);
-      dv.setBigUint64(filestat_ptr + 56, 0n, true);
-      return 0;
-    },
-    fd_seek(_fd, _offset, _whence, newoffset_ptr) {
-      v().setBigInt64(newoffset_ptr, 0n, true);
-      return 0;
-    },
-    proc_exit(code) {
-      throw new ProcExit(code);
-    },
-    sched_yield() {
-      return 0;
-    },
-    clock_time_get(_id, _precision, time_ptr) {
-      v().setBigUint64(time_ptr, BigInt(Date.now()) * 1000000n, true);
-      return 0;
-    },
-    random_get(buf_ptr, buf_len) {
-      crypto.getRandomValues(new Uint8Array(wasmMemory.buffer, buf_ptr, buf_len));
-      return 0;
-    },
-    path_open(_fd, _dirflags, _path, _path_len, _oflags, _rights_base, _rights_inheriting, _fdflags, opened_fd_ptr) {
-      v().setInt32(opened_fd_ptr, -1, true);
-      return 76;
-    },
-    path_create_directory(_fd, _path, _path_len) {
-      return 76;
-    },
-    path_unlink_file(_fd, _path, _path_len) {
-      return 76;
-    },
-    path_remove_directory(_fd, _path, _path_len) {
-      return 76;
-    },
-    path_rename(_fd, _old_path, _old_path_len, _new_fd, _new_path, _new_path_len) {
-      return 76;
-    },
-    path_filestat_get(_fd, _flags, _path, _path_len, filestat_ptr) {
-      new Uint8Array(wasmMemory.buffer, filestat_ptr, 64).fill(0);
-      return 76;
-    },
-    path_readlink(_fd, _path, _path_len, _buf, _buf_len, nread_ptr) {
-      v().setUint32(nread_ptr, 0, true);
-      return 76;
-    },
-    fd_readdir(_fd, _buf, _buf_len, _cookie, bufused_ptr) {
-      v().setUint32(bufused_ptr, 0, true);
-      return 76;
-    },
-    poll_oneoff(_in, _out, _nsubscriptions, nevents_ptr) {
-      v().setUint32(nevents_ptr, 0, true);
-      return 0;
-    }
-  };
-  function collectOutput() {
-    const remaining = stderrDecoder.decode(undefined, { stream: false });
-    const tail = stderrPartial + remaining;
-    if (tail.length > 0) {
-      if (tail.startsWith("__EDGE_META__:"))
-        stderrMeta += tail;
-      else
-        console.error("[ziex]", tail);
-      stderrPartial = "";
-    }
-    return {
-      stdout: mergeUint8Arrays(stdoutChunks),
-      stderrText: stderrMeta
-    };
-  }
-  return { wasiImport, setMemory, collectOutput };
-}
-function mergeUint8Arrays(arrays) {
-  const totalLen = arrays.reduce((sum, arr) => sum + arr.length, 0);
-  const result = new Uint8Array(totalLen);
-  let offset = 0;
-  for (const arr of arrays) {
-    result.set(arr, offset);
-    offset += arr.length;
-  }
-  return result;
-}
-
-// src/runtime.ts
-function buildWsImports(Suspending, mem, decoder2, ws) {
-  const readStr = (ptr, len) => decoder2.decode(new Uint8Array(mem().buffer, ptr, len));
-  return {
-    ws_upgrade: () => {
-      ws.upgraded = true;
-    },
-    ws_write: (ptr, len) => {
-      const data = new Uint8Array(mem().buffer, ptr, len).slice();
-      if (!ws.server) {
-        ws.pendingWrites.push(data);
-      } else {
-        ws.server.send(data);
-      }
-    },
-    ws_close: (code, reason_ptr, reason_len) => {
-      ws.server?.close(code, decoder2.decode(new Uint8Array(mem().buffer, reason_ptr, reason_len)));
-    },
-    ws_recv: Suspending ? new Suspending(async (buf_ptr, buf_max) => {
-      if (ws._resolveFirstSuspend) {
-        const fn = ws._resolveFirstSuspend;
-        ws._resolveFirstSuspend = undefined;
-        fn();
-      }
-      const deliver = (bytes) => {
-        if (bytes === null)
-          return -1;
-        const n = Math.min(bytes.length, buf_max);
-        new Uint8Array(mem().buffer, buf_ptr, n).set(bytes.subarray(0, n));
-        return n;
-      };
-      if (ws.messageQueue.length > 0)
-        return deliver(ws.messageQueue.shift());
-      return new Promise((resolve) => {
-        ws.recvResolve = (bytes) => resolve(deliver(bytes));
-      });
-    }) : (_buf_ptr, _buf_max) => -1,
-    ws_subscribe: (ptr, len) => {
-      ws.subscribe?.(readStr(ptr, len));
-    },
-    ws_unsubscribe: (ptr, len) => {
-      ws.unsubscribe?.(readStr(ptr, len));
-    },
-    ws_publish: (topic_ptr, topic_len, data_ptr, data_len) => {
-      const topic = readStr(topic_ptr, topic_len);
-      const data = new Uint8Array(mem().buffer, data_ptr, data_len).slice();
-      return ws.publish?.(topic, data) ?? 0;
-    },
-    ws_is_subscribed: (ptr, len) => ws.isSubscribed?.(readStr(ptr, len)) ? 1 : 0
-  };
-}
-function attachWebSocket(ws) {
-  const WebSocketPairCtor = globalThis.WebSocketPair;
-  const pair = new WebSocketPairCtor;
-  const client = pair[0];
-  const server = pair[1];
-  ws.server = server;
-  server.accept();
-  for (const data of ws.pendingWrites)
-    server.send(data);
-  ws.pendingWrites = [];
-  server.addEventListener("message", (event) => {
-    const data = typeof event.data === "string" ? new TextEncoder().encode(event.data) : new Uint8Array(event.data);
-    if (ws.recvResolve) {
-      const res = ws.recvResolve;
-      ws.recvResolve = null;
-      res(data);
-    } else {
-      ws.messageQueue.push(data);
-    }
-  });
-  server.addEventListener("close", () => {
-    if (ws.recvResolve) {
-      const res = ws.recvResolve;
-      ws.recvResolve = null;
-      res(null);
-    }
-  });
-  return { client };
-}
-function buildSysImports(jspi, Suspending) {
-  return {
-    sleep_ms: jspi ? new Suspending(async (ms) => new Promise((r) => setTimeout(r, ms))) : (_ms) => {}
-  };
-}
-function executeWasm(instance, jspi, Suspending, wsState) {
-  if (!jspi) {
-    try {
-      instance.exports._start();
-    } catch (e) {
-      if (!(e instanceof ProcExit))
-        throw e;
-    }
-    return Promise.resolve();
-  }
-  const start = WebAssembly.promising(instance.exports._start);
-  return start().catch((e) => {
-    if (e instanceof Error && e.message.startsWith("proc_exit"))
-      return;
-    throw e;
-  }).finally(() => {
-    if (wsState.recvResolve) {
-      const res = wsState.recvResolve;
-      wsState.recvResolve = null;
-      res(null);
-    }
-  });
-}
-function parseEdgeMeta(stderrText) {
-  const meta = { status: 200, headers: new Headers, streaming: false };
-  const metaPrefix = "__EDGE_META__:";
-  const metaLine = stderrText.split(`
-`).find((line) => line.startsWith(metaPrefix));
-  if (metaLine) {
-    try {
-      const parsed = JSON.parse(metaLine.slice(metaPrefix.length));
-      if (parsed.status)
-        meta.status = parsed.status;
-      if (parsed.streaming === true)
-        meta.streaming = true;
-      if (Array.isArray(parsed.headers)) {
-        for (const [name, value] of parsed.headers) {
-          meta.headers.append(name, value);
-        }
-      }
-    } catch {}
-  }
-  return meta;
-}
-async function run({
-  request,
-  env,
-  ctx,
-  module,
-  kv: kvBindings,
-  imports,
-  wasi,
-  websocket: doNamespace
-}) {
-  if (doNamespace && request.headers.get("upgrade")?.toLowerCase() === "websocket") {
-    const id = doNamespace.idFromName(new URL(request.url).pathname);
-    return doNamespace.get(id).fetch(request);
-  }
-  const stdinData = request.body ? new Uint8Array(await request.arrayBuffer()) : undefined;
-  const stdoutChunks = [];
-  let streamWriter = null;
-  const { wasiImport, setMemory, collectOutput } = createWasiImports({
-    request,
-    stdinData,
-    onStdout: (chunk) => {
-      if (streamWriter)
-        streamWriter.write(chunk);
-      else
-        stdoutChunks.push(chunk);
-    }
-  });
-  let wasmMemory = null;
-  const mem = () => wasmMemory;
-  const bridgeRef = { current: null };
-  const Suspending = WebAssembly.Suspending;
-  const jspi = typeof Suspending === "function";
-  const wsState = {
-    upgraded: false,
-    server: null,
-    pendingWrites: [],
-    messageQueue: [],
-    recvResolve: null
-  };
-  const instance = new WebAssembly.Instance(module, {
-    wasi_snapshot_preview1: { ...wasi?.wasiImport, ...wasiImport },
-    __zx_sys: buildSysImports(jspi, Suspending),
-    __zx_ws: buildWsImports(jspi ? Suspending : null, mem, new TextDecoder, wsState),
-    __zx_kv: createKVImports(kvBindings ?? { default: createMemoryKV() }, mem),
-    ...imports ? imports(mem) : {},
-    ...ZxWasiBridge.createImportObject(bridgeRef)
-  });
-  wasmMemory = instance.exports.memory;
-  setMemory(wasmMemory);
-  bridgeRef.current = new ZxWasiBridge(instance.exports);
-  const wasmPromise = executeWasm(instance, jspi, Suspending, wsState);
-  if (wsState.upgraded) {
-    const server = attachWebSocket(wsState);
-    ctx?.waitUntil(wasmPromise);
-    return new Response(null, { status: 101, webSocket: server.client });
-  }
-  const { stderrText } = collectOutput();
-  const meta = parseEdgeMeta(stderrText);
-  if (meta.streaming) {
-    const { readable, writable } = new TransformStream;
-    streamWriter = writable.getWriter();
-    for (const chunk of stdoutChunks)
-      streamWriter.write(chunk);
-    stdoutChunks.length = 0;
-    wasmPromise.finally(() => streamWriter?.close());
-    return new Response(readable, { status: meta.status, headers: meta.headers });
-  }
-  await wasmPromise;
-  const body = mergeUint8Arrays(stdoutChunks);
-  meta.headers.delete("transfer-encoding");
-  if (!meta.headers.has("content-length"))
-    meta.headers.set("content-length", String(body.byteLength));
-  return new Response(body.buffer, { status: meta.status, headers: meta.headers });
-}
-
-// src/app.ts
-async function resolveModule(input) {
-  if (typeof input === "string") {
-    if (input.startsWith("http://") || input.startsWith("https://")) {
-      return WebAssembly.compileStreaming(fetch(input));
-    }
-    const url = input.startsWith("/") ? `file://${input}` : input;
-    return WebAssembly.compile(await fetch(url).then((r) => r.arrayBuffer()));
-  }
-  if (input instanceof URL) {
-    return WebAssembly.compileStreaming(fetch(input));
-  }
-  if (input instanceof Response) {
-    return WebAssembly.compileStreaming(input);
-  }
-  if (input instanceof ArrayBuffer) {
-    return WebAssembly.compile(input);
-  }
-  if (ArrayBuffer.isView(input)) {
-    return WebAssembly.compile(input.buffer);
-  }
-  return input;
-}
-
-class Ziex {
-  options;
-  resolved = null;
-  constructor(options) {
-    this.options = options;
-  }
-  async getModule() {
-    if (!this.resolved)
-      this.resolved = await resolveModule(this.options.module);
-    return this.resolved;
-  }
-  resolveKV(env) {
-    const { kv } = this.options;
-    if (kv === undefined)
-      return;
-    if (typeof kv === "object" && kv !== null) {
-      const result = {};
-      for (const [name, key] of Object.entries(kv)) {
-        result[name] = env[key];
-      }
-      return result;
-    }
-    return { default: env[kv] };
-  }
-  fetch = async (request, env, ctx) => {
-    const module = await this.getModule();
-    const { wasi, imports, websocket } = this.options;
-    return run({
-      request,
-      env,
-      ctx,
-      module,
-      wasi,
-      imports,
-      kv: this.resolveKV(env),
-      websocket: websocket !== undefined ? env[websocket] : undefined
-    });
-  };
-}
-export {
-  Ziex
-};