keri-ts 0.11.0 → 2.0.0

package/esm/keri/npm/src/app/{notifying.js → notifications/notifying.js}

@@ -1,5 +1,5 @@
-import { ValidationError } from "../core/errors.js";
-import { createNoter, Notice } from "../db/noting.js";
+import { ValidationError } from "../../core/errors.js";
+import { createNoter, Notice } from "../../db/noting.js";
 import { Signaler } from "./signaling.js";
 export function notice(attrs, options = {}) {
     const dt = typeof options.dt === "string"
@@ -39,8 +39,8 @@ export function* openNoterForHabery(hby, options = {}) {
  * application-specific maps.
  */
 export class Notifier {
-    constructor(hby, { noter, signaler, }) {
-        Object.defineProperty(this, "hby", {
+    constructor(signator, { noter, signaler, }) {
+        Object.defineProperty(this, "signator", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -64,29 +64,20 @@ export class Notifier {
             writable: true,
             value: void 0
         });
-        this.hby = hby;
+        this.signator = signator;
         this.noter = noter;
         this.ownsSignaler = signaler === undefined;
-        this.signaler = signaler ?? new Signaler({ resources: hby.db.resources });
-        if (this.signaler.resources !== hby.db.resources) {
-            throw new RangeError("Notifier requires its Habery resource policy");
-        }
+        this.signaler = signaler ?? new Signaler();
     }
     /** Add one unread signed notice and emit a transient add signal. */
     add(attrs) {
-        const signator = this.requireSignator();
+        const signator = this.signator;
         const note = notice(attrs);
         const cigar = signator.sign(note.raw);
-        const prepared = this.prepareSignal("add", note);
-        try {
-            if (!this.noter.add(note, cigar))
-                return false;
-            prepared.publish();
-            return true;
-        }
-        finally {
-            prepared.release();
-        }
+        if (!this.noter.add(note, cigar))
+            return false;
+        this.publishSignal("add", note);
+        return true;
     }
     /** Close only a signal producer created here; the Noter and injected signalers remain borrowed. */
     close() {
@@ -107,36 +98,24 @@ export class Notifier {
         if (note.read) {
             return false;
         }
-        const signator = this.requireSignator();
+        const signator = this.signator;
         note.read = true;
         const cigar = signator.sign(note.raw);
-        const prepared = this.prepareSignal("mar", note);
-        try {
-            if (!this.noter.update(note, cigar))
-                return false;
-            prepared.publish();
-            return true;
-        }
-        finally {
-            prepared.release();
-        }
+        if (!this.noter.update(note, cigar))
+            return false;
+        this.publishSignal("mar", note);
+        return true;
     }
     /** Remove one verified notice and emit a transient remove signal. */
     remove(rid) {
         const [note] = this.requireNoticePair(rid);
-        const prepared = this.prepareSignal("rem", note);
-        try {
-            if (!this.noter.removeNotice(rid))
-                return false;
-            prepared.publish();
-            return true;
-        }
-        finally {
-            prepared.release();
-        }
+        if (!this.noter.removeNotice(rid))
+            return false;
+        this.publishSignal("rem", note);
+        return true;
     }
-    prepareSignal(action, note) {
-        return this.signaler.prepare(() => ({ action, dt: new Date().toISOString(), note: note.asDict() }), "/notification", { ckey: "/notification" });
+    publishSignal(action, note) {
+        this.signaler.push({ action, dt: new Date().toISOString(), note: note.asDict() }, "/notification", { ckey: "/notification" });
     }
     requireNoticePair(rid) {
         const pair = this.noter.getNotice(rid);
@@ -147,16 +126,10 @@ export class Notifier {
         return [this.requireVerifiedNotice(note, cigar), cigar];
     }
     requireVerifiedNotice(note, cigar) {
-        const signator = this.requireSignator();
+        const signator = this.signator;
         if (!signator.verify(note.raw, cigar)) {
             throw new ValidationError(`Notification ${note.rid} failed signator verification.`);
         }
         return note;
     }
-    requireSignator() {
-        if (!this.hby.signator) {
-            throw new ValidationError("Notifications require an available habery signator.");
-        }
-        return this.hby.signator;
-    }
 }

package/esm/keri/npm/src/app/notifications/signaling.js

@@ -0,0 +1,177 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    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 __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 _Signal_raw, _Signal_pad, _Signal_ckey;
+import { MtrDex, Salter } from "cesr-ts";
+import { runtimeTurn } from "../runtime/runtime-turn.js";
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+function randomNonce() {
+    const raw = crypto.getRandomValues(new Uint8Array(16));
+    return new Salter({ code: MtrDex.Salt_128, raw }).qb64;
+}
+function encodePad(pad) {
+    return textEncoder.encode(JSON.stringify(pad));
+}
+function decodePad(raw) {
+    return JSON.parse(textDecoder.decode(raw));
+}
+/**
+ * Transient host signal matching the KERIpy `Signal` pad shape.
+ *
+ * Unlike `Notice`, this is not durably stored. Hosts use it as a reload hint.
+ */
+export class Signal {
+    constructor(init) {
+        _Signal_raw.set(this, void 0);
+        _Signal_pad.set(this, void 0);
+        _Signal_ckey.set(this, void 0);
+        if ("raw" in init) {
+            __classPrivateFieldSet(this, _Signal_ckey, init.ckey, "f");
+            this.raw = init.raw;
+            return;
+        }
+        __classPrivateFieldSet(this, _Signal_ckey, init.ckey, "f");
+        this.pad = init.pad;
+    }
+    get raw() {
+        return new Uint8Array(__classPrivateFieldGet(this, _Signal_raw, "f"));
+    }
+    set raw(raw) {
+        this.pad = decodePad(raw);
+    }
+    get pad() {
+        return {
+            ...__classPrivateFieldGet(this, _Signal_pad, "f"),
+            a: { ...__classPrivateFieldGet(this, _Signal_pad, "f").a },
+        };
+    }
+    set pad(pad) {
+        const normalized = {
+            i: typeof pad.i === "string" && pad.i.length > 0 ? pad.i : randomNonce(),
+            dt: typeof pad.dt === "string" && pad.dt.length > 0
+                ? pad.dt
+                : new Date().toISOString(),
+            r: pad.r,
+            a: { ...pad.a },
+        };
+        __classPrivateFieldSet(this, _Signal_pad, normalized, "f");
+        __classPrivateFieldSet(this, _Signal_raw, encodePad(normalized), "f");
+    }
+    get rid() {
+        return __classPrivateFieldGet(this, _Signal_pad, "f").i;
+    }
+    get datetime() {
+        return __classPrivateFieldGet(this, _Signal_pad, "f").dt;
+    }
+    get topic() {
+        return __classPrivateFieldGet(this, _Signal_pad, "f").r;
+    }
+    get attrs() {
+        return { ...__classPrivateFieldGet(this, _Signal_pad, "f").a };
+    }
+    get ckey() {
+        return __classPrivateFieldGet(this, _Signal_ckey, "f");
+    }
+    asDict() {
+        return this.pad;
+    }
+}
+_Signal_raw = new WeakMap(), _Signal_pad = new WeakMap(), _Signal_ckey = new WeakMap();
+export function signal(attrs, topic, options = {}) {
+    const dt = typeof options.dt === "string"
+        ? options.dt
+        : options.dt?.toISOString();
+    return new Signal({
+        pad: {
+            i: "",
+            dt,
+            r: topic,
+            a: attrs,
+        },
+        ckey: options.ckey,
+    });
+}
+/** Transient reload hints with KERIpy-style collapse keys and expiry. */
+export class Signaler {
+    constructor({ signals = [], signalTimeoutMs = Signaler.SignalTimeoutMs } = {}) {
+        Object.defineProperty(this, "signalTimeoutMs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "signals", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "closed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        if (!Number.isFinite(signalTimeoutMs) || signalTimeoutMs < 0)
+            throw new RangeError("Invalid signal timeout");
+        this.signalTimeoutMs = signalTimeoutMs;
+        this.signals = [...signals];
+    }
+    /** Replace the first matching collapse key in place, otherwise append. */
+    push(attrs, topic, options = {}) {
+        if (this.closed)
+            throw new Error("Signaler is closed");
+        const created = signal(attrs, topic, options);
+        const index = options.ckey === undefined ? -1 : this.signals.findIndex((current) => current.ckey === options.ckey);
+        if (index >= 0)
+            this.signals[index] = created;
+        else
+            this.signals.push(created);
+        return created;
+    }
+    list() {
+        return this.signals.map((current) => new Signal({ raw: current.raw, ckey: current.ckey }));
+    }
+    count() {
+        return this.signals.length;
+    }
+    processOnce(now = Date.now()) {
+        const before = this.signals.length;
+        for (let index = this.signals.length - 1; index >= 0; index--) {
+            const time = new Date(this.signals[index].datetime).getTime();
+            if (Number.isNaN(time) || now - time > this.signalTimeoutMs)
+                this.signals.splice(index, 1);
+        }
+        return before - this.signals.length;
+    }
+    /** Drop transient wakeups without changing durable notices. */
+    clear() {
+        this.signals.length = 0;
+    }
+    /** Stop this producer and discard its queued wakeups. */
+    close() {
+        this.closed = true;
+        this.clear();
+    }
+    *signalDo() {
+        while (true) {
+            this.processOnce();
+            yield* runtimeTurn();
+        }
+    }
+}
+Object.defineProperty(Signaler, "SignalTimeoutMs", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: 10 * 60 * 1000
+});

package/esm/keri/npm/src/app/{parsering.js → protocol/parsering.js}

@@ -1,12 +1,12 @@
-import { BlindState, BoundState, Cigar, Dater, Diger, FirstSeen, Ilks, isCounterGroupLike, isGroupTuple, Labeler, Noncer, NumberPrimitive, parseSerder, Prefixer, requireFlatFrame, SealEvent, SealKind, SealSource, SerderACDC, SerderKERI, Siger, Texter, TypeMedia, Verfer, Verser, } from "cesr-ts";
-import { KeriDispatchEnvelope, PathedMaterialGroup, TransIdxSigGroup, TransLastIdxSigGroup, TransReceiptQuadruple, } from "../core/dispatch.js";
-import { kramReceipt } from "../core/kraming.js";
-import { nestedIpexRoute, nestedMultisigIlks } from "../core/protocol-exchanging.js";
+import { BlindState, BoundState, Cigar, concatBytes, Counter, Dater, Diger, FirstSeen, Ilks, isCounterGroupLike, isGroupTuple, Labeler, Noncer, NumberPrimitive, parseBytes, parseSerder, Prefixer, requireFlatFrame, SealEvent, SealKind, SealSource, SerderACDC, SerderKERI, Siger, Texter, TypeMedia, Verfer, Verser, } from "cesr-ts";
+import { KeriDispatchEnvelope, PathedMaterialGroup, TransIdxSigGroup, TransLastIdxSigGroup, TransReceiptQuadruple, } from "../../core/dispatch.js";
+import { nestedIpexRoute, supportsNestedExchange } from "../../core/exchange/protocol-exchanging.js";
+import { serializeMessage } from "../../core/protocol-serialization.js";
 /**
  * Convert one or more already-parsed CESR frames into KERI dispatch envelopes.
  *
  * Architectural rule:
- * - CESR parsing belongs to the real progressive CESR parser
+ * - CESR parsing belongs to the buffered finite CESR decoder
  * - KERI normalization belongs here
  * - routing into `Revery` / `Kevery` / `Exchanger` happens separately via
  *   `dispatchEnvelope(...)`
@@ -17,33 +17,66 @@ export function envelopesFromFrames(frames, local = false) {
 /**
  * Route one already-parsed KERI dispatch envelope into the established
  * `Revery` / `Kevery` / `Exchanger` architecture.
- * The optional ready consumer is scoped to v2 non-event dispatch; other messages
- * remain caller-consumed. No hydrated evidence is returned with the decision.
+ * Return ordinary buffered evidence and its decision to the application owner.
+ *
+ * @param envelope Parsed body and its exact attachment evidence.
+ * @param revery Borrowed reply-route verifier.
+ * @param kevery Input KEL processor for this dispatch.
+ * @param exchanger Optional exchange processor; absent exchange support remains explicit.
+ * @param tevery Optional legacy TEL processor.
+ * @param verifier Optional credential processor.
+ * @param mailboxAid Receiving hosted endpoint provenance, distinct from claimed sender.
+ * @param messageKevery Authoritative shared message-policy/KRAM processor when distinct from input Kevery.
+ * @param registry V2 registry intake over accepted public KEL state, without requiring a local alias.
+ * @param qvy Optional auxiliary query owner; receives full evidence after v2 message admission.
+ * @returns The processed envelope and protocol-specific decision data.
+ * @throws Unsupported input and infrastructure/handler failures follow their owning processor contracts.
  */
-export function* dispatchEnvelope(envelope, revery, kevery, exchanger, vdr = {}, mailboxAid, consume) {
+export function* dispatchEnvelope(envelope, revery, kevery, exchanger, tevery, verifier, mailboxAid, 
+/** Long-lived v2 message policy/KRAM owner; input-specific Kevery handles KEL and legacy traffic. */
+messageKevery = kevery, registry, qvy) {
     const serder = envelope.serder;
     if (serder instanceof SerderACDC) {
-        if (serder.ilk === null) {
-            vdr.vry?.processACDC?.(acdcEnvelopeFromDispatch(envelope, serder));
+        // Historical upd bytes remain decodable, but cannot enter live registry processing.
+        if (serder.ilk === Ilks.upd)
+            return { envelope, decision: { kind: "reject", reason: "event" } };
+        if (serder.ilk === Ilks.rip || serder.ilk === Ilks.bup) {
+            return {
+                envelope,
+                decision: registry?.processEvent(serder, {
+                    sscs: envelope.sscs,
+                    ssts: envelope.ssts,
+                    bsqs: envelope.bsqs,
+                    bsss: envelope.bsss,
+                })
+                    ?? { kind: "drop", reason: "missingProcessor" },
+            };
         }
-        return;
+        return {
+            envelope,
+            decision: serder.ilk === null ? verifier?.processACDC(acdcEnvelopeFromDispatch(envelope, serder)) : undefined,
+        };
     }
     if (serder.pvrsn.major >= 2
         && [Ilks.qry, Ilks.rpy, Ilks.exn, Ilks.xip, Ilks.pro, Ilks.bar].some((ilk) => ilk === serder.ilk)) {
-        return yield* dispatchMessage(envelope, revery, kevery, exchanger, vdr, mailboxAid, consume);
+        return yield* dispatchMessage(envelope, revery, messageKevery, exchanger, tevery, mailboxAid, qvy);
     }
     switch (serder.ilk) {
         case Ilks.rpy:
-            return revery.processReply({
-                serder,
-                cigars: envelope.cigars,
-                tsgs: envelope.tsgs,
-            });
+            return {
+                envelope,
+                decision: revery.processReply({
+                    serder,
+                    cigars: envelope.cigars,
+                    tsgs: envelope.tsgs,
+                    attachments: envelope,
+                }),
+            };
         case Ilks.qry:
             if (["tels", "tsn"].includes(serder.route ?? "")) {
-                return dispatchTelQuery(queryEnvelopeFromDispatch(envelope), vdr);
+                return { envelope, decision: dispatchTelQuery(queryEnvelopeFromDispatch(envelope), tevery) };
             }
-            return kevery.processQuery(queryEnvelopeFromDispatch(envelope));
+            return { envelope, decision: kevery.processQuery(queryEnvelopeFromDispatch(envelope)) };
         case Ilks.rct:
             kevery.processReceipt(envelope);
             break;
@@ -52,7 +85,7 @@ export function* dispatchEnvelope(envelope, revery, kevery, exchanger, vdr = {},
             if (serder.pvrsn.major === 1 && !envelope.tsgs.length && !envelope.cigars.length)
                 break;
             if (exchanger) {
-                return yield* dispatchExchange(envelope, exchanger, mailboxAid);
+                return { envelope, decision: yield* dispatchExchange(envelope, exchanger, mailboxAid) };
             }
             break;
         case Ilks.vcp:
@@ -61,8 +94,7 @@ export function* dispatchEnvelope(envelope, revery, kevery, exchanger, vdr = {},
         case Ilks.rev:
         case Ilks.bis:
         case Ilks.brv:
-            vdr.tvy?.processEvent?.(telEnvelopeFromDispatch(envelope, serder));
-            break;
+            return { envelope, decision: tevery?.processEvent(telEnvelopeFromDispatch(envelope, serder)) };
         case Ilks.icp:
         case Ilks.dip:
         case Ilks.rot:
@@ -89,76 +121,87 @@ export function* dispatchEnvelope(envelope, revery, kevery, exchanger, vdr = {},
                     local: envelope.local,
                 });
             }
-            return decision;
+            return { envelope, decision };
         }
         default:
             break;
     }
+    return { envelope, decision: undefined };
 }
 /**
- * Frozen processMsg boundary: sender policy precedes optional KRAM and proof
+ * processMsg boundary: sender policy precedes optional KRAM and proof
  * prerequisites and delegation. Downstream processors authenticate their own
  * evidence; this layer borrows the envelope and never owns its payloads.
  */
-function* dispatchMessage(envelope, revery, kevery, exchanger, vdr, mailboxAid, consume) {
+function* dispatchMessage(envelope, revery, kevery, exchanger, tevery, mailboxAid, qvy) {
     const serder = envelope.serder;
     const sender = serder.pre;
     if (sender !== null) {
         if (kevery.denyList.has(sender))
-            return { kind: "drop", reason: "deniedSender" };
-        if (kevery.allowList.size && !kevery.allowList.has(sender))
-            return { kind: "drop", reason: "senderNotAllowed" };
+            return { envelope, decision: { kind: "drop", reason: "deniedSender" } };
+        if (kevery.allowList.size && !kevery.allowList.has(sender)) {
+            return { envelope, decision: { kind: "drop", reason: "senderNotAllowed" } };
+        }
     }
-    let decision = undefined;
-    const dispatch = function* (ready) {
-        decision = yield* dispatchReadyMessage(ready, revery, kevery, exchanger, vdr, mailboxAid);
-        if (consume)
-            yield* consume(ready, decision);
-    };
-    const refusal = kevery.kramer ? yield* kevery.kramer.intake(envelope, dispatch) : yield* dispatch(envelope);
-    return refusal ?? decision;
+    if (serder.ilk === "qry" && !["logs", "ksn", "mbx", "tels", "tsn"].includes(serder.route ?? "")
+        && qvy?.resource !== serder.route) {
+        return { envelope, decision: { kind: "drop", reason: "missingProcessor" } };
+    }
+    const result = kevery.kramer?.intake(envelope);
+    if (result && result.kind !== "ready")
+        return { envelope, decision: result };
+    const ready = result?.kind === "ready" ? result.envelope : envelope;
+    const decision = yield* dispatchReadyMessage(ready, revery, kevery, exchanger, tevery, mailboxAid, result?.kind === "ready" ? result.receiverTime : undefined, qvy);
+    return { envelope: ready, decision };
 }
-/** Delegate inside the ready callback; downstream processors verify their own proof owners. */
-function* dispatchReadyMessage(envelope, revery, kevery, exchanger, vdr, mailboxAid) {
+/** Delegate accepted evidence; downstream processors verify their own proof owners. */
+function* dispatchReadyMessage(envelope, revery, kevery, exchanger, tevery, mailboxAid, receiverTime, qvy) {
     const serder = envelope.serder;
     switch (serder.ilk) {
         case Ilks.qry: {
+            if (qvy && !["logs", "ksn", "mbx", "tels", "tsn"].includes(serder.route ?? "")) {
+                if (!envelope.sigers.length && !envelope.ssgs.length && !envelope.tsgs.length && !envelope.cigars.length) {
+                    return { kind: "drop", reason: "missingAuthentication" };
+                }
+                return qvy.processQuery(envelope);
+            }
             const query = queryEnvelopeFromDispatch(envelope);
             if (!query.source && !query.cigars?.length)
                 return { kind: "drop", reason: "missingAuthentication" };
             if (["logs", "ksn", "mbx"].includes(serder.route ?? ""))
                 return kevery.processQuery(query);
             if (serder.route === "tels" || serder.route === "tsn") {
-                return dispatchTelQuery(query, vdr);
+                return dispatchTelQuery(query, tevery);
             }
             return { kind: "drop", reason: "unsupportedRoute" };
         }
         case Ilks.rpy:
             if (!envelope.cigars.length && !envelope.tsgs.length)
                 return { kind: "drop", reason: "missingAuthentication" };
-            return revery.processReply({ serder, cigars: envelope.cigars, tsgs: envelope.tsgs });
+            return revery.processReply({ serder, cigars: envelope.cigars, tsgs: envelope.tsgs, attachments: envelope });
+        case Ilks.xip:
         case Ilks.exn:
             if (!envelope.cigars.length && !envelope.tsgs.length && !envelope.sscs.length && !envelope.ssts.length) {
                 return { kind: "drop", reason: "missingAuthentication" };
             }
             if (!exchanger)
                 return { kind: "drop", reason: "missingProcessor" };
-            return yield* dispatchExchange(envelope, exchanger, mailboxAid);
+            return yield* dispatchExchange(envelope, exchanger, mailboxAid, receiverTime);
         default:
-            // processXip/processPro/processBar are pass stubs at the frozen reference.
+            // processPro/processBar remain pass stubs at the selected reference.
             return { kind: "drop", reason: "referenceStub" };
     }
 }
 /** Both body versions preserve requester prerequisites and the TEL owner's typed refusal. */
-function dispatchTelQuery(query, vdr) {
+function dispatchTelQuery(query, tevery) {
     if (!query.source && !query.cigars?.length)
         return { kind: "drop", reason: "missingAuthentication" };
-    if (!vdr.tvy?.processQuery)
+    if (!tevery)
         return { kind: "drop", reason: "missingProcessor" };
-    return vdr.tvy.processQuery(query);
+    return tevery.processQuery(query);
 }
 /** Await the route owner while preserving parent, child and mailbox provenance. */
-function* dispatchExchange(envelope, exchanger, mailboxAid) {
+function* dispatchExchange(envelope, exchanger, mailboxAid, receiverTime) {
     return yield* exchanger.processEvent({
         serder: envelope.serder,
         tsgs: envelope.tsgs,
@@ -168,10 +211,11 @@ function* dispatchExchange(envelope, exchanger, mailboxAid) {
         unresolvedLast: envelope.unresolvedLast,
         cigars: envelope.cigars,
         ptds: envelope.ptds,
-        essr: envelope.essr,
+        essrs: envelope.essrs,
+        gvrsn: envelope.gvrsn,
         nests: envelope.nests,
         mailboxAid,
-        receipt: kramReceipt(envelope),
+        receiverTime,
     });
 }
 function telEnvelopeFromDispatch(envelope, serder) {
@@ -203,7 +247,7 @@ function acdcEnvelopeFromDispatch(envelope, serder) {
         attachmentGroups: envelope.attachmentGroups,
         local: envelope.local,
         ptds: [...envelope.ptds],
-        essr: envelope.essr,
+        essrs: envelope.essrs,
         ssts: [...envelope.ssts],
         bsqs: [...envelope.bsqs],
         bsss: [...envelope.bsss],
@@ -395,12 +439,13 @@ function collectAttachments(group, envelope) {
             return;
     }
 }
-/** Project one complete frame for progressive routing without an intermediate event array. */
+/** Project one complete frame for message routing without an intermediate event array. */
 export function envelopeFromFrame(message, local = false) {
     // Only completed consumers may retain parent-owned children through normalization.
     const route = String(message.body.ked?.r ?? "");
-    if (message.body.ilk !== "exn" || message.body.pvrsn.major < 2
-        || (route !== "/fwd" && !nestedMultisigIlks(route) && !nestedIpexRoute(route))) {
+    const unblindQuery = message.body.ilk === "qry" && message.body.pvrsn.major === 2 && route === "/ipex/unblind";
+    if (!unblindQuery && ((message.body.ilk !== "exn" && !(message.body.ilk === "xip" && nestedIpexRoute(route)))
+        || !supportsNestedExchange(route, message.body.pvrsn.major))) {
         requireFlatFrame(message, "KERI runtime normalization");
     }
     const serder = (message.body instanceof SerderKERI || message.body instanceof SerderACDC)
@@ -409,7 +454,8 @@ export function envelopeFromFrame(message, local = false) {
     const envelope = new KeriDispatchEnvelope({
         serder,
         attachmentGroups: message.attachments,
-        essr: message.essr,
+        essrs: message.essrs,
+        gvrsn: message.gvrsn,
         nests: message.nests,
         local,
     });
@@ -418,6 +464,29 @@ export function envelopeFromFrame(message, local = false) {
     }
     return envelope;
 }
+/** Own an auxiliary query's normalized full proof and public nested evidence beyond synchronous intake. */
+export function copyAuxiliaryQuery(envelope) {
+    const version = envelope.gvrsn ?? envelope.serder.gvrsn ?? envelope.serder.pvrsn;
+    const copyFrame = (body, groups, genus, nests) => {
+        const frame = parseBytes(concatBytes(Counter.makeGVC(genus), body.raw, Counter.enclose({
+            code: "AttachmentGroup",
+            version: genus,
+            qb64: concatBytes(...groups.map(group => group.raw)),
+        })))[0];
+        frame.nests = nests.map(child => copyFrame(child.body, child.attachments, child.gvrsn ?? genus, child.nests ?? []));
+        return frame;
+    };
+    const copied = envelopeFromFrame(copyFrame(envelope.serder, envelope.attachmentGroups, version, envelope.nests), envelope.local);
+    // One-key raw/last-establishment proofs remain in the copied groups. KRAM's
+    // completed multi-key TSG may include earlier inputs, so copy that normalized proof too.
+    const normalized = envelopeFromFrame(parseBytes(serializeMessage(envelope.serder, {
+        tsgs: envelope.tsgs,
+        gvrsn: version,
+        genusify: true,
+    }))[0]);
+    copied.tsgs.splice(0, copied.tsgs.length, ...normalized.tsgs);
+    return copied;
+}
 /** Normalize the actual query endorsements for ingress and per-request authorization. */
 export function queryEnvelopeFromDispatch(envelope) {
     const lastSsg = envelope.ssgs.at(-1);
@@ -427,6 +496,7 @@ export function queryEnvelopeFromDispatch(envelope) {
         : undefined;
     return {
         serder: envelope.serder,
+        gvrsn: envelope.gvrsn,
         source: lastSsg?.prefixer ?? rawSource,
         sigers: lastSsg ? [...lastSsg.sigers] : rawSource ? [...envelope.sigers] : [],
         cigars: [...envelope.cigars],