ziex 0.1.0-dev.786 → 0.1.0-dev.804

package/cloudflare/index.js

@@ -9,26 +9,1042 @@ var __export = (target, all) => {
     });
 };
 
-// src/cloudflare/worker.ts
-var exports_worker = {};
-__export(exports_worker, {
+// ../../vendor/jsz/js/src/zigjs.ts
+var NAN_PREFIX = 2146959360;
+var predefined = {
+  nan: 0,
+  null: 1,
+  true: 2,
+  false: 3,
+  undefined: 4,
+  globalThis: 5,
+  runtime: 6
+};
+var PREDEFINED_ID_MAX = 6;
+var encoder = new TextEncoder;
+var decoder = new TextDecoder("utf-8");
+
+class ZigJS {
+  memory;
+  values = [NaN, null, true, false, undefined, globalThis, this];
+  idPool = [];
+  importObject() {
+    return {
+      "zig-js": {
+        valueGet: this.valueGet.bind(this),
+        valueSet: this.valueSet.bind(this),
+        valueDeinit: this.valueDeinit.bind(this),
+        valueObjectCreate: this.valueObjectCreate.bind(this),
+        valueStringCreate: this.valueStringCreate.bind(this),
+        valueStringLen: this.valueStringLen.bind(this),
+        valueStringCopy: this.valueStringCopy.bind(this),
+        valueNew: this.valueNew.bind(this),
+        funcApply: this.funcApply.bind(this)
+      }
+    };
+  }
+  valueGet(out, id, ptr, len) {
+    const val = this.loadValue(id);
+    const str = this.loadString(ptr, len);
+    const result = Reflect.get(val, str);
+    this.storeValue(out, result);
+  }
+  valueSet(id, ptr, len, refAddr) {
+    const obj = this.loadValue(id);
+    const str = this.loadString(ptr, len);
+    const val = this.loadRef(refAddr);
+    Reflect.set(obj, str, val);
+  }
+  valueDeinit(id) {
+    if (id > PREDEFINED_ID_MAX) {
+      this.values[id] = null;
+      this.idPool.push(id);
+    }
+  }
+  valueObjectCreate(out) {
+    this.storeValue(out, new Object);
+  }
+  valueStringCreate(out, ptr, len) {
+    const str = this.loadString(ptr, len);
+    this.storeValue(out, str);
+  }
+  valueStringLen(id) {
+    const val = this.loadValue(id);
+    const buf = encoder.encode(val);
+    return buf.byteLength;
+  }
+  valueStringCopy(id, ptr, max) {
+    if (this.memory == null)
+      return;
+    const val = this.loadValue(id);
+    const bytes = encoder.encode(val);
+    if (bytes.byteLength > max)
+      return;
+    new Uint8Array(this.memory.buffer, ptr, bytes.length).set(bytes);
+  }
+  valueNew(out, id, argsAddr, argsLen) {
+    const fn = this.loadValue(id);
+    const args = [];
+    for (let i = 0;i < argsLen; i++) {
+      args.push(this.loadRef(argsAddr + i * 8));
+    }
+    const result = Reflect.construct(fn, args);
+    this.storeValue(out, result);
+  }
+  funcApply(out, id, thisRefAddr, argsAddr, argsLen) {
+    const fn = this.loadValue(id);
+    const thisVal = this.loadRef(thisRefAddr);
+    const args = [];
+    for (let i = 0;i < argsLen; i++) {
+      args.push(this.loadRef(argsAddr + i * 8));
+    }
+    const result = Reflect.apply(fn, thisVal, args);
+    this.storeValue(out, result);
+  }
+  loadValue(id) {
+    return this.values[id];
+  }
+  deleteValue(id) {
+    const val = this.values[id];
+    this.valueDeinit(id);
+    return val;
+  }
+  loadRef(refAddr) {
+    if (this.memory == null)
+      return;
+    const view = new DataView(this.memory.buffer);
+    const floatVal = view.getFloat64(refAddr, true);
+    if (!isNaN(floatVal))
+      return floatVal;
+    const id = this.loadRefId(refAddr);
+    return this.values[id];
+  }
+  loadRefId(refAddr) {
+    if (this.memory == null)
+      return 0;
+    return new DataView(this.memory.buffer).getUint32(refAddr, true);
+  }
+  storeValue(out, val) {
+    if (this.memory == null)
+      return;
+    const view = new DataView(this.memory.buffer);
+    if (typeof val === "number") {
+      if (isNaN(val)) {
+        view.setUint32(out, predefined.nan, true);
+        view.setUint32(out + 4, NAN_PREFIX, true);
+      } else {
+        view.setFloat64(out, val, true);
+      }
+      return;
+    }
+    if (val === null) {
+      view.setUint32(out, predefined.null, true);
+      view.setUint32(out + 4, NAN_PREFIX, true);
+      return;
+    }
+    if (val === undefined) {
+      view.setUint32(out, predefined.undefined, true);
+      view.setUint32(out + 4, NAN_PREFIX, true);
+      return;
+    }
+    let id = this.idPool.pop();
+    if (id === undefined) {
+      id = this.values.length;
+    }
+    this.values[id] = val;
+    let typeId = 0;
+    switch (typeof val) {
+      case "object":
+        typeId = 1;
+        break;
+      case "string":
+        typeId = 2;
+        break;
+      case "symbol":
+        typeId = 3;
+        break;
+      case "function":
+        typeId = 4;
+        break;
+    }
+    view.setUint32(out, Number(id), true);
+    view.setUint32(out + 4, NAN_PREFIX | typeId, true);
+  }
+  loadString(ptr, len) {
+    if (this.memory == null)
+      return "";
+    const arr = new Uint8ClampedArray(this.memory.buffer, ptr, Number(len));
+    const data = arr.slice();
+    return decoder.decode(data);
+  }
+}
+// src/wasm/core.ts
+var CallbackType = {
+  Event: 0,
+  FetchSuccess: 1,
+  FetchError: 2,
+  Timeout: 3,
+  Interval: 4,
+  WebSocketOpen: 5,
+  WebSocketMessage: 6,
+  WebSocketError: 7,
+  WebSocketClose: 8
+};
+var jsz = new ZigJS;
+var tempRefBuffer = new ArrayBuffer(8);
+var tempRefView = new DataView(tempRefBuffer);
+function storeValueGetRef(val) {
+  const originalMemory = jsz.memory;
+  jsz.memory = { buffer: tempRefBuffer };
+  jsz.storeValue(0, val);
+  jsz.memory = originalMemory;
+  return tempRefView.getBigUint64(0, true);
+}
+var textDecoder = new TextDecoder;
+var textEncoder = new TextEncoder;
+var memoryView = null;
+var memoryBuffer = null;
+function getMemoryView() {
+  const buf = jsz.memory.buffer;
+  if (buf !== memoryBuffer) {
+    memoryBuffer = buf;
+    memoryView = new Uint8Array(buf);
+  }
+  return memoryView;
+}
+var stringCache = new Map;
+function stringCacheKey(ptr, len) {
+  return ptr * 65536 + len;
+}
+function readString(ptr, len) {
+  const key = stringCacheKey(ptr, len);
+  const cached = stringCache.get(key);
+  if (cached !== undefined)
+    return cached;
+  const str = textDecoder.decode(getMemoryView().subarray(ptr, ptr + len));
+  stringCache.set(key, str);
+  return str;
+}
+function writeBytes(ptr, data) {
+  getMemoryView().set(data, ptr);
+}
+
+class ZxBridgeCore {
+  #intervals = new Map;
+  _alloc;
+  #handler;
+  #fetchCompleteHandler;
+  constructor(exports) {
+    this._alloc = exports.__zx_alloc;
+    this.#handler = exports.__zx_cb;
+    this.#fetchCompleteHandler = exports.__zx_fetch_complete;
+    if (exports.memory)
+      jsz.memory = exports.memory;
+  }
+  #invoke(type, id, data) {
+    const handler = this.#handler;
+    if (!handler) {
+      console.warn("__zx_cb not exported from WASM");
+      return;
+    }
+    const dataRef = storeValueGetRef(data);
+    handler(type, id, dataRef);
+  }
+  fetchAsync(urlPtr, urlLen, methodPtr, methodLen, headersPtr, headersLen, bodyPtr, bodyLen, timeoutMs, fetchId) {
+    const url = readString(urlPtr, urlLen);
+    const method = methodLen > 0 ? readString(methodPtr, methodLen) : "GET";
+    const headersJson = headersLen > 0 ? readString(headersPtr, headersLen) : "{}";
+    const body = bodyLen > 0 ? readString(bodyPtr, bodyLen) : undefined;
+    let headers = {};
+    try {
+      headers = JSON.parse(headersJson);
+    } catch {
+      for (const line of headersJson.split(`
+`)) {
+        const colonIdx = line.indexOf(":");
+        if (colonIdx > 0) {
+          headers[line.slice(0, colonIdx)] = line.slice(colonIdx + 1);
+        }
+      }
+    }
+    const controller = new AbortController;
+    const timeout = timeoutMs > 0 ? setTimeout(() => controller.abort(), timeoutMs) : null;
+    const fetchOptions = {
+      method,
+      headers: Object.keys(headers).length > 0 ? headers : undefined,
+      body: method !== "GET" && method !== "HEAD" ? body : undefined,
+      signal: controller.signal
+    };
+    fetch(url, fetchOptions).then(async (response) => {
+      if (timeout)
+        clearTimeout(timeout);
+      const text = await response.text();
+      this._notifyFetchComplete(fetchId, response.status, text, false);
+    }).catch((error) => {
+      if (timeout)
+        clearTimeout(timeout);
+      const isAbort = error.name === "AbortError";
+      const errorMsg = isAbort ? "Request timeout" : error.message ?? "Fetch failed";
+      this._notifyFetchComplete(fetchId, 0, errorMsg, true);
+    });
+  }
+  _notifyFetchComplete(fetchId, statusCode, body, isError) {
+    const handler = this.#fetchCompleteHandler;
+    const encoded = textEncoder.encode(body);
+    const ptr = this._alloc(encoded.length);
+    writeBytes(ptr, encoded);
+    handler(fetchId, statusCode, ptr, encoded.length, isError ? 1 : 0);
+  }
+  setTimeout(callbackId, delayMs) {
+    setTimeout(() => {
+      this.#invoke(CallbackType.Timeout, callbackId, null);
+    }, delayMs);
+  }
+  setInterval(callbackId, intervalMs) {
+    const handle = setInterval(() => {
+      this.#invoke(CallbackType.Interval, callbackId, null);
+    }, intervalMs);
+    this.#intervals.set(callbackId, handle);
+  }
+  clearInterval(callbackId) {
+    const handle = this.#intervals.get(callbackId);
+    if (handle !== undefined) {
+      clearInterval(handle);
+      this.#intervals.delete(callbackId);
+    }
+  }
+  _writeStringToWasm(str) {
+    return this._writeBytesToWasm(textEncoder.encode(str));
+  }
+  _writeBytesToWasm(data) {
+    const ptr = this._alloc(data.length);
+    writeBytes(ptr, data);
+    return { ptr, len: data.length };
+  }
+  static log(level, ptr, len) {
+    const msg = textDecoder.decode(getMemoryView().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;
+    }
+  }
+  static createImportObject(bridgeRef) {
+    return {
+      ...jsz.importObject(),
+      __zx: {
+        _log: (level, ptr, len) => ZxBridgeCore.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/wasm/index.ts
+class ZxBridge extends ZxBridgeCore {
+  #websockets = new Map;
+  #wsOnOpenHandler;
+  #wsOnMessageHandler;
+  #wsOnErrorHandler;
+  #wsOnCloseHandler;
+  #eventbridge;
+  constructor(exports) {
+    super(exports);
+    this.#wsOnOpenHandler = exports.__zx_ws_onopen;
+    this.#wsOnMessageHandler = exports.__zx_ws_onmessage;
+    this.#wsOnErrorHandler = exports.__zx_ws_onerror;
+    this.#wsOnCloseHandler = exports.__zx_ws_onclose;
+    this.#eventbridge = exports.__zx_eventbridge;
+  }
+  submitFormActionAsync(form, statesJson, fetchId) {
+    const formData = new FormData(form);
+    formData.append("__zx_states", statesJson);
+    fetch(window.location.href, {
+      method: "POST",
+      headers: { "X-ZX-Action": "1" },
+      body: formData
+    }).then(async (response) => {
+      const text = await response.text();
+      this._notifyFetchComplete(fetchId, response.status, text, false);
+    }).catch((error) => {
+      const msg = error instanceof Error ? error.message : "Fetch failed";
+      this._notifyFetchComplete(fetchId, 0, msg, true);
+    });
+  }
+  wsConnect(wsId, urlPtr, urlLen, protocolsPtr, protocolsLen) {
+    const url = readString(urlPtr, urlLen);
+    const protocolsStr = protocolsLen > 0 ? readString(protocolsPtr, protocolsLen) : "";
+    const protocols = protocolsStr ? protocolsStr.split(",").map((p) => p.trim()).filter(Boolean) : undefined;
+    try {
+      const ws = protocols && protocols.length > 0 ? new WebSocket(url, protocols) : new WebSocket(url);
+      ws.binaryType = "arraybuffer";
+      ws.onopen = () => {
+        const handler = this.#wsOnOpenHandler;
+        if (!handler)
+          return;
+        const protocol = ws.protocol || "";
+        const { ptr, len } = this._writeStringToWasm(protocol);
+        handler(wsId, ptr, len);
+      };
+      ws.onmessage = (event) => {
+        const handler = this.#wsOnMessageHandler;
+        if (!handler)
+          return;
+        const isBinary = event.data instanceof ArrayBuffer;
+        const data = isBinary ? new Uint8Array(event.data) : textEncoder.encode(event.data);
+        const { ptr, len } = this._writeBytesToWasm(data);
+        handler(wsId, ptr, len, isBinary ? 1 : 0);
+      };
+      ws.onerror = (_event) => {
+        const handler = this.#wsOnErrorHandler;
+        if (!handler)
+          return;
+        const { ptr, len } = this._writeStringToWasm("WebSocket error");
+        handler(wsId, ptr, len);
+      };
+      ws.onclose = (event) => {
+        const handler = this.#wsOnCloseHandler;
+        if (!handler)
+          return;
+        const reason = event.reason || "";
+        const { ptr, len } = this._writeStringToWasm(reason);
+        handler(wsId, event.code, ptr, len, event.wasClean ? 1 : 0);
+        this.#websockets.delete(wsId);
+      };
+      this.#websockets.set(wsId, ws);
+    } catch (error) {
+      const handler = this.#wsOnErrorHandler;
+      if (handler) {
+        const msg = error instanceof Error ? error.message : "WebSocket connection failed";
+        const { ptr, len } = this._writeStringToWasm(msg);
+        handler(wsId, ptr, len);
+      }
+    }
+  }
+  wsSend(wsId, dataPtr, dataLen, isBinary) {
+    const ws = this.#websockets.get(wsId);
+    if (!ws || ws.readyState !== WebSocket.OPEN)
+      return;
+    const memory = getMemoryView();
+    if (isBinary) {
+      ws.send(memory.slice(dataPtr, dataPtr + dataLen));
+    } else {
+      ws.send(textDecoder.decode(memory.subarray(dataPtr, dataPtr + dataLen)));
+    }
+  }
+  wsClose(wsId, code, reasonPtr, reasonLen) {
+    const ws = this.#websockets.get(wsId);
+    if (!ws)
+      return;
+    const reason = reasonLen > 0 ? readString(reasonPtr, reasonLen) : undefined;
+    try {
+      if (reason)
+        ws.close(code, reason);
+      else
+        ws.close(code);
+    } catch {
+      ws.close();
+    }
+  }
+  eventbridge(velementId, eventTypeId, event) {
+    if (!this.#eventbridge)
+      return;
+    const eventRef = storeValueGetRef(event);
+    this.#eventbridge(velementId, eventTypeId, eventRef);
+  }
+  static createImportObject(bridgeRef) {
+    return {
+      ...jsz.importObject(),
+      __zx: {
+        _log: (level, ptr, len) => ZxBridgeCore.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);
+        },
+        _wsConnect: (wsId, urlPtr, urlLen, protocolsPtr, protocolsLen) => {
+          bridgeRef.current?.wsConnect(wsId, urlPtr, urlLen, protocolsPtr, protocolsLen);
+        },
+        _wsSend: (wsId, dataPtr, dataLen, isBinary) => {
+          bridgeRef.current?.wsSend(wsId, dataPtr, dataLen, isBinary);
+        },
+        _wsClose: (wsId, code, reasonPtr, reasonLen) => {
+          bridgeRef.current?.wsClose(wsId, code, reasonPtr, reasonLen);
+        },
+        _ce: (id, vnodeId) => {
+          const tagName = TAG_NAMES[id];
+          const el = id >= SVG_TAG_START_INDEX ? document.createElementNS("http://www.w3.org/2000/svg", tagName) : document.createElement(tagName);
+          el.__zx_ref = Number(vnodeId);
+          domNodes.set(vnodeId, el);
+          return storeValueGetRef(el);
+        },
+        _ct: (ptr, len, vnodeId) => {
+          const text = readString(ptr, len);
+          const node = document.createTextNode(text);
+          node.__zx_ref = Number(vnodeId);
+          domNodes.set(vnodeId, node);
+          return storeValueGetRef(node);
+        },
+        _sa: (vnodeId, namePtr, nameLen, valPtr, valLen) => {
+          domNodes.get(vnodeId)?.setAttribute(readString(namePtr, nameLen), readString(valPtr, valLen));
+        },
+        _ra: (vnodeId, namePtr, nameLen) => {
+          domNodes.get(vnodeId)?.removeAttribute(readString(namePtr, nameLen));
+        },
+        _snv: (vnodeId, ptr, len) => {
+          const node = domNodes.get(vnodeId);
+          if (node)
+            node.nodeValue = readString(ptr, len);
+        },
+        _ac: (parentId, childId) => {
+          const parent = domNodes.get(parentId);
+          const child = domNodes.get(childId);
+          if (parent && child)
+            parent.appendChild(child);
+        },
+        _ib: (parentId, childId, refId) => {
+          const parent = domNodes.get(parentId);
+          const child = domNodes.get(childId);
+          const ref = domNodes.get(refId) ?? null;
+          if (parent && child)
+            parent.insertBefore(child, ref);
+        },
+        _rc: (parentId, childId) => {
+          const parent = domNodes.get(parentId);
+          const child = domNodes.get(childId);
+          if (parent && child) {
+            parent.removeChild(child);
+            cleanupDomNodes(child);
+          }
+        },
+        _rpc: (parentId, newId, oldId) => {
+          const parent = domNodes.get(parentId);
+          const newChild = domNodes.get(newId);
+          const oldChild = domNodes.get(oldId);
+          if (parent && newChild && oldChild) {
+            parent.replaceChild(newChild, oldChild);
+            cleanupDomNodes(oldChild);
+          }
+        },
+        _getLocationHref: (bufPtr, bufLen) => {
+          const bytes = textEncoder.encode(window.location.href);
+          const len = Math.min(bytes.length, bufLen);
+          writeBytes(bufPtr, bytes.subarray(0, len));
+          return len;
+        },
+        _getFormData: (vnodeId, bufPtr, bufLen) => {
+          const form = domNodes.get(vnodeId);
+          if (!form || !(form instanceof HTMLFormElement))
+            return 0;
+          const formData = new FormData(form);
+          const urlEncoded = new URLSearchParams(formData).toString();
+          const bytes = textEncoder.encode(urlEncoded);
+          const len = Math.min(bytes.length, bufLen);
+          writeBytes(bufPtr, bytes.subarray(0, len));
+          return len;
+        },
+        _submitFormAction: (vnodeId) => {
+          const form = domNodes.get(vnodeId);
+          if (!form || !(form instanceof HTMLFormElement))
+            return;
+          const formData = new FormData(form);
+          fetch(window.location.href, {
+            method: "POST",
+            headers: { "X-ZX-Action": "1" },
+            body: formData
+          }).catch(() => {});
+        },
+        _submitFormActionAsync: (vnodeId, statesPtr, statesLen, fetchId) => {
+          const form = domNodes.get(vnodeId);
+          if (!form || !(form instanceof HTMLFormElement))
+            return;
+          const statesJson = statesLen > 0 ? readString(statesPtr, statesLen) : "[]";
+          bridgeRef.current?.submitFormActionAsync(form, statesJson, fetchId);
+        }
+      }
+    };
+  }
+}
+var domNodes = new Map;
+function cleanupDomNodes(node) {
+  const ref = node.__zx_ref;
+  if (ref !== undefined)
+    domNodes.delete(BigInt(ref));
+  const children = node.childNodes;
+  for (let i = 0;i < children.length; i++)
+    cleanupDomNodes(children[i]);
+}
+var SVG_TAG_START_INDEX = 140;
+var TAG_NAMES = [
+  "aside",
+  "fragment",
+  "iframe",
+  "slot",
+  "img",
+  "html",
+  "base",
+  "head",
+  "link",
+  "meta",
+  "script",
+  "style",
+  "title",
+  "address",
+  "article",
+  "body",
+  "h1",
+  "h6",
+  "footer",
+  "header",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "hgroup",
+  "nav",
+  "section",
+  "dd",
+  "dl",
+  "dt",
+  "div",
+  "figcaption",
+  "figure",
+  "hr",
+  "li",
+  "ol",
+  "ul",
+  "menu",
+  "main",
+  "p",
+  "picture",
+  "pre",
+  "a",
+  "abbr",
+  "b",
+  "bdi",
+  "bdo",
+  "br",
+  "cite",
+  "code",
+  "data",
+  "time",
+  "dfn",
+  "em",
+  "i",
+  "kbd",
+  "mark",
+  "q",
+  "blockquote",
+  "rp",
+  "ruby",
+  "rt",
+  "rtc",
+  "rb",
+  "s",
+  "del",
+  "ins",
+  "samp",
+  "small",
+  "span",
+  "strong",
+  "sub",
+  "sup",
+  "u",
+  "var",
+  "wbr",
+  "area",
+  "map",
+  "audio",
+  "source",
+  "track",
+  "video",
+  "embed",
+  "object",
+  "param",
+  "canvas",
+  "noscript",
+  "caption",
+  "table",
+  "col",
+  "colgroup",
+  "tbody",
+  "tr",
+  "thead",
+  "tfoot",
+  "td",
+  "th",
+  "button",
+  "datalist",
+  "option",
+  "fieldset",
+  "label",
+  "form",
+  "input",
+  "keygen",
+  "legend",
+  "meter",
+  "optgroup",
+  "select",
+  "output",
+  "progress",
+  "textarea",
+  "details",
+  "dialog",
+  "menuitem",
+  "summary",
+  "content",
+  "element",
+  "shadow",
+  "template",
+  "acronym",
+  "applet",
+  "basefont",
+  "font",
+  "big",
+  "blink",
+  "center",
+  "command",
+  "dir",
+  "frame",
+  "frameset",
+  "isindex",
+  "listing",
+  "marquee",
+  "noembed",
+  "plaintext",
+  "spacer",
+  "strike",
+  "tt",
+  "xmp",
+  "animate",
+  "animateMotion",
+  "animateTransform",
+  "circle",
+  "clipPath",
+  "defs",
+  "desc",
+  "ellipse",
+  "feBlend",
+  "feColorMatrix",
+  "feComponentTransfer",
+  "feComposite",
+  "feConvolveMatrix",
+  "feDiffuseLighting",
+  "feDisplacementMap",
+  "feDistantLight",
+  "feDropShadow",
+  "feFlood",
+  "feFuncA",
+  "feFuncB",
+  "feFuncG",
+  "feFuncR",
+  "feGaussianBlur",
+  "feImage",
+  "feMerge",
+  "feMergeNode",
+  "feMorphology",
+  "feOffset",
+  "fePointLight",
+  "feSpecularLighting",
+  "feSpotLight",
+  "feTile",
+  "feTurbulence",
+  "filter",
+  "foreignObject",
+  "g",
+  "image",
+  "line",
+  "linearGradient",
+  "marker",
+  "mask",
+  "metadata",
+  "mpath",
+  "path",
+  "pattern",
+  "polygon",
+  "polyline",
+  "radialGradient",
+  "rect",
+  "set",
+  "stop",
+  "svg",
+  "switch",
+  "symbol",
+  "text",
+  "textPath",
+  "tspan",
+  "use",
+  "view"
+];
+var DELEGATED_EVENTS = [
+  "click",
+  "dblclick",
+  "input",
+  "change",
+  "submit",
+  "focus",
+  "blur",
+  "keydown",
+  "keyup",
+  "keypress",
+  "mouseenter",
+  "mouseleave",
+  "mousedown",
+  "mouseup",
+  "mousemove",
+  "touchstart",
+  "touchend",
+  "touchmove",
+  "scroll"
+];
+var EVENT_TYPE_MAP = {
+  click: 0,
+  dblclick: 1,
+  input: 2,
+  change: 3,
+  submit: 4,
+  focus: 5,
+  blur: 6,
+  keydown: 7,
+  keyup: 8,
+  keypress: 9,
+  mouseenter: 10,
+  mouseleave: 11,
+  mousedown: 12,
+  mouseup: 13,
+  mousemove: 14,
+  touchstart: 15,
+  touchend: 16,
+  touchmove: 17,
+  scroll: 18
+};
+function initEventDelegation(bridge, rootSelector = "body") {
+  const root = document.querySelector(rootSelector);
+  if (!root)
+    return;
+  for (const eventType of DELEGATED_EVENTS) {
+    root.addEventListener(eventType, (event) => {
+      let target = event.target;
+      while (target && target !== document.body) {
+        const zxRef = target.__zx_ref;
+        if (zxRef !== undefined) {
+          bridge.eventbridge(BigInt(zxRef), EVENT_TYPE_MAP[eventType] ?? 0, event);
+          if (event.cancelBubble)
+            break;
+        }
+        target = target.parentElement;
+      }
+    }, { passive: eventType.startsWith("touch") || eventType === "scroll" });
+  }
+}
+var DEFAULT_URL = "/assets/main.wasm";
+async function init(options = {}) {
+  const url = options.url ?? DEFAULT_URL;
+  const bridgeRef = { current: null };
+  const importObject = Object.assign({}, ZxBridge.createImportObject(bridgeRef), options.importObject);
+  const source = await WebAssembly.instantiateStreaming(fetch(url), importObject);
+  const { instance } = source;
+  jsz.memory = instance.exports.memory;
+  const bridge = new ZxBridge(instance.exports);
+  bridgeRef.current = bridge;
+  initEventDelegation(bridge, options.eventDelegationRoot ?? "body");
+  const main = instance.exports.mainClient;
+  if (typeof main === "function")
+    main();
+  return { source, bridge };
+}
+
+// src/runtime.ts
+var exports_runtime = {};
+__export(exports_runtime, {
   run: () => run,
-  respond: () => respond,
-  prepare: () => prepare
+  buildWsImports: () => buildWsImports,
+  attachWebSocket: () => attachWebSocket
 });
 
-// src/cloudflare/kv.ts
+// src/wasm/wasi.ts
+var decoder2 = new TextDecoder;
+var encoder2 = 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 decoder2.decode(this.#view().subarray(ptr, ptr + len));
+  }
+  #writeBytes(ptr, data) {
+    this.#view().set(data, ptr);
+  }
+  log(level, ptr, len) {
+    const msg = decoder2.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 = encoder2.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 encoder = new TextEncoder;
-  const decoder = new TextDecoder;
+  const encoder3 = new TextEncoder;
+  const decoder3 = new TextDecoder;
   function readStr(ptr, len) {
-    return decoder.decode(new Uint8Array(getMemory().buffer, ptr, len));
+    return decoder3.decode(new Uint8Array(getMemory().buffer, ptr, len));
   }
-  function writeBytes(buf_ptr, buf_max, data) {
+  function writeBytes2(buf_ptr, buf_max, data) {
     if (data.length > buf_max)
       return -2;
     new Uint8Array(getMemory().buffer, buf_ptr, data.length).set(data);
@@ -38,6 +1054,14 @@ function createKVImports(bindings, getMemory) {
     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) => writeBytes2(buf_ptr, buf_max, encoder3.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));
@@ -46,7 +1070,7 @@ function createKVImports(bindings, getMemory) {
       const value = await b.get(readStr(key_ptr, key_len));
       if (value === null)
         return -1;
-      return writeBytes(buf_ptr, buf_max, encoder.encode(value));
+      return writeBytes2(buf_ptr, buf_max, encoder3.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));
@@ -65,15 +1089,15 @@ function createKVImports(bindings, getMemory) {
     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, encoder.encode("[]"));
+        return writeBytes2(buf_ptr, buf_max, encoder3.encode("[]"));
       const prefix = readStr(prefix_ptr, prefix_len);
       const result = await b.list(prefix.length > 0 ? { prefix } : undefined);
-      return writeBytes(buf_ptr, buf_max, encoder.encode(JSON.stringify(result.keys.map((k) => k.name))));
+      return writeBytes2(buf_ptr, buf_max, encoder3.encode(JSON.stringify(result.keys.map((k) => k.name))));
     })
   };
 }
 
-// src/cloudflare/worker.ts
+// src/wasi.ts
 class ProcExit extends Error {
   code;
   constructor(code) {
@@ -83,10 +1107,10 @@ class ProcExit extends Error {
 }
 function createWasiImports({
   request,
-  stdinData
+  stdinData,
+  onStdout
 }) {
-  const encoder = new TextEncoder;
-  const decoder = new TextDecoder;
+  const encoder3 = new TextEncoder;
   const url = new URL(request.url);
   const argStrings = [
     "wasm",
@@ -97,19 +1121,34 @@ function createWasiImports({
     "--search",
     url.search
   ];
-  for (const name of FORWARDED_HEADERS) {
-    const value = request.headers.get(name);
+  request.headers.forEach((value, name) => {
     if (value)
       argStrings.push("--header", `${name}:${value}`);
-  }
-  const encodedArgs = argStrings.map((a) => encoder.encode(a + "\x00"));
+  });
+  const encodedArgs = argStrings.map((a) => encoder3.encode(a + "\x00"));
   const argBufSize = encodedArgs.reduce((s, a) => s + a.length, 0);
   let wasmMemory = null;
   const setMemory = (m2) => {
     wasmMemory = m2;
   };
   const stdoutChunks = [];
-  const stderrChunks = [];
+  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);
@@ -151,10 +1190,13 @@ function createWasiImports({
         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)
-          stdoutChunks.push(chunk);
-        else if (fd === 2)
-          stderrChunks.push(chunk);
+        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);
@@ -262,67 +1304,150 @@ function createWasiImports({
     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: decoder.decode(mergeUint8Arrays(stderrChunks))
+      stderrText: stderrMeta
     };
   }
   return { wasiImport, setMemory, collectOutput };
 }
-function buildResponse({
-  stdout,
-  stderrText
-}) {
-  const meta = parseEdgeMeta(stderrText);
-  return new Response(stdout.buffer, {
-    status: meta.status,
-    headers: meta.headers
-  });
+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;
 }
-async function run({
-  request,
-  env,
-  ctx,
-  module,
-  kv: kvBindings,
-  imports
-}) {
-  const stdinData = request.body ? new Uint8Array(await request.arrayBuffer()) : undefined;
-  const { wasiImport, setMemory, collectOutput } = createWasiImports({ request, stdinData });
-  let wasmMemory = null;
-  const mem = () => wasmMemory;
-  const instance = new WebAssembly.Instance(module, {
-    wasi_snapshot_preview1: wasiImport,
-    ...kvBindings ? { __zx_kv: createKVImports(kvBindings, mem) } : {},
-    ...imports ? imports(mem) : {}
+
+// src/runtime.ts
+function buildWsImports(Suspending, mem, decoder3, ws) {
+  const readStr = (ptr, len) => decoder3.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, decoder3.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);
+    }
   });
-  wasmMemory = instance.exports.memory;
-  setMemory(wasmMemory);
-  const start = WebAssembly.promising(instance.exports._start);
-  try {
-    await start();
-  } catch (e) {
-    if (!(e instanceof Error) || !e.message.startsWith("proc_exit"))
-      throw e;
+  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();
   }
-  return buildResponse(collectOutput());
+  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);
+    }
+  });
 }
