ziex 0.0.1-dev.7 → 0.1.0-dev.1014

package/index.js

@@ -1,31 +1,939 @@
-// src/index.ts
-var zx = {
-  name: "zx",
-  version: "0.0.1-dev.270",
-  description: "ZX is a framework for building web applications with Zig.",
-  repository: "https://github.com/nurulhudaapon/zx",
-  fingerprint: 14616285862371232000,
-  minimum_zig_version: "0.15.2",
-  dependencies: {
-    httpz: {
-      url: "git+https://github.com/nurulhudaapon/httpz.git#7268154f43f5827bf78668e8e79a00f2ebe4db13",
-      hash: "httpz-0.0.0-PNVzrBgtBwCVkSJyophIX6WHwDR0r8XhBGQr96Kk-1El"
-    },
-    zli: {
-      url: "git+https://github.com/nurulhudaapon/cliz.git#aff3b54879e7514afaf8c87f1abe22121b8992d4",
-      hash: "zli-4.3.0-LeUjpu_fAABOSVASSCW2fFh8SFVNHrxQGDXGPNzcSE_i"
-    },
-    zig_js: {
-      url: "git+https://github.com/nurulhudaapon/jsz.git#04db83c617da1956ac5adc1cb9ba1e434c1cb6fd",
-      hash: "zig_js-0.0.0-rjCAV-6GAADxFug7rDmPH-uM_XcnJ5NmuAMJCAscMjhi"
-    }
-  },
-  paths: [
-    "build.zig",
-    "build.zig.zon",
-    "src"
-  ]
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
 };
