@lossless.org/client 1.21.1 → 1.22.0

package/dist_ts/nosqldb/classes.writerevisions.js

@@ -0,0 +1,246 @@
+import * as plugins from './plugins.js';
+import { assertDataOptions } from './classes.operationbudget.js';
+import { SmartdataPersistenceError, isMongoDuplicateKeyError } from './classes.persistence.js';
+/** The collection that holds the counters. */
+export const writeRevisionsCollectionName = '__smartdata_write_revisions';
+/** The counter every write revision belongs to; a new generation restarts all counters. */
+const epochId = '$epoch';
+const maximumPartitionLength = 512;
+const maximumPinnedPartitions = 64;
+/** Beyond this many documents, a write by selector bumps the shared counter instead. */
+export const maximumPreReadDocuments = 1024;
+const snapshotTimeoutMs = 5_000;
+const partitionFields = new WeakMap();
+/** @internal Validates and records the option; called once by the database's constructor. */
+export const configureSmartdataWriteRevisions = (dbArg, optionsArg) => {
+    if (optionsArg === undefined)
+        return;
+    const { partitionField } = assertDataOptions(optionsArg, ['partitionField']);
+    if (typeof partitionField !== 'string'
+        || partitionField.length === 0
+        || !partitionField.isWellFormed()
+        || partitionField.includes('.')
+        || partitionField.startsWith('$')
+        || partitionField === '_id') {
+        throw new SmartdataPersistenceError('invalid_argument', 'Write revisions require a top-level partition field other than _id: no "." and no leading "$".');
+    }
+    partitionFields.set(dbArg, partitionField);
+};
+/** @internal The configured partition field, whether or not the engine can carry revisions. */
+export const writeRevisionsPartitionField = (dbArg) => partitionFields.get(dbArg);
+/** @internal Write revisions are configured and the engine runs transactions. */
+export const isSmartdataWriteRevisionsActive = (dbArg) => partitionFields.has(dbArg) && dbArg.capabilities?.transactions === 'available';
+/** A string the counters can name, or `undefined`. */
+const partitionOf = (valueArg) => typeof valueArg === 'string' && valueArg.length <= maximumPartitionLength && valueArg.isWellFormed()
+    ? valueArg
+    : undefined;
+/** @internal The counter of one partition of a collection. */
+export const partitionRevisionId = (collectionArg, partitionArg) => `${collectionArg}$s${partitionArg}`;
+/** @internal The counter of a collection's writes that no partition can place. */
+export const sharedRevisionId = (collectionArg) => `${collectionArg}$*`;
+/**
+ * @internal The counter a stored value of the partition field belongs to:
+ * its partition's for a string the counters can name, the shared one otherwise.
+ */
+export const revisionIdOfValue = (collectionArg, valueArg) => {
+    const partition = partitionOf(valueArg);
+    return partition === undefined
+        ? sharedRevisionId(collectionArg)
+        : partitionRevisionId(collectionArg, partition);
+};
+const isPlainRecord = (valueArg) => {
+    if (typeof valueArg !== 'object' || valueArg === null || Array.isArray(valueArg))
+        return false;
+    const prototype = Object.getPrototypeOf(valueArg);
+    return prototype === Object.prototype || prototype === null;
+};
+/**
+ * The partitions a filter pins the field to: a string, `{ $eq: string }` or
+ * `{ $in: [...strings] }` beside other operators, at the top level or inside
+ * `$and`. The first pin found wins.
+ */
+const pinnedPartitions = (filterArg, fieldArg) => {
+    if (!isPlainRecord(filterArg))
+        return undefined;
+    if (Object.hasOwn(filterArg, fieldArg)) {
+        const condition = filterArg[fieldArg];
+        if (typeof condition === 'string') {
+            const partition = partitionOf(condition);
+            if (partition !== undefined)
+                return [partition];
+        }
+        else if (isPlainRecord(condition)
+            && Object.keys(condition).length > 0
+            && Object.keys(condition).every((keyArg) => keyArg.startsWith('$'))) {
+            if (Object.hasOwn(condition, '$eq')) {
+                const partition = partitionOf(condition.$eq);
+                if (partition !== undefined)
+                    return [partition];
+            }
+            const values = condition.$in;
+            if (Array.isArray(values)
+                && values.length > 0
+                && values.length <= maximumPinnedPartitions
+                && values.every((valueArg) => partitionOf(valueArg) !== undefined)) {
+                return [...new Set(values)];
+            }
+        }
+    }
+    if (Array.isArray(filterArg.$and)) {
+        for (const conjunct of filterArg.$and) {
+            const partitions = pinnedPartitions(conjunct, fieldArg);
+            if (partitions)
+                return partitions;
+        }
+    }
+    return undefined;
+};
+/*
+ * Snapshot keys: `e` for the epoch, `c<id>` for one counter and `r<collection>`
+ * for the sum of every counter of a collection.
+ */
+const epochKey = 'e';
+const counterKey = (idArg) => `c${idArg}`;
+const rangeKey = (collectionArg) => `r${collectionArg}`;
+/**
+ * @internal The snapshot keys one read depends on. A read the field pins
+ * depends on its partitions and the shared counter, which holds every
+ * document whose field holds no single string; any other read depends on the
+ * whole collection.
+ */
+export const writeRevisionKeysOfRead = (dbArg, collectionArg, kindArg, filterArg) => {
+    const field = partitionFields.get(dbArg);
+    const partitions = field === undefined || kindArg === 'collection'
+        ? undefined
+        : pinnedPartitions(filterArg, field);
+    if (!partitions)
+        return [epochKey, rangeKey(collectionArg)];
+    return [
+        epochKey,
+        counterKey(sharedRevisionId(collectionArg)),
+        ...partitions.map((partitionArg) => counterKey(partitionRevisionId(collectionArg, partitionArg))),
+    ];
+};
+const revisionsCollection = (mongoDbArg) => mongoDbArg.collection(writeRevisionsCollectionName);
+const connectedDb = (dbArg) => {
+    if (dbArg.status !== 'connected' || !dbArg.mongoDb) {
+        throw new SmartdataPersistenceError('unsupported_operation', 'Write revisions require a connected SmartdataDb.');
+    }
+    return dbArg.mongoDb;
+};
+/**
+ * @internal The current value of each snapshot key, or `undefined` for a key
+ * whose value cannot be known: a missing epoch means the counters restarted.
+ * Bounded by its own deadline.
+ */
+export const readWriteRevisionSnapshot = async (dbArg, keysArg) => {
+    const collection = revisionsCollection(connectedDb(dbArg));
+    const signal = AbortSignal.timeout(snapshotTimeoutMs);
+    const expiresAt = performance.now() + snapshotTimeoutMs;
+    const options = () => ({
+        timeoutMS: Math.max(1, Math.ceil(expiresAt - performance.now())),
+        timeoutMode: 'cursorLifetime',
+        signal,
+    });
+    const counterIds = keysArg.flatMap((keyArg) => keyArg.startsWith('c') ? [keyArg.slice(1)] : []);
+    const ranges = keysArg.flatMap((keyArg) => keyArg.startsWith('r') ? [keyArg.slice(1)] : []);
+    const [counters, ...sums] = await Promise.all([
+        collection.find({ _id: { $in: [epochId, ...counterIds] } }, { projection: { n: 1, generation: 1 }, ...options() }).toArray(),
+        ...ranges.map((collectionArg) => collection.aggregate([
+            { $match: { _id: { $gte: `${collectionArg}$`, $lt: `${collectionArg}%` } } },
+            { $group: { _id: null, n: { $sum: '$n' } } },
+        ], options()).toArray()),
+    ]);
+    const byId = new Map(counters.map((documentArg) => [documentArg._id, documentArg]));
+    const snapshot = new Map();
+    const epoch = byId.get(epochId);
+    snapshot.set(epochKey, typeof epoch?.generation === 'string' && Number.isSafeInteger(epoch.n)
+        ? `${epoch.generation}:${epoch.n}`
+        : undefined);
+    for (const id of counterIds) {
+        const counter = byId.get(id);
+        snapshot.set(counterKey(id), counter === undefined
+            ? '0'
+            : Number.isSafeInteger(counter.n) ? String(counter.n) : undefined);
+    }
+    for (const [index, collectionArg] of ranges.entries()) {
+        const sum = sums[index].length === 0 ? 0 : sums[index][0].n;
+        snapshot.set(rangeKey(collectionArg), typeof sum === 'number' && Number.isSafeInteger(sum)
+            ? String(sum)
+            : undefined);
+    }
+    return snapshot;
+};
+/**
+ * @internal Creates the epoch of a database that has none, before `init()`
+ * publishes the connection. Another process creating it at the same time is
+ * fine.
+ */
+export const ensureSmartdataWriteRevisions = async (mongoDbArg, optionsArg = {}) => {
+    try {
+        await revisionsCollection(mongoDbArg).updateOne({ _id: epochId }, { $setOnInsert: { n: 0, generation: plugins.nodeCrypto.randomUUID() } }, { upsert: true, ...optionsArg });
+    }
+    catch (errorArg) {
+        if (!isMongoDuplicateKeyError(errorArg))
+            throw errorArg;
+    }
+};
+/**
+ * @internal Bumps the epoch, which every read set depends on, so every read
+ * set of every process stops being current. An epoch that went missing is
+ * recreated with a new generation.
+ */
+export const bumpSmartdataWriteRevisionEpoch = async (dbArg, optionsArg) => {
+    const collection = revisionsCollection(connectedDb(dbArg));
+    const bump = () => collection.updateOne({ _id: epochId }, { $inc: { n: 1 }, $setOnInsert: { generation: plugins.nodeCrypto.randomUUID() } }, { upsert: true, ...optionsArg });
+    try {
+        await bump();
+    }
+    catch (errorArg) {
+        // A concurrent upsert created the epoch first; the update now matches it.
+        if (!isMongoDuplicateKeyError(errorArg))
+            throw errorArg;
+        await bump();
+    }
+};
+/**
+ * @internal Bumps the counters a transaction's writes touched, inside that
+ * transaction, right before its commit. Sorted, so concurrent transactions
+ * take the counters in one order.
+ */
+export const flushSmartdataWriteRevisions = async (mongoDbArg, rawSessionArg, idsArg, signalArg) => {
+    if (idsArg.size === 0)
+        return;
+    await revisionsCollection(mongoDbArg).bulkWrite([...idsArg].sort().map((idArg) => ({
+        updateOne: { filter: { _id: idArg }, update: { $inc: { n: 1 } }, upsert: true },
+    })), {
+        ordered: true,
+        session: rawSessionArg,
+        ...(signalArg === undefined ? {} : { signal: signalArg }),
+    });
+};
+/**
+ * @internal The counters of the documents a write by selector is about to
+ * change, read in its transaction before it runs. Snapshot isolation makes
+ * them exactly the documents the write sees. More documents than the bound,
+ * or a value the counters cannot name, bump the shared counter.
+ */
+export const readPreviousRevisionIds = async (dbArg, collectionArg, rawSessionArg, selectorArg, deadlineArg) => {
+    const field = partitionFields.get(dbArg);
+    const documents = await collectionArg.find(selectorArg, {
+        projection: { [field]: 1, _id: 0 },
+        limit: maximumPreReadDocuments + 1,
+        session: rawSessionArg,
+        ...deadlineArg.cursorOptions(),
+    }).toArray();
+    const ids = new Set();
+    if (documents.length > maximumPreReadDocuments) {
+        ids.add(sharedRevisionId(collectionArg.collectionName));
+        return ids;
+    }
+    for (const document of documents) {
+        ids.add(revisionIdOfValue(collectionArg.collectionName, Object.hasOwn(document, field) ? document[field] : undefined));
+    }
+    return ids;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.writerevisions.js","sourceRoot":"","sources":["../../ts/nosqldb/classes.writerevisions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AAGxC,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAEjE,OAAO,EAAE,yBAAyB,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AAkB/F,8CAA8C;AAC9C,MAAM,CAAC,MAAM,4BAA4B,GAAG,6BAA6B,CAAC;AAQ1E,2FAA2F;AAC3F,MAAM,OAAO,GAAG,QAAQ,CAAC;AACzB,MAAM,sBAAsB,GAAG,GAAG,CAAC;AACnC,MAAM,uBAAuB,GAAG,EAAE,CAAC;AACnC,wFAAwF;AACxF,MAAM,CAAC,MAAM,uBAAuB,GAAG,IAAI,CAAC;AAC5C,MAAM,iBAAiB,GAAG,KAAK,CAAC;AAEhC,MAAM,eAAe,GAAG,IAAI,OAAO,EAAuB,CAAC;AAE3D,6FAA6F;AAC7F,MAAM,CAAC,MAAM,gCAAgC,GAAG,CAAC,KAAkB,EAAE,UAAmB,EAAQ,EAAE;IAChG,IAAI,UAAU,KAAK,SAAS;QAAE,OAAO;IACrC,MAAM,EAAE,cAAc,EAAE,GAAG,iBAAiB,CAAC,UAAU,EAAE,CAAC,gBAAgB,CAAC,CAAC,CAAC;IAC7E,IACE,OAAO,cAAc,KAAK,QAAQ;WAC/B,cAAc,CAAC,MAAM,KAAK,CAAC;WAC3B,CAAC,cAAc,CAAC,YAAY,EAAE;WAC9B,cAAc,CAAC,QAAQ,CAAC,GAAG,CAAC;WAC5B,cAAc,CAAC,UAAU,CAAC,GAAG,CAAC;WAC9B,cAAc,KAAK,KAAK,EAC3B,CAAC;QACD,MAAM,IAAI,yBAAyB,CAAC,kBAAkB,EACpD,gGAAgG,CAAC,CAAC;IACtG,CAAC;IACD,eAAe,CAAC,GAAG,CAAC,KAAK,EAAE,cAAc,CAAC,CAAC;AAC7C,CAAC,CAAC;AAEF,+FAA+F;AAC/F,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAAC,KAAkB,EAAsB,EAAE,CACrF,eAAe,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;AAE7B,iFAAiF;AACjF,MAAM,CAAC,MAAM,+BAA+B,GAAG,CAAC,KAAkB,EAAW,EAAE,CAC7E,eAAe,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,YAAY,EAAE,YAAY,KAAK,WAAW,CAAC;AAEjF,sDAAsD;AACtD,MAAM,WAAW,GAAG,CAAC,QAAiB,EAAsB,EAAE,CAC5D,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,CAAC,MAAM,IAAI,sBAAsB,IAAI,QAAQ,CAAC,YAAY,EAAE;IAClG,CAAC,CAAC,QAAQ;IACV,CAAC,CAAC,SAAS,CAAC;AAEhB,8DAA8D;AAC9D,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,aAAqB,EAAE,YAAoB,EAAU,EAAE,CACzF,GAAG,aAAa,KAAK,YAAY,EAAE,CAAC;AAEtC,kFAAkF;AAClF,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,aAAqB,EAAU,EAAE,CAAC,GAAG,aAAa,IAAI,CAAC;AAExF;;;GAGG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,aAAqB,EAAE,QAAiB,EAAU,EAAE;IACpF,MAAM,SAAS,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAC;IACxC,OAAO,SAAS,KAAK,SAAS;QAC5B,CAAC,CAAC,gBAAgB,CAAC,aAAa,CAAC;QACjC,CAAC,CAAC,mBAAmB,CAAC,aAAa,EAAE,SAAS,CAAC,CAAC;AACpD,CAAC,CAAC;AAEF,MAAM,aAAa,GAAG,CAAC,QAAiB,EAAuC,EAAE;IAC/E,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,KAAK,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC;QAAE,OAAO,KAAK,CAAC;IAC/F,MAAM,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC;IAClD,OAAO,SAAS,KAAK,MAAM,CAAC,SAAS,IAAI,SAAS,KAAK,IAAI,CAAC;AAC9D,CAAC,CAAC;AAEF;;;;GAIG;AACH,MAAM,gBAAgB,GAAG,CAAC,SAAkB,EAAE,QAAgB,EAAwB,EAAE;IACtF,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC;QAAE,OAAO,SAAS,CAAC;IAChD,IAAI,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,QAAQ,CAAC,EAAE,CAAC;QACvC,MAAM,SAAS,GAAG,SAAS,CAAC,QAAQ,CAAC,CAAC;QACtC,IAAI,OAAO,SAAS,KAAK,QAAQ,EAAE,CAAC;YAClC,MAAM,SAAS,GAAG,WAAW,CAAC,SAAS,CAAC,CAAC;YACzC,IAAI,SAAS,KAAK,SAAS;gBAAE,OAAO,CAAC,SAAS,CAAC,CAAC;QAClD,CAAC;aAAM,IACL,aAAa,CAAC,SAAS,CAAC;eACrB,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,MAAM,GAAG,CAAC;eACjC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,EACnE,CAAC;YACD,IAAI,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,KAAK,CAAC,EAAE,CAAC;gBACpC,MAAM,SAAS,GAAG,WAAW,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;gBAC7C,IAAI,SAAS,KAAK,SAAS;oBAAE,OAAO,CAAC,SAAS,CAAC,CAAC;YAClD,CAAC;YACD,MAAM,MAAM,GAAG,SAAS,CAAC,GAAG,CAAC;YAC7B,IACE,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC;mBAClB,MAAM,CAAC,MAAM,GAAG,CAAC;mBACjB,MAAM,CAAC,MAAM,IAAI,uBAAuB;mBACxC,MAAM,CAAC,KAAK,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,WAAW,CAAC,QAAQ,CAAC,KAAK,SAAS,CAAC,EAClE,CAAC;gBACD,OAAO,CAAC,GAAG,IAAI,GAAG,CAAC,MAAkB,CAAC,CAAC,CAAC;YAC1C,CAAC;QACH,CAAC;IACH,CAAC;IACD,IAAI,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC;QAClC,KAAK,MAAM,QAAQ,IAAI,SAAS,CAAC,IAAI,EAAE,CAAC;YACtC,MAAM,UAAU,GAAG,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;YACxD,IAAI,UAAU;gBAAE,OAAO,UAAU,CAAC;QACpC,CAAC;IACH,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC,CAAC;AAEF;;;GAGG;AACH,MAAM,QAAQ,GAAG,GAAG,CAAC;AACrB,MAAM,UAAU,GAAG,CAAC,KAAa,EAAU,EAAE,CAAC,IAAI,KAAK,EAAE,CAAC;AAC1D,MAAM,QAAQ,GAAG,CAAC,aAAqB,EAAU,EAAE,CAAC,IAAI,aAAa,EAAE,CAAC;AAExE;;;;;GAKG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,CACrC,KAAkB,EAClB,aAAqB,EACrB,OAA6C,EAC7C,SAAkB,EACR,EAAE;IACZ,MAAM,KAAK,GAAG,eAAe,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IACzC,MAAM,UAAU,GAAG,KAAK,KAAK,SAAS,IAAI,OAAO,KAAK,YAAY;QAChE,CAAC,CAAC,SAAS;QACX,CAAC,CAAC,gBAAgB,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;IACvC,IAAI,CAAC,UAAU;QAAE,OAAO,CAAC,QAAQ,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAC,CAAC;IAC5D,OAAO;QACL,QAAQ;QACR,UAAU,CAAC,gBAAgB,CAAC,aAAa,CAAC,CAAC;QAC3C,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC,YAAY,EAAE,EAAE,CAAC,UAAU,CAAC,mBAAmB,CAAC,aAAa,EAAE,YAAY,CAAC,CAAC,CAAC;KAClG,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,mBAAmB,GAAG,CAAC,UAA8B,EAAE,EAAE,CAC7D,UAAU,CAAC,UAAU,CAAyB,4BAA4B,CAAC,CAAC;AAE9E,MAAM,WAAW,GAAG,CAAC,KAAkB,EAAsB,EAAE;IAC7D,IAAI,KAAK,CAAC,MAAM,KAAK,WAAW,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;QACnD,MAAM,IAAI,yBAAyB,CAAC,uBAAuB,EACzD,kDAAkD,CAAC,CAAC;IACxD,CAAC;IACD,OAAO,KAAK,CAAC,OAAO,CAAC;AACvB,CAAC,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,KAAK,EAC5C,KAAkB,EAClB,OAA0B,EACgB,EAAE;IAC5C,MAAM,UAAU,GAAG,mBAAmB,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;IAC3D,MAAM,MAAM,GAAG,WAAW,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC;IACtD,MAAM,SAAS,GAAG,WAAW,CAAC,GAAG,EAAE,GAAG,iBAAiB,CAAC;IACxD,MAAM,OAAO,GAAG,GAAG,EAAE,CAAC,CAAC;QACrB,SAAS,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,SAAS,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC,CAAC;QAChE,WAAW,EAAE,gBAAyB;QACtC,MAAM;KACP,CAAC,CAAC;IACH,MAAM,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IAChG,MAAM,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IAC5F,MAAM,CAAC,QAAQ,EAAE,GAAG,IAAI,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;QAC5C,UAAU,CAAC,IAAI,CACb,EAAE,GAAG,EAAE,EAAE,GAAG,EAAE,CAAC,OAAO,EAAE,GAAG,UAAU,CAAC,EAAE,EAAE,EAC1C,EAAE,UAAU,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,EAAE,GAAG,OAAO,EAAE,EAAE,CACtD,CAAC,OAAO,EAAE;QACX,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,aAAa,EAAE,EAAE,CAAC,UAAU,CAAC,SAAS,CAAiB;YACpE,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,EAAE,IAAI,EAAE,GAAG,aAAa,GAAG,EAAE,GAAG,EAAE,GAAG,aAAa,GAAG,EAAE,EAAE,EAAE;YAC5E,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE;SAC7C,EAAE,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC;KACzB,CAAC,CAAC;IACH,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC,WAAW,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;IACpF,MAAM,QAAQ,GAAG,IAAI,GAAG,EAA8B,CAAC;IACvD,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IAChC,QAAQ,CAAC,GAAG,CAAC,QAAQ,EAAE,OAAO,KAAK,EAAE,UAAU,KAAK,QAAQ,IAAI,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC;QAC3F,CAAC,CAAC,GAAG,KAAK,CAAC,UAAU,IAAI,KAAK,CAAC,CAAC,EAAE;QAClC,CAAC,CAAC,SAAS,CAAC,CAAC;IACf,KAAK,MAAM,EAAE,IAAI,UAAU,EAAE,CAAC;QAC5B,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QAC7B,QAAQ,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC,EAAE,OAAO,KAAK,SAAS;YAChD,CAAC,CAAC,GAAG;YACL,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;IACvE,CAAC;IACD,KAAK,MAAM,CAAC,KAAK,EAAE,aAAa,CAAC,IAAI,MAAM,CAAC,OAAO,EAAE,EAAE,CAAC;QACtD,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAC5D,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,GAAG,KAAK,QAAQ,IAAI,MAAM,CAAC,aAAa,CAAC,GAAG,CAAC;YACxF,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;YACb,CAAC,CAAC,SAAS,CAAC,CAAC;IACjB,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,6BAA6B,GAAG,KAAK,EAChD,UAA8B,EAC9B,UAAU,GAAiD,EAAE,EAC9C,EAAE;IACjB,IAAI,CAAC;QACH,MAAM,mBAAmB,CAAC,UAAU,CAAC,CAAC,SAAS,CAC7C,EAAE,GAAG,EAAE,OAAO,EAAE,EAChB,EAAE,YAAY,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,UAAU,EAAE,OAAO,CAAC,UAAU,CAAC,UAAU,EAAE,EAAE,EAAE,EACvE,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,UAAU,EAAE,CAChC,CAAC;IACJ,CAAC;IAAC,OAAO,QAAQ,EAAE,CAAC;QAClB,IAAI,CAAC,wBAAwB,CAAC,QAAQ,CAAC;YAAE,MAAM,QAAQ,CAAC;IAC1D,CAAC;AACH,CAAC,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAAG,KAAK,EAClD,KAAkB,EAClB,UAAwD,EACzC,EAAE;IACjB,MAAM,UAAU,GAAG,mBAAmB,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;IAC3D,MAAM,IAAI,GAAG,GAAG,EAAE,CAAC,UAAU,CAAC,SAAS,CACrC,EAAE,GAAG,EAAE,OAAO,EAAE,EAChB,EAAE,IAAI,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,YAAY,EAAE,EAAE,UAAU,EAAE,OAAO,CAAC,UAAU,CAAC,UAAU,EAAE,EAAE,EAAE,EACjF,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,UAAU,EAAE,CAChC,CAAC;IACF,IAAI,CAAC;QACH,MAAM,IAAI,EAAE,CAAC;IACf,CAAC;IAAC,OAAO,QAAQ,EAAE,CAAC;QAClB,0EAA0E;QAC1E,IAAI,CAAC,wBAAwB,CAAC,QAAQ,CAAC;YAAE,MAAM,QAAQ,CAAC;QACxD,MAAM,IAAI,EAAE,CAAC;IACf,CAAC;AACH,CAAC,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,KAAK,EAC/C,UAA8B,EAC9B,aAA4C,EAC5C,MAA2B,EAC3B,SAAkC,EACnB,EAAE;IACjB,IAAI,MAAM,CAAC,IAAI,KAAK,CAAC;QAAE,OAAO;IAC9B,MAAM,mBAAmB,CAAC,UAAU,CAAC,CAAC,SAAS,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QACjF,SAAS,EAAE,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE;KAChF,CAAC,CAAC,EAAE;QACH,OAAO,EAAE,IAAI;QACb,OAAO,EAAE,aAAa;QACtB,GAAG,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC;KAC1D,CAAC,CAAC;AACL,CAAC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,KAAK,EAC1C,KAAkB,EAClB,aAA8C,EAC9C,aAA4C,EAC5C,WAAoB,EACpB,WAAuC,EACjB,EAAE;IACxB,MAAM,KAAK,GAAG,eAAe,CAAC,GAAG,CAAC,KAAK,CAAE,CAAC;IAC1C,MAAM,SAAS,GAAG,MAAM,aAAa,CAAC,IAAI,CAAC,WAA0C,EAAE;QACrF,UAAU,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE;QAClC,KAAK,EAAE,uBAAuB,GAAG,CAAC;QAClC,OAAO,EAAE,aAAa;QACtB,GAAG,WAAW,CAAC,aAAa,EAAE;KAC/B,CAAC,CAAC,OAAO,EAAE,CAAC;IACb,MAAM,GAAG,GAAG,IAAI,GAAG,EAAU,CAAC;IAC9B,IAAI,SAAS,CAAC,MAAM,GAAG,uBAAuB,EAAE,CAAC;QAC/C,GAAG,CAAC,GAAG,CAAC,gBAAgB,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC,CAAC;QACxD,OAAO,GAAG,CAAC;IACb,CAAC;IACD,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;QACjC,GAAG,CAAC,GAAG,CAAC,iBAAiB,CAAC,aAAa,CAAC,cAAc,EACpD,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC;IACnE,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lossless.org/client",
-  "version": "1.21.1",
+  "version": "1.22.0",
   "private": false,
   "description": "One typed client for NoSQLDB, MongoDB, SQLDB, MariaDB, ClickHouse and S3 object storage.",
   "exports": {
@@ -81,15 +81,15 @@
     "@aws-sdk/client-s3": "^3.1039.0",
     "@clickhouse/client": "1.23.1",
     "@git.zone/tsbuild": "6.0.2",
-    "@git.zone/tsbundle": "3.1.4",
-    "@git.zone/tsrun": "3.0.2",
+    "@git.zone/tsbundle": "3.2.0",
+    "@git.zone/tsrun": "3.0.3",
     "@git.zone/tstest": "7.2.0",
     "@lossless.org/nosqldb": "8.0.2",
     "@lossless.org/nosqldb-qualified": "npm:@lossless.org/nosqldb@10.7.2",
     "@lossless.org/objectstorage": "10.3.1",
     "@lossless.org/sqldb": "0.2.3",
     "@push.rocks/qenv": "^6.1.3",
-    "@types/node": "26.6.3",
+    "@types/node": "26.6.4",
     "mariadb": "3.5.4",
     "mongodb-memory-server": "11.1.0"
   },

package/readme.md

@@ -118,6 +118,7 @@ Family imports preserve the established SmartData and SmartBucket names and cons
 | Subclasses need their own binding | a subclass of a bound model that declares decorators or a persistence policy of its own and no `@Collection()`, `@managed()` or `defineCollectionModel()` binding is refused with `invalid_configuration` on every read and write, so it never writes through the parent's schema; an undecorated subclass keeps the inherited binding |
 | Observing this process's writes | `db.observeWrites({ fields, listener })` — one frozen report per acknowledged model write, `{ collection, kind, documents, anchors }` with the requested top-level fields of the written documents and of the selector's equality anchors; writes inside a `db.createSession()` transaction are reported after the commit, never after a rollback; works on NoSQLDB, where `watch()` is unsupported |
 | Following this process's reads | `db.trackReads(fn)` resolves `{ result, reads }`; `reads.changed` turns true once a write this process makes through the database's models could have changed what a model read of `fn` returned, judged by the read's query and the ids it returned, and a write it cannot place counts as one that did, so a cache keyed by `reads` rebuilds only what a write touched; works on NoSQLDB |
+| Following every process's writes | with `new SmartdataDb({ ..., writeRevisions: { partitionField: 'organizationId' } })` in every writer, the awaited `reads.isCurrent()` is true while no model write of any process could have changed the reads, counted per collection and partition value in the write's transaction, so one organization's writes keep another's sets current; `db.invalidateTrackedReads()` states raw writes and migrations; needs an engine identified as NoSQLDB, elsewhere `isCurrent()` is always false |
 | Disposable test databases on a unix socket | `SmartdataTestDatabase.create({ connection: { socketPath } })` from `@lossless.org/client/testsupport` reaches an engine that listens only on a unix-domain socket, fault helpers included; the loopback `host`/`port` form is unchanged |
 
 `docs/source/smartdata/readme.md` documents each one with its refusals.

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@lossless.org/client',
-  version: '1.21.1',
+  version: '1.22.0',
   description: 'One typed client for NoSQLDB, MongoDB, SQLDB, MariaDB, ClickHouse and S3 object storage.'
 }