-var FORWARDED_HEADERS = [
-  "content-type",
-  "accept",
-  "authorization",
-  "cookie",
-  "user-agent",
-  "referer",
-  "x-forwarded-for",
-  "x-forwarded-proto",
-  "x-real-ip"
-];
 function parseEdgeMeta(stderrText) {
-  const meta = { status: 200, headers: new Headers };
+  const meta = { status: 200, headers: new Headers, streaming: false };
   const metaPrefix = "__EDGE_META__:";
   const metaLine = stderrText.split(`
 `).find((line) => line.startsWith(metaPrefix));
@@ -331,6 +1456,8 @@ function parseEdgeMeta(stderrText) {
       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);
@@ -340,72 +1467,241 @@ function parseEdgeMeta(stderrText) {
   }
   return meta;
 }
-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;
+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);
   }
-  return result;
+  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 });
 }
-async function collectStream(readable, chunks) {
-  const reader = readable.getReader();
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done)
-      break;
-    if (value)
-      chunks.push(value);
+// 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;
 }
-function prepare({
-  request,
-  env,
-  ctx
-}) {
-  const stdout = new TransformStream;
-  const stderr = new TransformStream;
-  const url = new URL(request.url);
-  const args = [
-    "--pathname",
-    url.pathname,
-    "--method",
-    request.method,
-    "--search",
-    url.search
-  ];
-  for (const name of FORWARDED_HEADERS) {
-    const value = request.headers.get(name);
-    if (value) {
-      args.push("--header", `${name}:${value}`);
+
+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] };
   }