+
+// 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 isSyncKVNamespace(binding) {
+  const candidate = binding;
+  return typeof candidate.getSync === "function" && typeof candidate.putSync === "function" && typeof candidate.deleteSync === "function" && typeof candidate.listSync === "function";
+}
+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") {
+    let syncBinding = function(ns) {
+      const candidate = binding(ns);
+      return candidate && isSyncKVNamespace(candidate) ? candidate : null;
+    };
+    return {
+      kv_get: (ns_ptr, ns_len, key_ptr, key_len, buf_ptr, buf_max) => {
+        const b = syncBinding(readStr(ns_ptr, ns_len));
+        if (!b)
+          return -1;
+        const value = b.getSync(readStr(key_ptr, key_len));
+        if (value === null)
+          return -1;
+        return writeBytes(buf_ptr, buf_max, encoder2.encode(value));
+      },
+      kv_put: (ns_ptr, ns_len, key_ptr, key_len, val_ptr, val_len) => {
+        const b = syncBinding(readStr(ns_ptr, ns_len));
+        if (!b)
+          return 0;
+        b.putSync(readStr(key_ptr, key_len), readStr(val_ptr, val_len));
+        return 0;
+      },
+      kv_delete: (ns_ptr, ns_len, key_ptr, key_len) => {
+        const b = syncBinding(readStr(ns_ptr, ns_len));
+        if (!b)
+          return 0;
+        b.deleteSync(readStr(key_ptr, key_len));
+        return 0;
+      },
+      kv_list: (ns_ptr, ns_len, pfx_ptr, pfx_len, buf_ptr, buf_max) => {
+        const b = syncBinding(readStr(ns_ptr, ns_len));
+        if (!b)
+          return writeBytes(buf_ptr, buf_max, encoder2.encode("[]"));
+        const prefix = readStr(pfx_ptr, pfx_len);
+        const result = b.listSync(prefix.length > 0 ? { prefix } : undefined);
+        return writeBytes(buf_ptr, buf_max, encoder2.encode(JSON.stringify(result.keys.map((k) => k.name))));
+      }
+    };
+  }
+  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/db.ts
+function decodeBlob(base64) {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0;i < binary.length; i++)
+    bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+function toD1Value(value) {
+  switch (value.kind) {
+    case "null":
+      return null;
+    case "integer":
+      return value.integer;
+    case "float":
+      return value.float;
+    case "text":
+      return value.text;
+    case "blob":
+      return decodeBlob(value.blob);
+    case "boolean":
+      return value.boolean;
+  }
+}
+function toPositionalBindings(json) {
+  switch (json.kind) {
+    case "none":
+      return [];
+    case "positional":
+      return json.values.map(toD1Value);
+    case "named":
+      throw new Error("Cloudflare D1 adapter does not support named bindings yet");
+  }
+}
+function toWireValue(value) {
+  if (value === null || value === undefined)
+    return { kind: "null" };
+  if (typeof value === "string")
+    return { kind: "text", text: value };
+  if (typeof value === "boolean")
+    return { kind: "boolean", boolean: value };
+  if (typeof value === "number") {
+    return Number.isInteger(value) ? { kind: "integer", integer: value } : { kind: "float", float: value };
+  }
+  if (value instanceof ArrayBuffer) {
+    const bytes = new Uint8Array(value);
+    let binary = "";
+    for (const byte of bytes)
+      binary += String.fromCharCode(byte);
+    return { kind: "blob", blob: btoa(binary) };
+  }
+  if (ArrayBuffer.isView(value)) {
+    const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    let binary = "";
+    for (const byte of bytes)
+      binary += String.fromCharCode(byte);
+    return { kind: "blob", blob: btoa(binary) };
+  }
+  return { kind: "text", text: String(value) };
+}
+function objectToWireRow(record) {
+  return {
+    fields: Object.entries(record).map(([name, value]) => ({
+      name,
+      value: toWireValue(value)
+    }))
+  };
+}
+function valuesToWireRows(rows) {
+  return rows.map((row) => row.map((value) => toWireValue(value)));
+}
+function createD1Imports(bindings, getMemory) {
+  const encoder2 = new TextEncoder;
+  const decoder2 = new TextDecoder;
+  function readStr(ptr, len) {
+    return decoder2.decode(new Uint8Array(getMemory().buffer, ptr, len));
+  }
+  function writeJson(buf_ptr, buf_max, value) {
+    const data = encoder2.encode(JSON.stringify(value));
+    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;
+  }
+  async function statement(ns_ptr, ns_len, sql_ptr, sql_len, bindings_ptr, bindings_len) {
+    const database = binding(readStr(ns_ptr, ns_len));
+    if (!database)
+      return null;
+    const sql = readStr(sql_ptr, sql_len);
+    const bindingsJson = JSON.parse(readStr(bindings_ptr, bindings_len));
+    return database.prepare(sql).bind(...toPositionalBindings(bindingsJson));
+  }
+  const Suspending = WebAssembly.Suspending;
+  if (typeof Suspending !== "function") {
+    return {
+      db_open: (_ns, _ns_len) => -1,
+      db_run: (_a, _b, _c, _d, _e, _f, _g, _h) => -1,
+      db_get: (_a, _b, _c, _d, _e, _f, _g, _h) => -1,
+      db_all: (_a, _b, _c, _d, _e, _f, _g, _h) => -1,
+      db_values: (_a, _b, _c, _d, _e, _f, _g, _h) => -1
+    };
+  }
+  return {
+    db_open: (ns_ptr, ns_len) => binding(readStr(ns_ptr, ns_len)) ? 0 : -1,
+    db_run: new Suspending(async (ns_ptr, ns_len, sql_ptr, sql_len, bindings_ptr, bindings_len, buf_ptr, buf_max) => {
+      const stmt = await statement(ns_ptr, ns_len, sql_ptr, sql_len, bindings_ptr, bindings_len);
+      if (!stmt)
+        return -1;
+      const result = await stmt.run();
+      return writeJson(buf_ptr, buf_max, {
+        last_insert_rowid: result.meta?.last_row_id ?? 0,
+        changes: result.meta?.changes ?? 0
+      });
+    }),
+    db_get: new Suspending(async (ns_ptr, ns_len, sql_ptr, sql_len, bindings_ptr, bindings_len, buf_ptr, buf_max) => {
+      const stmt = await statement(ns_ptr, ns_len, sql_ptr, sql_len, bindings_ptr, bindings_len);
+      if (!stmt)
+        return -1;
+      const row = await stmt.first();
+      if (!row)
+        return 0;
+      return writeJson(buf_ptr, buf_max, [objectToWireRow(row)]);
+    }),
+    db_all: new Suspending(async (ns_ptr, ns_len, sql_ptr, sql_len, bindings_ptr, bindings_len, buf_ptr, buf_max) => {
+      const stmt = await statement(ns_ptr, ns_len, sql_ptr, sql_len, bindings_ptr, bindings_len);
+      if (!stmt)
+        return -1;
+      const result = await stmt.all();
+      return writeJson(buf_ptr, buf_max, (result.results ?? []).map(objectToWireRow));
+    }),
+    db_values: new Suspending(async (ns_ptr, ns_len, sql_ptr, sql_len, bindings_ptr, bindings_len, buf_ptr, buf_max) => {
+      const stmt = await statement(ns_ptr, ns_len, sql_ptr, sql_len, bindings_ptr, bindings_len);
+      if (!stmt)
+        return -1;
+      const rows = await stmt.raw();
+      return writeJson(buf_ptr, buf_max, valuesToWireRows(rows));
+    })
+  };
+}
+
+// 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,
+  db: dbBindings,
+  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),
+    __zx_db: createD1Imports(dbBindings ?? {}, 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: earlyStderrText } = collectOutput();
+  const earlyMeta = parseEdgeMeta(earlyStderrText);
+  if (earlyMeta.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: earlyMeta.status, headers: earlyMeta.headers });
+  }
+  await wasmPromise;
+  const { stderrText } = collectOutput();
+  const meta = parseEdgeMeta(stderrText);
+  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] };
+  }
+  resolveDB(env) {
+    const { db } = this.options;
+    if (db === undefined)
+      return;
+    if (typeof db === "object" && db !== null) {
+      const result = {};
+      for (const [name, key] of Object.entries(db)) {
+        result[name] = env[key];
+      }
+      return result;
+    }
+    return { default: env[db] };
+  }
+  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),
+      db: this.resolveDB(env),
+      websocket: websocket !== undefined ? env[websocket] : undefined
+    });
+  };
+}
 export {
-  zx
+  Ziex
 };