@lossless.org/client 0.1.0

package/dist_ts/nosqldb/classes.exactpersistence.js

@@ -0,0 +1,1110 @@
+import * as plugins from './plugins.js';
+import { getInertObjectIdBytes } from './classes.bsonobjectid.js';
+import { assertBsonWithoutMutation } from './classes.bsonassertion.js';
+import { getOrdinaryPersistencePolicy } from './classes.ordinarypersistence.js';
+import { registerCollectionReconnectHandler } from './classes.collectionlifecycle.js';
+import { acquireSmartdataSession } from './classes.session.js';
+import { convertFilterForMongoDb, } from './classes.doc.js';
+const exactPersistencePolicySymbol = Symbol.for('@push.rocks/smartdata.exactPersistencePolicy');
+const storageMetadataKeys = ['_id', '_smartdataRevision'];
+const reservedKeys = [
+    ...storageMetadataKeys,
+    '_createdAt',
+    '_updatedAt',
+];
+export const isMongoObjectId = (valueArg) => valueArg instanceof plugins.mongodb.ObjectId;
+export class SmartdataExactPersistenceError extends Error {
+    code;
+    constructor(codeArg, messageArg, optionsArg) {
+        super(messageArg, optionsArg);
+        this.name = 'SmartdataExactPersistenceError';
+        this.code = codeArg;
+    }
+}
+const exactCollectionCache = new WeakMap();
+const bytesEqual = (leftArg, rightArg) => {
+    if (leftArg.byteLength !== rightArg.byteLength) {
+        return false;
+    }
+    for (let index = 0; index < leftArg.byteLength; index++) {
+        if (leftArg[index] !== rightArg[index]) {
+            return false;
+        }
+    }
+    return true;
+};
+const waitWithSignal = async (promiseArg, signalArg) => {
+    if (!signalArg)
+        return promiseArg;
+    signalArg.throwIfAborted();
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const beginSettlement = () => {
+            if (settled)
+                return false;
+            settled = true;
+            signalArg.removeEventListener('abort', onAbort);
+            return true;
+        };
+        const onAbort = () => {
+            if (beginSettlement())
+                reject(signalArg.reason);
+        };
+        signalArg.addEventListener('abort', onAbort, { once: true });
+        if (signalArg.aborted)
+            onAbort();
+        void promiseArg.then((valueArg) => {
+            if (beginSettlement())
+                resolve(valueArg);
+        }, (errorArg) => {
+            if (beginSettlement())
+                reject(errorArg);
+        });
+    });
+};
+const hasOwn = (documentArg, keyArg) => Object.prototype.hasOwnProperty.call(documentArg, keyArg);
+const isPlainObject = (valueArg) => {
+    if (typeof valueArg !== 'object' || valueArg === null) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(valueArg);
+    return prototype === Object.prototype || prototype === null;
+};
+const hasActiveInheritedToBsonEncoder = (prototypeArg) => {
+    let prototype = prototypeArg;
+    while (prototype) {
+        const descriptor = Object.getOwnPropertyDescriptor(prototype, 'toBSON');
+        if (descriptor &&
+            (!('value' in descriptor) ||
+                descriptor.value !== undefined)) {
+            return true;
+        }
+        prototype = Object.getPrototypeOf(prototype);
+    }
+    return false;
+};
+const maxExactSnapshotArrayLength = 100_000;
+const maxExactSnapshotByteLength = 16 * 1024 * 1024;
+const minSignedInt32 = -(2 ** 31);
+const maxSignedInt32 = 2 ** 31 - 1;
+const isSignedInt32 = (valueArg) => typeof valueArg === 'number' &&
+    Number.isInteger(valueArg) &&
+    !Object.is(valueArg, -0) &&
+    valueArg >= minSignedInt32 &&
+    valueArg <= maxSignedInt32;
+const typedArrayPrototype = Object.getPrototypeOf(Uint8Array.prototype);
+const typedArrayBufferGetter = Object.getOwnPropertyDescriptor(typedArrayPrototype, 'buffer')?.get;
+const typedArrayByteOffsetGetter = Object.getOwnPropertyDescriptor(typedArrayPrototype, 'byteOffset')?.get;
+const typedArrayByteLengthGetter = Object.getOwnPropertyDescriptor(typedArrayPrototype, 'byteLength')?.get;
+const regExpSourceGetter = Object.getOwnPropertyDescriptor(RegExp.prototype, 'source')?.get;
+const regExpFlagGetters = [
+    ['d', 'hasIndices'],
+    ['g', 'global'],
+    ['i', 'ignoreCase'],
+    ['m', 'multiline'],
+    ['s', 'dotAll'],
+    ['u', 'unicode'],
+    ['v', 'unicodeSets'],
+    ['y', 'sticky'],
+].map(([flag, property]) => ({
+    flag,
+    getter: Object.getOwnPropertyDescriptor(RegExp.prototype, property)?.get,
+}));
+const exactSnapshotError = (labelArg, detailArg) => new SmartdataExactPersistenceError('invalid_document', `${labelArg} ${detailArg}`);
+const constructExactBsonScalar = (constructorArg, labelArg) => {
+    try {
+        return constructorArg();
+    }
+    catch (errorArg) {
+        if (errorArg instanceof SmartdataExactPersistenceError) {
+            throw errorArg;
+        }
+        throw new SmartdataExactPersistenceError('invalid_document', `${labelArg} contains malformed BSON scalar data.`, {
+            cause: errorArg,
+        });
+    }
+};
+const getOwnDataValue = (valueArg, keyArg, labelArg) => {
+    const descriptor = Object.getOwnPropertyDescriptor(valueArg, keyArg);
+    if (!descriptor || !('value' in descriptor)) {
+        throw exactSnapshotError(labelArg, `contains a non-inert "${keyArg}" property.`);
+    }
+    return descriptor.value;
+};
+const getExactSnapshotBytes = (valueArg, labelArg) => {
+    if (typeof valueArg !== 'object' ||
+        valueArg === null ||
+        plugins.nodeUtil.types.isProxy(valueArg) ||
+        !ArrayBuffer.isView(valueArg) ||
+        !typedArrayBufferGetter ||
+        !typedArrayByteOffsetGetter ||
+        !typedArrayByteLengthGetter) {
+        throw exactSnapshotError(labelArg, 'contains invalid byte data.');
+    }
+    try {
+        const buffer = Reflect.apply(typedArrayBufferGetter, valueArg, []);
+        const byteOffset = Reflect.apply(typedArrayByteOffsetGetter, valueArg, []);
+        const byteLength = Reflect.apply(typedArrayByteLengthGetter, valueArg, []);
+        if (!Number.isSafeInteger(byteOffset) ||
+            !Number.isSafeInteger(byteLength) ||
+            byteLength < 0 ||
+            byteLength > maxExactSnapshotByteLength) {
+            throw exactSnapshotError(labelArg, 'contains oversized byte data.');
+        }
+        return Uint8Array.from(new Uint8Array(buffer, byteOffset, byteLength));
+    }
+    catch (errorArg) {
+        if (errorArg instanceof SmartdataExactPersistenceError) {
+            throw errorArg;
+        }
+        throw exactSnapshotError(labelArg, 'contains invalid byte data.');
+    }
+};
+const markInertBsonSnapshot = (valueArg) => {
+    Object.defineProperty(valueArg, 'toBSON', {
+        value: undefined,
+        enumerable: false,
+    });
+    return valueArg;
+};
+const snapshotInertExactValue = (valueArg, labelArg, seenArg = new WeakSet(), depthArg = 0) => {
+    if (typeof valueArg === 'function' || typeof valueArg === 'symbol') {
+        throw exactSnapshotError(labelArg, 'contains a value that cannot be inert BSON data.');
+    }
+    if (typeof valueArg !== 'object' || valueArg === null) {
+        return valueArg;
+    }
+    if (plugins.nodeUtil.types.isProxy(valueArg)) {
+        throw exactSnapshotError(labelArg, 'may not contain Proxy objects.');
+    }
+    if (seenArg.has(valueArg)) {
+        throw exactSnapshotError(labelArg, 'may not contain circular data.');
+    }
+    if (depthArg >= 100) {
+        throw exactSnapshotError(labelArg, 'exceeds the maximum supported nesting depth.');
+    }
+    seenArg.add(valueArg);
+    try {
+        const prototype = Object.getPrototypeOf(valueArg);
+        if (Array.isArray(valueArg)) {
+            if (prototype !== Array.prototype ||
+                valueArg.length > maxExactSnapshotArrayLength) {
+                throw exactSnapshotError(labelArg, 'must be a bounded ordinary array.');
+            }
+            if (hasActiveInheritedToBsonEncoder(prototype)) {
+                throw exactSnapshotError(labelArg, 'may not inherit a custom BSON encoder.');
+            }
+            const ownKeys = Reflect.ownKeys(valueArg);
+            const toBsonDescriptor = Object.getOwnPropertyDescriptor(valueArg, 'toBSON');
+            if (toBsonDescriptor &&
+                (!('value' in toBsonDescriptor) ||
+                    toBsonDescriptor.value !== undefined ||
+                    toBsonDescriptor.enumerable === true)) {
+                throw exactSnapshotError(labelArg, 'arrays may contain only an inert non-enumerable toBSON marker.');
+            }
+            const indexedKeys = ownKeys.filter((keyArg) => keyArg !== 'length' && keyArg !== 'toBSON');
+            if (indexedKeys.length !== valueArg.length ||
+                indexedKeys.some((keyArg) => {
+                    if (typeof keyArg !== 'string' ||
+                        !/^(0|[1-9]\d*)$/.test(keyArg)) {
+                        return true;
+                    }
+                    const index = Number(keyArg);
+                    return !Number.isSafeInteger(index) || index >= valueArg.length;
+                })) {
+                throw exactSnapshotError(labelArg, 'arrays must be dense and contain only indexed data properties.');
+            }
+            const snapshot = [];
+            for (let index = 0; index < valueArg.length; index++) {
+                const descriptor = Object.getOwnPropertyDescriptor(valueArg, String(index));
+                if (!descriptor ||
+                    !('value' in descriptor) ||
+                    descriptor.enumerable !== true) {
+                    throw exactSnapshotError(labelArg, 'arrays may contain only inert enumerable data properties.');
+                }
+                snapshot.push(snapshotInertExactValue(descriptor.value, `${labelArg}.${index}`, seenArg, depthArg + 1));
+            }
+            return snapshot;
+        }
+        if (isPlainObject(valueArg)) {
+            const snapshot = Object.create(null);
+            for (const key of Reflect.ownKeys(valueArg)) {
+                if (typeof key !== 'string' ||
+                    key === 'toBSON' ||
+                    key === '_bsontype') {
+                    throw exactSnapshotError(labelArg, 'may contain only ordinary string-keyed data.');
+                }
+                const descriptor = Object.getOwnPropertyDescriptor(valueArg, key);
+                if (!descriptor ||
+                    !('value' in descriptor) ||
+                    descriptor.enumerable !== true) {
+                    throw exactSnapshotError(labelArg, 'may contain only inert enumerable data properties.');
+                }
+                snapshot[key] = snapshotInertExactValue(descriptor.value, `${labelArg}.${key}`, seenArg, depthArg + 1);
+            }
+            return snapshot;
+        }
+        if (hasActiveInheritedToBsonEncoder(prototype)) {
+            throw exactSnapshotError(labelArg, 'may not inherit a custom BSON encoder.');
+        }
+        if (prototype === Date.prototype) {
+            if (Reflect.ownKeys(valueArg).length !== 0) {
+                throw exactSnapshotError(labelArg, 'contains a customized Date.');
+            }
+            return markInertBsonSnapshot(new Date(Reflect.apply(Date.prototype.getTime, valueArg, [])));
+        }
+        if (prototype === RegExp.prototype) {
+            const ownKeys = Reflect.ownKeys(valueArg);
+            if (ownKeys.length !== 1 ||
+                ownKeys[0] !== 'lastIndex' ||
+                !regExpSourceGetter) {
+                throw exactSnapshotError(labelArg, 'contains a customized regular expression.');
+            }
+            const source = Reflect.apply(regExpSourceGetter, valueArg, []);
+            const flags = regExpFlagGetters
+                .filter(({ getter }) => getter && Reflect.apply(getter, valueArg, []))
+                .map(({ flag }) => flag)
+                .join('');
+            return markInertBsonSnapshot(new RegExp(source, flags));
+        }
+        if (prototype === Uint8Array.prototype) {
+            return markInertBsonSnapshot(getExactSnapshotBytes(valueArg, labelArg));
+        }
+        const scalarToBsonDescriptor = Object.getOwnPropertyDescriptor(valueArg, 'toBSON');
+        if (scalarToBsonDescriptor &&
+            (!('value' in scalarToBsonDescriptor) ||
+                scalarToBsonDescriptor.value !== undefined ||
+                scalarToBsonDescriptor.enumerable === true)) {
+            throw exactSnapshotError(labelArg, 'contains a customized BSON scalar encoder.');
+        }
+        let scalarSnapshot;
+        if (prototype === plugins.mongodb.ObjectId.prototype) {
+            scalarSnapshot = constructExactBsonScalar(() => new plugins.mongodb.ObjectId(getInertObjectIdBytes(valueArg, () => exactSnapshotError(labelArg, 'contains a malformed or non-inert ObjectId.'))), labelArg);
+        }
+        else if (prototype === plugins.mongodb.UUID.prototype) {
+            scalarSnapshot = constructExactBsonScalar(() => new plugins.mongodb.UUID(getExactSnapshotBytes(getOwnDataValue(valueArg, 'buffer', labelArg), labelArg)), labelArg);
+        }
+        else if (prototype === plugins.mongodb.Binary.prototype) {
+            const buffer = getExactSnapshotBytes(getOwnDataValue(valueArg, 'buffer', labelArg), labelArg);
+            const subType = getOwnDataValue(valueArg, 'sub_type', labelArg);
+            const position = getOwnDataValue(valueArg, 'position', labelArg);
+            if (typeof subType !== 'number' ||
+                !Number.isSafeInteger(subType) ||
+                typeof position !== 'number' ||
+                !Number.isSafeInteger(position) ||
+                position < 0 ||
+                position > buffer.length) {
+                throw exactSnapshotError(labelArg, 'contains invalid binary data.');
+            }
+            scalarSnapshot = constructExactBsonScalar(() => new plugins.mongodb.Binary(buffer.subarray(0, position), subType), labelArg);
+        }
+        else if (prototype === plugins.mongodb.Decimal128.prototype) {
+            scalarSnapshot = constructExactBsonScalar(() => new plugins.mongodb.Decimal128(getExactSnapshotBytes(getOwnDataValue(valueArg, 'bytes', labelArg), labelArg)), labelArg);
+        }
+        else if (prototype === plugins.mongodb.Int32.prototype) {
+            const value = getOwnDataValue(valueArg, 'value', labelArg);
+            if (!isSignedInt32(value)) {
+                throw exactSnapshotError(labelArg, 'contains an invalid Int32.');
+            }
+            scalarSnapshot = constructExactBsonScalar(() => new plugins.mongodb.Int32(value), labelArg);
+        }
+        else if (prototype === plugins.mongodb.Double.prototype) {
+            const value = getOwnDataValue(valueArg, 'value', labelArg);
+            if (typeof value !== 'number') {
+                throw exactSnapshotError(labelArg, 'contains an invalid Double.');
+            }
+            scalarSnapshot = constructExactBsonScalar(() => new plugins.mongodb.Double(value), labelArg);
+        }
+        else if (prototype === plugins.mongodb.Long.prototype) {
+            const low = getOwnDataValue(valueArg, 'low', labelArg);
+            const high = getOwnDataValue(valueArg, 'high', labelArg);
+            const unsigned = getOwnDataValue(valueArg, 'unsigned', labelArg);
+            if (!isSignedInt32(low) ||
+                !isSignedInt32(high) ||
+                typeof unsigned !== 'boolean') {
+                throw exactSnapshotError(labelArg, 'contains an invalid 64-bit value.');
+            }
+            scalarSnapshot = constructExactBsonScalar(() => new plugins.mongodb.Long(low, high, unsigned), labelArg);
+        }
+        else if (prototype === plugins.mongodb.Timestamp.prototype) {
+            const low = getOwnDataValue(valueArg, 'low', labelArg);
+            const high = getOwnDataValue(valueArg, 'high', labelArg);
+            const unsigned = getOwnDataValue(valueArg, 'unsigned', labelArg);
+            if (!isSignedInt32(low) || !isSignedInt32(high) || unsigned !== true) {
+                throw exactSnapshotError(labelArg, 'contains an invalid Timestamp.');
+            }
+            scalarSnapshot = constructExactBsonScalar(() => new plugins.mongodb.Timestamp(new plugins.mongodb.Long(low, high, true)), labelArg);
+        }
+        else if (prototype === plugins.mongodb.BSONRegExp.prototype) {
+            const pattern = getOwnDataValue(valueArg, 'pattern', labelArg);
+            const options = getOwnDataValue(valueArg, 'options', labelArg);
+            if (typeof pattern !== 'string' || typeof options !== 'string') {
+                throw exactSnapshotError(labelArg, 'contains an invalid BSON regex.');
+            }
+            scalarSnapshot = constructExactBsonScalar(() => new plugins.mongodb.BSONRegExp(pattern, options), labelArg);
+        }
+        else if (prototype === plugins.mongodb.BSONSymbol.prototype) {
+            const value = getOwnDataValue(valueArg, 'value', labelArg);
+            if (typeof value !== 'string') {
+                throw exactSnapshotError(labelArg, 'contains an invalid BSON symbol.');
+            }
+            scalarSnapshot = constructExactBsonScalar(() => new plugins.mongodb.BSONSymbol(value), labelArg);
+        }
+        else if (prototype === plugins.mongodb.Code.prototype) {
+            const code = getOwnDataValue(valueArg, 'code', labelArg);
+            const scope = getOwnDataValue(valueArg, 'scope', labelArg);
+            if (typeof code !== 'string') {
+                throw exactSnapshotError(labelArg, 'contains invalid BSON code.');
+            }
+            scalarSnapshot = constructExactBsonScalar(() => new plugins.mongodb.Code(code, scope === null
+                ? null
+                : snapshotInertExactValue(scope, `${labelArg}.scope`, seenArg, depthArg + 1)), labelArg);
+        }
+        else if (prototype === plugins.mongodb.DBRef.prototype) {
+            const collection = getOwnDataValue(valueArg, 'collection', labelArg);
+            const oid = snapshotInertExactValue(getOwnDataValue(valueArg, 'oid', labelArg), `${labelArg}.oid`, seenArg, depthArg + 1);
+            const db = getOwnDataValue(valueArg, 'db', labelArg);
+            const fields = snapshotInertExactValue(getOwnDataValue(valueArg, 'fields', labelArg), `${labelArg}.fields`, seenArg, depthArg + 1);
+            if (typeof collection !== 'string' ||
+                !(oid instanceof plugins.mongodb.ObjectId) ||
+                (db !== undefined && typeof db !== 'string') ||
+                !isPlainObject(fields)) {
+                throw exactSnapshotError(labelArg, 'contains an invalid DBRef.');
+            }
+            scalarSnapshot = constructExactBsonScalar(() => new plugins.mongodb.DBRef(collection, oid, db, fields), labelArg);
+        }
+        else if (prototype === plugins.mongodb.MinKey.prototype) {
+            scalarSnapshot = new plugins.mongodb.MinKey();
+        }
+        else if (prototype === plugins.mongodb.MaxKey.prototype) {
+            scalarSnapshot = new plugins.mongodb.MaxKey();
+        }
+        else {
+            throw exactSnapshotError(labelArg, 'contains an object with a custom BSON encoding boundary.');
+        }
+        return markInertBsonSnapshot(scalarSnapshot);
+    }
+    finally {
+        seenArg.delete(valueArg);
+    }
+};
+const canonicalizeValue = (valueArg, seenArg = new WeakSet()) => {
+    if (typeof valueArg !== 'object' || valueArg === null) {
+        return valueArg;
+    }
+    const isArray = Array.isArray(valueArg);
+    if (!isArray && !isPlainObject(valueArg)) {
+        return valueArg;
+    }
+    if (seenArg.has(valueArg)) {
+        return valueArg;
+    }
+    seenArg.add(valueArg);
+    if (isArray) {
+        const canonicalArray = valueArg.map((entryArg) => canonicalizeValue(entryArg, seenArg));
+        seenArg.delete(valueArg);
+        return canonicalArray;
+    }
+    const canonical = Object.create(null);
+    for (const key of Object.keys(valueArg).sort()) {
+        const entry = valueArg[key];
+        if (entry !== undefined) {
+            canonical[key] = canonicalizeValue(entry, seenArg);
+        }
+    }
+    seenArg.delete(valueArg);
+    return canonical;
+};
+const isDuplicateKeyError = (errorArg) => {
+    const mongoError = errorArg;
+    return mongoError?.code === 11000 || mongoError?.codeName === 'DuplicateKey';
+};
+const isTransientTransactionError = (errorArg, sessionArg) => Boolean(sessionArg)
+    && typeof errorArg?.hasErrorLabel === 'function'
+    && errorArg
+        .hasErrorLabel('TransientTransactionError');
+const hasActiveTransaction = (sessionArg) => Boolean(sessionArg?.inTransaction());
+const unsupportedExactSave = async () => {
+    throw new SmartdataExactPersistenceError('unsupported_operation', 'save() is unavailable for exact-persistence models. Use the model exact API.');
+};
+const forbiddenExactDelete = async () => {
+    throw new SmartdataExactPersistenceError('unsupported_operation', 'delete() is forbidden for exact-persistence models.');
+};
+export class SmartdataExactCollection {
+    modelConstructor;
+    collection;
+    options;
+    initializationPromise;
+    initializedCollection;
+    initializationTarget;
+    initializationGeneration = 0;
+    allowedPersistedKeys;
+    uniqueIndexes;
+    reconcileBy;
+    constructor(modelConstructor, collection, options) {
+        this.modelConstructor = modelConstructor;
+        this.collection = collection;
+        this.options = options;
+        // Field-decorator initializers materialize the model metadata on its
+        // prototype. Exact persistence uses that metadata as the ownership boundary.
+        new this.modelConstructor();
+        const prototype = this.modelConstructor.prototype;
+        this.allowedPersistedKeys = new Set([
+            ...(prototype.globalSaveableProperties || []),
+            ...(prototype.saveableProperties || []),
+        ].filter((keyArg) => !reservedKeys.includes(keyArg)));
+        this.uniqueIndexes = [
+            ...new Set(prototype.uniqueIndexes || []),
+        ];
+        const identityValueTypes = prototype.identityValueTypes;
+        const numericIdentityField = this.uniqueIndexes.find((fieldArg) => identityValueTypes?.[fieldArg] === 'positiveSafeInteger');
+        if (numericIdentityField) {
+            throw new SmartdataExactPersistenceError('invalid_configuration', `Exact persistence identity field "${numericIdentityField}" must use the default string valueType.`);
+        }
+        const explicitReconcileBy = options.reconcileBy;
+        if (explicitReconcileBy) {
+            if (!this.allowedPersistedKeys.has(explicitReconcileBy) ||
+                !this.uniqueIndexes.includes(explicitReconcileBy)) {
+                throw new SmartdataExactPersistenceError('invalid_configuration', `Exact persistence reconcileBy field "${explicitReconcileBy}" must be a persisted field decorated with @unI().`);
+            }
+            this.reconcileBy = explicitReconcileBy;
+        }
+        else if (this.uniqueIndexes.length === 1) {
+            this.reconcileBy = this.uniqueIndexes[0];
+        }
+        else if (this.uniqueIndexes.length === 0) {
+            throw new SmartdataExactPersistenceError('invalid_configuration', 'Exact persistence requires at least one persisted field decorated with @unI().');
+        }
+        else {
+            throw new SmartdataExactPersistenceError('invalid_configuration', `Exact persistence requires reconcileBy when the model has multiple @unI() fields.`);
+        }
+        registerCollectionReconnectHandler(this.collection, () => {
+            this.initializationGeneration++;
+            this.initializationPromise = undefined;
+            this.initializedCollection = undefined;
+            this.initializationTarget = undefined;
+        });
+    }
+    async initialize() {
+        await this.collection.init();
+        if (this.initializedCollection === this.collection.mongoDbCollection) {
+            return;
+        }
+        const targetCollection = this.collection.mongoDbCollection;
+        if (this.initializationTarget !== targetCollection) {
+            this.initializationTarget = targetCollection;
+            this.initializationPromise = undefined;
+            this.initializationGeneration++;
+        }
+        if (!this.initializationPromise) {
+            const generation = this.initializationGeneration;
+            const initializationPromise = this.initializeOnce(targetCollection)
+                .then(() => {
+                if (this.initializationGeneration === generation
+                    && this.collection.mongoDbCollection === targetCollection) {
+                    this.initializedCollection = targetCollection;
+                }
+            })
+                .catch((errorArg) => {
+                if (this.initializationPromise === initializationPromise) {
+                    this.initializationPromise = undefined;
+                }
+                throw errorArg;
+            });
+            this.initializationPromise = initializationPromise;
+        }
+        await this.initializationPromise;
+        if (this.initializedCollection !== this.collection.mongoDbCollection) {
+            await this.initialize();
+        }
+    }
+    async initializeOnce(targetCollectionArg) {
+        const missingUniqueIndexes = this.uniqueIndexes.filter((uniqueIndexArg) => !this.collection.uniqueIndexes.includes(uniqueIndexArg));
+        for (const uniqueIndex of missingUniqueIndexes) {
+            await targetCollectionArg.createIndex({ [uniqueIndex]: 1 }, { unique: true, name: `${uniqueIndex}_1` });
+        }
+        const regularIndexes = this.modelConstructor.prototype.regularIndexes || [];
+        const missingRegularIndexes = regularIndexes.filter((regularIndexArg) => !this.collection.regularIndexes.some((existingIndexArg) => existingIndexArg.field === regularIndexArg.field));
+        for (const regularIndex of missingRegularIndexes) {
+            await targetCollectionArg.createIndex({ [regularIndex.field]: 1 }, regularIndex.options);
+        }
+        if (this.collection.mongoDbCollection !== targetCollectionArg) {
+            return;
+        }
+        for (const uniqueIndex of missingUniqueIndexes) {
+            if (!this.collection.uniqueIndexes.includes(uniqueIndex)) {
+                this.collection.uniqueIndexes.push(uniqueIndex);
+            }
+        }
+        for (const regularIndex of missingRegularIndexes) {
+            if (!this.collection.regularIndexes.some((existingIndexArg) => existingIndexArg.field === regularIndex.field)) {
+                this.collection.regularIndexes.push(regularIndex);
+            }
+        }
+    }
+    async prepare() {
+        await this.initialize();
+    }
+    async beginOperation(optionsArg, signalArg) {
+        signalArg?.throwIfAborted();
+        if (!optionsArg.session) {
+            await waitWithSignal(this.initialize(), signalArg);
+            signalArg?.throwIfAborted();
+            return { 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.');
+        }
+        const lease = acquireSmartdataSession(optionsArg.session, this.collection.smartdataDb);
+        if (signalArg?.aborted) {
+            lease.release();
+            signalArg.throwIfAborted();
+        }
+        return {
+            session: lease.rawSession,
+            release: lease.release,
+        };
+    }
+    async runOperation(optionsArg, operationArg, signalArg) {
+        const operation = await this.beginOperation(optionsArg, signalArg);
+        try {
+            signalArg?.throwIfAborted();
+            return await operationArg(operation.session);
+        }
+        finally {
+            operation.release();
+        }
+    }
+    canonicalizeDocument(documentArg, labelArg) {
+        let canonicalInput;
+        let serialized;
+        let canonical;
+        let reserialized;
+        try {
+            canonicalInput = canonicalizeValue(documentArg);
+            serialized = plugins.mongodb.BSON.serialize(canonicalInput);
+            canonical = canonicalizeValue(plugins.mongodb.BSON.deserialize(serialized));
+            reserialized = plugins.mongodb.BSON.serialize(canonical);
+        }
+        catch (errorArg) {
+            throw new SmartdataExactPersistenceError('invalid_document', `${labelArg} is not BSON serializable.`, { cause: errorArg });
+        }
+        if (!bytesEqual(serialized, reserialized)) {
+            throw new SmartdataExactPersistenceError('noncanonical_document', `${labelArg} is not byte-stable across a BSON roundtrip.`);
+        }
+        return canonical;
+    }
+    assertAllowedTopLevelKeys(documentArg, allowedMetadataKeysArg, labelArg) {
+        const allowedMetadataKeys = new Set(allowedMetadataKeysArg);
+        for (const key of Object.keys(documentArg)) {
+            if (reservedKeys.includes(key) &&
+                !allowedMetadataKeys.has(key)) {
+                throw new SmartdataExactPersistenceError('reserved_field', `${labelArg} may not define reserved field "${key}".`);
+            }
+            if (!this.allowedPersistedKeys.has(key) &&
+                !allowedMetadataKeys.has(key)) {
+                throw new SmartdataExactPersistenceError('invalid_document', `${labelArg} defines undeclared top-level field "${key}".`);
+            }
+        }
+    }
+    canonicalizePersistedDocument(documentArg) {
+        this.assertAllowedTopLevelKeys(documentArg, [], 'Persisted document');
+        const canonical = this.canonicalizeDocument(documentArg, 'Persisted document');
+        this.assertWithoutMutation(canonical, 'Persisted document');
+        return canonical;
+    }
+    canonicalizeStoredDocument(documentArg) {
+        this.assertAllowedTopLevelKeys(documentArg, storageMetadataKeys, 'Stored document');
+        const canonical = this.canonicalizeDocument(documentArg, 'Stored document');
+        const revision = canonical._smartdataRevision;
+        if (!isMongoObjectId(canonical._id)) {
+            throw new SmartdataExactPersistenceError('invalid_document', 'Stored document _id must be a MongoDB ObjectId.');
+        }
+        if (revision !== undefined &&
+            (typeof revision !== 'string' || revision.length === 0)) {
+            throw new SmartdataExactPersistenceError('invalid_document', 'Stored document _smartdataRevision must be a nonempty string when present.');
+        }
+        this.getPersistedBody(canonical);
+        return canonical;
+    }
+    assertWithoutMutation(documentArg, labelArg) {
+        assertBsonWithoutMutation(documentArg, this.options.assertDocument, (reasonArg, causeArg) => new SmartdataExactPersistenceError('invalid_document', `${labelArg} ${reasonArg === 'assertion' ? 'assertion failed.' :
+            reasonArg === 'bson' ? 'validator produced a non-BSON document.' :
+                'validator must not mutate the document.'}`, causeArg === undefined ? undefined : { cause: causeArg }));
+    }
+    getPersistedBody(storedDocumentArg) {
+        const body = Object.create(null);
+        for (const key of Object.keys(storedDocumentArg)) {
+            if (!reservedKeys.includes(key)) {
+                body[key] = storedDocumentArg[key];
+            }
+        }
+        return this.canonicalizePersistedDocument(body);
+    }
+    persistedDocumentsEqual(leftArg, rightArg) {
+        return bytesEqual(plugins.mongodb.BSON.serialize(leftArg), plugins.mongodb.BSON.serialize(rightArg));
+    }
+    storedDocumentsEqual(leftArg, rightArg) {
+        if (!leftArg._id.equals(rightArg._id)) {
+            return false;
+        }
+        if (leftArg._smartdataRevision !== rightArg._smartdataRevision) {
+            return false;
+        }
+        return this.persistedDocumentsEqual(this.getPersistedBody(leftArg), this.getPersistedBody(rightArg));
+    }
+    validateReconcileIdentity(documentArg) {
+        const value = documentArg[this.reconcileBy];
+        if (typeof value !== 'string' || value.trim().length === 0) {
+            throw new SmartdataExactPersistenceError('invalid_document', `Exact persistence reconcileBy field "${this.reconcileBy}" must be a nonempty string.`);
+        }
+        return value;
+    }
+    async serializeModel(modelArg) {
+        const serialized = (await modelArg.createSavableObject());
+        if (typeof serialized !== 'object' ||
+            serialized === null ||
+            Array.isArray(serialized)) {
+            throw new SmartdataExactPersistenceError('invalid_document', 'createSavableObject() must return a document object.');
+        }
+        for (const key of Object.keys(serialized)) {
+            if (!this.allowedPersistedKeys.has(key) &&
+                key !== '_createdAt' &&
+                key !== '_updatedAt') {
+                const code = reservedKeys.includes(key)
+                    ? 'reserved_field'
+                    : 'invalid_document';
+                throw new SmartdataExactPersistenceError(code, `Model serialization produced forbidden top-level field "${key}".`);
+            }
+        }
+        const body = Object.create(null);
+        for (const key of this.allowedPersistedKeys) {
+            if (hasOwn(serialized, key)) {
+                body[key] = serialized[key];
+            }
+        }
+        return this.canonicalizePersistedDocument(body);
+    }
+    async createPersistedDocument(documentArg) {
+        if (typeof documentArg !== 'object' || documentArg === null) {
+            throw new SmartdataExactPersistenceError('invalid_document', 'Exact persistence insert input must be an object.');
+        }
+        if (documentArg instanceof this.modelConstructor) {
+            return this.serializeModel(documentArg);
+        }
+        return this.canonicalizePersistedDocument(documentArg);
+    }
+    hydrateStoredDocument(documentArg) {
+        return this.modelConstructor.createInstanceFromMongoDbNativeDoc(documentArg);
+    }
+    async findByReconcileIdentity(identityArg, sessionArg) {
+        const rawDocument = await this.collection.mongoDbCollection.findOne({
+            [this.reconcileBy]: identityArg,
+        }, { session: sessionArg });
+        return rawDocument
+            ? this.canonicalizeStoredDocument(rawDocument)
+            : null;
+    }
+    ambiguousWriteError(messageArg, causeArg) {
+        return new SmartdataExactPersistenceError('ambiguous_write', messageArg, {
+            cause: causeArg,
+        });
+    }
+    canonicalizeDeleteCurrent(optionsArg) {
+        if (typeof optionsArg !== 'object' ||
+            optionsArg === null ||
+            plugins.nodeUtil.types.isProxy(optionsArg) ||
+            !isPlainObject(optionsArg)) {
+            throw new SmartdataExactPersistenceError('invalid_document', 'Exact delete options must be an object containing only current.');
+        }
+        const optionKeys = Reflect.ownKeys(optionsArg);
+        const currentDescriptor = Object.getOwnPropertyDescriptor(optionsArg, 'current');
+        if (optionKeys.length !== 1 ||
+            optionKeys[0] !== 'current' ||
+            !currentDescriptor ||
+            !('value' in currentDescriptor) ||
+            currentDescriptor.enumerable !== true) {
+            throw new SmartdataExactPersistenceError('invalid_document', 'Exact delete options must contain one inert enumerable current data property.');
+        }
+        const currentSnapshot = snapshotInertExactValue(currentDescriptor.value, 'Exact delete current');
+        const current = this.canonicalizeStoredDocument(currentSnapshot);
+        const identity = this.validateReconcileIdentity(this.getPersistedBody(current));
+        return { current, identity };
+    }
+    async reconcileDeleteOutcome(currentArg, identityArg, causeArg, sessionArg) {
+        let reconciled;
+        try {
+            reconciled = await this.findByReconcileIdentity(identityArg, sessionArg);
+        }
+        catch (errorArg) {
+            if (isTransientTransactionError(errorArg, sessionArg)) {
+                throw errorArg;
+            }
+            throw this.ambiguousWriteError('Exact delete outcome was inconclusive and reconciliation could not be completed.', causeArg);
+        }
+        if (reconciled && reconciled._id.equals(currentArg._id)) {
+            return { status: 'concurrent_change', deletedCount: 0 };
+        }
+        throw this.ambiguousWriteError('Exact delete outcome was inconclusive and could not be authoritatively reconciled.', causeArg);
+    }
+    async insert(documentArg, optionsArg = {}) {
+        return this.runOperation(optionsArg, async (sessionArg) => {
+            const persistedDocument = await this.createPersistedDocument(documentArg);
+            const identity = this.validateReconcileIdentity(persistedDocument);
+            const expectedStoredDocument = this.canonicalizeStoredDocument({
+                _id: new plugins.mongodb.ObjectId(),
+                ...persistedDocument,
+            });
+            if (hasActiveTransaction(sessionArg)) {
+                const existing = await this.findByReconcileIdentity(identity, sessionArg);
+                if (existing) {
+                    return this.persistedDocumentsEqual(this.getPersistedBody(existing), persistedDocument)
+                        ? { status: 'already_committed', document: existing }
+                        : { status: 'conflict', document: existing };
+                }
+            }
+            let result;
+            try {
+                result = await this.collection.mongoDbCollection.insertOne(expectedStoredDocument, { session: sessionArg });
+            }
+            catch (errorArg) {
+                if (isTransientTransactionError(errorArg, sessionArg)) {
+                    throw errorArg;
+                }
+                if (hasActiveTransaction(sessionArg)) {
+                    if (isDuplicateKeyError(errorArg)) {
+                        throw new SmartdataExactPersistenceError('unique_conflict', 'Exact transactional insert conflicts with a unique index.', { cause: errorArg });
+                    }
+                    throw errorArg;
+                }
+                let reconciled;
+                try {
+                    reconciled = await this.findByReconcileIdentity(identity, sessionArg);
+                }
+                catch (reconciliationError) {
+                    if (isTransientTransactionError(reconciliationError, sessionArg)) {
+                        throw reconciliationError;
+                    }
+                    if (isDuplicateKeyError(errorArg)) {
+                        throw new SmartdataExactPersistenceError('unique_conflict', 'Exact insert conflicts with a unique index and reconciliation failed.', { cause: errorArg });
+                    }
+                    throw this.ambiguousWriteError('Exact insert failed and reconciliation could not be completed.', errorArg);
+                }
+                if (reconciled) {
+                    if (this.persistedDocumentsEqual(this.getPersistedBody(reconciled), persistedDocument)) {
+                        return { status: 'already_committed', document: reconciled };
+                    }
+                    if (isDuplicateKeyError(errorArg)) {
+                        return { status: 'conflict', document: reconciled };
+                    }
+                }
+                if (isDuplicateKeyError(errorArg)) {
+                    throw new SmartdataExactPersistenceError('unique_conflict', 'Exact insert conflicts with a secondary unique index.', { cause: errorArg });
+                }
+                throw this.ambiguousWriteError('Exact insert failed and its outcome could not be reconciled.', errorArg);
+            }
+            if (!result.acknowledged) {
+                if (hasActiveTransaction(sessionArg)) {
+                    throw this.ambiguousWriteError('Exact transactional insert was not acknowledged.', result);
+                }
+                let reconciled;
+                try {
+                    reconciled = await this.findByReconcileIdentity(identity, sessionArg);
+                }
+                catch (errorArg) {
+                    if (isTransientTransactionError(errorArg, sessionArg)) {
+                        throw errorArg;
+                    }
+                    throw this.ambiguousWriteError('Exact insert was not acknowledged and reconciliation could not be completed.', result);
+                }
+                if (reconciled &&
+                    this.persistedDocumentsEqual(this.getPersistedBody(reconciled), persistedDocument)) {
+                    return { status: 'already_committed', document: reconciled };
+                }
+                throw this.ambiguousWriteError('Exact insert was not acknowledged and could not be reconciled.', result);
+            }
+            return { status: 'inserted', document: expectedStoredDocument };
+        });
+    }
+    toPersisted(storedDocumentArg) {
+        const storedDocument = this.canonicalizeStoredDocument(storedDocumentArg);
+        const persistedDocument = this.getPersistedBody(storedDocument);
+        return plugins.mongodb.BSON.deserialize(plugins.mongodb.BSON.serialize(persistedDocument));
+    }
+    canonicalBytes(persistedDocumentArg) {
+        return plugins.mongodb.BSON.serialize(this.canonicalizePersistedDocument(persistedDocumentArg));
+    }
+    async findStoredOne(filterArg, optionsArg = {}) {
+        return this.runOperation(optionsArg, async (sessionArg) => {
+            const cursor = this.collection.mongoDbCollection.find(convertFilterForMongoDb(filterArg), {
+                session: sessionArg,
+                signal: optionsArg.signal,
+                singleBatch: true,
+            }).limit(1);
+            const nativeCursorClose = cursor.close.bind(cursor);
+            let cursorClosePromise;
+            cursor.close = ((...args) => {
+                cursorClosePromise ??= nativeCursorClose(...args);
+                return cursorClosePromise;
+            });
+            let storedDocument;
+            try {
+                const rawDocument = await cursor.next();
+                storedDocument = rawDocument
+                    ? this.canonicalizeStoredDocument(rawDocument)
+                    : null;
+            }
+            catch (errorArg) {
+                try {
+                    await cursor.close();
+                }
+                catch {
+                    // Cleanup must not replace the exact primary operation error.
+                }
+                throw errorArg;
+            }
+            await cursor.close();
+            return storedDocument;
+        }, optionsArg.signal);
+    }
+    async findStored(optionsArg = {}) {
+        optionsArg.signal?.throwIfAborted();
+        return this.runOperation(optionsArg, async (sessionArg) => {
+            let cursor = this.collection.mongoDbCollection.find(convertFilterForMongoDb(optionsArg.filter || {}), { session: sessionArg, signal: optionsArg.signal });
+            // The driver abort listener does not await close, so every close must join
+            // the same native cleanup before runOperation releases its session lease.
+            const nativeCursorClose = cursor.close.bind(cursor);
+            let cursorClosePromise;
+            cursor.close = ((...args) => {
+                cursorClosePromise ??= nativeCursorClose(...args);
+                return cursorClosePromise;
+            });
+            let storedDocuments;
+            try {
+                if (optionsArg.sort) {
+                    cursor = cursor.sort(optionsArg.sort);
+                }
+                if (optionsArg.skip !== undefined) {
+                    cursor = cursor.skip(optionsArg.skip);
+                }
+                if (optionsArg.limit !== undefined) {
+                    cursor = cursor.limit(optionsArg.limit);
+                }
+                const rawDocuments = await cursor.toArray();
+                storedDocuments = rawDocuments.map((documentArg) => this.canonicalizeStoredDocument(documentArg));
+            }
+            catch (errorArg) {
+                try {
+                    await cursor.close();
+                }
+                catch {
+                    // Cleanup must not replace the exact primary operation error.
+                }
+                throw errorArg;
+            }
+            await cursor.close();
+            return storedDocuments;
+        }, optionsArg.signal);
+    }
+    async count(filterArg = {}, optionsArg = {}) {
+        return this.runOperation(optionsArg, async (sessionArg) => this.collection.mongoDbCollection.countDocuments(convertFilterForMongoDb(filterArg), { session: sessionArg }));
+    }
+    async distinct(fieldArg, filterArg = {}, optionsArg = {}) {
+        return this.runOperation(optionsArg, async (sessionArg) => (await this.collection.mongoDbCollection.distinct(fieldArg, convertFilterForMongoDb(filterArg), { session: sessionArg })));
+    }
+    async transition(optionsArg, sessionOptionsArg = {}) {
+        return this.runOperation(sessionOptionsArg, async (sessionArg) => {
+            const current = this.canonicalizeStoredDocument(optionsArg.current);
+            const currentBody = this.getPersistedBody(current);
+            const currentIdentity = this.validateReconcileIdentity(currentBody);
+            const model = this.hydrateStoredDocument(current);
+            const untouchedBody = await this.serializeModel(model);
+            if (!this.persistedDocumentsEqual(currentBody, untouchedBody)) {
+                throw new SmartdataExactPersistenceError('noncanonical_document', 'Stored document does not survive an untouched model serialization roundtrip.');
+            }
+            const changeResult = optionsArg.change(model);
+            if (changeResult !== null &&
+                (typeof changeResult === 'object' || typeof changeResult === 'function') &&
+                typeof changeResult.then === 'function') {
+                void Promise.resolve(changeResult).catch(() => undefined);
+                throw new SmartdataExactPersistenceError('unsupported_operation', 'Exact persistence transition callbacks must be synchronous.');
+            }
+            const candidateBody = await this.serializeModel(model);
+            const candidateIdentity = this.validateReconcileIdentity(candidateBody);
+            if (candidateIdentity !== currentIdentity) {
+                throw new SmartdataExactPersistenceError('invalid_document', `Exact persistence reconcileBy field "${this.reconcileBy}" is immutable.`);
+            }
+            const newRevision = globalThis.crypto.randomUUID();
+            const expectedStoredDocument = this.canonicalizeStoredDocument({
+                _id: current._id,
+                ...candidateBody,
+                _smartdataRevision: newRevision,
+            });
+            const selector = current._smartdataRevision !== undefined
+                ? { _id: current._id, _smartdataRevision: current._smartdataRevision }
+                : { _id: current._id, _smartdataRevision: { $exists: false } };
+            try {
+                const postimage = await this.collection.mongoDbCollection.findOneAndReplace(selector, expectedStoredDocument, {
+                    returnDocument: 'after',
+                    includeResultMetadata: false,
+                    upsert: false,
+                    session: sessionArg,
+                });
+                if (!postimage) {
+                    return { status: 'concurrent_change' };
+                }
+                const canonicalPostimage = this.canonicalizeStoredDocument(postimage);
+                if (!this.storedDocumentsEqual(canonicalPostimage, expectedStoredDocument)) {
+                    throw new SmartdataExactPersistenceError('ambiguous_write', 'Exact transition returned a postimage different from the requested state.');
+                }
+                return { status: 'transitioned', document: canonicalPostimage };
+            }
+            catch (errorArg) {
+                if (isTransientTransactionError(errorArg, sessionArg)) {
+                    throw errorArg;
+                }
+                if (isDuplicateKeyError(errorArg)) {
+                    throw new SmartdataExactPersistenceError('unique_conflict', 'Exact transition conflicts with a secondary unique index.', { cause: errorArg });
+                }
+                if (hasActiveTransaction(sessionArg)) {
+                    throw errorArg;
+                }
+                try {
+                    const reconciledRaw = await this.collection.mongoDbCollection.findOne({
+                        _id: current._id,
+                    }, { session: sessionArg });
+                    if (reconciledRaw) {
+                        const reconciled = this.canonicalizeStoredDocument(reconciledRaw);
+                        if (reconciled._smartdataRevision === newRevision &&
+                            this.storedDocumentsEqual(reconciled, expectedStoredDocument)) {
+                            return { status: 'transitioned', document: reconciled };
+                        }
+                    }
+                }
+                catch (reconciliationError) {
+                    if (isTransientTransactionError(reconciliationError, sessionArg)) {
+                        throw reconciliationError;
+                    }
+                    throw this.ambiguousWriteError('Exact transition failed and reconciliation could not be completed.', errorArg);
+                }
+                throw this.ambiguousWriteError('Exact transition failed and its outcome could not be reconciled.', errorArg);
+            }
+        });
+    }
+    async delete(optionsArg, sessionOptionsArg = {}) {
+        const { current, identity } = this.canonicalizeDeleteCurrent(optionsArg);
+        return this.runOperation(sessionOptionsArg, async (sessionArg) => {
+            const selector = current._smartdataRevision !== undefined
+                ? {
+                    _id: current._id,
+                    [this.reconcileBy]: identity,
+                    _smartdataRevision: current._smartdataRevision,
+                }
+                : {
+                    _id: current._id,
+                    [this.reconcileBy]: identity,
+                    _smartdataRevision: { $exists: false },
+                };
+            let result;
+            try {
+                result = await this.collection.mongoDbCollection.deleteOne(selector, {
+                    session: sessionArg,
+                });
+            }
+            catch (errorArg) {
+                if (isTransientTransactionError(errorArg, sessionArg)) {
+                    throw errorArg;
+                }
+                if (hasActiveTransaction(sessionArg)) {
+                    throw errorArg;
+                }
+                return this.reconcileDeleteOutcome(current, identity, errorArg, sessionArg);
+            }
+            if (result.acknowledged === true &&
+                result.deletedCount === 1) {
+                return { status: 'deleted', deletedCount: 1 };
+            }
+            if (result.acknowledged === true &&
+                result.deletedCount === 0) {
+                return { status: 'concurrent_change', deletedCount: 0 };
+            }
+            if (result.acknowledged === false) {
+                if (hasActiveTransaction(sessionArg)) {
+                    throw this.ambiguousWriteError('Exact transactional delete was not acknowledged.', result);
+                }
+                return this.reconcileDeleteOutcome(current, identity, result, sessionArg);
+            }
+            try {
+                await this.findByReconcileIdentity(identity, sessionArg);
+            }
+            catch (errorArg) {
+                if (isTransientTransactionError(errorArg, sessionArg)) {
+                    throw errorArg;
+                }
+                throw this.ambiguousWriteError('Exact delete returned an invalid result and reconciliation could not be completed.', result);
+            }
+            throw this.ambiguousWriteError('Exact delete returned an invalid acknowledged result.', result);
+        });
+    }
+}
+export function exactPersistence(optionsArg) {
+    return function classDecorator(valueArg, contextArg) {
+        if (contextArg.kind !== 'class') {
+            throw new Error('exactPersistence can only decorate classes.');
+        }
+        if (getOrdinaryPersistencePolicy(valueArg)) {
+            throw new Error('Ordinary and exact persistence policies cannot be combined.');
+        }
+        const exactOptions = Object.freeze({ ...optionsArg });
+        const constructor = valueArg;
+        const exactPolicy = Object.freeze({
+            options: exactOptions,
+            unsupportedSave: unsupportedExactSave,
+            forbiddenDelete: forbiddenExactDelete,
+        });
+        Object.defineProperty(constructor, exactPersistencePolicySymbol, {
+            value: exactPolicy,
+            enumerable: false,
+            configurable: false,
+            writable: false,
+        });
+        Object.defineProperty(constructor.prototype, 'save', {
+            value: unsupportedExactSave,
+            enumerable: false,
+            configurable: false,
+            writable: false,
+        });
+        Object.defineProperty(constructor.prototype, 'delete', {
+            value: forbiddenExactDelete,
+            enumerable: false,
+            configurable: false,
+            writable: false,
+        });
+        Object.defineProperty(constructor, 'exact', {
+            get() {
+                const receiver = this;
+                if (typeof receiver !== 'function' || (receiver !== constructor
+                    && !Object.prototype.isPrototypeOf.call(constructor, receiver))
+                    || Reflect.get(receiver, exactPersistencePolicySymbol) !== exactPolicy) {
+                    throw new SmartdataExactPersistenceError('invalid_configuration', 'Exact persistence requires the decorated model or an inheriting receiver.');
+                }
+                const collection = receiver.collection;
+                let byCollection = exactCollectionCache.get(receiver);
+                if (!byCollection) {
+                    byCollection = new WeakMap();
+                    exactCollectionCache.set(receiver, byCollection);
+                }
+                let exactCollection = byCollection.get(collection);
+                if (!exactCollection) {
+                    exactCollection = new SmartdataExactCollection(receiver, collection, exactOptions);
+                    byCollection.set(collection, exactCollection);
+                }
+                return exactCollection;
+            },
+            enumerable: false,
+            configurable: false,
+        });
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.exactpersistence.js","sourceRoot":"","sources":["../../ts/nosqldb/classes.exactpersistence.ts"],"names":[],"mappings":"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"}