package/ts/nosqldb/classes.atomicdelete.ts

@@ -1,6 +1,7 @@
 import * as plugins from './plugins.js';
 import type { SmartdataCollection } from './classes.collection.js';
 import {
+  readPreviousWriteRevisions,
   reportSmartdataCollectionWrite,
   runWithOrdinarySmartdataSession,
   type TSmartdataOrdinarySession,
@@ -27,11 +28,15 @@ export const executeAtomicDelete = async <T>(
     {
       ordinaryWrite: true,
       prepared: collectionArg.isInitializedForCurrentDatabase(),
+      prepare: () => collectionArg.init(),
       collectionName: collectionArg.collectionName,
       timeoutMS: optsArg?.timeoutMS,
     },
     async (rawSessionArg, deadlineArg) => {
       await deadlineArg.join(collectionArg.init());
+      const previousPartitionsRead = await readPreviousWriteRevisions(
+        collectionArg.smartdataDb, collectionArg.mongoDbCollection, rawSessionArg, filterArg, deadlineArg,
+      );
       const result = await collectionArg.mongoDbCollection.deleteOne(
         filterArg,
         {
@@ -46,7 +51,7 @@ export const executeAtomicDelete = async <T>(
           'delete',
           null,
           filterArg,
-          { images: 'none' },
+          { images: 'none', ...(previousPartitionsRead ? { previousPartitionsRead } : {}) },
         );
       }
       return result;
@@ -77,12 +82,16 @@ export const executeAtomicDeleteMany = async <T>(
     {
       ordinaryWrite: true,
       prepared: collectionArg.isInitializedForCurrentDatabase(),
+      prepare: () => collectionArg.init(),
       collectionName: collectionArg.collectionName,
       timeoutMS: optsArg?.timeoutMS,
       signal: optsArg?.signal,
     },
     async (rawSessionArg, deadlineArg) => {
       await deadlineArg.join(collectionArg.init());
+      const previousPartitionsRead = await readPreviousWriteRevisions(
+        collectionArg.smartdataDb, collectionArg.mongoDbCollection, rawSessionArg, filterArg, deadlineArg,
+      );
       const result = await collectionArg.mongoDbCollection.deleteMany(
         filterArg,
         {
@@ -97,7 +106,7 @@ export const executeAtomicDeleteMany = async <T>(
           'delete',
           null,
           filterArg,
-          { images: 'none' },
+          { images: 'none', ...(previousPartitionsRead ? { previousPartitionsRead } : {}) },
         );
       }
       return result;

package/ts/nosqldb/classes.atomicfindoneandupdate.ts

@@ -5,8 +5,10 @@ import {
   SmartdataPersistenceError,
 } from './classes.persistence.js';
 import {
+  readPreviousWriteRevisions,
   reportSmartdataCollectionWrite,
   runWithOrdinarySmartdataSession,
+  isOrdinarySessionInTransaction,
   isSmartdataSession,
   failSmartdataTransaction,
   type SmartdataSession,
@@ -100,7 +102,13 @@ export const executeAtomicFindOneAndUpdate = async <T>(
   },
 ): Promise<TAtomicFindOneAndUpdateExecutionResult> => {
   const policy = collectionArg.getBoundModelSchema()?.ordinaryPersistence;
-  if (policy && (!isSmartdataSession(optionsArg.session) || optionsArg.returnDocument !== 'after')) {
+  // The caller's own transaction: one SmartData starts for write revisions
+  // would let a validated update run where it is otherwise refused.
+  if (policy && (
+    !isSmartdataSession(optionsArg.session)
+    || !isOrdinarySessionInTransaction(optionsArg.session)
+    || optionsArg.returnDocument !== 'after'
+  )) {
     throw new SmartdataPersistenceError('unsupported_operation',
       'Validated ordinary updates require an owned transaction and an after image.');
   }
@@ -110,6 +118,7 @@ export const executeAtomicFindOneAndUpdate = async <T>(
     {
       ordinaryWrite: true,
       prepared: collectionArg.isInitializedForCurrentDatabase(),
+      prepare: () => collectionArg.init(),
       collectionName: collectionArg.collectionName,
       timeoutMS: optionsArg.timeoutMS,
     },
@@ -120,6 +129,11 @@ export const executeAtomicFindOneAndUpdate = async <T>(
       }
       await deadlineArg.join(collectionArg.init());
       try {
+        // A before image states the document's previous partition itself.
+        const previousPartitionsRead = optionsArg.returnDocument === 'after'
+          && await readPreviousWriteRevisions(
+            collectionArg.smartdataDb, collectionArg.mongoDbCollection, rawSessionArg, filterArg, deadlineArg,
+          );
         const result = await collectionArg.mongoDbCollection.findOneAndUpdate(
           filterArg,
           updateArg,
@@ -149,6 +163,7 @@ export const executeAtomicFindOneAndUpdate = async <T>(
               {
                 images: classified.document ? optionsArg.returnDocument : 'none',
                 update: updateArg,
+                ...(previousPartitionsRead ? { previousPartitionsRead } : {}),
               },
             );
           }
@@ -202,12 +217,17 @@ export const executeAtomicFindOneAndReplace = async <T>(
     {
       ordinaryWrite: true,
       prepared: collectionArg.isInitializedForCurrentDatabase(),
+      prepare: () => collectionArg.init(),
       collectionName: collectionArg.collectionName,
       timeoutMS: optionsArg.timeoutMS,
     },
     async (rawSessionArg, deadlineArg) => {
       await deadlineArg.join(collectionArg.init());
       try {
+        const previousPartitionsRead = optionsArg.returnDocument === 'after'
+          && await readPreviousWriteRevisions(
+            collectionArg.smartdataDb, collectionArg.mongoDbCollection, rawSessionArg, filterArg, deadlineArg,
+          );
         const result = await collectionArg.mongoDbCollection.findOneAndReplace(
           filterArg,
           replacementArg,
@@ -237,7 +257,10 @@ export const executeAtomicFindOneAndReplace = async <T>(
               ? [classified.document]
               : [classified.document, replacementArg],
             filterArg,
-            { images: optionsArg.returnDocument === 'after' ? 'after' : 'beforeAndAfter' },
+            {
+              images: optionsArg.returnDocument === 'after' ? 'after' : 'beforeAndAfter',
+              ...(previousPartitionsRead ? { previousPartitionsRead } : {}),
+            },
           );
         }
         return classified;

package/ts/nosqldb/classes.atomicupdate.ts

@@ -5,6 +5,7 @@ import {
   normalizeOrdinaryPersistenceError,
 } from './classes.persistence.js';
 import {
+  readPreviousWriteRevisions,
   reportSmartdataCollectionWrite,
   runWithOrdinarySmartdataSession,
   type TSmartdataOrdinarySession,
@@ -35,12 +36,16 @@ export const executeAtomicUpdate = async <T>(
     {
       ordinaryWrite: true,
       prepared: collectionArg.isInitializedForCurrentDatabase(),
+      prepare: () => collectionArg.init(),
       collectionName: collectionArg.collectionName,
       timeoutMS: optsArg?.timeoutMS,
     },
     async (rawSessionArg, deadlineArg) => {
       await deadlineArg.join(collectionArg.init());
       try {
+        const previousPartitionsRead = await readPreviousWriteRevisions(
+          collectionArg.smartdataDb, collectionArg.mongoDbCollection, rawSessionArg, filterArg, deadlineArg,
+        );
         const result = await collectionArg.mongoDbCollection.updateOne(
           filterArg,
           updateArg,
@@ -57,7 +62,7 @@ export const executeAtomicUpdate = async <T>(
             result.upsertedCount > 0 ? 'insert' : 'update',
             optsArg?.observedDocument ? [optsArg.observedDocument] : null,
             filterArg,
-            { images: 'none', update: updateArg },
+            { images: 'none', update: updateArg, ...(previousPartitionsRead ? { previousPartitionsRead } : {}) },
           );
         }
         return result;
@@ -102,11 +107,13 @@ export const executeAtomicUpsertMany = async <T>(
     {
       ordinaryWrite: true,
       prepared: collectionArg.isInitializedForCurrentDatabase(),
+      prepare: () => collectionArg.init(),
       collectionName: collectionArg.collectionName,
       timeoutMS: optsArg?.timeoutMS,
     },
     async (rawSessionArg, deadlineArg) => {
       await deadlineArg.join(collectionArg.init());
+      let previousPartitionsRead = false;
       /**
        * Every entry upserts, so an entry that neither inserted nor failed
        * matched its document.
@@ -123,11 +130,22 @@ export const executeAtomicUpsertMany = async <T>(
             Object.hasOwn(upsertedIdsArg ?? {}, indexArg) ? 'insert' : 'update',
             null,
             operationArg.filter,
-            { images: 'none', update: operationArg.update },
+            {
+              images: 'none',
+              update: operationArg.update,
+              ...(previousPartitionsRead ? { previousPartitionsRead } : {}),
+            },
           );
         });
       };
       try {
+        previousPartitionsRead = await readPreviousWriteRevisions(
+          collectionArg.smartdataDb,
+          collectionArg.mongoDbCollection,
+          rawSessionArg,
+          { $or: operationsArg.map((operationArg) => operationArg.filter) },
+          deadlineArg,
+        );
         const result = await collectionArg.mongoDbCollection.bulkWrite(
           operationsArg.map((operationArg) => ({
             updateOne: {
@@ -193,12 +211,16 @@ export const executeAtomicUpdateMany = async <T>(
     {
       ordinaryWrite: true,
       prepared: collectionArg.isInitializedForCurrentDatabase(),
+      prepare: () => collectionArg.init(),
       collectionName: collectionArg.collectionName,
       timeoutMS: optsArg?.timeoutMS,
     },
     async (rawSessionArg, deadlineArg) => {
       await deadlineArg.join(collectionArg.init());
       try {
+        const previousPartitionsRead = await readPreviousWriteRevisions(
+          collectionArg.smartdataDb, collectionArg.mongoDbCollection, rawSessionArg, filterArg, deadlineArg,
+        );
         const result = await collectionArg.mongoDbCollection.updateMany(
           filterArg,
           updateArg,
@@ -214,7 +236,7 @@ export const executeAtomicUpdateMany = async <T>(
             'update',
             null,
             filterArg,
-            { images: 'none', update: updateArg },
+            { images: 'none', update: updateArg, ...(previousPartitionsRead ? { previousPartitionsRead } : {}) },
           );
         }
         return result;

package/ts/nosqldb/classes.bootstraprecord.ts

@@ -6,8 +6,11 @@ import { snapshotBoundedBsonDocument } from './classes.bsonsnapshot.js';
 import { validateOrdinaryStoredDocument } from './classes.ordinarypersistence.js';
 import { SmartdataPersistenceError, isMongoDuplicateKeyError } from './classes.persistence.js';
 import { readBoundedInspectionCursor } from './classes.namespaceinspection.js';
-import { reportSmartdataWrite, reportSmartdataWriteFailure } from './classes.session.js';
+import {
+  reportSmartdataWrite, reportSmartdataWriteFailure, runWithOrdinarySmartdataSession,
+} from './classes.session.js';
 import { runSmartdataWrite } from './classes.readtracker.js';
+import { isSmartdataWriteRevisionsActive } from './classes.writerevisions.js';
 import {
   collectionModelSchemaResolverSymbol, collectionTopologyDbInspectionSymbol,
   getExpectedCollectionTopologyForSchema, inspectCollectionTopologySnapshot,
@@ -60,7 +63,11 @@ export const insertBootstrapRecord = async (
       )), schema.ordinaryPersistence, schema.persistedFields,
     );
     const expected = getExpectedCollectionTopologyForSchema(schema);
+    const reportInsert = (): void => reportSmartdataWrite(dbArg, undefined, {
+      collection: schema.collectionName, kind: 'insert', documents: [document], images: 'after',
+    });
     let dispatched = false;
+    let reported = false;
     let outcome: TBootstrapOutcome;
     try {
       // Explicit preparation uses this same connection-generation guard.
@@ -85,6 +92,26 @@ export const insertBootstrapRecord = async (
         if (topology.status !== 'absent' && topology.status !== 'exact') return 'invalid_configuration';
         const insertOptions = budget.operationOptions();
         dispatched = true;
+        if (isSmartdataWriteRevisionsActive(dbArg)) {
+          // The insert runs in a transaction of its own that commits its write revisions with it.
+          try {
+            const inserted = await runWithOrdinarySmartdataSession(undefined, dbArg, {
+              ordinaryWrite: true, prepared: true, ...insertOptions,
+            }, async (rawSessionArg, deadlineArg) => {
+              const result = await collection.insertOne(document, {
+                session: rawSessionArg, ...deadlineArg.commandOptions(),
+              });
+              if (!result.acknowledged || result.insertedId !== document._id) return false;
+              reportInsert();
+              return true;
+            });
+            reported = inserted;
+            budget.check();
+            return inserted ? 'inserted' : 'ambiguous_write';
+          } catch (errorArg) {
+            return isMongoDuplicateKeyError(errorArg) ? 'unique_conflict' : 'ambiguous_write';
+          }
+        }
         try {
           const result = await collection.insertOne(document, insertOptions);
           budget.check();
@@ -100,9 +127,7 @@ export const insertBootstrapRecord = async (
           : 'Bootstrap insertion could not inspect the current database connection.');
     }
     if (outcome === 'inserted') {
-      reportSmartdataWrite(dbArg, undefined, {
-        collection: schema.collectionName, kind: 'insert', documents: [document], images: 'after',
-      });
+      if (!reported) reportInsert();
       return Object.freeze({ acknowledged: true, insertedId: document._id as string });
     }
     if (outcome === 'ambiguous_write') reportSmartdataWriteFailure(dbArg, undefined, schema.collectionName);