@syncular/server 0.0.5-44 → 0.0.6-101

package/src/index.ts

@@ -27,3 +27,4 @@ export * from './snapshot-chunks';
 export type { SnapshotChunkStorage } from './snapshot-chunks/types';
 export * from './stats';
 export * from './subscriptions';
+export * from './sync';

package/src/notify.test.ts

@@ -1,8 +1,8 @@
 import { afterEach, beforeEach, describe, expect, it } from 'bun:test';
-import { createBunSqliteDb } from '../../dialect-bun-sqlite/src';
+import { createDatabase } from '@syncular/core';
+import { createBunSqliteDialect } from '../../dialect-bun-sqlite/src';
 import { createSqliteServerDialect } from '../../server-dialect-sqlite/src';
-import { createServerHandler } from './handlers';
-import { TableRegistry } from './handlers/registry';
+import { createServerHandler, createServerHandlerCollection } from './handlers';
 import { ensureSyncSchema } from './migrate';
 import { EXTERNAL_CLIENT_ID, notifyExternalDataChange } from './notify';
 import { pull } from './pull';
@@ -36,7 +36,10 @@ interface ClientDb {
 const dialect = createSqliteServerDialect();
 
 async function setupDb() {
-  const db = createBunSqliteDb<TestDb>({ path: ':memory:' });
+  const db = createDatabase<TestDb>({
+    dialect: createBunSqliteDialect({ path: ':memory:' }),
+    family: 'sqlite',
+  });
   await ensureSyncSchema(db, dialect);
 
   await db.schema
@@ -60,7 +63,7 @@ async function setupDb() {
 }
 
 describe('notifyExternalDataChange', () => {
-  let db: ReturnType<typeof createBunSqliteDb<TestDb>>;
+  let db: ReturnType<typeof createBunSqliteDialect<TestDb>>;
 
   beforeEach(async () => {
     db = await setupDb();
@@ -198,7 +201,7 @@ describe('notifyExternalDataChange', () => {
 });
 
 describe('pull re-bootstrap after external data change', () => {
-  let db: ReturnType<typeof createBunSqliteDb<TestDb>>;
+  let db: ReturnType<typeof createBunSqliteDialect<TestDb>>;
 
   beforeEach(async () => {
     db = await setupDb();
@@ -227,15 +230,14 @@ describe('pull re-bootstrap after external data change', () => {
       resolveScopes: async () => ({ catalog_id: '*' }),
     });
 
-    const handlers = new TableRegistry<TestDb>();
-    handlers.register(codesHandler);
+    const handlers = createServerHandlerCollection<TestDb>([codesHandler]);
 
     // 1. Initial bootstrap pull
     const firstPull = await pull({
       db,
       dialect,
       handlers,
-      actorId: 'u1',
+      auth: { actorId: 'u1' },
       request: {
         clientId: 'client-1',
         limitCommits: 10,
@@ -262,7 +264,7 @@ describe('pull re-bootstrap after external data change', () => {
       db,
       dialect,
       handlers,
-      actorId: 'u1',
+      auth: { actorId: 'u1' },
       request: {
         clientId: 'client-1',
         limitCommits: 10,
@@ -296,7 +298,7 @@ describe('pull re-bootstrap after external data change', () => {
       db,
       dialect,
       handlers,
-      actorId: 'u1',
+      auth: { actorId: 'u1' },
       request: {
         clientId: 'client-1',
         limitCommits: 10,
@@ -341,16 +343,17 @@ describe('pull re-bootstrap after external data change', () => {
       resolveScopes: async () => ({ catalog_id: '*' }),
     });
 
-    const handlers = new TableRegistry<TestDb>();
-    handlers.register(tasksHandler);
-    handlers.register(codesHandler);
+    const handlers = createServerHandlerCollection<TestDb>([
+      tasksHandler,
+      codesHandler,
+    ]);
 
     // 1. Bootstrap pull for tasks
     const firstPull = await pull({
       db,
       dialect,
       handlers,
-      actorId: 'u1',
+      auth: { actorId: 'u1' },
       request: {
         clientId: 'client-1',
         limitCommits: 10,
@@ -382,7 +385,7 @@ describe('pull re-bootstrap after external data change', () => {
       db,
       dialect,
       handlers,
-      actorId: 'u1',
+      auth: { actorId: 'u1' },
       request: {
         clientId: 'client-1',
         limitCommits: 10,
@@ -437,16 +440,17 @@ describe('pull re-bootstrap after external data change', () => {
       resolveScopes: async () => ({ catalog_id: '*' }),
     });
 
-    const handlers = new TableRegistry<TestDb>();
-    handlers.register(tasksHandler);
-    handlers.register(codesHandler);
+    const handlers = createServerHandlerCollection<TestDb>([
+      tasksHandler,
+      codesHandler,
+    ]);
 
     // 1. Bootstrap both subscriptions
     const firstPull = await pull({
       db,
       dialect,
       handlers,
-      actorId: 'u1',
+      auth: { actorId: 'u1' },
       request: {
         clientId: 'client-1',
         limitCommits: 10,
@@ -480,7 +484,7 @@ describe('pull re-bootstrap after external data change', () => {
       db,
       dialect,
       handlers,
-      actorId: 'u1',
+      auth: { actorId: 'u1' },
       request: {
         clientId: 'client-1',
         limitCommits: 10,

package/src/notify.ts

@@ -24,7 +24,7 @@ function toDialectJsonValue(
   value: unknown
 ): unknown {
   if (value === null || value === undefined) return null;
-  if (dialect.name === 'sqlite') return JSON.stringify(value);
+  if (dialect.family === 'sqlite') return JSON.stringify(value);
   return value;
 }
 

package/src/proxy/collection.ts

@@ -0,0 +1,39 @@
+import type { ProxyTableHandler } from './types';
+
+export interface ProxyHandlerCollection {
+  handlers: ProxyTableHandler[];
+  byTable: ReadonlyMap<string, ProxyTableHandler>;
+}
+
+export function createProxyHandlerCollection(
+  handlers: ProxyTableHandler[]
+): ProxyHandlerCollection {
+  const byTable = new Map<string, ProxyTableHandler>();
+  for (const handler of handlers) {
+    if (byTable.has(handler.table)) {
+      throw new Error(
+        `Proxy table handler already registered: ${handler.table}`
+      );
+    }
+    byTable.set(handler.table, handler);
+  }
+  return { handlers, byTable };
+}
+
+export function getProxyHandler(
+  collection: ProxyHandlerCollection,
+  tableName: string
+): ProxyTableHandler | undefined {
+  return collection.byTable.get(tableName);
+}
+
+export function getProxyHandlerOrThrow(
+  collection: ProxyHandlerCollection,
+  tableName: string
+): ProxyTableHandler {
+  const handler = collection.byTable.get(tableName);
+  if (!handler) {
+    throw new Error(`No proxy table handler for table: ${tableName}`);
+  }
+  return handler;
+}

package/src/proxy/handler.test.ts

@@ -1,11 +1,12 @@
 import { afterEach, beforeEach, describe, expect, it } from 'bun:test';
+import { createDatabase } from '@syncular/core';
 import type { Kysely } from 'kysely';
-import { createBunSqliteDb } from '../../../dialect-bun-sqlite/src';
+import { createBunSqliteDialect } from '../../../dialect-bun-sqlite/src';
 import { createSqliteServerDialect } from '../../../server-dialect-sqlite/src';
 import { ensureSyncSchema } from '../migrate';
 import type { SyncCoreDb } from '../schema';
+import { createProxyHandlerCollection } from './collection';
 import { executeProxyQuery } from './handler';
-import { ProxyTableRegistry } from './registry';
 
 interface TasksTable {
   id: string;
@@ -21,15 +22,20 @@ interface ProxyTestDb extends SyncCoreDb {
 describe('executeProxyQuery', () => {
   let db: Kysely<ProxyTestDb>;
   const dialect = createSqliteServerDialect();
-  const handlers = new ProxyTableRegistry().register({
-    table: 'tasks',
-    computeScopes: (row) => ({
-      user_id: String(row.user_id),
-    }),
-  });
+  const handlers = createProxyHandlerCollection([
+    {
+      table: 'tasks',
+      computeScopes: (row) => ({
+        user_id: String(row.user_id),
+      }),
+    },
+  ]);
 
   beforeEach(async () => {
-    db = createBunSqliteDb<ProxyTestDb>({ path: ':memory:' });
+    db = createDatabase<ProxyTestDb>({
+      dialect: createBunSqliteDialect({ path: ':memory:' }),
+      family: 'sqlite',
+    });
     await ensureSyncSchema(db, dialect);
 
     await db.schema

package/src/proxy/handler.ts

@@ -8,6 +8,7 @@ import type { Kysely, RawBuilder } from 'kysely';
 import { sql } from 'kysely';
 import type { ServerSyncDialect } from '../dialect/types';
 import type { SyncCoreDb } from '../schema';
+import { getProxyHandler, type ProxyHandlerCollection } from './collection';
 import {
   appendReturning,
   detectMutation,
@@ -15,7 +16,6 @@ import {
   hasReturningWildcard,
 } from './mutation-detector';
 import { createOplogEntries } from './oplog';
-import type { ProxyTableRegistry } from './registry';
 import type { ProxyQueryContext } from './types';
 
 export interface ExecuteProxyQueryArgs<DB extends SyncCoreDb = SyncCoreDb> {
@@ -23,8 +23,8 @@ export interface ExecuteProxyQueryArgs<DB extends SyncCoreDb = SyncCoreDb> {
   db: Kysely<DB>;
   /** Server sync dialect */
   dialect: ServerSyncDialect;
-  /** Proxy table registry for oplog generation */
-  handlers: ProxyTableRegistry;
+  /** Proxy table handlers for oplog generation */
+  handlers: ProxyHandlerCollection;
   /** Query context (actor/client IDs) */
   ctx: ProxyQueryContext;
   /** SQL query string */
@@ -111,7 +111,7 @@ export async function executeProxyQuery<DB extends SyncCoreDb>(
   }
 
   // Check if this table has a registered handler
-  const handler = handlers.get(mutation.tableName);
+  const handler = getProxyHandler(handlers, mutation.tableName);
   if (!handler) {
     // No handler registered - execute without oplog
     // This allows proxy operations on non-synced tables

package/src/proxy/index.ts

@@ -4,6 +4,14 @@
  * Server-side proxy functionality for database access.
  */
 
+// Oplog creation
+// Collections
+export {
+  createProxyHandlerCollection,
+  getProxyHandler,
+  getProxyHandlerOrThrow,
+  type ProxyHandlerCollection,
+} from './collection';
 // Query execution
 export {
   type ExecuteProxyQueryArgs,
@@ -12,7 +20,4 @@ export {
 } from './handler';
 // Mutation detection
 export { type DetectedMutation, detectMutation } from './mutation-detector';
-// Oplog creation
-// Registry
-export { ProxyTableRegistry } from './registry';
 // Types

package/src/proxy/oplog.ts

@@ -15,7 +15,7 @@ function toDialectJsonValue(
   value: unknown
 ): unknown {
   if (value === null || value === undefined) return null;
-  if (dialect.name === 'sqlite') return JSON.stringify(value);
+  if (dialect.family === 'sqlite') return JSON.stringify(value);
   return value;
 }
 

package/src/pull.ts

@@ -22,7 +22,12 @@ import {
 } from '@syncular/core';
 import type { Kysely } from 'kysely';
 import type { DbExecutor, ServerSyncDialect } from './dialect/types';
-import type { TableRegistry } from './handlers/registry';
+import {
+  getServerBootstrapOrderFor,
+  getServerHandlerOrThrow,
+  type ServerHandlerCollection,
+} from './handlers/collection';
+import type { ServerTableHandler, SyncServerAuth } from './handlers/types';
 import { EXTERNAL_CLIENT_ID } from './notify';
 import type { SyncCoreDb } from './schema';
 import {
@@ -30,8 +35,14 @@ import {
   readSnapshotChunkRefByPageKey,
 } from './snapshot-chunks';
 import type { SnapshotChunkStorage } from './snapshot-chunks/types';
+import {
+  createMemoryScopeCache,
+  type ScopeCacheBackend,
+} from './subscriptions/cache';
 import { resolveEffectiveScopesForSubscriptions } from './subscriptions/resolve';
 
+const defaultScopeCache = createMemoryScopeCache();
+
 function concatByteChunks(chunks: readonly Uint8Array[]): Uint8Array {
   if (chunks.length === 1) {
     return chunks[0] ?? new Uint8Array();
@@ -62,6 +73,20 @@ export interface PullResult {
   clientCursor: number;
 }
 
+interface PendingExternalChunkWrite {
+  snapshot: SyncSnapshot;
+  cacheLookup: {
+    partitionId: string;
+    scopeKey: string;
+    scope: string;
+    asOfCommitSeq: number;
+    rowCursor: string | null;
+    rowLimit: number;
+  };
+  rowFramePayload: Uint8Array;
+  expiresAt: string;
+}
+
 /**
  * Generate a stable cache key for snapshot chunks.
  */
@@ -241,12 +266,14 @@ async function readExternalDataChanges<DB extends SyncCoreDb>(
   }));
 }
 
-export async function pull<DB extends SyncCoreDb>(args: {
+export async function pull<
+  DB extends SyncCoreDb,
+  Auth extends SyncServerAuth,
+>(args: {
   db: Kysely<DB>;
   dialect: ServerSyncDialect;
-  handlers: TableRegistry<DB>;
-  actorId: string;
-  partitionId?: string;
+  handlers: ServerHandlerCollection<DB, Auth>;
+  auth: Auth;
   request: SyncPullRequest;
   /**
    * Optional snapshot chunk storage adapter.
@@ -254,10 +281,16 @@ export async function pull<DB extends SyncCoreDb>(args: {
    * instead of inline in the database.
    */
   chunkStorage?: SnapshotChunkStorage;
+  /**
+   * Optional shared scope cache backend.
+   * Request-local memoization is always applied, even with custom backends.
+   * Defaults to process-local memory cache.
+   */
+  scopeCache?: ScopeCacheBackend;
 }): Promise<PullResult> {
   const { request, dialect } = args;
   const db = args.db;
-  const partitionId = args.partitionId ?? 'default';
+  const partitionId = args.auth.partitionId ?? 'default';
   const requestedSubscriptionCount = Array.isArray(request.subscriptions)
     ? request.subscriptions.length
     : 0;
@@ -289,13 +322,15 @@ export async function pull<DB extends SyncCoreDb>(args: {
           50
         );
         const dedupeRows = request.dedupeRows === true;
+        const pendingExternalChunkWrites: PendingExternalChunkWrite[] = [];
 
         // Resolve effective scopes for each subscription
         const resolved = await resolveEffectiveScopesForSubscriptions({
           db,
-          actorId: args.actorId,
+          auth: args.auth,
           subscriptions: request.subscriptions ?? [],
           handlers: args.handlers,
+          scopeCache: args.scopeCache ?? defaultScopeCache,
         });
 
         const result = await dialect.executeInTransaction(db, async (trx) => {
@@ -347,7 +382,7 @@ export async function pull<DB extends SyncCoreDb>(args: {
           for (const sub of resolved) {
             const cursor = Math.max(-1, sub.cursor ?? -1);
             // Validate table handler exists (throws if not registered)
-            args.handlers.getOrThrow(sub.table);
+            getServerHandlerOrThrow(args.handlers, sub.table);
 
             if (
               sub.status === 'revoked' ||
@@ -379,9 +414,10 @@ export async function pull<DB extends SyncCoreDb>(args: {
                 latestExternalCommitForTable > cursor);
 
             if (needsBootstrap) {
-              const tables = args.handlers
-                .getBootstrapOrderFor(sub.table)
-                .map((handler) => handler.table);
+              const tables = getServerBootstrapOrderFor(
+                args.handlers,
+                sub.table
+              ).map((handler) => handler.table);
 
               const initState: SyncBootstrapState = {
                 asOfCommitSeq: maxCommitSeq,
@@ -462,63 +498,51 @@ export async function pull<DB extends SyncCoreDb>(args: {
                   const rowFramePayload = concatByteChunks(
                     bundle.rowFrameParts
                   );
-                  const sha256 = await sha256Hex(rowFramePayload);
                   const expiresAt = new Date(
                     Date.now() + Math.max(1000, bundle.ttlMs)
                   ).toISOString();
 
                   if (args.chunkStorage) {
-                    if (args.chunkStorage.storeChunkStream) {
-                      const { stream: bodyStream, byteLength } =
-                        await gzipBytesToStream(rowFramePayload);
-                      chunkRef = await args.chunkStorage.storeChunkStream({
+                    const snapshot: SyncSnapshot = {
+                      table: bundle.table,
+                      rows: [],
+                      chunks: [],
+                      isFirstPage: bundle.isFirstPage,
+                      isLastPage: bundle.isLastPage,
+                    };
+                    snapshots.push(snapshot);
+                    pendingExternalChunkWrites.push({
+                      snapshot,
+                      cacheLookup: {
                         partitionId,
                         scopeKey: cacheKey,
                         scope: bundle.table,
                         asOfCommitSeq: effectiveState.asOfCommitSeq,
                         rowCursor: bundle.startCursor,
                         rowLimit: bundleRowLimit,
-                        encoding: SYNC_SNAPSHOT_CHUNK_ENCODING,
-                        compression: SYNC_SNAPSHOT_CHUNK_COMPRESSION,
-                        sha256,
-                        byteLength,
-                        bodyStream,
-                        expiresAt,
-                      });
-                    } else {
-                      const compressedBody = await gzipBytes(rowFramePayload);
-                      chunkRef = await args.chunkStorage.storeChunk({
-                        partitionId,
-                        scopeKey: cacheKey,
-                        scope: bundle.table,
-                        asOfCommitSeq: effectiveState.asOfCommitSeq,
-                        rowCursor: bundle.startCursor,
-                        rowLimit: bundleRowLimit,
-                        encoding: SYNC_SNAPSHOT_CHUNK_ENCODING,
-                        compression: SYNC_SNAPSHOT_CHUNK_COMPRESSION,
-                        sha256,
-                        body: compressedBody,
-                        expiresAt,
-                      });
-                    }
-                  } else {
-                    const compressedBody = await gzipBytes(rowFramePayload);
-                    const chunkId = randomId();
-                    chunkRef = await insertSnapshotChunk(trx, {
-                      chunkId,
-                      partitionId,
-                      scopeKey: cacheKey,
-                      scope: bundle.table,
-                      asOfCommitSeq: effectiveState.asOfCommitSeq,
-                      rowCursor: bundle.startCursor,
-                      rowLimit: bundleRowLimit,
-                      encoding: SYNC_SNAPSHOT_CHUNK_ENCODING,
-                      compression: SYNC_SNAPSHOT_CHUNK_COMPRESSION,
-                      sha256,
-                      body: compressedBody,
+                      },
+                      rowFramePayload,
                       expiresAt,
                     });
+                    return;
                   }
+                  const sha256 = await sha256Hex(rowFramePayload);
+                  const compressedBody = await gzipBytes(rowFramePayload);
+                  const chunkId = randomId();
+                  chunkRef = await insertSnapshotChunk(trx, {
+                    chunkId,
+                    partitionId,
+                    scopeKey: cacheKey,
+                    scope: bundle.table,
+                    asOfCommitSeq: effectiveState.asOfCommitSeq,
+                    rowCursor: bundle.startCursor,
+                    rowLimit: bundleRowLimit,
+                    encoding: SYNC_SNAPSHOT_CHUNK_ENCODING,
+                    compression: SYNC_SNAPSHOT_CHUNK_COMPRESSION,
+                    sha256,
+                    body: compressedBody,
+                    expiresAt,
+                  });
                 }
 
                 snapshots.push({
@@ -539,7 +563,8 @@ export async function pull<DB extends SyncCoreDb>(args: {
               ) {
                 if (!nextState) break;
 
-                const nextTableName = nextState.tables[nextState.tableIndex];
+                const nextTableName: string | undefined =
+                  nextState.tables[nextState.tableIndex];
                 if (!nextTableName) {
                   if (activeBundle) {
                     activeBundle.isLastPage = true;
@@ -550,7 +575,8 @@ export async function pull<DB extends SyncCoreDb>(args: {
                   break;
                 }
 
-                const tableHandler = args.handlers.getOrThrow(nextTableName);
+                const tableHandler: ServerTableHandler<DB, Auth> =
+                  getServerHandlerOrThrow(args.handlers, nextTableName);
                 if (!activeBundle || activeBundle.table !== nextTableName) {
                   if (activeBundle) {
                     await flushSnapshotBundle(activeBundle);
@@ -568,16 +594,18 @@ export async function pull<DB extends SyncCoreDb>(args: {
                   };
                 }
 
-                const page = await tableHandler.snapshot(
-                  {
-                    db: trx,
-                    actorId: args.actorId,
-                    scopeValues: effectiveScopes,
-                    cursor: nextState.rowCursor,
-                    limit: limitSnapshotRows,
-                  },
-                  sub.params
-                );
+                const page: { rows: unknown[]; nextCursor: string | null } =
+                  await tableHandler.snapshot(
+                    {
+                      db: trx,
+                      actorId: args.auth.actorId,
+                      auth: args.auth,
+                      scopeValues: effectiveScopes,
+                      cursor: nextState.rowCursor,
+                      limit: limitSnapshotRows,
+                    },
+                    sub.params
+                  );
 
                 const rowFrames = encodeSnapshotRowFrames(page.rows ?? []);
                 activeBundle.rowFrameParts.push(rowFrames);
@@ -659,7 +687,6 @@ export async function pull<DB extends SyncCoreDb>(args: {
                   commitSeq: number;
                   createdAt: string;
                   actorId: string;
-                  changeId: number;
                   change: SyncChange;
                 }
               >();
@@ -682,11 +709,15 @@ export async function pull<DB extends SyncCoreDb>(args: {
                   scopes: r.scopes,
                 };
 
+                // Move row keys to insertion tail so Map iteration yields
+                // "latest change wins" order without a full array sort.
+                if (latestByRowKey.has(rowKey)) {
+                  latestByRowKey.delete(rowKey);
+                }
                 latestByRowKey.set(rowKey, {
                   commitSeq: r.commit_seq,
                   createdAt: r.created_at,
                   actorId: r.actor_id,
-                  changeId: r.change_id,
                   change,
                 });
               }
@@ -706,12 +737,8 @@ export async function pull<DB extends SyncCoreDb>(args: {
                 continue;
               }
 
-              const latest = Array.from(latestByRowKey.values()).sort(
-                (a, b) => a.commitSeq - b.commitSeq || a.changeId - b.changeId
-              );
-
               const commits: SyncCommit[] = [];
-              for (const item of latest) {
+              for (const item of latestByRowKey.values()) {
                 const lastCommit = commits[commits.length - 1];
                 if (!lastCommit || lastCommit.commitSeq !== item.commitSeq) {
                   commits.push({
@@ -817,6 +844,61 @@ export async function pull<DB extends SyncCoreDb>(args: {
           };
         });
 
+        const chunkStorage = args.chunkStorage;
+        if (chunkStorage && pendingExternalChunkWrites.length > 0) {
+          for (const pending of pendingExternalChunkWrites) {
+            let chunkRef = await readSnapshotChunkRefByPageKey(db, {
+              partitionId: pending.cacheLookup.partitionId,
+              scopeKey: pending.cacheLookup.scopeKey,
+              scope: pending.cacheLookup.scope,
+              asOfCommitSeq: pending.cacheLookup.asOfCommitSeq,
+              rowCursor: pending.cacheLookup.rowCursor,
+              rowLimit: pending.cacheLookup.rowLimit,
+              encoding: SYNC_SNAPSHOT_CHUNK_ENCODING,
+              compression: SYNC_SNAPSHOT_CHUNK_COMPRESSION,
+            });
+
+            if (!chunkRef) {
+              const sha256 = await sha256Hex(pending.rowFramePayload);
+              if (chunkStorage.storeChunkStream) {
+                const { stream: bodyStream, byteLength } =
+                  await gzipBytesToStream(pending.rowFramePayload);
+                chunkRef = await chunkStorage.storeChunkStream({
+                  partitionId: pending.cacheLookup.partitionId,
+                  scopeKey: pending.cacheLookup.scopeKey,
+                  scope: pending.cacheLookup.scope,
+                  asOfCommitSeq: pending.cacheLookup.asOfCommitSeq,
+                  rowCursor: pending.cacheLookup.rowCursor,
+                  rowLimit: pending.cacheLookup.rowLimit,
+                  encoding: SYNC_SNAPSHOT_CHUNK_ENCODING,
+                  compression: SYNC_SNAPSHOT_CHUNK_COMPRESSION,
+                  sha256,
+                  byteLength,
+                  bodyStream,
+                  expiresAt: pending.expiresAt,
+                });
+              } else {
+                const compressedBody = await gzipBytes(pending.rowFramePayload);
+                chunkRef = await chunkStorage.storeChunk({
+                  partitionId: pending.cacheLookup.partitionId,
+                  scopeKey: pending.cacheLookup.scopeKey,
+                  scope: pending.cacheLookup.scope,
+                  asOfCommitSeq: pending.cacheLookup.asOfCommitSeq,
+                  rowCursor: pending.cacheLookup.rowCursor,
+                  rowLimit: pending.cacheLookup.rowLimit,
+                  encoding: SYNC_SNAPSHOT_CHUNK_ENCODING,
+                  compression: SYNC_SNAPSHOT_CHUNK_COMPRESSION,
+                  sha256,
+                  body: compressedBody,
+                  expiresAt: pending.expiresAt,
+                });
+              }
+            }
+
+            pending.snapshot.chunks = [chunkRef];
+          }
+        }
+
         const durationMs = Math.max(0, Date.now() - startedAtMs);
         const stats = summarizePullResponse(result.response);