@syncular/server 0.26.1 → 0.26.4

package/dist/d1-storage.js

@@ -583,6 +583,13 @@ export class D1ServerStorage {
     /** Set by `ensureSchema`: app-table lookup for the relational row store. */
     #tables;
     #schemaVersion;
+    /**
+     * Page reads waiting for the end of the current microtask turn. A pull
+     * starts the window read (or first snapshot page) of every subscription
+     * before awaiting any of them, so they leave as ONE `db.batch` round trip
+     * instead of one per subscription (SYNCULAR-PULL-ROUNDTRIPS-001).
+     */
+    #pendingReads;
     constructor(db, options = {}) {
         this.#db = db;
         this.#pushApplySerialized =
@@ -944,6 +951,47 @@ export class D1ServerStorage {
         return { complete: false, statementsExecuted };
     }
     /** Every protected read or write shares a transaction with its schema check. */
+    /** Queue one read into the current turn's `db.batch` (see `#pendingReads`). */
+    #batchedAll(sql, params) {
+        let pending = this.#pendingReads;
+        if (pending === undefined) {
+            const created = {
+                db: this.#schemaDatabase(),
+                entries: [],
+            };
+            pending = created;
+            this.#pendingReads = created;
+            queueMicrotask(() => {
+                this.#pendingReads = undefined;
+                created.db.batch(created.entries.map((entry) => entry.statement)).then((results) => {
+                    created.entries.forEach((entry, i) => {
+                        const result = results[i];
+                        if (typeof result !== 'object' ||
+                            result === null ||
+                            !('results' in result) ||
+                            !Array.isArray(result.results)) {
+                            entry.reject(new Error('D1 query returned an invalid batch result'));
+                        }
+                        else {
+                            entry.resolve(result.results);
+                        }
+                    });
+                }, (error) => {
+                    for (const entry of created.entries)
+                        entry.reject(error);
+                });
+            });
+        }
+        const target = pending;
+        const statement = target.db.prepare(sql).bind(...params);
+        return new Promise((resolve, reject) => {
+            target.entries.push({
+                statement,
+                resolve: (rows) => resolve(rows),
+                reject,
+            });
+        });
+    }
     #schemaDatabase() {
         if (this.#schemaVersion === undefined)
             throw new StorageQueryError('sync.storage.schema_changed');
@@ -1392,7 +1440,6 @@ export class D1ServerStorage {
         };
     }
     async readCommitWindow(partition, query) {
-        const db = this.#schemaDatabase();
         const variables = Object.keys(query.scopeFilter).sort();
         const firstVariable = variables[0];
         if (firstVariable === undefined)
@@ -1401,19 +1448,28 @@ export class D1ServerStorage {
         if (firstValues.length === 0)
             return [];
         // Candidates via the inverted index (one variable) LEFT JOINed to the
-        // commit meta + the table's changes — one D1 round trip per page, never
-        // two per candidate (see `commitWindowPageSql`). Exact multi-variable
-        // verification against the stored scope map in `collectCommitWindowPage`.
+        // commit meta + the table's changes — one statement per page, never two
+        // per candidate (see `commitWindowPageSql`), and concurrent pages share
+        // one D1 round trip. Exact multi-variable verification against the
+        // stored scope map in `collectCommitWindowPage`.
         const sql = commitWindowPageSql(firstValues.length, 'sqlite');
         const commits = [];
         let deliveredChanges = 0;
         let afterSeq = query.afterSeq;
         const batchSize = Math.max(64, query.limitChanges);
         while (deliveredChanges < query.limitChanges) {
-            const { results: records } = await db
-                .prepare(sql)
-                .bind(partition, query.table, firstVariable, ...firstValues, afterSeq, query.throughSeq, batchSize, partition, partition, query.table)
-                .all();
+            const records = await this.#batchedAll(sql, [
+                partition,
+                query.table,
+                firstVariable,
+                ...firstValues,
+                afterSeq,
+                query.throughSeq,
+                batchSize,
+                partition,
+                partition,
+                query.table,
+            ]);
             if (records.length === 0)
                 break;
             const page = collectCommitWindowPage(records, query.scopeFilter, query.limitChanges - deliveredChanges);
@@ -1426,23 +1482,28 @@ export class D1ServerStorage {
         return commits;
     }
     async scanRows(partition, query) {
-        const db = this.#schemaDatabase();
         const firstVariable = assertScopeIndexedScan(query);
         const firstValues = query.scopeFilter[firstVariable] ?? [];
         if (firstValues.length === 0)
             return [];
         // Candidates via the inverted index LEFT JOINed to the row table — one
-        // D1 round trip per page, never one per row (see `scanRowPageSql`).
+        // statement per page, never one per row (see `scanRowPageSql`), and
+        // concurrent pages share one D1 round trip.
         // Exact multi-variable verification against the stored scope map below.
         const sql = scanRowPageSql(this.table(query.table), firstValues.length, 'sqlite');
         const rows = [];
         let afterRowId = query.afterRowId ?? '';
         const batchSize = Math.max(64, query.limit);
         while (rows.length < query.limit) {
-            const { results: records } = await db
-                .prepare(sql)
-                .bind(partition, query.table, firstVariable, ...firstValues, afterRowId, batchSize, partition)
-                .all();
+            const records = await this.#batchedAll(sql, [
+                partition,
+                query.table,
+                firstVariable,
+                ...firstValues,
+                afterRowId,
+                batchSize,
+                partition,
+            ]);
             if (records.length === 0)
                 break;
             for (const record of records) {

package/dist/handler.js

@@ -14,7 +14,7 @@ import { clockOf, limitsOf, REMOTE_COMMAND_CLIENT_ID_PREFIX, RESOLVER_OUTAGE, to
 import { SyncError, syncError } from './errors.js';
 import { emitEvent, } from './events.js';
 import { END_FRAME_BYTES, encodeResponseFrame, responseEnvelopeHeader, } from './frame-bytes.js';
-import { ACCEPT_EXTERNAL_ROWS, ACCEPT_INLINE_ROWS, clampPullLimits, subscriptionSection, } from './pull.js';
+import { ACCEPT_EXTERNAL_ROWS, ACCEPT_INLINE_ROWS, clampPullLimits, prepareSections, preparedSection, } from './pull.js';
 import { processPushCommitWithTrace } from './push.js';
 import { serveNotReadyError } from './readiness.js';
 import { compileSchema } from './schema.js';
@@ -353,9 +353,13 @@ async function* streamResponse(plan, ctx, schema, report) {
             const limits = clampPullLimits(plan.pull);
             const maxSeq = await ctx.storage.getMaxCommitSeq(ctx.partition);
             const horizonSeq = await ctx.storage.getHorizonSeq(ctx.partition);
-            for (const subscription of plan.subscriptions) {
+            const prepared = await prepareSections(ctx, limits, plan.subscriptions, maxSeq, horizonSeq);
+            for (const [index, subscription] of plan.subscriptions.entries()) {
                 const trace = summaries !== undefined ? { segments: [] } : undefined;
-                const section = subscriptionSection(ctx, schema, limits, subscription, maxSeq, horizonSeq, trace, plan.logEpoch);
+                const reads = prepared[index];
+                if (reads === undefined)
+                    throw new Error('prepareSections lost a plan');
+                const section = preparedSection(ctx, schema, limits, subscription, maxSeq, reads, trace, plan.logEpoch);
                 let status = 'active';
                 let bootstrap = false;
                 let commits = 0;

package/dist/postgres-storage.js

@@ -5,7 +5,7 @@ import { serveNotReadyError } from './readiness.js';
 import { bindAuthoritativePartition, postgresPlaceholders, prepareAuthoritativeQuery, } from './authoritative-query.js';
 import { syncError } from './errors.js';
 import { asBytes, asNumber, } from './pg-executor.js';
-import { assertPhysicalColumns, assertStoredLayouts, commitWindowPageSql, deleteRowSql, dropTableDdl, indexRowPageStatement, layoutsOf, migratePayload, parseLayouts, retiredTableNames, rewritePlan, rewriteRowSql, rewriteValues, SCHEMA_META_DDL_POSTGRES, scanRowPageSql, schemaDdl, selectRowScopesSql, selectRowSql, selectRowsForRewriteSql, upsertSql, upsertValues, } from './relational-rows.js';
+import { assertPhysicalColumns, assertStoredLayouts, COMMIT_WINDOW_BATCH_SQL, deleteRowSql, dropTableDdl, indexRowPageStatement, layoutsOf, migratePayload, parseLayouts, retiredTableNames, rewritePlan, rewriteRowSql, rewriteValues, SCHEMA_META_DDL_POSTGRES, scanRowBatchSql, scanRowPageSql, schemaDdl, selectRowScopesSql, selectRowSql, selectRowsForRewriteSql, upsertSql, upsertValues, } from './relational-rows.js';
 import { matchesEffective } from './scopes.js';
 import { isPostgresConstraintError, StorageConstraintError, } from './storage-errors.js';
 import { assertScopeIndexedScan, resolveIndexRowScan } from './storage-query.js';
@@ -171,19 +171,21 @@ async function installCheckpointOn(client, partition, name, schemaVersion, nowMs
 }
 /** RFC 0007 serve gate on either the pool or a transaction's client. */
 async function readServeGateOn(client, partition, runningSchemaVersion) {
-    const marker = await client.query('SELECT schema_version FROM sync_schema_meta WHERE id=1');
-    const epoch = await client.query('SELECT log_epoch FROM sync_partition_registry WHERE partition=$1', [partition]);
-    const pending = await client.query(`SELECT partition, name FROM sync_backfill_checkpoints
-      WHERE schema_version=$1 AND state<>'activated'`, [runningSchemaVersion]);
+    // One statement: every request reads the gate twice (entry and verify),
+    // so its parts share one round trip and one snapshot.
+    const { rows } = await client.query(`SELECT (SELECT schema_version FROM sync_schema_meta WHERE id=1) AS schema_version,
+            (SELECT log_epoch FROM sync_partition_registry WHERE partition=$1) AS log_epoch,
+            (SELECT json_agg(json_build_object('partition', partition, 'name', name))
+               FROM sync_backfill_checkpoints
+              WHERE schema_version=$2 AND state<>'activated') AS pending`, [partition, runningSchemaVersion]);
+    const row = rows[0];
     return {
-        storedSchemaVersion: marker.rows[0] === undefined
-            ? 0
-            : asNumber(marker.rows[0].schema_version),
-        logEpoch: epoch.rows[0]?.log_epoch,
-        pending: pending.rows.map((row) => ({
-            partition: row.partition,
-            name: row.name,
-        })),
+        // asNumber maps the NULL of a missing marker row to 0.
+        storedSchemaVersion: asNumber(row?.schema_version),
+        logEpoch: row?.log_epoch ?? undefined,
+        pending: row?.pending === null || row?.pending === undefined
+            ? []
+            : asJson(row.pending),
     };
 }
 async function hasSourceChangesAboveOn(client, partition, tables, seq) {
@@ -725,9 +727,53 @@ export class PostgresServerStorage {
     /** Set by `ensureSchema`: app-table lookup for the relational row store. */
     #tables;
     #schemaVersion;
+    /**
+     * Page reads waiting for the end of the current microtask turn, keyed by
+     * statement and fixed params. A pull starts the window read (or first
+     * snapshot page) of every subscription before awaiting any of them, so the
+     * reads of one table leave as ONE set-based statement instead of one round
+     * trip per subscription (SYNCULAR-PULL-ROUNDTRIPS-001).
+     */
+    #pageBatches = new Map();
     constructor(exec) {
         this.#exec = exec;
     }
+    /**
+     * Queue one page read into the batch for (`sql`, `partition`, `table`).
+     * The batch runs as a single statement with the queued specs bound as a
+     * JSON array (`$2`); each spec gets its position as `i`, and the result
+     * rows are split back by their `sub` column.
+     */
+    #batchedPage(sql, partition, table, spec) {
+        const key = `${sql}\u0000${partition}\u0000${table}`;
+        let batch = this.#pageBatches.get(key);
+        if (batch === undefined) {
+            const queued = [];
+            batch = queued;
+            this.#pageBatches.set(key, queued);
+            queueMicrotask(() => {
+                this.#pageBatches.delete(key);
+                const specs = JSON.stringify(queued.map((entry, i) => ({ ...entry.spec, i })));
+                this.#exec.query(sql, [partition, specs, table]).then(({ rows }) => {
+                    const grouped = queued.map(() => []);
+                    for (const row of rows)
+                        grouped[asNumber(row.sub)]?.push(row);
+                    queued.forEach((entry, i) => entry.resolve(grouped[i] ?? []));
+                }, (error) => {
+                    for (const entry of queued)
+                        entry.reject(error);
+                });
+            });
+        }
+        const target = batch;
+        return new Promise((resolve, reject) => {
+            target.push({
+                spec,
+                resolve: (rows) => resolve(rows),
+                reject,
+            });
+        });
+    }
     /** Apply the schema DDL (idempotent). Call once before use. */
     async migrate() {
         // Split on the statement boundary so drivers that reject multi-statement
@@ -1313,25 +1359,22 @@ FOR EACH ROW EXECUTE FUNCTION syncular_writer_fence()`);
         // Candidates via the inverted index (one variable): the (partition, tbl,
         // var, value, commit_seq) PK makes the candidate subquery an index range
         // scan returning commit_seq already ascending (see postgres-explain
-        // .test.ts), LEFT JOINed to the commit meta + the table's changes — one
-        // round trip per page, never two per candidate (see
-        // `commitWindowPageSql`). Exact multi-variable verification against the
-        // stored scope map happens below.
-        const sql = commitWindowPageSql(firstValues.length, 'postgres');
+        // .test.ts), LEFT JOINed to the commit meta + the table's changes. Pages
+        // of concurrent window reads on the same table share one statement (see
+        // `COMMIT_WINDOW_BATCH_SQL`). Exact multi-variable verification against
+        // the stored scope map happens below.
         const commits = [];
         let deliveredChanges = 0;
         let afterSeq = query.afterSeq;
         const batchSize = Math.max(64, query.limitChanges);
         while (deliveredChanges < query.limitChanges) {
-            const { rows: records } = await this.#exec.query(sql, [
-                partition,
-                query.table,
-                firstVariable,
-                ...firstValues,
-                afterSeq,
-                query.throughSeq,
-                batchSize,
-            ]);
+            const records = await this.#batchedPage(COMMIT_WINDOW_BATCH_SQL, partition, query.table, {
+                var: firstVariable,
+                vals: firstValues,
+                after: afterSeq,
+                through: query.throughSeq,
+                lim: batchSize,
+            });
             if (records.length === 0)
                 break;
             // Fold the page: rows arrive ordered (commit_seq, idx); consecutive
@@ -1397,21 +1440,20 @@ FOR EACH ROW EXECUTE FUNCTION syncular_writer_fence()`);
             return [];
         // Candidates via the inverted index (ordered + LIMITed at the covering
         // PK) LEFT JOINed to the row table — one round trip per page, never one
-        // per row (see `scanRowPageSql`). Exact multi-variable verification
+        // per row, and pages of concurrent scans on the same table share one
+        // statement (see `scanRowBatchSql`). Exact multi-variable verification
         // against the stored scope map happens below.
-        const sql = scanRowPageSql(this.table(query.table), firstValues.length, 'postgres');
+        const sql = scanRowBatchSql(this.table(query.table));
         const rows = [];
         let afterRowId = query.afterRowId ?? '';
         const batchSize = Math.max(64, query.limit);
         while (rows.length < query.limit) {
-            const { rows: records } = await this.#exec.query(sql, [
-                partition,
-                query.table,
-                firstVariable,
-                ...firstValues,
-                afterRowId,
-                batchSize,
-            ]);
+            const records = await this.#batchedPage(sql, partition, query.table, {
+                var: firstVariable,
+                vals: firstValues,
+                after: afterRowId,
+                lim: batchSize,
+            });
             if (records.length === 0)
                 break;
             for (const record of records) {

package/dist/pull.d.ts

@@ -6,6 +6,7 @@ import { type PullHeaderFrame, type ResponseFrame, type ScopeMap, type Subscript
 import type { SyncRequestContext } from './context.js';
 import type { PullSegmentSummary } from './events.js';
 import type { CompiledSchema, CompiledTable } from './schema.js';
+import type { StoredCommit, StoredRow } from './storage.js';
 /** §4.2 accept bitmask. */
 export declare const ACCEPT_INLINE_ROWS: number;
 export declare const ACCEPT_EXTERNAL_ROWS: number;
@@ -37,8 +38,26 @@ export interface SubscriptionResult {
 export interface PullSectionTrace {
     readonly segments: PullSegmentSummary[];
 }
+/**
+ * The storage reads a section needs before its first frame. A pull starts
+ * them for every subscription before awaiting any, so a storage that batches
+ * concurrent page reads (PostgreSQL) answers all subscriptions of one table
+ * with one statement, and the horizon re-check runs once per pull.
+ */
+export interface PreparedSection {
+    /** §4.5 window read for an incremental cursor; empty when none was read. */
+    readonly commits: StoredCommit[];
+    /** Horizon to judge the cursor against, re-read after any window read. */
+    readonly horizonSeq: number;
+    /** First rows-lane snapshot page, read when the sqlite lane is excluded. */
+    readonly firstPage: StoredRow[] | undefined;
+}
+/** Run the pre-frame storage reads of every subscription concurrently. */
+export declare function prepareSections(ctx: SyncRequestContext, limits: PullLimits, plans: readonly SubscriptionPlan[], maxSeq: number, horizonSeq: number): Promise<PreparedSection[]>;
 /**
  * Produce the `SUB_START … SUB_END` section for one subscription (§1.6),
  * returning the cursor recorded for the retention watermark (§4.5).
  */
 export declare function subscriptionSection(ctx: SyncRequestContext, schema: CompiledSchema, limits: PullLimits, plan: SubscriptionPlan, maxSeq: number, horizonSeq: number, trace?: PullSectionTrace, logEpoch?: string): AsyncGenerator<ResponseFrame, SubscriptionResult>;
+/** The section of one subscription whose reads `prepareSections` ran. */
+export declare function preparedSection(ctx: SyncRequestContext, schema: CompiledSchema, limits: PullLimits, plan: SubscriptionPlan, maxSeq: number, prepared: PreparedSection, trace?: PullSectionTrace, logEpoch?: string): AsyncGenerator<ResponseFrame, SubscriptionResult>;

package/dist/pull.js

@@ -132,6 +132,19 @@ function segmentRefFrame(record, scopeDigest, extra) {
             : {}),
     };
 }
+/**
+ * §5.3: the sqlite-image lane — whole-table, chosen only at the start of a
+ * table (a mid-table resume stays on the rows lane, never switching lanes),
+ * and only when the client advertised bit 2. §5.11: a table with any
+ * encrypted column is image-INELIGIBLE — an image copies ciphertext
+ * wholesale with no per-row decrypt pass, so it MUST be served on the rows
+ * lane (which decrypts per row on the client).
+ */
+function sqliteLaneEligible(limits, plan, startRowCursor) {
+    return ((limits.accept & ACCEPT_SQLITE) !== 0 &&
+        startRowCursor === null &&
+        plan.table.encryptedColumnIndices.length === 0);
+}
 /**
  * §5.3 sqlite-image lane: only at the start of a table, only when the
  * client advertised bit 2, and only when the snapshot exceeds one rows
@@ -260,32 +273,26 @@ async function* sqliteImageSegment(ctx, schema, limits, plan, asOf, digest, trac
     yield segmentRefFrame(record, digest, await signedUrlFields(ctx, limits, record.segmentId, digest, clockOf(ctx)()));
     return true;
 }
-async function* bootstrapSegments(ctx, schema, limits, plan, asOf, startRowCursor, trace, logEpoch) {
+async function* bootstrapSegments(ctx, schema, limits, plan, asOf, startRowCursor, trace, logEpoch, firstPage) {
     const { storage, segments, partition } = ctx;
     const serverLimits = limitsOf(ctx);
     const digest = await scopeDigest(plan.effective);
     const now = clockOf(ctx)();
-    // §5.3: the sqlite-image lane — whole-table, chosen only at the start
-    // of a table (a mid-table resume stays on the rows lane, never
-    // switching lanes), and only when the client advertised bit 2.
-    // §5.11: a table with any encrypted column is image-INELIGIBLE — an image
-    // copies ciphertext wholesale with no per-row decrypt pass, so it MUST be
-    // served on the rows lane (which decrypts per row on the client).
-    if ((limits.accept & ACCEPT_SQLITE) !== 0 &&
-        startRowCursor === null &&
-        plan.table.encryptedColumnIndices.length === 0) {
+    if (sqliteLaneEligible(limits, plan, startRowCursor)) {
         const imaged = yield* sqliteImageSegment(ctx, schema, limits, plan, asOf, digest, trace, logEpoch);
         if (imaged)
             return { complete: true, rowCursor: null };
     }
     let rowCursor = startRowCursor;
     for (let page = 0; page < limits.maxSnapshotPages; page++) {
-        const scanned = await storage.scanRows(partition, {
-            table: plan.table.name,
-            scopeFilter: plan.effective,
-            afterRowId: rowCursor,
-            limit: limits.limitSnapshotRows + 1,
-        });
+        const scanned = page === 0 && firstPage !== undefined
+            ? firstPage
+            : await storage.scanRows(partition, {
+                table: plan.table.name,
+                scopeFilter: plan.effective,
+                afterRowId: rowCursor,
+                limit: limits.limitSnapshotRows + 1,
+            });
         const pageRows = scanned.slice(0, limits.limitSnapshotRows);
         const hasMore = scanned.length > limits.limitSnapshotRows;
         // §5.2: every row record carries the row's current server_version.
@@ -343,11 +350,73 @@ async function* bootstrapSegments(ctx, schema, limits, plan, asOf, startRowCurso
     }
     return { complete: false, rowCursor };
 }
+/** Run the pre-frame storage reads of every subscription concurrently. */
+export async function prepareSections(ctx, limits, plans, maxSeq, horizonSeq) {
+    const reads = plans.map((plan) => {
+        const sub = plan.frame;
+        if (plan.status === 'revoked')
+            return {};
+        const token = parseBootstrapToken(sub.bootstrapState, sub.table);
+        if (token === undefined &&
+            sub.cursor >= 0 &&
+            sub.cursor >= horizonSeq &&
+            sub.cursor <= maxSeq) {
+            return {
+                commits: ctx.storage.readCommitWindow(ctx.partition, {
+                    table: sub.table,
+                    scopeFilter: plan.effective,
+                    afterSeq: sub.cursor,
+                    throughSeq: maxSeq,
+                    limitChanges: limits.limitCommits + 1,
+                }),
+            };
+        }
+        // §4.6 reset: no reads.
+        if (token === undefined && sub.cursor >= 0 && sub.cursor < horizonSeq) {
+            return {};
+        }
+        // Bootstrapping: the same resume decision `preparedSection` makes (§4.7).
+        const startCursor = token !== undefined && token.asOfCommitSeq >= horizonSeq
+            ? token.rowCursor
+            : null;
+        if (sqliteLaneEligible(limits, plan, startCursor))
+            return {};
+        return {
+            firstPage: ctx.storage.scanRows(ctx.partition, {
+                table: plan.table.name,
+                scopeFilter: plan.effective,
+                afterRowId: startCursor,
+                limit: limits.limitSnapshotRows + 1,
+            }),
+        };
+    });
+    const settled = await Promise.all(reads.map(async (read) => ({
+        commits: read.commits === undefined ? undefined : await read.commits,
+        firstPage: await read.firstPage,
+    })));
+    // Validate continuity before committing to an active section. A prune
+    // during a paged read can otherwise make an incomplete window look empty.
+    const windowHorizon = settled.some((read) => read.commits !== undefined)
+        ? Math.max(horizonSeq, await ctx.storage.getHorizonSeq(ctx.partition))
+        : horizonSeq;
+    return settled.map((read) => ({
+        commits: read.commits ?? [],
+        horizonSeq: read.commits === undefined ? horizonSeq : windowHorizon,
+        firstPage: read.firstPage,
+    }));
+}
 /**
  * Produce the `SUB_START … SUB_END` section for one subscription (§1.6),
  * returning the cursor recorded for the retention watermark (§4.5).
  */
 export async function* subscriptionSection(ctx, schema, limits, plan, maxSeq, horizonSeq, trace, logEpoch) {
+    const [prepared] = await prepareSections(ctx, limits, [plan], maxSeq, horizonSeq);
+    if (prepared === undefined)
+        throw new Error('prepareSections lost a plan');
+    return yield* preparedSection(ctx, schema, limits, plan, maxSeq, prepared, trace, logEpoch);
+}
+/** The section of one subscription whose reads `prepareSections` ran. */
+export async function* preparedSection(ctx, schema, limits, plan, maxSeq, prepared, trace, logEpoch) {
     const sub = plan.frame;
     if (logEpoch === undefined || logEpoch.length === 0) {
         throw new Error('subscriptionSection requires a non-empty log epoch');
@@ -365,22 +434,7 @@ export async function* subscriptionSection(ctx, schema, limits, plan, maxSeq, ho
         return { nextCursor: sub.cursor, active: false };
     }
     const token = parseBootstrapToken(sub.bootstrapState, sub.table);
-    let commits = [];
-    if (token === undefined &&
-        sub.cursor >= 0 &&
-        sub.cursor >= horizonSeq &&
-        sub.cursor <= maxSeq) {
-        commits = await ctx.storage.readCommitWindow(ctx.partition, {
-            table: sub.table,
-            scopeFilter: plan.effective,
-            afterSeq: sub.cursor,
-            throughSeq: maxSeq,
-            limitChanges: limits.limitCommits + 1,
-        });
-        // Validate continuity before committing to an active section. A prune
-        // during a paged read can otherwise make an incomplete window look empty.
-        horizonSeq = Math.max(horizonSeq, await ctx.storage.getHorizonSeq(ctx.partition));
-    }
+    const { commits, horizonSeq } = prepared;
     // §4.6: a cursor behind the horizon (and not resuming a bootstrap)
     // cannot compute deltas — answer `reset` and echo the cursor.
     if (token === undefined && sub.cursor >= 0 && sub.cursor < horizonSeq) {
@@ -412,7 +466,7 @@ export async function* subscriptionSection(ctx, schema, limits, plan, maxSeq, ho
             effectiveScopes: plan.effective,
             bootstrap: true,
         };
-        const outcome = yield* bootstrapSegments(ctx, schema, limits, plan, asOf, startCursor, trace, logEpoch);
+        const outcome = yield* bootstrapSegments(ctx, schema, limits, plan, asOf, startCursor, trace, logEpoch, prepared.firstPage);
         if (outcome.complete) {
             yield { type: 'SUB_END', nextCursor: asOf };
         }

package/dist/relational-rows.d.ts

@@ -225,6 +225,30 @@ export declare function scanRowPageSql(table: CompiledTable, valueCount: number,
  *     again for the joins).
  */
 export declare function commitWindowPageSql(valueCount: number, dialect: RelationalDialect): string;
+/**
+ * PostgreSQL set-based form of `scanRowPageSql`: one statement answers the
+ * page of every subscription scanning `table` in a pull. `$2` is a JSON array
+ * of `{i, var, vals, after, lim}` records; each record runs the same
+ * index-first candidate subquery through a LATERAL join, so every
+ * subscription keeps its own keyset cursor and LIMIT. Rows arrive ordered
+ * by (i, row_id).
+ *
+ * Params: [partition, specs (JSON text), tbl]. The specs bind as text before
+ * the JSONB cast, so a driver that JSON-encodes a string bound to a `jsonb`
+ * parameter (Bun.sql) cannot turn the array into a JSON string.
+ */
+export declare function scanRowBatchSql(table: CompiledTable): string;
+/**
+ * PostgreSQL set-based form of `commitWindowPageSql`: one statement answers
+ * the window page of every subscription reading `tbl` in a pull. `$2` is a
+ * JSON array of `{i, var, vals, after, through, lim}` records, each running
+ * the same index-first candidate subquery through a LATERAL join. Rows
+ * arrive ordered by (i, commit_seq, idx).
+ *
+ * Params: [partition, specs (JSON text), tbl], the specs bound as text like
+ * `scanRowBatchSql`.
+ */
+export declare const COMMIT_WINDOW_BATCH_SQL = "SELECT s.i AS sub, c.commit_seq AS commit_seq, m.actor_id AS actor_id, m.created_at_ms AS created_at_ms,\n       ch.tbl AS tbl, ch.row_id AS row_id, ch.op AS op, ch.row_version AS row_version, ch.scopes AS scopes, ch.payload AS payload\n     FROM jsonb_to_recordset($2::text::jsonb) AS s(i int, var text, vals text[], after bigint, through bigint, lim int)\n     CROSS JOIN LATERAL (SELECT DISTINCT commit_seq FROM sync_change_scopes\n       WHERE partition=$1 AND tbl=$3 AND var=s.var AND value=ANY(s.vals)\n         AND commit_seq>s.after AND commit_seq<=s.through\n       ORDER BY commit_seq LIMIT s.lim) c\n     LEFT JOIN sync_commits m\n       ON m.partition=$1 AND m.commit_seq=c.commit_seq\n     LEFT JOIN sync_changes ch\n       ON ch.partition=$1 AND ch.commit_seq=c.commit_seq AND ch.tbl=$3\n     ORDER BY s.i, c.commit_seq, ch.idx";
 /** SELECT a row's version + scope map (admin/blob authz). Params: [partition, rowId]. */
 export declare function selectRowScopesSql(table: CompiledTable, dialect: RelationalDialect): string;
 /** DELETE one stored row. Params: [partition, rowId]. */

package/dist/relational-rows.js

@@ -548,6 +548,51 @@ export function commitWindowPageSql(valueCount, dialect) {
        ON ch.partition=${joinPartition} AND ch.commit_seq=c.commit_seq AND ch.tbl=${joinTbl}
      ORDER BY c.commit_seq, ch.idx`;
 }
+/**
+ * PostgreSQL set-based form of `scanRowPageSql`: one statement answers the
+ * page of every subscription scanning `table` in a pull. `$2` is a JSON array
+ * of `{i, var, vals, after, lim}` records; each record runs the same
+ * index-first candidate subquery through a LATERAL join, so every
+ * subscription keeps its own keyset cursor and LIMIT. Rows arrive ordered
+ * by (i, row_id).
+ *
+ * Params: [partition, specs (JSON text), tbl]. The specs bind as text before
+ * the JSONB cast, so a driver that JSON-encodes a string bound to a `jsonb`
+ * parameter (Bun.sql) cannot turn the array into a JSON string.
+ */
+export function scanRowBatchSql(table) {
+    return `SELECT s.i AS sub, c.row_id AS row_id, r.${quoteIdent(SYNC_VERSION_COLUMN)} AS server_version, r.${quoteIdent(SYNC_SCOPES_COLUMN)} AS scopes, r.${quoteIdent(SYNC_PAYLOAD_COLUMN)} AS payload, r.${quoteIdent(SYNC_COLUMN_VERSIONS_COLUMN)} AS column_versions
+     FROM jsonb_to_recordset($2::text::jsonb) AS s(i int, var text, vals text[], after text, lim int)
+     CROSS JOIN LATERAL (SELECT DISTINCT row_id FROM sync_row_scopes
+       WHERE partition=$1 AND tbl=$3 AND var=s.var AND value=ANY(s.vals)
+         AND row_id>s.after
+       ORDER BY row_id LIMIT s.lim) c
+     LEFT JOIN ${quoteIdent(table.name)} r
+       ON r.${quoteIdent(SYNC_PARTITION_COLUMN)}=$1 AND r.${quoteIdent(SYNC_ROW_ID_COLUMN)}=c.row_id
+     ORDER BY s.i, c.row_id`;
+}
+/**
+ * PostgreSQL set-based form of `commitWindowPageSql`: one statement answers
+ * the window page of every subscription reading `tbl` in a pull. `$2` is a
+ * JSON array of `{i, var, vals, after, through, lim}` records, each running
+ * the same index-first candidate subquery through a LATERAL join. Rows
+ * arrive ordered by (i, commit_seq, idx).
+ *
+ * Params: [partition, specs (JSON text), tbl], the specs bound as text like
+ * `scanRowBatchSql`.
+ */
+export const COMMIT_WINDOW_BATCH_SQL = `SELECT s.i AS sub, c.commit_seq AS commit_seq, m.actor_id AS actor_id, m.created_at_ms AS created_at_ms,
+       ch.tbl AS tbl, ch.row_id AS row_id, ch.op AS op, ch.row_version AS row_version, ch.scopes AS scopes, ch.payload AS payload
+     FROM jsonb_to_recordset($2::text::jsonb) AS s(i int, var text, vals text[], after bigint, through bigint, lim int)
+     CROSS JOIN LATERAL (SELECT DISTINCT commit_seq FROM sync_change_scopes
+       WHERE partition=$1 AND tbl=$3 AND var=s.var AND value=ANY(s.vals)
+         AND commit_seq>s.after AND commit_seq<=s.through
+       ORDER BY commit_seq LIMIT s.lim) c
+     LEFT JOIN sync_commits m
+       ON m.partition=$1 AND m.commit_seq=c.commit_seq
+     LEFT JOIN sync_changes ch
+       ON ch.partition=$1 AND ch.commit_seq=c.commit_seq AND ch.tbl=$3
+     ORDER BY s.i, c.commit_seq, ch.idx`;
 /** SELECT a row's version + scope map (admin/blob authz). Params: [partition, rowId]. */
 export function selectRowScopesSql(table, dialect) {
     const p = dialect === 'sqlite' ? ['?', '?'] : ['$1', '$2'];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syncular/server",
-  "version": "0.26.1",
+  "version": "0.26.4",
   "description": "Syncular server: handleSyncRequest + storage/auth interfaces for the sync protocol",
   "license": "Apache-2.0",
   "author": "Benjamin Kniffler",
@@ -68,7 +68,7 @@
     "verify:node": "cd ../.. && bun build ./packages/server/test/sqlite-runtime/verify-node.mjs --target=node --conditions=bun --outfile=./packages/server/.verify-node.built.mjs && node ./packages/server/.verify-node.built.mjs"
   },
   "dependencies": {
-    "@syncular/core": "0.26.1"
+    "@syncular/core": "0.26.4"
   },
   "devDependencies": {
     "@electric-sql/pglite": "^0.5.4"