keri-ts 2.0.1 → 2.2.0

package/esm/keri/npm/src/cli/messaging/multisig.js

@@ -1,18 +1,44 @@
-import { action, spawn } from "effection";
-import { resolveDelegationCommunicationHab } from "../../app/identity/delegating.js";
-import { endpointRoleAccepted, groupSigningMembers, isLocalGroupHab, localGroupMember, proposeGroupEndpointRole, } from "../../app/identity/endpoint-roleing.js";
-import { uniqueMembers } from "../../app/multisig/group-members.js";
-import { MULTISIG_ICP_ROUTE, MULTISIG_IXN_ROUTE, MULTISIG_REV_ROUTE, MULTISIG_ROT_ROUTE, MULTISIG_VCP_ROUTE, } from "../../app/multisig/grouping.js";
-import { approvePendingMultisigProposal, commitAcceptedGroupMembers, eventAccepted, publishProposal, routeForKelEvent, } from "../../app/multisig/multisig-workflows.js";
-import { runAgentRuntime } from "../../app/runtime/agent-runtime.js";
-import { Receiptor, WitnessReceiptor } from "../../app/witness/receipting.js";
+/**
+ * `tufa multisig ...` command implementation.
+ *
+ * The command surface follows KLI's group lifecycle model and calls the library's
+ * proposal API; a command only parses, resolves the user's choices, waits on the
+ * Counselor under runtime workers and returns what to print:
+ * - `incept`, `rotate`, and `interact` propose a group KEL event (`proposeGroup*`)
+ *   and publish a `/multisig/*` EXN to the other members
+ * - `join` approves one stored proposal the user consents to
+ *   (`approveGroupProposal`) and signs nothing else; see `group-join.ts`
+ */
+import { Ilks } from "cesr-ts";
+import { action } from "effection";
+import { registryEventRef, registryEventStatus, settleRegistryEvent } from "../../app/credentials/registry-settling.js";
+import { telEventStatus, waitForIssuedCredential, waitForTelEvent, } from "../../app/credentials/tel-completion.js";
+import { endpointRoleAccepted, isLocalGroupHab, localGroupMember, proposeGroupEndpointRole, } from "../../app/identity/endpoint-roleing.js";
+import { MULTISIG_REV_ROUTE, MULTISIG_ROT_ROUTE, MULTISIG_VCP_ROUTE } from "../../app/multisig/grouping.js";
+import { routeForKelEvent } from "../../app/multisig/multisig-workflows.js";
+import { proposeGroupInception, proposeGroupInteraction, proposeGroupRotation, settleProposedRotation, } from "../../app/multisig/proposing.js";
+import { observeUntil } from "../../app/runtime/workflow-contract.js";
 import { ValidationError } from "../../core/errors.js";
+import { isV2RegistryRoute } from "../../core/exchange/protocol-exchanging.js";
 import { Roles } from "../../core/roles.js";
 import { withAgentRuntime } from "../common/context.js";
 import { loadOptionObject, loadRotateFileOptions, parseBooleanOption, parseCountOption, parseDataItems, parseFileData, parseKeriVersionOption, parseNumberOption, parseStringListOption, parseStringOption, parseThresholdOption, } from "../common/parsing.js";
