orez 0.2.27 → 0.2.30

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

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