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

package/platforms/cloudflare/kv.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Cloudflare KV implements the generic {@link KVNamespace} binding.
+ */
+export { createMemoryKV, createKVImports } from "../../runtime/kv";
+export type { KVNamespace } from "../../runtime/kv";

package/platforms/cloudflare/worker.d.ts

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

package/{vercel → platforms/vercel}/index.js

@@ -1,4 +1,4 @@
-// src/vercel/index.ts
+// src/platforms/vercel/index.ts
 function handle(app) {
   return (req) => app.fetch(req);
 }

package/runtime/db/extern.d.ts

@@ -0,0 +1,38 @@
+import { type WasmAllocRef } from "../../wasm/core";
+export type { WasmAllocRef };
+export type DbValue = null | string | number | boolean | ArrayBuffer | ArrayBufferView;
+/** Result of a mutating statement (`INSERT`/`UPDATE`/`DELETE`). */
+export interface ExecResult {
+    meta?: {
+        changes?: number;
+        last_row_id?: number;
+    };
+}
+/** Prepared statement - Cloudflare D1–shaped; Postgres/SQLite adapters implement the same. */
+export interface PreparedStatement {
+    bind(...values: DbValue[]): PreparedStatement;
+    first<T = Record<string, unknown>>(): Promise<T | null>;
+    all<T = Record<string, unknown>>(): Promise<{
+        results?: T[];
+    }>;
+    raw(options?: {
+        columnNames?: boolean;
+    }): Promise<unknown[][]>;
+    run(): Promise<ExecResult>;
+}
+/**
+ * SQL database binding for `__zx_db`.
+ * Shape matches Cloudflare D1 so Workers bindings work as-is; Postgres and other
+ * drivers adapt to this interface.
+ */
+export interface Database {
+    prepare(query: string): PreparedStatement;
+}
+/**
+ * Build the `__zx_db` host functions for SQL database bindings.
+ *
+ * ```ts
+ * if (__FEAT_DB__) importObject.__zx_db = createDbImports(bindings, getMemory, allocRef);
+ * ```
+ */
+export declare function createDbImports(bindings: Record<string, Database>, getMemory: () => WebAssembly.Memory, allocRef: WasmAllocRef): WebAssembly.ModuleImports;

package/runtime/db/sqlite.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Native SQLite client binding - not implemented yet.
+ * Server builds currently use the WASM `__zx_db` host via {@link createDbImports}.
+ */
+export declare const Sqlite: {
+    open(_path: string): never;
+};

package/runtime/db.d.ts

@@ -0,0 +1,3 @@
+export type { WasmAllocRef, DbValue, ExecResult, PreparedStatement, Database, } from "./db/extern";
+export { createDbImports } from "./db/extern";
+export { Sqlite } from "./db/sqlite";

package/runtime/db.js

@@ -0,0 +1,419 @@
+// ../../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");
+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 = encoder.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 = encoder.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 decoder.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)));
+}
+
+// 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 toDbValue(value) {
+  switch (value.kind) {
+    case "null":
+      return null;
+    case "integer":
+      return value.integer;
+    case "float":
+      return value.float;
+    case "text":
+      return value.text;
+    case "blob":
+      return decodeBlob(value.blob);
+    case "boolean":
+      return value.boolean;
+  }
+}
+function toPositionalBindings(json) {
+  switch (json.kind) {
+    case "none":
+      return [];
+    case "positional":
+      return json.values.map(toDbValue);
+    case "named":
+      throw new Error("named SQL bindings are not supported yet");
+  }
+}
+function toWireValue(value) {
+  if (value === null || value === void 0) return { kind: "null" };
+  if (typeof value === "string") return { kind: "text", text: value };
+  if (typeof value === "boolean") return { kind: "boolean", boolean: value };
+  if (typeof value === "number") {
+    return Number.isInteger(value) ? { kind: "integer", integer: value } : { kind: "float", float: value };
+  }
+  if (value instanceof ArrayBuffer) {
+    const bytes = new Uint8Array(value);
+    let binary = "";
+    for (const byte of bytes) binary += String.fromCharCode(byte);
+    return { kind: "blob", blob: btoa(binary) };
+  }
+  if (ArrayBuffer.isView(value)) {
+    const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    let binary = "";
+    for (const byte of bytes) binary += String.fromCharCode(byte);
+    return { kind: "blob", blob: btoa(binary) };
+  }
+  return { kind: "text", text: String(value) };
+}
+function objectToWireRow(record) {
+  return {
+    fields: Object.entries(record).map(([name, value]) => ({
+      name,
+      value: toWireValue(value)
+    }))
+  };
+}
+function valuesToWireRows(rows) {
+  return rows.map((row) => row.map((value) => toWireValue(value)));
+}
+function createDbImports(bindings, getMemory, allocRef) {
+  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;
+  }
+  async function statement(ns_ptr, ns_len, sql_ptr, sql_len, bindings_ptr, bindings_len) {
+    const database = binding(readStr(ns_ptr, ns_len));
+    if (!database) return null;
+    const sql = readStr(sql_ptr, sql_len);
+    const bindingsJson = JSON.parse(readStr(bindings_ptr, bindings_len));
+    return database.prepare(sql).bind(...toPositionalBindings(bindingsJson));
+  }
+  const Suspending = WebAssembly.Suspending;
+  if (typeof Suspending !== "function") {
+    return {
+      db_open: (_ns, _ns_len) => -1,
+      db_run: (_a, _b, _c, _d, _e, _f, _g) => -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, 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 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, 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) {
+        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, 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();
+      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, 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();
+      if (rows.length === 0) {
+        new DataView(getMemory().buffer).setUint32(out_ptr, 0, true);
+        return 0;
+      }
+      return writeJsonOut(getMemory, allocRef, out_ptr, valuesToWireRows(rows));
+    })
+  };
+}
+
+// src/runtime/db/sqlite.ts
+var Sqlite = {
+  open(_path) {
+    throw new Error("db/sqlite: not implemented yet");
+  }
+};
+export {
+  Sqlite,
+  createDbImports
+};

