keri-ts 0.11.0 → 2.0.0

package/esm/keri/npm/src/{app/cli → cli/tools}/benchmark.js

@@ -1,8 +1,10 @@
 import * as dntShim from "../../_dnt.shims.js";
-import { BENCH_INPUT_LIMIT, benchmarkParser, } from "cesr-ts";
-import { abortable } from "../abortable.js";
-import { collectBytes, fileBytes, streamBytes } from "../byte-source.js";
-import { writeStdout } from "./output.js";
+import { benchmarkParser, } from "cesr-ts";
+import { abortable } from "../../app/runtime/abortable.js";
+import { collectBytes, fileBytes, streamBytes } from "../../app/transport/byte-source.js";
+import { ValidationError } from "../../core/errors.js";
+import { parseBooleanOption, parseCountOption, parseStringOption } from "../common/parsing.js";
+import { writeStdout } from "../output.js";
 /** Present complete-run metrics using the shared benchmark's measured values. */
 function formatBenchmarkText(source, result) {
     return [
@@ -19,14 +21,21 @@ function formatBenchmarkText(source, result) {
 }
 /** Retain one admitted corpus and own every input, parse, and output leaf in this operation. */
 export function* benchmarkCommand(args) {
-    const options = args;
-    const limit = options.maxBytes ?? BENCH_INPUT_LIMIT;
+    const options = {
+        inPath: parseStringOption(args.inPath, "inPath"),
+        json: parseBooleanOption(args.json, "json"),
+        iterations: parseCountOption(args.iterations, "iterations"),
+        warmupIterations: parseCountOption(args.warmupIterations, "warmupIterations"),
+        chunkSize: parseCountOption(args.chunkSize, "chunkSize"),
+    };
+    if (options.iterations === 0 || options.chunkSize === 0) {
+        throw new ValidationError("iterations and chunkSize must be positive");
+    }
     const source = options.inPath ?? "stdin";
-    const bytes = yield* abortable((signal) => collectBytes(options.inPath ? fileBytes(options.inPath, { signal }) : streamBytes(dntShim.Deno.stdin.readable, { signal }), limit));
+    const bytes = yield* abortable((signal) => collectBytes(options.inPath ? fileBytes(options.inPath, { signal }) : streamBytes(dntShim.Deno.stdin.readable, { signal })));
     const result = yield* abortable((signal) => benchmarkParser(bytes, {
         ...options,
-        maxBytes: limit,
-        parserOptions: { signal },
+        signal,
     }));
     const text = options.json ? JSON.stringify({ source, ...result }) : formatBenchmarkText(source, result);
     yield* abortable((signal) => writeStdout(`${text}\n`, signal));

package/esm/keri/npm/src/{app/cli → cli/tools}/db-dump.js

@@ -3,9 +3,9 @@ import { DatabaseOperationError, ValidationError } from "../../core/errors.js";
 import { RawRecord } from "../../core/records.js";
 import { createBaser } from "../../db/basing.js";
 import { createKeeper } from "../../db/keeping.js";
-import { createMailboxer } from "../../db/mailboxing.js";
+import { createMailboxer } from "../../db/mailbox/mailboxing.js";
 import { createNoter } from "../../db/noting.js";
-import { createOutboxer } from "../../db/outboxing.js";
+import { parseBooleanOption, parseIntegerOption, parseStringOption } from "../common/parsing.js";
 const DOMAIN_FACTORIES = {
     baser: {
         open: (options) => createBaser(options),
@@ -19,9 +19,6 @@ const DOMAIN_FACTORIES = {
     noter: {
         open: (options) => createNoter(options),
     },
-    outboxer: {
-        open: (options) => createOutboxer(options),
-    },
 };
 const DEFAULT_TARGET = "baser.evts";
 const DEFAULT_LIMIT = 50;
@@ -35,9 +32,8 @@ function parseTarget(rawTarget) {
     if (domainRaw !== "baser"
         && domainRaw !== "keeper"
         && domainRaw !== "mailboxer"
-        && domainRaw !== "noter"
-        && domainRaw !== "outboxer") {
-        throw new ValidationError(`Unknown dump domain "${domainRaw}". Expected one of: baser, keeper, mailboxer, noter, outboxer.`);
+        && domainRaw !== "noter") {
+        throw new ValidationError(`Unknown dump domain "${domainRaw}". Expected one of: baser, keeper, mailboxer, noter.`);
     }
     return {
         domain: domainRaw,
@@ -245,18 +241,17 @@ function resolveLimit(rawLimit) {
  * - `baser.ends`
  * - `mailboxer`
  * - `mailboxer.tpcs`
- * - `outboxer.tgts`
  */
 export function* dumpDatabase(args) {
-    const name = args.name;
-    const base = args.base;
-    const headDirPath = args.headDirPath;
-    const temp = args.temp;
-    const compat = args.compat;
-    const mapSize = resolveMapSize(args.mapSize);
-    const target = args.target;
-    const prefix = args.prefix;
-    const limit = resolveLimit(args.limit);
+    const name = parseStringOption(args.name, "name");
+    const base = parseStringOption(args.base, "base");
+    const headDirPath = parseStringOption(args.headDirPath, "headDirPath");
+    const temp = parseBooleanOption(args.temp, "temp");
+    const compat = parseBooleanOption(args.compat, "compat");
+    const mapSize = resolveMapSize(parseIntegerOption(args.mapSize, "mapSize"));
+    const target = parseStringOption(args.target, "target");
+    const prefix = parseStringOption(args.prefix, "prefix");
+    const limit = resolveLimit(parseIntegerOption(args.limit, "limit"));
     if (!name) {
         throw new ValidationError("`--name` is required");
     }
@@ -287,15 +282,7 @@ export function* dumpDatabase(args) {
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        throw new DatabaseOperationError(`Error dumping database: ${message}`, {
-            name,
-            base,
-            headDirPath,
-            temp,
-            compat,
-            target: target ?? DEFAULT_TARGET,
-            prefix: prefix ?? "",
-        });
+        throw new DatabaseOperationError(`Error dumping database: ${message}`, { cause: error });
     }
     finally {
         yield* domain.close();

package/esm/keri/npm/src/{app/cli → cli/tools}/saidify.js

@@ -1,11 +1,12 @@
 import * as dntShim from "../../_dnt.shims.js";
 import { Saider } from "cesr-ts";
 import { ValidationError } from "../../core/errors.js";
+import { parseStringOption } from "../common/parsing.js";
 /** Implement KLI-compatible `saidify`: mutate one JSON SAD file in place. */
 export function* saidifyCommand(args) {
     const commandArgs = {
-        file: args.file,
-        label: args.label,
+        file: parseStringOption(args.file, "file"),
+        label: parseStringOption(args.label, "label"),
     };
     if (!commandArgs.file) {
         throw new ValidationError("File is required and cannot be empty.");

package/esm/keri/npm/src/{app/cli → cli/tools}/sign.js

@@ -1,6 +1,7 @@
+import { isLocalGroupHab } from "../../app/multisig/group-members.js";
 import { ValidationError } from "../../core/errors.js";
-import { withExistingHab } from "./common/context.js";
-import { loadTextArgument } from "./common/parsing.js";
+import { withExistingHab } from "../common/context.js";
+import { loadTextArgument, parseBooleanOption, parseStringOption } from "../common/parsing.js";
 /**
  * Sign one arbitrary text payload with the habitat's current accepted keys.
  *
@@ -8,16 +9,18 @@ import { loadTextArgument } from "./common/parsing.js";
  * - prints numbered indexed signatures as `1. <qb64>`
  * - the numbering is presentation only; `tufa verify` still expects raw
  *   signature qb64 values, matching KLI
+ * - group output labels its partial member contribution; it does not collect
+ *   approval or establish that the group's threshold has been satisfied
  */
 export function* signCommand(args) {
     const signArgs = {
-        name: args.name,
-        base: args.base,
-        headDirPath: args.headDirPath,
-        passcode: args.passcode,
-        alias: args.alias,
-        compat: args.compat,
-        text: args.text,
+        name: parseStringOption(args.name, "--name"),
+        base: parseStringOption(args.base, "--base"),
+        headDirPath: parseStringOption(args.headDirPath, "--head-dir"),
+        passcode: parseStringOption(args.passcode, "--passcode"),
+        alias: parseStringOption(args.alias, "--alias"),
+        compat: parseBooleanOption(args.compat, "--compat"),
+        text: parseStringOption(args.text, "--text"),
     };
     if (!signArgs.name) {
         throw new ValidationError("Name is required and cannot be empty");
@@ -34,8 +37,11 @@ export function* signCommand(args) {
         readonly: false,
         skipConfig: true,
         skipSignator: true,
-    }, function* ({ hab }) {
+    }, function* ({ hby, hab }) {
         const sigers = hab.sign(loadTextArgument(text), true);
+        if (isLocalGroupHab(hby, hab)) {
+            console.log(`Partial multisig signature contribution for ${hab.pre}; group approval is not collected by sign.`);
+        }
         for (const [idx, siger] of sigers.entries()) {
             console.log(`${idx + 1}. ${siger.qb64}`);
         }

package/esm/keri/npm/src/{app/cli → cli/tools}/verify.js

@@ -13,8 +13,8 @@
  */
 import { Siger } from "cesr-ts";
 import { ValidationError } from "../../core/errors.js";
-import { withExistingHabery } from "./common/context.js";
-import { loadTextArgument } from "./common/parsing.js";
+import { withExistingHabery } from "../common/context.js";
+import { loadTextArgument, parseBooleanOption, parseStringListOption, parseStringOption } from "../common/parsing.js";
 /**
  * Verify one or more indexed signatures against locally accepted key state.
  *
@@ -25,14 +25,14 @@ import { loadTextArgument } from "./common/parsing.js";
  */
 export function* verifyCommand(args) {
     const verifyArgs = {
-        name: args.name,
-        base: args.base,
-        headDirPath: args.headDirPath,
-        passcode: args.passcode,
-        prefix: args.prefix,
-        compat: args.compat,
-        text: args.text,
-        signature: args.signature,
+        name: parseStringOption(args.name, "--name"),
+        base: parseStringOption(args.base, "--base"),
+        headDirPath: parseStringOption(args.headDirPath, "--head-dir"),
+        passcode: parseStringOption(args.passcode, "--passcode"),
+        prefix: parseStringOption(args.prefix, "--prefix"),
+        compat: parseBooleanOption(args.compat, "--compat"),
+        text: parseStringOption(args.text, "--text"),
+        signature: parseStringListOption(args.signature, "--signature"),
     };
     if (!verifyArgs.name) {
         throw new ValidationError("Name is required and cannot be empty");

package/esm/keri/npm/src/core/attachment-countering.js

@@ -1,4 +1,4 @@
-import { Counter, CtrDexV1, CtrDexV2, Vrsn_1_0, Vrsn_2_0 } from "cesr-ts";
+import { Counter, CtrDexV1, CtrDexV2, NumberPrimitive, Seqner, Vrsn_1_0, Vrsn_2_0 } from "cesr-ts";
 import { ValidationError } from "./errors.js";
 const MAX_SMALL_COUNTER_COUNT = 4095;
 /**
@@ -19,6 +19,36 @@ export function resolveAttachmentGvrsn(serder, gvrsn = Vrsn_1_0, nested = false)
     }
     return resolved;
 }
+/**
+ * Qualify a sequence or first-seen ordinal for an attachment of genus `gvrsn`.
+ *
+ * KERIpy `messagize` (`_v1seqner`/`_v2number`): v1 attachments carry the fixed-width
+ * `0A` Seqner, v2 attachments the smallest automatic Number code (`MAAB` for 1),
+ * whatever primitive the caller holds, so a freshly signed message and one rebuilt
+ * from storage serialize to the same bytes. Hex strings are KERI `snh` ordinals.
+ */
+export function attachmentOrdinal(ordinal, gvrsn) {
+    if (gvrsn.major === 1 && ordinal instanceof Seqner)
+        return ordinal;
+    const value = ordinal instanceof Seqner
+        ? ordinal.sn
+        : ordinal instanceof NumberPrimitive
+            ? ordinal.num
+            : hexOrdinal(ordinal);
+    if (gvrsn.major >= 2)
+        return NumberPrimitive.fromNum(value);
+    if (value >= 1n << 128n)
+        throw new ValidationError(`Ordinal ${value} exceeds the 16-byte v1 Seqner.`);
+    const raw = new Uint8Array(16);
+    for (let at = raw.length - 1, rest = value; at >= 0; at--, rest >>= 8n)
+        raw[at] = Number(rest & 0xffn);
+    return new Seqner({ code: "0A", raw });
+}
+function hexOrdinal(hex) {
+    if (!/^[0-9a-f]+$/i.test(hex))
+        throw new ValidationError(`Invalid hex ordinal ${hex}`);
+    return BigInt(`0x${hex}`);
+}
 /** Build one bare attachment counter using the code family for `gvrsn`. */
 export function attachmentCounterQb64b(name, count, gvrsn = Vrsn_1_0) {
     validateCounterCount(name, count);

package/esm/keri/npm/src/core/deck.js

@@ -3,17 +3,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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 __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 _Deck_items, _Deck_capacity;
-import { ResourceLimitError } from "cesr-ts";
-/** Hard queue backpressure, distinct from invalid protocol data or other byte limits. */
-export class DeckFullError extends ResourceLimitError {
-}
+var _Deck_items;
 /**
  * Double-ended queue with KERIpy-like naming.
  *
@@ -27,37 +17,12 @@ export class DeckFullError extends ResourceLimitError {
  *   the flow-based handoff seam between long-running Effection operations
  */
 export class Deck {
-    /** Create a queue with optional initial contents and a hard reference limit. */
-    constructor(initial, capacity = Infinity) {
+    /** Create a queue with optional initial contents. */
+    constructor(initial) {
         _Deck_items.set(this, []);
-        /** Maximum retained references; ordinary local decks remain unbounded unless configured. */
-        _Deck_capacity.set(this, Infinity);
-        this.capacity = capacity;
         if (initial)
             this.extend(initial);
     }
-    /** Current hard reference limit, including every append/prepend/extend caller. */
-    get capacity() {
-        return __classPrivateFieldGet(this, _Deck_capacity, "f");
-    }
-    /** Tighten a shared deck before admitting producers; existing entries are never discarded. */
-    set capacity(value) {
-        if (value !== Infinity && (!Number.isSafeInteger(value) || value < 0)) {
-            throw new RangeError("Invalid deck capacity");
-        }
-        if (this.length > value)
-            throw new DeckFullError("Existing deck exceeds capacity");
-        __classPrivateFieldSet(this, _Deck_capacity, value, "f");
-    }
-    /** Preflight synchronous side effects whose resulting cues must fit without losing accepted work. */
-    checkSpace(count = 1) {
-        if (!Number.isSafeInteger(count) || count < 0)
-            throw new RangeError("Invalid deck admission count");
-        if (count > __classPrivateFieldGet(this, _Deck_capacity, "f"))
-            throw new ResourceLimitError("Batch exceeds deck capacity");
-        if (count > __classPrivateFieldGet(this, _Deck_capacity, "f") - this.length)
-            throw new DeckFullError("Deck capacity exceeded");
-    }
     /** Number of queued items. */
     get length() {
         return __classPrivateFieldGet(this, _Deck_items, "f").length;
@@ -68,7 +33,6 @@ export class Deck {
     }
     /** Append one item to the tail. */
     append(item) {
-        this.checkSpace();
         __classPrivateFieldGet(this, _Deck_items, "f").push(item);
         return __classPrivateFieldGet(this, _Deck_items, "f").length;
     }
@@ -78,7 +42,6 @@ export class Deck {
     }
     /** Prepend one item to the head. */
     prepend(item) {
-        this.checkSpace();
         __classPrivateFieldGet(this, _Deck_items, "f").unshift(item);
         return __classPrivateFieldGet(this, _Deck_items, "f").length;
     }
@@ -94,11 +57,9 @@ export class Deck {
     extend(items) {
         const pending = [];
         for (const item of items) {
-            this.checkSpace(pending.length + 1);
             pending.push(item);
         }
-        // Validate the whole finite batch first: overflow or a failing iterator must leave the deck intact.
-        this.checkSpace(pending.length);
+        // Collect first so a failing iterator leaves the queue intact.
         for (const item of pending)
             __classPrivateFieldGet(this, _Deck_items, "f").push(item);
         return __classPrivateFieldGet(this, _Deck_items, "f").length;
@@ -119,7 +80,7 @@ export class Deck {
     toArray() {
         return [...__classPrivateFieldGet(this, _Deck_items, "f")];
     }
-    [(_Deck_items = new WeakMap(), _Deck_capacity = new WeakMap(), Symbol.iterator)]() {
+    [(_Deck_items = new WeakMap(), Symbol.iterator)]() {
         return __classPrivateFieldGet(this, _Deck_items, "f")[Symbol.iterator]();
     }
 }

package/esm/keri/npm/src/core/dispatch.js

@@ -167,6 +167,13 @@ export class PathedMaterialGroup {
 export class KeriDispatchEnvelope {
     /** Project parent evidence while borrowing complete child trees from the dispatch owner. */
     constructor(init) {
+        /** Resolved wire genus for faithful exchange replay. */
+        Object.defineProperty(this, "gvrsn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "serder", {
             enumerable: true,
             configurable: true,
@@ -258,7 +265,7 @@ export class KeriDispatchEnvelope {
             value: void 0
         });
         /** Shared payload views preserve parser ownership through dispatch. */
-        Object.defineProperty(this, "essr", {
+        Object.defineProperty(this, "essrs", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -304,7 +311,8 @@ export class KeriDispatchEnvelope {
         this.ssts = [...(init.ssts ?? [])];
         this.tdcs = [...(init.tdcs ?? [])];
         this.ptds = [...(init.ptds ?? [])];
-        this.essr = init.essr;
+        this.essrs = init.essrs;
+        this.gvrsn = init.gvrsn;
         this.nests = init.nests ?? [];
         this.bsqs = [...(init.bsqs ?? [])];
         this.bsss = [...(init.bsss ?? [])];

package/esm/keri/npm/src/core/errors.js

@@ -1,18 +1,13 @@
 /**
  * Base application error for `keri-ts` app/db infrastructure.
  *
- * Use subclasses to communicate the failure domain while optionally attaching
- * structured maintainer-facing context for logging or debugging.
+ * Use subclasses for the failure domain, messages for diagnostics, and standard
+ * Error.cause only for an actual underlying failure. Foreign thrown values stay
+ * opaque; domain processing never inspects them for instructions.
  */
 export class AppError extends Error {
-    constructor(message, context) {
-        super(message);
-        Object.defineProperty(this, "context", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: context
-        });
+    constructor(message, options) {
+        super(message, options);
         this.name = globalThis[Symbol.for("import-meta-ponyfill-esmodule")](import.meta).name;
     }
 }

package/esm/keri/npm/src/core/{exchange-proofing.js → exchange/exchange-proofing.js}

@@ -1,5 +1,35 @@
-import { TransIdxSigGroup } from "./dispatch.js";
-import { Kever } from "./kever.js";
+/** Independently verify EXN or disclosed-node proofs against already accepted KEL state. */
+import { Diger, NumberPrimitive } from "cesr-ts";
+import { TransIdxSigGroup } from "../dispatch.js";
+import { Kever } from "../kel/kever.js";
+/**
+ * Authenticate a named query sender independently of optional KRAM admission.
+ * Explicit sender TSGs take precedence; only their absence allows raw/last
+ * factors to resolve against current accepted establishment state. A valid
+ * alternative suffices, but missing claimed coordinates refuse, as in Python.
+ */
+export function verifyQueryAttachments(db, envelope) {
+    const { serder } = envelope;
+    let tsgs = envelope.tsgs.filter((group) => group.pre === serder.pre);
+    const kever = db.getKever(serder.pre);
+    if (!tsgs.length && kever) {
+        const sigers = [
+            ...envelope.sigers,
+            ...envelope.ssgs.filter((group) => group.pre === serder.pre)
+                .flatMap((group) => group.sigers),
+        ];
+        if (sigers.length) {
+            tsgs = [
+                new TransIdxSigGroup(kever.prefixer, NumberPrimitive.fromNum(BigInt(kever.lastEst.s)), new Diger({ qb64: kever.lastEst.d }), sigers),
+            ];
+        }
+    }
+    const verified = verifyExchangeProofs(db, serder, {
+        tsgs,
+        cigars: envelope.cigars.filter((cigar) => cigar.verfer?.qb64 === serder.pre),
+    });
+    return !verified.missing.length && !!(verified.tsgs.length || verified.cigars.length);
+}
 /**
  * Match frozen KERIpy peer.exchanging.verifyAttachments without fetching or publishing.
  * Source seals select an accepted key event containing this body's SAID.

package/esm/keri/npm/src/core/{protocol-exchanging.js → exchange/protocol-exchanging.js}

@@ -1,7 +1,24 @@
 import { concatBytes, Ilks, Kinds, makePather, NonceDex, Noncer, reapSerder, Saider, SerderKERI, Vrsn_1_0, Vrsn_2_0, } from "cesr-ts";
-import { makeNowIso8601 } from "../time/mod.js";
-import { pathedMaterialCounterQb64b } from "./attachment-countering.js";
-import { serializeMessage as serializeExchangeMessage } from "./protocol-serialization.js";
+import { makeNowIso8601 } from "../../time/mod.js";
+import { pathedMaterialCounterQb64b } from "../attachment-countering.js";
+import { serializeMessage as serializeExchangeMessage } from "../protocol-serialization.js";
+/** Narrow a wire route component before consulting version-specific policy. */
+export function isIpexVerb(value) {
+    return value === "apply"
+        || value === "offer"
+        || value === "agree"
+        || value === "grant"
+        || value === "admit"
+        || value === "spurn";
+}
+/** KERIpy acdc.ipexing PreviousRoutes, shared by v2 construction and accepted-conversation verification. */
+export const IPEX_V2_PREDECESSORS = {
+    offer: ["apply"],
+    agree: ["offer"],
+    grant: ["apply", "agree"],
+    admit: ["grant"],
+    spurn: ["apply", "offer", "agree", "grant"],
+};
 function resolveVersion(version, pvrsn, gvrsn, kind) {
     const actualPvrsn = pvrsn ?? version ?? Vrsn_1_0;
     return {
@@ -128,9 +145,17 @@ export function serializeMessage(serder, { tsgs, cigars, pathed, pipelined = fal
         gvrsn,
     });
 }
-/** Exact v2 multisig route/child-ilk contract at frozen KERIpy 927c0cb8 grouping.py:validate. */
+/** V2 TEL proposal routes share exact registry/anchor consent, not an arbitrary anchor bucket. */
+export function isV2RegistryRoute(route) {
+    return route === "/multisig/rip" || route === "/multisig/bup";
+}
+/** Selected ACDC v2 multisig routes; exact child relationships remain the coordinator's obligation. */
 export function nestedMultisigIlks(route) {
     switch (route) {
+        case "/multisig/rip":
+            return ["rip", "ixn", "rot", "drt"];
+        case "/multisig/bup":
+            return ["bup", "ixn", "rot", "drt"];
         case "/multisig/icp":
             return ["icp", "dip"];
         case "/multisig/rot":
@@ -139,11 +164,29 @@ export function nestedMultisigIlks(route) {
             return ["ixn"];
         case "/multisig/rpy":
             return ["rpy"];
+        case "/multisig/qry":
+            return ["qry"]; // Local v2 coordination profile; not an upstream KERI or #1740 route.
+        case "/multisig/ipex-proof":
+            return ["xip", "exn"]; // Local v2 coordination profile; the child is one complete Grant stream.
+        case "/multisig/exn":
+            return ["xip", "exn"];
         default:
             return null;
     }
 }
+/**
+ * Payload field carrying a v2 wrapper's signed child SAID: the route's last
+ * segment, except `/multisig/ipex-proof`, which commits its Grant as `grant`
+ * (KERIpy `Multiplexor.V2Fields`).
+ */
+export function multisigChildField(route) {
+    return route === "/multisig/ipex-proof" ? "grant" : route.slice(route.lastIndexOf("/") + 1);
+}
 /** V2 routes whose handlers own direct disclosed ACDC children. */
 export function nestedIpexRoute(route) {
     return route === "/ipex/offer" || route === "/ipex/grant";
 }
+/** Structural v2 nested-route support; handler child validation and independent proofs remain separate obligations. */
+export function supportsNestedExchange(route, protocolMajor) {
+    return protocolMajor >= 2 && (route === "/fwd" || nestedMultisigIlks(route) !== null || nestedIpexRoute(route));
+}

package/esm/keri/npm/src/core/genus-framing.js

@@ -0,0 +1,44 @@
+/** Stream genus framing for concatenated messages whose attachment genera may differ. */
+import { b64ToInt, concatBytes, Counter, smell, sniff, VersionError, Vrsn_2_0 } from "cesr-ts";
+/** Text-domain genus-version counter code; its three-character count is major plus two-character minor. */
+const GENUS_VERSION_CODE = "-_AAA";
+/** Attachment genus a stream message is framed in, or the genus a leading selector switches to. */
+function messageGenus(message) {
+    if (sniff(message) === "msg") {
+        const { pvrsn, gvrsn } = smell(message).smellage;
+        // A v2 version string may leave its genus field unset (0.00); the protocol version then governs.
+        return { genus: gvrsn && gvrsn.major > 0 ? gvrsn : pvrsn, selector: false };
+    }
+    const head = new TextDecoder().decode(message.subarray(0, 8));
+    if (head.startsWith(GENUS_VERSION_CODE) && head.length === 8) {
+        const major = b64ToInt(head[5]);
+        if (major !== 1 && major !== 2)
+            throw new VersionError(`Unsupported stream genus major ${major}`);
+        return { genus: { major, minor: b64ToInt(head.slice(6)) }, selector: true };
+    }
+    // Native CESR bodies and enclosing message groups exist only in genus 2.
+    return { genus: Vrsn_2_0, selector: false };
+}
+/**
+ * Prefix a genus-version counter wherever consecutive messages change attachment genus.
+ *
+ * Receivers keep a stream's genus across messages and change it only at a top-level
+ * genus-version counter: KERIpy starts every stream at 2.0, and keri-ts infers the
+ * first unselected body and then keeps any selection. The first message sets the
+ * stream's genus without a counter, so single-genus streams stay byte-identical; each
+ * later change carries its counter in the same chunk as the message it selects.
+ * Messages that already begin with a selector set the current genus unchanged.
+ */
+export function* genusFramed(messages) {
+    let current = null;
+    for (const message of messages) {
+        if (message.length === 0) {
+            yield message;
+            continue;
+        }
+        const { genus, selector } = messageGenus(message);
+        const changed = current !== null && (current.major !== genus.major || current.minor !== genus.minor);
+        current = genus;
+        yield changed && !selector ? concatBytes(Counter.makeGVC(genus), message) : message;
+    }
+}