@lossless.org/client 1.20.2 → 1.21.1

package/dist_ts/nosqldb/classes.readtracker.js

@@ -0,0 +1,876 @@
+import * as plugins from './plugins.js';
+import { collectionTopologyDbInspectionSymbol } from './classes.collectiontopology.js';
+import { readBoundedInspectionCursor } from './classes.namespaceinspection.js';
+import { SmartdataPersistenceError } from './classes.persistence.js';
+/**
+ * The reads one `db.trackReads()` call made. `changed` turns true once a write
+ * of this process may have changed what any of them returned, and stays true.
+ */
+export class SmartdataReadSet {
+    /**
+     * Whether a write this process made through the database's models since the
+     * reads ran could have changed any of their results. Also true after
+     * `close()`, after the database closed, and for a set that tracked a read
+     * it cannot follow.
+     */
+    get changed() {
+        const state = readSetStates.get(this);
+        return !state || state.changed;
+    }
+    /** Stops following writes and frees the recorded reads; `changed` is true from then on. */
+    close() {
+        const state = readSetStates.get(this);
+        if (state)
+            changeReadSet(state);
+    }
+}
+// Values an image or a stored path can hold beside real values.
+const MISSING = Symbol('missing');
+const UNKNOWN = Symbol('unknown');
+const readSetStates = new WeakMap();
+const readSetsByDb = new WeakMap();
+/** Databases a read set was ever opened on; writes to others skip all capture work. */
+const trackedDbs = new WeakSet();
+const droppedReadSets = new FinalizationRegistry((stateArg) => {
+    changeReadSet(stateArg);
+});
+const readScope = new plugins.nodeAsyncHooks.AsyncLocalStorage();
+/**
+ * Per database, whether the predicates can follow a collection's reads: only a
+ * plain collection without a default collation compares like they do.
+ */
+const followableCollections = new WeakMap();
+const writeScope = new plugins.nodeAsyncHooks.AsyncLocalStorage();
+/** Orders read settling against write starts. */
+let sequence = 0;
+const changeReadSet = (stateArg) => {
+    if (stateArg.changed)
+        return;
+    stateArg.changed = true;
+    stateArg.reads.clear();
+    readSetsByDb.get(stateArg.db)?.delete(stateArg);
+};
+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;
+};
+const isObjectIdLike = (valueArg) => typeof valueArg === 'object'
+    && valueArg !== null
+    && valueArg._bsontype === 'ObjectId'
+    && typeof valueArg.toHexString === 'function';
+const isFilterPrimitive = (valueArg) => valueArg === null
+    || typeof valueArg === 'boolean'
+    || (typeof valueArg === 'number' && Number.isFinite(valueArg))
+    || (typeof valueArg === 'string' && valueArg.isWellFormed());
+/** A stable key for an `_id`, or `undefined` for a value that has none. */
+const documentIdKeyOf = (valueArg) => {
+    if (typeof valueArg === 'string')
+        return `s${valueArg}`;
+    if (typeof valueArg === 'number' && Number.isFinite(valueArg))
+        return `n${valueArg}`;
+    if (typeof valueArg === 'boolean')
+        return `b${valueArg}`;
+    if (isObjectIdLike(valueArg))
+        return `o${valueArg.toHexString()}`;
+    return undefined;
+};
+/** A stable key for a document's identity values, or `undefined` unless all are concrete primitives. */
+const identityKeyOf = (valuesArg) => valuesArg.every((valueArg) => valueArg !== null && isFilterPrimitive(valueArg))
+    ? JSON.stringify(valuesArg)
+    : undefined;
+// --- Document images --------------------------------------------------------
+/** The image of a whole stored document, or `undefined` when its shape cannot be followed. */
+const completeImage = (documentArg) => {
+    if (!isPlainRecord(documentArg) || 'toBSON' in documentArg)
+        return undefined;
+    const values = new Map();
+    for (const key of Object.keys(documentArg)) {
+        if (key.length === 0 || key.includes('.') || key.startsWith('$'))
+            return undefined;
+        values.set(key, documentArg[key]);
+    }
+    return { values, complete: true };
+};
+/** Follows `segmentsArg` below a value; arrays and foreign objects are not followed. */
+const descendValue = (valueArg, segmentsArg) => {
+    let value = valueArg;
+    for (const segment of segmentsArg) {
+        if (value === MISSING || value === UNKNOWN)
+            return value;
+        if (value === undefined)
+            return UNKNOWN;
+        if (typeof value !== 'object' || value === null)
+            return MISSING;
+        if (!isPlainRecord(value) || 'toBSON' in value)
+            return UNKNOWN;
+        value = Object.hasOwn(value, segment) ? value[segment] : MISSING;
+    }
+    if (value === undefined)
+        return UNKNOWN;
+    if (isPlainRecord(value) && 'toBSON' in value)
+        return UNKNOWN;
+    return value;
+};
+/** The value at a dotted path of an image: a value, `MISSING`, or `UNKNOWN`. */
+const lookupPath = (imageArg, pathArg) => {
+    if (!imageArg)
+        return UNKNOWN;
+    const segments = pathArg.split('.');
+    for (let length = segments.length; length > 0; length--) {
+        const key = length === segments.length ? pathArg : segments.slice(0, length).join('.');
+        if (imageArg.values.has(key)) {
+            return descendValue(imageArg.values.get(key), segments.slice(length));
+        }
+    }
+    const prefix = `${pathArg}.`;
+    for (const key of imageArg.values.keys()) {
+        // The image changed part of the value, so the rest of it is not known here.
+        if (key.startsWith(prefix))
+            return UNKNOWN;
+    }
+    if (imageArg.base)
+        return lookupPath(imageArg.base, pathArg);
+    if (imageArg.complete)
+        return pathArg === '_id' ? UNKNOWN : MISSING;
+    return UNKNOWN;
+};
+/** A deep copy of plain records and arrays, so a buffered change keeps the values of its write. */
+const snapshotValue = (valueArg) => {
+    if (Array.isArray(valueArg))
+        return valueArg.map(snapshotValue);
+    if (isPlainRecord(valueArg) && !('toBSON' in valueArg)) {
+        const copy = {};
+        for (const key of Object.keys(valueArg))
+            copy[key] = snapshotValue(valueArg[key]);
+        return copy;
+    }
+    return valueArg;
+};
+const unknownPredicate = () => undefined;
+const unknownCondition = () => undefined;
+const allOf = (partsArg) => (arg) => {
+    let result = true;
+    for (const part of partsArg) {
+        const match = part(arg);
+        if (match === false)
+            return false;
+        if (match === undefined)
+            result = undefined;
+    }
+    return result;
+};
+const anyOf = (partsArg) => (arg) => {
+    let result = false;
+    for (const part of partsArg) {
+        const match = part(arg);
+        if (match === true)
+            return true;
+        if (match === undefined)
+            result = undefined;
+    }
+    return result;
+};
+const negate = (partArg) => (arg) => {
+    const match = partArg(arg);
+    return match === undefined ? undefined : !match;
+};
+/**
+ * Whether a stored value is one the supported operators decide on. Arrays
+ * match element-wise, and other BSON types compare across numeric types, so
+ * both stay undecided.
+ */
+const isDecidableValue = (valueArg) => valueArg === MISSING
+    || isFilterPrimitive(valueArg)
+    || isObjectIdLike(valueArg)
+    || isPlainRecord(valueArg);
+const decided = (conditionArg) => (valueArg) => isDecidableValue(valueArg) ? conditionArg(valueArg) : undefined;
+/** Equality with a filter primitive or ObjectId; `null` also matches a missing field. */
+const equals = (operandArg) => decided((valueArg) => {
+    if (valueArg === MISSING || valueArg === null)
+        return operandArg === null;
+    if (isObjectIdLike(operandArg)) {
+        return isObjectIdLike(valueArg) && valueArg.toHexString() === operandArg.toHexString();
+    }
+    if (isObjectIdLike(valueArg))
+        return false;
+    if (isPlainRecord(valueArg))
+        return false;
+    return valueArg === operandArg;
+});
+const isEqualityOperand = (valueArg) => isFilterPrimitive(valueArg) || isObjectIdLike(valueArg);
+/** Strings without surrogates order the same by UTF-16 units and by UTF-8 bytes. */
+const isPlainOrderString = (valueArg) => !/[\uD800-￿]/.test(valueArg);
+const compares = (operatorArg, operandArg) => {
+    if (!(typeof operandArg === 'number' && Number.isFinite(operandArg))
+        && !(typeof operandArg === 'string' && isPlainOrderString(operandArg))) {
+        return unknownCondition;
+    }
+    return decided((valueArg) => {
+        if (valueArg === MISSING)
+            return false;
+        // A range only matches values of its operand's BSON type.
+        if (typeof valueArg !== typeof operandArg)
+            return false;
+        if (typeof valueArg === 'string' && !isPlainOrderString(valueArg))
+            return undefined;
+        const value = valueArg;
+        const operand = operandArg;
+        switch (operatorArg) {
+            case '$gt': return value > operand;
+            case '$gte': return value >= operand;
+            case '$lt': return value < operand;
+            case '$lte': return value <= operand;
+        }
+    });
+};
+const isOperatorObject = (valueArg) => isPlainRecord(valueArg)
+    && Object.keys(valueArg).length > 0
+    && Object.keys(valueArg).every((keyArg) => keyArg.startsWith('$'));
+const compileCondition = (conditionArg) => {
+    if (isEqualityOperand(conditionArg))
+        return equals(conditionArg);
+    if (!isOperatorObject(conditionArg))
+        return unknownCondition;
+    const parts = [];
+    for (const operator of Object.keys(conditionArg)) {
+        const operand = conditionArg[operator];
+        switch (operator) {
+            case '$eq':
+                parts.push(isEqualityOperand(operand) ? equals(operand) : unknownCondition);
+                break;
+            case '$ne':
+                parts.push(isEqualityOperand(operand) ? negate(equals(operand)) : unknownCondition);
+                break;
+            case '$in':
+            case '$nin': {
+                const listed = Array.isArray(operand) && operand.every(isEqualityOperand)
+                    ? anyOf(operand.map(equals))
+                    : unknownCondition;
+                parts.push(operator === '$in' ? listed : negate(listed));
+                break;
+            }
+            case '$gt':
+            case '$gte':
+            case '$lt':
+            case '$lte':
+                parts.push(compares(operator, operand));
+                break;
+            case '$exists':
+                parts.push(typeof operand === 'boolean'
+                    ? (valueArg) => valueArg === UNKNOWN
+                        ? undefined
+                        : (valueArg !== MISSING) === operand
+                    : unknownCondition);
+                break;
+            case '$not':
+                parts.push(isOperatorObject(operand) ? negate(compileCondition(operand)) : unknownCondition);
+                break;
+            default:
+                parts.push(unknownCondition);
+        }
+    }
+    return allOf(parts);
+};
+/**
+ * The part of a path a write or filter can be followed on: up to the first
+ * positional or numeric segment, which may address array elements.
+ */
+const followablePath = (pathArg) => {
+    const segments = pathArg.split('.');
+    if (segments.some((segmentArg) => segmentArg.length === 0))
+        return undefined;
+    const cut = segments.findIndex((segmentArg) => segmentArg.startsWith('$') || /^\d+$/.test(segmentArg));
+    if (cut === 0)
+        return undefined;
+    return cut === -1
+        ? { path: pathArg, whole: true }
+        : { path: segments.slice(0, cut).join('.'), whole: false };
+};
+const compileFilter = (filterArg, refsArg) => {
+    if (!isPlainRecord(filterArg)) {
+        refsArg.all = true;
+        return unknownPredicate;
+    }
+    const parts = [];
+    for (const key of Object.keys(filterArg)) {
+        const value = filterArg[key];
+        if (key === '$and' || key === '$or' || key === '$nor') {
+            if (!Array.isArray(value) || value.length === 0 || !value.every(isPlainRecord)) {
+                refsArg.all = true;
+                parts.push(unknownPredicate);
+                continue;
+            }
+            const branches = value.map((branchArg) => compileFilter(branchArg, refsArg));
+            parts.push(key === '$and'
+                ? allOf(branches)
+                : key === '$or' ? anyOf(branches) : negate(anyOf(branches)));
+            continue;
+        }
+        if (key === '$comment')
+            continue;
+        const followable = key.startsWith('$') ? undefined : followablePath(key);
+        if (!followable) {
+            refsArg.all = true;
+            parts.push(unknownPredicate);
+            continue;
+        }
+        refsArg.paths.add(followable.path);
+        if (!followable.whole) {
+            parts.push(unknownPredicate);
+            continue;
+        }
+        const condition = compileCondition(value);
+        parts.push((imageArg) => condition(lookupPath(imageArg, key)));
+    }
+    return allOf(parts);
+};
+const addSortRefs = (sortArg, refsArg) => {
+    if (sortArg === undefined)
+        return;
+    if (!isPlainRecord(sortArg)) {
+        refsArg.all = true;
+        return;
+    }
+    for (const key of Object.keys(sortArg)) {
+        const followable = key.startsWith('$') ? undefined : followablePath(key);
+        const direction = sortArg[key];
+        if (!followable || (direction !== 1 && direction !== -1)) {
+            refsArg.all = true;
+            return;
+        }
+        refsArg.paths.add(followable.path);
+    }
+};
+const updatesWithUnknownResult = new Set([
+    '$inc', '$mul', '$min', '$max', '$currentDate',
+    '$push', '$pull', '$pullAll', '$addToSet', '$pop', '$bit',
+]);
+const analyzeUpdate = (updateArg, insertedArg) => {
+    const everything = { touched: 'all', sets: new Map() };
+    if (!isPlainRecord(updateArg))
+        return everything;
+    const operators = Object.keys(updateArg);
+    if (operators.length === 0 || operators.some((operatorArg) => !operatorArg.startsWith('$'))) {
+        return everything;
+    }
+    const touched = new Set();
+    const sets = new Map();
+    const touch = (pathArg, valueArg) => {
+        const followable = followablePath(pathArg);
+        if (!followable)
+            return false;
+        const value = !followable.whole || sets.has(followable.path) ? UNKNOWN : valueArg;
+        touched.add(followable.path);
+        sets.set(followable.path, value);
+        return true;
+    };
+    for (const operator of operators) {
+        const fields = updateArg[operator];
+        if (!isPlainRecord(fields))
+            return everything;
+        for (const path of Object.keys(fields)) {
+            let followed = true;
+            switch (operator) {
+                case '$set':
+                    followed = touch(path, fields[path]);
+                    break;
+                case '$setOnInsert':
+                    if (insertedArg)
+                        followed = touch(path, fields[path]);
+                    break;
+                case '$unset':
+                    followed = touch(path, MISSING);
+                    break;
+                case '$rename':
+                    followed = typeof fields[path] === 'string'
+                        && touch(path, UNKNOWN)
+                        && touch(fields[path], UNKNOWN);
+                    break;
+                default:
+                    if (!updatesWithUnknownResult.has(operator))
+                        return everything;
+                    followed = touch(path, UNKNOWN);
+            }
+            if (!followed)
+                return everything;
+        }
+    }
+    return { touched, sets };
+};
+/**
+ * The top-level equality conditions of a selector, including inside `$and`.
+ * `null` also matches a missing field, and a non-null value also matches an
+ * array holding it, so only an `_id` (never an array) states a stored value.
+ */
+const collectEqualities = (selectorArg, equalitiesArg) => {
+    if (!isPlainRecord(selectorArg))
+        return;
+    for (const key of Object.keys(selectorArg)) {
+        const condition = selectorArg[key];
+        if (key === '$and') {
+            if (Array.isArray(condition)) {
+                for (const conjunct of condition)
+                    collectEqualities(conjunct, equalitiesArg);
+            }
+            continue;
+        }
+        if (key.startsWith('$') || key.includes('.'))
+            continue;
+        let value = UNKNOWN;
+        if (isEqualityOperand(condition)) {
+            value = condition;
+        }
+        else if (isPlainRecord(condition)
+            && Object.keys(condition).length === 1
+            && Object.hasOwn(condition, '$eq')
+            && isEqualityOperand(condition.$eq)) {
+            value = condition.$eq;
+        }
+        if (value === UNKNOWN || value === null)
+            continue;
+        if (!equalitiesArg.has(key))
+            equalitiesArg.set(key, value);
+    }
+};
+const documentIdImage = (selectorArg) => {
+    const equalities = new Map();
+    collectEqualities(selectorArg, equalities);
+    const values = new Map();
+    if (documentIdKeyOf(equalities.get('_id')) !== undefined)
+        values.set('_id', equalities.get('_id'));
+    return { values, complete: false };
+};
+const selectorIdentityKey = (selectorArg, identityFieldsArg) => {
+    if (!identityFieldsArg?.length)
+        return undefined;
+    const equalities = new Map();
+    collectEqualities(selectorArg, equalities);
+    if (!identityFieldsArg.every((fieldArg) => equalities.has(fieldArg)))
+        return undefined;
+    return identityKeyOf(identityFieldsArg.map((fieldArg) => equalities.get(fieldArg)));
+};
+const imageIdentityKey = (imageArg, identityFieldsArg) => {
+    if (!imageArg || !identityFieldsArg?.length)
+        return undefined;
+    return identityKeyOf(identityFieldsArg.map((fieldArg) => lookupPath(imageArg, fieldArg)));
+};
+/**
+ * The document an upsert inserted: the selector's plain top-level equalities
+ * under the update's values. A selector of only such equalities states every
+ * field; any other condition leaves its field unknown.
+ */
+const upsertedImage = (selectorArg, effectArg) => {
+    if (effectArg.touched === 'all' || !isPlainRecord(selectorArg))
+        return undefined;
+    const values = new Map();
+    let complete = true;
+    for (const key of Object.keys(selectorArg)) {
+        const condition = selectorArg[key];
+        if (key.startsWith('$') || key.includes('.')) {
+            complete = false;
+            continue;
+        }
+        values.set(key, isEqualityOperand(condition) && condition !== null ? condition : UNKNOWN);
+    }
+    return { values: effectArg.sets, complete: false, base: { values, complete } };
+};
+const withDocumentKeys = (changeArg, writeArg) => {
+    changeArg.idKey = documentIdKeyOf(lookupPath(changeArg.before, '_id'))
+        ?? documentIdKeyOf(lookupPath(changeArg.after, '_id'));
+    changeArg.identityKey = imageIdentityKey(changeArg.before, writeArg.identityFields)
+        ?? selectorIdentityKey(writeArg.selector, writeArg.identityFields);
+    return changeArg;
+};
+/** What one acknowledged write did to each document it wrote, as far as its report tells. */
+const describeWrite = (writeArg, startedAtArg) => {
+    const { kind, images, documents } = writeArg;
+    const unknown = [{ kind: 'unknown', touched: 'all', startedAt: startedAtArg }];
+    const change = (fieldsArg) => withDocumentKeys({ kind, startedAt: startedAtArg, ...fieldsArg }, writeArg);
+    const documentIdOf = (imageArg) => {
+        const id = lookupPath(imageArg, '_id');
+        return documentIdKeyOf(id) === undefined
+            ? undefined
+            : { values: new Map([['_id', id]]), complete: false };
+    };
+    switch (kind) {
+        case 'insert':
+            if (images === 'after' && documents) {
+                return documents.map((documentArg) => change({ after: completeImage(documentArg), touched: 'all' }));
+            }
+            if (images === 'none' && writeArg.update !== undefined) {
+                return [change({
+                        after: upsertedImage(writeArg.selector, analyzeUpdate(writeArg.update, true)),
+                        touched: 'all',
+                    })];
+            }
+            return images === undefined ? unknown : [change({ touched: 'all' })];
+        case 'update': {
+            const effect = analyzeUpdate(writeArg.update, false);
+            if (images === 'after' && documents?.length === 1) {
+                const after = completeImage(documents[0]);
+                return [change({ before: documentIdOf(after), after, touched: effect.touched })];
+            }
+            if (images === 'before' && documents?.length === 1) {
+                const before = completeImage(documents[0]);
+                return [change({
+                        before,
+                        after: effect.touched === 'all' || !before
+                            ? undefined
+                            : { values: effect.sets, complete: false, base: before },
+                        touched: effect.touched,
+                    })];
+            }
+            if (images === 'none') {
+                const before = documentIdImage(writeArg.selector);
+                return [change({
+                        before,
+                        after: effect.touched === 'all'
+                            ? undefined
+                            : { values: effect.sets, complete: false, base: before },
+                        touched: effect.touched,
+                    })];
+            }
+            return unknown;
+        }
+        case 'replace': {
+            if (images === 'beforeAndAfter' && documents?.length === 2) {
+                const before = completeImage(documents[0]);
+                let after = completeImage(documents[1]);
+                if (after && !after.values.has('_id') && before?.values.has('_id')) {
+                    after = { ...after, values: new Map([...after.values, ['_id', before.values.get('_id')]]) };
+                }
+                return [change({ before, after, touched: 'all' })];
+            }
+            if (images === 'after' && documents?.length) {
+                // Documents before the last are what the caller expected, not what was stored.
+                const after = completeImage(documents[documents.length - 1]);
+                return [change({ before: documentIdOf(after), after, touched: 'all' })];
+            }
+            return unknown;
+        }
+        case 'delete':
+            if (images === 'before' && documents) {
+                return documents.map((documentArg) => change({ before: completeImage(documentArg), touched: 'all' }));
+            }
+            if (images === 'none') {
+                return [change({ before: documentIdImage(writeArg.selector), touched: 'all' })];
+            }
+            return unknown;
+    }
+    return unknown;
+};
+// --- Evaluation -------------------------------------------------------------
+const pathsOverlap = (leftArg, rightArg) => leftArg === rightArg
+    || leftArg.startsWith(`${rightArg}.`)
+    || rightArg.startsWith(`${leftArg}.`);
+const refsOverlap = (refsArg, touchedArg) => {
+    if (refsArg === 'all' || touchedArg === 'all')
+        return true;
+    for (const ref of refsArg) {
+        for (const path of touchedArg) {
+            if (pathsOverlap(ref, path))
+                return true;
+        }
+    }
+    return false;
+};
+/**
+ * Whether the change could alter what the read returned. Anything that is not
+ * known to leave the result alone counts as a change.
+ */
+const changeAffectsRead = (readArg, changeArg) => {
+    if (changeArg.kind === 'unknown' || readArg.kind === 'collection')
+        return true;
+    const matchesBefore = () => readArg.predicate(changeArg.before);
+    const matchesAfter = () => readArg.predicate(changeArg.after);
+    // A write that started before the read settled may be part of what it returned.
+    const concurrent = !readArg.settled || readArg.settledAt > changeArg.startedAt;
+    if (readArg.kind === 'count') {
+        if (changeArg.kind === 'insert')
+            return matchesAfter() !== false;
+        if (changeArg.kind === 'delete')
+            return matchesBefore() !== false;
+        if (!refsOverlap(readArg.refs, changeArg.touched))
+            return false;
+        const before = matchesBefore();
+        const after = matchesAfter();
+        if (concurrent)
+            return !(before === false && after === false);
+        return before === undefined || after === undefined || before !== after;
+    }
+    if (changeArg.kind === 'insert')
+        return matchesAfter() !== false;
+    let returned;
+    if (readArg.settled && !concurrent) {
+        if (changeArg.idKey !== undefined && readArg.byId) {
+            returned = readArg.byId.has(changeArg.idKey);
+        }
+        else if (changeArg.identityKey !== undefined && readArg.byIdentity) {
+            returned = readArg.byIdentity.has(changeArg.identityKey);
+        }
+    }
+    if (returned === true)
+        return true;
+    if (returned === undefined && matchesBefore() !== false)
+        return true;
+    // The document was not returned: only one that matches afterwards can enter.
+    if (changeArg.kind === 'delete')
+        return false;
+    if (matchesAfter() === false)
+        return false;
+    return refsOverlap(readArg.refs, changeArg.touched);
+};
+const applyChanges = (dbArg, collectionArg, changesArg) => {
+    const states = readSetsByDb.get(dbArg);
+    if (!states)
+        return;
+    for (const state of [...states]) {
+        const reads = state.reads.get(collectionArg);
+        if (!reads)
+            continue;
+        if (reads.some((readArg) => changesArg.some((changeArg) => changeAffectsRead(readArg, changeArg)))) {
+            changeReadSet(state);
+        }
+    }
+};
+/** How long the check of one read collection may take. */
+const collectionCheckTimeoutMs = 5_000;
+/**
+ * Whether the reads of a collection can be followed, or `undefined` when it
+ * does not exist: a view, another namespace type and a collection with a
+ * default collation compare in ways the predicates do not.
+ */
+const isFollowableCollection = async (dbArg, collectionArg) => {
+    const signal = AbortSignal.timeout(collectionCheckTimeoutMs);
+    const expiresAt = performance.now() + collectionCheckTimeoutMs;
+    const cleanupOptions = () => ({ timeoutMS: Math.max(1, Math.ceil(expiresAt - performance.now())) });
+    const [namespace] = await dbArg[collectionTopologyDbInspectionSymbol]((mongoDbArg) => readBoundedInspectionCursor(mongoDbArg.listCollections({ name: collectionArg }, { nameOnly: false, batchSize: 1, ...cleanupOptions(), signal }), 1, signal, cleanupOptions));
+    if (!namespace)
+        return undefined;
+    const options = namespace.options;
+    return namespace.type === 'collection'
+        && (options === undefined || (isPlainRecord(options) && options.collation === undefined));
+};
+/**
+ * Checks each collection the set read, once per database. A collection that
+ * cannot be followed, does not exist or cannot be checked changes the set.
+ */
+const checkReadCollections = async (stateArg) => {
+    let known = followableCollections.get(stateArg.db);
+    if (!known) {
+        known = new Map();
+        followableCollections.set(stateArg.db, known);
+    }
+    const collections = [...stateArg.reads.keys()];
+    try {
+        await Promise.all(collections.filter((collectionArg) => !known.has(collectionArg))
+            .map(async (collectionArg) => {
+            const followable = await isFollowableCollection(stateArg.db, collectionArg);
+            if (followable !== undefined)
+                known.set(collectionArg, followable);
+        }));
+    }
+    catch {
+        changeReadSet(stateArg);
+        return;
+    }
+    if (collections.some((collectionArg) => known.get(collectionArg) !== true))
+        changeReadSet(stateArg);
+};
+// --- Internal API -----------------------------------------------------------
+/** @internal Runs `fnArg` with a new read set open; see `SmartdataDb.trackReads`. */
+export const trackSmartdataReads = async (dbArg, fnArg) => {
+    if (typeof fnArg !== 'function') {
+        throw new SmartdataPersistenceError('invalid_argument', 'db.trackReads() requires a callback function.');
+    }
+    const reads = new SmartdataReadSet();
+    const state = { db: dbArg, changed: false, finished: false, reads: new Map() };
+    readSetStates.set(reads, state);
+    let states = readSetsByDb.get(dbArg);
+    if (!states) {
+        states = new Set();
+        readSetsByDb.set(dbArg, states);
+    }
+    states.add(state);
+    trackedDbs.add(dbArg);
+    droppedReadSets.register(reads, state);
+    try {
+        const result = await readScope.run([...(readScope.getStore() ?? []), state], fnArg);
+        state.finished = true;
+        if (!state.changed)
+            await checkReadCollections(state);
+        return { result, reads };
+    }
+    catch (errorArg) {
+        reads.close();
+        throw errorArg;
+    }
+};
+/** @internal Whether a read of the current async context is tracked. */
+export const hasSmartdataReadScope = () => readScope.getStore() !== undefined;
+/** @internal Whether any read set of the database is open. */
+export const hasSmartdataReadSets = (dbArg) => (readSetsByDb.get(dbArg)?.size ?? 0) > 0;
+/** @internal Marks every open read set of the database changed, as its `close()` does. */
+export const changeSmartdataReadSetsOfDb = (dbArg) => {
+    // A reconnected database may hold recreated collections.
+    followableCollections.delete(dbArg);
+    for (const state of [...(readSetsByDb.get(dbArg) ?? [])])
+        changeReadSet(state);
+};
+/**
+ * Whether a limited read keeps the documents its filter and sort decide: at
+ * most one document matches an equality on `_id` or an identity field, and a
+ * sort by `_id` or by an identity field whose index holds every document
+ * orders them all.
+ */
+const limitFollowsQuery = (specArg) => {
+    const filter = specArg.filter;
+    const sort = specArg.sort;
+    const pins = (valueArg) => (isFilterPrimitive(valueArg) && valueArg !== null)
+        || isObjectIdLike(valueArg)
+        || (isPlainRecord(valueArg) && Object.keys(valueArg).length === 1 && Object.hasOwn(valueArg, '$eq') && pins(valueArg.$eq));
+    return ['_id', ...(specArg.identityFields ?? [])].some((fieldArg) => isPlainRecord(filter) && Object.hasOwn(filter, fieldArg) && pins(filter[fieldArg]))
+        || ['_id', ...(specArg.orderingIdentityFields ?? [])].some((fieldArg) => isPlainRecord(sort) && Object.hasOwn(sort, fieldArg));
+};
+/**
+ * @internal Registers one read with every open read set of the current async
+ * context, before the read is issued. A read inside a transaction sees writes
+ * that may never commit, and a read of another database or of a collection the
+ * predicates cannot follow is not followed, so each marks the sets changed
+ * instead.
+ */
+export const observeSmartdataRead = (dbArg, specArg, inTransactionArg) => {
+    const states = readScope.getStore()?.filter((stateArg) => !stateArg.changed);
+    if (!states?.length)
+        return undefined;
+    const followed = [];
+    const followable = followableCollections.get(dbArg)?.get(specArg.collection);
+    for (const state of states) {
+        // A read after the callback returned was never checked with the others.
+        if (inTransactionArg
+            || state.db !== dbArg
+            || followable === false
+            || (state.finished && followable !== true)) {
+            changeReadSet(state);
+        }
+        else {
+            followed.push(state);
+        }
+    }
+    if (followed.length === 0)
+        return undefined;
+    const refs = { paths: new Set(), all: false };
+    let predicate = specArg.kind === 'collection'
+        ? unknownPredicate
+        : compileFilter(specArg.filter ?? {}, refs);
+    addSortRefs(specArg.sort, refs);
+    if (specArg.limited && !limitFollowsQuery(specArg)) {
+        // Which matching documents the limit keeps follows the query plan, which a write to any field can reorder.
+        refs.all = true;
+    }
+    if (specArg.hint !== undefined) {
+        // A hinted sparse or partial index can leave out matching documents.
+        const filterPredicate = predicate;
+        predicate = (imageArg) => filterPredicate(imageArg) === false ? false : undefined;
+        refs.all = true;
+    }
+    const observation = {
+        kind: specArg.kind,
+        predicate,
+        refs: refs.all ? 'all' : refs.paths,
+        identityFields: specArg.identityFields?.length ? [...specArg.identityFields] : undefined,
+        settles: specArg.matches !== true,
+        settled: false,
+        settledAt: 0,
+        byId: new Set(),
+        byIdentity: specArg.identityFields?.length ? new Set() : null,
+    };
+    for (const state of followed) {
+        let reads = state.reads.get(specArg.collection);
+        if (!reads) {
+            reads = [];
+            state.reads.set(specArg.collection, reads);
+        }
+        reads.push(observation);
+    }
+    return {
+        record: (documentArg) => {
+            if (observation.settled)
+                return;
+            if (!isPlainRecord(documentArg)) {
+                observation.byId = null;
+                observation.byIdentity = null;
+                return;
+            }
+            const idKey = documentIdKeyOf(documentArg._id);
+            if (idKey === undefined)
+                observation.byId = null;
+            else
+                observation.byId?.add(idKey);
+            if (observation.byIdentity && observation.identityFields) {
+                const identityKey = identityKeyOf(observation.identityFields.map((fieldArg) => Object.hasOwn(documentArg, fieldArg) ? documentArg[fieldArg] : undefined));
+                if (identityKey === undefined)
+                    observation.byIdentity = null;
+                else
+                    observation.byIdentity.add(identityKey);
+            }
+        },
+        settle: () => {
+            if (!observation.settles || observation.settled)
+                return;
+            observation.settled = true;
+            observation.settledAt = ++sequence;
+        },
+    };
+};
+/**
+ * @internal Runs one model write. A write inside a read scope marks its sets
+ * changed; any other write records when it started, so its report can tell
+ * which reads ran concurrently with it.
+ */
+export const runSmartdataWrite = (dbArg, operationArg) => {
+    for (const state of readScope.getStore() ?? [])
+        changeReadSet(state);
+    if (!trackedDbs.has(dbArg))
+        return operationArg();
+    return writeScope.run({ db: dbArg, startedAt: ++sequence }, operationArg);
+};
+/**
+ * @internal Captures how one acknowledged write changes the open read sets of
+ * its database, and returns the change to apply, or `undefined` when no set
+ * can be affected. A `deferred` change is applied after a transaction
+ * commits; it copies the written values now and also reaches sets opened in
+ * the meantime.
+ */
+export const captureSmartdataReadChange = (dbArg, writeArg, deferredArg) => {
+    if (!trackedDbs.has(dbArg)) {
+        return deferredArg ? captureSmartdataCollectionChange(dbArg, writeArg.collection, true) : undefined;
+    }
+    if (!deferredArg && !hasSmartdataReadSets(dbArg))
+        return undefined;
+    const scope = writeScope.getStore();
+    const startedAt = scope?.db === dbArg ? scope.startedAt : 0;
+    const write = deferredArg
+        ? {
+            ...writeArg,
+            documents: writeArg.documents?.map((documentArg) => snapshotValue(documentArg)) ?? null,
+            selector: snapshotValue(writeArg.selector),
+            update: snapshotValue(writeArg.update),
+        }
+        : writeArg;
+    const changes = describeWrite(write, startedAt);
+    return () => applyChanges(dbArg, writeArg.collection, changes);
+};
+/**
+ * @internal Captures a write to the collection whose effect is not known — a
+ * failed write may still have applied — so every read of it counts as changed.
+ */
+export const captureSmartdataCollectionChange = (dbArg, collectionArg, deferredArg) => {
+    if (!deferredArg && !hasSmartdataReadSets(dbArg))
+        return undefined;
+    return () => applyChanges(dbArg, collectionArg, [{ kind: 'unknown', touched: 'all', startedAt: 0 }]);
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.readtracker.js","sourceRoot":"","sources":["../../ts/nosqldb/classes.readtracker.ts"],"names":[],"mappings":"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"}