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

package/platforms/cloudflare/kv.d.ts

@@ -1,5 +1,7 @@
 /**
- * Cloudflare KV implements the generic {@link KVNamespace} binding.
+ * Cloudflare KV can be used as a {@link KVNamespace} binding
+ * (`delete` is accepted as `del` by the host imports).
  */
-export { createMemoryKV, createKVImports } from "../../runtime/kv";
+export { createKVImports } from "../../runtime/kv";
 export type { KVNamespace } from "../../runtime/kv";
+export { get, put, del, list } from "../../runtime/kv/memory";

package/platforms/cloudflare/stateful.d.ts

@@ -0,0 +1,26 @@
+import type { WsState } from "../../runtime";
+import type { KVNamespace } from "../../runtime/kv";
+import type { Database } from "../../runtime/db";
+type ConnState = WsState & {
+    topics: Set<string>;
+};
+/**
+ * Build a sticky long-lived fetch class for the host runtime.
+ *
+ * Prefer {@link stateful} so the handler reuses the app's module/kv/db.
+ *
+ * @internal
+ */
+export declare function createStatefulFetch(module: WebAssembly.Module, options?: {
+    kv?: (env: any) => Record<string, KVNamespace>;
+    db?: (env: any) => Record<string, Database>;
+    imports?: (mem: () => WebAssembly.Memory) => WebAssembly.Imports;
+}): {
+    new (state: any, env: any): {
+        readonly state: any;
+        readonly env: any;
+        readonly connections: Map<WebSocket, ConnState>;
+        fetch(request: Request): Promise<Response>;
+    };
+};
+export {};

package/platforms/cloudflare/worker.d.ts

@@ -1,3 +1,2 @@
 export { run, buildWsImports, attachWebSocket } from "../../runtime";
-export type { DurableObjectNamespace, WsState } from "../../runtime";
-export { createWebSocketDO } from "./do";
+export type { StickyNamespace, WsState } from "../../runtime";

package/platforms/vercel/index.d.ts

@@ -3,7 +3,7 @@
  *
  * @example
  * ```ts
- * import { Ziex } from "ziex/cloudflare";
+ * import { Ziex } from "ziex";
  * import { handle } from "ziex/vercel";
  * import module from "./app.wasm"; // or fetch at runtime
  *

package/runtime/index.d.ts

@@ -1,11 +1,11 @@
 import type { WASI } from "./wasi";
-import { type KVNamespace } from "./kv";
+import type { KVNamespace } from "./kv";
 import type { Database } from "./db";
-/** Minimal Durable Object namespace shape needed for WebSocket routing. */
-export type DurableObjectNamespace = {
+/** Minimal sticky long-lived fetch namespace shape (e.g. Cloudflare Durable Object binding). */
+export type StickyNamespace = {
     idFromName(name: string): unknown;
-    get(id: unknown): {
-        fetch(req: Request): Promise<Response>;
+    get(id: any): {
+        fetch(request: Request): Promise<Response>;
     };
 };
 export type WsState = {
@@ -21,6 +21,16 @@ export type WsState = {
     publish?: (topic: string, data: Uint8Array) => number;
     isSubscribed?: (topic: string) => boolean;
 };
+type HttpState = {
+    committed: boolean;
+    ended: boolean;
+    status: number;
+    streaming: boolean;
+    headers: Headers;
+    bodyChunks: Uint8Array[];
+    streamWriter: WritableStreamDefaultWriter<Uint8Array> | null;
+};
+export declare function buildHttpImports(mem: () => WebAssembly.Memory, http: HttpState): WebAssembly.ModuleImports;
 /** Build the __zx_ws import object for a given connection state. */
 export declare function buildWsImports(Suspending: any, mem: () => WebAssembly.Memory, decoder: TextDecoder, ws: WsState): WebAssembly.ModuleImports;
 /** Create WebSocketPair, wire message/close listeners, flush pending writes. */
@@ -42,7 +52,7 @@ export declare function attachWebSocket(ws: WsState): {
  * });
  * ```
  */