package/{fetch.d.ts → runtime/fetch.d.ts}

@@ -2,4 +2,4 @@
  * Create a `fetch` import object for blocking WASM fetch via JSPI.
  * When JSPI is unavailable the import always returns -1 (network error).
  */
-export declare function createFetchImports(getMemory: () => WebAssembly.Memory): Record<string, unknown>;
+export declare function createFetchImports(getMemory: () => WebAssembly.Memory): WebAssembly.ModuleImports;

package/{runtime.d.ts → runtime/index.d.ts}

@@ -1,6 +1,6 @@
 import type { WASI } from "./wasi";
-import type { KVNamespace } from "./kv";
-import type { D1Database } from "./db";
+import { type KVNamespace } from "./kv";
+import type { Database } from "./db";
 /** Minimal Durable Object namespace shape needed for WebSocket routing. */
 export type DurableObjectNamespace = {
     idFromName(name: string): unknown;
@@ -22,16 +22,7 @@ export type WsState = {
     isSubscribed?: (topic: string) => boolean;
 };
 /** Build the __zx_ws import object for a given connection state. */
-export declare function buildWsImports(Suspending: any, mem: () => WebAssembly.Memory, decoder: TextDecoder, ws: WsState): {
-    ws_upgrade: () => void;
-    ws_write: (ptr: number, len: number) => void;
-    ws_close: (code: number, reason_ptr: number, reason_len: number) => void;
-    ws_recv: any;
-    ws_subscribe: (ptr: number, len: number) => void;
-    ws_unsubscribe: (ptr: number, len: number) => void;
-    ws_publish: (topic_ptr: number, topic_len: number, data_ptr: number, data_len: number) => number;
-    ws_is_subscribed: (ptr: number, len: number) => number;
-};
+export declare function buildWsImports(Suspending: any, mem: () => WebAssembly.Memory, decoder: TextDecoder, ws: WsState): WebAssembly.ModuleImports;
 /** Create WebSocketPair, wire message/close listeners, flush pending writes. */
 export declare function attachWebSocket(ws: WsState): {
     client: WebSocket;
@@ -60,9 +51,9 @@ export declare function run({ request, env, ctx, module, kv: kvBindings, db: dbB
     module: WebAssembly.Module;
     /** KV namespace bindings - `{ default: env.KV, otherName: env.OTHER_KV }` */
     kv?: Record<string, KVNamespace>;
-    /** D1 bindings - `{ default: env.DB, analytics: env.ANALYTICS_DB }` */
-    db?: Record<string, D1Database>;
-    imports?: (mem: () => WebAssembly.Memory) => Record<string, Record<string, unknown>>;
+    /** DB bindings - `{ default: env.DB, analytics: env.ANALYTICS_DB }` */
+    db?: Record<string, Database>;
+    imports?: (mem: () => WebAssembly.Memory) => WebAssembly.Imports;
     wasi?: WASI;
     /**
      * Durable Object namespace to use for WebSocket connections.

package/runtime/kv/extern.d.ts

@@ -0,0 +1,11 @@
+import { type WasmAllocRef } from "../../wasm/core";
+import type { KVNamespace } from "../kv";
+export type { WasmAllocRef };
+/**
+ * Build the `__zx_kv` host functions for key/value namespace bindings.
+ *
+ * ```ts
+ * if (__FEAT_KV__) importObject.__zx_kv = createKVImports(bindings, getMemory, allocRef);
+ * ```
+ */
+export declare function createKVImports(bindings: Record<string, KVNamespace>, getMemory: () => WebAssembly.Memory, allocRef: WasmAllocRef): WebAssembly.ModuleImports;

package/runtime/kv/indexdb.d.ts

@@ -0,0 +1,7 @@
+import type { KVNamespace } from "../kv";
+export type IndexedDbKVOptions = {
+    databaseName?: string;
+    storeName?: string;
+    namespace?: string;
+};
+export declare function createIndexedDbKV(options?: IndexedDbKVOptions): KVNamespace;

package/runtime/kv/localstorage.d.ts

@@ -0,0 +1,6 @@
+import type { SyncKVNamespace } from "../kv";
+export type LocalStorageKVOptions = {
+    namespace?: string;
+    storagePrefix?: string;
+};
+export declare function createLocalStorageKV(options?: LocalStorageKVOptions): SyncKVNamespace;

package/runtime/kv/memory.d.ts

@@ -0,0 +1,6 @@
+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;

package/runtime/kv.d.ts

@@ -0,0 +1,45 @@
+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 interface KVNamespace {
+    get(key: string): Promise<string | null>;
+    put(key: string, value: string, options?: {
+        expiration?: number;
+        expirationTtl?: number;
+    }): Promise<void>;
+    delete(key: string): Promise<void>;
+    list(options?: {
+        prefix?: string;
+    }): Promise<{
+        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?: {
+        expiration?: number;
+        expirationTtl?: number;
+    }): void;
+    deleteSync(key: string): void;
+    listSync(options?: {
+        prefix?: string;
+    }): {
+        keys: {
+            name: string;
+        }[];
+    };
+}
+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 & {
+    storagePrefix?: string;
+    forceLocalStorage?: boolean;
+};
+export declare function hasJSPI(): boolean;
+/** Prefer IndexedDB when JSPI is available, otherwise localStorage. */
+export declare function createBrowserKVBindings(options?: BrowserKVOptions): Record<string, KVNamespace>;