@lossless.org/client 1.21.1 → 1.22.0

package/ts/nosqldb/classes.collection.ts

@@ -34,6 +34,7 @@ import { hasSmartdataWriteObservers } from './classes.writeobserver.js';
 import {
   leaseOrdinarySmartdataSession,
   reportSmartdataCollectionWrite,
+  readPreviousWriteRevisions,
   runWithOrdinarySmartdataSession,
   trackSmartdataRead,
   type TSmartdataOrdinarySession,
@@ -1955,6 +1956,7 @@ export class SmartdataCollection<T> {
       {
         ordinaryWrite: optionsArg.ordinaryWrite,
         prepared: this.isInitializedForCurrentDatabase(),
+        prepare: () => this.init(),
         collectionName: this.collectionName,
         timeoutMS: optionsArg.timeoutMS,
         signal: optionsArg.signal,
@@ -2423,11 +2425,11 @@ export class SmartdataCollection<T> {
       { ordinaryWrite: false, timeoutMS: opts?.timeoutMS },
       async (rawSessionArg, deadlineArg) => {
         await deadlineArg.join(this.init());
-        const tracked = trackSmartdataRead(this, opts?.session, {
+        const tracked = await trackSmartdataRead(this, opts?.session, {
           kind: 'documents',
           filter: filterObject,
           limited: true,
-        });
+        }, deadlineArg);
         const document = await this.mongoDbCollection.findOne(filterObject, {
           projection: opts?.projection,
           maxTimeMS: opts?.maxTimeMS,
@@ -2457,7 +2459,7 @@ export class SmartdataCollection<T> {
     });
     try {
       await this.init();
-      const tracked = trackSmartdataRead(this, opts?.session, {
+      const tracked = await trackSmartdataRead(this, opts?.session, {
         kind: 'documents',
         filter: filterObjectArg,
       });
@@ -2483,10 +2485,10 @@ export class SmartdataCollection<T> {
       { ordinaryWrite: false, timeoutMS: opts?.timeoutMS },
       async (rawSessionArg, deadlineArg) => {
         await deadlineArg.join(this.init());
-        const tracked = trackSmartdataRead(this, opts?.session, {
+        const tracked = await trackSmartdataRead(this, opts?.session, {
           kind: 'documents',
           filter: filterObject,
-        });
+        }, deadlineArg);
         const cursor = this.mongoDbCollection.find(filterObject, {
           session: rawSessionArg,
           ...deadlineArg.cursorOptions(),
@@ -2692,11 +2694,11 @@ export class SmartdataCollection<T> {
       async (rawSessionArg, deadlineArg) => {
         await deadlineArg.join(this.init());
         // Totals depend on every matching document, not on which ones come back.
-        trackSmartdataRead(this, opts?.session, {
+        await trackSmartdataRead(this, opts?.session, {
           kind: 'documents',
           filter: matchArg ?? {},
           matches: true,
-        });
+        }, deadlineArg);
         const pipeline: plugins.mongodb.Document[] = [];
         if (matchArg && Object.keys(matchArg).length > 0) {
           pipeline.push({ $match: matchArg });
@@ -2921,6 +2923,9 @@ export class SmartdataCollection<T> {
             : {}),
         };
         try {
+          const previousPartitionsRead = await readPreviousWriteRevisions(
+            this.smartdataDb, this.mongoDbCollection, rawSessionArg, identifiableObject, deadlineArg,
+          );
           const result = await this.mongoDbCollection.updateOne(
             identifiableObject,
             update,
@@ -2933,7 +2938,7 @@ export class SmartdataCollection<T> {
               result.upsertedCount > 0 ? 'insert' : 'update',
               [saveableObject],
               identifiableObject,
-              { images: 'none', update },
+              { images: 'none', update, ...(previousPartitionsRead ? { previousPartitionsRead } : {}) },
             );
           }
           return result;
@@ -2963,6 +2968,9 @@ export class SmartdataCollection<T> {
         const observedDocument = hasSmartdataWriteObservers(this.smartdataDb)
           ? await dbDocArg.createSavableObject() as object
           : undefined;
+        const previousPartitionsRead = await readPreviousWriteRevisions(
+          this.smartdataDb, this.mongoDbCollection, rawSessionArg, identifiableObject, deadlineArg,
+        );
         const result = await this.mongoDbCollection.deleteOne(identifiableObject, {
           session: rawSessionArg,
           ...deadlineArg.commandOptions(),
@@ -2974,7 +2982,7 @@ export class SmartdataCollection<T> {
             'delete',
             observedDocument ? [observedDocument] : null,
             identifiableObject,
-            { images: 'none' },
+            { images: 'none', ...(previousPartitionsRead ? { previousPartitionsRead } : {}) },
           );
         }
         return result;
@@ -3026,11 +3034,11 @@ export class SmartdataCollection<T> {
       { ordinaryWrite: false, timeoutMS: opts?.timeoutMS, signal: opts?.signal },
       async (rawSessionArg, deadlineArg) => {
         await deadlineArg.join(this.init());
-        const tracked = trackSmartdataRead(this, opts?.session, {
+        const tracked = await trackSmartdataRead(this, opts?.session, {
           kind: 'count',
           filter: filterObject,
           hint: opts?.hint,
-        });
+        }, deadlineArg);
         const pipeline: plugins.mongodb.Document[] = [{ $match: filterObject }];
         if (opts?.limit !== undefined) {
           pipeline.push({ $limit: opts.limit });
@@ -3108,7 +3116,7 @@ export class SmartdataCollection<T> {
     duplicateFields: Array<{ field: string; duplicateValues: number }>;
   }> {
     await this.init();
-    trackSmartdataRead(this, undefined, { kind: 'collection' });
+    await trackSmartdataRead(this, undefined, { kind: 'collection' });
     const result = {
       ok: true,
       estimatedCount: 0,

package/ts/nosqldb/classes.connection.ts

@@ -1,4 +1,5 @@
 import { SmartdataDb } from './classes.db.js';
+import type { ISmartdataWriteRevisionsOptions } from './classes.writerevisions.js';
 import {
   composeSmartdataCapabilities,
   smartdataCompositeGrouping,
@@ -14,6 +15,8 @@ export interface INoSqlConnectionOptions {
   username?: string;
   password?: string;
   connectionLimit?: number;
+  /** See `ISmartdataDbOptions.writeRevisions`. */
+  writeRevisions?: ISmartdataWriteRevisionsOptions;
 }
 
 export class NoSqlConnection extends SmartdataDb {
@@ -24,7 +27,8 @@ export class NoSqlConnection extends SmartdataDb {
   constructor(public readonly options: INoSqlConnectionOptions) {
     super({ mongoDbUrl: options.url, mongoDbName: options.database,
       mongoDbUser: options.username, mongoDbPass: options.password,
-      ...(options.connectionLimit === undefined ? {} : { maxPoolSize: options.connectionLimit }) });
+      ...(options.connectionLimit === undefined ? {} : { maxPoolSize: options.connectionLimit }),
+      ...(options.writeRevisions === undefined ? {} : { writeRevisions: options.writeRevisions }) });
     this.backend = options.backend;
     this.declaredCapabilities = composeSmartdataCapabilities(this.backend,
       smartdataCompositeGrouping(this.engineIdentity));

package/ts/nosqldb/classes.db.ts

@@ -29,6 +29,17 @@ import {
   trackSmartdataReads,
   type ISmartdataTrackedReads,
 } from './classes.readtracker.js';
+import {
+  bumpSmartdataWriteRevisionEpoch,
+  configureSmartdataWriteRevisions,
+  ensureSmartdataWriteRevisions,
+  isSmartdataWriteRevisionsActive,
+  type ISmartdataWriteRevisionsOptions,
+} from './classes.writerevisions.js';
+import {
+  requireOperationSignal,
+  requireOperationTimeoutMS,
+} from './classes.operationdeadline.js';
 
 export { SmartdataSession } from './classes.session.js';
 export { SmartdataReadSet } from './classes.readtracker.js';
@@ -38,6 +49,7 @@ export type {
   TSmartdataOrdinarySession,
   TSmartdataTransactionCommitOutcome,
 } from './classes.session.js';
+export type { ISmartdataWriteRevisionsOptions } from './classes.writerevisions.js';
 export type {
   ISmartdataWriteObserverOptions,
   ISmartdataWriteReport,
@@ -91,6 +103,19 @@ export interface ISmartdataDbOptions {
   serverSelectionTimeoutMS?: number;
   /** Milliseconds a socket may stay inactive before it is closed. Default 30000. */
   socketTimeoutMS?: number;
+  /**
+   * Keeps write revisions, so `reads.isCurrent()` of `trackReads()` also
+   * notices writes of other processes. Every process that writes the database
+   * must enable it with the same `partitionField`; see `trackReads()`. Read
+   * once, by the constructor.
+   */
+  writeRevisions?: ISmartdataWriteRevisionsOptions;
+}
+
+export interface ISmartdataInvalidateTrackedReadsOptions {
+  /** Client deadline of the write-revision epoch's bump (1..120000 ms). */
+  timeoutMS?: number;
+  signal?: AbortSignal;
 }
 
 export interface ISmartdataReadinessOptions {
@@ -220,6 +245,7 @@ export class SmartdataDb {
   private capabilitiesState: ICapabilities | undefined;
 
   constructor(smartdataOptions: ISmartdataDbOptions) {
+    configureSmartdataWriteRevisions(this, smartdataOptions.writeRevisions);
     this.smartdataOptions = smartdataOptions;
     this.status = 'initial';
     void this.statusConnectedDeferred.promise.catch(() => {});
@@ -312,6 +338,10 @@ export class SmartdataDb {
         this.applyEngineIdentity(await probeSmartdataEngineIdentity(candidateDb, budget));
         // The probe absorbs its own failures, so a budget that expired during it must still refuse here.
         budget?.check();
+        if (isSmartdataWriteRevisionsActive(this)) {
+          await ensureSmartdataWriteRevisions(candidateDb, budget?.operationOptions());
+          budget?.check();
+        }
         this.mongoDbClient = candidateClient;
         this.mongoDb = candidateDb;
         candidateClient = undefined;
@@ -562,8 +592,11 @@ export class SmartdataDb {
    * as one that did. A cache keyed by `reads` rebuilds only what such a write
    * touched.
    *
-   * Writes of other processes, raw driver access and migrations are not
-   * followed. A read inside a transaction, a read of another database and a
+   * `reads.changed` does not follow writes of other processes, raw driver
+   * access or migrations. With the `writeRevisions` option, the awaited
+   * `reads.isCurrent()` also answers for the model writes of every process
+   * that enables it, and for raw writes once `invalidateTrackedReads()` states
+   * them. A read inside a transaction, a read of another database and a
    * write made inside `fnArg` mark the set changed at once. Queries are
    * evaluated by MongoDB's simple binary comparison, so a read of a view or of
    * a collection with a default collation marks the set changed as well; each
@@ -576,6 +609,36 @@ export class SmartdataDb {
     return trackSmartdataReads(this, fnArg);
   }
 
+  /**
+   * States that something wrote the database behind its models, such as a
+   * migration or an operator command on the raw driver: every open read set
+   * of this process changes, and with `writeRevisions` active the database's
+   * epoch is bumped, so `isCurrent()` turns false in every process. Call it
+   * after the raw writes; a raw write in flight meanwhile can still be missed.
+   */
+  public async invalidateTrackedReads(
+    optionsArg: ISmartdataInvalidateTrackedReadsOptions = {},
+  ): Promise<void> {
+    const { timeoutMS, signal } = assertDataOptions(optionsArg, ['timeoutMS', 'signal']);
+    const options = {
+      timeoutMS: requireOperationTimeoutMS(timeoutMS, 'invalidateTrackedReads timeoutMS'),
+      signal: requireOperationSignal(signal, 'invalidateTrackedReads signal'),
+    };
+    changeSmartdataReadSetsOfDb(this);
+    if (!isSmartdataWriteRevisionsActive(this)) return;
+    try {
+      await bumpSmartdataWriteRevisionEpoch(this, {
+        ...(options.timeoutMS === undefined ? {} : { timeoutMS: options.timeoutMS }),
+        ...(options.signal === undefined ? {} : { signal: options.signal }),
+      });
+    } catch (errorArg) {
+      if (isMongoDeadlineError(errorArg)) {
+        throw createSmartdataTimeoutError('Bumping the write-revision epoch exceeded its client deadline.', errorArg);
+      }
+      throw errorArg;
+    }
+  }
+
   /**
    * Creates a narrowly scoped MongoDB administration facade bound to this
    * SmartData lifecycle. Applications never need direct driver access.

package/ts/nosqldb/classes.doc.ts

@@ -30,6 +30,7 @@ import { SmartdataDbWatcher } from './classes.watcher.js';
 import { SmartdataLuceneAdapter } from './classes.lucene.adapter.js';
 import { executeAtomicDelete, executeAtomicDeleteMany } from './classes.atomicdelete.js';
 import { requireOperationSignal } from './classes.operationdeadline.js';
+import { isSmartdataWriteRevisionsActive } from './classes.writerevisions.js';
 import {
   executeAtomicFindOneAndReplace, executeAtomicFindOneAndUpdate,
 } from './classes.atomicfindoneandupdate.js';
@@ -4602,7 +4603,9 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
    * unless the caller supplies a transaction session. With ordered semantics
    * (the default) MongoDB stops at the first failure; documents MongoDB
    * reports as inserted are marked database-backed even when the batch fails
-   * part-way, so callers can compensate precisely.
+   * part-way, so callers can compensate precisely. On a database with active
+   * write revisions, a batch outside a transaction runs in one of its own and
+   * inserts every document or none.
    */
   public static async insertMany<T extends SmartDataDbDoc<any, any>>(
     this: plugins.tsclass.typeFest.Class<T>,
@@ -4674,6 +4677,9 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
     }
     const collection: SmartdataCollection<T> = (this as any).collection;
     const inTransaction = isOrdinarySessionInTransaction(opts?.session);
+    // Outside a transaction, a database with write revisions runs the batch
+    // in one of its own, so a failed batch inserted nothing.
+    const insertsWhole = !inTransaction && isSmartdataWriteRevisionsActive(collection.smartdataDb);
     const markInsertedDocuments = (
       insertedIdsArg: Record<number, unknown> | undefined,
     ): void => {
@@ -4701,7 +4707,7 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
       const bulkError = error instanceof SmartdataPersistenceError
         ? error.cause
         : error;
-      if (bulkError instanceof plugins.mongodb.MongoBulkWriteError) {
+      if (bulkError instanceof plugins.mongodb.MongoBulkWriteError && !insertsWhole) {
         markInsertedDocuments(
           bulkError.result?.insertedIds as unknown as
             | Record<number, unknown>
@@ -6057,12 +6063,12 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
     }, async (rawSessionArg, deadlineArg) => {
       await deadlineArg.join(collection.init());
       const sort = { [optionsArg.sortField]: sortDirection, [uniqueField]: sortDirection } as const;
-      const tracked = trackSmartdataRead(collection, optionsArg.session, {
+      const tracked = await trackSmartdataRead(collection, optionsArg.session, {
         kind: 'documents',
         filter: selector,
         sort,
         limited: true,
-      });
+      }, deadlineArg);
       const rawCursor = collection.mongoDbCollection
         .find(selector, { session: rawSessionArg, ...deadlineArg.cursorOptions() })
         .sort(sort)
@@ -6080,7 +6086,9 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
         );
         const lastRow: any = pageRows[pageRows.length - 1];
         const countTracked = optionsArg.withTotal
-          ? trackSmartdataRead(collection, optionsArg.session, { kind: 'count', filter: baseSelector })
+          ? await trackSmartdataRead(
+            collection, optionsArg.session, { kind: 'count', filter: baseSelector }, deadlineArg,
+          )
           : undefined;
         const total = optionsArg.withTotal
           ? await collection.mongoDbCollection.countDocuments(baseSelector, {
@@ -6230,7 +6238,7 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
       const filter = (this as any).normalizeReadFilter(filterArg);
       // A modifier changes the query in ways a read set cannot follow, and a
       // skipped page depends on the documents before it.
-      const tracked = trackSmartdataRead(collection, session, modifier
+      const tracked = await trackSmartdataRead(collection, session, modifier
         ? { kind: 'collection' }
         : { kind: 'documents', filter, sort, hint, matches: skip !== undefined && skip > 0, limited: Boolean(limit) });
       let rawCursor: plugins.mongodb.FindCursor<any> =
@@ -6332,9 +6340,9 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
       defaultTimeoutMS: 5_000,
       signal: opts.signal,
     }, async (rawSessionArg, deadlineArg) => {
-      const tracked = trackSmartdataRead(collection, opts.session, {
+      const tracked = await trackSmartdataRead(collection, opts.session, {
         kind: 'documents', filter, sort, hint, matches: skip > 0, limited: true,
-      });
+      }, deadlineArg);
       const rawCursor = collection.mongoDbCollection.find(filter, {
         projection, sort, hint, skip, limit, maxTimeMS,
         ...deadlineArg.cursorOptions(), session: rawSessionArg,

package/ts/nosqldb/classes.exactpersistence.ts

@@ -6,11 +6,14 @@ import { getOrdinaryPersistencePolicy } from './classes.ordinarypersistence.js';
 import type { SmartdataCollection } from './classes.collection.js';
 import { getIdentityIndexName } from './classes.collectiontopology.js';
 import { registerCollectionReconnectHandler } from './classes.collectionlifecycle.js';
-import type { SmartdataSession } from './classes.session.js';
 import {
+  SmartdataSession,
   acquireSmartdataSession,
+  needsSmartdataRevisionTransaction,
+  readPreviousWriteRevisions,
   reportSmartdataCollectionWrite,
   reportSmartdataWriteFailure,
+  runSmartdataRevisionTransaction,
   settleSmartdataOperationError,
   resolveSmartdataOperationDeadline,
   trackSmartdataRead,
@@ -1068,6 +1071,19 @@ export class SmartdataExactCollection<
     await this.initialize();
   }
 
+  /** Refuses an owned session until the collection is prepared: its DDL cannot run in a transaction. */
+  private requirePreparedForSession(): void {
+    if (
+      !this.collection.isInitializedForCurrentDatabase()
+      || this.initializedCollection !== this.collection.mongoDbCollection
+    ) {
+      throw new SmartdataExactPersistenceError(
+        'unsupported_operation',
+        'Exact collection must be prepared before it participates in a transaction.',
+      );
+    }
+  }
+
   private async beginOperation(
     sessionArg: SmartdataSession | undefined,
     boundsArg: { timeoutMS?: number; signal?: AbortSignal },
@@ -1081,15 +1097,7 @@ export class SmartdataExactCollection<
       await deadline.join(this.initialize());
       return { deadline, release: () => {} };
     }
-    if (
-      !this.collection.isInitializedForCurrentDatabase()
-      || this.initializedCollection !== this.collection.mongoDbCollection
-    ) {
-      throw new SmartdataExactPersistenceError(
-        'unsupported_operation',
-        'Exact collection must be prepared before it participates in a transaction.',
-      );
-    }
+    this.requirePreparedForSession();
     const lease = acquireSmartdataSession(
       sessionArg,
       this.collection.smartdataDb,
@@ -1141,7 +1149,8 @@ export class SmartdataExactCollection<
   /**
    * Runs one exact write through `runOperation`. A write that fails once
    * started may still have applied, so it changes every open read set that
-   * read the collection.
+   * read the collection. A write of a database with write revisions outside
+   * an owned transaction starts one, on the caller's session if it passed one.
    */
   private async runWriteOperation<TResult>(
     optionsArg: IExactBoundedOptions,
@@ -1150,6 +1159,9 @@ export class SmartdataExactCollection<
       deadlineArg: SmartdataOperationDeadline,
     ) => Promise<TResult>,
   ): Promise<TResult> {
+    if (needsSmartdataRevisionTransaction(optionsArg.session, this.collection.smartdataDb)) {
+      return this.runRevisionWriteOperation(optionsArg, operationArg);
+    }
     let started = false;
     try {
       return await runSmartdataWrite(this.collection.smartdataDb, () =>
@@ -1167,6 +1179,39 @@ export class SmartdataExactCollection<
     }
   }
 
+  /**
+   * Runs one exact write in a transaction that carries the write's revisions:
+   * on the caller's owned session, which needs the collection prepared, or on
+   * a session of its own, which prepares the collection first. The
+   * transaction's commit is the write's outcome: one whose commit outcome is
+   * unknown is `ambiguous_write`.
+   */
+  private async runRevisionWriteOperation<TResult>(
+    optionsArg: IExactBoundedOptions,
+    operationArg: (
+      sessionArg: plugins.mongodb.ClientSession | undefined,
+      deadlineArg: SmartdataOperationDeadline,
+    ) => Promise<TResult>,
+  ): Promise<TResult> {
+    const timeoutMS = requireOperationTimeoutMS(optionsArg.timeoutMS, 'Exact operation timeoutMS');
+    const signal = requireOperationSignal(optionsArg.signal, 'Exact operation signal');
+    signal?.throwIfAborted();
+    if (optionsArg.session) this.requirePreparedForSession();
+    try {
+      return await runSmartdataRevisionTransaction(optionsArg.session, this.collection.smartdataDb, {
+        ...(optionsArg.session ? { prepared: true } : { prepare: () => this.initialize() }),
+        collectionName: this.collection.collectionName,
+        ...(timeoutMS === undefined ? {} : { timeoutMS }),
+        ...(signal === undefined ? {} : { signal }),
+      }, (sessionArg) => this.runWriteOperation({ session: sessionArg }, operationArg));
+    } catch (errorArg) {
+      if (SmartdataSession.getCommitOutcome(errorArg) === 'unknown') {
+        throw this.ambiguousWriteError('The commit outcome of an exact write is unknown.', errorArg);
+      }
+      throw errorArg;
+    }
+  }
+
   /**
    * The error of a non-transactional write that its client deadline or
    * signal interrupted after the write was handed to the driver: the command
@@ -1712,11 +1757,11 @@ export class SmartdataExactCollection<
   ): Promise<TStoredDocument<TPersisted> | null> {
     return this.runOperation(optionsArg, async (sessionArg, deadlineArg) => {
     const filter = convertFilterForMongoDb(filterArg);
-    const tracked = trackSmartdataRead(this.collection, optionsArg.session, {
+    const tracked = await trackSmartdataRead(this.collection, optionsArg.session, {
       kind: 'documents',
       filter,
       limited: true,
-    });
+    }, deadlineArg);
     const cursor = this.collection.mongoDbCollection.find(
       filter,
       {
@@ -1758,13 +1803,13 @@ export class SmartdataExactCollection<
     return this.runOperation(optionsArg, async (sessionArg, deadlineArg) => {
     const filter = convertFilterForMongoDb(optionsArg.filter || {});
     // A skipped page depends on the documents before it, which it never returns.
-    const tracked = trackSmartdataRead(this.collection, optionsArg.session, {
+    const tracked = await trackSmartdataRead(this.collection, optionsArg.session, {
       kind: 'documents',
       filter,
       sort: optionsArg.sort,
       matches: optionsArg.skip !== undefined && optionsArg.skip > 0,
       limited: optionsArg.limit !== undefined,
-    });
+    }, deadlineArg);
     let cursor = this.collection.mongoDbCollection.find(
       filter,
       { session: sessionArg, ...deadlineArg.cursorOptions() },
@@ -1813,7 +1858,9 @@ export class SmartdataExactCollection<
   ): Promise<number> {
     return this.runOperation(optionsArg, async (sessionArg, deadlineArg) => {
       const filter = convertFilterForMongoDb(filterArg);
-      const tracked = trackSmartdataRead(this.collection, optionsArg.session, { kind: 'count', filter });
+      const tracked = await trackSmartdataRead(
+        this.collection, optionsArg.session, { kind: 'count', filter }, deadlineArg,
+      );
       const count = await this.collection.mongoDbCollection.countDocuments(
         filter,
         { session: sessionArg, ...deadlineArg.commandOptions() },
@@ -1834,11 +1881,11 @@ export class SmartdataExactCollection<
   >>> {
     return this.runOperation(optionsArg, async (sessionArg, deadlineArg) => {
       const filter = convertFilterForMongoDb(filterArg);
-      trackSmartdataRead(this.collection, optionsArg.session, {
+      await trackSmartdataRead(this.collection, optionsArg.session, {
         kind: 'documents',
         filter,
         matches: true,
-      });
+      }, deadlineArg);
       return (await this.collection.mongoDbCollection.distinct(
         fieldArg as string,
         filter,
@@ -1904,7 +1951,12 @@ export class SmartdataExactCollection<
       ? { _id: current._id, _smartdataRevision: current._smartdataRevision }
       : { _id: current._id, _smartdataRevision: { $exists: false } };
 
-    // Only a revision pins the stored body the selector matched.
+    // Only a revision pins the stored body the selector matched; without one
+    // the write-revision partition it held is read first.
+    const previousPartitionsRead = current._smartdataRevision === undefined
+      && await readPreviousWriteRevisions(
+        this.collection.smartdataDb, this.collection.mongoDbCollection, sessionArg, selector, deadlineArg,
+      );
     const reportTransition = (): void => {
       reportSmartdataCollectionWrite(
         this.collection,
@@ -1912,7 +1964,10 @@ export class SmartdataExactCollection<
         'replace',
         [current, expectedStoredDocument],
         selector,
-        { images: current._smartdataRevision !== undefined ? 'beforeAndAfter' : 'after' },
+        {
+          images: current._smartdataRevision !== undefined ? 'beforeAndAfter' : 'after',
+          ...(previousPartitionsRead ? { previousPartitionsRead } : {}),
+        },
       );
     };
     const replaceOptions = {
@@ -2006,6 +2061,10 @@ export class SmartdataExactCollection<
           [this.reconcileBy]: identity,
           _smartdataRevision: { $exists: false },
         };
+    const previousPartitionsRead = current._smartdataRevision === undefined
+      && await readPreviousWriteRevisions(
+        this.collection.smartdataDb, this.collection.mongoDbCollection, sessionArg, selector, deadlineArg,
+      );
     let result: plugins.mongodb.DeleteResult;
     const deleteOptions = { session: sessionArg, ...deadlineArg.commandOptions() };
     try {
@@ -2032,7 +2091,10 @@ export class SmartdataExactCollection<
         'delete',
         [current],
         selector,
-        { images: current._smartdataRevision !== undefined ? 'before' : 'none' },
+        {
+          images: current._smartdataRevision !== undefined ? 'before' : 'none',
+          ...(previousPartitionsRead ? { previousPartitionsRead } : {}),
+        },
       );
       return { status: 'deleted', deletedCount: 1 };
     }

package/ts/nosqldb/classes.operationdeadline.ts

@@ -76,6 +76,14 @@ export class SmartdataOperationDeadline {
     return this.expiresAt !== undefined;
   }
 
+  /**
+   * The time left for a deadline handed on whole, such as a transaction's;
+   * `undefined` when unbounded. Throws `timeout` once it has passed.
+   */
+  public remainingTimeoutMS(): number | undefined {
+    return this.expiresAt === undefined ? undefined : this.remainingMS();
+  }
+
   /** Throws the signal's reason once the call was aborted. */
   public throwIfAborted(): void {
     this.signal?.throwIfAborted();