@bsv/overlay 2.3.0 → 2.6.1

package/dist/cjs/src/storage/mongo/MongoPayloadStore.js

@@ -0,0 +1,756 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoPayloadStore = void 0;
+const node_crypto_1 = require("node:crypto");
+const node_events_1 = require("node:events");
+const promises_1 = require("node:timers/promises");
+const mongodb_1 = require("mongodb");
+const MongoSchema_js_1 = require("./MongoSchema.js");
+const MAX_UINT64 = (BigInt(1) << BigInt(64)) - BigInt(1);
+const HEX_256 = /^[0-9a-f]{64}$/;
+function duplicateKey(error) {
+    return typeof error === 'object' && error !== null && 'code' in error && error.code === 11000;
+}
+/**
+ * Content-addressed blob primitives for the Mongo adapter. The store deliberately
+ * has no Engine/Storage methods: S03 combines its reference operations with the
+ * owner record in an admission transaction.
+ */
+class MongoPayloadStore {
+    constructor(db, scope, options = {}) {
+        var _a, _b, _c, _d, _e;
+        this.db = db;
+        this.options = options;
+        this.writeConcern = { w: 'majority', j: true };
+        this.scope = { network: scope.network, genesisHash: scope.genesisHash, nodeId: scope.nodeId };
+        this.inlineCeiling = (_a = options.inlineCeilingBytes) !== null && _a !== void 0 ? _a : 256 * 1024;
+        this.gridFsChunkBytes = (_b = options.gridFsChunkBytes) !== null && _b !== void 0 ? _b : 255 * 1024;
+        this.uploadLeaseMs = (_c = options.uploadLeaseMs) !== null && _c !== void 0 ? _c : 60000;
+        this.maxPayloadBytes = (_d = options.maxPayloadBytes) !== null && _d !== void 0 ? _d : BigInt(64 * 1024 * 1024);
+        this.now = (_e = options.now) !== null && _e !== void 0 ? _e : (() => new Date());
+        if (!Number.isSafeInteger(this.inlineCeiling) ||
+            this.inlineCeiling < 1 ||
+            this.inlineCeiling > 1024 * 1024)
+            throw new Error('Invalid Mongo payload inline ceiling');
+        if (!Number.isSafeInteger(this.gridFsChunkBytes) ||
+            this.gridFsChunkBytes < 1 ||
+            this.gridFsChunkBytes > 255 * 1024)
+            throw new Error('Invalid Mongo GridFS chunk size');
+        if (!Number.isSafeInteger(this.uploadLeaseMs) || this.uploadLeaseMs < 1)
+            throw new Error('Invalid Mongo upload lease');
+        if (this.maxPayloadBytes < BigInt(1) || this.maxPayloadBytes > MAX_UINT64)
+            throw new Error('Invalid Mongo payload byte bound');
+        this.bucket = new mongodb_1.GridFSBucket(db, {
+            bucketName: MongoSchema_js_1.MongoGridFsBucketName,
+            chunkSizeBytes: this.gridFsChunkBytes,
+            writeConcern: this.writeConcern
+        });
+    }
+    async read(payload, range) {
+        const payloadId = this.payloadId(this.scope, payload);
+        const record = await this.db
+            .collection(MongoSchema_js_1.MongoCollectionNames.payloads)
+            .findOne({
+            _id: payloadId,
+            state: 'ready'
+        });
+        if (record === null)
+            throw new Error('Mongo payload is not ready');
+        const total = BigInt((0, MongoSchema_js_1.decodeMongoUint64)(record.byteLength));
+        const offset = range === undefined ? BigInt(0) : BigInt(range.offset);
+        const length = range === undefined ? total : BigInt(range.byteLength);
+        if (offset < BigInt(0) || length < BigInt(0) || offset + length > total)
+            throw new Error('Mongo payload range is invalid');
+        if (offset + length > BigInt(Number.MAX_SAFE_INTEGER))
+            throw new Error('Mongo payload range exceeds safe integer');
+        const bytes = await this.readBytes(record);
+        return bytes.subarray(Number(offset), Number(offset + length));
+    }
+    async publish(input) {
+        input = { ...input };
+        this.validateInput(input);
+        const payloadId = (0, MongoSchema_js_1.mongoRecordKey)((0, MongoSchema_js_1.mongoChainKey)(this.scope), input.kind, input.digest);
+        const payloads = this.db.collection(MongoSchema_js_1.MongoCollectionNames.payloads);
+        const reserved = await this.reserveUpload(payloads, payloadId, input);
+        if (reserved.ready)
+            return this.refFor(input, reserved.record);
+        return await this.completeUpload(payloads, input, payloadId, reserved.record);
+    }
+    /** Must be called in the same transaction that creates the referenced owner record. */
+    async addReference(session, reference, operation = {}) {
+        this.assertOperation(operation);
+        this.assertTransaction(session);
+        this.validateReference(reference);
+        const payloadId = this.payloadId(reference.scope, reference.payload);
+        const refs = this.db.collection(MongoSchema_js_1.MongoCollectionNames.payloadReferences);
+        const payloads = this.db.collection(MongoSchema_js_1.MongoCollectionNames.payloads);
+        const refId = (0, MongoSchema_js_1.mongoRecordKey)((0, MongoSchema_js_1.mongoNodeKey)(reference.scope), reference.ownerKind, reference.ownerId, reference.slot);
+        const existing = await refs.findOne({ _id: refId }, { session, timeoutMS: operation.timeoutMS });
+        if (existing !== null) {
+            if (existing.payloadId !== payloadId)
+                throw new Error('Mongo payload reference slot already names different content');
+            // An idempotent reference still needs a live ready payload. The row may
+            // have been reclaimed since the reference was written. This CAS also
+            // serializes the pin refresh below against a concurrent GC claim.
+            const guarded = await payloads.updateOne({ _id: payloadId, state: 'ready' }, { $set: { updatedAt: this.now() } }, { session, timeoutMS: operation.timeoutMS });
+            if (guarded.matchedCount !== 1)
+                throw new Error('Mongo payload is not ready for reference');
+            if (reference.ownerKind === 'pin')
+                await this.refreshPinExpiry(refs, refId, reference, existing, session, operation);
+            return;
+        }
+        // This conditional write is the guard; a snapshot read followed by an insert is unsafe.
+        const guarded = await payloads.updateOne({ _id: payloadId, state: 'ready' }, { $set: { updatedAt: this.now() } }, { session, timeoutMS: operation.timeoutMS });
+        if (guarded.matchedCount !== 1)
+            throw new Error('Mongo payload is not ready for reference');
+        await refs.insertOne({
+            _id: refId,
+            schemaVersion: 1,
+            network: reference.scope.network,
+            genesisHash: reference.scope.genesisHash,
+            nodeId: reference.scope.nodeId,
+            payloadId,
+            ownerKind: reference.ownerKind,
+            ownerId: reference.ownerId,
+            slot: reference.slot,
+            createdAt: this.now(),
+            updatedAt: this.now(),
+            ...(reference.expiresAt === undefined ? {} : { expiresAt: reference.expiresAt })
+        }, { session, timeoutMS: operation.timeoutMS });
+    }
+    /**
+     * Refreshes an existing pin's expiry when the same slot is re-added: an
+     * expired pin is reactivated with the caller's new expiry, and a still-live
+     * pin may only be extended, never silently shortened. Called only after the
+     * caller's {_id: payloadId, state: 'ready'} CAS has already matched in this
+     * transaction, so this stays serialized against a concurrent GC claim.
+     */
+    async refreshPinExpiry(refs, refId, reference, existing, session, operation) {
+        const now = this.now();
+        // validateReference requires expiresAt for every pin reference.
+        const requested = reference.expiresAt;
+        const current = existing.expiresAt;
+        const currentExpired = current === undefined || current <= now;
+        if (!currentExpired && requested < current)
+            throw new Error('Mongo payload pin re-add must not shorten an unexpired expiry');
+        if (currentExpired || requested.getTime() !== current.getTime()) {
+            await refs.updateOne({ _id: refId }, { $set: { expiresAt: requested, updatedAt: now } }, { session, timeoutMS: operation.timeoutMS });
+        }
+    }
+    /** Must be called in the transaction that releases the owner record's payload obligation. */
+    async releaseReference(session, reference, operation = {}) {
+        this.assertOperation(operation);
+        this.assertTransaction(session);
+        this.validateReference(reference);
+        const refId = (0, MongoSchema_js_1.mongoRecordKey)((0, MongoSchema_js_1.mongoNodeKey)(reference.scope), reference.ownerKind, reference.ownerId, reference.slot);
+        const payloadId = this.payloadId(reference.scope, reference.payload);
+        const deleted = await this.db
+            .collection(MongoSchema_js_1.MongoCollectionNames.payloadReferences)
+            .deleteOne({ _id: refId, payloadId }, { session, timeoutMS: operation.timeoutMS });
+        if (deleted.deletedCount !== 1)
+            throw new Error('Mongo payload reference does not exist');
+    }
+    /**
+     * Creates one bounded manifest component and its durable pin in one caller
+     * transaction. S03 can combine this with its manifest owner record; this
+     * method does not parse or reconstruct BEEF.
+     */
+    async addManifestComponent(session, component) {
+        this.assertTransaction(session);
+        if (!this.isUint64(component.ordinal) || component.manifestId.length === 0)
+            throw new Error('Invalid Mongo manifest component');
+        if (component.kind !== component.payload.kind)
+            throw new Error('Mongo manifest component kind mismatch');
+        const scope = this.scope;
+        const ownerId = component.manifestId;
+        const slot = component.ordinal;
+        await this.addReference(session, {
+            scope,
+            payload: component.payload,
+            ownerKind: 'manifest',
+            ownerId,
+            slot
+        });
+        const payloadId = this.payloadId(scope, component.payload);
+        const id = (0, MongoSchema_js_1.mongoRecordKey)((0, MongoSchema_js_1.mongoNodeKey)(scope), component.manifestId, component.ordinal);
+        const existing = await this.db
+            .collection(MongoSchema_js_1.MongoCollectionNames.manifestComponents)
+            .findOne({ _id: id }, { session });
+        if (existing !== null) {
+            if (existing.payloadId !== payloadId || existing.kind !== component.kind)
+                throw new Error('Mongo manifest ordinal already names different content');
+            return;
+        }
+        const now = this.now();
+        await this.db
+            .collection(MongoSchema_js_1.MongoCollectionNames.manifestComponents)
+            .insertOne({
+            _id: id,
+            schemaVersion: 1,
+            network: scope.network,
+            genesisHash: scope.genesisHash,
+            nodeId: scope.nodeId,
+            manifestId: component.manifestId,
+            ordinal: (0, MongoSchema_js_1.encodeMongoUint64)(component.ordinal),
+            payloadId,
+            kind: component.kind,
+            createdAt: now,
+            updatedAt: now
+        }, { session });
+    }
+    /** Claims logical deletion inside a caller transaction; physical deletion resumes outside it. */
+    async claimGarbage(session, payload, operation = {}) {
+        var _a, _b;
+        this.assertOperation(operation);
+        this.assertTransaction(session);
+        const payloadId = this.payloadId(this.scope, payload);
+        const refs = this.db.collection(MongoSchema_js_1.MongoCollectionNames.payloadReferences);
+        const liveReferences = await refs.countDocuments({
+            payloadId,
+            $or: [{ ownerKind: { $ne: 'pin' } }, { $expr: { $gt: ['$expiresAt', '$$NOW'] } }]
+        }, { session, timeoutMS: operation.timeoutMS });
+        if (liveReferences !== 0)
+            return false;
+        const claimed = await this.db
+            .collection(MongoSchema_js_1.MongoCollectionNames.payloads)
+            .findOneAndUpdate({ _id: payloadId, state: 'ready' }, [
+            {
+                $set: {
+                    state: 'deleting',
+                    guard: (0, node_crypto_1.randomUUID)(),
+                    updatedAt: '$$NOW',
+                    leaseUntil: {
+                        $dateAdd: { startDate: '$$NOW', unit: 'millisecond', amount: this.uploadLeaseMs }
+                    }
+                }
+            }
+        ], { session, timeoutMS: operation.timeoutMS, returnDocument: 'after' });
+        if (claimed === null)
+            return false;
+        // Every pin row still present here was already confirmed expired by the
+        // liveReferences count above; delete it in this same transaction so the
+        // unique slot cannot outlive the payload it named and short-circuit a
+        // future addReference on that slot.
+        await refs.deleteMany({ payloadId, ownerKind: 'pin', $expr: { $lte: ['$expiresAt', '$$NOW'] } }, { session, timeoutMS: operation.timeoutMS });
+        await ((_b = (_a = this.options.hooks) === null || _a === void 0 ? void 0 : _a.afterDeleteClaim) === null || _b === void 0 ? void 0 : _b.call(_a));
+        return true;
+    }
+    /** Safe to retry after process death. It only deletes the file named by the deleting record. */
+    async finishGarbage(payload) {
+        const payloadId = this.payloadId(this.scope, payload);
+        const payloads = this.db.collection(MongoSchema_js_1.MongoCollectionNames.payloads);
+        const record = await payloads.findOne({ _id: payloadId, state: 'deleting' });
+        if (record === null)
+            return false;
+        if (record.fileId !== undefined) {
+            const owned = await this.db.collection(`${MongoSchema_js_1.MongoGridFsBucketName}.files`).findOne({
+                _id: record.fileId,
+                'metadata.ownerId': record.ownerId,
+                'metadata.fencingToken': record.fencingToken
+            });
+            if (owned !== null) {
+                await this.bucket.delete(record.fileId).catch(error => {
+                    // The driver reports an already-removed file as MongoRuntimeError
+                    // "File not found for id <id>"; a concurrent finisher got there first.
+                    if (!(error instanceof Error) || !/File not found/i.test(error.message))
+                        throw error;
+                });
+            }
+        }
+        const result = await payloads.updateOne({ _id: payloadId, state: 'deleting', guard: record.guard }, {
+            $set: {
+                state: 'deleted',
+                updatedAt: this.now(),
+                ...(record.fileId === undefined ? {} : { retiredFileId: record.fileId })
+            },
+            $unset: { inlineData: '', fileId: '' }
+        }, { writeConcern: this.writeConcern });
+        return result.modifiedCount === 1;
+    }
+    /** Recovery may retain content; it never guesses that a missing external owner is disposable. */
+    async recoverUploads() {
+        const payloads = this.db.collection(MongoSchema_js_1.MongoCollectionNames.payloads);
+        const stale = await payloads
+            .find({
+            network: this.scope.network,
+            genesisHash: this.scope.genesisHash,
+            state: 'uploading',
+            $expr: { $lte: ['$leaseUntil', '$$NOW'] }
+        })
+            .toArray();
+        for (const record of stale)
+            await this.recoverStaleUpload(payloads, record);
+        const deleting = await payloads
+            .find({ network: this.scope.network, genesisHash: this.scope.genesisHash, state: 'deleting' })
+            .toArray();
+        for (const record of deleting)
+            await this.finishGarbage({ kind: record.kind, digest: record.digest });
+    }
+    async completeUpload(payloads, input, payloadId, reserved) {
+        var _a, _b;
+        const ownerId = reserved.ownerId;
+        const fence = reserved.fencingToken;
+        let fileId;
+        try {
+            const streamed = await this.streamInput(input, payloadId, ownerId, fence);
+            this.throwIfAborted(input.signal);
+            fileId = streamed.fileId;
+            this.assertStreamedPayload(input, streamed);
+            const binary = streamed.inline === undefined ? undefined : new mongodb_1.Binary(Buffer.concat(streamed.inline));
+            if (binary !== undefined && !this.fitsInline(payloadId, input, binary, this.now()))
+                throw new Error('Mongo payload inline BSON document exceeds safety ceiling');
+            if (fileId !== undefined)
+                await this.stageGridFsUpload(payloads, input, payloadId, ownerId, fence, fileId);
+            await ((_b = (_a = this.options.hooks) === null || _a === void 0 ? void 0 : _a.beforeReadyCas) === null || _b === void 0 ? void 0 : _b.call(_a));
+            this.throwIfAborted(input.signal);
+            const ready = await payloads.findOneAndUpdate({
+                _id: payloadId,
+                state: 'uploading',
+                ownerId,
+                guard: ownerId,
+                $expr: { $gt: ['$leaseUntil', '$$NOW'] }
+            }, {
+                $set: {
+                    state: 'ready',
+                    updatedAt: this.now(),
+                    ...(fileId === undefined ? { inlineData: binary } : { fileId })
+                },
+                $unset: { uploadId: '' }
+            }, { returnDocument: 'after', writeConcern: this.writeConcern });
+            if (ready === null)
+                throw new Error('Mongo payload upload lease was fenced before publication');
+            return this.refFor(input, ready);
+        }
+        catch (error) {
+            await this.abandonUpload(payloads, payloadId, ownerId, fence, fileId, error);
+            throw error;
+        }
+    }
+    assertStreamedPayload(input, streamed) {
+        if (streamed.digest !== input.digest || streamed.length !== BigInt(input.byteLength))
+            throw new Error('Mongo payload digest or declared length mismatch');
+        if (input.kind === 'raw-transaction' && input.txid !== undefined && input.txid !== streamed.txid)
+            throw new Error('Mongo raw transaction id does not match bytes');
+    }
+    async stageGridFsUpload(payloads, input, payloadId, ownerId, fence, fileId) {
+        var _a, _b, _c, _d;
+        const staged = await payloads.updateOne({ _id: payloadId, state: 'uploading', ownerId, guard: ownerId }, { $set: { fileId, updatedAt: this.now() } }, { writeConcern: this.writeConcern });
+        if (staged.matchedCount !== 1)
+            throw new Error('Mongo payload upload lease was fenced before staging');
+        await this.verifyGridFs(fileId, input, input.signal);
+        this.throwIfAborted(input.signal);
+        await ((_b = (_a = this.options.hooks) === null || _a === void 0 ? void 0 : _a.afterGridFsUploaded) === null || _b === void 0 ? void 0 : _b.call(_a));
+        this.throwIfAborted(input.signal);
+        const published = await this.db.collection(`${MongoSchema_js_1.MongoGridFsBucketName}.files`).updateOne({
+            _id: fileId,
+            'metadata.ownerId': ownerId,
+            'metadata.fencingToken': fence,
+            'metadata.state': 'staged'
+        }, { $set: { 'metadata.state': 'published' } }, { writeConcern: this.writeConcern });
+        if (published.matchedCount !== 1)
+            throw new Error('Mongo GridFS staged file was lost');
+        await ((_d = (_c = this.options.hooks) === null || _c === void 0 ? void 0 : _c.afterGridFsPublished) === null || _d === void 0 ? void 0 : _d.call(_c));
+    }
+    async abandonUpload(payloads, payloadId, ownerId, fence, fileId, error) {
+        // Never remove a file by payload identity: a newer fenced owner may have published it.
+        if (fileId !== undefined) {
+            const published = await this.db.collection(`${MongoSchema_js_1.MongoGridFsBucketName}.files`).findOne({
+                _id: fileId,
+                'metadata.ownerId': ownerId,
+                'metadata.fencingToken': fence,
+                'metadata.state': 'published'
+            });
+            if (published !== null)
+                throw error;
+            await this.retireOwnedFile(fileId, ownerId);
+        }
+        await payloads.updateOne({ _id: payloadId, state: 'uploading', ownerId, guard: ownerId }, {
+            $set: {
+                state: 'deleted',
+                updatedAt: this.now(),
+                ...(fileId === undefined ? {} : { retiredFileId: fileId })
+            },
+            $unset: { inlineData: '', fileId: '' }
+        }, { writeConcern: this.writeConcern });
+    }
+    async recoverStaleUpload(payloads, record) {
+        if (record.fileId !== undefined) {
+            try {
+                await this.verifyGridFs(record.fileId, {
+                    digest: record.digest,
+                    byteLength: BigInt(record.byteLength).toString()
+                });
+                await this.db.collection(`${MongoSchema_js_1.MongoGridFsBucketName}.files`).updateOne({
+                    _id: record.fileId,
+                    'metadata.ownerId': record.ownerId,
+                    'metadata.fencingToken': record.fencingToken
+                }, { $set: { 'metadata.state': 'published' } }, { writeConcern: this.writeConcern });
+                const recovered = await payloads.updateOne({ _id: record._id, state: 'uploading', ownerId: record.ownerId, guard: record.guard }, { $set: { state: 'ready', updatedAt: this.now() }, $unset: { uploadId: '' } }, { writeConcern: this.writeConcern });
+                if (recovered.modifiedCount === 1)
+                    return;
+            }
+            catch {
+                /* an incomplete upload is retired below */
+            }
+        }
+        const current = await payloads.findOne({ _id: record._id });
+        if (current === null ||
+            current.state !== 'uploading' ||
+            current.ownerId !== record.ownerId ||
+            current.guard !== record.guard) {
+            return;
+        }
+        if (record.fileId !== undefined)
+            await this.retireOwnedFile(record.fileId, record.ownerId, record.fencingToken);
+        await payloads.updateOne({ _id: record._id, state: 'uploading', ownerId: record.ownerId, guard: record.guard }, {
+            $set: {
+                state: 'deleted',
+                updatedAt: this.now(),
+                ...(record.fileId === undefined ? {} : { retiredFileId: record.fileId })
+            },
+            $unset: { inlineData: '', fileId: '' }
+        }, { writeConcern: this.writeConcern });
+    }
+    async reserveUpload(payloads, payloadId, input) {
+        const deadline = Date.now() + this.uploadLeaseMs;
+        while (true) {
+            this.throwIfAborted(input.signal);
+            const observed = await payloads.findOne({ _id: payloadId });
+            if ((observed === null || observed === void 0 ? void 0 : observed.state) === 'ready')
+                return { ready: true, record: observed };
+            const claimed = await this.tryClaimUpload(payloads, payloadId, input, observed);
+            if (claimed !== undefined)
+                return claimed;
+            const ready = await payloads.findOne({ _id: payloadId, state: 'ready' });
+            if (ready !== null)
+                return { ready: true, record: ready };
+            if (Date.now() > deadline)
+                throw new Error('Mongo payload upload reservation was lost');
+            await (0, promises_1.setTimeout)(50);
+        }
+    }
+    async tryClaimUpload(payloads, payloadId, input, observed) {
+        var _a;
+        const ownerId = (0, node_crypto_1.randomUUID)();
+        const fence = (0, MongoSchema_js_1.encodeMongoUint64)((BigInt((_a = observed === null || observed === void 0 ? void 0 : observed.fencingToken) !== null && _a !== void 0 ? _a : '00000000000000000000') + BigInt(1)).toString());
+        try {
+            const claimed = await payloads.findOneAndUpdate(observed === null
+                ? { _id: payloadId, state: { $exists: false } }
+                : {
+                    _id: payloadId,
+                    state: observed.state,
+                    guard: observed.guard,
+                    fencingToken: observed.fencingToken,
+                    $or: [{ state: 'deleted' }, { $expr: { $lte: ['$leaseUntil', '$$NOW'] } }]
+                }, [
+                {
+                    $set: {
+                        schemaVersion: { $ifNull: ['$schemaVersion', 1] },
+                        network: { $ifNull: ['$network', this.scope.network] },
+                        genesisHash: { $ifNull: ['$genesisHash', this.scope.genesisHash] },
+                        kind: { $ifNull: ['$kind', input.kind] },
+                        digest: { $ifNull: ['$digest', input.digest] },
+                        byteLength: {
+                            $cond: [
+                                { $eq: ['$state', 'deleted'] },
+                                (0, MongoSchema_js_1.encodeMongoUint64)(input.byteLength),
+                                { $ifNull: ['$byteLength', (0, MongoSchema_js_1.encodeMongoUint64)(input.byteLength)] }
+                            ]
+                        },
+                        createdAt: { $ifNull: ['$createdAt', '$$NOW'] },
+                        state: 'uploading',
+                        guard: ownerId,
+                        ownerNodeId: this.scope.nodeId,
+                        ownerId,
+                        fencingToken: fence,
+                        leaseUntil: {
+                            $dateAdd: { startDate: '$$NOW', unit: 'millisecond', amount: this.uploadLeaseMs }
+                        },
+                        updatedAt: '$$NOW',
+                        uploadId: ownerId
+                    }
+                },
+                { $unset: ['inlineData', 'fileId'] }
+            ], { upsert: observed === null, returnDocument: 'after', writeConcern: this.writeConcern });
+            if (claimed !== null && claimed.ownerId === ownerId && claimed.guard === ownerId) {
+                if ((observed === null || observed === void 0 ? void 0 : observed.fileId) !== undefined)
+                    await this.retireOwnedFile(observed.fileId, observed.ownerId, observed.fencingToken);
+                return { ready: false, record: claimed };
+            }
+        }
+        catch (error) {
+            if (!duplicateKey(error))
+                throw error;
+        }
+        return undefined;
+    }
+    async streamInput(input, payloadId, ownerId, fencingToken) {
+        var _a, _b;
+        const stream = {
+            hash: (0, node_crypto_1.createHash)('sha256'),
+            length: BigInt(0),
+            inline: [],
+            upload: undefined,
+            fileId: undefined
+        };
+        const iterator = input.bytes[Symbol.asyncIterator]();
+        try {
+            while (true) {
+                const next = await this.nextWithAbort(iterator, input.signal);
+                if (next.done)
+                    break;
+                await this.consumePayloadChunk(input, payloadId, ownerId, fencingToken, next.value, stream);
+            }
+            await this.finishPayloadUpload(stream.upload, input.signal);
+        }
+        catch (error) {
+            (_a = stream.upload) === null || _a === void 0 ? void 0 : _a.destroy(error instanceof Error ? error : new Error('Mongo payload stream failed'));
+            await ((_b = iterator.return) === null || _b === void 0 ? void 0 : _b.call(iterator).catch(() => undefined));
+            throw error;
+        }
+        const digest = stream.hash.digest();
+        const result = {
+            digest: digest.toString('hex'),
+            length: stream.length,
+            inline: stream.inline,
+            fileId: stream.fileId
+        };
+        if (input.kind === 'raw-transaction')
+            result.txid = (0, node_crypto_1.createHash)('sha256').update(digest).digest().reverse().toString('hex');
+        return result;
+    }
+    async consumePayloadChunk(input, payloadId, ownerId, fencingToken, chunk, stream) {
+        var _a;
+        var _b;
+        if ((_a = input.signal) === null || _a === void 0 ? void 0 : _a.aborted)
+            throw (_b = input.signal.reason) !== null && _b !== void 0 ? _b : new Error('Mongo payload upload aborted');
+        if (!(chunk instanceof Uint8Array))
+            throw new Error('Mongo payload stream yielded a non-byte chunk');
+        stream.length += BigInt(chunk.byteLength);
+        if (stream.length > BigInt(input.byteLength))
+            throw new Error('Mongo payload stream exceeds declared length');
+        if (stream.length > this.maxPayloadBytes)
+            throw new Error('Mongo payload stream exceeds configured byte bound');
+        stream.hash.update(chunk);
+        if (stream.inline !== undefined) {
+            stream.inline.push(chunk);
+            if (stream.length > BigInt(this.inlineCeiling))
+                await this.spillInlineToGridFs(input, payloadId, ownerId, fencingToken, stream);
+            return;
+        }
+        if (stream.upload === undefined)
+            throw new Error('Mongo payload stream writer missing');
+        if (!stream.upload.write(Buffer.from(chunk)))
+            await this.awaitAbort((0, node_events_1.once)(stream.upload, 'drain'), input.signal);
+    }
+    async spillInlineToGridFs(input, payloadId, ownerId, fencingToken, stream) {
+        const buffered = stream.inline;
+        if (buffered === undefined)
+            throw new Error('Mongo payload stream writer missing');
+        stream.fileId = new mongodb_1.ObjectId();
+        stream.upload = this.bucket.openUploadStreamWithId(stream.fileId, payloadId, {
+            chunkSizeBytes: this.gridFsChunkBytes,
+            metadata: {
+                state: 'staged',
+                payloadId,
+                kind: input.kind,
+                digest: input.digest,
+                byteLength: (0, MongoSchema_js_1.encodeMongoUint64)(input.byteLength),
+                ownerId,
+                fencingToken
+            }
+        });
+        stream.inline = undefined;
+        for (const item of buffered)
+            if (!stream.upload.write(Buffer.from(item)))
+                await this.awaitAbort((0, node_events_1.once)(stream.upload, 'drain'), input.signal);
+    }
+    async finishPayloadUpload(upload, signal) {
+        if (upload === undefined)
+            return;
+        upload.end();
+        await this.awaitAbort((0, node_events_1.once)(upload, 'finish'), signal);
+    }
+    fitsInline(payloadId, input, data, now) {
+        const candidate = {
+            _id: payloadId,
+            schemaVersion: 1,
+            network: this.scope.network,
+            genesisHash: this.scope.genesisHash,
+            kind: input.kind,
+            digest: input.digest,
+            byteLength: (0, MongoSchema_js_1.encodeMongoUint64)(input.byteLength),
+            state: 'ready',
+            guard: '0'.repeat(36),
+            ownerNodeId: this.scope.nodeId,
+            ownerId: '0'.repeat(36),
+            fencingToken: (0, MongoSchema_js_1.encodeMongoUint64)('1'),
+            leaseUntil: now,
+            createdAt: now,
+            updatedAt: now,
+            inlineData: data
+        };
+        return mongodb_1.BSON.serialize(candidate).byteLength < 1024 * 1024;
+    }
+    async retireOwnedFile(fileId, ownerId, fencingToken) {
+        const file = await this.db.collection(`${MongoSchema_js_1.MongoGridFsBucketName}.files`).findOne({
+            _id: fileId,
+            'metadata.ownerId': ownerId,
+            ...(fencingToken === undefined ? {} : { 'metadata.fencingToken': fencingToken })
+        });
+        if (file !== null)
+            await this.bucket.delete(fileId).catch(() => undefined);
+    }
+    async readBytes(record) {
+        if (record.inlineData !== undefined)
+            return Buffer.from(record.inlineData.buffer);
+        if (record.fileId === undefined)
+            throw new Error('Mongo ready payload has no bytes');
+        const chunks = [];
+        const download = this.bucket.openDownloadStream(record.fileId);
+        const iterator = download[Symbol.asyncIterator]();
+        try {
+            while (true) {
+                const next = await iterator.next();
+                if (next.done)
+                    break;
+                const chunk = next.value;
+                if (!(chunk instanceof Uint8Array))
+                    throw new Error('Mongo GridFS returned a non-byte chunk');
+                chunks.push(Buffer.from(chunk));
+            }
+        }
+        catch (error) {
+            download.destroy(error instanceof Error ? error : new Error('Mongo payload read failed'));
+            throw error;
+        }
+        return Buffer.concat(chunks);
+    }
+    async verifyGridFs(fileId, input, signal) {
+        const hash = (0, node_crypto_1.createHash)('sha256');
+        let length = BigInt(0);
+        const download = this.bucket.openDownloadStream(fileId);
+        const iterator = download[Symbol.asyncIterator]();
+        try {
+            while (true) {
+                const next = await this.nextWithAbort(iterator, signal);
+                if (next.done)
+                    break;
+                const chunk = next.value;
+                if (!(chunk instanceof Uint8Array))
+                    throw new Error('Mongo GridFS returned a non-byte chunk');
+                length += BigInt(chunk.byteLength);
+                hash.update(chunk);
+            }
+        }
+        catch (error) {
+            download.destroy(error instanceof Error ? error : new Error('Mongo GridFS verification failed'));
+            throw error;
+        }
+        if (length !== BigInt(input.byteLength) || hash.digest('hex') !== input.digest)
+            throw new Error('Mongo GridFS staged payload verification failed');
+    }
+    refFor(input, record) {
+        if (record !== undefined && (0, MongoSchema_js_1.decodeMongoUint64)(record.byteLength) !== input.byteLength)
+            throw new Error('Mongo payload byte length does not match ready content');
+        const ref = {
+            kind: input.kind,
+            digest: input.digest,
+            byteLength: input.byteLength
+        };
+        if (input.kind === 'raw-transaction') {
+            ref.txid = (0, node_crypto_1.createHash)('sha256')
+                .update(Buffer.from(input.digest, 'hex'))
+                .digest()
+                .reverse()
+                .toString('hex');
+            if (input.txid !== undefined && input.txid !== ref.txid)
+                throw new Error('Mongo raw transaction id does not match bytes');
+        }
+        return ref;
+    }
+    payloadId(scope, payload) {
+        if (!HEX_256.test(payload.digest))
+            throw new Error('Invalid Mongo payload digest');
+        return (0, MongoSchema_js_1.mongoRecordKey)((0, MongoSchema_js_1.mongoChainKey)(scope), payload.kind, payload.digest);
+    }
+    validateInput(input) {
+        this.payloadId(this.scope, input);
+        if (!this.isUint64(input.byteLength))
+            throw new Error('Invalid Mongo payload byte length');
+        if (BigInt(input.byteLength) > this.maxPayloadBytes)
+            throw new Error('Mongo payload exceeds configured byte bound');
+        if (input.txid !== undefined && (input.kind !== 'raw-transaction' || !HEX_256.test(input.txid)))
+            throw new Error('Invalid Mongo raw transaction id');
+    }
+    validateReference(reference) {
+        this.payloadId(reference.scope, reference.payload);
+        if (reference.scope.network !== this.scope.network ||
+            reference.scope.genesisHash !== this.scope.genesisHash ||
+            reference.scope.nodeId !== this.scope.nodeId)
+            throw new Error('Mongo payload reference scope does not match this store');
+        if (reference.ownerId.length === 0 || reference.slot.length === 0)
+            throw new Error('Invalid Mongo payload reference owner');
+        if ((reference.ownerKind === 'pin') !== (reference.expiresAt !== undefined))
+            throw new Error('Mongo payload expiry is valid only for explicit pins');
+        if (reference.expiresAt !== undefined && reference.expiresAt <= this.now())
+            throw new Error('Mongo payload pin must be unexpired');
+    }
+    assertTransaction(session) {
+        if (!session.inTransaction())
+            throw new Error('Mongo payload reference changes require an active transaction');
+    }
+    assertOperation(operation) {
+        var _a;
+        var _b;
+        if ((_a = operation.signal) === null || _a === void 0 ? void 0 : _a.aborted)
+            throw (_b = operation.signal.reason) !== null && _b !== void 0 ? _b : new Error('Mongo payload operation aborted');
+        if (operation.timeoutMS !== undefined &&
+            (!Number.isSafeInteger(operation.timeoutMS) || operation.timeoutMS < 1))
+            throw new Error('Invalid Mongo payload operation timeout');
+    }
+    async nextWithAbort(iterator, signal) {
+        var _a;
+        if (signal === undefined)
+            return await iterator.next();
+        if (signal.aborted)
+            throw (_a = signal.reason) !== null && _a !== void 0 ? _a : new Error('Mongo payload upload aborted');
+        return await this.raceAbort(iterator.next(), signal);
+    }
+    async awaitAbort(promise, signal) {
+        var _a;
+        if (signal === undefined)
+            return await promise;
+        if (signal.aborted)
+            throw (_a = signal.reason) !== null && _a !== void 0 ? _a : new Error('Mongo payload upload aborted');
+        return await this.raceAbort(promise, signal);
+    }
+    async raceAbort(promise, signal) {
+        return await new Promise((resolve, reject) => {
+            const abort = () => {
+                var _a;
+                cleanup();
+                reject((_a = signal.reason) !== null && _a !== void 0 ? _a : new Error('Mongo payload upload aborted'));
+            };
+            const cleanup = () => signal.removeEventListener('abort', abort);
+            signal.addEventListener('abort', abort, { once: true });
+            promise.then(value => {
+                cleanup();
+                resolve(value);
+            }, error => {
+                cleanup();
+                reject(error);
+            });
+        });
+    }
+    throwIfAborted(signal) {
+        var _a;
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted)
+            throw (_a = signal.reason) !== null && _a !== void 0 ? _a : new Error('Mongo payload upload aborted');
+    }
+    isUint64(value) {
+        return /^(0|[1-9]\d{0,19})$/.test(value) && BigInt(value) <= MAX_UINT64;
+    }
+}
+exports.MongoPayloadStore = MongoPayloadStore;
+//# sourceMappingURL=MongoPayloadStore.js.map