-  const stdin = request.body ?? undefined;
-  return { args, stdout, stderr, stdin };
+  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
+    });
+  };
 }
-async function respond({
-  exec,
-  stdout,
-  stderr
-}) {
-  const stdoutChunks = [];
-  const stderrChunks = [];
-  const stderrReadable = stderr instanceof ReadableStream ? stderr : stderr.readable;
-  await Promise.all([
-    exec,
-    collectStream(stdout.readable, stdoutChunks),
-    collectStream(stderrReadable, stderrChunks)
-  ]);
-  const stderrText = new TextDecoder().decode(mergeUint8Arrays(stderrChunks));
-  const meta = parseEdgeMeta(stderrText);
-  return new Response(mergeUint8Arrays(stdoutChunks).buffer, {
-    status: meta.status,
-    headers: meta.headers
-  });
+// src/cloudflare/do.ts
+function createWebSocketDO(module, options) {
+  return class ZxWebSocketDO {
+    doState;
+    env;
+    connections = new Map;
+    constructor(state, env) {
+      this.doState = state;
+      this.env = env;
+    }
+    async fetch(request) {
+      const stdinData = request.body ? new Uint8Array(await request.arrayBuffer()) : undefined;
+      const { wasiImport, setMemory } = createWasiImports({ request, stdinData });
+      let wasmMemory = null;
+      const mem = () => wasmMemory;
+      const bridgeRef = { current: null };
+      const bridgeImports = ZxBridge.createImportObject(bridgeRef);
+      const Suspending = WebAssembly.Suspending;
+      const jspi = typeof Suspending === "function";
+      const decoder3 = new TextDecoder;
+      let _resolveFirstSuspend;
+      const firstSuspendPromise = new Promise((resolve) => {
+        _resolveFirstSuspend = resolve;
+      });
+      let wasmExited = false;
+      const connState = {
+        upgraded: false,
+        server: null,
+        pendingWrites: [],
+        messageQueue: [],
+        recvResolve: null,
+        _resolveFirstSuspend,
+        topics: new Set,
+        subscribe: (topic) => connState.topics.add(topic),
+        unsubscribe: (topic) => connState.topics.delete(topic),
+        publish: (topic, data) => {
+          let count = 0;
+          for (const [ws, conn] of this.connections) {
+            if (conn.topics.has(topic)) {
+              try {
+                ws.send(data);
+                count++;
+              } catch {}
+            }
+          }
+          if (!connState.server && connState.topics.has(topic)) {
+            connState.pendingWrites.push(data.slice());
+            count++;
+          }
+          return count;
+        },
+        isSubscribed: (topic) => connState.topics.has(topic)
+      };
+      const sysImports = {
+        sleep_ms: jspi ? new Suspending(async (ms) => new Promise((r) => setTimeout(r, ms))) : (_ms) => {}
+      };
+      const wsImports = buildWsImports(jspi ? Suspending : null, mem, decoder3, connState);
+      const kvBindings = options?.kv?.(this.env);
+      const instance = new WebAssembly.Instance(module, {
+        wasi_snapshot_preview1: wasiImport,
+        __zx_sys: sysImports,
+        __zx_ws: wsImports,
+        __zx_kv: createKVImports(kvBindings ?? { default: createMemoryKV() }, mem),
+        ...options?.imports ? options.imports(mem) : {},
+        ...bridgeImports
+      });
+      wasmMemory = instance.exports.memory;
+      setMemory(wasmMemory);
+      bridgeRef.current = new ZxBridge(instance.exports);
+      const start = WebAssembly.promising(instance.exports._start);
+      const wasmPromise = start().catch((e) => {
+        wasmExited = true;
+        if (e instanceof Error && e.message.startsWith("proc_exit"))
+          return;
+        console.error("[ZxWebSocketDO] WASM error:", e);
+      }).finally(() => {
+        if (connState.server)
+          this.connections.delete(connState.server);
+        if (connState.recvResolve) {
+          const res = connState.recvResolve;
+          connState.recvResolve = null;
+          res(null);
+        }
+      });
+      await Promise.race([firstSuspendPromise, wasmPromise]);
+      if (!connState.upgraded || wasmExited) {
+        return new Response("WebSocket upgrade expected", { status: 426 });
+      }
+      const { client } = attachWebSocket(connState);
+      this.connections.set(connState.server, connState);
+      this.doState.waitUntil(wasmPromise);
+      return new Response(null, { status: 101, webSocket: client });
+    }
+  };
 }
 export {
-  exports_worker as worker,
-  exports_kv as kv
+  exports_runtime as worker,
+  exports_kv as kv,
+  createWebSocketDO,
+  Ziex
 };