orez 0.2.25 → 0.2.27

package/src/cf-do/.wrangler/tmp/dev-qbho19/worker.js

@@ -0,0 +1,1059 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// worker.ts
+import { DurableObject } from "cloudflare:workers";
+
+// ../do-sql-tracking.ts
+var RETURNING_INTERNAL_PREFIX = "__orez_returning_";
+function trackedChangeRow(row, track) {
+  const allowed = track.rowColumns ? new Set(track.rowColumns) : null;
+  const out = {};
+  for (const [key, value] of Object.entries(row)) {
+    if (key.startsWith(RETURNING_INTERNAL_PREFIX)) continue;
+    if (allowed && !allowed.has(key)) continue;
+    out[key] = value;
+  }
+  return out;
+}
+__name(trackedChangeRow, "trackedChangeRow");
+
+// watermark.ts
+var WATERMARK_STATE_TABLE = "_zero_change_state";
+function quoteIdent(name) {
+  return `"${name.replace(/"/g, '""')}"`;
+}
+__name(quoteIdent, "quoteIdent");
+function finitePositiveNumber(value) {
+  const number = Number(value ?? 0);
+  return Number.isFinite(number) && number > 0 ? number : 0;
+}
+__name(finitePositiveNumber, "finitePositiveNumber");
+var DurableWatermarkState = class {
+  constructor(sql) {
+    this.sql = sql;
+  }
+  static {
+    __name(this, "DurableWatermarkState");
+  }
+  ensureTables() {
+    this.sql.exec(
+      "CREATE TABLE IF NOT EXISTS _zero_changes (watermark INTEGER PRIMARY KEY AUTOINCREMENT, table_name TEXT NOT NULL, op TEXT NOT NULL CHECK (op IN ('INSERT', 'UPDATE', 'DELETE')), row_data TEXT, old_data TEXT, created_at INTEGER NOT NULL DEFAULT (unixepoch()))"
+    );
+    this.sql.exec(
+      `CREATE TABLE IF NOT EXISTS ${quoteIdent(WATERMARK_STATE_TABLE)} (id INTEGER PRIMARY KEY CHECK (id = 1), last_value INTEGER NOT NULL DEFAULT 0)`
+    );
+    this.setWatermarkState(this.watermarkState());
+  }
+  next() {
+    return this.current() + 1;
+  }
+  mark(watermark) {
+    this.setWatermarkState(watermark);
+    this.updateWatermarkSequences(watermark);
+  }
+  current() {
+    this.ensureTables();
+    const state = this.watermarkState();
+    const row = this.sql.exec("SELECT COALESCE(MAX(watermark), 0) AS watermark FROM _zero_changes").one();
+    const tableWatermark = finitePositiveNumber(row?.watermark);
+    const sequenceWatermark = this.watermarkSequenceValue();
+    const watermark = Math.max(state, tableWatermark, sequenceWatermark);
+    if (watermark > state) this.setWatermarkState(watermark);
+    if (watermark > sequenceWatermark) this.updateWatermarkSequences(watermark);
+    return watermark;
+  }
+  watermarkState() {
+    try {
+      const table = quoteIdent(WATERMARK_STATE_TABLE);
+      const row = this.sql.exec(`SELECT last_value FROM ${table} WHERE id = 1`).one();
+      return finitePositiveNumber(row?.last_value);
+    } catch {
+      return 0;
+    }
+  }
+  setWatermarkState(watermark) {
+    const table = quoteIdent(WATERMARK_STATE_TABLE);
+    this.sql.exec(`INSERT OR IGNORE INTO ${table} (id, last_value) VALUES (1, 0)`);
+    this.sql.exec(`UPDATE ${table} SET last_value = ? WHERE id = 1`, watermark);
+  }
+  watermarkSequenceValue() {
+    let watermark = 0;
+    for (const name of this.watermarkSequenceTables()) {
+      try {
+        const row = this.sql.exec(`SELECT last_value, is_called FROM ${quoteIdent(name)} WHERE dummy = 1`).one();
+        if (!row || !row.is_called) continue;
+        watermark = Math.max(watermark, finitePositiveNumber(row.last_value));
+      } catch {
+      }
+    }
+    return watermark;
+  }
+  watermarkSequenceTables() {
+    return this.sql.exec(
+      "SELECT name FROM sqlite_master WHERE type='table' AND name LIKE '%zero_watermark%'"
+    ).toArray().map((row) => String(row.name || "")).filter(Boolean);
+  }
+  updateWatermarkSequences(watermark) {
+    for (const name of this.watermarkSequenceTables()) {
+      const table = quoteIdent(name);
+      try {
+        this.sql.exec(
+          `INSERT OR IGNORE INTO ${table} (dummy, last_value, is_called) VALUES (1, ?, 1)`,
+          watermark
+        );
+        this.sql.exec(
+          `UPDATE ${table} SET last_value = ?, is_called = 1 WHERE dummy = 1`,
+          watermark
+        );
+      } catch {
+      }
+    }
+  }
+};
+
+// worker.ts
+var SCHEMA_VERSION = 1;
+var SQL_ERROR_SNIPPET_RADIUS = 1600;
+var SQL_ERROR_FALLBACK_LIMIT = 4e3;
+function quoteIdent2(name) {
+  return `"${name.replace(/"/g, '""')}"`;
+}
+__name(quoteIdent2, "quoteIdent");
+function sqliteErrorOffset(message) {
+  const marker = "offset ";
+  const start = message.indexOf(marker);
+  if (start < 0) return null;
+  let index = start + marker.length;
+  let digits = "";
+  while (index < message.length) {
+    const code = message.charCodeAt(index);
+    if (code < 48 || code > 57) break;
+    digits += message[index];
+    index++;
+  }
+  if (!digits) return null;
+  const offset = Number(digits);
+  return Number.isFinite(offset) ? offset : null;
+}
+__name(sqliteErrorOffset, "sqliteErrorOffset");
+function sqlErrorSnippet(sql, message) {
+  const offset = sqliteErrorOffset(message);
+  if (offset !== null) {
+    const start = Math.max(0, offset - SQL_ERROR_SNIPPET_RADIUS);
+    const end = Math.min(sql.length, offset + SQL_ERROR_SNIPPET_RADIUS);
+    return `${start > 0 ? "..." : ""}${sql.slice(start, end)}${end < sql.length ? "..." : ""}`;
+  }
+  if (sql.length <= SQL_ERROR_FALLBACK_LIMIT) return sql;
+  return `${sql.slice(0, SQL_ERROR_FALLBACK_LIMIT)}...`;
+}
+__name(sqlErrorSnippet, "sqlErrorSnippet");
+var ZeroDO = class extends DurableObject {
+  static {
+    __name(this, "ZeroDO");
+  }
+  sql;
+  watermarks;
+  schemaTables = /* @__PURE__ */ new Set();
+  tableSchemas = /* @__PURE__ */ new Map();
+  constructor(ctx, env) {
+    super(ctx, env);
+    this.sql = ctx.storage.sql;
+    this.watermarks = new DurableWatermarkState(this.sql);
+  }
+  async fetch(request) {
+    const url = new URL(request.url);
+    if (request.method === "OPTIONS") {
+      return new Response(null, {
+        headers: {
+          "Access-Control-Allow-Origin": "*",
+          "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+          "Access-Control-Allow-Headers": "*"
+        }
+      });
+    }
+    if (url.pathname.startsWith("/sync/v") && url.pathname.endsWith("/connect"))
+      return this.handleSyncConnect(request, url);
+    if ((url.pathname === "/zero/push" || url.pathname === "/api/zero/push") && request.method === "POST")
+      return this.handleHttpPush(request);
+    if (url.pathname === "/exec" && request.method === "POST")
+      return this.handleExec(request);
+    if (url.pathname === "/batch" && request.method === "POST")
+      return this.handleBatch(request);
+    if (url.pathname === "/changes" && (request.method === "GET" || request.method === "POST"))
+      return this.handleChanges(request, url);
+    if (url.pathname === "/notify" && request.method === "POST")
+      return Response.json({ ok: true, cookie: this.cookie() });
+    return new Response("not found", { status: 404 });
+  }
+  // ── Zero sync protocol ──────────────────────────────────────────────────
+  handleSyncConnect(request, url) {
+    if (request.headers.get("upgrade")?.toLowerCase() !== "websocket") {
+      return new Response("expected websocket upgrade", { status: 426 });
+    }
+    const pair = new WebSocketPair();
+    const client = pair[0];
+    const server = pair[1];
+    const clientID = url.searchParams.get("clientID") || "anon";
+    const clientGroupID = url.searchParams.get("clientGroupID") || "default";
+    const userID = url.searchParams.get("userID") || "anon";
+    const wsid = url.searchParams.get("wsid") || crypto.randomUUID();
+    const baseCookie = url.searchParams.get("baseCookie");
+    this.ctx.acceptWebSocket(server);
+    server.serializeAttachment({
+      clientID,
+      clientGroupID,
+      userID,
+      cookie: baseCookie ? baseCookie : null,
+      initialized: false,
+      desiredTableNames: [],
+      desiredQueries: []
+    });
+    this.sendJSON(server, ["connected", { wsid, timestamp: Date.now() }]);
+    const secProtocol = request.headers.get("sec-websocket-protocol");
+    if (secProtocol) {
+      const initData = decodeInitConnection(secProtocol);
+      if (initData) {
+        const clientSchema = initData[1]?.clientSchema;
+        const patch = initData[1]?.desiredQueriesPatch || [];
+        this.applyDesiredQueries(server, patch, clientSchema);
+      }
+    }
+    return new Response(null, {
+      status: 101,
+      headers: secProtocol ? { "Sec-WebSocket-Protocol": secProtocol } : void 0,
+      webSocket: client
+    });
+  }
+  async webSocketMessage(socket, messageData) {
+    this.watermarks.ensureTables();
+    const ws = socket;
+    const attachment = this.readSocketAttachment(ws);
+    if (!attachment) return;
+    const message = this.parseMessage(messageData);
+    if (!message) return;
+    const body = message[1] || {};
+    switch (message[0]) {
+      case "initConnection":
+      case "changeDesiredQueries":
+        this.applyDesiredQueries(
+          ws,
+          body.desiredQueriesPatch || [],
+          body.clientSchema
+        );
+        break;
+      case "push":
+        this.handlePush(ws, attachment, message[1]);
+        break;
+      case "pull":
+        this.handlePull(ws, message[1]);
+        break;
+      case "ping":
+        this.sendJSON(ws, ["pong", {}]);
+        break;
+    }
+  }
+  webSocketClose(_socket, _code, _reason, _wasClean) {
+  }
+  applyDesiredQueries(socket, patch, clientSchema) {
+    const attachment = this.readSocketAttachment(socket);
+    if (!attachment) return;
+    if (clientSchema) this.ensureSchemaTables(clientSchema);
+    let nextAttachment = this.applyDesiredQueryPatch(attachment, patch);
+    socket.serializeAttachment(nextAttachment);
+    if (!nextAttachment.initialized) {
+      nextAttachment = this.sendSyncPoke(
+        socket,
+        { ...nextAttachment, initialized: true },
+        { lastMutationIDChanges: {}, rowsPatch: [] }
+      );
+    }
+    if (patch.length === 0) return;
+    const rowsPatch = [
+      { op: "clear" },
+      ...this.rowsPatchForTables(nextAttachment.desiredTableNames)
+    ];
+    this.sendSyncPoke(socket, nextAttachment, {
+      gotQueriesPatch: this.gotQueriesPatch(patch),
+      rowsPatch
+    });
+  }
+  applyDesiredQueryPatch(attachment, patch) {
+    const desiredQueries = /* @__PURE__ */ new Map();
+    for (const query of attachment.desiredQueries || [])
+      desiredQueries.set(query.hash, query.tableNames);
+    for (const op of patch) {
+      if (op.op === "clear") {
+        desiredQueries.clear();
+      } else if (op.op === "put" && op.hash) {
+        desiredQueries.set(op.hash, this.resolveTablesFromPatch([op]));
+      } else if (op.op === "del" && op.hash) {
+        desiredQueries.delete(op.hash);
+      }
+    }
+    const queries = [...desiredQueries.entries()].map(([hash, tableNames]) => ({
+      hash,
+      tableNames
+    }));
+    return {
+      ...attachment,
+      desiredQueries: queries,
+      desiredTableNames: [...new Set(queries.flatMap((query) => query.tableNames))]
+    };
+  }
+  gotQueriesPatch(patch) {
+    const got = [];
+    for (const op of patch) {
+      if (op.op === "clear") got.push({ op: "clear" });
+      else if (op.hash) got.push({ op: op.op, hash: op.hash });
+    }
+    return got;
+  }
+  rowsPatchForTables(tableNames) {
+    const rowsPatch = [];
+    for (const tn of tableNames) {
+      if (!this.tableExists(tn)) continue;
+      for (const row of this.readAllRows(tn))
+        rowsPatch.push({ op: "put", tableName: tn, value: row });
+    }
+    return rowsPatch;
+  }
+  resolveTablesFromPatch(patch) {
+    const tables = [];
+    for (const op of patch) {
+      const tableFromName = this.tableNameFromOperationName(op.name);
+      if (tableFromName) tables.push(tableFromName);
+      if (op.ast) this.extractTableFromAST(op.ast, tables);
+    }
+    return tables;
+  }
+  extractTableFromAST(ast, tables) {
+    if (ast?.table) tables.push(ast.table);
+    if (ast?.related)
+      for (const rel of ast.related) {
+        if (rel?.subquery?.table) tables.push(rel.subquery.table);
+        if (rel?.subquery?.related) this.extractTableFromAST(rel.subquery, tables);
+      }
+  }
+  handlePush(socket, attachment, body) {
+    const mutations = Array.isArray(body?.mutations) ? body.mutations : [];
+    const before = this.watermark();
+    const mutationResults = [];
+    const lastMutationIDChanges = {};
+    for (const m of mutations) {
+      const result = this.applyMutation(m);
+      mutationResults.push({ id: { clientID: m.clientID, id: m.id }, result });
+      lastMutationIDChanges[m.clientID] = m.id;
+    }
+    this.sendJSON(socket, ["pushResponse", { mutations: mutationResults }]);
+    const after = this.watermark();
+    const changes = after > before ? this.readChangesSince(before) : [];
+    const rowsPatch = changes.map((c) => this.syncRowPatchFromChange(c));
+    if (Object.keys(lastMutationIDChanges).length > 0 || rowsPatch.length > 0)
+      this.broadcastMutationPoke(attachment, {
+        lastMutationIDChanges,
+        rowsPatch
+      });
+  }
+  async handleHttpPush(request) {
+    try {
+      const body = await request.json();
+      const before = this.watermark();
+      const mutations = Array.isArray(body?.mutations) ? body.mutations : [];
+      const mutationResults = [];
+      const lastMutationIDChanges = {};
+      for (const m of mutations) {
+        const result = this.applyMutation(m);
+        mutationResults.push({ id: { clientID: m.clientID, id: m.id }, result });
+        lastMutationIDChanges[m.clientID] = m.id;
+      }
+      const after = this.watermark();
+      const changes = after > before ? this.readChangesSince(before) : [];
+      const rowsPatch = changes.map((c) => this.syncRowPatchFromChange(c));
+      if (Object.keys(lastMutationIDChanges).length > 0 || rowsPatch.length > 0)
+        this.broadcastPoke(body?.clientGroupID || "default", {
+          lastMutationIDChanges,
+          rowsPatch
+        });
+      return Response.json({ mutations: mutationResults });
+    } catch (err) {
+      return Response.json({ error: err.message }, { status: 500 });
+    }
+  }
+  handlePull(socket, body) {
+    this.sendJSON(socket, [
+      "pull",
+      {
+        requestID: body?.requestID || crypto.randomUUID(),
+        cookie: this.cookie(),
+        lastMutationIDChanges: {},
+        patch: []
+      }
+    ]);
+  }
+  // ── SQL execution endpoints ─────────────────────────────────────────────
+  async handleExec(request) {
+    let sql = "";
+    try {
+      const body = await request.json();
+      sql = body.sql;
+      const params = Array.isArray(body.params) ? body.params : [];
+      const result = body.track ? await this.ctx.storage.transaction(
+        () => this.executeSQL(sql, params, body.track)
+      ) : this.executeSQL(sql, params);
+      return Response.json(result);
+    } catch (err) {
+      const suffix = sql ? ` while executing: ${sqlErrorSnippet(sql, err.message)}` : "";
+      console.error(`[exec-500] ${err.message} :: SQL=${sql.slice(0, 800)}`);
+      return Response.json({ error: `${err.message}${suffix}` }, { status: 500 });
+    }
+  }
+  /** Execute multiple statements atomically via ctx.storage.transaction() */
+  async handleBatch(request) {
+    try {
+      const { statements } = await request.json();
+      const allRows = await this.ctx.storage.transaction(() => {
+        const results = [];
+        for (const statement of statements) {
+          const item = typeof statement === "string" ? { sql: statement } : statement;
+          if (!item?.sql?.trim()) continue;
+          try {
+            results.push(
+              this.executeSQL(
+                item.sql,
+                Array.isArray(item.params) ? item.params : [],
+                item.track
+              )
+            );
+          } catch (err) {
+            throw new Error(
+              `${err.message} while executing: ${sqlErrorSnippet(item.sql, err.message)}`
+            );
+          }
+        }
+        return results;
+      });
+      return Response.json({ results: allRows });
+    } catch (err) {
+      return Response.json({ error: err.message }, { status: 500 });
+    }
+  }
+  async handleChanges(request, url) {
+    try {
+      let watermark = Number(
+        url.searchParams.get("watermark") ?? url.searchParams.get("since") ?? 0
+      );
+      let limit = Number(url.searchParams.get("limit") ?? 1e3);
+      if (request.method === "POST") {
+        const body = await request.json().catch(() => ({}));
+        watermark = Number(body.watermark ?? body.since ?? watermark);
+        limit = Number(body.limit ?? limit);
+      }
+      if (!Number.isFinite(watermark) || watermark < 0) watermark = 0;
+      if (!Number.isFinite(limit) || limit <= 0) limit = 1e3;
+      return Response.json({
+        watermark: this.watermark(),
+        changes: this.readChangesSince(watermark).slice(0, Math.min(limit, 1e4))
+      });
+    } catch (err) {
+      return Response.json({ error: err.message }, { status: 500 });
+    }
+  }
+  executeSQL(sql, params = [], track) {
+    const cursor = this.sql.exec(sql, ...params);
+    const columns = Array.isArray(cursor.columnNames) ? cursor.columnNames : [];
+    const rows = this.cursorRows(cursor);
+    if (!track) return { rows, columns };
+    for (const row of rows) {
+      const trackedRow = trackedChangeRow(row, track);
+      if (track.operation === "DELETE")
+        this.appendTrackedChange(track.tableName, "DELETE", null, trackedRow);
+      else this.appendTrackedChange(track.tableName, track.operation, trackedRow, null);
+    }
+    return {
+      rows: track.returnRows ? rows : [],
+      columns: track.returnRows ? columns : [],
+      affectedRows: rows.length
+    };
+  }
+  cursorRows(cursor) {
+    return cursor.toArray().map((row) => {
+      const obj = {};
+      for (const k of Object.keys(row)) obj[k] = row[k];
+      return obj;
+    });
+  }
+  // ── CRUD operations ──────────────────────────────────────────────────────
+  applyMutation(mutation) {
+    if (mutation.type === "crud" && mutation.name === "_zero_crud") {
+      return this.applyCrudMutation(mutation);
+    }
+    if (mutation.name === "_zero_cleanupResults") return {};
+    if (mutation.type === "custom") return this.applyTableMutation(mutation);
+    return {
+      error: "app",
+      message: `unsupported mutation ${mutation.type}:${mutation.name}`
+    };
+  }
+  applyTableMutation(mutation) {
+    const [tableName, action] = this.tableActionFromMutationName(mutation.name);
+    if (!tableName || !action)
+      return { error: "app", message: `invalid mutation name ${mutation.name}` };
+    if (!this.tableExists(tableName))
+      return { error: "app", message: `unknown table ${tableName}` };
+    const value = mutation.args[0] || {};
+    const primaryKey = this.primaryKeyForTable(tableName, []);
+    if (action === "insert") this.insertRow(tableName, value, primaryKey);
+    else if (action === "upsert") this.upsertRow(tableName, value, primaryKey);
+    else if (action === "delete") this.deleteRow(tableName, value, primaryKey);
+    else this.updateRow(tableName, value, primaryKey);
+    return {};
+  }
+  tableActionFromMutationName(name) {
+    if (name.includes("|")) return name.split("|", 2);
+    return name.split(".", 2);
+  }
+  tableNameFromOperationName(name) {
+    if (!name) return null;
+    return name.split(/[.|]/, 1)[0] || null;
+  }
+  applyCrudMutation(mutation) {
+    const arg = mutation.args[0];
+    const ops = Array.isArray(arg?.ops) ? arg.ops : [];
+    for (const crud of ops) {
+      if (!crud?.tableName) return { error: "app", message: "invalid crud mutation" };
+      if (!this.tableExists(crud.tableName))
+        return { error: "app", message: `unknown table ${crud.tableName}` };
+      const value = crud.value || {};
+      const primaryKey = this.primaryKeyForTable(crud.tableName, crud.primaryKey || []);
+      if (crud.op === "insert") this.insertRow(crud.tableName, value, primaryKey);
+      else if (crud.op === "upsert") this.upsertRow(crud.tableName, value, primaryKey);
+      else if (crud.op === "update") this.updateRow(crud.tableName, value, primaryKey);
+      else if (crud.op === "delete") this.deleteRow(crud.tableName, value, primaryKey);
+    }
+    return {};
+  }
+  insertRow(tn, value, pk) {
+    if (this.readRowByPrimaryKey(tn, value, pk)) return;
+    const row = this.storageRow(tn, value, true);
+    const cols = Object.keys(row);
+    if (!cols.length) return;
+    const qc = cols.map((c) => quoteIdent2(c)).join(", ");
+    const ph = cols.map(() => "?").join(", ");
+    this.sql.exec(
+      `INSERT INTO ${quoteIdent2(tn)} (${qc}) VALUES (${ph})`,
+      ...cols.map((c) => row[c])
+    );
+    const next = this.readRowByPrimaryKey(tn, value, pk) || this.normalizeRow(tn, row);
+    this.appendChange(tn, "INSERT", next, null);
+  }
+  upsertRow(tn, value, pk) {
+    const existing = this.readRowByPrimaryKey(tn, value, pk);
+    if (existing) {
+      this.updateRow(tn, value, pk);
+      return;
+    }
+    this.insertRow(tn, value, pk);
+  }
+  updateRow(tn, value, pk) {
+    if (!pk.length) return;
+    const existing = this.readRowByPrimaryKey(tn, value, pk);
+    if (!existing) return;
+    const nk = Object.keys(value).filter((c) => !pk.includes(c));
+    if (!nk.length) return;
+    const storage = this.storageRow(tn, value, false);
+    this.sql.exec(
+      `UPDATE ${quoteIdent2(tn)} SET ${nk.map((c) => `${quoteIdent2(c)} = ?`).join(", ")} WHERE ${this.primaryKeyWhere(pk)}`,
+      ...nk.map((c) => storage[c]),
+      ...pk.map((c) => this.storageColumnValue(tn, c, value[c]))
+    );
+    const next = this.readRowByPrimaryKey(tn, value, pk);
+    if (next) this.appendChange(tn, "UPDATE", next, existing);
+  }
+  deleteRow(tn, value, pk) {
+    if (!pk.length) return;
+    const existing = this.readRowByPrimaryKey(tn, value, pk);
+    if (!existing) return;
+    this.sql.exec(
+      `DELETE FROM ${quoteIdent2(tn)} WHERE ${this.primaryKeyWhere(pk)}`,
+      ...pk.map((c) => this.storageColumnValue(tn, c, value[c]))
+    );
+    this.appendChange(tn, "DELETE", null, existing);
+  }
+  appendChange(tn, op, rowData, oldData) {
+    this.appendTrackedChange(tn, op, rowData, oldData);
+  }
+  appendTrackedChange(tableName, op, rowData, oldData) {
+    this.watermarks.ensureTables();
+    const watermark = this.watermarks.next();
+    this.sql.exec(
+      "INSERT INTO _zero_changes (watermark, table_name, op, row_data, old_data) VALUES (?, ?, ?, ?, ?)",
+      watermark,
+      tableName,
+      op,
+      rowData ? JSON.stringify(rowData) : null,
+      oldData ? JSON.stringify(oldData) : null
+    );
+    this.watermarks.mark(watermark);
+  }
+  readChangesSince(watermark) {
+    this.watermarks.ensureTables();
+    return this.sql.exec(
+      "SELECT watermark, table_name, op, row_data, old_data FROM _zero_changes WHERE watermark > ? ORDER BY watermark",
+      watermark
+    ).toArray().map((row) => ({
+      watermark: Number(row.watermark),
+      tableName: String(row.table_name),
+      op: String(row.op),
+      rowData: row.row_data ? JSON.parse(String(row.row_data)) : null,
+      oldData: row.old_data ? JSON.parse(String(row.old_data)) : null
+    }));
+  }
+  watermark() {
+    return this.watermarks.current();
+  }
+  ensureSchemaTables(clientSchema) {
+    this.ensureSchemaMetadataTable();
+    for (const [name, def] of Object.entries(clientSchema.tables)) {
+      this.tableSchemas.set(name, def);
+      this.sql.exec(
+        "INSERT OR REPLACE INTO _zero_schema_tables (name, schema_json) VALUES (?, ?)",
+        name,
+        JSON.stringify(def)
+      );
+      if (this.schemaTables.has(name)) continue;
+      const pk = def.primaryKey.map((c) => quoteIdent2(c));
+      const pkClause = pk.length ? `, PRIMARY KEY (${pk.join(", ")})` : "";
+      const colDefs = Object.entries(def.columns).map(([cn, cd]) => {
+        const t = {
+          string: "TEXT",
+          number: "REAL",
+          boolean: "INTEGER",
+          json: "TEXT",
+          bigint: "TEXT"
+        };
+        return `${quoteIdent2(cn)} ${t[cd.type] || "TEXT"}`;
+      });
+      this.sql.exec(
+        `CREATE TABLE IF NOT EXISTS ${quoteIdent2(name)} (${colDefs.join(", ")}${pkClause})`
+      );
+      this.schemaTables.add(name);
+    }
+  }
+  ensureSchemaMetadataTable() {
+    this.sql.exec(
+      "CREATE TABLE IF NOT EXISTS _zero_schema_tables (name TEXT PRIMARY KEY, schema_json TEXT NOT NULL)"
+    );
+  }
+  schemaForTable(tableName) {
+    const cached = this.tableSchemas.get(tableName);
+    if (cached) return cached;
+    try {
+      this.ensureSchemaMetadataTable();
+      const row = this.sql.exec("SELECT schema_json FROM _zero_schema_tables WHERE name = ?", tableName).one();
+      if (!row?.schema_json) return void 0;
+      const schema = JSON.parse(String(row.schema_json));
+      this.tableSchemas.set(tableName, schema);
+      return schema;
+    } catch {
+      return void 0;
+    }
+  }
+  tableExists(n) {
+    try {
+      return !!this.sql.exec("SELECT name FROM sqlite_master WHERE type='table' AND name=?", n).one();
+    } catch {
+      return false;
+    }
+  }
+  readAllRows(tn) {
+    try {
+      return this.sql.exec(`SELECT * FROM ${quoteIdent2(tn)}`).toArray().map((row) => this.normalizeRow(tn, row));
+    } catch {
+      return [];
+    }
+  }
+  readRowByPrimaryKey(tn, value, pk) {
+    if (!pk.length) return null;
+    try {
+      const row = this.sql.exec(
+        `SELECT * FROM ${quoteIdent2(tn)} WHERE ${this.primaryKeyWhere(pk)}`,
+        ...pk.map((c) => this.storageColumnValue(tn, c, value[c]))
+      ).one();
+      return row ? this.normalizeRow(tn, row) : null;
+    } catch {
+      return null;
+    }
+  }
+  primaryKeyWhere(pk) {
+    return pk.map((c) => `${quoteIdent2(c)} = ?`).join(" AND ");
+  }
+  primaryKeyForTable(tn, fallback) {
+    const schema = this.schemaForTable(tn);
+    if (schema?.primaryKey?.length) return schema.primaryKey;
+    return fallback;
+  }
+  storageRow(tn, value, includeMissingSchemaColumns) {
+    const schema = this.schemaForTable(tn);
+    const row = {};
+    if (schema && includeMissingSchemaColumns) {
+      for (const column of Object.keys(schema.columns))
+        row[column] = this.storageColumnValue(tn, column, value[column] ?? null);
+    }
+    for (const column of Object.keys(value)) {
+      if (value[column] !== void 0)
+        row[column] = this.storageColumnValue(tn, column, value[column]);
+    }
+    return row;
+  }
+  storageColumnValue(tn, column, value) {
+    if (value === void 0 || value === null) return null;
+    const type = this.schemaForTable(tn)?.columns?.[column]?.type;
+    if (type === "boolean") return value ? 1 : 0;
+    if (type === "json") return typeof value === "string" ? value : JSON.stringify(value);
+    if (type === "number") return Number(value);
+    if (type === "bigint") return String(value);
+    return value;
+  }
+  normalizeRow(tn, row) {
+    const schema = this.schemaForTable(tn);
+    const normalized = {};
+    for (const key of Object.keys(row)) {
+      const type = schema?.columns?.[key]?.type;
+      const value = row[key];
+      if (value === null || value === void 0) {
+        normalized[key] = null;
+      } else if (type === "boolean") {
+        normalized[key] = value === true || value === 1 || value === "1" || value === "true";
+      } else if (type === "number") {
+        normalized[key] = Number(value);
+      } else if (type === "json" && typeof value === "string") {
+        try {
+          normalized[key] = JSON.parse(value);
+        } catch {
+          normalized[key] = value;
+        }
+      } else {
+        normalized[key] = value;
+      }
+    }
+    return normalized;
+  }
+  sendSyncPoke(socket, attachment, part) {
+    const cookie = this.nextCookie();
+    const pokeID = crypto.randomUUID();
+    this.sendJSON(socket, [
+      "pokeStart",
+      {
+        pokeID,
+        baseCookie: attachment.cookie,
+        schemaVersions: {
+          minSupportedVersion: SCHEMA_VERSION,
+          maxSupportedVersion: SCHEMA_VERSION
+        },
+        timestamp: Date.now()
+      }
+    ]);
+    this.sendJSON(socket, ["pokePart", { pokeID, ...part }]);
+    this.sendJSON(socket, ["pokeEnd", { pokeID, cookie }]);
+    const nextAttachment = { ...attachment, cookie };
+    socket.serializeAttachment(nextAttachment);
+    return nextAttachment;
+  }
+  broadcastPoke(clientGroupID, part) {
+    for (const socket of this.ctx.getWebSockets()) {
+      const ws = socket;
+      const attachment = this.readSocketAttachment(ws);
+      if (!attachment) continue;
+      if (attachment.clientGroupID !== clientGroupID) continue;
+      this.sendSyncPoke(ws, attachment, part);
+    }
+  }
+  broadcastMutationPoke(sourceAttachment, part) {
+    const rowsPatch = part.rowsPatch || [];
+    const changedTables = new Set(
+      rowsPatch.map((op) => op?.tableName).filter((tableName) => !!tableName)
+    );
+    const hasLastMutationIDChanges = Object.keys(part.lastMutationIDChanges || {}).length > 0;
+    for (const socket of this.ctx.getWebSockets()) {
+      const ws = socket;
+      const attachment = this.readSocketAttachment(ws);
+      if (!attachment) continue;
+      if (attachment.userID !== sourceAttachment.userID) continue;
+      const isSourceClientGroup = attachment.clientGroupID === sourceAttachment.clientGroupID;
+      const wantsChangedRows = changedTables.size > 0 && attachment.desiredTableNames.some((tableName) => changedTables.has(tableName));
+      const nextPart = {};
+      if (wantsChangedRows) nextPart.rowsPatch = rowsPatch;
+      if (isSourceClientGroup && hasLastMutationIDChanges)
+        nextPart.lastMutationIDChanges = part.lastMutationIDChanges;
+      if (!nextPart.rowsPatch && !nextPart.lastMutationIDChanges) continue;
+      this.sendSyncPoke(ws, attachment, nextPart);
+    }
+  }
+  syncRowPatchFromChange(change) {
+    if (change.op === "DELETE")
+      return {
+        op: "del",
+        tableName: change.tableName,
+        id: this.primaryKeyValue(change.tableName, change.oldData || {})
+      };
+    return {
+      op: "put",
+      tableName: change.tableName,
+      value: this.normalizeRow(change.tableName, change.rowData || {})
+    };
+  }
+  primaryKeyValue(tableName, row) {
+    const pk = this.primaryKeyForTable(tableName, []);
+    if (pk.length) return Object.fromEntries(pk.map((column) => [column, row[column]]));
+    if ("id" in row) return { id: row.id };
+    return row;
+  }
+  cookie() {
+    return String(this.watermark()).padStart(20, "0");
+  }
+  nextCookie() {
+    const watermark = this.watermarks.next();
+    this.watermarks.mark(watermark);
+    return String(watermark).padStart(20, "0");
+  }
+  readSocketAttachment(socket) {
+    const attachment = socket.deserializeAttachment();
+    if (!attachment) return null;
+    return {
+      ...attachment,
+      initialized: attachment.initialized === true,
+      desiredTableNames: attachment.desiredTableNames || [],
+      desiredQueries: attachment.desiredQueries || []
+    };
+  }
+  sendJSON(socket, msg) {
+    try {
+      socket.send(JSON.stringify(msg));
+    } catch {
+    }
+  }
+  parseMessage(data) {
+    try {
+      return JSON.parse(typeof data === "string" ? data : new TextDecoder().decode(data));
+    } catch {
+      return null;
+    }
+  }
+};
+var worker_default = {
+  async fetch(request, env) {
+    const url = new URL(request.url);
+    const id = env.ZERO_DO.idFromName("singleton");
+    if (url.pathname.startsWith("/sync/v") && url.pathname.endsWith("/connect")) {
+      return env.ZERO_DO.get(id).fetch(request);
+    }
+    if ((url.pathname === "/zero/push" || url.pathname === "/api/zero/push") && request.method === "POST") {
+      return env.ZERO_DO.get(id).fetch(request);
+    }
+    if (url.pathname === "/exec" && request.method === "POST") {
+      return env.ZERO_DO.get(id).fetch(request);
+    }
+    if (url.pathname === "/batch" && request.method === "POST") {
+      return env.ZERO_DO.get(id).fetch(request);
+    }
+    if (url.pathname === "/changes" && (request.method === "GET" || request.method === "POST")) {
+      return env.ZERO_DO.get(id).fetch(request);
+    }
+    if (url.pathname === "/notify" && request.method === "POST") {
+      return env.ZERO_DO.get(id).fetch(request);
+    }
+    return new Response("not found", { status: 404 });
+  }
+};
+function decodeInitConnection(secProtocol) {
+  try {
+    const decoded = decodeURIComponent(secProtocol);
+    const bytes = Uint8Array.from(atob(decoded), (char) => char.charCodeAt(0));
+    const protocols = JSON.parse(new TextDecoder().decode(bytes));
+    const message = protocols.initConnectionMessage;
+    if (Array.isArray(message) && message[0] === "initConnection") {
+      return message;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+__name(decodeInitConnection, "decodeInitConnection");
+
+// ../../../soot/node_modules/wrangler/templates/middleware/middleware-ensure-req-body-drained.ts
+var drainBody = /* @__PURE__ */ __name(async (request, env, _ctx, middlewareCtx) => {
+  try {
+    return await middlewareCtx.next(request, env);
+  } finally {
+    try {
+      if (request.body !== null && !request.bodyUsed) {
+        const reader = request.body.getReader();
+        while (!(await reader.read()).done) {
+        }
+      }
+    } catch (e) {
+      console.error("Failed to drain the unused request body.", e);
+    }
+  }
+}, "drainBody");
+var middleware_ensure_req_body_drained_default = drainBody;
+
+// ../../../soot/node_modules/wrangler/templates/middleware/middleware-miniflare3-json-error.ts
+function reduceError(e) {
+  return {
+    name: e?.name,
+    message: e?.message ?? String(e),
+    stack: e?.stack,
+    cause: e?.cause === void 0 ? void 0 : reduceError(e.cause)
+  };
+}
+__name(reduceError, "reduceError");
+var jsonError = /* @__PURE__ */ __name(async (request, env, _ctx, middlewareCtx) => {
+  try {
+    return await middlewareCtx.next(request, env);
+  } catch (e) {
+    const error = reduceError(e);
+    return Response.json(error, {
+      status: 500,
+      headers: { "MF-Experimental-Error-Stack": "true" }
+    });
+  }
+}, "jsonError");
+var middleware_miniflare3_json_error_default = jsonError;
+
+// .wrangler/tmp/bundle-vYmw0E/middleware-insertion-facade.js
+var __INTERNAL_WRANGLER_MIDDLEWARE__ = [
+  middleware_ensure_req_body_drained_default,
+  middleware_miniflare3_json_error_default
+];
+var middleware_insertion_facade_default = worker_default;
+
+// ../../../soot/node_modules/wrangler/templates/middleware/common.ts
+var __facade_middleware__ = [];
+function __facade_register__(...args) {
+  __facade_middleware__.push(...args.flat());
+}
+__name(__facade_register__, "__facade_register__");
+function __facade_invokeChain__(request, env, ctx, dispatch, middlewareChain) {
+  const [head, ...tail] = middlewareChain;
+  const middlewareCtx = {
+    dispatch,
+    next(newRequest, newEnv) {
+      return __facade_invokeChain__(newRequest, newEnv, ctx, dispatch, tail);
+    }
+  };
+  return head(request, env, ctx, middlewareCtx);
+}
+__name(__facade_invokeChain__, "__facade_invokeChain__");
+function __facade_invoke__(request, env, ctx, dispatch, finalMiddleware) {
+  return __facade_invokeChain__(request, env, ctx, dispatch, [
+    ...__facade_middleware__,
+    finalMiddleware
+  ]);
+}
+__name(__facade_invoke__, "__facade_invoke__");
+
+// .wrangler/tmp/bundle-vYmw0E/middleware-loader.entry.ts
+var __Facade_ScheduledController__ = class ___Facade_ScheduledController__ {
+  constructor(scheduledTime, cron, noRetry) {
+    this.scheduledTime = scheduledTime;
+    this.cron = cron;
+    this.#noRetry = noRetry;
+  }
+  static {
+    __name(this, "__Facade_ScheduledController__");
+  }
+  #noRetry;
+  noRetry() {
+    if (!(this instanceof ___Facade_ScheduledController__)) {
+      throw new TypeError("Illegal invocation");
+    }
+    this.#noRetry();
+  }
+};
+function wrapExportedHandler(worker) {
+  if (__INTERNAL_WRANGLER_MIDDLEWARE__ === void 0 || __INTERNAL_WRANGLER_MIDDLEWARE__.length === 0) {
+    return worker;
+  }
+  for (const middleware of __INTERNAL_WRANGLER_MIDDLEWARE__) {
+    __facade_register__(middleware);
+  }
+  const fetchDispatcher = /* @__PURE__ */ __name(function(request, env, ctx) {
+    if (worker.fetch === void 0) {
+      throw new Error("Handler does not export a fetch() function.");
+    }
+    return worker.fetch(request, env, ctx);
+  }, "fetchDispatcher");
+  return {
+    ...worker,
+    fetch(request, env, ctx) {
+      const dispatcher = /* @__PURE__ */ __name(function(type, init) {
+        if (type === "scheduled" && worker.scheduled !== void 0) {
+          const controller = new __Facade_ScheduledController__(
+            Date.now(),
+            init.cron ?? "",
+            () => {
+            }
+          );
+          return worker.scheduled(controller, env, ctx);
+        }
+      }, "dispatcher");
+      return __facade_invoke__(request, env, ctx, dispatcher, fetchDispatcher);
+    }
+  };
+}
+__name(wrapExportedHandler, "wrapExportedHandler");
+function wrapWorkerEntrypoint(klass) {
+  if (__INTERNAL_WRANGLER_MIDDLEWARE__ === void 0 || __INTERNAL_WRANGLER_MIDDLEWARE__.length === 0) {
+    return klass;
+  }
+  for (const middleware of __INTERNAL_WRANGLER_MIDDLEWARE__) {
+    __facade_register__(middleware);
+  }
+  return class extends klass {
+    #fetchDispatcher = /* @__PURE__ */ __name((request, env, ctx) => {
+      this.env = env;
+      this.ctx = ctx;
+      if (super.fetch === void 0) {
+        throw new Error("Entrypoint class does not define a fetch() function.");
+      }
+      return super.fetch(request);
+    }, "#fetchDispatcher");
+    #dispatcher = /* @__PURE__ */ __name((type, init) => {
+      if (type === "scheduled" && super.scheduled !== void 0) {
+        const controller = new __Facade_ScheduledController__(
+          Date.now(),
+          init.cron ?? "",
+          () => {
+          }
+        );
+        return super.scheduled(controller);
+      }
+    }, "#dispatcher");
+    fetch(request) {
+      return __facade_invoke__(
+        request,
+        this.env,
+        this.ctx,
+        this.#dispatcher,
+        this.#fetchDispatcher
+      );
+    }
+  };
+}
+__name(wrapWorkerEntrypoint, "wrapWorkerEntrypoint");
+var WRAPPED_ENTRY;
+if (typeof middleware_insertion_facade_default === "object") {
+  WRAPPED_ENTRY = wrapExportedHandler(middleware_insertion_facade_default);
+} else if (typeof middleware_insertion_facade_default === "function") {
+  WRAPPED_ENTRY = wrapWorkerEntrypoint(middleware_insertion_facade_default);
+}
+var middleware_loader_entry_default = WRAPPED_ENTRY;
+export {
+  ZeroDO,
+  __INTERNAL_WRANGLER_MIDDLEWARE__,
+  middleware_loader_entry_default as default
+};
+//# sourceMappingURL=worker.js.map