orez 0.2.25 → 0.2.27

package/dist/cf-do/worker.js

@@ -1,69 +1,112 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZeroDO = void 0;
 // @ts-nocheck — cloudflare:workers types not available in orez
-const cloudflare_workers_1 = require("cloudflare:workers");
-// ── constants ─────────────────────────────────────────────────────────
+import { DurableObject } from 'cloudflare:workers';
+import { trackedChangeRow } from '../do-sql-tracking.js';
+import { DurableWatermarkState } from './watermark.js';
 const SCHEMA_VERSION = 1;
-// ── Durable Object ────────────────────────────────────────────────────
-class ZeroDO extends cloudflare_workers_1.DurableObject {
+const SQL_ERROR_SNIPPET_RADIUS = 1600;
+const SQL_ERROR_FALLBACK_LIMIT = 4000;
+function quoteIdent(name) {
+    return `"${name.replace(/"/g, '""')}"`;
+}
+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;
+}
+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)}...`;
+}
+export class ZeroDO extends DurableObject {
     sql;
-    initialized = false;
-    // track which tables have been created from clientSchema
+    watermarks;
     schemaTables = new Set();
+    tableSchemas = new Map();
     constructor(ctx, env) {
         super(ctx, env);
         this.sql = ctx.storage.sql;
+        this.watermarks = new DurableWatermarkState(this.sql);
     }
-    // ── fetch handler (HTTP + WebSocket upgrade) ────────────────────────
     async fetch(request) {
-        this.ensureInternalTables();
         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': '*' },
+                headers: {
+                    'Access-Control-Allow-Origin': '*',
+                    'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+                    'Access-Control-Allow-Headers': '*',
+                },
             });
         }
-        // Zero sync protocol WebSocket endpoint
-        if (url.pathname === '/sync/v49/connect') {
+        if (url.pathname.startsWith('/sync/v') && url.pathname.endsWith('/connect'))
             return this.handleSyncConnect(request, url);
-        }
-        // Push mutations via HTTP (used by app server to proxy pushes)
-        if (url.pathname === '/zero/push' && request.method === 'POST') {
+        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 WebSocket handler ────────────────────────────
+    // ── 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 socket = pair[1];
+        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 baseCookieParam = url.searchParams.get('baseCookie');
-        this.ctx.acceptWebSocket(socket);
-        const attachment = {
+        const wsid = url.searchParams.get('wsid') || crypto.randomUUID();
+        const baseCookie = url.searchParams.get('baseCookie');
+        this.ctx.acceptWebSocket(server);
+        server.serializeAttachment({
             clientID,
             clientGroupID,
             userID,
-            cookie: baseCookieParam || null,
+            cookie: baseCookie ? baseCookie : null,
+            initialized: false,
             desiredTableNames: [],
-        };
-        socket.serializeAttachment(attachment);
-        // Send connected message
-        this.sendJSON(socket, ['connected', { wsid: url.searchParams.get('wsid') || crypto.randomUUID(), timestamp: Date.now() }]);
-        // Decode init connection from Sec-WebSocket-Protocol header
+            desiredQueries: [],
+        });
+        this.sendJSON(server, ['connected', { wsid, timestamp: Date.now() }]);
         const secProtocol = request.headers.get('sec-websocket-protocol');
-        const initData = secProtocol ? this.decodeInitConnection(secProtocol) : null;
-        if (initData) {
-            const clientSchema = initData[1]?.clientSchema;
-            const patch = (initData[1]?.desiredQueriesPatch || []);
-            this.applyDesiredQueries(socket, patch, clientSchema);
+        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,
@@ -71,209 +114,400 @@ class ZeroDO extends cloudflare_workers_1.DurableObject {
             webSocket: client,
         });
     }
-    // ── WebSocket message handler ───────────────────────────────────────
     async webSocketMessage(socket, messageData) {
-        this.ensureInternalTables();
-        const socketState = socket;
-        const attachment = socketState.deserializeAttachment();
+        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': {
-                const patch = (message[1]?.desiredQueriesPatch || []);
-                const clientSchema = message[1]?.clientSchema;
-                this.applyDesiredQueries(socketState, patch, clientSchema);
+            case 'changeDesiredQueries':
+                this.applyDesiredQueries(ws, (body.desiredQueriesPatch || []), body.clientSchema);
                 break;
-            }
             case 'push':
-                this.handlePush(socketState, attachment, message[1]);
+                this.handlePush(ws, attachment, message[1]);
                 break;
-            case 'ping':
-                this.sendJSON(socketState, ['pong', {}]);
+            case 'pull':
+                this.handlePull(ws, message[1]);
                 break;
-            case 'deleteClients':
-            case 'closeConnection':
-            case 'ackMutationResponses':
-            case 'updateAuth':
-                // no-op for experiment
+            case 'ping':
+                this.sendJSON(ws, ['pong', {}]);
                 break;
         }
     }
-    async webSocketClose(socket, code, reason, wasClean) {
-        // cleanup if needed
-    }
-    // ── handle desired queries (initial data / query change) ────────────
+    webSocketClose(_socket, _code, _reason, _wasClean) { }
     applyDesiredQueries(socket, patch, clientSchema) {
-        const attachment = socket.deserializeAttachment();
+        const attachment = this.readSocketAttachment(socket);
         if (!attachment)
             return;
-        // Create tables from client schema
-        if (clientSchema) {
+        if (clientSchema)
             this.ensureSchemaTables(clientSchema);
-        }
-        // Track desired tables from AST references
-        const tableNames = this.resolveTablesFromPatch(patch);
-        const allTableNames = [...new Set([...attachment.desiredTableNames, ...tableNames])];
-        const nextAttachment = {
-            ...attachment,
-            desiredTableNames: allTableNames,
-        };
+        let nextAttachment = this.applyDesiredQueryPatch(attachment, patch);
         socket.serializeAttachment(nextAttachment);
-        // Send initial poke with all rows for desired tables
-        if (allTableNames.length > 0) {
-            const rowsPatch = [];
-            for (const tableName of allTableNames) {
-                if (!this.tableExists(tableName))
-                    continue;
-                const rows = this.readAllRows(tableName);
-                for (const row of rows) {
-                    rowsPatch.push({ op: 'put', tableName, value: row });
-                }
+        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 = 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]));
             }
-            if (rowsPatch.length > 0) {
-                this.sendSyncPoke(socket, attachment, { rowsPatch });
+            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))],
+        };
     }
-    // ── resolve table names from query AST ──────────────────────────────
-    resolveTablesFromPatch(patch) {
-        const tableNames = [];
+    gotQueriesPatch(patch) {
+        const got = [];
         for (const op of patch) {
-            if (!op.ast)
+            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;
-            // Extract table references from the AST
-            const tables = this.extractTableFromAST(op.ast);
-            tableNames.push(...tables);
+            for (const row of this.readAllRows(tn))
+                rowsPatch.push({ op: 'put', tableName: tn, value: row });
         }
-        return tableNames;
+        return rowsPatch;
     }
-    extractTableFromAST(ast) {
+    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) {
+        if (ast?.related)
             for (const rel of ast.related) {
                 if (rel?.subquery?.table)
                     tables.push(rel.subquery.table);
-                // recurse into nested related
-                if (rel?.subquery?.related) {
-                    tables.push(...this.extractTableFromAST(rel.subquery));
-                }
+                if (rel?.subquery?.related)
+                    this.extractTableFromAST(rel.subquery, tables);
             }
-        }
-        return tables;
     }
-    // ── handle push mutations ──────────────────────────────────────────
     handlePush(socket, attachment, body) {
         const mutations = Array.isArray(body?.mutations) ? body.mutations : [];
-        const beforeWatermark = this.currentWatermark();
+        const before = this.watermark();
         const mutationResults = [];
         const lastMutationIDChanges = {};
-        for (const mutation of mutations) {
-            if (mutation.type === 'crud' && mutation.name === '_zero_crud') {
-                this.applyCrudMutation(mutation);
-            }
-            mutationResults.push({
-                id: { clientID: mutation.clientID, id: mutation.id },
-                result: {},
-            });
-            lastMutationIDChanges[mutation.clientID] = mutation.id;
+        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;
         }
-        // Send push response
         this.sendJSON(socket, ['pushResponse', { mutations: mutationResults }]);
-        // Build poke from changes
-        const afterWatermark = this.currentWatermark();
-        if (afterWatermark > beforeWatermark) {
-            const changes = this.readChangesSince(beforeWatermark);
-            const rowsPatch = changes.map((change) => this.syncRowPatchFromChange(change));
-            if (rowsPatch.length > 0) {
-                this.broadcastPoke(attachment.clientGroupID, { lastMutationIDChanges, rowsPatch });
-            }
-        }
+        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,
+            });
     }
-    // ── HTTP push (used by app server proxy) ────────────────────────────
     async handleHttpPush(request) {
         try {
-            const body = await request.json();
+            const body = (await request.json());
+            const before = this.watermark();
             const mutations = Array.isArray(body?.mutations) ? body.mutations : [];
-            const beforeWatermark = this.currentWatermark();
-            for (const mutation of mutations) {
-                if (mutation.type === 'crud' && mutation.name === '_zero_crud') {
-                    this.applyCrudMutation(mutation);
-                }
+            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 afterWatermark = this.currentWatermark();
-            if (afterWatermark > beforeWatermark) {
-                const changes = this.readChangesSince(beforeWatermark);
-                const rowsPatch = changes.map((change) => this.syncRowPatchFromChange(change));
-                if (rowsPatch.length > 0) {
-                    this.broadcastPoke('default', { rowsPatch });
+            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 : [];
+            // Only wrap in ctx.storage.transaction() when the call has change-tracking
+            // side effects (executeSQL writes BOTH the user table AND _zero_changes,
+            // which must commit together to keep source-tab sync flicker-free). A
+            // bare /exec is single-statement and ctx.storage.sql already serializes;
+            // the transaction wrap was adding ~2-5ms × every call, which on chat's
+            // 27k-stmt boot pushed orez backend startup past chat's 60s wait-for-port.
+            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') ?? 1000);
+            if (request.method === 'POST') {
+                const body = (await request.json().catch(() => ({})));
+                watermark = Number(body.watermark ?? body.since ?? watermark);
+                limit = Number(body.limit ?? limit);
             }
-            return Response.json({ ok: true });
+            if (!Number.isFinite(watermark) || watermark < 0)
+                watermark = 0;
+            if (!Number.isFinite(limit) || limit <= 0)
+                limit = 1000;
+            return Response.json({
+                watermark: this.watermark(),
+                changes: this.readChangesSince(watermark).slice(0, Math.min(limit, 10_000)),
+            });
         }
         catch (err) {
             return Response.json({ error: err.message }, { status: 500 });
         }
     }
-    // ── apply a single CRUD mutation ────────────────────────────────────
+    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 || typeof crud !== 'object')
-                continue;
-            const tableName = crud.tableName;
-            if (!tableName || !this.tableExists(tableName))
-                continue;
+            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 || {};
-            if (crud.op === 'insert' || crud.op === 'upsert') {
-                this.upsertRow(tableName, value);
-            }
-            else if (crud.op === 'update') {
-                this.updateRow(tableName, value, crud.primaryKey || []);
-            }
-            else if (crud.op === 'delete') {
-                this.deleteRow(tableName, value, crud.primaryKey || []);
-            }
+            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) => quoteIdent(c)).join(', ');
+        const ph = cols.map(() => '?').join(', ');
+        this.sql.exec(`INSERT INTO ${quoteIdent(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);
     }
