ziex 0.1.0-dev.1466 → 0.1.0-dev.1568

package/runtime/kv.js

@@ -1,164 +1,3 @@
-// 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/kv/localstorage.ts
-function getLocalStorage() {
-  if (typeof localStorage === "undefined") {
-    throw new Error("localStorage is not available in this environment");
-  }
-  return localStorage;
-}
-function createLocalStorageKV(options = {}) {
-  const storage = getLocalStorage();
-  const namespace = options.namespace ?? "default";
-  const storagePrefix = options.storagePrefix ?? "ziex-kv";
-  const scopedKey = (key) => `${storagePrefix}:${namespace}:${key}`;
-  const namespacePrefix = scopedKey("");
-  return {
-    getSync(key) {
-      return storage.getItem(scopedKey(key));
-    },
-    async get(key) {
-      return this.getSync(key);
-    },
-    putSync(key, value) {
-      storage.setItem(scopedKey(key), value);
-    },
-    async put(key, value) {
-      this.putSync(key, value);
-    },
-    deleteSync(key) {
-      storage.removeItem(scopedKey(key));
-    },
-    async delete(key) {
-      this.deleteSync(key);
-    },
-    listSync(options2) {
-      const prefix = namespacePrefix + (options2?.prefix ?? "");
-      const keys = [];
-      for (let i = 0; i < storage.length; i += 1) {
-        const key = storage.key(i);
-        if (!key || !key.startsWith(prefix)) continue;
-        keys.push({ name: key.slice(namespacePrefix.length) });
-      }
-      return { keys };
-    },
-    async list(options2) {
-      return this.listSync(options2);
-    }
-  };
-}
-
-// src/runtime/kv/indexdb.ts
-function getIndexedDb() {
-  if (typeof indexedDB === "undefined") {
-    throw new Error("IndexedDB is not available in this environment");
-  }
-  return indexedDB;
-}
-function requestToPromise(request) {
-  return new Promise((resolve, reject) => {
-    request.onsuccess = () => resolve(request.result);
-    request.onerror = () => reject(request.error ?? new Error("IndexedDB request failed"));
-  });
-}
-function transactionToPromise(transaction) {
-  return new Promise((resolve, reject) => {
-    transaction.oncomplete = () => resolve();
-    transaction.onabort = () => reject(transaction.error ?? new Error("IndexedDB transaction aborted"));
-    transaction.onerror = () => reject(transaction.error ?? new Error("IndexedDB transaction failed"));
-  });
-}
-function createIndexedDbKV(options = {}) {
-  const databaseName = options.databaseName ?? "ziex-kv";
-  const storeName = options.storeName ?? "kv";
-  const namespace = options.namespace ?? "default";
-  const dbPromise = new Promise((resolve, reject) => {
-    const request = getIndexedDb().open(databaseName, 1);
-    request.onupgradeneeded = () => {
-      const db = request.result;
-      if (!db.objectStoreNames.contains(storeName)) {
-        db.createObjectStore(storeName);
-      }
-    };
-    request.onsuccess = () => resolve(request.result);
-    request.onerror = () => reject(request.error ?? new Error("Failed to open IndexedDB"));
-  });
-  const scopedKey = (key) => `${namespace}:${key}`;
-  return {
-    async get(key) {
-      const db = await dbPromise;
-      const tx = db.transaction(storeName, "readonly");
-      const store = tx.objectStore(storeName);
-      const value = await requestToPromise(store.get(scopedKey(key)));
-      await transactionToPromise(tx);
-      return typeof value === "string" ? value : null;
-    },
-    async put(key, value) {
-      const db = await dbPromise;
-      const tx = db.transaction(storeName, "readwrite");
-      tx.objectStore(storeName).put(value, scopedKey(key));
-      await transactionToPromise(tx);
-    },
-    async delete(key) {
-      const db = await dbPromise;
-      const tx = db.transaction(storeName, "readwrite");
-      tx.objectStore(storeName).delete(scopedKey(key));
-      await transactionToPromise(tx);
-    },
-    async list(options2) {
-      const db = await dbPromise;
-      const tx = db.transaction(storeName, "readonly");
-      const store = tx.objectStore(storeName);
-      const keys = await requestToPromise(store.getAllKeys());
-      await transactionToPromise(tx);
-      const prefix = scopedKey(options2?.prefix ?? "");
-      return {
-        keys: keys.filter((key) => typeof key === "string" && key.startsWith(prefix)).map((key) => ({ name: key.slice(namespace.length + 1) }))
-      };
-    }
-  };
-}
-
 // ../../vendor/jsz/js/src/zigjs.ts
 var NAN_PREFIX = 2146959360;
 var predefined = {
@@ -434,110 +273,208 @@ function writeJsonOut(getMemory, allocRef, outPtrAddr, value) {
 }
 
 // src/runtime/kv/extern.ts
+var Suspending = WebAssembly.Suspending;
+var jspi = typeof Suspending === "function";
+var miss = jspi ? -1 : 0;
 function putOptions(ttlSeconds) {
   if (ttlSeconds < 60) return void 0;
   return { expirationTtl: ttlSeconds };
 }
+function kvDel(binding, key) {
+  const b = binding;
+  return (b.del ?? b.delete).call(b, key);
+}
 function isSyncKVNamespace(binding) {
-  const candidate = binding;
-  return typeof candidate.getSync === "function" && typeof candidate.putSync === "function" && typeof candidate.deleteSync === "function" && typeof candidate.listSync === "function";
+  return typeof binding.get === "function" && binding.get.constructor.name !== "AsyncFunction";
 }
-function createKVImports(bindings, getMemory, allocRef) {
-  const encoder2 = new TextEncoder();
-  const decoder2 = new TextDecoder();
-  function readStr(ptr, len) {
-    return decoder2.decode(new Uint8Array(getMemory().buffer, ptr, len));
-  }
-  function binding(ns) {
-    return bindings[ns] ?? bindings["default"] ?? null;
+function listOpts(prefix) {
+  return prefix.length > 0 ? { prefix } : void 0;
+}
+function maybeThen(r, f) {
+  return r instanceof Promise ? r.then(f) : f(r);
+}
+function readStr(getMemory, ptr, len) {
+  return textDecoder.decode(new Uint8Array(getMemory().buffer, ptr, len));
+}
+function resolve(bindings, ns) {
+  const b = bindings[ns] ?? bindings["default"] ?? null;
+  if (!b || jspi) return b;
+  return isSyncKVNamespace(b) ? b : null;
+}
+function encodeGet(getMemory, allocRef, value, out_ptr) {
+  if (value === null) return -1;
+  return writeBytesOut(getMemory, allocRef, out_ptr, textEncoder.encode(value));
+}
+function encodeList(getMemory, allocRef, names, out_ptr) {
+  if (names.length === 0) {
+    new DataView(getMemory().buffer).setUint32(out_ptr, 0, true);
+    return 0;
   }
-  const Suspending = WebAssembly.Suspending;
-  if (typeof Suspending !== "function") {
-    let syncBinding2 = function(ns) {
-      const candidate = binding(ns);
-      return candidate && isSyncKVNamespace(candidate) ? candidate : null;
-    };
-    var syncBinding = syncBinding2;
-    return {
-      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 writeBytesOut(getMemory, allocRef, out_ptr, encoder2.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));
-        if (!b) return 0;
-        b.putSync(readStr(key_ptr, key_len), readStr(val_ptr, val_len), putOptions(ttl_seconds));
-        return 0;
-      },
-      kv_delete: (ns_ptr, ns_len, key_ptr, key_len) => {
-        const b = syncBinding2(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, out_ptr) => {
-        const b = syncBinding2(readStr(ns_ptr, ns_len));
-        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 writeJsonOut(getMemory, allocRef, out_ptr, result.keys.map((k) => k.name));
-      }
-    };
+  return writeJsonOut(getMemory, allocRef, out_ptr, names);
+}
+function get(b, key, out_ptr, getMemory, allocRef) {
+  return maybeThen(b.get(key), (v) => encodeGet(getMemory, allocRef, v, out_ptr));
+}
+function put(b, key, val, ttl) {
+  return maybeThen(b.put(key, val, putOptions(ttl)), () => 0);
+}
+function del(b, key) {
+  return maybeThen(kvDel(b, key), () => 0);
+}
+function list(b, prefix, out_ptr, getMemory, allocRef) {
+  return maybeThen(
+    b.list(listOpts(prefix)),
+    (result) => encodeList(getMemory, allocRef, result.keys.map((k) => k.name), out_ptr)
+  );
+}
+function wrapImport(impl) {
+  if (!jspi) {
+    return ((...args) => {
+      const r = impl(...args);
+      if (r instanceof Promise) throw new Error("async kv binding requires JSPI");
+      return r;
+    });
   }
+  return new Suspending(impl);
+}
+function createKVImports(bindings, getMemory, allocRef) {
   return {
-    kv_get: new Suspending(async (ns_ptr, ns_len, key_ptr, key_len, out_ptr) => {
-      const b = binding(readStr(ns_ptr, ns_len));
+    kv_get: wrapImport((ns_ptr, ns_len, key_ptr, key_len, out_ptr) => {
+      const b = resolve(bindings, readStr(getMemory, ns_ptr, ns_len));
       if (!b) return -1;
-      const value = await b.get(readStr(key_ptr, key_len));
-      if (value === null) return -1;
-      return writeBytesOut(getMemory, allocRef, out_ptr, encoder2.encode(value));
+      return get(b, readStr(getMemory, key_ptr, key_len), out_ptr, getMemory, allocRef);
     }),
-    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));
-      if (!b) return -1;
-      await b.put(readStr(key_ptr, key_len), readStr(val_ptr, val_len), putOptions(ttl_seconds));
-      return 0;
+    kv_put: wrapImport((ns_ptr, ns_len, key_ptr, key_len, val_ptr, val_len, ttl_seconds) => {
+      const b = resolve(bindings, readStr(getMemory, ns_ptr, ns_len));
+      if (!b) return miss;
+      return put(
+        b,
+        readStr(getMemory, key_ptr, key_len),
+        readStr(getMemory, val_ptr, val_len),
+        ttl_seconds
+      );
     }),
-    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_delete: wrapImport((ns_ptr, ns_len, key_ptr, key_len) => {
+      const b = resolve(bindings, readStr(getMemory, ns_ptr, ns_len));
+      if (!b) return miss;
+      return del(b, readStr(getMemory, key_ptr, key_len));
     }),
-    kv_list: new Suspending(async (ns_ptr, ns_len, prefix_ptr, prefix_len, out_ptr) => {
-      const b = binding(readStr(ns_ptr, ns_len));
+    kv_list: wrapImport((ns_ptr, ns_len, pfx_ptr, pfx_len, out_ptr) => {
+      const b = resolve(bindings, readStr(getMemory, ns_ptr, ns_len));
       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);
-      const names = result.keys.map((k) => k.name);
-      if (names.length === 0) {
-        new DataView(getMemory().buffer).setUint32(out_ptr, 0, true);
-        return 0;
-      }
-      return writeJsonOut(getMemory, allocRef, out_ptr, names);
+      return list(b, readStr(getMemory, pfx_ptr, pfx_len), out_ptr, getMemory, allocRef);
     })
   };
 }
 
-// src/runtime/kv.ts
-function hasJSPI() {
-  return typeof WebAssembly.Suspending === "function" && typeof WebAssembly.promising === "function";
+// src/runtime/kv/localstorage.ts
+var namespace = "default";
+var storagePrefix = "ziex-kv";
+var namespacePrefix = `${storagePrefix}:${namespace}:`;
+function storage() {
+  if (typeof localStorage === "undefined") {
+    throw new Error("localStorage is not available in this environment");
+  }
+  return localStorage;
+}
+function get2(key) {
+  return storage().getItem(`${storagePrefix}:${namespace}:${key}`);
 }
+function put2(key, value) {
+  storage().setItem(`${storagePrefix}:${namespace}:${key}`, value);
+}
+function del2(key) {
+  storage().removeItem(`${storagePrefix}:${namespace}:${key}`);
+}
+function list2(options) {
+  const ls = storage();
+  const prefix = namespacePrefix + (options?.prefix ?? "");
+  const keys = [];
+  for (let i = 0; i < ls.length; i += 1) {
+    const key = ls.key(i);
+    if (!key || !key.startsWith(prefix)) continue;
+    keys.push({ name: key.slice(namespacePrefix.length) });
+  }
+  return { keys };
+}
+
+// src/runtime/kv/indexdb.ts
+var databaseName = "ziex-kv";
+var storeName = "kv";
+var namespace2 = "default";
+var dbPromise;
+function openDb() {
+  if (!dbPromise) {
+    if (typeof indexedDB === "undefined") {
+      return Promise.reject(new Error("IndexedDB is not available in this environment"));
+    }
+    dbPromise = new Promise((resolve2, reject) => {
+      const request = indexedDB.open(databaseName, 1);
+      request.onupgradeneeded = () => {
+        const db = request.result;
+        if (!db.objectStoreNames.contains(storeName)) {
+          db.createObjectStore(storeName);
+        }
+      };
+      request.onsuccess = () => resolve2(request.result);
+      request.onerror = () => reject(request.error ?? new Error("Failed to open IndexedDB"));
+    });
+  }
+  return dbPromise;
+}
+function requestToPromise(request) {
+  return new Promise((resolve2, reject) => {
+    request.onsuccess = () => resolve2(request.result);
+    request.onerror = () => reject(request.error ?? new Error("IndexedDB request failed"));
+  });
+}
+function transactionToPromise(transaction) {
+  return new Promise((resolve2, reject) => {
+    transaction.oncomplete = () => resolve2();
+    transaction.onabort = () => reject(transaction.error ?? new Error("IndexedDB transaction aborted"));
+    transaction.onerror = () => reject(transaction.error ?? new Error("IndexedDB transaction failed"));
+  });
+}
+async function get3(key) {
+  const db = await openDb();
+  const tx = db.transaction(storeName, "readonly");
+  const value = await requestToPromise(tx.objectStore(storeName).get(`${namespace2}:${key}`));
+  await transactionToPromise(tx);
+  return typeof value === "string" ? value : null;
+}
+async function put3(key, value) {
+  const db = await openDb();
+  const tx = db.transaction(storeName, "readwrite");
+  tx.objectStore(storeName).put(value, `${namespace2}:${key}`);
+  await transactionToPromise(tx);
+}
+async function del3(key) {
+  const db = await openDb();
+  const tx = db.transaction(storeName, "readwrite");
+  tx.objectStore(storeName).delete(`${namespace2}:${key}`);
+  await transactionToPromise(tx);
+}
+async function list3(options) {
+  const db = await openDb();
+  const tx = db.transaction(storeName, "readonly");
+  const keys = await requestToPromise(tx.objectStore(storeName).getAllKeys());
+  await transactionToPromise(tx);
+  const prefix = `${namespace2}:${options?.prefix ?? ""}`;
+  return {
+    keys: keys.filter((key) => typeof key === "string" && key.startsWith(prefix)).map((key) => ({ name: key.slice(namespace2.length + 1) }))
+  };
+}
+
+// src/runtime/kv.ts
+var hasJspi = typeof WebAssembly.Suspending === "function" && typeof WebAssembly.promising === "function";
 function createBrowserKVBindings(options = {}) {
-  const namespace = options.namespace ?? "default";
-  const isIndexedDb = hasJSPI() && !options.forceLocalStorage;
+  const namespace3 = options.namespace ?? "default";
   return {
-    [namespace]: isIndexedDb ? createIndexedDbKV(options) : createLocalStorageKV(options)
+    [namespace3]: hasJspi && !options.forceLocalStorage ? { get: get3, put: put3, del: del3, list: list3 } : { get: get2, put: put2, del: del2, list: list2 }
   };
 }
 export {
   createBrowserKVBindings,
-  createIndexedDbKV,
   createKVImports,
-  createLocalStorageKV,
-  createMemoryKV,
-  hasJSPI
+  hasJspi
 };

package/runtime/wasi.d.ts

@@ -17,11 +17,10 @@ export type WASI = {
         };
     }): void;
 };
-export declare function createWasiImports({ request, stdinData, onStdout, }: {
+/** WASI imports for request argv/stdin. Response body uses `__zx_http`, not stdout. */
+export declare function createWasiImports({ request, stdinData, }: {
     request: Request;
     stdinData?: Uint8Array;
-    /** Called for each stdout chunk. When provided, chunks are NOT buffered internally. */
-    onStdout?: (chunk: Uint8Array) => void;
 }): {
     wasiImport: {
         args_sizes_get(argc_ptr: number, argv_buf_size_ptr: number): number;
@@ -71,9 +70,5 @@ export declare function createWasiImports({ request, stdinData, onStdout, }: {
         poll_oneoff(_in: number, _out: number, _nsubscriptions: number, nevents_ptr: number): number;
     };
     setMemory: (m: WebAssembly.Memory) => void;
-    collectOutput: () => {
-        stdout: Uint8Array;
-        stderrText: string;
-    };
 };
 export declare function mergeUint8Arrays(arrays: Uint8Array[]): Uint8Array;

package/wasm/dom_cmd.d.ts

@@ -1,12 +1,3 @@
-/**
- * DomCmd flush decoder — must match `src/runtime/client/dom_cmd.zig`.
- *
- * Buffer layout (little-endian):
- *   Header (8): u32 record_count, u32 flags (0 = absolute WASM ptr+len strings)
- *   Records (24 each): u8 op, u8 flags, u16 pad, u32 p0..p4
- *
- * String fields are absolute linear-memory pointers (same as the old per-op ABI).
- */
 export type DomFlushContext = {
     domNodes: Map<number, Node>;
     cleanupDomNodes: (node: Node) => void;