@powersync/service-module-mongodb-storage 0.23.2 → 0.24.0

package/test/src/concurrent_writers.test.ts

@@ -1,4 +1,5 @@
 import { mongo } from '@powersync/lib-service-mongodb';
+import { ReplicationAbortedError } from '@powersync/lib-services-framework';
 import { storage, updateSyncRulesFromYaml } from '@powersync/service-core';
 import { test_utils } from '@powersync/service-core-tests';
 import { execFile } from 'node:child_process';
@@ -8,6 +9,9 @@ import { describe, expect, test, vi } from 'vitest';
 import { PersistedBatch } from '../../src/storage/implementation/common/PersistedBatch.js';
 import { MongoOpIdAllocator } from '../../src/storage/implementation/MongoOpIdAllocator.js';
 import { MongoPersistedReplicationStream } from '../../src/storage/implementation/MongoPersistedReplicationStream.js';
+import { PersistedBatchV1 } from '../../src/storage/implementation/v1/PersistedBatchV1.js';
+import { VersionedPowerSyncMongoV1 } from '../../src/storage/implementation/v1/VersionedPowerSyncMongoV1.js';
+import { PersistedBatchV3 } from '../../src/storage/implementation/v3/PersistedBatchV3.js';
 import { mongoTestStorageFactoryGenerator } from '../../src/utils/test-utils.js';
 import { env } from './env.js';
 