-    // ── row operations ──────────────────────────────────────────────────
-    upsertRow(tableName, value) {
-        const columns = Object.keys(value);
-        if (columns.length === 0)
+    updateRow(tn, value, pk) {
+        if (!pk.length)
             return;
-        const quotedCols = columns.map((c) => `"${c}"`).join(', ');
-        const placeholders = columns.map(() => '?').join(', ');
-        const updateSet = columns.map((c) => `"${c}" = ?`).join(', ');
-        this.sql.exec(`INSERT INTO "${tableName}" (${quotedCols}) VALUES (${placeholders}) ON CONFLICT DO UPDATE SET ${updateSet}`, ...columns.map((c) => value[c]), ...columns.map((c) => value[c]));
-        this.appendChange(tableName, 'INSERT', value, null);
-    }
-    updateRow(tableName, value, primaryKey) {
-        const nonKeyCols = Object.keys(value).filter((c) => !primaryKey.includes(c));
-        if (nonKeyCols.length === 0)
+        const existing = this.readRowByPrimaryKey(tn, value, pk);
+        if (!existing)
             return;
-        const updateSet = nonKeyCols.map((c) => `"${c}" = ?`).join(', ');
-        const whereClause = primaryKey.map((c) => `"${c}" = ?`).join(' AND ');
-        this.sql.exec(`UPDATE "${tableName}" SET ${updateSet} WHERE ${whereClause}`, ...nonKeyCols.map((c) => value[c]), ...primaryKey.map((c) => value[c]));
-        this.appendChange(tableName, 'UPDATE', value, null);
+        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 ${quoteIdent(tn)} SET ${nk.map((c) => `${quoteIdent(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(tableName, value, primaryKey) {
-        const whereClause = primaryKey.map((c) => `"${c}" = ?`).join(' AND ');
-        this.sql.exec(`DELETE FROM "${tableName}" WHERE ${whereClause}`, ...primaryKey.map((c) => value[c]));
-        this.appendChange(tableName, 'DELETE', null, value);
+    deleteRow(tn, value, pk) {
+        if (!pk.length)
+            return;
+        const existing = this.readRowByPrimaryKey(tn, value, pk);
+        if (!existing)
+            return;
+        this.sql.exec(`DELETE FROM ${quoteIdent(tn)} WHERE ${this.primaryKeyWhere(pk)}`, ...pk.map((c) => this.storageColumnValue(tn, c, value[c])));
+        this.appendChange(tn, 'DELETE', null, existing);
     }
-    // ── change tracking ─────────────────────────────────────────────────
-    appendChange(tableName, op, rowData, oldData) {
-        this.sql.exec('INSERT INTO _zero_changes (table_name, op, row_data, old_data) VALUES (?, ?, ?, ?)', tableName, op, rowData ? JSON.stringify(rowData) : null, oldData ? JSON.stringify(oldData) : null);
+    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) {
-        const cursor = this.sql.exec('SELECT watermark, table_name, op, row_data, old_data FROM _zero_changes WHERE watermark > ? ORDER BY watermark', watermark);
-        return cursor.toArray().map((row) => ({
+        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),
@@ -281,160 +515,307 @@ class ZeroDO extends cloudflare_workers_1.DurableObject {
             oldData: row.old_data ? JSON.parse(String(row.old_data)) : null,
         }));
     }
-    currentWatermark() {
-        const row = this.sql.exec('SELECT COALESCE(MAX(watermark), 0) AS watermark FROM _zero_changes').one();
-        return row?.watermark ?? 0;
-    }
-    // ── table management ────────────────────────────────────────────────
-    ensureInternalTables() {
-        if (this.initialized)
-            return;
-        this.initialized = true;
-        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())
-      )
-    `);
+    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;
-            this.createTable(name, def);
+            const pk = def.primaryKey.map((c) => quoteIdent(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 `${quoteIdent(cn)} ${t[cd.type] || 'TEXT'}`;
+            });
+            this.sql.exec(`CREATE TABLE IF NOT EXISTS ${quoteIdent(name)} (${colDefs.join(', ')}${pkClause})`);
             this.schemaTables.add(name);
         }
     }
-    createTable(name, def) {
-        const pkColumns = def.primaryKey.map((c) => `"${c}"`);
-        const pkClause = pkColumns.length > 0 ? `, PRIMARY KEY (${pkColumns.join(', ')})` : '';
-        const columnDefs = Object.entries(def.columns).map(([colName, colDef]) => {
-            const sqlType = this.mapZeroTypeToSQLite(colDef.type);
-            return `"${colName}" ${sqlType}`;
-        });
-        this.sql.exec(`CREATE TABLE IF NOT EXISTS "${name}" (${columnDefs.join(', ')}${pkClause})`);
+    ensureSchemaMetadataTable() {
+        this.sql.exec('CREATE TABLE IF NOT EXISTS _zero_schema_tables (name TEXT PRIMARY KEY, schema_json TEXT NOT NULL)');
     }
-    mapZeroTypeToSQLite(zeroType) {
-        switch (zeroType) {
-            case 'string': return 'TEXT';
-            case 'number': return 'REAL';
-            case 'boolean': return 'INTEGER';
-            case 'json': return 'TEXT';
-            case 'bigint': return 'TEXT';
-            default: return 'TEXT';
+    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 undefined;
+            const schema = JSON.parse(String(row.schema_json));
+            this.tableSchemas.set(tableName, schema);
+            return schema;
+        }
+        catch {
+            return undefined;
         }
     }
-    tableExists(name) {
+    tableExists(n) {
         try {
-            const row = this.sql.exec(`SELECT name FROM sqlite_master WHERE type='table' AND name=?`, name).one();
-            return !!row;
+            return !!this.sql
+                .exec("SELECT name FROM sqlite_master WHERE type='table' AND name=?", n)
+                .one();
         }
         catch {
             return false;
         }
     }
-    readAllRows(tableName) {
+    readAllRows(tn) {
         try {
-            const cursor = this.sql.exec(`SELECT * FROM "${tableName}"`);
-            return cursor.toArray().map((row) => {
-                const result = {};
-                // SQLite DO returns columns as properties
-                for (const key of Object.keys(row)) {
-                    result[key] = row[key];
-                }
-                return result;
-            });
+            return this.sql
+                .exec(`SELECT * FROM ${quoteIdent(tn)}`)
+                .toArray()
+                .map((row) => this.normalizeRow(tn, row));
         }
         catch {
             return [];
         }
     }
-    // ── poke helpers ────────────────────────────────────────────────────
+    readRowByPrimaryKey(tn, value, pk) {
+        if (!pk.length)
+            return null;
+        try {
+            const row = this.sql
+                .exec(`SELECT * FROM ${quoteIdent(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) => `${quoteIdent(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] !== undefined)
+                row[column] = this.storageColumnValue(tn, column, value[column]);
+        }
+        return row;
+    }
+    storageColumnValue(tn, column, value) {
+        if (value === undefined || 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 === undefined) {
+                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 watermark = this.currentWatermark();
-        const cookie = String(watermark).padStart(20, '0');
+        const cookie = this.nextCookie();
         const pokeID = crypto.randomUUID();
-        this.sendJSON(socket, ['pokeStart', {
+        this.sendJSON(socket, [
+            'pokeStart',
+            {
                 pokeID,
                 baseCookie: attachment.cookie,
-                schemaVersions: { minSupportedVersion: SCHEMA_VERSION, maxSupportedVersion: SCHEMA_VERSION },
+                schemaVersions: {
+                    minSupportedVersion: SCHEMA_VERSION,
+                    maxSupportedVersion: SCHEMA_VERSION,
+                },
                 timestamp: Date.now(),
-            }]);
+            },
+        ]);
         this.sendJSON(socket, ['pokePart', { pokeID, ...part }]);
         this.sendJSON(socket, ['pokeEnd', { pokeID, cookie }]);
-        socket.serializeAttachment({ ...attachment, cookie });
+        const nextAttachment = { ...attachment, cookie };
+        socket.serializeAttachment(nextAttachment);
+        return nextAttachment;
     }
     broadcastPoke(clientGroupID, part) {
-        const websockets = this.ctx.getWebSockets();
-        for (const ws of websockets) {
-            const socket = ws;
-            const attachment = socket.deserializeAttachment();
+        for (const socket of this.ctx.getWebSockets()) {
+            const ws = socket;
+            const attachment = this.readSocketAttachment(ws);
             if (!attachment)
                 continue;
-            this.sendSyncPoke(socket, attachment, part);
+            if (attachment.clientGroupID !== clientGroupID)
+                continue;
+            this.sendSyncPoke(ws, attachment, part);
         }
     }
-    syncRowPatchFromChange(change) {
-        if (change.op === 'DELETE') {
-            const id = change.oldData ? this.extractID(change.oldData) : {};
-            return { op: 'del', tableName: change.tableName, id };
+    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);
         }
-        return { op: 'put', tableName: change.tableName, value: change.rowData };
     }
-    extractID(row) {
-        // For a simple id column, use it directly
-        if (row.id !== undefined)
+    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 };
-        // Otherwise use first key
-        const key = Object.keys(row)[0];
-        return key ? { [key]: row[key] } : {};
+        return row;
     }
-    // ── message helpers ─────────────────────────────────────────────────
-    sendJSON(socket, message) {
-        socket.send(JSON.stringify(message));
+    cookie() {
+        return String(this.watermark()).padStart(20, '0');
     }
-    parseMessage(data) {
-        try {
-            const text = typeof data === 'string' ? data : new TextDecoder().decode(data);
-            return JSON.parse(text);
-        }
-        catch {
+    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 { }
     }
-    decodeInitConnection(secProtocol) {
+    parseMessage(data) {
         try {
-            const decoded = atob(secProtocol);
-            return JSON.parse(decoded);
+            return JSON.parse(typeof data === 'string' ? data : new TextDecoder().decode(data));
         }
         catch {
             return null;
         }
     }
 }
-exports.ZeroDO = ZeroDO;
-// ── Worker entry ───────────────────────────────────────────────────────
-exports.default = {
+export default {
     async fetch(request, env) {
         const url = new URL(request.url);
-        // Route to DO: /sync/v49/connect → named DO instance
-        if (url.pathname === '/sync/v49/connect') {
-            const clientGroupID = url.searchParams.get('clientGroupID') || 'default';
-            const doId = env.ZERO_DO.idFromName(clientGroupID);
-            const stub = env.ZERO_DO.get(doId);
-            return stub.fetch(request);
-        }
-        // Push mutations via HTTP
-        if (url.pathname === '/zero/push' && request.method === 'POST') {
-            const doId = env.ZERO_DO.idFromName('default');
-            const stub = env.ZERO_DO.get(doId);
-            return stub.fetch(request);
+        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;
+    }
+}
 //# sourceMappingURL=worker.js.map