ziex 0.1.0-dev.1389 → 0.1.0-dev.1466

package/index.js

@@ -1,9 +1,14 @@
+// src/wasm/constants.ts
+var CallbackType_FetchSuccess = 1;
+var CallbackType_FetchError = 2;
+var CallbackType_Timeout = 3;
+var CallbackType_Interval = 4;
+
 // src/wasm/wasi.ts
 var decoder = new TextDecoder();
 var encoder = new TextEncoder();
 var ZxWasiBridge = class {
   #alloc;
-  #fetchCompleteHandler;
   #memory;
   #cb;
   #intervals = /* @__PURE__ */ new Map();
@@ -13,7 +18,6 @@ var ZxWasiBridge = class {
   constructor(exports) {
     this.#memory = exports.memory;
     this.#alloc = exports.__zx_alloc;
-    this.#fetchCompleteHandler = exports.__zx_fetch_complete;
     this.#cb = exports.__zx_cb;
   }
   #view() {
@@ -25,10 +29,21 @@ var ZxWasiBridge = class {
     return this.#memView;
   }
   #readString(ptr, len) {
-    return decoder.decode(this.#view().subarray(ptr, ptr + len));
+    const start = ptr >>> 0;
+    const length = len >>> 0;
+    if (length === 0) return "";
+    const view = this.#view();
+    if (start + length > view.byteLength) return "";
+    return decoder.decode(view.subarray(start, start + length));
   }
   #writeBytes(ptr, data) {
-    this.#view().set(data, ptr);
+    const start = ptr >>> 0;
+    const view = this.#view();
+    if (start + data.length > view.byteLength) return;
+    view.set(data, start);
+  }
+  #invoke(type, id, a = 0n, b = 0n, c = 0n) {
+    this.#cb?.(type, id, a, b, c);
   }
   log(level, ptr, len) {
     const msg = decoder.decode(this.#view().subarray(ptr, ptr + len));
@@ -82,13 +97,14 @@ var ZxWasiBridge = class {
     const encoded = typeof body === "string" ? encoder.encode(body) : body;
     const ptr = this.#alloc(encoded.length);
     this.#writeBytes(ptr, encoded);
-    this.#fetchCompleteHandler(fetchId, status, ptr, encoded.length, isError ? 1 : 0);
+    const type = isError ? CallbackType_FetchError : CallbackType_FetchSuccess;
+    this.#invoke(type, fetchId, BigInt(status), BigInt(ptr), BigInt(encoded.length));
   }
   setTimeout(callbackId, delayMs) {
-    setTimeout(() => this.#cb?.(3, callbackId, 0n), delayMs);
+    setTimeout(() => this.#invoke(CallbackType_Timeout, callbackId), delayMs);
   }
   setInterval(callbackId, intervalMs) {
-    const handle = setInterval(() => this.#cb?.(4, callbackId, 0n), intervalMs);
+    const handle = setInterval(() => this.#invoke(CallbackType_Interval, callbackId), intervalMs);
     this.#intervals.set(callbackId, handle);
   }
   clearInterval(callbackId) {
@@ -108,10 +124,10 @@ var ZxWasiBridge = class {
     return {
       __zx: {
         _log: (level, ptr, len) => {
-          bridgeRef.current?.log(level, ptr, len);
+          bridgeRef[0]?.log(level, ptr, len);
         },
         _fetchAsync: (urlPtr, urlLen, methodPtr, methodLen, headersPtr, headersLen, bodyPtr, bodyLen, timeoutMs, fetchId) => {
-          bridgeRef.current?.fetchAsync(
+          bridgeRef[0]?.fetchAsync(
             urlPtr,
             urlLen,
             methodPtr,
@@ -125,77 +141,376 @@ var ZxWasiBridge = class {
           );
         },
         _setTimeout: (callbackId, delayMs) => {
-          bridgeRef.current?.setTimeout(callbackId, delayMs);
+          bridgeRef[0]?.setTimeout(callbackId, delayMs);
         },
         _setInterval: (callbackId, intervalMs) => {
-          bridgeRef.current?.setInterval(callbackId, intervalMs);
+          bridgeRef[0]?.setInterval(callbackId, intervalMs);
         },
         _clearInterval: (callbackId) => {
-          bridgeRef.current?.clearInterval(callbackId);
+          bridgeRef[0]?.clearInterval(callbackId);
         }
       }
     };
   }
 };
 
-// src/kv.ts
-function putOptions(ttlSeconds) {
-  if (ttlSeconds < 60) return void 0;
-  return { expirationTtl: ttlSeconds };
-}
-function createMemoryKV() {
-  const store = /* @__PURE__ */ new Map();
-  function read(key) {
-    const entry = store.get(key);
-    if (!entry) return null;
-    if (entry.expiresAt !== void 0 && Date.now() >= entry.expiresAt) {
-      store.delete(key);
-      return null;
+// src/runtime/fetch.ts
+function createFetchImports(getMemory) {
+  const encoder3 = new TextEncoder();
+  const decoder3 = new TextDecoder();
+  function readStr(ptr, len) {
+    return decoder3.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 readBytes(ptr, len) {
+    return new Uint8Array(getMemory().buffer, ptr, len);
+  }
+  function parseHeaders(headersJson) {
+    let headers = {};
+    try {
+      headers = JSON.parse(headersJson);
+    } catch {
+      for (const line of headersJson.split("\n")) {
+        const colonIdx = line.indexOf(":");
+        if (colonIdx > 0) {
+          headers[line.slice(0, colonIdx)] = line.slice(colonIdx + 1);
+        }
+      }
     }
-    return entry.value;
+    return headers;
   }
-  function write(key, value, options) {
-    let expiresAt;
-    if (options?.expiration !== void 0) {
-      expiresAt = options.expiration * 1e3;
-    } else if (options?.expirationTtl !== void 0) {
-      expiresAt = Date.now() + options.expirationTtl * 1e3;
+  async function doFetch(url_ptr, url_len, method_ptr, method_len, headers_ptr, headers_len, body_ptr, body_len, timeout_ms, status_out, buf_ptr, buf_max) {
+    const url = readStr(url_ptr, url_len);
+    const method = method_len > 0 ? readStr(method_ptr, method_len) : "GET";
+    const headersJson = headers_len > 0 ? readStr(headers_ptr, headers_len) : "{}";
+    const body = body_len > 0 ? readBytes(body_ptr, body_len) : void 0;
+    const headers = parseHeaders(headersJson);
+    const controller = new AbortController();
+    const timeout = timeout_ms > 0 ? setTimeout(() => controller.abort(), timeout_ms) : null;
+    try {
+      const response = await fetch(url, {
+        method,
+        headers: Object.keys(headers).length > 0 ? headers : void 0,
+        body: method !== "GET" && method !== "HEAD" ? body : void 0,
+        signal: controller.signal
+      });
+      if (timeout) clearTimeout(timeout);
+      new DataView(getMemory().buffer).setUint16(status_out, response.status, true);
+      const bytes = new Uint8Array(await response.arrayBuffer());
+      return writeBytes(buf_ptr, buf_max, bytes);
+    } catch (err) {
+      if (timeout) clearTimeout(timeout);
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`wasm fetch failed: ${url} (${msg})`);
+      return -1;
     }
-    store.set(key, { value, expiresAt });
+  }
+  const Suspending = WebAssembly.Suspending;
+  if (typeof Suspending !== "function") {
+    return {
+      fetch: (_url_ptr, _url_len, _method_ptr, _method_len, _headers_ptr, _headers_len, _body_ptr, _body_len, _timeout_ms, _status_out, _buf_ptr, _buf_max) => -1
+    };
   }
   return {
-    async get(key) {
-      return read(key);
-    },
-    async put(key, value, options) {
-      write(key, value, options);
-    },
-    async delete(key) {
-      store.delete(key);
-    },
-    async list(options) {
-      const keys = [...store.keys()].filter((k) => {
-        if (options?.prefix && !k.startsWith(options.prefix)) return false;
-        return read(k) !== null;
-      }).map((name) => ({ name }));
-      return { keys };
-    }
+    fetch: new Suspending(doFetch)
   };
 }
+
+// ../../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 encoder2 = new TextEncoder();
+var decoder2 = new TextDecoder("utf-8");
+var ZigJS = class {
+  constructor() {
+    /**
+     * The values, indexed by ID (number). Duplicate values can be in this
+     * if they are loaded multiple times. That just acts as duplicate references.
+     * */
+    this.values = [NaN, null, true, false, void 0, globalThis, this];
+    /**
+     * When a value is removed from the values array, its ID is put
+     * in the pool so that we can use it next. This avoids fragmentation in
+     * our array keys.
+     * */
+    this.idPool = [];
+  }
+  /**
+   * Returns the import object that should be merged with your import
+   * object when instantiating your wasm instance. This injects the required
+   * functions into the wasm environment.
+   * */
+  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)
+      }
+    };
+  }
+  /**
+   * Get a value from the JS environment.
+   * */
+  valueGet(out, id, ptr, len) {
+    const val = this.loadValue(id);
+    if (val === null || val === void 0 || typeof val !== "object" && typeof val !== "function") {
+      this.storeValue(out, void 0);
+      return;
+    }
+    const str = this.loadString(ptr, len);
+    const result = Reflect.get(val, str);
+    this.storeValue(out, result);
+  }
+  /**
+   * Set a value on an object.
+   * */
+  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);
+  }
+  /**
+   * Dereference a value, allowing the JS environment to potentially GC it.
+   * */
+  valueDeinit(id) {
+    if (id > PREDEFINED_ID_MAX) {
+      this.values[id] = null;
+      this.idPool.push(id);
+    }
+  }
+  /**
+   * Create an empty object.
+   * */
+  valueObjectCreate(out) {
+    this.storeValue(out, new Object());
+  }
+  /**
+   * Creates a string on the JS side from a UTF-8 encoded string in wasm memory.
+   * */
+  valueStringCreate(out, ptr, len) {
+    const str = this.loadString(ptr, len);
+    this.storeValue(out, str);
+  }
+  /**
+   * Returns the length of the string given by id.
+   * */
+  valueStringLen(id) {
+    const val = this.loadValue(id);
+    const buf = encoder2.encode(val);
+    return buf.byteLength;
+  }
+  /**
+   * Copy the string at id "id" into the shared memory at ptr.
+   * */
+  valueStringCopy(id, ptr, max) {
+    if (this.memory == null) return;
+    const dest = ptr >>> 0;
+    const cap = max >>> 0;
+    const val = this.loadValue(id);
+    if (typeof val !== "string") return;
+    const bytes = encoder2.encode(val);
+    if (bytes.byteLength > cap || bytes.length === 0) return;
+    const buf = this.memory.buffer;
+    if (dest + bytes.length > buf.byteLength) return;
+    new Uint8Array(buf, dest, bytes.length).set(bytes);
+  }
+  /**
+   * Call a constructor given by id.
+   * */
+  valueNew(out, id, argsAddr, argsLen) {
+    const fn = this.loadValue(id);
+    const args = [];
+    const base = argsAddr >>> 0;
+    const count = argsLen >>> 0;
+    for (let i = 0; i < count; i++) {
+      args.push(this.loadRef(base + i * 8));
+    }
+    const result = Reflect.construct(fn, args);
+    this.storeValue(out, result);
+  }
+  /**
+   * Call a function given by id.
+   * */
+  funcApply(out, id, thisRefAddr, argsAddr, argsLen) {
+    const fn = this.loadValue(id);
+    const thisVal = this.loadRef(thisRefAddr >>> 0);
+    const args = [];
+    const base = argsAddr >>> 0;
+    const count = argsLen >>> 0;
+    for (let i = 0; i < count; i++) {
+      args.push(this.loadRef(base + i * 8));
+    }
+    if (typeof fn !== "function") {
+      this.storeValue(out, void 0);
+      return;
+    }
+    try {
+      const result = Reflect.apply(fn, thisVal, args);
+      this.storeValue(out, result);
+    } catch {
+      this.storeValue(out, void 0);
+    }
+  }
+  /**
+   * This can be used to load a value given by an ID. A WASM function
+   * might return a value as an ID. This can be used to retrieve it.
+   * */
+  loadValue(id) {
+    return this.values[id];
+  }
+  /**
+   * This removes the value from the values list and returns it. This
+   * will not remove predefined values but can still be used to retrieve
+   * them.
+   * */
+  deleteValue(id) {
+    const val = this.values[id];
+    this.valueDeinit(id);
+    return val;
+  }
+  loadRef(refAddr) {
+    if (this.memory == null) return;
+    const addr = refAddr >>> 0;
+    const view = new DataView(this.memory.buffer);
+    const floatVal = view.getFloat64(addr, true);
+    if (!isNaN(floatVal)) return floatVal;
+    const id = this.loadRefId(addr);
+    return this.values[id];
+  }
+  loadRefId(refAddr) {
+    if (this.memory == null) return 0;
+    return new DataView(this.memory.buffer).getUint32(refAddr >>> 0, true);
+  }
+  storeValue(out, val) {
+    if (this.memory == null) return;
+    const view = new DataView(this.memory.buffer);
+    out = out >>> 0;
+    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 === void 0) {
+      view.setUint32(out, predefined.undefined, true);
+      view.setUint32(out + 4, NAN_PREFIX, true);
+      return;
+    }
+    if (typeof val === "boolean") {
+      view.setUint32(out, val ? predefined.true : predefined.false, true);
+      view.setUint32(out + 4, NAN_PREFIX, true);
+      return;
+    }
+    if (typeof val === "bigint") {
+      view.setFloat64(out, Number(val), true);
+      return;
+    }
+    let id = this.idPool.pop();
+    if (id === void 0) {
+      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 start = ptr >>> 0;
+    const length = Number(len) >>> 0;
+    const buf = this.memory.buffer;
+    if (length === 0 || start + length > buf.byteLength) return "";
+    const arr = new Uint8ClampedArray(buf, start, length);
+    const data = arr.slice();
+    return decoder2.decode(data);
+  }
+};
+
+// src/wasm/core.ts
+var jsz = new ZigJS();
+var tempRefBuffer = new ArrayBuffer(8);
+var tempRefView = new DataView(tempRefBuffer);
+var textDecoder = new TextDecoder();
+var textEncoder = new TextEncoder();
+function writeBytesOut(getMemory, allocRef, outPtrAddr, data) {
+  if (data.length === 0) {
+    new DataView(getMemory().buffer).setUint32(outPtrAddr, 0, true);
+    return 0;
+  }
+  const alloc = allocRef[0];
+  if (!alloc) return -1;
+  const ptr = alloc(data.length) >>> 0;
+  if (!ptr) return -1;
+  const buffer = getMemory().buffer;
+  if (ptr + data.length > buffer.byteLength) return -1;
+  new Uint8Array(buffer, ptr, data.length).set(data);
+  new DataView(buffer).setUint32(outPtrAddr >>> 0, ptr, true);
+  return data.length;
+}
+function writeJsonOut(getMemory, allocRef, outPtrAddr, value) {
+  return writeBytesOut(getMemory, allocRef, outPtrAddr, textEncoder.encode(JSON.stringify(value)));
+}
+function bindWasmAlloc(allocRef, exports) {
+  allocRef[0] = exports.__zx_alloc;
+}
+
+// src/runtime/kv/extern.ts
+function putOptions(ttlSeconds) {
+  if (ttlSeconds < 60) return void 0;
+  return { expirationTtl: ttlSeconds };
+}
 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 createKVImports(bindings, getMemory, allocRef) {
+  const encoder3 = new TextEncoder();
+  const decoder3 = 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;
+    return decoder3.decode(new Uint8Array(getMemory().buffer, ptr, len));
   }
   function binding(ns) {
     return bindings[ns] ?? bindings["default"] ?? null;
@@ -208,12 +523,12 @@ function createKVImports(bindings, getMemory) {
     };
     var syncBinding = syncBinding2;
     return {
-      kv_get: (ns_ptr, ns_len, key_ptr, key_len, buf_ptr, buf_max) => {
+      kv_get: (ns_ptr, ns_len, key_ptr, key_len, out_ptr) => {
         const b = syncBinding2(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));
+        return writeBytesOut(getMemory, allocRef, out_ptr, encoder3.encode(value));
       },
       kv_put: (ns_ptr, ns_len, key_ptr, key_len, val_ptr, val_len, ttl_seconds) => {
         const b = syncBinding2(readStr(ns_ptr, ns_len));
@@ -227,22 +542,22 @@ function createKVImports(bindings, getMemory) {
         b.deleteSync(readStr(key_ptr, key_len));
         return 0;
       },
-      kv_list: (ns_ptr, ns_len, pfx_ptr, pfx_len, buf_ptr, buf_max) => {
+      kv_list: (ns_ptr, ns_len, pfx_ptr, pfx_len, out_ptr) => {
         const b = syncBinding2(readStr(ns_ptr, ns_len));
-        if (!b) return writeBytes(buf_ptr, buf_max, encoder2.encode("[]"));
+        if (!b) return writeJsonOut(getMemory, allocRef, out_ptr, []);
         const prefix = readStr(pfx_ptr, pfx_len);
         const result = b.listSync(prefix.length > 0 ? { prefix } : void 0);
-        return writeBytes(buf_ptr, buf_max, encoder2.encode(JSON.stringify(result.keys.map((k) => k.name))));
+        return writeJsonOut(getMemory, allocRef, out_ptr, result.keys.map((k) => k.name));
       }
     };
   }
   return {
-    kv_get: new Suspending(async (ns_ptr, ns_len, key_ptr, key_len, buf_ptr, buf_max) => {
+    kv_get: new Suspending(async (ns_ptr, ns_len, key_ptr, key_len, out_ptr) => {
       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));
+      return writeBytesOut(getMemory, allocRef, out_ptr, encoder3.encode(value));
     }),
     kv_put: new Suspending(async (ns_ptr, ns_len, key_ptr, key_len, val_ptr, val_len, ttl_seconds) => {
       const b = binding(readStr(ns_ptr, ns_len));
@@ -256,90 +571,29 @@ function createKVImports(bindings, getMemory) {
       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) => {
+    kv_list: new Suspending(async (ns_ptr, ns_len, prefix_ptr, prefix_len, out_ptr) => {
       const b = binding(readStr(ns_ptr, ns_len));
-      if (!b) return writeBytes(buf_ptr, buf_max, encoder2.encode("[]"));
+      if (!b) return writeJsonOut(getMemory, allocRef, out_ptr, []);
       const prefix = readStr(prefix_ptr, prefix_len);
       const result = await b.list(prefix.length > 0 ? { prefix } : void 0);
-      return writeBytes(buf_ptr, buf_max, encoder2.encode(JSON.stringify(result.keys.map((k) => k.name))));
-    })
-  };
-}
-
-// src/fetch.ts
-function createFetchImports(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 readBytes(ptr, len) {
-    return new Uint8Array(getMemory().buffer, ptr, len);
-  }
-  function parseHeaders(headersJson) {
-    let headers = {};
-    try {
-      headers = JSON.parse(headersJson);
-    } catch {
-      for (const line of headersJson.split("\n")) {
-        const colonIdx = line.indexOf(":");
-        if (colonIdx > 0) {
-          headers[line.slice(0, colonIdx)] = line.slice(colonIdx + 1);
-        }
+      const names = result.keys.map((k) => k.name);
+      if (names.length === 0) {
+        new DataView(getMemory().buffer).setUint32(out_ptr, 0, true);
+        return 0;
       }
-    }
-    return headers;
-  }
-  async function doFetch(url_ptr, url_len, method_ptr, method_len, headers_ptr, headers_len, body_ptr, body_len, timeout_ms, status_out, buf_ptr, buf_max) {
-    const url = readStr(url_ptr, url_len);
-    const method = method_len > 0 ? readStr(method_ptr, method_len) : "GET";
-    const headersJson = headers_len > 0 ? readStr(headers_ptr, headers_len) : "{}";
-    const body = body_len > 0 ? readBytes(body_ptr, body_len) : void 0;
-    const headers = parseHeaders(headersJson);
-    const controller = new AbortController();
-    const timeout = timeout_ms > 0 ? setTimeout(() => controller.abort(), timeout_ms) : null;
-    try {
-      const response = await fetch(url, {
-        method,
-        headers: Object.keys(headers).length > 0 ? headers : void 0,
-        body: method !== "GET" && method !== "HEAD" ? body : void 0,
-        signal: controller.signal
-      });
-      if (timeout) clearTimeout(timeout);
-      new DataView(getMemory().buffer).setUint16(status_out, response.status, true);
-      const bytes = new Uint8Array(await response.arrayBuffer());
-      return writeBytes(buf_ptr, buf_max, bytes);
-    } catch (err) {
-      if (timeout) clearTimeout(timeout);
-      const msg = err instanceof Error ? err.message : String(err);
-      console.error(`wasm fetch failed: ${url} (${msg})`);
-      return -1;
-    }
-  }
-  const Suspending = WebAssembly.Suspending;
-  if (typeof Suspending !== "function") {
-    return {
-      fetch: (_url_ptr, _url_len, _method_ptr, _method_len, _headers_ptr, _headers_len, _body_ptr, _body_len, _timeout_ms, _status_out, _buf_ptr, _buf_max) => -1
-    };
-  }
-  return {
-    fetch: new Suspending(doFetch)
+      return writeJsonOut(getMemory, allocRef, out_ptr, names);
+    })
   };
 }
 
-// src/db.ts
+// src/runtime/db/extern.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) {
+function toDbValue(value) {
   switch (value.kind) {
     case "null":
       return null;
@@ -360,9 +614,9 @@ function toPositionalBindings(json) {
     case "none":
       return [];
     case "positional":
-      return json.values.map(toD1Value);
+      return json.values.map(toDbValue);
     case "named":
-      throw new Error("Cloudflare D1 adapter does not support named bindings yet");
+      throw new Error("named SQL bindings are not supported yet");
   }
 }
 function toWireValue(value) {
@@ -397,17 +651,10 @@ function objectToWireRow(record) {
 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 createDbImports(bindings, getMemory, allocRef) {
+  const decoder3 = 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;
+    return decoder3.decode(new Uint8Array(getMemory().buffer, ptr, len));
   }
   function binding(ns) {
     return bindings[ns] ?? bindings["default"] ?? null;
@@ -423,46 +670,58 @@ function createD1Imports(bindings, getMemory) {
   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
+      db_run: (_a, _b, _c, _d, _e, _f, _g) => -1,
+      db_get: (_a, _b, _c, _d, _e, _f, _g) => -1,
+      db_all: (_a, _b, _c, _d, _e, _f, _g) => -1,
+      db_values: (_a, _b, _c, _d, _e, _f, _g) => -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) => {
+    db_run: new Suspending(async (ns_ptr, ns_len, sql_ptr, sql_len, bindings_ptr, bindings_len, out_ptr) => {
       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, {
+      return writeJsonOut(getMemory, allocRef, out_ptr, {
         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) => {
+    db_get: new Suspending(async (ns_ptr, ns_len, sql_ptr, sql_len, bindings_ptr, bindings_len, out_ptr) => {
       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)]);
+      if (!row) {
+        new DataView(getMemory().buffer).setUint32(out_ptr, 0, true);
+        return 0;
+      }
+      return writeJsonOut(getMemory, allocRef, out_ptr, [objectToWireRow(row)]);
     }),
-    db_all: new Suspending(async (ns_ptr, ns_len, sql_ptr, sql_len, bindings_ptr, bindings_len, buf_ptr, buf_max) => {
+    db_all: new Suspending(async (ns_ptr, ns_len, sql_ptr, sql_len, bindings_ptr, bindings_len, out_ptr) => {
       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));
+      const rows = (result.results ?? []).map(objectToWireRow);
+      if (rows.length === 0) {
+        new DataView(getMemory().buffer).setUint32(out_ptr, 0, true);
+        return 0;
+      }
+      return writeJsonOut(getMemory, allocRef, out_ptr, rows);
     }),
-    db_values: new Suspending(async (ns_ptr, ns_len, sql_ptr, sql_len, bindings_ptr, bindings_len, buf_ptr, buf_max) => {
+    db_values: new Suspending(async (ns_ptr, ns_len, sql_ptr, sql_len, bindings_ptr, bindings_len, out_ptr) => {
       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));
+      if (rows.length === 0) {
+        new DataView(getMemory().buffer).setUint32(out_ptr, 0, true);
+        return 0;
+      }
+      return writeJsonOut(getMemory, allocRef, out_ptr, valuesToWireRows(rows));
     })
   };
 }
 
-// src/wasi.ts
+// src/runtime/wasi.ts
 var ProcExit = class extends Error {
   constructor(code) {
     super(`proc_exit(${code})`);
@@ -474,7 +733,7 @@ function createWasiImports({
   stdinData,
   onStdout
 }) {
-  const encoder2 = new TextEncoder();
+  const encoder3 = new TextEncoder();
   const url = new URL(request.url);
   const argStrings = [
     "wasm",
@@ -490,7 +749,7 @@ function createWasiImports({
   request.headers.forEach((value, name) => {
     if (value) argStrings.push("--header", `${name}:${value}`);
   });
-  const encodedArgs = argStrings.map((a) => encoder2.encode(a + "\0"));
+  const encodedArgs = argStrings.map((a) => encoder3.encode(a + "\0"));
   const argBufSize = encodedArgs.reduce((s, a) => s + a.length, 0);
   let wasmMemory = null;
   const setMemory = (m2) => {
@@ -756,9 +1015,51 @@ function mergeUint8Arrays(arrays) {
   return result;
 }
 
-// src/runtime.ts
-function buildWsImports(Suspending, mem, decoder2, ws) {
-  const readStr = (ptr, len) => decoder2.decode(new Uint8Array(mem().buffer, ptr, len));
+// src/runtime/kv/memory.ts
+function createMemoryKV() {
+  const store = /* @__PURE__ */ new Map();
+  function read(key) {
+    const entry = store.get(key);
+    if (!entry) return null;
+    const expiresAt = entry[1];
+    if (expiresAt !== void 0 && Date.now() >= expiresAt) {
+      store.delete(key);
+      return null;
+    }
+    return entry[0];
+  }
+  function write(key, value, options) {
+    let expiresAt;
+    if (options?.expiration !== void 0) {
+      expiresAt = options.expiration * 1e3;
+    } else if (options?.expirationTtl !== void 0) {
+      expiresAt = Date.now() + options.expirationTtl * 1e3;
+    }
+    store.set(key, [value, expiresAt]);
+  }
+  return {
+    async get(key) {
+      return read(key);
+    },
+    async put(key, value, options) {
+      write(key, value, options);
+    },
+    async delete(key) {
+      store.delete(key);
+    },
+    async list(options) {
+      const keys = [...store.keys()].filter((k) => {
+        if (options?.prefix && !k.startsWith(options.prefix)) return false;
+        return read(k) !== null;
+      }).map((name) => ({ name }));
+      return { keys };
+    }
+  };
+}
+
+// src/runtime/index.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;
@@ -772,7 +1073,7 @@ function buildWsImports(Suspending, mem, decoder2, ws) {
       }
     },
     ws_close: (code, reason_ptr, reason_len) => {
-      ws.server?.close(code, decoder2.decode(new Uint8Array(mem().buffer, 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) {
@@ -908,7 +1209,8 @@ async function run({
   });
   let wasmMemory = null;
   const mem = () => wasmMemory;
-  const bridgeRef = { current: null };
+  const bridgeRef = [null];
+  const allocRef = [null];
   const Suspending = WebAssembly.Suspending;
   const jspi = typeof Suspending === "function";
   const wsState = {
@@ -918,19 +1220,33 @@ async function run({
     messageQueue: [],
     recvResolve: null
   };
-  const instance = new WebAssembly.Instance(module, {
+  const importObject = {
     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),
     __zx_net: createFetchImports(mem),
     ...imports ? imports(mem) : {},
     ...ZxWasiBridge.createImportObject(bridgeRef)
-  });
+  };
+  if (true) {
+    importObject.__zx_kv = createKVImports(
+      kvBindings ?? { default: createMemoryKV() },
+      mem,
+      allocRef
+    );
+  }
+  if (true) {
+    importObject.__zx_db = createDbImports(
+      dbBindings ?? {},
+      mem,
+      allocRef
+    );
+  }
+  const instance = new WebAssembly.Instance(module, importObject);
   wasmMemory = instance.exports.memory;
   setMemory(wasmMemory);
-  bridgeRef.current = new ZxWasiBridge(instance.exports);
+  bridgeRef[0] = new ZxWasiBridge(instance.exports);
+  bindWasmAlloc(allocRef, instance.exports);
   const wasmPromise = executeWasm(instance, jspi, Suspending, wsState);
   if (wsState.upgraded) {
     const server = attachWebSocket(wsState);