keri-ts 1.0.0 → 2.0.0

package/esm/keri/npm/src/{app/cli → cli/messaging}/multisig.js

@@ -1,26 +1,17 @@
-/**
- * `tufa multisig ...` command implementation.
- *
- * The command surface follows KLI's group lifecycle model:
- * - `incept`, `rotate`, and `interact` propose a group KEL event and publish a
- *   `/multisig/*` EXN to the other members
- * - `join` polls mailbox notifications, signs the embedded event with local
- *   member keys, and republishes the approval EXN
- */
-import * as dntShim from "../../_dnt.shims.js";
 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";
 import { ValidationError } from "../../core/errors.js";
 import { Roles } from "../../core/roles.js";
-import { runAgentRuntime } from "../agent-runtime.js";
-import { resolveDelegationCommunicationHab } from "../delegating.js";
-import { endpointRoleAccepted, groupSigningMembers, isLocalGroupHab, localGroupMember, proposeGroupEndpointRole, } from "../endpoint-roleing.js";
-import { uniqueMembers } from "../group-members.js";
-import { MULTISIG_ICP_ROUTE, MULTISIG_IXN_ROUTE, MULTISIG_ROT_ROUTE, } from "../grouping.js";
-import { approvePendingMultisigProposal, eventAccepted, publishProposal, routeForKelEvent, } from "../multisig-workflows.js";
-import { Receiptor, WitnessReceiptor } from "../witnessing.js";
-import { withAgentRuntime } from "./common/context.js";
-import { loadRotateFileOptions, parseDataItems, parseThresholdOption, } from "./common/parsing.js";
-import { resolveWitnessAuths } from "./common/witness-auth.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";
 function requireText(value, label) {
     if (!value) {
@@ -28,37 +19,38 @@ function requireText(value, label) {
     }
     return value;
 }
+/** Validate every supplied group member and policy field before opening the group store. */
 function loadMultisigInceptFile(path) {
-    const loaded = JSON.parse(dntShim.Deno.readTextFileSync(path));
+    const loaded = loadOptionObject(path);
     return {
-        ...loaded,
-        aids: Array.isArray(loaded.aids) ? loaded.aids.filter(isString) : loaded.aids,
-        rmids: Array.isArray(loaded.rmids) ? loaded.rmids.filter(isString) : loaded.rmids,
+        aids: parseStringListOption(loaded.aids, "aids"),
+        rmids: parseStringListOption(loaded.rmids, "rmids"),
         isith: parseThresholdOption(loaded.isith),
         nsith: parseThresholdOption(loaded.nsith),
-        wits: Array.isArray(loaded.wits) ? loaded.wits.filter(isString) : loaded.wits,
+        toad: parseCountOption(loaded.toad, "toad"),
+        wits: parseStringListOption(loaded.wits, "wits"),
+        data: parseFileData(loaded.data),
+        delpre: parseStringOption(loaded.delpre, "delpre"),
     };
 }
-function isString(value) {
-    return typeof value === "string";
-}
 /** Create or begin a distributed group identifier from a KLI-style file. */
 export function* multisigInceptCommand(args) {
     const commandArgs = {
-        name: args.name,
-        base: args.base,
-        headDirPath: args.headDirPath,
-        passcode: args.passcode,
-        alias: args.alias,
-        group: args.group,
-        compat: args.compat,
-        endpoint: args.endpoint,
-        authenticate: args.authenticate,
-        code: args.code,
-        codeTime: args.codeTime,
-        file: args.file,
+        name: parseStringOption(args.name, "name"),
+        base: parseStringOption(args.base, "base"),
+        headDirPath: parseStringOption(args.headDirPath, "headDirPath"),
+        passcode: parseStringOption(args.passcode, "passcode"),
+        alias: parseStringOption(args.alias, "alias"),
+        group: parseStringOption(args.group, "group"),
+        compat: parseBooleanOption(args.compat, "compat"),
+        endpoint: parseBooleanOption(args.endpoint, "endpoint"),
+        authenticate: parseBooleanOption(args.authenticate, "authenticate"),
+        code: parseStringListOption(args.code, "code"),
+        codeTime: parseStringOption(args.codeTime, "codeTime"),
+        file: parseStringOption(args.file, "file"),
         approvalTimeoutSeconds: nonNegativeNumber(args.approvalTimeoutSeconds, 10, "approval timeout seconds"),
-        proxy: args.proxy,
+        proxy: parseStringOption(args.proxy, "proxy"),
+        version: parseKeriVersionOption(args.version),
     };
     const name = requireText(commandArgs.name, "Name");
     const alias = requireText(commandArgs.alias, "Alias");
@@ -70,7 +62,7 @@ export function* multisigInceptCommand(args) {
     if (smids.length === 0) {
         throw new ValidationError("Multisig inception config must include non-empty aids.");
     }
-    yield* withMultisigRuntime(commandArgs, name, function* ({ hby, runtime }) {
+    return yield* withMultisigRuntime(commandArgs, name, function* ({ hby, runtime }) {
         const member = requireHabByAlias(hby, alias);
         const created = hby.makeGroupHab(group, member, smids, rmids, undefined, {
             isith: options.isith,
@@ -79,8 +71,9 @@ export function* multisigInceptCommand(args) {
             wits: options.wits ?? [],
             delpre: options.delpre,
             data: options.data ?? [],
+            version: commandArgs.version,
         });
-        const deliveries = yield* publishProposal(runtime, member, uniqueMembers([...smids, ...rmids]), {
+        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);
@@ -94,43 +87,45 @@ export function* multisigInceptCommand(args) {
             yield* receiptAcceptedEvent(hby, created.hab.pre, commandArgs, runtime);
             delegationPhase = yield* completeDelegationIfNeeded(hby, runtime, created.hab.pre, commandArgs.proxy);
         }
-        printIdentifier(hby, created.hab.pre, delegationPhase);
-        console.log(JSON.stringify({
+        return {
             route: MULTISIG_ICP_ROUTE,
             group: created.hab.pre,
             accepted,
+            messages,
             deliveries,
-        }));
+            state: hby.db.getState(created.hab.pre),
+            delegationPhase: delegationPhase,
+        };
     });
 }
 /** Poll for and approve one pending group multisig event. */
 export function* multisigJoinCommand(args) {
     const commandArgs = {
-        name: args.name,
-        base: args.base,
-        headDirPath: args.headDirPath,
-        passcode: args.passcode,
-        alias: args.alias,
-        group: args.group,
-        compat: args.compat,
-        endpoint: args.endpoint,
-        authenticate: args.authenticate,
-        code: args.code,
-        codeTime: args.codeTime,
-        auto: args.auto,
-        registryName: args.registryName,
-        said: args.said,
+        name: parseStringOption(args.name, "name"),
+        base: parseStringOption(args.base, "base"),
+        headDirPath: parseStringOption(args.headDirPath, "headDirPath"),
+        passcode: parseStringOption(args.passcode, "passcode"),
+        alias: parseStringOption(args.alias, "alias"),
+        group: parseStringOption(args.group, "group"),
+        compat: parseBooleanOption(args.compat, "compat"),
+        endpoint: parseBooleanOption(args.endpoint, "endpoint"),
+        authenticate: parseBooleanOption(args.authenticate, "authenticate"),
+        code: parseStringListOption(args.code, "code"),
+        codeTime: parseStringOption(args.codeTime, "codeTime"),
+        auto: parseBooleanOption(args.auto, "auto"),
+        registryName: parseStringOption(args.registryName, "registryName"),
+        said: parseStringOption(args.said, "said"),
         approvalTimeoutSeconds: nonNegativeNumber(args.approvalTimeoutSeconds, 60, "approval timeout seconds"),
-        proxy: args.proxy,
+        proxy: parseStringOption(args.proxy, "proxy"),
     };
     const name = requireText(commandArgs.name, "Name");
-    yield* withMultisigRuntime(commandArgs, name, function* ({ hby, runtime }) {
+    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);
             if (!local) {
-                throw new ValidationError("No matching multisig notification was available to join.");
+                throw new ValidationError("No matching stored multisig proposal was available to join.");
             }
             if (local.accepted) {
                 yield* receiptAcceptedEvent(hby, local.group, commandArgs, runtime);
@@ -138,8 +133,21 @@ export function* multisigJoinCommand(args) {
                     yield* completeDelegationIfNeeded(hby, runtime, local.group, commandArgs.proxy);
                 }
             }
-            console.log(JSON.stringify(local));
-            return;
+            return local;
+        }
+        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);
+                result.accepted = reger.tels.getOn(tel.pre, tel.sn)?.qb64 === result.embedded;
+            }
+            else {
+                yield* waitForIssuedCredential(publication, tel.pre, approval.deadline);
+                result.accepted = reger.saved.get(tel.pre) !== null;
+            }
+            tel.publicationComplete = publication.complete(tel.pre, tel.sn);
+            return result;
         }
         if (result.accepted) {
             yield* receiptAcceptedEvent(hby, result.group, commandArgs, runtime);
@@ -148,33 +156,34 @@ export function* multisigJoinCommand(args) {
                 yield* completeDelegationIfNeeded(hby, runtime, result.group, commandArgs.proxy);
             }
         }
-        console.log(JSON.stringify(result));
+        return result;
     });
 }
 /** Create or begin one group interaction event. */
 export function* multisigInteractCommand(args) {
     const commandArgs = {
-        name: args.name,
-        base: args.base,
-        headDirPath: args.headDirPath,
-        passcode: args.passcode,
-        alias: args.alias,
-        group: args.group,
-        compat: args.compat,
-        endpoint: args.endpoint,
-        authenticate: args.authenticate,
-        code: args.code,
-        codeTime: args.codeTime,
-        data: args.data,
+        name: parseStringOption(args.name, "name"),
+        base: parseStringOption(args.base, "base"),
+        headDirPath: parseStringOption(args.headDirPath, "headDirPath"),
+        passcode: parseStringOption(args.passcode, "passcode"),
+        alias: parseStringOption(args.alias, "alias"),
+        group: parseStringOption(args.group, "group"),
+        compat: parseBooleanOption(args.compat, "compat"),
+        endpoint: parseBooleanOption(args.endpoint, "endpoint"),
+        authenticate: parseBooleanOption(args.authenticate, "authenticate"),
+        code: parseStringListOption(args.code, "code"),
+        codeTime: parseStringOption(args.codeTime, "codeTime"),
+        data: parseStringListOption(args.data, "data"),
         approvalTimeoutSeconds: nonNegativeNumber(args.approvalTimeoutSeconds, 10, "approval timeout seconds"),
+        version: parseKeriVersionOption(args.version),
     };
     const name = requireText(commandArgs.name, "Name");
     const group = requireText(commandArgs.group ?? commandArgs.alias, "Group");
     const data = parseDataItems(commandArgs.data);
-    yield* withMultisigRuntime(commandArgs, name, function* ({ hby, runtime }) {
-        const created = hby.interactGroupHab(group, undefined, { 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 = yield* publishProposal(runtime, localGroupMember(hby, created.hab.pre), smids, { route: MULTISIG_IXN_ROUTE, attrs: { gid: created.hab.pre, smids } }, created.message);
+        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,
@@ -183,46 +192,49 @@ export function* multisigInteractCommand(args) {
         if (accepted) {
             yield* receiptAcceptedEvent(hby, created.hab.pre, commandArgs, runtime);
         }
-        printIdentifier(hby, created.hab.pre);
-        console.log(JSON.stringify({
+        return {
             route: MULTISIG_IXN_ROUTE,
             group: created.hab.pre,
             accepted,
+            messages,
             deliveries,
-        }));
+            state: hby.db.getState(created.hab.pre),
+            delegationPhase: null,
+        };
     });
 }
 /** Rotate or begin rotation of one group identifier. */
 export function* multisigRotateCommand(args) {
     const commandArgs = {
-        name: args.name,
-        base: args.base,
-        headDirPath: args.headDirPath,
-        passcode: args.passcode,
-        alias: args.alias,
-        group: args.group,
-        compat: args.compat,
-        endpoint: args.endpoint,
-        authenticate: args.authenticate,
-        code: args.code,
-        codeTime: args.codeTime,
-        file: args.file,
-        isith: args.isith,
-        nsith: args.nsith,
-        toad: args.toad,
-        witnesses: args.witnesses,
-        cuts: args.cuts,
-        witnessAdd: args.witnessAdd,
-        data: args.data,
-        smids: args.smids,
-        rmids: args.rmids,
-        proxy: args.proxy,
+        name: parseStringOption(args.name, "name"),
+        base: parseStringOption(args.base, "base"),
+        headDirPath: parseStringOption(args.headDirPath, "headDirPath"),
+        passcode: parseStringOption(args.passcode, "passcode"),
+        alias: parseStringOption(args.alias, "alias"),
+        group: parseStringOption(args.group, "group"),
+        compat: parseBooleanOption(args.compat, "compat"),
+        endpoint: parseBooleanOption(args.endpoint, "endpoint"),
+        authenticate: parseBooleanOption(args.authenticate, "authenticate"),
+        code: parseStringListOption(args.code, "code"),
+        codeTime: parseStringOption(args.codeTime, "codeTime"),
+        file: parseStringOption(args.file, "file"),
+        isith: parseThresholdOption(args.isith),
+        nsith: parseThresholdOption(args.nsith),
+        toad: parseCountOption(args.toad, "toad"),
+        witnesses: parseStringListOption(args.witnesses, "witnesses"),
+        cuts: parseStringListOption(args.cuts, "cuts"),
+        witnessAdd: parseStringListOption(args.witnessAdd, "witnessAdd"),
+        data: parseStringListOption(args.data, "data"),
+        smids: parseStringListOption(args.smids, "smids"),
+        rmids: parseStringListOption(args.rmids, "rmids"),
+        proxy: parseStringOption(args.proxy, "proxy"),
         approvalTimeoutSeconds: nonNegativeNumber(args.approvalTimeoutSeconds, 10, "approval timeout seconds"),
+        version: parseKeriVersionOption(args.version),
     };
     const name = requireText(commandArgs.name, "Name");
     const group = requireText(commandArgs.group ?? commandArgs.alias, "Group");
     const options = mergeRotateOptions(commandArgs);
-    yield* withMultisigRuntime(commandArgs, name, function* ({ hby, runtime }) {
+    return yield* withMultisigRuntime(commandArgs, name, function* ({ hby, runtime }) {
         const rotated = hby.rotateGroupHab(group, commandArgs.smids, commandArgs.rmids, {
             isith: options.isith,
             nsith: options.nsith,
@@ -230,10 +242,11 @@ export function* multisigRotateCommand(args) {
             cuts: options.witsCut,
             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 = yield* publishProposal(runtime, localGroupMember(hby, rotated.hab.pre), uniqueMembers([...smids, ...rmids]), { route: MULTISIG_ROT_ROUTE, attrs: { gid: rotated.hab.pre, smids, rmids } }, rotated.message);
+        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,
@@ -241,40 +254,44 @@ export function* multisigRotateCommand(args) {
         }));
         let delegationPhase = null;
         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);
         }
-        printIdentifier(hby, rotated.hab.pre, delegationPhase);
-        console.log(JSON.stringify({
+        return {
             route: MULTISIG_ROT_ROUTE,
             group: rotated.hab.pre,
             accepted,
+            messages,
             deliveries,
-        }));
+            state: hby.db.getState(rotated.hab.pre),
+            delegationPhase: delegationPhase,
+        };
     });
 }
 /** Propose one group multisig reply such as `/end/role/add`. */
 export function* multisigRpyCommand(args) {
     const commandArgs = {
-        name: args.name,
-        base: args.base,
-        headDirPath: args.headDirPath,
-        passcode: args.passcode,
-        alias: args.alias,
-        group: args.group,
-        compat: args.compat,
-        eid: args.eid,
-        role: args.role,
-        allow: args.allow,
+        name: parseStringOption(args.name, "name"),
+        base: parseStringOption(args.base, "base"),
+        headDirPath: parseStringOption(args.headDirPath, "headDirPath"),
+        passcode: parseStringOption(args.passcode, "passcode"),
+        alias: parseStringOption(args.alias, "alias"),
+        group: parseStringOption(args.group, "group"),
+        compat: parseBooleanOption(args.compat, "compat"),
+        eid: parseStringOption(args.eid, "eid"),
+        role: parseStringOption(args.role, "role"),
+        allow: parseBooleanOption(args.allow, "allow"),
         approvalTimeoutSeconds: nonNegativeNumber(args.approvalTimeoutSeconds, 0, "approval timeout seconds"),
     };
     const name = requireText(commandArgs.name, "Name");
     const group = requireText(commandArgs.group ?? commandArgs.alias, "Group");
     const eid = requireText(commandArgs.eid, "Endpoint identifier");
     const role = commandArgs.role ?? Roles.mailbox;
-    yield* withMultisigRuntime(commandArgs, name, function* ({ hby, runtime }) {
+    return yield* withMultisigRuntime(commandArgs, name, function* ({ hby, runtime }) {
         const groupHab = requireHabByAlias(hby, group);
-        const result = yield* proposeGroupEndpointRole(runtime, groupHab, { eid, role, allow: commandArgs.allow });
+        const result = yield* proposeGroupEndpointRole(hby, runtime.protocol, runtime.postman, groupHab, { eid, role, allow: commandArgs.allow });
         const accepted = commandArgs.approvalTimeoutSeconds > 0
             ? yield* waitForReplyAcceptance(hby, runtime, groupHab.pre, role, eid, multisigApprovalOptions(hby, {
                 ...commandArgs,
@@ -282,13 +299,7 @@ export function* multisigRpyCommand(args) {
                 auto: true,
             }))
             : result.accepted;
-        console.log(JSON.stringify({
-            route: result.route,
-            proposals: result.proposals,
-            group: result.group,
-            accepted,
-            deliveries: result.deliveries,
-        }));
+        return { ...result, accepted };
     });
 }
 function* withMultisigRuntime(args, name, use) {
@@ -322,21 +333,21 @@ function requireHabByAlias(hby, alias) {
 function mergeRotateOptions(args) {
     const options = args.file && args.file !== "" ? loadRotateFileOptions(args.file) : {};
     if (args.isith !== undefined) {
-        options.isith = parseThresholdOption(args.isith);
+        options.isith = args.isith;
     }
     if (args.nsith !== undefined) {
-        options.nsith = parseThresholdOption(args.nsith);
+        options.nsith = args.nsith;
     }
     if (args.toad !== undefined) {
-        options.toad = Number(args.toad);
+        options.toad = args.toad;
     }
-    if ((args.witnesses?.length ?? 0) > 0) {
+    if (args.witnesses !== undefined) {
         options.wits = [...args.witnesses];
     }
-    if ((args.cuts?.length ?? 0) > 0) {
+    if (args.cuts !== undefined) {
         options.witsCut = [...args.cuts];
     }
-    if ((args.witnessAdd?.length ?? 0) > 0) {
+    if (args.witnessAdd !== undefined) {
         options.witsAdd = [...args.witnessAdd];
     }
     if (args.data !== undefined) {
@@ -348,8 +359,10 @@ 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.
     return {
-        group: args.group,
+        group: args.group ? groupHabByAliasOrPrefix(hby, args.group)?.pre : undefined,
         said: args.said,
         deadline: Date.now() + args.approvalTimeoutSeconds * 1000,
         callbacks: multisigApprovalCallbacks(hby, args),
@@ -412,6 +425,14 @@ function approvePrompt(args, context) {
     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.
+ *
+ * @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.
+ */
 function* receiptAcceptedEvent(hby, pre, args, runtime) {
     const kever = hby.db.getKever(pre);
     if (!kever || kever.wits.length === 0) {
@@ -422,35 +443,22 @@ function* receiptAcceptedEvent(hby, pre, args, runtime) {
         promptMissing: args.authenticate ?? false,
     });
     if (args.endpoint) {
-        const receiptor = new Receiptor(hby, { reactor: runtime.reactor, services: runtime.services });
+        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, { reactor: runtime.reactor, services: runtime.services });
+        const witDoer = new WitnessReceiptor(hby, runtime.protocol, runtime.http, runtime.clock);
         yield* witDoer.submit(pre, { sn: kever.sn, auths });
     }
 }
+/** Approval waits allow fractional seconds and zero, but never coerce absence or overflow a deadline. */
 function nonNegativeNumber(value, fallback, label) {
-    if (value === undefined || value === null || value === "") {
-        return fallback;
-    }
-    const parsed = Number(value);
-    if (!Number.isFinite(parsed) || parsed < 0) {
-        throw new ValidationError(`${label} must be a finite nonnegative number.`);
+    const parsed = parseNumberOption(value, label) ?? fallback;
+    if (parsed < 0 || !Number.isFinite(parsed * 1000)) {
+        throw new ValidationError(`${label} must be a finite nonnegative duration.`);
     }
     return parsed;
 }
-function printIdentifier(hby, pre, delegationPhase) {
-    const state = hby.db.getState(pre);
-    console.log(`Prefix  ${pre}`);
-    console.log(`New Sequence No.  ${state?.s ?? ""}`);
-    for (const [idx, key] of (state?.k ?? []).entries()) {
-        console.log(`\tPublic key ${idx + 1}:  ${key}`);
-    }
-    if (delegationPhase) {
-        console.log(`Delegation status  ${delegationPhase}`);
-    }
-}
 /** Approve stored proposals until the target event is accepted or the deadline expires. */
 function* waitForGroupAcceptance(hby, runtime, serder, options) {
     if (eventAccepted(hby, serder)) {
@@ -505,6 +513,7 @@ function* waitForLocalGroupCompletion(hby, runtime, options) {
         group: groupHab.pre,
         accepted,
         deliveries: [],
+        messages: [],
     };
 }
 /** Approve stored proposals until the endpoint reply is accepted or the deadline expires. */

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

@@ -1,6 +1,7 @@
+import { Notifier, openNoterForHabery } from "../../app/notifications/notifying.js";
 import { ValidationError } from "../../core/errors.js";
-import { Notifier, openNoterForHabery } from "../notifying.js";
-import { withExistingHabery } from "./common/context.js";
+import { withExistingHabery } from "../common/context.js";
+import { parseBooleanOption, parseCountOption, parseStringOption } from "../common/parsing.js";
 function requireName(name) {
     if (!name) {
         throw new ValidationError("Name is required and cannot be empty");
@@ -22,8 +23,11 @@ function* withNotifier(args, use) {
         skipConfig: true,
         skipSignator: false,
     }, function* ({ hby }) {
+        const signator = hby.signator;
+        if (!signator)
+            throw new ValidationError("Notifications require an available habery signator.");
         const noter = yield* openNoterForHabery(hby);
-        const notifier = new Notifier(hby, { noter });
+        const notifier = new Notifier(signator, { noter });
         try {
             return yield* use({ notifier });
         }
@@ -38,13 +42,13 @@ function* withNotifier(args, use) {
 /** Print verified local controller notices as JSON for operator inspection. */
 export function* notificationsListCommand(args) {
     const commandArgs = {
-        name: args.name,
-        base: args.base,
-        headDirPath: args.headDirPath,
-        passcode: args.passcode,
-        compat: args.compat,
-        start: args.start,
-        limit: args.limit,
+        name: parseStringOption(args.name, "name"),
+        base: parseStringOption(args.base, "base"),
+        headDirPath: parseStringOption(args.headDirPath, "headDirPath"),
+        passcode: parseStringOption(args.passcode, "passcode"),
+        compat: parseBooleanOption(args.compat, "compat"),
+        start: parseCountOption(args.start, "start"),
+        limit: parseCountOption(args.limit, "limit"),
     };
     yield* withNotifier(commandArgs, function* ({ notifier }) {
         const start = commandArgs.start ?? 0;
@@ -66,12 +70,12 @@ export function* notificationsListCommand(args) {
 /** Mark one verified notice as read and persist its new detached signature. */
 export function* notificationsMarkReadCommand(args) {
     const commandArgs = {
-        name: args.name,
-        base: args.base,
-        headDirPath: args.headDirPath,
-        passcode: args.passcode,
-        compat: args.compat,
-        rid: args.rid,
+        name: parseStringOption(args.name, "name"),
+        base: parseStringOption(args.base, "base"),
+        headDirPath: parseStringOption(args.headDirPath, "headDirPath"),
+        passcode: parseStringOption(args.passcode, "passcode"),
+        compat: parseBooleanOption(args.compat, "compat"),
+        rid: parseStringOption(args.rid, "rid"),
     };
     yield* withNotifier(commandArgs, function* ({ notifier }) {
         const rid = requireRid(commandArgs.rid);
@@ -82,12 +86,12 @@ export function* notificationsMarkReadCommand(args) {
 /** Remove one verified notice from the notification sidecar. */
 export function* notificationsRemoveCommand(args) {
     const commandArgs = {
-        name: args.name,
-        base: args.base,
-        headDirPath: args.headDirPath,
-        passcode: args.passcode,
-        compat: args.compat,
-        rid: args.rid,
+        name: parseStringOption(args.name, "name"),
+        base: parseStringOption(args.base, "base"),
+        headDirPath: parseStringOption(args.headDirPath, "headDirPath"),
+        passcode: parseStringOption(args.passcode, "passcode"),
+        compat: parseBooleanOption(args.compat, "compat"),
+        rid: parseStringOption(args.rid, "rid"),
     };
     yield* withNotifier(commandArgs, function* ({ notifier }) {
         const rid = requireRid(commandArgs.rid);

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

@@ -1,5 +1,5 @@
 /** Own stdout writes until completion or cancellation, including partial native writes. */
-import * as dntShim from "../../_dnt.shims.js";
+import * as dntShim from "../_dnt.shims.js";
 export async function writeStdout(text, signal) {
     const bytes = new TextEncoder().encode(text);
     /** The CLI owns stdout; closing it interrupts a blocked native write on scope cancellation. */

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

@@ -1,12 +1,18 @@
 import * as dntShim from "../../_dnt.shims.js";
 import { annotate } from "cesr-ts";
-import { abortable } from "../abortable.js";
-import { collectBytes, fileBytes, streamBytes } from "../byte-source.js";
+import { abortable } from "../../app/runtime/abortable.js";
+import { collectBytes, fileBytes, streamBytes } from "../../app/transport/byte-source.js";
+import { parseBooleanOption, parseStringOption } from "../common/parsing.js";
+import { writeStdout } from "../output.js";
 import { colorizeAnnotatedOutput } from "./annotate-color.js";
-import { writeStdout } from "./output.js";
 /** Annotate bounded file/stdin input with every I/O leaf owned by this operation. */
 export function* annotateCommand(args) {
-    const options = args;
+    const options = {
+        inPath: parseStringOption(args.inPath, "inPath"),
+        outPath: parseStringOption(args.outPath, "outPath"),
+        pretty: parseBooleanOption(args.pretty, "pretty"),
+        colored: parseBooleanOption(args.colored, "colored"),
+    };
     const bytes = yield* abortable((signal) => collectBytes(options.inPath ? fileBytes(options.inPath, { signal }) : streamBytes(dntShim.Deno.stdin.readable, { signal })));
     const text = annotate(bytes, { pretty: options.pretty });
     if (options.outPath) {