keri-ts 2.2.5 → 2.2.6

package/esm/keri/npm/src/acdc/dhking.js

@@ -17,6 +17,7 @@ import { query, reply } from "../core/protocol-eventing.js";
 import { messagize } from "../core/protocol-serialization.js";
 import { fetchStoredTsgs, unverifiedReplyDecision } from "../core/routing.js";
 import { timestampMicros } from "../time/mod.js";
+import { QUERY_RESEND_MS } from "./query-resend.js";
 import { validateUpdate, verifyRegistryAnchor } from "./regeventing.js";
 import { publicOpeningAttachment } from "./registering.js";
 const domain = new TextEncoder().encode("KERI/ipex/dhke/X25519-HKDF-SHA256-Salt128/v1");
@@ -343,6 +344,8 @@ export class Dhke {
             peer: null,
             query: null,
             reply: null,
+            accepted: null,
+            repliedAt: 0,
             proposal: null,
             contribution: null,
             custody: null,
@@ -493,6 +496,12 @@ export class Dhke {
             if (own && (!op.proposal || !bytesEqual(op.proposal, serder.raw))) {
                 throw new ValidationError("Own DH query lacks exact local proposal approval");
             }
+            // A group re-sends its frozen query unchanged (one member cannot re-date it), and KERIpy resends identical
+            // bytes. The wire, attachments included, is compared against the one already authenticated, so a copy is
+            // never trusted on its body or SAID alone.
+            const wire = auxiliaryQueryWire(envelope);
+            if (!own && op.accepted && bytesEqual(op.accepted, wire))
+                return this.duplicateQuery(op);
             if (!verifyQueryAttachments(this.hab.db, envelope)) {
                 return { kind: "drop", reason: "missingAuthentication" };
             }
@@ -513,6 +522,7 @@ export class Dhke {
             }
             if (this.group && !this.custody(op)) {
                 op.peer = { ...peer };
+                op.accepted = wire;
                 return { kind: "accept" };
             }
             if (!op.reply) {
@@ -537,10 +547,12 @@ export class Dhke {
                 }
                 if (this.group) {
                     this.outgoing.push({ kin: "sign", dest: this.hab.pre, msg: op.contribution.slice() });
+                    op.accepted = wire;
                     return { kind: "accept" };
                 }
             }
-            this.outgoing.push({ kin: "reply", dest: op.issuer, msg: op.reply.slice() });
+            this.emitReply(op);
+            op.accepted = wire;
             return { kind: "accept" };
         }
         catch (error) {
@@ -549,6 +561,21 @@ export class Dhke {
             throw error;
         }
     }
+    /**
+     * A copy of the accepted query: nothing is verified, derived or contributed again, so a member round that
+     * already holds its `sign` contribution is not asked for another. If the reply exists it is queued again for a
+     * peer that lost it, at most once per {@link QUERY_RESEND_MS}.
+     */
+    duplicateQuery(op) {
+        if (op.reply && this.now() - op.repliedAt >= QUERY_RESEND_MS)
+            this.emitReply(op);
+        return { kind: "accept" };
+    }
+    /** Queue the stored reply for the issuer and note when. */
+    emitReply(op) {
+        this.outgoing.push({ kin: "reply", dest: op.issuer, msg: op.reply.slice() });
+        op.repliedAt = this.now();
+    }
     /** Revery decides reply threshold acceptance before any issuer derivation or retention. */
     processReply({ serder, diger, route, cigars = [], tsgs = [] }) {
         try {
@@ -574,7 +601,7 @@ export class Dhke {
                     });
                 }
                 if (this.custody(op))
-                    this.outgoing.push({ kin: "reply", dest: op.issuer, msg: op.reply.slice() });
+                    this.emitReply(op);
             }
             else if (this.custody(op) && !op.completed)
                 this.retain(op, peer, this.derive(op, peer, "issuer"));

package/esm/keri/npm/src/acdc/observing.js