-import { waitForIssuedCredential, waitForTelPublication } from "../common/tel-completion.js";
-import { resolveWitnessAuths } from "../common/witness-auth.js";
-const MULTISIG_TOPIC = "multisig";
+import { withRuntimeWorkers } from "../common/runtime-workers.js";
+import { joinProposal } from "./group-join.js";
+import { counselInputs, finishAcceptedEvent, supplyDelegationProxy, supplyWitnessAuths, waitForAcceptance, } from "./group-wait.js";
+import { rootCopyLine } from "./root-copy-lines.js";
+/**
+ * Re-seal held registry roots to members an accepted group rotation added or
+ * rekeyed, as KERIpy `kli multisig rotate|join`. Runs while the command's
+ * runtime worker delivers; every outcome is returned, none fails the rotation.
+ */
+function* resealAfterRotation(hby, runtime, group, rotation) {
+    const replicating = runtime.rootReplicator;
+    if (!hby.habs.get(group) || !replicating)
+        return [];
+    replicating.prompt(group);
+    return (yield* replicating.processOnce()).map(rootCopyLine);
+}
 function requireText(value, label) {
     if (!value) {
         throw new ValidationError(`${label} is required and cannot be empty`);
@@ -63,8 +89,9 @@ export function* multisigInceptCommand(args) {
         throw new ValidationError("Multisig inception config must include non-empty aids.");
     }
     return yield* withMultisigRuntime(commandArgs, name, function* ({ hby, runtime }) {
-        const member = requireHabByAlias(hby, alias);
-        const created = hby.makeGroupHab(group, member, smids, rmids, undefined, {
+        const sent = yield* proposeGroupInception(proposeDeps(hby, runtime), requireHabByAlias(hby, alias), group, {
+            smids,
+            rmids,
             isith: options.isith,
             nsith: options.nsith,
             toad: options.toad,
@@ -72,33 +99,13 @@ export function* multisigInceptCommand(args) {
             delpre: options.delpre,
             data: options.data ?? [],
             version: commandArgs.version,
-        });
-        const { deliveries, messages } = yield* publishProposal(hby, runtime.protocol, runtime.postman, member, uniqueMembers([...smids, ...rmids]), {
-            route: MULTISIG_ICP_ROUTE,
-            attrs: { smids, rmids, ...(options.delpre ? { delegator: options.delpre } : {}) },
-        }, created.message);
-        const accepted = yield* waitForGroupAcceptance(hby, runtime, created.serder, multisigApprovalOptions(hby, {
-            ...commandArgs,
-            group,
-            auto: true,
-        }));
-        let delegationPhase = null;
-        if (accepted) {
-            yield* receiptAcceptedEvent(hby, created.hab.pre, commandArgs, runtime);
-            delegationPhase = yield* completeDelegationIfNeeded(hby, runtime, created.hab.pre, commandArgs.proxy);
-        }
-        return {
-            route: MULTISIG_ICP_ROUTE,
-            group: created.hab.pre,
-            accepted,
-            messages,
-            deliveries,
-            state: hby.db.getState(created.hab.pre),
-            delegationPhase: delegationPhase,
-        };
+        }, counselInputs(hby, commandArgs.proxy, options.delpre !== undefined, group));
+        const accepted = yield* waitForAcceptance(hby, runtime, sent.event, approvalDeadline(commandArgs));
+        const delegationPhase = accepted ? yield* finishAcceptedEvent(hby, runtime, sent.event, commandArgs) : null;
+        return { ...groupEventResult(hby, sent, accepted), delegationPhase };
     });
 }
-/** Poll for and approve one pending group multisig event. */
+/** Approve one stored group multisig proposal the user consents to. */
 export function* multisigJoinCommand(args) {
     const commandArgs = {
         name: parseStringOption(args.name, "name"),
@@ -120,43 +127,48 @@ export function* multisigJoinCommand(args) {
     };
     const name = requireText(commandArgs.name, "Name");
     return yield* withMultisigRuntime(commandArgs, name, function* ({ hby, runtime }) {
-        const approval = multisigApprovalOptions(hby, commandArgs);
-        const result = yield* waitForOneApproval(hby, runtime, approval);
-        if (!result) {
-            const local = yield* waitForLocalGroupCompletion(hby, runtime, approval);
+        const deadline = approvalDeadline(commandArgs);
+        const joined = yield* joinProposal(approvalDeps(hby, runtime), {
+            group: commandArgs.group,
+            said: commandArgs.said,
+            deadline,
+            confirm: proposal => approvePrompt(commandArgs, proposal),
+            groupAlias: proposal => chooseGroupAlias(hby, commandArgs, proposal.group),
+            registryName: proposal => chooseRegistryName(commandArgs, proposal.embedded),
+            inputs: () => ({ fallbackAfterMs: 0 }),
+        });
+        if (!joined) {
+            const local = yield* completeLocalGroupEvent(hby, runtime, commandArgs, deadline);
             if (!local) {
                 throw new ValidationError("No matching stored multisig proposal was available to join.");
             }
-            if (local.accepted) {
-                yield* receiptAcceptedEvent(hby, local.group, commandArgs, runtime);
-                if (local.route === MULTISIG_ICP_ROUTE || local.route === MULTISIG_ROT_ROUTE) {
-                    yield* completeDelegationIfNeeded(hby, runtime, local.group, commandArgs.proxy);
-                }
-            }
             return local;
         }
+        const { event, ...result } = joined.result;
         if (result.tel) {
             const { publication, reger } = runtime.vdr;
             const tel = result.tel;
             if (result.route === MULTISIG_VCP_ROUTE || result.route === MULTISIG_REV_ROUTE) {
-                yield* waitForTelPublication(publication, tel.pre, tel.sn, approval.deadline);
+                yield* waitForTelEvent({ publication }, tel.pre, tel.sn, { deadline });
                 result.accepted = reger.tels.getOn(tel.pre, tel.sn)?.qb64 === result.embedded;
             }
             else {
-                yield* waitForIssuedCredential(publication, tel.pre, approval.deadline);
+                yield* waitForIssuedCredential({ publication }, tel.pre, { deadline });
                 result.accepted = reger.saved.get(tel.pre) !== null;
             }
-            tel.publicationComplete = publication.complete(tel.pre, tel.sn);
+            tel.publicationComplete = telEventStatus({ publication }, tel.pre, tel.sn).state === "complete";
             return result;
         }
-        if (result.accepted) {
-            yield* receiptAcceptedEvent(hby, result.group, commandArgs, runtime);
-            if (result.route === MULTISIG_ICP_ROUTE
-                || result.route === MULTISIG_ROT_ROUTE) {
-                yield* completeDelegationIfNeeded(hby, runtime, result.group, commandArgs.proxy);
-            }
+        if (isV2RegistryRoute(result.route)) {
+            supplyWitnessAuths(hby, runtime, event, commandArgs);
+            result.accepted = yield* settleRegistryApproval(hby, runtime, result, deadline);
+            return result;
         }
-        return result;
+        if (!event)
+            return result;
+        // No scheduling point separates the approval from here, so the Counselor has not yet used its defaults.
+        supplyDelegationProxy(hby, runtime, event, commandArgs.proxy);
+        return yield* finishJoinedEvent(hby, runtime, result, event, commandArgs);
     });
 }
 /** Create or begin one group interaction event. */
@@ -181,26 +193,11 @@ export function* multisigInteractCommand(args) {
     const group = requireText(commandArgs.group ?? commandArgs.alias, "Group");
     const data = parseDataItems(commandArgs.data);
     return yield* withMultisigRuntime(commandArgs, name, function* ({ hby, runtime }) {
-        const created = hby.interactGroupHab(group, undefined, { data, version: commandArgs.version });
-        const smids = groupSigningMembers(hby, created.hab.pre);
-        const { deliveries, messages } = yield* publishProposal(hby, runtime.protocol, runtime.postman, localGroupMember(hby, created.hab.pre), smids, { route: MULTISIG_IXN_ROUTE, attrs: { gid: created.hab.pre, smids } }, created.message);
-        const accepted = yield* waitForGroupAcceptance(hby, runtime, created.serder, multisigApprovalOptions(hby, {
-            ...commandArgs,
-            group,
-            auto: true,
-        }));
-        if (accepted) {
-            yield* receiptAcceptedEvent(hby, created.hab.pre, commandArgs, runtime);
-        }
-        return {
-            route: MULTISIG_IXN_ROUTE,
-            group: created.hab.pre,
-            accepted,
-            messages,
-            deliveries,
-            state: hby.db.getState(created.hab.pre),
-            delegationPhase: null,
-        };
+        const sent = yield* proposeGroupInteraction(proposeDeps(hby, runtime), requireGroupHab(hby, group), data, { fallbackAfterMs: 0 }, commandArgs.version);
+        const accepted = yield* waitForAcceptance(hby, runtime, sent.event, approvalDeadline(commandArgs));
+        if (accepted)
+            yield* finishAcceptedEvent(hby, runtime, sent.event, commandArgs);
+        return groupEventResult(hby, sent, accepted);
     });
 }
 /** Rotate or begin rotation of one group identifier. */
@@ -235,7 +232,10 @@ export function* multisigRotateCommand(args) {
     const group = requireText(commandArgs.group ?? commandArgs.alias, "Group");
     const options = mergeRotateOptions(commandArgs);
     return yield* withMultisigRuntime(commandArgs, name, function* ({ hby, runtime }) {
-        const rotated = hby.rotateGroupHab(group, commandArgs.smids, commandArgs.rmids, {
+        const groupHab = requireGroupHab(hby, group);
+        const sent = yield* proposeGroupRotation(proposeDeps(hby, runtime), groupHab, {
+            smids: commandArgs.smids,
+            rmids: commandArgs.rmids,
             isith: options.isith,
             nsith: options.nsith,
             toad: options.toad,
@@ -243,31 +243,17 @@ export function* multisigRotateCommand(args) {
             adds: options.witsAdd,
             data: options.data ?? [],
             version: commandArgs.version,
-        });
-        const smids = commandArgs.smids?.length ? commandArgs.smids : groupSigningMembers(hby, rotated.hab.pre);
-        const rmids = commandArgs.rmids?.length ? commandArgs.rmids : smids;
-        const { deliveries, messages } = yield* publishProposal(hby, runtime.protocol, runtime.postman, localGroupMember(hby, rotated.hab.pre), uniqueMembers([...smids, ...rmids]), { route: MULTISIG_ROT_ROUTE, attrs: { gid: rotated.hab.pre, smids, rmids } }, rotated.message);
-        const accepted = yield* waitForGroupAcceptance(hby, runtime, rotated.serder, multisigApprovalOptions(hby, {
-            ...commandArgs,
-            group,
-            auto: true,
-        }));
+        }, counselInputs(hby, commandArgs.proxy, !!hby.db.getKever(groupHab.pre)?.delpre, group));
+        const accepted = yield* waitForAcceptance(hby, runtime, sent.event, approvalDeadline(commandArgs));
         let delegationPhase = null;
+        let rootCopies = [];
         if (accepted) {
             // The proposer's own acceptance must commit the rotated membership as a joiner's does.
-            commitAcceptedGroupMembers(hby, rotated.serder, smids, rmids);
-            yield* receiptAcceptedEvent(hby, rotated.hab.pre, commandArgs, runtime);
-            delegationPhase = yield* completeDelegationIfNeeded(hby, runtime, rotated.hab.pre, commandArgs.proxy);
+            settleProposedRotation({ hby }, sent);
+            delegationPhase = yield* finishAcceptedEvent(hby, runtime, sent.event, commandArgs);
+            rootCopies = yield* resealAfterRotation(hby, runtime, sent.group, sent.event.said);
         }
-        return {
-            route: MULTISIG_ROT_ROUTE,
-            group: rotated.hab.pre,
-            accepted,
-            messages,
-            deliveries,
-            state: hby.db.getState(rotated.hab.pre),
-            delegationPhase: delegationPhase,
-        };
+        return { ...groupEventResult(hby, sent, accepted), delegationPhase, rootCopies };
     });
 }
 /** Propose one group multisig reply such as `/end/role/add`. */
@@ -292,12 +278,12 @@ export function* multisigRpyCommand(args) {
     return yield* withMultisigRuntime(commandArgs, name, function* ({ hby, runtime }) {
         const groupHab = requireHabByAlias(hby, group);
         const result = yield* proposeGroupEndpointRole(hby, runtime.protocol, runtime.postman, groupHab, { eid, role, allow: commandArgs.allow });
+        // The reply is accepted when the other members' contributions reach this runtime.
         const accepted = commandArgs.approvalTimeoutSeconds > 0
-            ? yield* waitForReplyAcceptance(hby, runtime, groupHab.pre, role, eid, multisigApprovalOptions(hby, {
-                ...commandArgs,
-                group: groupHab.pre,
-                auto: true,
-            }))
+            ? yield* observeUntil(() => endpointRoleAccepted(hby, groupHab.pre, role, eid), {
+                timeoutMs: Math.max(0, approvalDeadline(commandArgs) - Date.now()),
+                pollMs: 250,
+            })
             : result.accepted;
         return { ...result, accepted };
     });
@@ -314,13 +300,7 @@ function* withMultisigRuntime(args, name, use) {
         const signer = selected && isLocalGroupHab(context.hby, selected)
             ? localGroupMember(context.hby, selected.pre)
             : selected;
-        const worker = yield* spawn(() => runAgentRuntime(context.runtime, { hab: signer }));
-        try {
-            return yield* use(context);
-        }
-        finally {
-            yield* worker.halt();
-        }
+        return yield* withRuntimeWorkers(context.runtime, { hab: signer }, () => use(context));
     });
 }
 function requireHabByAlias(hby, alias) {
@@ -330,6 +310,12 @@ function requireHabByAlias(hby, alias) {
     }
     return hab;
 }
+function requireGroupHab(hby, group) {
+    const hab = hby.habByName(group);
+    if (!hab)
+        throw new ValidationError(`Group alias ${group} is invalid.`);
+    return hab;
+}
 function mergeRotateOptions(args) {
     const options = args.file && args.file !== "" ? loadRotateFileOptions(args.file) : {};
     if (args.isith !== undefined) {
@@ -358,22 +344,75 @@ function mergeRotateOptions(args) {
     }
     return options;
 }
-function multisigApprovalOptions(hby, args) {
-    // An existing group constrains approval; a new alias only names the group
-    // after its inception proposal is selected and approved.
+/** Deadline of this command's approval wait, measured from when the wait starts. */
+function approvalDeadline(args) {
+    return Date.now() + args.approvalTimeoutSeconds * 1000;
+}
+function proposeDeps(hby, runtime) {
+    return { hby, protocol: runtime.protocol, postman: runtime.postman, counselor: runtime.counselor };
+}
+function approvalDeps(hby, runtime) {
     return {
-        group: args.group ? groupHabByAliasOrPrefix(hby, args.group)?.pre : undefined,
-        said: args.said,
-        deadline: Date.now() + args.approvalTimeoutSeconds * 1000,
-        callbacks: multisigApprovalCallbacks(hby, args),
+        hby,
+        exc: runtime.exc,
+        reactor: runtime.reactor,
+        protocol: runtime.protocol,
+        postman: runtime.postman,
+        notifier: runtime.notifier,
+        registryStore: runtime.acdc?.store ?? null,
+        vdr: runtime.vdr,
+        counselor: runtime.counselor,
     };
 }
-function multisigApprovalCallbacks(hby, args) {
+function groupEventResult(hby, sent, accepted) {
     return {
-        approveProposal: (context) => approvePrompt(args, context),
-        chooseGroupAlias: (groupPre) => chooseGroupAlias(hby, args, groupPre),
-        chooseRegistryName: (regk) => chooseRegistryName(args, regk),
+        route: sent.route,
+        group: sent.group,
+        accepted,
+        messages: sent.messages,
+        deliveries: sent.deliveries,
+        state: hby.db.getState(sent.group),
+        delegationPhase: null,
+    };
+}
+/**
+ * A joined event that this approval completed has nothing left to wait for from other
+ * members; finish its receipts and delegation. One that still needs other members
+ * returns at once and stays counseled in the store.
+ */
+function* finishJoinedEvent(hby, runtime, result, event, args) {
+    if (!result.accepted)
+        return result;
+    yield* finishAcceptedEvent(hby, runtime, event, args);
+    if (result.route !== MULTISIG_ROT_ROUTE)
+        return result;
+    return { ...result, rootCopies: yield* resealAfterRotation(hby, runtime, result.group, result.embedded) };
+}
+/** Resume a locally authored group event named by `--group` when no proposal was left to join. */
+function* completeLocalGroupEvent(hby, runtime, args, deadline) {
+    if (!args.group || args.said)
+        return null;
+    const groupHab = hby.habByName(args.group) ?? hby.habs.get(args.group);
+    if (!groupHab?.pre || !isLocalGroupHab(hby, groupHab))
+        return null;
+    const serder = hby.db.getKever(groupHab.pre)?.serder ?? hby.db.getEvtSerder(groupHab.pre, groupHab.pre);
+    const route = serder && routeForKelEvent(serder);
+    if (!serder?.said || serder.sn === null || !route)
+        return null;
+    const event = { pre: groupHab.pre, sn: serder.sn, said: serder.said };
+    const delegated = serder.ilk === Ilks.dip || serder.ilk === Ilks.drt;
+    runtime.counselor.start(event, counselInputs(hby, args.proxy, delegated, groupHab.pre));
+    const accepted = yield* waitForAcceptance(hby, runtime, event, deadline);
+    const result = {
+        route,
+        said: "",
+        embedded: serder.said,
+        group: groupHab.pre,
+        accepted,
+        deliveries: [],
+        messages: [],
     };
+    return yield* finishJoinedEvent(hby, runtime, result, event, args);
 }
 function chooseRegistryName(args, regk) {
     if (args.registryName) {
@@ -413,42 +452,42 @@ function chooseGroupAlias(hby, args, groupPre) {
         return group;
     }
 }
-function approvePrompt(args, context) {
+/** Ask whether to join a proposal; `--auto` answers yes without asking, only for the join command that set it. */
+export function approvePrompt(args, proposal) {
     if (args.auto) {
         return true;
     }
     console.log(JSON.stringify({
-        route: context.route,
-        group: context.group,
-        embedded: context.embedded,
+        route: `/multisig/${proposal.kind}`,
+        group: proposal.group,
+        embedded: proposal.embedded,
     }, null, 2));
     const yn = prompt("\nJoin [Y|n]? ");
     return yn === null || yn === "" || yn === "y" || yn === "Y";
 }
 /**
- * Collect witness receipts for the current accepted multisig event using explicit runtime collaborators.
+ * Settle one approved v2 RIP/BUP as KERIpy's join Counselor does: wait for the group's KEL acceptance of
+ * the exact anchor and let the anchor escrow accept the TEL event. The Counselor, started by the approval,
+ * converges the anchor's witness receipts, which the TEL event needs.
  *
- * @param hby Borrowed local identities and accepted-state stores.
- * @param pre Accepted group event subject.
- * @param args Witness authentication and HTTP endpoint mode choices.
- * @param runtime Borrowed composed runtime; caller owns its worker and store lifetime.
+ * @returns Whether the approved TEL event is accepted before the approval deadline.
  */
-function* receiptAcceptedEvent(hby, pre, args, runtime) {
-    const kever = hby.db.getKever(pre);
-    if (!kever || kever.wits.length === 0) {
-        return;
-    }
-    const auths = resolveWitnessAuths(kever.wits, args.code ?? [], {
-        codeTime: args.codeTime,
-        promptMissing: args.authenticate ?? false,
-    });
-    if (args.endpoint) {
-        const receiptor = new Receiptor(hby, runtime.protocol, runtime.http, runtime.clock);
-        yield* receiptor.receipt(pre, { sn: kever.sn, auths });
-    }
-    else {
-        const witDoer = new WitnessReceiptor(hby, runtime.protocol, runtime.http, runtime.clock);
-        yield* witDoer.submit(pre, { sn: kever.sn, auths });
+function* settleRegistryApproval(hby, runtime, result, deadline) {
+    const store = runtime.acdc?.store, tel = store?.event(result.embedded);
+    const anc = hby.db.exns.get([result.said])?.sad?.a?.anc;
+    if (!store || !tel || typeof tel.sad?.n !== "string" || typeof anc !== "string")
+        return result.accepted;
+    const anchor = hby.db.getEvtSerder(result.group, anc);
+    const ref = registryEventRef(tel, { pre: result.group, sn: anchor?.sn ?? 0, said: anc });
+    const deps = { db: hby.db, store, protocol: runtime.protocol };
+    while (true) {
+        if (registryEventStatus(deps, ref).state === "accepted")
+            return true;
+        if ((yield* settleRegistryEvent(deps, ref)).state === "accepted")
+            return true;
+        if (Date.now() >= deadline)
+            return false;
+        yield* sleep(Math.min(250, deadline - Date.now()));
     }
 }
 /** Approval waits allow fractional seconds and zero, but never coerce absence or overflow a deadline. */
@@ -459,108 +498,6 @@ function nonNegativeNumber(value, fallback, label) {
     }
     return parsed;
 }
-/** Approve stored proposals until the target event is accepted or the deadline expires. */
-function* waitForGroupAcceptance(hby, runtime, serder, options) {
-    if (eventAccepted(hby, serder)) {
-        return true;
-    }
-    while (true) {
-        yield* approvePendingMultisigProposal(hby, runtime, options);
-        if (eventAccepted(hby, serder)) {
-            return true;
-        }
-        if (Date.now() >= options.deadline)
-            break;
-        yield* sleep(Math.min(250, options.deadline - Date.now()));
-    }
-    return eventAccepted(hby, serder);
-}
-/** Wait for one stored proposal while the command host owns background progress. */
-function* waitForOneApproval(hby, runtime, options) {
-    while (true) {
-        const result = yield* approvePendingMultisigProposal(hby, runtime, options);
-        if (result) {
-            return result;
-        }
-        if (Date.now() >= options.deadline)
-            break;
-        yield* sleep(Math.min(250, options.deadline - Date.now()));
-    }
-    return null;
-}
-/** Wait for a locally authored group event to complete through stored approvals. */
-function* waitForLocalGroupCompletion(hby, runtime, options) {
-    if (!options.group || options.said) {
-        return null;
-    }
-    const groupHab = groupHabByAliasOrPrefix(hby, options.group);
-    if (!groupHab?.pre) {
-        return null;
-    }
-    const serder = localGroupJoinSerder(hby, groupHab.pre);
-    if (!serder) {
-        return null;
-    }
-    const route = routeForKelEvent(serder);
-    if (!route) {
-        return null;
-    }
-    const accepted = yield* waitForGroupAcceptance(hby, runtime, serder, options);
-    return {
-        route,
-        said: "",
-        embedded: serder.said ?? "",
-        group: groupHab.pre,
-        accepted,
-        deliveries: [],
-        messages: [],
-    };
-}
-/** Approve stored proposals until the endpoint reply is accepted or the deadline expires. */
-function* waitForReplyAcceptance(hby, runtime, groupPre, role, eid, options) {
-    if (endpointRoleAccepted(hby, groupPre, role, eid)) {
-        return true;
-    }
-    while (true) {
-        yield* approvePendingMultisigProposal(hby, runtime, options);
-        if (endpointRoleAccepted(hby, groupPre, role, eid)) {
-            return true;
-        }
-        if (Date.now() >= options.deadline)
-            break;
-        yield* sleep(Math.min(250, options.deadline - Date.now()));
-    }
-    return endpointRoleAccepted(hby, groupPre, role, eid);
-}
-/** Complete the delegation workflow for an accepted delegated group event. */
-function* completeDelegationIfNeeded(hby, runtime, pre, proxy) {
-    const kever = hby.db.getKever(pre);
-    if (!kever?.delpre) {
-        return null;
-    }
-    const communicationHab = resolveDelegationCommunicationHab(hby, proxy);
-    if (!communicationHab) {
-        throw new ValidationError(`Delegated group event for ${pre} requires --proxy <alias>.`);
-    }
-    runtime.delegating.beginLatest(pre, kever.sn, { communicationHab });
-    const deadline = Date.now() + 120_000;
-    while (!runtime.delegating.complete(pre, kever.sn)) {
-        if (Date.now() >= deadline)
-            throw new Error("Runtime did not converge within 120000ms.");
-        yield* sleep(Math.min(250, deadline - Date.now()));
-    }
-    return runtime.delegating.workflowStatus(pre, kever.sner.numh).phase;
-}
-function groupHabByAliasOrPrefix(hby, group) {
-    return hby.habByName(group) ?? hby.habs.get(group) ?? null;
-}
-function localGroupJoinSerder(hby, groupPre) {
-    const kever = hby.db.getKever(groupPre);
-    if (kever?.serder) {
-        return kever.serder;
-    }
-    return hby.db.getEvtSerder(groupPre, groupPre);
-}
 function* sleep(ms) {
     yield* action((resolve) => {
         const id = setTimeout(resolve, ms);

package/esm/keri/npm/src/cli/messaging/root-copy-lines.js

@@ -0,0 +1,31 @@
+/** The operator command that resends a copy automatic replication did not send. */
+export const RootCopyRecoveryCommand = "tufa vc registry root send";
+function errorText(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/** Map one typed copy result to its `root_copy` line. */
+export function rootCopyLine(result) {
+    const line = {
+        phase: "root_copy",
+        gid: result.group,
+        registry: result.registry,
+        sender: result.sender,
+        recipient: result.recipient,
+        transmitted: false,
+    };
+    if (result.exchange !== undefined)
+        line.exchange = result.exchange;
+    if (result.kin === "sent")
+        return { ...line, transmitted: true };
+    return { ...line, error: errorText(result.error), recovery: RootCopyRecoveryCommand };
+}
+/** Map an unexaminable rotation to its `root_copy` line. */
+export function rootResealLine(examination) {
+    return {
+        phase: "root_copy",
+        gid: examination.group,
+        rotation: examination.rotation,
+        transmitted: false,
+        error: examination.error.message,
+    };
+}

package/esm/keri/npm/src/cli/tools/annotate.js

@@ -1,7 +1,8 @@
 import * as dntShim from "../../_dnt.shims.js";
 import { annotate } from "cesr-ts";
 import { abortable } from "../../app/runtime/abortable.js";
-import { collectBytes, fileBytes, streamBytes } from "../../app/transport/byte-source.js";
+import { collectBytes, streamBytes } from "../../app/transport/byte-source.js";
+import { fileBytes } from "../../app/transport/file-bytes.js";
 import { parseBooleanOption, parseStringOption } from "../common/parsing.js";
 import { writeStdout } from "../output.js";
 import { colorizeAnnotatedOutput } from "./annotate-color.js";

package/esm/keri/npm/src/cli/tools/benchmark.js

@@ -1,7 +1,8 @@
 import * as dntShim from "../../_dnt.shims.js";
 import { benchmarkParser, } from "cesr-ts";
 import { abortable } from "../../app/runtime/abortable.js";
-import { collectBytes, fileBytes, streamBytes } from "../../app/transport/byte-source.js";
+import { collectBytes, streamBytes } from "../../app/transport/byte-source.js";
+import { fileBytes } from "../../app/transport/file-bytes.js";
 import { ValidationError } from "../../core/errors.js";
 import { parseBooleanOption, parseCountOption, parseStringOption } from "../common/parsing.js";
 import { writeStdout } from "../output.js";

package/esm/keri/npm/src/cli/tools/db-dump.js

@@ -1,10 +1,7 @@
 import { displayStr } from "../../core/bytes.js";
 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/mailbox/mailboxing.js";
-import { createNoter } from "../../db/noting.js";
+import { createBaser, createKeeper, createMailboxer, createNoter } from "../../db/lmdb-stores.js";
 import { parseBooleanOption, parseIntegerOption, parseStringOption } from "../common/parsing.js";
 const DOMAIN_FACTORIES = {
     baser: {

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

@@ -1,3 +1,12 @@
+/** Unsigned bytewise order, shorter first on a shared prefix, as LMDB orders keys. */
+export function compareBytes(left, right) {
+    const shared = Math.min(left.length, right.length);
+    for (let i = 0; i < shared; i++) {
+        if (left[i] !== right[i])
+            return left[i] - right[i];
+    }
+    return left.length - right.length;
+}
 /**
  * Check if keyBytes starts with prefixBytes
  */