keri-ts 0.11.0 → 2.0.0

package/esm/keri/npm/src/db/{kram-factors.js → mailbox/kram-factors.js}

@@ -1,6 +1,6 @@
 /** Durable KRAM factors preserve proof ownership; callers own authentication and atomic publication. */
-import { BlindState, BoundState, byteString, Cigar, Diger, FirstSeen, NumberPrimitive, ResourceLimitError, SealEvent, SealKind, SealSource, TypeMedia, } from "cesr-ts";
-import { KeriDispatchEnvelope, PathedMaterialGroup, TransIdxSigGroup, TransReceiptQuadruple, } from "../core/dispatch.js";
+import { BlindState, BoundState, byteString, Cigar, Diger, FirstSeen, NumberPrimitive, SealEvent, SealKind, TypeMedia, } from "cesr-ts";
+import { KeriDispatchEnvelope, PathedMaterialGroup, TransIdxSigGroup, TransReceiptQuadruple, } from "../../core/dispatch.js";
 /** Normalize historical ordinals before durable tuple identity is compared. */
 function number(value) {
     return NumberPrimitive.fromNum(value instanceof NumberPrimitive ? value.num : value.sn);
@@ -15,22 +15,6 @@ function identity(value) {
         return value.qb64;
     throw new Error("Unexpected KRAM stored factor");
 }
-/** Measure without encoding opaque bytes or allocating concatenated tuple strings. */
-function extent(value) {
-    if (value instanceof Uint8Array)
-        return value.byteLength;
-    if (Array.isArray(value))
-        return value.reduce((size, item) => size + extent(item), 0);
-    if (value && typeof value === "object" && "qb64" in value && typeof value.qb64 === "string")
-        return value.qb64.length;
-    throw new Error("Unexpected KRAM stored factor");
-}
-/** Reject finite factor limits without catching corruption or infrastructure failures. */
-function charge(credits, value) {
-    if (--credits.items < 0 || (credits.bytes -= extent(value)) < 0) {
-        throw new ResourceLimitError("KRAM partial evidence exceeds finite limits");
-    }
-}
 /** Enumerate tables consistently for validation and owned-factor cleanup. */
 function tables(db) {
     return [
@@ -49,24 +33,14 @@ function tables(db) {
         db.tmqs,
     ];
 }
-/** Validate staged durable rows before the caller's transaction commits; errors must roll back it. */
-export function validateKramFactors(db, key) {
-    const credits = { items: 4096, bytes: 8 * 1024 ** 2 };
-    for (const table of tables(db))
-        for (const value of table.getIter(key))
-            charge(credits, value);
-}
-/** Merge exact members in first-receipt order while charging the complete durable/incoming union. */
-function merge(saved, incoming, credits) {
+/** Merge exact members in first-receipt order. */
+function merge(saved, incoming) {
     const result = [], seen = new Set();
     for (const source of [saved, incoming]) {
         for (const value of source) {
-            if (extent(value) > 8 * 1024 ** 2)
-                throw new ResourceLimitError("KRAM partial evidence exceeds finite limits");
             const id = identity(value);
             if (seen.has(id))
                 continue;
-            charge(credits, value);
             seen.add(id);
             result.push(value);
         }
@@ -81,7 +55,7 @@ function* signatureTuples(groups) {
         }
     }
 }
-/** Stage factors in the caller's transaction; validateKramFactors must run before commit.
+/** Stage factors in the caller's transaction.
  * Sender body, establishment seal and verified pmks pool remain caller-owned.
  */
 export function storeKramFactors(db, key, envelope) {
@@ -152,9 +126,8 @@ export function rehydrateKramFactors(db, key, envelope) {
         && (body.raw.length !== envelope.serder.raw.length || !body.raw.every((byte, i) => byte === envelope.serder.raw[i]))) {
         throw new Error("KRAM partial body mismatch");
     }
-    const credits = { items: 4096, bytes: 8 * 1024 ** 2 };
     const grouped = new Map();
-    for (const [pre, num, dig, sig] of merge(db.tsgs.getIter(key), signatureTuples(envelope.tsgs), credits)) {
+    for (const [pre, num, dig, sig] of merge(db.tsgs.getIter(key), signatureTuples(envelope.tsgs))) {
         const group = new TransIdxSigGroup(pre, num, dig, [sig]);
         const previous = grouped.get(group.routeKey);
         if (previous)
@@ -162,32 +135,26 @@ export function rehydrateKramFactors(db, key, envelope) {
         else
             grouped.set(group.routeKey, group);
     }
-    for (const seal of envelope.sscs)
-        charge(credits, SealSource.toTuple(seal));
-    // Incoming last groups remain separate, awaiting receipt-time normalization by their owner.
-    for (const group of envelope.ssgs)
-        for (const sig of group.sigers)
-            charge(credits, [group.prefixer, sig]);
     return new KeriDispatchEnvelope({
         ...envelope,
         attachmentGroups: [...envelope.attachmentGroups],
-        sigers: merge(db.pmks.getIter(key), envelope.sigers, credits).sort((a, b) => a.index - b.index),
+        sigers: merge(db.pmks.getIter(key), envelope.sigers).sort((a, b) => a.index - b.index),
         tsgs: [...grouped.values()],
-        unresolvedLast: merge(db.ulgs.getIter(key), envelope.unresolvedLast, credits),
+        unresolvedLast: merge(db.ulgs.getIter(key), envelope.unresolvedLast),
         cigars: merge(db.cigs.getIter(key), envelope.cigars.map((c) => {
             if (!c.verfer)
                 throw new Error("KRAM cigar has no verifier context");
             return [c.verfer, c];
-        }), credits)
+        }))
             .map(([verfer, cigar]) => new Cigar(cigar, verfer)),
-        trqs: merge(db.trqs.getIter(key), envelope.trqs.map((v) => [v.prefixer, number(v.seqner), v.diger, v.siger]), credits)
+        trqs: merge(db.trqs.getIter(key), envelope.trqs.map((v) => [v.prefixer, number(v.seqner), v.diger, v.siger]))
             .map(TransReceiptQuadruple.fromTuple),
-        ssts: merge(db.ssts.getIter(key), envelope.ssts.map(SealEvent.toTuple), credits).map(SealEvent.fromTuple),
-        frcs: merge(db.frcs.getIter(key), envelope.frcs.map(FirstSeen.toTuple), credits).map(FirstSeen.fromTuple),
-        tdcs: merge(db.tdcs.getIter(key), envelope.tdcs.map(SealKind.toTuple), credits).map(SealKind.fromTuple),
-        ptds: merge(db.ptds.getIter(key), envelope.ptds.map((v) => v.raw), credits).map(PathedMaterialGroup.fromRaw),
-        bsqs: merge(db.bsqs.getIter(key), envelope.bsqs.map(BlindState.toTuple), credits).map(BlindState.fromTuple),
-        bsss: merge(db.bsss.getIter(key), envelope.bsss.map(BoundState.toTuple), credits).map(BoundState.fromTuple),
-        tmqs: merge(db.tmqs.getIter(key), envelope.tmqs.map(TypeMedia.toTuple), credits).map(TypeMedia.fromTuple),
+        ssts: merge(db.ssts.getIter(key), envelope.ssts.map(SealEvent.toTuple)).map(SealEvent.fromTuple),
+        frcs: merge(db.frcs.getIter(key), envelope.frcs.map(FirstSeen.toTuple)).map(FirstSeen.fromTuple),
+        tdcs: merge(db.tdcs.getIter(key), envelope.tdcs.map(SealKind.toTuple)).map(SealKind.fromTuple),
+        ptds: merge(db.ptds.getIter(key), envelope.ptds.map((v) => v.raw)).map(PathedMaterialGroup.fromRaw),
+        bsqs: merge(db.bsqs.getIter(key), envelope.bsqs.map(BlindState.toTuple)).map(BlindState.fromTuple),
+        bsss: merge(db.bsss.getIter(key), envelope.bsss.map(BoundState.toTuple)).map(BoundState.fromTuple),
+        tmqs: merge(db.tmqs.getIter(key), envelope.tmqs.map(TypeMedia.toTuple)).map(TypeMedia.fromTuple),
     });
 }

package/esm/keri/npm/src/db/{mailboxing.js → mailbox/mailboxing.js}

@@ -14,9 +14,9 @@
  *   they all treat this module as the single source of mailbox payload truth
  */
 import { Diger, MtrDex } from "cesr-ts";
-import { DatabaseNotOpenError } from "../core/errors.js";
-import { LMDBer } from "./core/lmdber.js";
-import { CesrOnSuber, Suber } from "./subing.js";
+import { DatabaseNotOpenError } from "../../core/errors.js";
+import { LMDBer } from "../core/lmdber.js";
+import { CesrOnSuber, Suber } from "../subing.js";
 /** Raw-byte value family used for stored mailbox message bodies. */
 class BytesSuber extends Suber {
     _ser(val) {
@@ -141,13 +141,10 @@ export class Mailboxer extends LMDBer {
      *
      * This is the storage primitive used by mailbox SSE streaming so the caller
      * can preserve both payload bytes and the ordered mailbox event id.
-     * An optional ceiling uses native preflight; omitted ceilings preserve whole-row reads.
      */
-    *cloneTopicIter(topic, fn = 0, maxMessageBytes) {
+    *cloneTopicIter(topic, fn = 0) {
         for (const [keys, on, dig] of this.tpcs.getAllItemIter(topic, fn)) {
-            const msg = maxMessageBytes === undefined
-                ? this.msgs.get(dig.qb64)
-                : this.getValBounded(this.msgs.sdb, new TextEncoder().encode(dig.qb64), maxMessageBytes);
+            const msg = this.msgs.get(dig.qb64);
             if (!msg) {
                 continue;
             }

package/esm/keri/npm/src/db/reger.js

@@ -9,16 +9,16 @@
  * - TEL state machines, registry orchestration, credential issuance, and
  *   verifier policy live in later VDR runtime modules
  */
-import { b, Cigar, concatBytes, Counter, Dater, Diger, NumberPrimitive, NumDex, Prefixer, ResourceLimitError, Saider, Seqner, SerderACDC, SerderKERI, Siger, t, Verfer, Vrsn_1_0, } from "cesr-ts";
-import { attachmentCounterPayloadQb64b, attachmentCounterQb64b, resolveAttachmentGvrsn, } from "../core/attachment-countering.js";
+import { b, Cigar, concatBytes, Counter, Dater, Diger, NumberPrimitive, Prefixer, Saider, SerderACDC, SerderKERI, Siger, t, Verfer, Vrsn_1_0, } from "cesr-ts";
+import { attachmentCounterPayloadQb64b, attachmentCounterQb64b, attachmentOrdinal, resolveAttachmentGvrsn, } from "../core/attachment-countering.js";
 import { DatabaseNotOpenError, DatabaseOperationError, ValidationError } from "../core/errors.js";
 import { RegistryRecord, RegStateRecord } from "../core/records.js";
 import { dgKey, splitOnKey } from "./core/keys.js";
 import { LMDBer } from "./core/lmdber.js";
 import { Broker } from "./escrowing.js";
 import { Komer } from "./koming.js";
+import { CapturedTelReplay, UnsupportedTelReplayError, } from "./replay/tel-replay.js";
 import { BytesSuber, CatCesrIoSetSuber, CatCesrSuber, CesrDupSuber, CesrIoSetSuber, CesrOnSuber, CesrSuber, IoDupSuber, OnIoDupSuber, SerderSuber, } from "./subing.js";
-import { CapturedTelReplay } from "./tel-replay.js";
 function keyText(value) {
     return typeof value === "string" ? value : t(value);
 }
@@ -28,19 +28,6 @@ function digestText(value) {
     }
     return keyText(value);
 }
-function fixedOrdinalRaw(num, size = 16) {
-    const raw = new Uint8Array(size);
-    let value = num;
-    for (let i = raw.length - 1; i >= 0; i--) {
-        raw[i] = Number(value & 0xffn);
-        value >>= 8n;
-    }
-    return raw;
-}
-/** Widen the ordinal value to the fixed v1 seal encoding. */
-function seqnerFromNumber(number) {
-    return new Seqner({ code: NumDex.Huge, raw: fixedOrdinalRaw(number.num) });
-}
 function saiderFromDigest(diger) {
     return new Saider({ qb64: diger.qb64 });
 }
@@ -50,8 +37,8 @@ function isRecord(value) {
 /**
  * VDR/TEL credential database owner.
  *
- * Bound stores are literal KERIpy `Reger` subkeys. Keeping this class thin
- * lets higher VDR processors share one storage contract with KERIpy fixtures.
+ * Protocol evidence uses literal KERIpy `Reger` subkeys; observer receipt
+ * evidence remains separate from local issuer publication state.
  */
 export class Reger extends LMDBer {
     constructor(options = {}) {
@@ -100,12 +87,13 @@ export class Reger extends LMDBer {
             writable: true,
             value: void 0
         }); // Backer AIDs at one TEL management state.
+        /** Indexed backer proofs; out-of-order candidates are reverified against accepted cohorts before admission. */
         Object.defineProperty(this, "tibs", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
-        }); // Indexed backer receipt signatures.
+        });
         Object.defineProperty(this, "oots", {
             enumerable: true,
             configurable: true,
@@ -237,7 +225,7 @@ export class Reger extends LMDBer {
             configurable: true,
             writable: true,
             value: void 0
-        }); // Completed TEL event marker.
+        }); // Completed local TEL publication, valued by issuer anchor SAID.
         Object.defineProperty(this, "cmse", {
             enumerable: true,
             configurable: true,
@@ -350,7 +338,7 @@ export class Reger extends LMDBer {
             return this.opened;
         }
         catch (error) {
-            throw new DatabaseOperationError("Failed to open Reger sub-databases", { cause: error instanceof Error ? error.message : String(error) });
+            throw new DatabaseOperationError("Failed to open Reger sub-databases", { cause: error });
         }
     }
     /** Persist one base credential and its anchoring event triple. */
@@ -375,30 +363,14 @@ export class Reger extends LMDBer {
         const [prefixer, number, diger] = anchor;
         return [creder, prefixer, number, diger];
     }
-    /** Bound selected credential body and anchor rows before hydration; caller holds decoded/copy credit. */
-    cloneCredBounded(said, maxBodyBytes) {
-        const creder = this.creds.getBounded([said], maxBodyBytes);
-        if (creder === null)
-            throw new ValidationError(`no credential found with said ${said}`);
-        // One prefix/ordinal/digest tuple is finite local storage policy, not a protocol maximum.
-        const anchor = this.cancs.getBounded([said], 512);
-        if (anchor === null)
-            throw new ValidationError(`no credential anchor found with said ${said}`);
-        if (anchor.length !== 3)
-            throw new DatabaseOperationError("Corrupt credential anchor tuple");
-        return [creder, ...anchor];
-    }
-    /** Iterate TEL events from ordinal `fn`, honoring the requested attachment genus floor. */
+    /** Iterate TEL events from ordinal `fn`, using the requested attachment genus exactly. */
     *clonePreIter(pre, fn = 0, gvrsn = Vrsn_1_0) {
         for (const [, , diger] of this.tels.getAllItemIter(pre, fn)) {
             yield this.cloneTvt(pre, diger, gvrsn);
         }
     }
     /** Capture one TEL extent without body reads; each reader releases its cursor before yielding. */
-    replay(pre, { gvrsn = Vrsn_1_0, genusify = false, maxMessageBytes = 8 * 1024 * 1024 } = {}) {
-        if (!Number.isSafeInteger(maxMessageBytes) || maxMessageBytes < 1) {
-            throw new RangeError("TEL replay message limit must be a positive safe integer");
-        }
+    replay(pre, { gvrsn = Vrsn_1_0, genusify = false } = {}) {
         let end = null;
         for (const entry of this.tels.sdb.getRange({ start: b(`${pre}.${"f".repeat(32)}`), reverse: true, limit: 1 })) {
             const [prefix, ordinal] = splitOnKey(entry.key);
@@ -410,13 +382,13 @@ export class Reger extends LMDBer {
         if (!Number.isFinite(end) || end < 0)
             throw new DatabaseOperationError("Corrupt TEL replay ordinal");
         if (!Number.isSafeInteger(end))
-            throw new ResourceLimitError("TEL replay ordinal exceeds supported range");
-        return new CapturedTelReplay(this, [[pre, end]], { gvrsn, genusify, maxMessageBytes });
+            throw new RangeError("TEL replay ordinal exceeds supported range");
+        return new CapturedTelReplay(this, [[pre, end]], { gvrsn, genusify });
     }
     /** Consume one captured horizon without retaining a cursor or event queue across a yield. */
-    *replayRange([pre, last], { gvrsn, genusify, maxMessageBytes }) {
-        if (!pre || !Number.isSafeInteger(last) || last < 0 || !Number.isSafeInteger(maxMessageBytes) || maxMessageBytes < 1) {
-            throw new RangeError("Invalid captured TEL range or message limit");
+    *replayRange([pre, last], { gvrsn, genusify }) {
+        if (!pre || !Number.isSafeInteger(last) || last < 0) {
+            throw new RangeError("Invalid captured TEL range");
         }
         let next = 0;
         while (next <= last) {
@@ -435,10 +407,10 @@ export class Reger extends LMDBer {
                 throw new DatabaseOperationError("Corrupt TEL replay sequence");
             }
             next = ordinal + 1;
-            yield this.cloneTvt(pre, diger, gvrsn, maxMessageBytes, genusify);
+            yield this.cloneTvt(pre, diger, gvrsn, genusify);
         }
     }
-    /** Clone one TEL event at sequence `sn`, preserving its body and honoring the genus floor. */
+    /** Clone one TEL event at sequence `sn`, preserving its body and using the requested genus exactly. */
     cloneTvtAt(pre, sn = 0, gvrsn = Vrsn_1_0) {
         const diger = this.tels.getOn(pre, sn);
         if (diger === null) {
@@ -446,38 +418,30 @@ export class Reger extends LMDBer {
         }
         return this.cloneTvt(pre, diger, gvrsn);
     }
-    /** Preflight one TEL body and cap incremental proofs, preserving its minimum/requested genus. */
-    cloneTvt(pre, dig, gvrsn = Vrsn_1_0, maxMessageBytes = 8 * 1024 * 1024, genusify = false) {
-        if (!Number.isSafeInteger(maxMessageBytes) || maxMessageBytes < 1) {
-            throw new RangeError("TEL replay message limit must be a positive safe integer");
-        }
+    /** Clone a TEL body/proof in the requested genus, refusing evidence that requires a newer version. */
+    cloneTvt(pre, dig, gvrsn = Vrsn_1_0, genusify = false) {
         const preText = keyText(pre);
         const digText = digestText(dig);
         const dgkey = dgKey(preText, digText);
-        const raw = this.tvts.getBounded(dgkey, maxMessageBytes);
+        const raw = this.tvts.get(dgkey);
         if (raw === null) {
             throw new ValidationError(`Missing event for dig=${digText}.`);
         }
+        const serder = new SerderKERI({ raw });
+        const required = resolveAttachmentGvrsn(serder, serder.pvrsn);
+        if (gvrsn.major < required.major || (gvrsn.major === required.major && gvrsn.minor < required.minor)) {
+            throw new UnsupportedTelReplayError(preText, digText, gvrsn, required);
+        }
         // Native dupsort yields one fixed signature record at a time, without collecting its bucket.
         const tibPayload = [];
-        let remaining = maxMessageBytes - raw.length;
         for (const tib of this.tibs.getIter([preText, digText])) {
-            const size = tib.qb64.length;
-            if (size > remaining)
-                throw new ResourceLimitError("TEL proofs exceed replay message limit");
-            remaining -= size;
             tibPayload.push(tib.qb64b);
         }
         const couple = this.ancs.get(dgkey);
         if (tibPayload.length === 0 && couple === null && !genusify)
             return raw;
-        // A requested genus is a floor; retain the body bytes and honor its declared minimum.
-        gvrsn = resolveAttachmentGvrsn(new SerderKERI({ raw }), gvrsn);
         const selector = genusify ? Counter.makeGVC(gvrsn) : new Uint8Array();
         if (tibPayload.length === 0 && couple === null) {
-            if (raw.length + selector.length > maxMessageBytes) {
-                throw new ResourceLimitError("TEL selector exceeds message limit");
-            }
             return concatBytes(selector, raw);
         }
         const attachments = [];
@@ -489,16 +453,13 @@ export class Reger extends LMDBer {
         if (couple !== null) {
             const [number, diger] = couple;
             const sealPayload = [
-                gvrsn.major === 1 ? seqnerFromNumber(number).qb64b : number.qb64b,
+                attachmentOrdinal(number, gvrsn).qb64b,
                 saiderFromDigest(diger).qb64b,
             ];
             attachments.push(attachmentCounterPayloadQb64b("SealSourceCouples", 1, sealPayload, gvrsn), ...sealPayload);
         }
         const attachmentBytes = attachments.reduce((total, item) => total + item.length, 0);
         const counter = attachmentCounterQb64b("AttachmentGroup", attachmentBytes / 4, gvrsn);
-        if (selector.length + raw.length + counter.length + attachmentBytes > maxMessageBytes) {
-            throw new ResourceLimitError("TEL proofs exceed replay message limit");
-        }
         const atc = new Uint8Array(attachmentBytes);
         let offset = 0;
         for (const part of attachments) {
@@ -526,7 +487,7 @@ export class Reger extends LMDBer {
             const selected = resolveAttachmentGvrsn(sourceCreder, gvrsn);
             const sealPayload = [
                 prefixer.qb64b,
-                selected.major === 1 ? seqnerFromNumber(number).qb64b : number.qb64b,
+                attachmentOrdinal(number, selected).qb64b,
                 saiderFromDigest(diger).qb64b,
             ];
             const atc = concatBytes(attachmentCounterPayloadQb64b("SealSourceTriples", 1, sealPayload, selected), ...sealPayload);
@@ -570,6 +531,7 @@ Object.defineProperty(Reger, "MaxNamedDBs", {
 export function* createReger(options = {}) {
     const reger = new Reger(options);
     let delivered = false;
+    let failure;
     try {
         const opened = yield* reger.reopen(options);
         if (!opened) {
@@ -578,8 +540,25 @@ export function* createReger(options = {}) {
         delivered = true;
         return reger;
     }
+    catch (error) {
+        failure = { error };
+        throw error;
+    }
     finally {
-        if (!delivered)
-            yield* reger.close();
+        if (!delivered) {
+            try {
+                yield* reger.close();
+            }
+            catch (error) {
+                if (failure) {
+                    // deno-lint-ignore no-unsafe-finally -- Preserve the operation failure alongside shutdown failure.
+                    throw new AggregateError([failure.error, error], "Database acquisition and close failed", {
+                        cause: failure.error,
+                    });
+                }
+                // deno-lint-ignore no-unsafe-finally -- A shutdown failure must propagate.
+                throw error;
+            }
+        }
     }
 }

package/esm/keri/npm/src/db/{kel-replay.js → replay/kel-replay.js}

@@ -4,37 +4,27 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var __classPrivateFieldIn = (this && this.__classPrivateFieldIn) || function(state, receiver) {
-    if (receiver === null || (typeof receiver !== "object" && typeof receiver !== "function")) throw new TypeError("Cannot use 'in' operator on non-object");
-    return typeof state === "function" ? receiver === state : state.has(receiver);
-};
 var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _CapturedKelReplay_db;
+var _CapturedKelReplay_instances, _CapturedKelReplay_db, _CapturedKelReplay_ranges;
+/** Inspectable KEL replay metadata; event bytes and read cursors remain consumption-owned. */
+import { genusFramed } from "../../core/genus-framing.js";
 /** A reopenable captured extent borrowing one runtime-owned Baser, never its event cache. */
 export class CapturedKelReplay {
     /** Copy primitive ranges into plain frozen containers; caller keeps the borrowed store alive. */
-    constructor(db, ranges, maxMessageBytes) {
+    constructor(db, ranges) {
+        _CapturedKelReplay_instances.add(this);
         Object.defineProperty(this, "ranges", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "maxMessageBytes", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         _CapturedKelReplay_db.set(this, void 0);
         const count = ranges.length;
-        if (!Number.isSafeInteger(count) || count < 0 || !Number.isSafeInteger(maxMessageBytes) || maxMessageBytes < 1) {
-            throw new RangeError("Invalid KEL replay range count or message limit");
-        }
         __classPrivateFieldSet(this, _CapturedKelReplay_db, db, "f");
         const owned = [];
         for (let i = 0; i < count; i++) {
@@ -46,17 +36,15 @@ export class CapturedKelReplay {
             owned.push(Object.freeze([pre, from, end]));
         }
         this.ranges = Object.freeze(owned);
-        this.maxMessageBytes = maxMessageBytes;
         Object.freeze(this);
     }
-    /** Recognize only this canonical owner, excluding prototype spoofs and additional subclass retention. */
-    static is(value) {
-        return typeof value === "object" && value !== null && __classPrivateFieldIn(_CapturedKelReplay_db, value)
-            && Object.getPrototypeOf(value) === CapturedKelReplay.prototype;
-    }
     /** Open no cursor until requested; each range reader joins its cursor before yielding an event. */
-    *[(_CapturedKelReplay_db = new WeakMap(), Symbol.iterator)]() {
-        for (const range of this.ranges)
-            yield* __classPrivateFieldGet(this, _CapturedKelReplay_db, "f").replayRange(range, this.maxMessageBytes);
+    *[(_CapturedKelReplay_db = new WeakMap(), _CapturedKelReplay_instances = new WeakSet(), Symbol.iterator)]() {
+        // A delegator's KEL may use a different KERI version than the queried log.
+        yield* genusFramed(__classPrivateFieldGet(this, _CapturedKelReplay_instances, "m", _CapturedKelReplay_ranges).call(this));
     }
 }
+_CapturedKelReplay_ranges = function* _CapturedKelReplay_ranges() {
+    for (const range of this.ranges)
+        yield* __classPrivateFieldGet(this, _CapturedKelReplay_db, "f").replayRange(range);
+};

package/esm/keri/npm/src/db/{tel-replay.js → replay/tel-replay.js}

@@ -4,19 +4,49 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var __classPrivateFieldIn = (this && this.__classPrivateFieldIn) || function(state, receiver) {
-    if (receiver === null || (typeof receiver !== "object" && typeof receiver !== "function")) throw new TypeError("Cannot use 'in' operator on non-object");
-    return typeof state === "function" ? receiver === state : state.has(receiver);
-};
 var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _CapturedTelReplay_db;
-/** A fixed single/pair TEL source; inspection never opens iterators or traverses its borrowed store. */
+import { ValidationError } from "../../core/errors.js";
+/** Requested replay cannot represent this stored body/proof; its signed bytes are never rewritten. */
+export class UnsupportedTelReplayError extends ValidationError {
+    /** Retain the refused event and owned version values for a local caller or transport boundary. */
+    constructor(pre, said, requested, required) {
+        super(`TEL replay ${pre}/${said} requires version ${required.major}.${required.minor}; requested ${requested.major}.${requested.minor}.`);
+        Object.defineProperty(this, "pre", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: pre
+        });
+        Object.defineProperty(this, "said", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: said
+        });
+        Object.defineProperty(this, "requested", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "required", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.requested = Object.freeze({ ...requested });
+        this.required = Object.freeze({ ...required });
+    }
+}
+/** A captured TEL source; readers borrow the store without retaining event bytes. */
 export class CapturedTelReplay {
-    /** Copy at most two range tuples and wire settings; caller keeps the store alive through consumption. */
+    /** Copy range tuples and wire settings; caller keeps the store alive through consumption. */
     constructor(db, ranges, settings) {
         Object.defineProperty(this, "ranges", {
             enumerable: true,
@@ -32,14 +62,8 @@ export class CapturedTelReplay {
         });
         _CapturedTelReplay_db.set(this, void 0);
         const count = ranges.length;
-        if (!Number.isSafeInteger(count) || count < 1 || count > 2) {
-            throw new RangeError("TEL replay requires one range or a fixed pair");
-        }
-        const { gvrsn, genusify, maxMessageBytes } = settings;
+        const { gvrsn, genusify } = settings;
         const major = gvrsn.major, minor = gvrsn.minor;
-        if (!Number.isSafeInteger(maxMessageBytes) || maxMessageBytes < 1) {
-            throw new RangeError("TEL replay message limit must be a positive safe integer");
-        }
         if (!Number.isSafeInteger(major) || major < 0 || !Number.isSafeInteger(minor) || minor < 0
             || typeof genusify !== "boolean") {
             throw new RangeError("Invalid TEL replay wire settings");
@@ -54,31 +78,9 @@ export class CapturedTelReplay {
             owned.push(Object.freeze([pre, end]));
         }
         this.ranges = Object.freeze(owned);
-        this.settings = Object.freeze({ gvrsn: Object.freeze({ major, minor }), genusify, maxMessageBytes });
+        this.settings = Object.freeze({ gvrsn: Object.freeze({ major, minor }), genusify });
         Object.freeze(this);
     }
-    /** Require this private brand and exact prototype; subclass/opaque sources cannot hide retention. */
-    static is(value) {
-        return typeof value === "object" && value !== null && __classPrivateFieldIn(_CapturedTelReplay_db, value)
-            && Object.getPrototypeOf(value) === CapturedTelReplay.prototype;
-    }
-    /** Compose only fixed metadata in management/credential order, preserving null and duplicate ranges. */
-    static pair(first, second) {
-        if ((first === null || CapturedTelReplay.is(first)) && (second === null || CapturedTelReplay.is(second))) {
-            if (first === null)
-                return second;
-            if (second === null)
-                return first;
-            const left = first.settings, right = second.settings;
-            if (__classPrivateFieldGet(first, _CapturedTelReplay_db, "f") !== __classPrivateFieldGet(second, _CapturedTelReplay_db, "f") || left.maxMessageBytes !== right.maxMessageBytes
-                || left.genusify !== right.genusify || left.gvrsn.major !== right.gvrsn.major
-                || left.gvrsn.minor !== right.gvrsn.minor) {
-                throw new RangeError("TEL replay pair requires the same borrowed store and wire settings");
-            }
-            return new CapturedTelReplay(__classPrivateFieldGet(first, _CapturedTelReplay_db, "f"), [...first.ranges, ...second.ranges], left);
-        }
-        throw new RangeError("TEL replay pair requires canonical captures");
-    }
     /** Open readers only during consumption; each closes its cursor before cloning/yielding an event. */
     *[(_CapturedTelReplay_db = new WeakMap(), Symbol.iterator)]() {
         for (const range of this.ranges)

package/esm/keri/npm/src/db/{witness-replay.js → replay/witness-replay.js}

@@ -11,13 +11,13 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 };
 var _CapturedWitnessReplay_db;
 /** Witness sequence replay borrows its Baser without retaining event bytes or read cursors. */
-import { b, bytesEqual, ResourceLimitError, t } from "cesr-ts";
-import { DatabaseOperationError } from "../core/errors.js";
-import { onKey, splitOnKey } from "./core/keys.js";
+import { b, bytesEqual, t } from "cesr-ts";
+import { DatabaseOperationError } from "../../core/errors.js";
+import { onKey, splitOnKey } from "../core/keys.js";
 /** Captured KEL/FEL horizons; duplicate order and current proofs are read only during consumption. */
 export class CapturedWitnessReplay {
     /** Fixed primitive metadata only; the caller keeps the borrowed store open through response disposal. */
-    constructor(db, pre, from, end, felEnd, maxMessageBytes) {
+    constructor(db, pre, from, end, felEnd) {
         Object.defineProperty(this, "pre", {
             enumerable: true,
             configurable: true,
@@ -42,19 +42,13 @@ export class CapturedWitnessReplay {
             writable: true,
             value: felEnd
         });
-        Object.defineProperty(this, "maxMessageBytes", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: maxMessageBytes
-        });
         _CapturedWitnessReplay_db.set(this, void 0);
         if (typeof pre !== "string" || !pre || !Number.isSafeInteger(from) || from < 0 || !Number.isSafeInteger(end)
             || end < from) {
             throw new RangeError("Invalid witness KEL sequence range");
         }
-        if (!Number.isSafeInteger(felEnd) || felEnd < 0 || !Number.isSafeInteger(maxMessageBytes) || maxMessageBytes < 1) {
-            throw new RangeError("Invalid witness first-seen horizon or message ceiling");
+        if (!Number.isSafeInteger(felEnd) || felEnd < 0) {
+            throw new RangeError("Invalid witness first-seen horizon");
         }
         __classPrivateFieldSet(this, _CapturedWitnessReplay_db, db, "f");
         Object.freeze(this);
@@ -123,11 +117,11 @@ export class CapturedWitnessReplay {
             if (!Number.isFinite(fn) || fn < 0)
                 throw new DatabaseOperationError("Corrupt witness first-seen ordinal");
             if (!Number.isSafeInteger(fn))
-                throw new ResourceLimitError("Unsupported witness first-seen ordinal");
+                throw new RangeError("Unsupported witness first-seen ordinal");
             // New accepted duplicates at an old sequence are outside this response's first-seen horizon.
             if (fn > this.felEnd)
                 continue;
-            yield __classPrivateFieldGet(this, _CapturedWitnessReplay_db, "f").cloneEvtMsg(this.pre, fn, said, this.maxMessageBytes);
+            yield __classPrivateFieldGet(this, _CapturedWitnessReplay_db, "f").cloneEvtMsg(this.pre, fn, said);
         }
     }
 }