@@ -37,6 +41,10 @@ async function insert(writer: storage.BucketStorageBatch, table: storage.SourceT
 }
 
 describe.each([1, 2, 4])('concurrent writers v%s', (version) => {
+  const batchPrototype = version < 3 ? PersistedBatchV1.prototype : PersistedBatchV3.prototype;
+  const originalWrite = () => (version < 3 ? PersistedBatchV1.prototype.flush : PersistedBatchV3.prototype.publish);
+  const spyWrite = () =>
+    version < 3 ? vi.spyOn(PersistedBatchV1.prototype, 'flush') : vi.spyOn(PersistedBatchV3.prototype, 'publish');
   test('requires a lease to create a writer, including after another lease is released', async () => {
     await using factory = await factoryGen.factory();
     const stream = await factory.updateSyncRules(updateSyncRulesFromYaml(rules, { storageVersion: version }));
@@ -98,13 +106,10 @@ describe.each([1, 2, 4])('concurrent writers v%s', (version) => {
     await insert(writer, a.table, 'warmup');
     await writer.commit('1/2');
     // Force a split after each row without needing a transaction-sized fixture.
-    const split = vi.spyOn(PersistedBatch.prototype, 'shouldFlushTransaction').mockReturnValue(true);
-    const flush = PersistedBatch.prototype.flush;
+    const split = vi.spyOn(batchPrototype, 'shouldFlushTransaction').mockReturnValue(true);
+    const flush = originalWrite();
     const observed: bigint[] = [];
-    const inspect = vi.spyOn(PersistedBatch.prototype, 'flush').mockImplementation(async function (
-      this: PersistedBatch,
-      ...args
-    ) {
+    const inspect = spyWrite().mockImplementation(async function (this: PersistedBatch, ...args) {
       observed.push((await a.bucketStorage.getCheckpoint()).checkpoint);
       return flush.apply(this, args);
     });
@@ -206,15 +211,14 @@ describe.each([1, 2, 4])('concurrent writers v%s', (version) => {
     let admissions = 0;
     const admission = vi.spyOn(mutex, 'exclusiveLock').mockImplementation(function (callback) {
       const result = exclusiveLock.call(mutex, callback);
-      if (++admissions === 3) queued.resolve();
+      if (++admissions === 3) {
+        queued.resolve();
+      }
       return result;
     });
     const transactions = vi.spyOn(mongo.ClientSession.prototype, 'withTransaction');
-    const flush = PersistedBatch.prototype.flush;
-    const stalled = vi.spyOn(PersistedBatch.prototype, 'flush').mockImplementationOnce(async function (
-      this: PersistedBatch,
-      ...args
-    ) {
+    const flush = originalWrite();
+    const stalled = spyWrite().mockImplementationOnce(async function (this: PersistedBatch, ...args) {
       entered.resolve();
       await release.promise;
       return flush.apply(this, args);
@@ -246,17 +250,22 @@ describe.each([1, 2, 4])('concurrent writers v%s', (version) => {
     await using factory = await factoryGen.factory();
     const a = await openStream(factory, version);
     await using writerA = a.writer;
+    // Keep A active and B processing, so independent publication is tested
+    // without replacing/stopping A's config or activating B under A's fence.
+    if (version >= 3) {
+      await writerA.commit('1/1');
+    }
     // An independent factory/client has no shared allocator or in-process coordination.
     await using other = await factoryGen.factory({ doNotClear: true });
     const b = await openStream(other, version);
     await using writerB = b.writer;
+    if (version >= 3) {
+      await writerB.markTableSnapshotRequired(b.table);
+    }
     const entered = Promise.withResolvers<void>();
     const release = Promise.withResolvers<void>();
-    const flush = PersistedBatch.prototype.flush;
-    const stalled = vi.spyOn(PersistedBatch.prototype, 'flush').mockImplementationOnce(async function (
-      this: PersistedBatch,
-      ...args
-    ) {
+    const flush = originalWrite();
+    const stalled = spyWrite().mockImplementationOnce(async function (this: PersistedBatch, ...args) {
       entered.resolve();
       await release.promise;
       return flush.apply(this, args);
@@ -267,7 +276,8 @@ describe.each([1, 2, 4])('concurrent writers v%s', (version) => {
       await entered.promise;
       await insert(writerB, b.table, 'b');
       await writerB.commit('1/2');
-      expect((await b.bucketStorage.getCheckpoint()).checkpoint).toBeGreaterThan(1n);
+      expect(writerB.last_flushed_op).toBeGreaterThan(1n);
+      expect((await b.bucketStorage.getCheckpoint()).checkpoint).toBe(version >= 3 ? 0n : writerB.last_flushed_op);
       expect((await a.bucketStorage.getCheckpoint()).checkpoint).toBe(0n);
     } finally {
       release.resolve();
@@ -281,20 +291,23 @@ describe.each([1, 2, 4])('concurrent writers v%s', (version) => {
     expect(writerA.last_flushed_op).toBe(2n);
   });
 
-  test('another process can reserve and checkpoint while this process holds a stream transaction', async () => {
+  test('another process can reserve and commit progress while this process holds a stream transaction', async () => {
     await using factory = await factoryGen.factory();
     const a = await openStream(factory, version);
     await using writerA = a.writer;
+    if (version >= 3) {
+      await writerA.commit('1/1');
+    }
     const b = await openStream(factory, version);
+    if (version >= 3) {
+      await b.writer.markTableSnapshotRequired(b.table);
+    }
     await b.writer.dispose();
     await test_utils.releaseTestStorageLease(factory, b.stream.replicationStreamId);
     const entered = Promise.withResolvers<void>();
     const release = Promise.withResolvers<void>();
-    const flush = PersistedBatch.prototype.flush;
-    const stalled = vi.spyOn(PersistedBatch.prototype, 'flush').mockImplementationOnce(async function (
-      this: PersistedBatch,
-      ...args
-    ) {
+    const flush = originalWrite();
+    const stalled = spyWrite().mockImplementationOnce(async function (this: PersistedBatch, ...args) {
       entered.resolve();
       await release.promise;
       return flush.apply(this, args);
@@ -314,7 +327,7 @@ describe.each([1, 2, 4])('concurrent writers v%s', (version) => {
       ).catch((error) => {
         throw new Error(`${error.message}\n${error.stdout}\n${error.stderr}`);
       });
-      expect(child.stdout).toMatch(/checkpoint=[1-9][0-9]+/);
+      expect(child.stdout).toMatch(version >= 3 ? /persisted=[1-9][0-9]+/ : /checkpoint=[1-9][0-9]+/);
       expect((await a.bucketStorage.getCheckpoint()).checkpoint).toBe(0n);
     } finally {
       release.resolve();
@@ -328,11 +341,8 @@ describe.each([1, 2, 4])('concurrent writers v%s', (version) => {
     const { writer: batch, table, bucketStorage } = await openStream(factory, version);
     await using writer = batch;
     const reservations = vi.spyOn(MongoOpIdAllocator.prototype, 'reserve');
-    const flush = PersistedBatch.prototype.flush;
-    const retry = vi.spyOn(PersistedBatch.prototype, 'flush').mockImplementationOnce(async function (
-      this: PersistedBatch,
-      ...args
-    ) {
+    const flush = originalWrite();
+    const retry = spyWrite().mockImplementationOnce(async function (this: PersistedBatch, ...args) {
       await flush.apply(this, args);
       throw new mongo.MongoServerError({ message: 'retry', code: 112, errorLabels: ['TransientTransactionError'] });
     });
@@ -364,11 +374,8 @@ describe.each([1, 2, 4])('concurrent writers v%s', (version) => {
     const abort = new AbortController();
     await using writer = await a.bucketStorage.createWriter({ ...test_utils.BATCH_OPTIONS, signal: abort.signal });
     const table = await test_utils.resolveTestTable(writer, 'items', ['id'], factoryGen, a.stream.replicationStreamId);
-    const flush = PersistedBatch.prototype.flush;
-    const interrupted = vi.spyOn(PersistedBatch.prototype, 'flush').mockImplementationOnce(async function (
-      this: PersistedBatch,
-      ...args
-    ) {
+    const flush = originalWrite();
+    const interrupted = spyWrite().mockImplementationOnce(async function (this: PersistedBatch, ...args) {
       const result = await flush.apply(this, args);
       if (when === 'during flush') {
         abort.abort();
@@ -455,10 +462,18 @@ describe.each([1, 2, 4])('concurrent writers v%s', (version) => {
     await writerB.flush();
     const higher = writerB.last_flushed_op!;
     await insert(writerA, a.table, 'c');
-    await writerA.flush();
-    expect(writerA.last_flushed_op).toBeGreaterThan(higher);
-    await writerA.commit('1/2');
-    expect((await a.bucketStorage.getCheckpoint()).checkpoint).toBe(writerA.last_flushed_op);
+    if (version >= 3) {
+      // Independent allocators on the same lease can reserve disjoint ranges in
+      // the opposite order from publication. The stale writer must stop.
+      await expect(writerA.flush()).rejects.toThrow('does not advance persisted stream head');
+      expect(writerA.last_flushed_op).toBeLessThan(higher);
+      await expect(writerA.commit('1/2')).rejects.toThrow('restart replication from persisted progress');
+    } else {
+      await writerA.flush();
+      expect(writerA.last_flushed_op).toBeGreaterThan(higher);
+      await writerA.commit('1/2');
+      expect((await a.bucketStorage.getCheckpoint()).checkpoint).toBe(writerA.last_flushed_op);
+    }
   });
 
   test('lease takeover fences stale row, metadata, and checkpoint writes', async () => {
@@ -468,7 +483,7 @@ describe.each([1, 2, 4])('concurrent writers v%s', (version) => {
     const stream = initial.stream as MongoPersistedReplicationStream;
     await test_utils.releaseTestStorageLease(factory, stream.replicationStreamId);
     const first = await stream.lock();
-    await using firstLifetime = { [Symbol.asyncDispose]: () => first.release() };
+    await using _firstLifetime = { [Symbol.asyncDispose]: () => first.release() };
     await using oldWriter = await factory.getInstance(stream).createWriter(test_utils.BATCH_OPTIONS);
     await using oldCheckpointWriter = await factory.getInstance(stream).createWriter(test_utils.BATCH_OPTIONS);
     const oldTable = await test_utils.resolveTestTable(oldWriter, 'items', ['id'], factoryGen, 1);
@@ -482,7 +497,7 @@ describe.each([1, 2, 4])('concurrent writers v%s', (version) => {
     await using other = await factoryGen.factory({ doNotClear: true });
     const nextStream = (await other.getReplicatingReplicationStreams())[0];
     const next = await nextStream.lock();
-    await using nextLifetime = { [Symbol.asyncDispose]: () => next.release() };
+    await using _nextLifetime = { [Symbol.asyncDispose]: () => next.release() };
     await using nextWriter = await other.getInstance(nextStream).createWriter(test_utils.BATCH_OPTIONS);
     const nextTable = await test_utils.resolveTestTable(nextWriter, 'items', ['id'], factoryGen, 1);
     await insert(nextWriter, nextTable, 'new');
@@ -490,12 +505,12 @@ describe.each([1, 2, 4])('concurrent writers v%s', (version) => {
     expect(nextWriter.last_flushed_op).toBeGreaterThan(abandonedEnd);
     await insert(oldWriter, oldTable, 'stale');
     await expect(oldWriter.flush()).rejects.toThrow('no longer owns');
-    await expect(oldWriter.setResumeLsn('9/9')).rejects.toThrow('no longer owns');
-    await expect(oldWriter.markAllSnapshotDone('9/9')).rejects.toThrow('no longer owns');
-    await expect(oldWriter.markTableSnapshotRequired(oldTable)).rejects.toThrow('no longer owns');
-    await expect(oldWriter.commit('9/9')).rejects.toThrow('no longer owns');
+    await expect(oldWriter.setResumeLsn('9/9')).rejects.toBeInstanceOf(ReplicationAbortedError);
+    await expect(oldWriter.markAllSnapshotDone('9/9')).rejects.toBeInstanceOf(ReplicationAbortedError);
+    await expect(oldWriter.markTableSnapshotRequired(oldTable)).rejects.toBeInstanceOf(ReplicationAbortedError);
+    await expect(oldWriter.commit('9/9')).rejects.toBeInstanceOf(ReplicationAbortedError);
     // No pending rows: this exercises the checkpoint fence, not the flush fence.
-    await expect(oldCheckpointWriter.commit('9/9')).rejects.toThrow('no longer owns');
+    await expect(oldCheckpointWriter.commit('9/9')).rejects.toBeInstanceOf(ReplicationAbortedError);
     await first.release();
     expect((await factory.db.sync_rules.findOne({ _id: stream.replicationStreamId }))!.lock?.id).toBe(
       (next as typeof first).lock_id
@@ -511,7 +526,7 @@ describe.each([1, 2, 4])('concurrent writers v%s', (version) => {
       bucketStorage.replicationStream.current_lock!
     );
     await allocator.reserve();
-    allocator.committed(65_535n);
+    allocator.consume(65_535n);
     // Simulate capacity becoming insufficient after the pre-transaction check.
     // The fallback must still abort and retry safely in that case.
     const capacity = vi.spyOn(allocator, 'ensureCapacity');
@@ -525,7 +540,7 @@ describe.each([1, 2, 4])('concurrent writers v%s', (version) => {
       await writer.commit('1/2');
       expect(writer.last_flushed_op).toBe(65_537n);
       expect((await bucketStorage.getCheckpoint()).checkpoint).toBe(65_537n);
-      expect(sequences).toHaveBeenCalledTimes(fallback ? 2 : 1);
+      expect(sequences).toHaveBeenCalledTimes(version < 3 ? (fallback ? 2 : 1) : fallback ? 3 : 2);
     } finally {
       capacity.mockRestore();
       sequences.mockRestore();
@@ -533,11 +548,70 @@ describe.each([1, 2, 4])('concurrent writers v%s', (version) => {
   });
 });
 
+describe.each([1, 2])('legacy batch lifecycle v%s', (version) => {
+  test('clears a successful flush and can accumulate the next writes independently', async () => {
+    await using factory = await factoryGen.factory();
+    const context = await openStream(factory, version);
+    await using _writer = context.writer;
+    const db = factory.db.versioned(
+      context.bucketStorage.replicationStream.getStorageConfig()
+    ) as VersionedPowerSyncMongoV1;
+    const batch = new PersistedBatchV1(db, context.stream.replicationStreamId, 0);
+    await db.client.withSession(async (session) => {
+      for (const id of ['first', 'second']) {
+        batch.upsertCurrentData({
+          sourceTableId: context.table.id as mongo.ObjectId,
+          replicaId: test_utils.rid(id),
+          data: null,
+          buckets: [],
+          lookups: []
+        });
+        expect(batch.currentSize).toBeGreaterThan(0);
+        await session.withTransaction(async () => {
+          expect(await batch.flush(session)).toEqual({
+            bucketDataCount: 0,
+            parameterDataCount: 0,
+            currentDataCount: 1,
+            flushedAny: true
+          });
+        });
+        expect(batch.currentSize).toBe(0);
+      }
+    });
+    const records = await db.sourceRecordsV1.find({ '_id.g': context.stream.replicationStreamId }).toArray();
+    expect(records).toHaveLength(2);
+    expect(records.map((record) => record._id.k)).toEqual(
+      expect.arrayContaining([test_utils.rid('first'), test_utils.rid('second')])
+    );
+  });
+});
+
 describe('operation ID reservations', () => {
+  test('consumes abandoned IDs without advancing the durable head or discarding the unused tail', async () => {
+    await using factory = await factoryGen.factory();
+    const a = await openStream(factory, 4);
+    await using _writer = a.writer;
+    const allocator = factory.getOpIdAllocator(
+      a.bucketStorage.replicationStream,
+      a.bucketStorage.replicationStream.current_lock!
+    );
+    await allocator.reserve();
+    const sequence = allocator.sequence(0n);
+    expect(sequence.next()).toBe(1n);
+    expect(sequence.next()).toBe(2n);
+    allocator.consume(sequence.last());
+    // The sealed work is abandoned: a new sequence sees the same durable head.
+    expect(allocator.sequence(0n).next()).toBe(3n);
+    expect((await a.bucketStorage.getCheckpoint()).checkpoint).toBe(0n);
+    const watermark = (await factory.db.op_id_sequence.findOne({ _id: 'main' }))!.op_id;
+    await allocator.ensureCapacity();
+    expect((await factory.db.op_id_sequence.findOne({ _id: 'main' }))!.op_id).toBe(watermark);
+  });
+
   test('initializes and reserves disjoint ranges concurrently in one command each', async () => {
     await using factory = await factoryGen.factory();
     const a = await openStream(factory, 4);
-    await using writer = a.writer;
+    await using _writer = a.writer;
     const db = factory.db.versioned(a.bucketStorage.replicationStream.getStorageConfig());
     const allocators = Array.from({ length: 4 }, () => new MongoOpIdAllocator(db));
     const initialize = vi.spyOn(db.op_id_sequence, 'updateOne');
@@ -557,20 +631,20 @@ describe('operation ID reservations', () => {
   test('refills below 16k remaining IDs, preserving the tail across disjoint ranges', async () => {
     await using factory = await factoryGen.factory();
     const a = await openStream(factory, 4);
-    await using writer = a.writer;
+    await using _writer = a.writer;
     const db = factory.db.versioned(a.bucketStorage.replicationStream.getStorageConfig());
     const allocator = factory.getOpIdAllocator(
       a.bucketStorage.replicationStream,
       a.bucketStorage.replicationStream.current_lock!
     );
     await allocator.ensureCapacity();
-    allocator.committed(49_152n);
+    allocator.consume(49_152n);
     await allocator.ensureCapacity();
     expect((await db.op_id_sequence.findOne({ _id: 'main' }))!.op_id).toBe(65_536n);
 
     // Another stream's reservation creates a gap that must not count as capacity.
     await new MongoOpIdAllocator(db).reserve();
-    allocator.committed(49_153n);
+    allocator.consume(49_153n);
     await Promise.all([allocator.ensureCapacity(), allocator.ensureCapacity()]);
     expect((await db.op_id_sequence.findOne({ _id: 'main' }))!.op_id).toBe(196_608n);
     expect(allocator.sequence(49_153n).next()).toBe(49_154n);
@@ -584,7 +658,7 @@ describe('operation ID reservations', () => {
   test('refuses a reservation that would overflow without changing the watermark', async () => {
     await using factory = await factoryGen.factory();
     const a = await openStream(factory, 4);
-    await using writer = a.writer;
+    await using _writer = a.writer;
     const max = (1n << 63n) - 1n;
     await factory.db.op_id_sequence.insertOne({ _id: 'main', op_id: max - 65_536n });
     const allocator = factory.getOpIdAllocator(

package/test/src/helpers/PublicationCommandMonitor.ts

@@ -0,0 +1,119 @@
+import { mongo } from '@powersync/lib-service-mongodb';
+
+interface CommandSample {
+  name: string;
+  startedAt: number;
+  endedAt?: number;
+  failed?: boolean;
+  transaction?: TransactionSample;
+}
+
+interface TransactionSample {
+  key: string;
+  startedAt: number;
+  endedAt?: number;
+  outcome?: 'committed' | 'aborted';
+  replication: boolean;
+  commands: CommandSample[];
+}
+
+/**
+ * Counts actual wire commands, including getMore, aborted attempts and commit retries.
+ * Attach after setup/warmup to keep index creation and allocator refills separate.
+ * Store timing and classification only, never source data or command payloads.
+ */
+export class PublicationCommandMonitor implements Disposable {
+  readonly commands: CommandSample[] = [];
+  readonly transactions = new Map<string, TransactionSample>();
+  private readonly requests = new Map<number, CommandSample>();
+
+  constructor(private readonly client: mongo.MongoClient) {
+    client.on('commandStarted', this.started);
+    client.on('commandSucceeded', this.succeeded);
+    client.on('commandFailed', this.failed);
+  }
+
+  get replicationAttempts() {
+    return [...this.transactions.values()].filter((transaction) => transaction.replication);
+  }
+
+  get activeReplicationAttempts() {
+    return this.replicationAttempts.filter((transaction) => transaction.endedAt == null);
+  }
+
+  summary() {
+    const counts = (commands: CommandSample[]) => {
+      const result: Record<string, number> = {};
+      for (const command of commands) {
+        result[command.name] = (result[command.name] ?? 0) + 1;
+      }
+      return result;
+    };
+    return {
+      commands: counts(this.commands),
+      outsideTransaction: counts(this.commands.filter((command) => command.transaction == null)),
+      replicationAttempts: this.replicationAttempts.map((transaction) => ({
+        outcome: transaction.outcome,
+        activeMs: transaction.endedAt == null ? null : transaction.endedAt - transaction.startedAt,
+        commands: counts(transaction.commands),
+        failedCommands: transaction.commands.filter((command) => command.failed).length
+      })),
+      otherTransactions: [...this.transactions.values()].filter((transaction) => !transaction.replication).length
+    };
+  }
+
+  private started = (event: mongo.CommandStartedEvent) => {
+    const command = event.command;
+    const startedAt = performance.now();
+    let transaction: TransactionSample | undefined;
+    // txnNumber alone also appears on retryable writes outside transactions.
+    if (command.autocommit === false) {
+      const key = `${command.lsid.id.toString('hex')}:${command.txnNumber.toString()}`;
+      transaction = this.transactions.get(key);
+      if (transaction == null) {
+        transaction = { key, startedAt, replication: false, commands: [] };
+        this.transactions.set(key, transaction);
+      }
+      // The writer's first command is the conditional stream fence. Compaction
+      // shares the client but does not fence the replication stream document.
+      transaction.replication ||= event.commandName === 'findAndModify' && command.findAndModify === 'sync_rules';
+    }
+    const sample: CommandSample = { name: event.commandName, startedAt, transaction };
+    this.commands.push(sample);
+    transaction?.commands.push(sample);
+    this.requests.set(event.requestId, sample);
+  };
+
+  private finish(requestId: number, failed: boolean, errorCode?: number) {
+    const sample = this.requests.get(requestId);
+    if (sample == null) {
+      return;
+    }
+    this.requests.delete(requestId);
+    sample.endedAt = performance.now();
+    sample.failed = failed;
+    // A failed commit can have an unknown outcome and may be retried. Only a
+    // successful commit or a confirmed abort closes the observed attempt.
+    // NoSuchTransaction also confirms that the server already aborted it.
+    if (
+      sample.transaction != null &&
+      ((sample.name === 'abortTransaction' && (!failed || errorCode === 251)) ||
+        (sample.name === 'commitTransaction' && !failed))
+    ) {
+      sample.transaction.endedAt = sample.endedAt;
+      sample.transaction.outcome = sample.name === 'commitTransaction' ? 'committed' : 'aborted';
+    }
+  }
+
+  private succeeded = (event: mongo.CommandSucceededEvent) => this.finish(event.requestId, false);
+  private failed = (event: mongo.CommandFailedEvent) => {
+    const errorCode = event.failure instanceof mongo.MongoServerError ? event.failure.code : undefined;
+    this.finish(event.requestId, true, typeof errorCode === 'number' ? errorCode : undefined);
+  };
+
+  [Symbol.dispose]() {
+    this.client.off('commandStarted', this.started);
+    this.client.off('commandSucceeded', this.succeeded);
+    this.client.off('commandFailed', this.failed);
+  }
+}

package/test/src/helpers/concurrentWriter.mjs

@@ -10,7 +10,7 @@ async function main() {
   const streamId = Number(process.argv[3]);
   const stream = (await factory.getReplicatingReplicationStreams()).find((s) => s.replicationStreamId === streamId);
   const lock = await stream.lock();
-  await using lockLifetime = { [Symbol.asyncDispose]: () => lock.release() };
+  await using _lockLifetime = { [Symbol.asyncDispose]: () => lock.release() };
   const bucketStorage = factory.getInstance(stream, { replicationLock: lock });
   await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
   const table = await test_utils.resolveTestTable(writer, 'items', ['id'], factoryGen, streamId);
@@ -21,7 +21,7 @@ async function main() {
     afterReplicaId: test_utils.rid('child')
   });
   await writer.commit('1/2');
-  console.log(`checkpoint=${(await bucketStorage.getCheckpoint()).checkpoint}`);
+  console.log(`checkpoint=${(await bucketStorage.getCheckpoint()).checkpoint}; persisted=${writer.last_flushed_op}`);
 }
 
 await main();

package/test/src/invalid_sync_config.test.ts

@@ -0,0 +1,9 @@
+import { register } from '@powersync/service-core-tests';
+import { describe } from 'vitest';
+import { INITIALIZED_MONGO_STORAGE_FACTORY, TEST_STORAGE_VERSIONS } from './util.js';
+
+for (const storageVersion of TEST_STORAGE_VERSIONS) {
+  describe(`storage v${storageVersion}`, () => {
+    register.registerInvalidSyncConfigTests(INITIALIZED_MONGO_STORAGE_FACTORY, storageVersion);
+  });
+}

package/test/src/object_storage_lifecycle.test.ts

@@ -1,9 +1,79 @@
+import { ObjectId } from 'bson';
 import { createHash } from 'node:crypto';
-import { describe, expect, test } from 'vitest';
-import { ObjectStorageLifecycle } from '../../src/storage/implementation/v3/object-storage/ObjectStorageLifecycle.js';
+import { describe, expect, test, vi } from 'vitest';
+import {
+  OBJECT_STORAGE_PUBLICATION_SAFETY_MARGIN_MS,
+  ObjectStorageLifecycle
+} from '../../src/storage/implementation/v3/object-storage/ObjectStorageLifecycle.js';
 import { MemoryObjectStorage } from './helpers/MemoryObjectStorage.js';
 
 describe('ObjectStorageLifecycle', () => {
+  test('does not start PUTs when their protection has expired', async () => {
+    const objectStorage = new MemoryObjectStorage();
+    const lifecycle = new ObjectStorageLifecycle(null as any, 12, objectStorage);
+    using put = vi.spyOn(objectStorage, 'put');
+    await expect(
+      lifecycle.storeUploads([
+        {
+          upload: {
+            markerId: new ObjectId(),
+            path: 'expired',
+            deleteAfter: new Date(Date.now() + OBJECT_STORAGE_PUBLICATION_SAFETY_MARGIN_MS)
+          },
+          payload: new Uint8Array()
+        }
+      ])
+    ).rejects.toThrow('lease expired before PUT');
+    expect(put).not.toHaveBeenCalled();
+  });
+
+  test('expiry cancels queued requests and joins an active request before rejecting', async () => {
+    vi.useFakeTimers();
+    using _clock = { [Symbol.dispose]: () => vi.useRealTimers() };
+    const objectStorage = new MemoryObjectStorage();
+    const lifecycle = new ObjectStorageLifecycle(null as any, 12, objectStorage);
+    const release = Promise.withResolvers<void>();
+    let activeSignal: AbortSignal | undefined;
+    let queuedStarted = false;
+    using _put = vi
+      .spyOn(objectStorage, 'put')
+      .mockImplementationOnce(async (_path, _data, _metadata, options) => {
+        activeSignal = options!.signal;
+        await release.promise;
+        activeSignal!.throwIfAborted();
+      })
+      .mockImplementationOnce(async (_path, _data, _metadata, options) => {
+        // Model waiting for the shared adapter's semaphore: observe abort before
+        // starting the remote request, even when the active request is draining.
+        await new Promise<void>((resolve) =>
+          options!.signal!.addEventListener('abort', () => resolve(), { once: true })
+        );
+        options!.signal!.throwIfAborted();
+        queuedStarted = true;
+      });
+    const uploads = ['active', 'queued'].map((path) => ({
+      upload: {
+        markerId: new ObjectId(),
+        path,
+        deleteAfter: new Date(Date.now() + OBJECT_STORAGE_PUBLICATION_SAFETY_MARGIN_MS + 1000)
+      },
+      payload: new Uint8Array()
+    }));
+    const pending = lifecycle.storeUploads(uploads);
+    let settled = false;
+    const failed = expect(
+      pending.finally(() => {
+        settled = true;
+      })
+    ).rejects.toThrow('lease expired during PUT');
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(activeSignal!.aborted).toBe(true);
+    expect(queuedStarted).toBe(false);
+    expect(settled).toBe(false);
+    release.resolve();
+    await failed;
+  });
+
   test('escapes bucket names as path segments', () => {
     const lifecycle = new ObjectStorageLifecycle(null as any, 12, null as any);