mindoodb 0.0.92 → 0.0.93

package/dist/core/BaseMindooDB.js

@@ -628,6 +628,16 @@ class BaseMindooDB {
         // ---------------------------------------------------------------------------
         /** Serializes concurrent author-trust reconciles (per database). */
         this.authorTrustReconcileChain = Promise.resolve();
+        /**
+         * Key series this replica gained or lost during the current pass. Documents of
+         * a group document are not re-checked one by one when its wraps change; the
+         * next {@link reconcileGroupKeyAccess} re-runs the key visibility reconcile.
+         */
+        this.groupKeyAccessChanged = new Set();
+        /** Per document: whether its origin decrypted with the partial series held then. */
+        this.partialSeriesProbes = new Map();
+        /** Group key series last probed without success, by key id (ms), see ingestGroupKey. */
+        this.groupKeyMisses = new Map();
         (0, databaseIdValidation_1.validateDatabaseId)(store.getId(), "dbId");
         (0, databaseIdValidation_1.validateDatabaseId)(attachmentStore.getId(), "dbId");
         if (store.getId() !== attachmentStore.getId()) {
@@ -3161,7 +3171,7 @@ class BaseMindooDB {
             const existingIndex = this.getDocIndexPosition(docId);
             const existing = existingIndex === undefined ? undefined : this.index[existingIndex];
             await this.ingestSealed(visibility.decryptionKeyId, metadataByDoc.get(docId));
-            const canRead = await this.tenant.hasDecryptionKey(visibility.decryptionKeyId);
+            const canRead = await this.canReadWithKey(visibility.decryptionKeyId, docId, metadataByDoc.get(docId));
             if (canRead) {
                 // This scan is the authority on visibility, so it also heals a tally
                 // that a visible->visible short-circuit below would leave untouched.
@@ -3465,6 +3475,8 @@ class BaseMindooDB {
             this.beginChangeNotificationHold();
             try {
                 await this.syncStoreChangesInternal();
+                // Joined or left a group document in this batch: its documents follow.
+                await this.reconcileGroupKeyAccess();
             }
             finally {
                 this.endChangeNotificationHold();
@@ -3523,6 +3535,26 @@ class BaseMindooDB {
                         this.logger.debug(`Dropping cached sealed document ${docId} — newest wrap is not for this user`);
                         return;
                     }
+                    // Full rebuild: drop the cached state and materialize the document
+                    // again, through the access-control path when that is enforced.
+                    const reloadFully = async () => {
+                        this.docCache.delete(docId);
+                        updatedDoc = await this.loadDocumentInternal(docId);
+                        if (updatedDoc) {
+                            // New entries triggered this reload, so force the re-emit.
+                            this.updateIndex(docId, updatedDoc.lastModified, updatedDoc.isDeleted, updatedDoc.decryptionKeyId, "visible", updatedDoc.awaitingWitness ?? false, updatedDoc.witnessed ?? false, true);
+                        }
+                    };
+                    if (await this.isAclEnforced()) {
+                        // The incremental path below applies new entries without the
+                        // access-control gate (docs/accesscontrol.md §10). With access
+                        // control active, a change by someone the rules do not allow must be
+                        // quarantined like on a fresh load, so rebuild the document through
+                        // maybeMaterializeWithAccessControl instead.
+                        this.logger.debug(`Document ${docId} found in cache, access control enforced: full reload`);
+                        await reloadFully();
+                        return;
+                    }
                     // Document is cached - try incremental update
                     this.logger.debug(`Document ${docId} found in cache, attempting incremental update`);
                     try {
@@ -3543,12 +3575,7 @@ class BaseMindooDB {
                     catch (error) {
                         // If incremental update fails, fall back to full reload
                         this.logger.warn(`Incremental update failed for document ${docId}, falling back to full reload:`, error);
-                        this.docCache.delete(docId);
-                        updatedDoc = await this.loadDocumentInternal(docId);
-                        if (updatedDoc) {
-                            // New entries triggered this reload, so force the re-emit.
-                            this.updateIndex(docId, updatedDoc.lastModified, updatedDoc.isDeleted, updatedDoc.decryptionKeyId, "visible", updatedDoc.awaitingWitness ?? false, updatedDoc.witnessed ?? false, true);
-                        }
+                        await reloadFully();
                     }
                 }
                 else {
@@ -3586,7 +3613,7 @@ class BaseMindooDB {
                             sealedIngestEntries = fullDocMetadata;
                         }
                         await this.ingestSealed(representativeEntry.decryptionKeyId, sealedIngestEntries);
-                        const keyAvailable = await this.tenant.hasDecryptionKey(representativeEntry.decryptionKeyId);
+                        const keyAvailable = await this.canReadWithKey(representativeEntry.decryptionKeyId, docId, coldSync ? entryMetadataList : fullDocMetadata);
                         if (!keyAvailable) {
                             this.logger.debug(`Skipping metadata-first index for doc ${docId} — decryption key "${representativeEntry.decryptionKeyId}" not available`);
                             // This is where a device that is still waiting for its keys meets
@@ -4515,6 +4542,10 @@ class BaseMindooDB {
                 throw new Error("createDocument: recipients is not supported together with a convergent custom id; " +
                     "pass assumeUniqueId for random ids.");
             }
+            if (useDeterministicSeed && options.groupKeyDocId !== undefined) {
+                throw new Error("createDocument: groupKeyDocId is not supported together with a convergent custom id; " +
+                    "pass assumeUniqueId for random ids.");
+            }
             if (useDeterministicSeed && (options.attachments?.length ?? 0) > 0) {
                 throw new Error("createDocument: attachments are not supported together with a convergent custom id; " +
                     "pass assumeUniqueId, or add them with changeDoc().");
@@ -4764,6 +4795,9 @@ class BaseMindooDB {
         if (useDeterministicSeed && options.recipients !== undefined) {
             throw new Error("createDocuments: recipients is not supported together with a convergent custom id; pass assumeUniqueId");
         }
+        if (useDeterministicSeed && options.groupKeyDocId !== undefined) {
+            throw new Error("createDocuments: groupKeyDocId is not supported together with a convergent custom id; pass assumeUniqueId");
+        }
         // Sanitize caller-provided initial values: internal/reserved fields are
         // managed by MindooDB and must not be seeded by callers. `undefined`
         // values are treated as "not set" (Automerge cannot represent undefined).
@@ -5102,13 +5136,112 @@ class BaseMindooDB {
     async ingestSealed(keyId, entries) {
         if (!this.tenant.ingestSealedFromEntries)
             return;
+        const hadKey = (0, sealedTypes_1.isSealedKeyId)(keyId) ? await this.tenant.hasDecryptionKey(keyId) : false;
+        const heldBefore = this.tenant.getSealedGenerations?.(keyId).length ?? 0;
         this.sealedIngestDepth++;
         try {
             await this.tenant.ingestSealedFromEntries(keyId, entries);
+            // A document encrypted with a group document's key series (`groupKeyDocId`)
+            // carries no recipient block of its own: the wraps are on the group document.
+            if ((0, sealedTypes_1.isSealedKeyId)(keyId) && !(0, recipients_1.newestRecipientBlock)(entries)) {
+                await this.ingestGroupKey(keyId);
+            }
+            // A series that does not reach back to epoch 1 may be completed from the
+            // key document's older recipient blocks; `entries` is often just a batch.
+            if ((0, sealedTypes_1.isSealedKeyId)(keyId) && this.tenant.needsDeepSealedIngest?.(keyId)) {
+                const keyDocId = (0, sealedTypes_1.sealedKeyDocId)(keyId);
+                if (keyDocId) {
+                    await this.tenant.ingestSealedFromEntries(keyId, await this.scanAllMetadata(this.store, { docId: keyDocId }), { complete: true });
+                }
+            }
         }
         finally {
             this.sealedIngestDepth--;
         }
+        if ((0, sealedTypes_1.isSealedKeyId)(keyId) &&
+            (hadKey !== (await this.tenant.hasDecryptionKey(keyId)) ||
+                (hadKey &&
+                    heldBefore !== (this.tenant.getSealedGenerations?.(keyId).length ?? 0)))) {
+            this.partialSeriesProbes.clear();
+            // Joined or left the key series: documents of a group document that were
+            // hidden (or readable) until now have to follow (see reconcileGroupKeyAccess).
+            this.groupKeyAccessChanged.add(keyId);
+        }
+    }
+    /**
+     * Whether this replica can read a document of key `keyId`. Usually the key id
+     * alone decides; a reader added to a group without its history
+     * (`history: "none"`) knows the key id but holds only the newer generations,
+     * so the document's origin entry is test-decrypted (once per document).
+     */
+    async canReadWithKey(keyId, docId, metas) {
+        if (!(await this.tenant.hasDecryptionKey(keyId)))
+            return false;
+        if (!(0, sealedTypes_1.isSealedKeyId)(keyId) || !this.tenant.isPartialSealedSeries?.(keyId))
+            return true;
+        const known = this.partialSeriesProbes.get(docId);
+        if (known !== undefined)
+            return known;
+        const all = metas ?? (await this.scanAllMetadata(this.store, { docId }));
+        // Loading starts from the newest snapshot when there is one (written under
+        // the new key when readers were added without history), else from the create.
+        const origin = all
+            .filter((meta) => meta.entryType === "doc_snapshot")
+            .sort((a, b) => b.createdAt - a.createdAt)[0] ??
+            all.find((meta) => meta.entryType === "doc_create");
+        if (!origin)
+            return true;
+        let ok = false;
+        try {
+            const [entry] = await this.store.getEntries([origin.id]);
+            if (entry) {
+                await this.tenant.decryptPayload(entry.encryptedData, entry.decryptionKeyId);
+                ok = true;
+            }
+        }
+        catch {
+            ok = false;
+        }
+        this.partialSeriesProbes.set(docId, ok);
+        return ok;
+    }
+    /**
+     * Makes the key series `$sealed:<groupDocId>` available from the group
+     * document's own entries when the session does not have it yet. A miss is
+     * remembered briefly, so a few hundred documents of a group this replica is not
+     * a member of cost one scan of the group document, not one each.
+     */
+    async ingestGroupKey(keyId) {
+        const groupDocId = (0, sealedTypes_1.sealedKeyDocId)(keyId);
+        if (!groupDocId || (await this.tenant.hasDecryptionKey(keyId)))
+            return;
+        const lastMiss = this.groupKeyMisses.get(keyId);
+        if (lastMiss !== undefined && Date.now() - lastMiss < BaseMindooDB.GROUP_KEY_MISS_TTL_MS)
+            return;
+        const groupEntries = await this.scanAllMetadata(this.store, { docId: groupDocId });
+        if (groupEntries.length > 0) {
+            await this.tenant.ingestSealedFromEntries(keyId, groupEntries);
+        }
+        if (await this.tenant.hasDecryptionKey(keyId)) {
+            this.groupKeyMisses.delete(keyId);
+        }
+        else {
+            this.groupKeyMisses.set(keyId, Date.now());
+        }
+    }
+    /**
+     * After a pass that changed access to a key series (added to or removed from a
+     * group document), reveal or hide the documents that use it. Runs the full key
+     * visibility reconcile, which is rare enough: it only happens when this
+     * replica's membership in a group changed.
+     */
+    async reconcileGroupKeyAccess() {
+        if (this.groupKeyAccessChanged.size === 0 || this.isTimeTravelMode())
+            return;
+        this.groupKeyAccessChanged.clear();
+        this.groupKeyMisses.clear();
+        await this.reconcileKeyVisibility();
+        this.groupKeyAccessChanged.clear();
     }
     /**
      * Unwrap a `$sealed:` DEK from entry recipient wraps into the tenant session
@@ -8527,7 +8660,9 @@ class BaseMindooDB {
             isAccessible: () => true,
             isAwaitingWitness: () => internalDoc.awaitingWitness ?? false,
             isWitnessed: () => internalDoc.witnessed ?? false,
-            isSealed: () => (0, sealedTypes_1.isSealedKeyId)(internalDoc.decryptionKeyId),
+            isSealed: () => (0, sealedTypes_1.isSealedKeyId)(internalDoc.decryptionKeyId) &&
+                (0, sealedTypes_1.groupKeyDocIdOf)(internalDoc.decryptionKeyId, internalDoc.id) === undefined,
+            getGroupKeyDocId: () => (0, sealedTypes_1.groupKeyDocIdOf)(internalDoc.decryptionKeyId, internalDoc.id),
             getRecipients: () => (0, recipients_1.resolveRecipientsFromPayload)(internalDoc.doc, internalDoc.sealedRecipients),
             getRecipientEpoch: () => internalDoc.sealedRecipients?.epoch ?? 0,
             isEncryptedFor: (users) => (0, sealedTypes_1.isSealedKeyId)(internalDoc.decryptionKeyId) &&
@@ -9688,6 +9823,7 @@ class BaseMindooDB {
                 attachmentIds,
                 bypassPrecheck,
                 recipients: options.recipients,
+                forceSnapshot: options.forceSnapshot,
             });
         }
         catch (error) {
@@ -9790,8 +9926,9 @@ class BaseMindooDB {
                 signingKeyPair,
                 signingKeyPassword,
                 createdByPublicKey: createdByPublicKey ?? "",
+                force: options.forceSnapshot,
             }
-            : { createdByPublicKey: createdByPublicKey ?? "" });
+            : { createdByPublicKey: createdByPublicKey ?? "", force: options.forceSnapshot });
     }
     async buildDocChangeStoreEntry(options) {
         const { internalDoc, changeBytes, now, useCustomKey, signingKeyPair, signingKeyPassword, attachmentIds, attachmentRefs, recipients, } = options;
@@ -9858,7 +9995,7 @@ class BaseMindooDB {
             // An absent counter (first write this session) forces one scan to learn
             // the real backlog, after which the counter tracks it incrementally.
             const knownWrites = this.writesSinceSnapshotCheck.get(docId);
-            if (knownWrites !== undefined) {
+            if (knownWrites !== undefined && !options.force) {
                 const writes = knownWrites + 1;
                 if (writes < this.snapshotMinChanges) {
                     this.writesSinceSnapshotCheck.set(docId, writes);
@@ -9874,10 +10011,11 @@ class BaseMindooDB {
             const latestSnapshotAt = latestSnapshot?.createdAt ?? 0;
             const changesSinceSnapshot = replayEntries.filter((em) => em.createdAt > latestSnapshotAt).length;
             this.writesSinceSnapshotCheck.set(docId, changesSinceSnapshot);
-            if (changesSinceSnapshot < this.snapshotMinChanges) {
+            if (changesSinceSnapshot < this.snapshotMinChanges && !options.force) {
                 return;
             }
-            if (latestSnapshot &&
+            if (!options.force &&
+                latestSnapshot &&
                 Date.now() - latestSnapshot.createdAt < this.snapshotCooldownMs) {
                 return;
             }
@@ -11410,6 +11548,12 @@ class BaseMindooDB {
             options.decryptionKeyId !== undefined) {
             throw new Error("createDocument: recipients and decryptionKeyId are mutually exclusive");
         }
+        if (options.groupKeyDocId !== undefined) {
+            if (options.recipients !== undefined || options.decryptionKeyId !== undefined) {
+                throw new Error("createDocument: groupKeyDocId is mutually exclusive with recipients and decryptionKeyId");
+            }
+            return await this.requireGroupKey(options.groupKeyDocId);
+        }
         if (options.recipients !== undefined) {
             return (0, sealedTypes_1.sealedKeyId)(docId ?? options.id ?? "pending");
         }
@@ -11429,6 +11573,27 @@ class BaseMindooDB {
         }
         return "default";
     }
+    /**
+     * The key id of a group document's key series, after checking that the group
+     * document is a sealed document of this database and that the caller is a member.
+     */
+    async requireGroupKey(groupKeyDocId) {
+        if (!types_1.CUSTOM_DOC_ID_REGEX.test(groupKeyDocId) && !/^[a-z0-9_]+$/.test(groupKeyDocId)) {
+            throw new Error(`createDocument: invalid groupKeyDocId "${groupKeyDocId}"`);
+        }
+        const keyId = (0, sealedTypes_1.sealedKeyId)(groupKeyDocId);
+        const groupEntries = await this.scanAllMetadata(this.store, { docId: groupKeyDocId });
+        const groupCreate = groupEntries.find((entry) => entry.entryType === "doc_create");
+        if (!groupCreate || groupCreate.decryptionKeyId !== keyId) {
+            throw new Error(`createDocument: group document "${groupKeyDocId}" does not exist in this database or was not created with recipients`);
+        }
+        this.groupKeyMisses.delete(keyId);
+        await this.ingestSealed(keyId, groupEntries);
+        if (!(await this.tenant.hasDecryptionKey(keyId))) {
+            throw new Error(`createDocument: you are not a member of group document "${groupKeyDocId}"`);
+        }
+        return keyId;
+    }
     async prepareSealedCreate(options, docId, keyId, now, signerPublicKey) {
         if (options.recipients === undefined)
             return undefined;
@@ -11573,6 +11738,9 @@ class BaseMindooDB {
     async setRecipients(doc, recipients, options) {
         return this.mutateRecipients(doc, "set", recipients, options);
     }
+    async revealHistory(doc, recipients, options) {
+        return this.mutateRecipients(doc, "reveal", recipients, options);
+    }
     async canChangeRecipients(doc, next) {
         const after = { ...doc.getData() };
         after[sealedTypes_1.ENCRYPT_FOR_FIELD] = {
@@ -11586,6 +11754,10 @@ class BaseMindooDB {
         if (!(0, sealedTypes_1.isSealedKeyId)(doc.getDecryptionKeyId())) {
             throw new Error("Recipient mutators require a document created with `recipients`");
         }
+        const groupDocId = (0, sealedTypes_1.groupKeyDocIdOf)(doc.getDecryptionKeyId(), doc.getId());
+        if (groupDocId !== undefined) {
+            throw new Error(`Document ${doc.getId()} uses the key series of group document ${groupDocId}; change the recipients there`);
+        }
         const tenant = this.tenant;
         const docId = doc.getId();
         let internalDoc = this.getCachedDocument(docId) ?? (await this.loadDocumentInternal(docId));
@@ -11625,6 +11797,16 @@ class BaseMindooDB {
                     addedTargets.push(target);
             }
         }
+        const revealedIds = [];
+        if (mode === "reveal") {
+            for (const [id, entry] of Object.entries(currentMap)) {
+                if (entry.removedAt || !entry.historyFrom)
+                    continue;
+                if (resolved.targets.some((target) => matchesTarget(id, entry, target))) {
+                    revealedIds.push(id);
+                }
+            }
+        }
         if (mode === "remove") {
             for (const [id, entry] of Object.entries(currentMap)) {
                 if (entry.removedAt)
@@ -11645,19 +11827,69 @@ class BaseMindooDB {
                     removedStableIds.push(base);
             }
         }
-        const rotate = removedStableIds.length > 0;
-        const currentGens = tenant.getSealedGenerations(internalDoc.decryptionKeyId);
-        if (currentGens.length === 0) {
+        const withoutHistory = (mode === "add" || mode === "set") &&
+            addedTargets.length > 0 &&
+            (options?.history ?? sealedTypes_1.DEFAULT_RECIPIENT_HISTORY) === "none";
+        const rotate = removedStableIds.length > 0 || withoutHistory;
+        const heldSeries = tenant.getSealedSeries
+            ? tenant.getSealedSeries(internalDoc.decryptionKeyId)
+            : tenant
+                .getSealedGenerations(internalDoc.decryptionKeyId)
+                .map((key, index, all) => ({ epoch: all.length - index, key }));
+        if (heldSeries.length === 0) {
             throw new Error("Cannot change recipients: the current document key is not in this session");
         }
-        let generations = currentGens;
-        let epoch = internalDoc.sealedRecipients?.epoch ?? currentGens.length;
+        // The epoch comes from the store, not from the cached document.
+        const newestBlock = (0, recipients_1.newestRecipientBlock)(await this.scanAllMetadata(this.store, { docId })) ??
+            internalDoc.sealedRecipients;
+        let epoch = Math.max(newestBlock?.epoch ?? 0, heldSeries[0].epoch);
+        if (heldSeries[0].epoch < epoch) {
+            throw new Error("Cannot change recipients: this replica does not hold the current document key yet; sync first");
+        }
+        // What this replica can seal: the contiguous run of generations that ends at
+        // the current epoch. A member who joined without the earlier history holds a
+        // shorter run; readers entitled to more keep taking the older generations
+        // from the earlier recipient blocks (see ingestSealedFromEntries).
+        let series = heldSeries;
+        let run = [];
+        for (const entry of heldSeries) {
+            if (run.length > 0 && entry.epoch !== run[run.length - 1].epoch - 1)
+                break;
+            run.push(entry);
+        }
         if (rotate) {
             const nextDek = tenant
                 .getCryptoAdapter()
                 .getRandomValues(new Uint8Array(32));
-            generations = [nextDek, ...currentGens];
             epoch += 1;
+            run = [{ epoch, key: nextDek }, ...run];
+            series = [{ epoch, key: nextDek }, ...heldSeries];
+        }
+        /** Oldest epoch this replica can hand to anyone. */
+        const sealFrom = run[run.length - 1].epoch;
+        const generations = run.map((entry) => entry.key);
+        const addedHistoryFrom = withoutHistory
+            ? epoch
+            : sealFrom > 1
+                ? sealFrom
+                : undefined;
+        // Revealing reaches as far back as the caller's own history.
+        const revealTo = sealFrom > 1 ? sealFrom : undefined;
+        for (const id of [...revealedIds]) {
+            if ((currentMap[id]?.historyFrom ?? 1) <= sealFrom) {
+                revealedIds.splice(revealedIds.indexOf(id), 1);
+            }
+        }
+        const historyFromByStable = new Map();
+        for (const [id, entry] of Object.entries(currentMap)) {
+            if (entry.removedAt || !entry.historyFrom)
+                continue;
+            const from = revealedIds.includes(id) ? revealTo : entry.historyFrom;
+            if (!from)
+                continue;
+            historyFromByStable.set(id.split("#")[0], from);
+            if (entry.keyFingerprint)
+                historyFromByStable.set(entry.keyFingerprint, from);
         }
         const remainingByStable = new Map();
         const existingSpecs = Object.entries(currentMap)
@@ -11676,8 +11908,14 @@ class BaseMindooDB {
             for (const target of existingResolved.targets)
                 remainingByStable.set(target.stableId, target);
         }
+        for (const [stableId, target] of remainingByStable) {
+            const from = historyFromByStable.get(stableId) ??
+                historyFromByStable.get(target.keyFingerprint);
+            if (from)
+                remainingByStable.set(stableId, { ...target, historyFrom: from });
+        }
         for (const target of addedTargets)
-            remainingByStable.set(target.stableId, target);
+            remainingByStable.set(target.stableId, addedHistoryFrom ? { ...target, historyFrom: addedHistoryFrom } : target);
         for (const id of removedStableIds) {
             remainingByStable.delete(id);
             for (const [stableId, target] of [...remainingByStable.entries()]) {
@@ -11698,7 +11936,7 @@ class BaseMindooDB {
             targets: remaining,
             epoch,
         });
-        tenant.rememberSealedGenerations(internalDoc.decryptionKeyId, generations);
+        tenant.rememberSealedGenerations(internalDoc.decryptionKeyId, series.map((entry) => entry.key), recipientsBlock, series.map((entry) => entry.epoch));
         const headsBeforeChange = automerge_adapter_1.Automerge.getHeads(internalDoc.doc);
         const newDoc = automerge_adapter_1.Automerge.change(internalDoc.doc, { message: changeMessage }, (draft) => {
             if (addedTargets.length > 0) {
@@ -11710,10 +11948,22 @@ class BaseMindooDB {
                         addedBy: signer,
                         keyFingerprint: target.keyFingerprint,
                         ...(target.label ? { label: target.label } : {}),
+                        ...(addedHistoryFrom ? { historyFrom: addedHistoryFrom } : {}),
                     };
                 }
                 (0, recipients_1.applyEncryptForAdds)(draft, addMap, epoch);
             }
+            if (revealedIds.length > 0) {
+                const map = draft[sealedTypes_1.ENCRYPT_FOR_FIELD];
+                for (const id of revealedIds) {
+                    if (!map[id])
+                        continue;
+                    if (revealTo)
+                        map[id].historyFrom = revealTo;
+                    else
+                        delete map[id].historyFrom;
+                }
+            }
             if (removedStableIds.length > 0) {
                 (0, recipients_1.applyEncryptForRemoves)(draft, removedStableIds, now, signer);
             }
@@ -11734,6 +11984,9 @@ class BaseMindooDB {
             successMessage: "recipients updated",
             bypassPrecheck: options?.bypassAccessControlPrecheck,
             recipients: recipientsBlock,
+            // Readers added without history cannot decrypt the older entries of this
+            // document itself: a snapshot under the new key gives them its current state.
+            forceSnapshot: withoutHistory,
         });
         if (options?.change) {
             await this.changeDoc(this.wrapDocument(internalDoc), options.change, {
@@ -12790,7 +13043,9 @@ class BaseMindooDB {
             isAccessible: () => internalDoc.accessible ?? true,
             isAwaitingWitness: () => internalDoc.awaitingWitness ?? false,
             isWitnessed: () => internalDoc.witnessed ?? false,
-            isSealed: () => (0, sealedTypes_1.isSealedKeyId)(internalDoc.decryptionKeyId),
+            isSealed: () => (0, sealedTypes_1.isSealedKeyId)(internalDoc.decryptionKeyId) &&
+                (0, sealedTypes_1.groupKeyDocIdOf)(internalDoc.decryptionKeyId, internalDoc.id) === undefined,
+            getGroupKeyDocId: () => (0, sealedTypes_1.groupKeyDocIdOf)(internalDoc.decryptionKeyId, internalDoc.id),
             getRecipients: () => (0, recipients_1.resolveRecipientsFromPayload)(internalDoc.doc, internalDoc.sealedRecipients),
             getRecipientEpoch: () => internalDoc.sealedRecipients?.epoch ?? 0,
             isEncryptedFor: (users) => (0, sealedTypes_1.isSealedKeyId)(internalDoc.decryptionKeyId) &&
@@ -13852,6 +14107,7 @@ class BaseMindooDB {
     }
 }
 exports.BaseMindooDB = BaseMindooDB;
+BaseMindooDB.GROUP_KEY_MISS_TTL_MS = 2000;
 /** The "access control not enforced" allow decision returned by the
  * non-throwing `canCreate`/`canChange`/`canDelete` prediction helpers. */
 BaseMindooDB.ACL_NOT_ENFORCED_DECISION = {