-export declare function run({ request, env, ctx, module, kv: kvBindings, db: dbBindings, imports, wasi, websocket: doNamespace, }: {
+export declare function run({ request, env, ctx, module, kv: kvBindings, db: dbBindings, imports, wasi, sticky, }: {
     request: Request;
     env?: unknown;
     ctx?: {
@@ -56,9 +66,9 @@ export declare function run({ request, env, ctx, module, kv: kvBindings, db: dbB
     imports?: (mem: () => WebAssembly.Memory) => WebAssembly.Imports;
     wasi?: WASI;
     /**
-     * Durable Object namespace to use for WebSocket connections.
-     * When provided, WebSocket upgrade requests are automatically forwarded to
-     * the DO so that pub/sub works across multiple connected clients.
+     * Sticky namespace for long-lived fetch (WebSocket upgrades).
+     * When provided, upgrade requests are forwarded so pub/sub works across clients.
      */
-    websocket?: DurableObjectNamespace;
+    sticky?: StickyNamespace;
 }): Promise<Response>;
+export {};

package/runtime/kv/indexdb.d.ts

@@ -1,7 +1,15 @@
-import type { KVNamespace } from "../kv";
-export type IndexedDbKVOptions = {
+export type Options = {
     databaseName?: string;
     storeName?: string;
     namespace?: string;
 };
-export declare function createIndexedDbKV(options?: IndexedDbKVOptions): KVNamespace;
+export declare function get(key: string): Promise<string | null>;
+export declare function put(key: string, value: string): Promise<void>;
+export declare function del(key: string): Promise<void>;
+export declare function list(options?: {
+    prefix?: string;
+}): Promise<{
+    keys: {
+        name: string;
+    }[];
+}>;

package/runtime/kv/localstorage.d.ts

@@ -1,6 +1,14 @@
-import type { SyncKVNamespace } from "../kv";
-export type LocalStorageKVOptions = {
+export type Options = {
     namespace?: string;
     storagePrefix?: string;
 };
-export declare function createLocalStorageKV(options?: LocalStorageKVOptions): SyncKVNamespace;
+export declare function get(key: string): string | null;
+export declare function put(key: string, value: string): void;
+export declare function del(key: string): void;
+export declare function list(options?: {
+    prefix?: string;
+}): {
+    keys: {
+        name: string;
+    }[];
+};

package/runtime/kv/memory.d.ts

@@ -1,6 +1,13 @@
-import type { KVNamespace } from "../kv";
-/**
- * In-memory KV. Used as the default shim on platforms that don't provide a
- * real KV binding (e.g. Vercel). Data lives only for the lifetime of the isolate.
- */
-export declare function createMemoryKV(): KVNamespace;
+export declare function get(key: string): Promise<string | null>;
+export declare function put(key: string, value: string, options?: {
+    expiration?: number;
+    expirationTtl?: number;
+}): Promise<void>;
+export declare function del(key: string): Promise<void>;
+export declare function list(options?: {
+    prefix?: string;
+}): Promise<{
+    keys: {
+        name: string;
+    }[];
+}>;

package/runtime/kv.d.ts

@@ -1,29 +1,32 @@
 export type { WasmAllocRef } from "../wasm/core";
-/** Key/value namespace binding. Cloudflare KV–shaped so CF bindings work as-is; other backends adapt to the same interface. */
+export { createKVImports } from "./kv/extern";
+import { type Options as IndexedDbOptions } from "./kv/indexdb";
+type MaybePromise<T> = T | Promise<T>;
+/** Key/value namespace binding (get/put/del/list). */
 export interface KVNamespace {
-    get(key: string): Promise<string | null>;
+    get(key: string): MaybePromise<string | null>;
     put(key: string, value: string, options?: {
         expiration?: number;
         expirationTtl?: number;
-    }): Promise<void>;
-    delete(key: string): Promise<void>;
+    }): MaybePromise<void>;
+    del(key: string): MaybePromise<void>;
     list(options?: {
         prefix?: string;
-    }): Promise<{
+    }): MaybePromise<{
         keys: {
             name: string;
         }[];
     }>;
 }
-/** Synchronous KV used when JSPI is unavailable (e.g. localStorage). */
-export interface SyncKVNamespace extends KVNamespace {
-    getSync(key: string): string | null;
-    putSync(key: string, value: string, options?: {
+/** Synchronous KV used when JSPI is unavailable (e.g. localStorage). Same method names, sync returns. */
+export interface SyncKVNamespace {
+    get(key: string): string | null;
+    put(key: string, value: string, options?: {
         expiration?: number;
         expirationTtl?: number;
     }): void;
-    deleteSync(key: string): void;
-    listSync(options?: {
+    del(key: string): void;
+    list(options?: {
         prefix?: string;
     }): {
         keys: {
@@ -31,15 +34,10 @@ export interface SyncKVNamespace extends KVNamespace {
         }[];
     };
 }
-export { createMemoryKV } from "./kv/memory";
-export { createLocalStorageKV, type LocalStorageKVOptions } from "./kv/localstorage";
-export { createIndexedDbKV, type IndexedDbKVOptions } from "./kv/indexdb";
-export { createKVImports } from "./kv/extern";
-import { type IndexedDbKVOptions } from "./kv/indexdb";
-export type BrowserKVOptions = IndexedDbKVOptions & {
+export type BrowserKVOptions = IndexedDbOptions & {
     storagePrefix?: string;
     forceLocalStorage?: boolean;
 };
-export declare function hasJSPI(): boolean;
+export declare const hasJspi: boolean;
 /** Prefer IndexedDB when JSPI is available, otherwise localStorage. */
 export declare function createBrowserKVBindings(options?: BrowserKVOptions): Record<string, KVNamespace>;