@@ -11,9 +11,10 @@ import { publicOpeningAttachment } from "./registering.js";
  * event commits independently; a later failure preserves the already accepted prefix.
  * Parsed evidence stays borrowed. Composition supplies this owner to v2 protocol dispatch;
  * no local habitat, alias or application disclosure custody is created by public intake.
+ * `cues` receives the issuer KEL `logs` query of each event that first waits for its anchoring KEL event.
  */
 export class RegistryObserver {
-    constructor(db, store) {
+    constructor(db, store, cues = null) {
         Object.defineProperty(this, "db", {
             enumerable: true,
             configurable: true,
@@ -26,6 +27,12 @@ export class RegistryObserver {
             writable: true,
             value: store
         });
+        Object.defineProperty(this, "cues", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: cues
+        });
     }
     /** Stage parsed events before inception, otherwise delegate ordinary validation and acceptance. */
     processEvent(serder, locators = {}) {
@@ -62,7 +69,7 @@ export class RegistryObserver {
         if (event.ilk === Ilks.rip) {
             if (!event.issuer)
                 return { kind: "reject", reason: "issuer" };
-            engine ??= new RegistryEventer(this.db, event.issuer, this.store, event.regid);
+            engine ??= new RegistryEventer(this.db, event.issuer, this.store, event.regid, this.cues);
         }
         if (engine) {
             const decision = engine.processEvent(serder, locators);
@@ -124,6 +131,6 @@ export class RegistryObserver {
         if (result.kind !== "valid" || result.event.regid !== regid || !result.event.issuer) {
             throw new Error("Corrupt observer registry inception.");
         }
-        return new RegistryEventer(this.db, result.event.issuer, this.store, regid);
+        return new RegistryEventer(this.db, result.event.issuer, this.store, regid, this.cues);
     }
 }

package/esm/keri/npm/src/acdc/query-resend.js

@@ -0,0 +1,74 @@
+/**
+ * Resend schedule for a group's threshold DH or Unblind query.
+ *
+ * A single signer re-dates every resend (`Dhke.requery`, `Unblind.requery`), so a resend is a new query the peer's
+ * KRAM accepts. A group cannot: re-dating needs the members' signatures, so the frozen query is resent as the same
+ * bytes. The peer's KRAM drops identical copies cheaply only while its replay cache row lives, and once the query's
+ * `dt` is older than the multi-key acceptance window it refuses every copy as untimely. This schedule therefore
+ * backs off and stops resending an unchanged query when the peer can no longer accept it. It never ends the
+ * operation: the owner keeps waiting until its own deadline, exactly as before.
+ */
+import { parseBytes } from "cesr-ts";
+import { ValidationError } from "../core/errors.js";
+import { timestampMicros } from "../time/mod.js";
+/** Milliseconds between the first resends of a query, and the shortest gap a receiver re-sends a stored reply. */
+export const QUERY_RESEND_MS = 1000;
+/** The longest gap the backoff reaches, in milliseconds. */
+export const QUERY_RESEND_CAP_MS = 8000;
+/** One group operation's frozen threshold query and when it may next be sent; memory only. */
+export class ThresholdQueryResend {
+    constructor() {
+        /** The frozen signed query, unchanged on every resend; absent until the members' contributions complete it. */
+        Object.defineProperty(this, "query", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "queryAt", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "next", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "wait", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+    }
+    /** Take the frozen query and restart the schedule; its own `dt` is what the acceptance window is measured from. */
+    set(query) {
+        const body = parseBytes(query)[0]?.body;
+        const micros = timestampMicros(body?.sad?.dt);
+        if (micros === null)
+            throw new ValidationError("Threshold query has no valid date");
+        this.query = query;
+        this.queryAt = Number(micros / 1000n);
+        this.next = 0;
+        this.wait = 0;
+    }
+    /** Whether a query is frozen and the running gap has elapsed at `now` (epoch ms). */
+    ready(now) {
+        return !!this.query && now >= this.next;
+    }
+    /**
+     * Whether the query is still younger than `windowMs` at `now`; past it a receiver can no longer accept the
+     * unchanged query, so it is not sent again. A null window (this store never ran KRAM) never closes.
+     */
+    fresh(now, windowMs) {
+        return windowMs === null || now - this.queryAt < windowMs;
+    }
+    /** Record a send at `now`: the next gap doubles from `baseMs` up to {@link QUERY_RESEND_CAP_MS}. */
+    sent(now, baseMs) {
+        this.wait = this.wait ? Math.max(baseMs, Math.min(this.wait * 2, QUERY_RESEND_CAP_MS)) : baseMs;
+        this.next = now + this.wait;
+    }
+}

package/esm/keri/npm/src/acdc/regengine.js

@@ -2,14 +2,18 @@
 import { Diger, Ilks, NumberPrimitive, } from "cesr-ts";
 import { DatabaseNotOpenError, DatabaseOperationError } from "../core/errors.js";
 import { consoleLogger } from "../core/logger.js";
+import { missingAnchorCue, missingAnchorQuery } from "../core/missing-anchor-query.js";
 import { findRegistryAnchor, validateRegistrySourceLocators, validateRip, validateUpdate, verifyRegistryAnchor, } from "./regeventing.js";
 /**
  * Borrow the issuer's accepted KEL and registry store; no keys or handles are acquired.
  * The local facade and foreign observer share this accepted-state engine.
  * Publication is atomic; binding this instance happens only after successful commit.
+ * An event that first enters the anchor escrow publishes one issuer KEL `logs` query to `cues` after that write.
  */
 export class RegistryEventer {
-    constructor(db, issuer, store, regk = null) {
+    constructor(db, issuer, store, regk = null, 
+    /** Application cue flow for missing-anchor queries; null for a local issuer, whose own KEL holds every anchor. */
+    cues = null) {
         Object.defineProperty(this, "db", {
             enumerable: true,
             configurable: true,
@@ -34,6 +38,12 @@ export class RegistryEventer {
             writable: true,
             value: regk
         });
+        Object.defineProperty(this, "cues", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: cues
+        });
     }
     /** Validated accepted head metadata; local construction may inspect it without duplicating acceptance checks. */
     get acceptedHeadEvent() {
@@ -234,6 +244,9 @@ export class RegistryEventer {
         const decision = this.processOne(serder, locators);
         if (decision.kind === "accept")
             this.processQueued();
+        // The escrow row is committed; ask the issuer's KEL holders for what the anchor needs through the ordinary cue path.
+        if (decision.kind === "escrow" && decision.query)
+            this.cues?.push(missingAnchorCue(decision.query));
         return decision;
     }
     /** Decide and persist one event; callers own subsequent chain progression. */
@@ -269,10 +282,8 @@ export class RegistryEventer {
                 return previous;
             this.store.putEvent(serder);
             this.discoverAnchor(event);
-            if (!this.store.anchor(event.said)) {
-                this.store.escrowMissingAnchor(event.regid, Number(event.sn), event.said);
-                return { kind: "escrow", reason: "anchor", event };
-            }
+            if (!this.store.anchor(event.said))
+                return this.escrowAnchorless(event, locators);
             this.store.baser.maes.rem(event.regid, Number(event.sn), [event.said]);
             if (!prior) {
                 this.store.escrowOutOfOrder(event.regid, Number(event.sn), event.said);
@@ -314,10 +325,8 @@ export class RegistryEventer {
                 throw new Error("Registry head exists without its accepted inception.");
             this.store.putEvent(serder);
             this.discoverAnchor(event);
-            if (!this.store.anchor(event.said)) {
-                this.store.escrowMissingAnchor(event.regid, 0, event.said);
-                return { kind: "escrow", reason: "anchor", event };
-            }
+            if (!this.store.anchor(event.said))
+                return this.escrowAnchorless(event, locators);
             this.commit(event);
             return { kind: "accept", event };
         });
@@ -325,6 +334,27 @@ export class RegistryEventer {
             this.regk = event.regid;
         return decision;
     }
+    /**
+     * Retain an event whose anchoring issuer KEL event is not accepted yet and decide whether to ask for it.
+     *
+     * The decision names the missing KEL only when this call put the event into the anchor escrow; retries and repeat
+     * arrivals find the row present. A source seal naming this issuer supplies the anchor's sequence number, and the
+     * highest one bounds the replay; without one the query names only where the recipient's KEL ends.
+     */
+    escrowAnchorless(event, locators) {
+        const added = this.store.escrowMissingAnchor(event.regid, Number(event.sn), event.said);
+        const decision = { kind: "escrow", reason: "anchor", event };
+        if (!added)
+            return decision;
+        const seals = [
+            ...(locators.sscs ?? []).map((seal) => seal.s.num),
+            ...(locators.ssts ?? []).filter((seal) => seal.i.qb64 === this.issuer).map((seal) => seal.s.num),
+        ];
+        const anchor = seals.length ? seals.reduce((high, sn) => (sn > high ? sn : high)) : null;
+        const accepted = this.db.getKever(this.issuer, { refresh: true })?.sner.num ?? null;
+        const query = missingAnchorQuery(this.issuer, accepted, anchor);
+        return query ? { ...decision, query } : decision;
+    }
     /** Replay is read-only; first acceptance repeats this check under its write transaction. */
     acceptedEvent(event) {
         const existing = this.acceptedAt(event.regid, Number(event.sn));

package/esm/keri/npm/src/acdc/regeventing.js

@@ -150,8 +150,9 @@ function sealDigests(event) {
 export function findRegistryAnchor(db, issuer, registry) {
     let earliest = null;
     for (const event of currentRegistryBranch(db, issuer)) {
-        if (db.fullyWitnessed(event)
-            && event.seals.some((seal) => matchesRegistrySeal(seal, registry))) {
+        // Seal test first: fullyWitnessed walks back to the governing establishment, so it runs only on matches.
+        if (event.seals.some((seal) => matchesRegistrySeal(seal, registry))
+            && db.fullyWitnessed(event)) {
             earliest = [event.sn, event.said];
         }
     }
@@ -161,7 +162,8 @@ export function findRegistryAnchor(db, issuer, registry) {
 function findDigestAnchor(db, issuer, digest) {
     let earliest = null;
     for (const event of currentRegistryBranch(db, issuer)) {
-        if (db.fullyWitnessed(event) && sealDigests(event).includes(digest)) {
+        // Seal test first: fullyWitnessed walks back to the governing establishment, so it runs only on matches.
+        if (sealDigests(event).includes(digest) && db.fullyWitnessed(event)) {
             earliest = [event.sn, event.said];
         }
     }

package/esm/keri/npm/src/acdc/unblinding.js

@@ -25,6 +25,7 @@ import { query, reply } from "../core/protocol-eventing.js";
 import { messagize } from "../core/protocol-serialization.js";
 import { fetchStoredTsgs, unverifiedReplyDecision } from "../core/routing.js";
 import { prepareNests, publishNests } from "../db/exchange/exchange-nests.js";
+import { QUERY_RESEND_MS } from "./query-resend.js";
 import { validateUpdate, verifyRegistryAnchor, vet, vetBlind, vetBound, } from "./regeventing.js";
 import { publicOpeningAttachment } from "./registering.js";
 /** Ordinary registry states an Unblind operation may reveal unless its approval names others. */
@@ -89,7 +90,7 @@ const KEL_ASK_MS = 5000;
  */
 export class Unblind {
     /** Bind the exact Grant verifier's store; the state vocabulary is chosen per approved operation. */
-    constructor({ hab, exc, registry, rvy = hab.rvy, kram = true }) {
+    constructor({ hab, exc, registry, rvy = hab.rvy, now = Date.now, kram = true }) {
         Object.defineProperty(this, "resource", {
             enumerable: true,
             configurable: true,
@@ -162,7 +163,14 @@ export class Unblind {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "now", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.kram = kram;
+        this.now = now;
         if (!(hab instanceof Hab) || hab.db !== exc.hby.db || registry.db !== hab.db || rvy.db !== hab.db
             || exc.hby.habs.get(hab.pre) !== hab) {
             throw new ValidationError("Unblind requires a local signing habitat");
@@ -228,6 +236,8 @@ export class Unblind {
             scope: new Map([...context.registries].map(([regid, nodes]) => [regid, [...nodes]])),
             query: null,
             reply: null,
+            accepted: null,
+            repliedAt: 0,
             requested: null,
             selected: null,
             openings: new Map(),
@@ -389,6 +399,11 @@ export class Unblind {
             if (own && (!op.proposal || !bytesEqual(op.proposal, serder.raw))) {
                 throw new ValidationError("Own Unblind query lacks its exact locally approved proposal");
             }
+            // A group re-sends its frozen query unchanged (one member cannot re-date it), and KERIpy resends identical
+            // bytes. The wire, attachments and evidence included, is compared against the one already authenticated, so
+            // a copy is never trusted on its body or SAID alone.
+            if (!own && op.accepted && bytesEqual(op.accepted, this.queryWire(envelope)))
+                return this.duplicateQuery(op);
             if (!verifyQueryAttachments(this.hab.db, envelope))
                 return { kind: "drop", reason: "missingAuthentication" };
             if (op.requested && !sameSelection(op.requested, selected)) {
@@ -429,9 +444,11 @@ export class Unblind {
             op.requestedByPeer = true;
             // KRAM now holds this query as seen, so a resend of it is a replay and a group cannot re-date it: the
             // owed reply must outlive this owner. The accepted request is the durable record; the operation is a cache.
-            this.hab.db.heldu.pin([this.hab.pre, op.xid], auxiliaryQueryWire(envelope, this.publicEvents(envelope.nests)));
+            const wire = this.queryWire(envelope);
+            this.hab.db.heldu.pin([this.hab.pre, op.xid], wire);
             if (!this.group)
                 this.respond(op.xid);
+            op.accepted = wire;
             return { kind: "accept" };
         }
         catch (error) {
@@ -533,9 +550,27 @@ export class Unblind {
             }
             op.reply = signed;
         }
-        this.outgoing.push({ kin: "reply", dest: op.recipient, msg: op.reply.slice() });
+        this.emitReply(op);
         return op.reply.slice();
     }
+    /** The query as held and compared: its frame, every attachment group, the public evidence and KRAM's normalized proof. */
+    queryWire(envelope) {
+        return auxiliaryQueryWire(envelope, this.publicEvents(envelope.nests));
+    }
+    /**
+     * A copy of the accepted query: nothing is verified or derived again. If the reply exists it is queued again for
+     * a peer that lost it, at most once per {@link QUERY_RESEND_MS}.
+     */
+    duplicateQuery(op) {
+        if (op.reply && this.now() - op.repliedAt >= QUERY_RESEND_MS)
+            this.emitReply(op);
+        return { kind: "accept" };
+    }
+    /** Queue the stored reply for the recipient and note when. */
+    emitReply(op) {
+        this.outgoing.push({ kin: "reply", dest: op.recipient, msg: op.reply.slice() });
+        op.repliedAt = this.now();
+    }
     /** Independently vet openings before caching them; Revery owns signature threshold and BADA. */
     processReply({ serder, diger, route, cigars = [], tsgs = [], attachments }) {
         try {

package/esm/keri/npm/src/app/delivery/forwarding.js

@@ -5,6 +5,7 @@ import { Deck } from "../../core/deck.js";
 import { ValidationError } from "../../core/errors.js";
 import { exchange } from "../../core/exchange/protocol-exchanging.js";
 import { Roles } from "../../core/roles.js";
+import { holdsHeads, kelHeads } from "../mailbox/kel-publishing.js";
 import { mailboxTopicKey } from "../mailbox/mailboxing.js";
 import { transportMailboxTopic } from "../mailbox/topic-routing.js";
 import { localGroupMember } from "../multisig/group-members.js";
@@ -690,6 +691,32 @@ export class Poster {
         }
         return remoteCesrTarget(endpoint, evt.msg);
     }
+    /**
+     * Whether the configured relay is already known to hold what it needs to verify `signer`'s `/fwd` wrappers, so
+     * the whole-KEL introduction can be left out.
+     *
+     * The relay verifies a wrapper against the signer's current key state, which the signer's latest establishment
+     * event fixes; interaction events do not change it. The evidence is `Baser.kpub`, the record the KEL publisher
+     * keeps per (identifier, mailbox) of the establishment event whose KEL (delegation chain included, and only once a
+     * delegated establishment is anchored) the mailbox was last given. The relay is the signer's mailbox, so the
+     * publisher and the mailbox admin request keep that record. Any other endpoint, and any mismatch or missing
+     * record, keeps today's full introduction.
+     *
+     * Known limit: a 2xx is not acceptance, and a relay that lost its store answers a `/fwd` from a sender it no
+     * longer knows with the same 204 acknowledgement and drops it. Nothing in the `/fwd` path signals that today; the
+     * sender's next mailbox poll gets the relay's 403, which makes `KelPublisher` clear the record and repost the KEL.
+     * Wrappers sent in between are lost until then.
+     *
+     * @param signer Local habitat that signs the wrapper (a group's local member).
+     * @param eid Endpoint AID the prepared wire goes to.
+     * @returns True only when `eid` is the relay and the record holds `signer`'s current establishment heads.
+     */
+    relayHoldsKel(signer, eid) {
+        if (!this.relay || this.relay.aid !== eid || !signer.pre)
+            return false;
+        const heads = kelHeads(this.hby, signer.pre);
+        return !!heads && holdsHeads(this.hby.db.kpub.get([signer.pre, eid]), heads);
+    }
     /**
      * Prepare complete signed wire and its introduction before opening transport.
      *
@@ -726,7 +753,7 @@ export class Poster {
         const forwarded = [];
         for (const child of frames)
             forwarded.push(yield* buildForwardedDelivery(signer, { recipient, topic, child }));
-        const intro = introduce(signer, endpoint.eid);
+        const intro = this.relayHoldsKel(signer, endpoint.eid) ? new Uint8Array() : introduce(signer, endpoint.eid);
         let message = concatBytes(intro, ...forwarded);
         if (evt.kin === "stream") {
             // This node's own wrappers around already-decoded children: a parse failure here is a fault.

package/esm/keri/npm/src/app/ipex/group-issuance.js

@@ -46,10 +46,12 @@ import { call } from "effection";
 import { RegistryAuthor } from "../../acdc/authoring.js";
 import { RegistryCustody } from "../../acdc/custody.js";
 import { Dhke, grantTransactionId } from "../../acdc/dhking.js";
+import { ThresholdQueryResend } from "../../acdc/query-resend.js";
 import { vet } from "../../acdc/regeventing.js";
 import { RegistryRoot } from "../../acdc/salting.js";
 import { ValidationError } from "../../core/errors.js";
 import { Kever } from "../../core/kel/kever.js";
+import { multiKeyQueryWindow } from "../../core/mailbox/kram-policy.js";
 import { messagize } from "../../core/protocol-serialization.js";
 import { loadNests } from "../../db/exchange/exchange-nests.js";
 import { timestampMicros } from "../../time/mod.js";
@@ -613,17 +615,12 @@ export class GroupIssuance {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "query", {
+        /** The frozen threshold query and its resend schedule; a group cannot re-date it (`Dhke.requery` refuses groups). */
+        Object.defineProperty(this, "resend", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "nextQuery", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0
+            value: new ThresholdQueryResend()
         });
         Object.defineProperty(this, "nextProofScan", {
             enumerable: true,
@@ -651,6 +648,13 @@ export class GroupIssuance {
             writable: true,
             value: void 0
         });
+        /** What the Grant send's proof support carried; absent when this operation did not send it (rebuilt after a restart). */
+        Object.defineProperty(this, "supportMark", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "mode", {
             enumerable: true,
             configurable: true,
@@ -886,7 +890,9 @@ export function* stepGroup(ops, op) {
         const input = deps.exc.retainedInput(grant, { pending: true });
         const frame = parseBytes(messagize(input.serder, { tsgs: input.tsgs, cigars: input.cigars, gvrsn: Vrsn_2_0 }))[0];
         frame.nests = [...input.nests ?? []];
-        const full = concatBytes(ops.discloser.proofSupport(g.nodeBytes, hab), yield* wire(frame));
+        const support = ops.discloser.proofSupport(g.nodeBytes, hab);
+        g.supportMark = ops.discloser.proofSupportMark(g.nodeBytes, hab);
+        const full = concatBytes(support, yield* wire(frame));
         for (const peer of party.others())
             yield* send(peer, full);
         if (issuer) {
@@ -940,13 +946,17 @@ export function* stepGroup(ops, op) {
             yield* broadcast(yield* party.wrap(child, MULTISIG_RPY_ROUTE));
         }
         else if (message.kin === "query")
-            g.query = message.msg;
+            g.resend.set(message.msg);
         else
             yield* send(message.dest, message.msg, "credential");
     }
-    if (g.query && deps.clock.now() >= g.nextQuery && !dh.complete(xid)) {
-        yield* send(g.grant.sad.ri, g.query, "credential");
-        g.nextQuery = deps.clock.now() + (deps.queryResendMs ?? ISSUANCE_QUERY_RESEND_MS);
+    // The unchanged query is resent with backoff while the holder can still accept it; the operation keeps waiting
+    // for the holder past that, to its own deadline.
+    const now = deps.clock.now(), base = deps.queryResendMs ?? ISSUANCE_QUERY_RESEND_MS;
+    if (g.resend.ready(now) && g.resend.fresh(now, multiKeyQueryWindow(deps.hby.db, Dhke.Route))
+        && !dh.complete(xid)) {
+        yield* send(g.grant.sad.ri, g.resend.query, "credential");
+        g.resend.sent(now, base);
     }
     if (!lead || !dh.complete(xid))
         return false;
@@ -980,7 +990,11 @@ export function* stepGroup(ops, op) {
     if (!deps.exc.complete(grant))
         throw new ValidationError("Issued group Grant remains unaccepted");
     const completed = parseBytes(yield* storedBytes(deps.exc, grant))[0];
-    const support = ops.discloser.proofSupport(g.nodeBytes, hab);
+    // The Grant send already carried the support; proving added the anchoring event and the registry update. An
+    // operation without a mark did not send it, so it sends in full.
+    const support = g.supportMark
+        ? ops.discloser.proofSupportSince(g.nodeBytes, hab, g.supportMark)
+        : ops.discloser.proofSupport(g.nodeBytes, hab);
     // KERIpy form: the elected member shares the proof with the other members by mailbox.
     const wrapped = yield* party.wrap(completed, MULTISIG_IPEX_PROOF_ROUTE);
     // Kept locally, so the proof the members received is the one {@link groupIssuanceProof} exports.

package/esm/keri/npm/src/app/ipex/ipex-discloser.js

@@ -235,6 +235,56 @@ export class IpexDiscloser {
      * name. Reads accepted state only and signs nothing, so it needs no keys.
      */
     proofSupportFor(raw, parties) {
+        const { ordered, registries } = this.supportSelection(raw, parties);
+        const messages = [Counter.makeGVC(Vrsn_2_0)];
+        // Keep first-seen authorizers and exact stored attachments, including superseded history.
+        // clonePreIter skips broken rows; finite disclosure must instead fail if an accepted row cannot be replayed.
+        for (const aid of ordered)
+            messages.push(...this.supportKel(aid, 0));
+        for (const regid of registries)
+            messages.push(this.registry.cloneTel(regid));
+        return concatBytes(...messages);
+    }
+    /**
+     * Record how far `proofSupport(raw, hab)` reaches right now: each KEL's last first-seen ordinal and each
+     * registry's last TEL ordinal. Call it in the same synchronous turn as the send it describes, so the mark is
+     * exactly what that send carried; {@link proofSupportSince} then sends what accepted state has gained.
+     */
+    proofSupportMark(raw, hab) {
+        const { ordered, registries } = this.supportSelection(raw, [hab.pre]);
+        const kels = new Map(), tels = new Map();
+        for (const aid of ordered) {
+            let last = -1;
+            for (const [, fn] of this.hby.db.fels.getAllItemIter(aid))
+                last = fn;
+            kels.set(aid, last);
+        }
+        for (const regid of registries) {
+            let last = -1;
+            for (const [, sn] of this.registry.baser.tels.getAllItemIter(regid))
+                last = sn;
+            tels.set(regid, last);
+        }
+        return { kels, tels };
+    }
+    /**
+     * The part of `proofSupport(raw, hab)` that accepted state gained after `mark` was taken, in the same order and
+     * with the same stored attachments: later first-seen KEL events of each identifier (the anchoring interaction
+     * event of a registry update, say) and later TEL events of each registry. An identifier or registry the mark does
+     * not name (support that grew a new party) is carried whole. A recipient that holds what `mark` describes holds
+     * the same state after this as after a second full `proofSupport`.
+     */
+    proofSupportSince(raw, hab, mark) {
+        const { ordered, registries } = this.supportSelection(raw, [hab.pre]);
+        const messages = [Counter.makeGVC(Vrsn_2_0)];
+        for (const aid of ordered)
+            messages.push(...this.supportKel(aid, (mark.kels.get(aid) ?? -1) + 1));
+        for (const regid of registries)
+            messages.push(this.registry.cloneTel(regid, (mark.tels.get(regid) ?? -1) + 1));
+        return concatBytes(...messages);
+    }
+    /** The identifiers (each after its delegation ancestry) and registries that support for `raw` and `parties` names. */
+    supportSelection(raw, parties) {
         const aids = new Set(parties), registries = new Set();
         for (const frame of parseBytes(raw)) {
             if (!(frame.body instanceof SerderACDC))
@@ -256,7 +306,6 @@ export class IpexDiscloser {
                     aids.add(seal.i.qb64);
             }
         }
-        const messages = [Counter.makeGVC(Vrsn_2_0)];
         const db = this.hby.db, ordered = new Set();
         // An ancestry claim selects supporting KELs; it does not establish delegation authority.
         for (const aid of aids) {
@@ -275,15 +324,15 @@ export class IpexDiscloser {
             for (const ancestor of ancestors.reverse())
                 ordered.add(ancestor);
         }
-        // Keep first-seen authorizers and exact stored attachments, including superseded history.
-        // clonePreIter skips broken rows; finite disclosure must instead fail if an accepted row cannot be replayed.
-        for (const aid of ordered) {
-            for (const [, fn, said] of db.fels.getAllItemIter(aid))
-                messages.push(db.cloneEvtMsg(aid, fn, said, Vrsn_2_0));
+        return { ordered, registries };
+    }
+    /** Stored first-seen events of `aid` from ordinal `from`, each with its exact stored attachments. */
+    supportKel(aid, from) {
+        const messages = [];
+        for (const [, fn, said] of this.hby.db.fels.getAllItemIter(aid, from)) {
+            messages.push(this.hby.db.cloneEvtMsg(aid, fn, said, Vrsn_2_0));
         }
-        for (const regid of registries)
-            messages.push(this.registry.cloneTel(regid));
-        return concatBytes(...messages);
+        return messages;
     }
     /** Public replay includes actual stored witness receipts; it grants no new consent. */
     kel(hab) {