@powersync/service-module-mongodb-storage 0.21.0 → 0.22.0

package/dist/storage/implementation/v3/MongoCompactorV3.js

@@ -1,5 +1,6 @@
 import { ReplicationAssertionError, ServiceAssertionError } from '@powersync/lib-services-framework';
-import { addChecksums, formatBytes, utils } from '@powersync/service-core';
+import { acquireSemaphoreAbortable, addChecksums, formatBytes, utils } from '@powersync/service-core';
+import { setImmediate } from 'node:timers/promises';
 import { ConcurrentCompactionError, MongoCompactor } from '../MongoCompactor.js';
 import { cacheKey } from '../OperationBatch.js';
 import { loadBucketDataDocument, maxOpId, serializeBucketData } from './bucket-format.js';
@@ -109,7 +110,8 @@ export class MongoCompactorV3 extends MongoCompactor {
      * Batching specifically help to cover cases of many buckets where no compaction is required:
      * Instead of sequentially claiming and then rescheduling a bucket, this handles it in bulk.
      *
-     * Buckets that do need compaction are still claimed and processed sequentially.
+     * Chunk merges overlap a bounded number of buckets. Full compaction stays
+     * sequential because its working set includes operation deduplication state.
      *
      * Any concurrent workers may read the same batch. Rescheduling filters out buckets handled
      * by a concurrent worker or replication write, while buckets that do need compaction are
@@ -123,24 +125,27 @@ export class MongoCompactorV3 extends MongoCompactor {
         // Writers derive next_compact_check from MongoDB's $$NOW. Use the same
         // clock for the fixed job boundary so clock skew cannot exclude work at
         // the exact initial-replication interval.
-        const [{ now: jobStartedAt }] = await this.db.db
-            .aggregate([{ $documents: [{}] }, { $project: { _id: 0, now: '$$NOW' } }])
-            .toArray();
+        const jobStartedAt = await this.readCompactionTime();
         const dueBefore = new Date(jobStartedAt.getTime() + (options.dueAheadMs ?? 0));
         const forceKind = options.forceKind;
         const rescheduleNotBefore = new Date(dueBefore.getTime() + 1);
+        // Keep accounting documents bounded by workers, not buckets or scan batches.
+        const workerUsage = Array.from({ length: this.storage.factory.chunkCompactionConcurrency }, () => new ObjectStorageUsage(this.db, this.group_id, createObjectStorageUsageWriterId()));
         while (true) {
             this.signal?.throwIfAborted();
             const states = await this.findScheduledBucketBatch(dueBefore);
             if (states.length == 0) {
                 break;
             }
+            // Keep eligibility bounded by dueBefore, but classify with the current
+            // server time so buckets that age into full compaction can advance.
+            const batchStartedAt = await this.readCompactionTime();
             const scheduled = [];
             for (const state of states) {
                 try {
                     scheduled.push({
                         state,
-                        decision: chooseCompactionKind(state, jobStartedAt, this),
+                        decision: chooseCompactionKind(state, batchStartedAt, this),
                         forcedKind: forcedCompactionKind(state, forceKind, this)
                     });
                 }
@@ -150,18 +155,23 @@ export class MongoCompactorV3 extends MongoCompactor {
             }
             const noOpStates = scheduled.filter(({ state, decision, forcedKind }) => state.compact_lease == null && (forceKind == null ? decision.kind : forcedKind) == null);
             await this.rescheduleUnclaimedBuckets(noOpStates, rescheduleNotBefore);
-            for (const { state, decision, forcedKind } of scheduled) {
+            const processBucket = async ({ state, decision, forcedKind }, objectStorageUsage, chunksOnly = false) => {
                 const kind = forceKind == null ? decision.kind : forcedKind;
                 if (state.compact_lease == null && kind == null) {
-                    continue;
+                    return;
                 }
                 try {
                     await using lease = await this.claimBucket({ _id: state._id, next_compact_check: { $lte: dueBefore } });
                     if (lease == null) {
-                        continue;
+                        return;
                     }
                     const claimedDecision = chooseCompactionKind(lease.state, lease.startedAt, this);
                     const claimedKind = forceKind == null ? claimedDecision.kind : forcedCompactionKind(lease.state, forceKind, this);
+                    if (chunksOnly && claimedKind === CompactionKind.Full) {
+                        // The decision changed after scanning. Release the lease without
+                        // rescheduling; the next batch will classify it with a fresh timestamp.
+                        return;
+                    }
                     if (claimedKind == null) {
                         await this.rescheduleClaimedBucket(lease, claimedDecision, rescheduleNotBefore);
                     }
@@ -171,7 +181,7 @@ export class MongoCompactorV3 extends MongoCompactor {
                         await this.rescheduleClaimedBucket(lease, claimedDecision, rescheduleNotBefore);
                     }
                     else {
-                        await this.compactClaimedBucket(lease, claimedKind, claimedDecision, rescheduleNotBefore);
+                        await this.compactClaimedBucket(lease, claimedKind, claimedDecision, rescheduleNotBefore, objectStorageUsage);
                     }
                 }
                 catch (error) {
@@ -182,6 +192,73 @@ export class MongoCompactorV3 extends MongoCompactor {
                     }
                     await this.rescheduleFailedBucket(state, rescheduleNotBefore, error);
                 }
+            };
+            const chunkBuckets = scheduled.filter(({ decision, forcedKind }) => (forceKind == null ? decision.kind : forcedKind) === CompactionKind.Chunks);
+            const sequentialBuckets = scheduled.filter(({ decision, forcedKind }) => (forceKind == null ? decision.kind : forcedKind) !== CompactionKind.Chunks);
+            await this.runChunkCompactionWorkers(chunkBuckets, workerUsage, (entry, usage) => processBucket(entry, usage, true));
+            // Full compaction cannot overlap chunk workers from this job, and only
+            // one full bucket is processed at a time.
+            for (const entry of sequentialBuckets) {
+                await processBucket(entry, this.objectStorageUsage);
+            }
+        }
+    }
+    /** Use MongoDB's clock, matching scheduling and lease timestamps. */
+    async readCompactionTime() {
+        const [{ now }] = await this.db.db
+            .aggregate([{ $documents: [{}] }, { $project: { _id: 0, now: '$$NOW' } }])
+            .toArray();
+        return now;
+    }
+    /** Process one scheduled batch with a fixed pool of workers. */
+    async runChunkCompactionWorkers(buckets, workerUsage, processBucket) {
+        const signal = this.signal;
+        let nextBucket = 0;
+        let failed = false;
+        const runWorker = async (usage) => {
+            try {
+                while (!failed && nextBucket < buckets.length) {
+                    // Taking an entry has no await, so each worker gets a different bucket.
+                    // A worker takes another only after finishing its current bucket.
+                    const bucket = buckets[nextBucket++];
+                    // This pool bounds one job; the factory semaphore bounds all jobs together.
+                    // Acquire before claiming the bucket lease, and hold until it is released.
+                    const acquired = await acquireSemaphoreAbortable(this.storage.factory.chunkCompactionSlots, signal);
+                    if (acquired === 'aborted') {
+                        signal?.throwIfAborted();
+                        return;
+                    }
+                    const [, releaseSlot] = acquired;
+                    try {
+                        // A sibling may have failed while this worker waited for a slot.
+                        if (failed)
+                            return;
+                        signal?.throwIfAborted();
+                        await processBucket(bucket, usage);
+                    }
+                    finally {
+                        releaseSlot();
+                    }
+                    // Let replication and other event-loop work run between buckets.
+                    await setImmediate();
+                }
+            }
+            catch (error) {
+                // Drain work already started, but do not let siblings start new buckets.
+                failed = true;
+                throw error;
+            }
+        };
+        // Concurrent transactions must not all increment the same usage document.
+        // Reuse one writer for each worker instead of creating one per bucket.
+        const workers = workerUsage.map(runWorker);
+        // Do not release the caller's replication lock or run cleanup while a
+        // sibling worker still owns a bucket lease or is finishing a replacement.
+        // Wait for every worker even on failure, then propagate the first error.
+        const results = await Promise.allSettled(workers);
+        for (const result of results) {
+            if (result.status === 'rejected') {
+                throw result.reason;
             }
         }
     }
@@ -238,10 +315,10 @@ export class MongoCompactorV3 extends MongoCompactor {
     async claimBucket(filter, sort) {
         return CompactionLease.claim(this.db.bucketState(this.group_id), filter, sort, this.compactLeaseDurationMs);
     }
-    async compactClaimedBucket(lease, kind, decision, rescheduleNotBefore) {
+    async compactClaimedBucket(lease, kind, decision, rescheduleNotBefore, objectStorageUsage = this.objectStorageUsage) {
         const context = new CompactionContext(lease, kind, decision, rescheduleNotBefore, this.compactionTarget(lease.state));
         lease.startRenewal();
-        await this.compactSingleBucket(context);
+        await this.compactSingleBucket(context, objectStorageUsage);
     }
     async rescheduleClaimedBucket(lease, decision, notBefore) {
         await lease.reschedule(this.rescheduleAtOrAfter(decision.nextCompactCheck, notBefore));
@@ -271,11 +348,11 @@ export class MongoCompactorV3 extends MongoCompactor {
         }
         return new ObjectStorageLifecycle(this.db, this.group_id, this.storage.objectStorage);
     }
-    async compactSingleBucket(context) {
+    async compactSingleBucket(context, objectStorageUsage) {
         if (context.kind == CompactionKind.Chunks) {
-            return this.compactSingleBucketChunks(context);
+            return this.compactSingleBucketChunks(context, objectStorageUsage);
         }
-        return this.compactSingleBucketFully(context);
+        return this.compactSingleBucketFully(context, objectStorageUsage);
     }
     /**
      * Merge adjacent bucket-data chunks without inspecting their operations
@@ -283,7 +360,7 @@ export class MongoCompactorV3 extends MongoCompactor {
      * update the persisted checksum state and to decide whether a group can fit
      * in one chunk.
      */
-    async compactSingleBucketChunks(context) {
+    async compactSingleBucketChunks(context, objectStorageUsage) {
         const bucket = context.state._id.b;
         const resolvedDefinitionId = context.state._id.d;
         const bucketContext = new BucketDataContextV3(this.db, {
@@ -362,7 +439,7 @@ export class MongoCompactorV3 extends MongoCompactor {
                 }
                 const nextSize = pendingSize + doc.size;
                 if (pendingChunks.length > 0 && nextSize > DEFAULT_MAX_DOC_SIZE_BYTES) {
-                    const groupStats = await this.flushChunkMerge(bucket, pendingChunks, collection, dataContext, bucketContext);
+                    const groupStats = await this.flushChunkMerge(bucket, pendingChunks, collection, dataContext, bucketContext, objectStorageUsage);
                     compactedTail = combineAdjacentStats(compactedTail, groupStats);
                     pendingChunks = [];
                     pendingSize = 0;
@@ -376,7 +453,7 @@ export class MongoCompactorV3 extends MongoCompactor {
             }
         }
         if (pendingChunks.length > 0) {
-            const groupStats = await this.flushChunkMerge(bucket, pendingChunks, collection, dataContext, bucketContext);
+            const groupStats = await this.flushChunkMerge(bucket, pendingChunks, collection, dataContext, bucketContext, objectStorageUsage);
             compactedTail = combineAdjacentStats(compactedTail, groupStats);
         }
         if (compactedOpId == null) {
@@ -397,33 +474,44 @@ export class MongoCompactorV3 extends MongoCompactor {
         this.compactedBucketCount++;
         this.logger.info(`Compacted bucket chunks ${bucket}: ${result.bucketStats.count} ops, ${result.bucketStats.chunks} chunks, ${formatBytes(result.bucketStats.bytes)}`);
     }
-    async flushChunkMerge(bucket, inputs, collection, context, bucketContext) {
+    async flushChunkMerge(bucket, inputs, collection, context, bucketContext, objectStorageUsage) {
         if (inputs.length == 1) {
             return statsForDocument(inputs[0]);
         }
-        // The metadata scan deliberately excluded ops. Read inline payloads only
-        // for this merge group; object-storage payloads are fetched below using
-        // the same rule.
-        const inlineInputs = inputs.filter((input) => input.storage_ref == null);
-        if (inlineInputs.length > 0) {
-            const inlineDocuments = await collection
-                .find({ _id: { $in: inlineInputs.map((input) => input._id) } }, { projection: { _id: 1, ops: 1 } })
-                .toArray();
-            const opsById = new Map(inlineDocuments.map((document) => [document._id.o.toString(), document.ops]));
-            for (const input of inlineInputs) {
-                input.ops = opsById.get(input._id.o.toString());
+        try {
+            this.signal?.throwIfAborted();
+            // The metadata scan deliberately excluded ops. Read inline payloads only
+            // for this merge group; object-storage payloads are fetched below using
+            // the same rule.
+            const inlineInputs = inputs.filter((input) => input.storage_ref == null);
+            if (inlineInputs.length > 0) {
+                const inlineDocuments = await collection
+                    .find({ _id: { $in: inlineInputs.map((input) => input._id) } }, { projection: { _id: 1, ops: 1 } })
+                    .toArray();
+                const opsById = new Map(inlineDocuments.map((document) => [document._id.o.toString(), document.ops]));
+                for (const input of inlineInputs) {
+                    input.ops = opsById.get(input._id.o.toString());
+                }
             }
+            await hydrateBucketDataDocuments(inputs, this.storage.objectStorage, { signal: this.signal });
+            const operations = inputs.flatMap((input) => Array.from(loadBucketDataDocument(context, input)));
+            const targetOp = inputs.reduce((maxTarget, input) => maxOpId(maxTarget, input.target_op), null);
+            const result = await this.flushCompactionGroup(bucket, {
+                inputs,
+                ops: operations,
+                changed: true,
+                targetOp
+            }, bucketContext, context, objectStorageUsage);
+            return result.stats;
+        }
+        finally {
+            // The scan batch also references these documents. Do not retain hydrated
+            // operations after finishing this merge group.
+            for (const input of inputs) {
+                delete input.ops;
+            }
+            await setImmediate();
         }
-        await hydrateBucketDataDocuments(inputs, this.storage.objectStorage, { signal: this.signal });
-        const operations = inputs.flatMap((input) => Array.from(loadBucketDataDocument(context, input)));
-        const targetOp = inputs.reduce((maxTarget, input) => maxOpId(maxTarget, input.target_op), null);
-        const result = await this.flushCompactionGroup(bucket, {
-            inputs,
-            ops: operations,
-            changed: true,
-            targetOp
-        }, bucketContext, context);
-        return result.stats;
     }
     async finalizeCompactedBucket({ context, compactedOpId, compactionResult, puts }) {
         await context.lease.throwIfLost();
@@ -526,7 +614,7 @@ export class MongoCompactorV3 extends MongoCompactor {
                 : addChecksums(0, Number(stats?.checksum ?? 0))
         };
     }
-    async compactSingleBucketFully(context) {
+    async compactSingleBucketFully(context, objectStorageUsage) {
         const bucket = context.state._id.b;
         const resolvedDefinitionId = context.state._id.d;
         const bucketContext = new BucketDataContextV3(this.db, {
@@ -673,7 +761,7 @@ export class MongoCompactorV3 extends MongoCompactor {
                     }
                     else {
                         const flushedGroup = pendingGroup;
-                        const result = await this.flushCompactionGroup(bucket, flushedGroup, bucketContext, dataContext);
+                        const result = await this.flushCompactionGroup(bucket, flushedGroup, bucketContext, dataContext, objectStorageUsage);
                         compactedStats = combineAdjacentStats(compactedStats, result.stats);
                         if (lastNotPut != null &&
                             flushedGroup.ops[0].o <= lastNotPut &&
@@ -692,7 +780,7 @@ export class MongoCompactorV3 extends MongoCompactor {
             this.logger.info(`Compacted batch of ${batchDocs.length} documents for bucket ${bucket}`);
         }
         if (pendingGroup != null) {
-            const result = await this.flushCompactionGroup(bucket, pendingGroup, bucketContext, dataContext);
+            const result = await this.flushCompactionGroup(bucket, pendingGroup, bucketContext, dataContext, objectStorageUsage);
             compactedStats = combineAdjacentStats(compactedStats, result.stats);
             if (lastNotPut != null &&
                 pendingGroup.ops[0].o <= lastNotPut &&
@@ -709,7 +797,7 @@ export class MongoCompactorV3 extends MongoCompactor {
             if (clearBoundary == null || clearBoundary.opId != lastNotPut) {
                 throw new ReplicationAssertionError(`Missing CLEAR boundary document for bucket ${bucket}`);
             }
-            const clearResult = await this.clearBucketLeading(lastNotPut, clearBoundary.documentId, bucketContext, collection, dataContext);
+            const clearResult = await this.clearBucketLeading(lastNotPut, clearBoundary.documentId, bucketContext, collection, dataContext, objectStorageUsage);
             totalOpCount += clearResult.opCountDiff;
             compactedStats = applyStatsReplacement(compactedStats, clearResult.before, clearResult.after);
         }
@@ -731,7 +819,7 @@ export class MongoCompactorV3 extends MongoCompactor {
      * If verification or the transaction fails, the prepared markers retain enough
      * information for the uploaded objects to be cleaned up later.
      */
-    async flushCompactionGroup(bucket, group, bucketContext, context) {
+    async flushCompactionGroup(bucket, group, bucketContext, context, objectStorageUsage) {
         if (group.inputs.length == 1 && !group.changed) {
             return {
                 documentId: group.inputs[0]._id,
@@ -768,10 +856,13 @@ export class MongoCompactorV3 extends MongoCompactor {
                     verification.opCountSum !== expectedOpCount) {
                     throw new ConcurrentCompactionError(`Inputs changed while compacting bucket ${bucket}; restarting from the latest bucket state`);
                 }
-                await bucketContext.collection.deleteMany({ _id: { $in: idsToDelete } }, { session });
-                await bucketContext.collection.insertMany(documents, { session });
-                await this.finishObjectStorageReplacement(oldStoragePaths, newStoragePaths, uploads, session);
-                await this.recordObjectStorageReplacement(oldStorageBytes, documents, context.definitionId, session);
+                // Replacement documents can reuse deleted IDs, so retain delete-before-insert ordering.
+                const writes = this.db.createWriteBatch(session, { ordered: true });
+                writes.deleteMany(bucketContext.collection, { _id: { $in: idsToDelete } });
+                writes.insertMany(bucketContext.collection, documents);
+                this.finishObjectStorageReplacement(oldStoragePaths, newStoragePaths, uploads, writes);
+                this.recordObjectStorageReplacement(oldStorageBytes, documents, context.definitionId, writes, objectStorageUsage);
+                await writes.execute();
             }, {
                 writeConcern: { w: 'majority' },
                 readConcern: { level: 'snapshot' }
@@ -794,7 +885,7 @@ export class MongoCompactorV3 extends MongoCompactor {
      * Returns the op count and stored-stat changes after replacing cleared ops
      * with CLEAR ops.
      */
-    async clearBucketLeading(lastNotPut, boundaryDocId, bucketContext, collection, context) {
+    async clearBucketLeading(lastNotPut, boundaryDocId, bucketContext, collection, context, objectStorageUsage) {
         let opCountDiff = 0;
         let before = emptyBucketStats();
         let after = emptyBucketStats();
@@ -804,7 +895,7 @@ export class MongoCompactorV3 extends MongoCompactor {
             // First step is to clear full chunks that contain only CLEAR/MOVE/REMOVE operations.
             // There can be many of them, so we do one batch at a time.
             while (!done) {
-                const batch = await this.clearLeadingFullDocuments(session, lastNotPut, boundaryDocId, bucketContext, collection, context);
+                const batch = await this.clearLeadingFullDocuments(session, lastNotPut, boundaryDocId, bucketContext, collection, context, objectStorageUsage);
                 done = batch.done;
                 opCountDiff += batch.opCountDiff;
                 before = combineAdjacentStats(before, batch.before);
@@ -812,7 +903,7 @@ export class MongoCompactorV3 extends MongoCompactor {
             }
             // The final step is to process the "boundary" document: It may contain some CLEAR/MOVE/REMOVE operations,
             // potentially followed by PUT operations. This is only a single document, so no need for batching.
-            const boundaryResult = await this.clearBoundaryDocument(session, lastNotPut, boundaryDocId, bucketContext, collection, context);
+            const boundaryResult = await this.clearBoundaryDocument(session, lastNotPut, boundaryDocId, bucketContext, collection, context, objectStorageUsage);
             opCountDiff += boundaryResult.opCountDiff;
             before = combineAdjacentStats(before, boundaryResult.before);
             after = combineAdjacentStats(after, boundaryResult.after);
@@ -822,7 +913,7 @@ export class MongoCompactorV3 extends MongoCompactor {
         }
         return { opCountDiff, before, after };
     }
-    async clearLeadingFullDocuments(session, lastNotPut, boundaryDocId, bucketContext, collection, context) {
+    async clearLeadingFullDocuments(session, lastNotPut, boundaryDocId, bucketContext, collection, context, objectStorageUsage) {
         const bucket = bucketContext.key.bucket;
         this.signal?.throwIfAborted();
         let prepared;
@@ -902,12 +993,13 @@ export class MongoCompactorV3 extends MongoCompactor {
             }
             prepared ??= await this.prepareCompactionUploads(bucket, context, [lastNotPut]);
             this.logger.info(`Flushing CLEAR for ${clearedOpCount} ops at ${lastDocId?.o}`);
-            await collection.deleteMany({
+            const writes = this.db.createWriteBatch(session, { ordered: true });
+            writes.deleteMany(collection, {
                 _id: {
                     $gte: bucketContext.minId,
                     $lte: lastDocId
                 }
-            }, { session });
+            });
             const clearOp = {
                 bucketKey: { ...context, bucket },
                 o: lastDocId.o,
@@ -918,9 +1010,10 @@ export class MongoCompactorV3 extends MongoCompactor {
             const persisted = await this.persistBucketData(bucket, [[clearOp]], context, prepared, {
                 targetOp: maxTargetOp
             });
-            await collection.insertOne(persisted.documents[0], { session });
-            await this.finishObjectStorageReplacement(oldStoragePaths, persisted.storagePaths, persisted.uploads, session);
-            await this.recordObjectStorageReplacement(oldStorageBytes, persisted.documents, context.definitionId, session);
+            writes.insertOne(collection, persisted.documents[0]);
+            this.finishObjectStorageReplacement(oldStoragePaths, persisted.storagePaths, persisted.uploads, writes);
+            this.recordObjectStorageReplacement(oldStorageBytes, persisted.documents, context.definitionId, writes, objectStorageUsage);
+            await writes.execute();
             opCountDiff = -clearedOpCount + 1;
             before = inputStats;
             after = statsForDocuments(persisted.documents);
@@ -930,7 +1023,7 @@ export class MongoCompactorV3 extends MongoCompactor {
         });
         return { done, opCountDiff, before, after };
     }
-    async clearBoundaryDocument(session, lastNotPut, boundaryDocId, bucketContext, collection, context) {
+    async clearBoundaryDocument(session, lastNotPut, boundaryDocId, bucketContext, collection, context, objectStorageUsage) {
         const bucket = bucketContext.key.bucket;
         this.signal?.throwIfAborted();
         const prepared = await this.prepareCompactionUploads(bucket, context, [lastNotPut, boundaryDocId.o]);
@@ -1012,12 +1105,13 @@ export class MongoCompactorV3 extends MongoCompactor {
                 throw new Error(`CLEAR boundary document not found for bucket ${bucket}`);
             }
             this.logger.info(`Flushing CLEAR for ${clearedOpCount} ops at ${lastNotPut}`);
-            await collection.deleteMany({
+            const writes = this.db.createWriteBatch(session, { ordered: true });
+            writes.deleteMany(collection, {
                 _id: {
                     $gte: bucketContext.minId,
                     $lte: boundaryDocId
                 }
-            }, { session });
+            });
             const clearOp = {
                 bucketKey: { ...context, bucket },
                 o: lastNotPut,
@@ -1034,9 +1128,10 @@ export class MongoCompactorV3 extends MongoCompactor {
             const persisted = await this.persistBucketData(bucket, chunks, context, prepared, {
                 targetOp: maxTargetOp ?? undefined
             });
-            await collection.insertMany(persisted.documents, { session });
-            await this.finishObjectStorageReplacement(oldStoragePaths, persisted.storagePaths, persisted.uploads, session);
-            await this.recordObjectStorageReplacement(oldStorageBytes, persisted.documents, context.definitionId, session);
+            writes.insertMany(collection, persisted.documents);
+            this.finishObjectStorageReplacement(oldStoragePaths, persisted.storagePaths, persisted.uploads, writes);
+            this.recordObjectStorageReplacement(oldStorageBytes, persisted.documents, context.definitionId, writes, objectStorageUsage);
+            await writes.execute();
             opCountDiff = -clearedOpCount + 1;
             before = inputStats;
             after = statsForDocuments(persisted.documents);
@@ -1064,14 +1159,14 @@ export class MongoCompactorV3 extends MongoCompactor {
         return lifecycle.prepareUploads(paths);
     }
     /** Publish replacement uploads and retire superseded objects in the same transaction. */
-    async finishObjectStorageReplacement(oldStoragePaths, newStoragePaths, uploads, session) {
+    finishObjectStorageReplacement(oldStoragePaths, newStoragePaths, uploads, writes) {
         if (!this.storage.objectStorage) {
             return;
         }
-        await this.objectStorageLifecycle.publishUploads(uploads, session);
-        await this.objectStorageLifecycle.retire(Array.from(oldStoragePaths).filter((path) => !newStoragePaths.has(path)), session);
+        this.objectStorageLifecycle.publishUploads(uploads, writes);
+        this.objectStorageLifecycle.retire(Array.from(oldStoragePaths).filter((path) => !newStoragePaths.has(path)), writes);
     }
-    async recordObjectStorageReplacement(oldBytes, newDocuments, definitionId, session) {
+    recordObjectStorageReplacement(oldBytes, newDocuments, definitionId, writes, objectStorageUsage) {
         if (!this.storage.objectStorage) {
             return;
         }
@@ -1079,7 +1174,7 @@ export class MongoCompactorV3 extends MongoCompactor {
         for (const document of newDocuments) {
             newBytes += ObjectStorageUsage.bytes(document);
         }
-        await this.objectStorageUsage.applyDelta(definitionId, newBytes - oldBytes, session);
+        objectStorageUsage.applyDelta(definitionId, newBytes - oldBytes, writes);
     }
     async persistBucketData(bucket, chunks, context, preparedUploads, options) {
         const serializedChunks = chunks.map((chunk) => serializeBucketData(bucket, chunk, options));