@helyx/bot 0.4.11 → 0.4.14

package/dist/shard-contracts.d.ts

@@ -169,6 +169,10 @@ export type ShardHealthSnapshot = z.infer<typeof shardHealthSnapshotSchema>;
 export declare const shardControlOperationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"guild.state.get">;
     guildId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"guild.presence.list">;
+    guildIds: z.ZodArray<z.ZodString>;
+    correlationId: z.ZodUUID;
 }, z.core.$strict>, z.ZodObject<{
     actorUserId: z.ZodString;
     correlationId: z.ZodString;
@@ -234,6 +238,16 @@ export declare const shardControlOperationSchema: z.ZodDiscriminatedUnion<[z.Zod
     guildId: z.ZodString;
     moduleId: z.ZodString;
     actionId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"guild.module.resource.access">;
+    guildId: z.ZodString;
+    moduleId: z.ZodString;
+    resourceType: z.ZodString;
+    operation: z.ZodEnum<{
+        list: "list";
+        read: "read";
+    }>;
+    actorUserId: z.ZodString;
 }, z.core.$strict>, z.ZodObject<{
     actorUserId: z.ZodString;
     correlationId: z.ZodString;
@@ -338,6 +352,100 @@ export declare const shardControlOperationSchema: z.ZodDiscriminatedUnion<[z.Zod
         readonly dashboard_security: "dashboard_security";
         readonly discord_command: "discord_command";
     }>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"verification.result.accept">;
+    envelope: z.ZodObject<{
+        payload: z.ZodObject<{
+            protocolVersion: z.ZodLiteral<"1.0">;
+            scoreVersion: z.ZodString;
+            policyVersion: z.ZodString;
+            installationId: z.ZodUUID;
+            deploymentSourceClassification: z.ZodEnum<{
+                helyx_hosted: "helyx_hosted";
+                self_hosted_reported: "self_hosted_reported";
+            }>;
+            evidenceSources: z.ZodObject<{
+                discord: z.ZodEnum<{
+                    helyx_hosted: "helyx_hosted";
+                    self_hosted_reported: "self_hosted_reported";
+                }>;
+                browser: z.ZodLiteral<"helyx_observed_web">;
+                network: z.ZodLiteral<"provider_observed">;
+            }, z.core.$strict>;
+            guildId: z.ZodString;
+            userId: z.ZodString;
+            challengeId: z.ZodUUID;
+            attemptId: z.ZodUUID;
+            decision: z.ZodEnum<{
+                pass: "pass";
+                review: "review";
+                deny: "deny";
+                temporary_failure: "temporary_failure";
+            }>;
+            riskScore: z.ZodNullable<z.ZodNumber>;
+            riskBand: z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+                incomplete: "incomplete";
+            }>;
+            reasonCodes: z.ZodArray<z.ZodEnum<{
+                "network.proxy": "network.proxy";
+                "network.vpn": "network.vpn";
+                "network.compromised": "network.compromised";
+                "network.scraper": "network.scraper";
+                "network.tor": "network.tor";
+                "network.hosting": "network.hosting";
+                "network.anonymous": "network.anonymous";
+                "network.country_policy": "network.country_policy";
+                "account.too_new": "account.too_new";
+                "account.name_quarantined": "account.name_quarantined";
+                "relationship.exact_device_server_enforced": "relationship.exact_device_server_enforced";
+                "relationship.strong_server_enforced": "relationship.strong_server_enforced";
+                "relationship.exact_device": "relationship.exact_device";
+                "relationship.strong": "relationship.strong";
+                "relationship.possible": "relationship.possible";
+                "relationship.ip_only": "relationship.ip_only";
+                "abuse.concurrent_submission": "abuse.concurrent_submission";
+                "abuse.token_replay": "abuse.token_replay";
+                "trust.prior_server_success": "trust.prior_server_success";
+                "trust.other_server_success": "trust.other_server_success";
+                "trust.reviewed_public_flag": "trust.reviewed_public_flag";
+                "rule.account_age": "rule.account_age";
+                "rule.network_category": "rule.network_category";
+                "rule.country": "rule.country";
+                "rule.banned_account_relationship": "rule.banned_account_relationship";
+                "evidence.network_incomplete": "evidence.network_incomplete";
+                "service.temporary_failure": "service.temporary_failure";
+            }>>;
+            overridingRule: z.ZodOptional<z.ZodEnum<{
+                "rule.account_age": "rule.account_age";
+                "rule.network_category": "rule.network_category";
+                "rule.country": "rule.country";
+                "rule.banned_account_relationship": "rule.banned_account_relationship";
+            }>>;
+            actionBoundary: z.ZodObject<{
+                recommendedAction: z.ZodEnum<{
+                    none: "none";
+                    grant_role: "grant_role";
+                    kick: "kick";
+                    ban: "ban";
+                }>;
+                allowedActions: z.ZodArray<z.ZodEnum<{
+                    none: "none";
+                    grant_role: "grant_role";
+                    kick: "kick";
+                    ban: "ban";
+                }>>;
+            }, z.core.$strict>;
+            issuedAt: z.ZodISODateTime;
+            expiresAt: z.ZodISODateTime;
+            resultNonce: z.ZodString;
+        }, z.core.$strict>;
+        signature: z.ZodString;
+        keyId: z.ZodString;
+        algorithm: z.ZodLiteral<"Ed25519">;
+    }, z.core.$strict>;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"privacy.providers.list">;
 }, z.core.$strict>, z.ZodObject<{
@@ -368,6 +476,10 @@ export declare const shardControlRequestSchema: z.ZodObject<{
     operation: z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"guild.state.get">;
         guildId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"guild.presence.list">;
+        guildIds: z.ZodArray<z.ZodString>;
+        correlationId: z.ZodUUID;
     }, z.core.$strict>, z.ZodObject<{
         actorUserId: z.ZodString;
         correlationId: z.ZodString;
@@ -433,6 +545,16 @@ export declare const shardControlRequestSchema: z.ZodObject<{
         guildId: z.ZodString;
         moduleId: z.ZodString;
         actionId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"guild.module.resource.access">;
+        guildId: z.ZodString;
+        moduleId: z.ZodString;
+        resourceType: z.ZodString;
+        operation: z.ZodEnum<{
+            list: "list";
+            read: "read";
+        }>;
+        actorUserId: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
         actorUserId: z.ZodString;
         correlationId: z.ZodString;
@@ -537,6 +659,100 @@ export declare const shardControlRequestSchema: z.ZodObject<{
             readonly dashboard_security: "dashboard_security";
             readonly discord_command: "discord_command";
         }>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"verification.result.accept">;
+        envelope: z.ZodObject<{
+            payload: z.ZodObject<{
+                protocolVersion: z.ZodLiteral<"1.0">;
+                scoreVersion: z.ZodString;
+                policyVersion: z.ZodString;
+                installationId: z.ZodUUID;
+                deploymentSourceClassification: z.ZodEnum<{
+                    helyx_hosted: "helyx_hosted";
+                    self_hosted_reported: "self_hosted_reported";
+                }>;
+                evidenceSources: z.ZodObject<{
+                    discord: z.ZodEnum<{
+                        helyx_hosted: "helyx_hosted";
+                        self_hosted_reported: "self_hosted_reported";
+                    }>;
+                    browser: z.ZodLiteral<"helyx_observed_web">;
+                    network: z.ZodLiteral<"provider_observed">;
+                }, z.core.$strict>;
+                guildId: z.ZodString;
+                userId: z.ZodString;
+                challengeId: z.ZodUUID;
+                attemptId: z.ZodUUID;
+                decision: z.ZodEnum<{
+                    pass: "pass";
+                    review: "review";
+                    deny: "deny";
+                    temporary_failure: "temporary_failure";
+                }>;
+                riskScore: z.ZodNullable<z.ZodNumber>;
+                riskBand: z.ZodEnum<{
+                    low: "low";
+                    medium: "medium";
+                    high: "high";
+                    incomplete: "incomplete";
+                }>;
+                reasonCodes: z.ZodArray<z.ZodEnum<{
+                    "network.proxy": "network.proxy";
+                    "network.vpn": "network.vpn";
+                    "network.compromised": "network.compromised";
+                    "network.scraper": "network.scraper";
+                    "network.tor": "network.tor";
+                    "network.hosting": "network.hosting";
+                    "network.anonymous": "network.anonymous";
+                    "network.country_policy": "network.country_policy";
+                    "account.too_new": "account.too_new";
+                    "account.name_quarantined": "account.name_quarantined";
+                    "relationship.exact_device_server_enforced": "relationship.exact_device_server_enforced";
+                    "relationship.strong_server_enforced": "relationship.strong_server_enforced";
+                    "relationship.exact_device": "relationship.exact_device";
+                    "relationship.strong": "relationship.strong";
+                    "relationship.possible": "relationship.possible";
+                    "relationship.ip_only": "relationship.ip_only";
+                    "abuse.concurrent_submission": "abuse.concurrent_submission";
+                    "abuse.token_replay": "abuse.token_replay";
+                    "trust.prior_server_success": "trust.prior_server_success";
+                    "trust.other_server_success": "trust.other_server_success";
+                    "trust.reviewed_public_flag": "trust.reviewed_public_flag";
+                    "rule.account_age": "rule.account_age";
+                    "rule.network_category": "rule.network_category";
+                    "rule.country": "rule.country";
+                    "rule.banned_account_relationship": "rule.banned_account_relationship";
+                    "evidence.network_incomplete": "evidence.network_incomplete";
+                    "service.temporary_failure": "service.temporary_failure";
+                }>>;
+                overridingRule: z.ZodOptional<z.ZodEnum<{
+                    "rule.account_age": "rule.account_age";
+                    "rule.network_category": "rule.network_category";
+                    "rule.country": "rule.country";
+                    "rule.banned_account_relationship": "rule.banned_account_relationship";
+                }>>;
+                actionBoundary: z.ZodObject<{
+                    recommendedAction: z.ZodEnum<{
+                        none: "none";
+                        grant_role: "grant_role";
+                        kick: "kick";
+                        ban: "ban";
+                    }>;
+                    allowedActions: z.ZodArray<z.ZodEnum<{
+                        none: "none";
+                        grant_role: "grant_role";
+                        kick: "kick";
+                        ban: "ban";
+                    }>>;
+                }, z.core.$strict>;
+                issuedAt: z.ZodISODateTime;
+                expiresAt: z.ZodISODateTime;
+                resultNonce: z.ZodString;
+            }, z.core.$strict>;
+            signature: z.ZodString;
+            keyId: z.ZodString;
+            algorithm: z.ZodLiteral<"Ed25519">;
+        }, z.core.$strict>;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"privacy.providers.list">;
     }, z.core.$strict>, z.ZodObject<{
@@ -1072,6 +1288,10 @@ export declare const supervisorMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObje
     operation: z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"guild.state.get">;
         guildId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"guild.presence.list">;
+        guildIds: z.ZodArray<z.ZodString>;
+        correlationId: z.ZodUUID;
     }, z.core.$strict>, z.ZodObject<{
         actorUserId: z.ZodString;
         correlationId: z.ZodString;
@@ -1137,6 +1357,16 @@ export declare const supervisorMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObje
         guildId: z.ZodString;
         moduleId: z.ZodString;
         actionId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"guild.module.resource.access">;
+        guildId: z.ZodString;
+        moduleId: z.ZodString;
+        resourceType: z.ZodString;
+        operation: z.ZodEnum<{
+            list: "list";
+            read: "read";
+        }>;
+        actorUserId: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
         actorUserId: z.ZodString;
         correlationId: z.ZodString;
@@ -1241,6 +1471,100 @@ export declare const supervisorMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObje
             readonly dashboard_security: "dashboard_security";
             readonly discord_command: "discord_command";
         }>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"verification.result.accept">;
+        envelope: z.ZodObject<{
+            payload: z.ZodObject<{
+                protocolVersion: z.ZodLiteral<"1.0">;
+                scoreVersion: z.ZodString;
+                policyVersion: z.ZodString;
+                installationId: z.ZodUUID;
+                deploymentSourceClassification: z.ZodEnum<{
+                    helyx_hosted: "helyx_hosted";
+                    self_hosted_reported: "self_hosted_reported";
+                }>;
+                evidenceSources: z.ZodObject<{
+                    discord: z.ZodEnum<{
+                        helyx_hosted: "helyx_hosted";
+                        self_hosted_reported: "self_hosted_reported";
+                    }>;
+                    browser: z.ZodLiteral<"helyx_observed_web">;
+                    network: z.ZodLiteral<"provider_observed">;
+                }, z.core.$strict>;
+                guildId: z.ZodString;
+                userId: z.ZodString;
+                challengeId: z.ZodUUID;
+                attemptId: z.ZodUUID;
+                decision: z.ZodEnum<{
+                    pass: "pass";
+                    review: "review";
+                    deny: "deny";
+                    temporary_failure: "temporary_failure";
+                }>;
+                riskScore: z.ZodNullable<z.ZodNumber>;
+                riskBand: z.ZodEnum<{
+                    low: "low";
+                    medium: "medium";
+                    high: "high";
+                    incomplete: "incomplete";
+                }>;
+                reasonCodes: z.ZodArray<z.ZodEnum<{
+                    "network.proxy": "network.proxy";
+                    "network.vpn": "network.vpn";
+                    "network.compromised": "network.compromised";
+                    "network.scraper": "network.scraper";
+                    "network.tor": "network.tor";
+                    "network.hosting": "network.hosting";
+                    "network.anonymous": "network.anonymous";
+                    "network.country_policy": "network.country_policy";
+                    "account.too_new": "account.too_new";
+                    "account.name_quarantined": "account.name_quarantined";
+                    "relationship.exact_device_server_enforced": "relationship.exact_device_server_enforced";
+                    "relationship.strong_server_enforced": "relationship.strong_server_enforced";
+                    "relationship.exact_device": "relationship.exact_device";
+                    "relationship.strong": "relationship.strong";
+                    "relationship.possible": "relationship.possible";
+                    "relationship.ip_only": "relationship.ip_only";
+                    "abuse.concurrent_submission": "abuse.concurrent_submission";
+                    "abuse.token_replay": "abuse.token_replay";
+                    "trust.prior_server_success": "trust.prior_server_success";
+                    "trust.other_server_success": "trust.other_server_success";
+                    "trust.reviewed_public_flag": "trust.reviewed_public_flag";
+                    "rule.account_age": "rule.account_age";
+                    "rule.network_category": "rule.network_category";
+                    "rule.country": "rule.country";
+                    "rule.banned_account_relationship": "rule.banned_account_relationship";
+                    "evidence.network_incomplete": "evidence.network_incomplete";
+                    "service.temporary_failure": "service.temporary_failure";
+                }>>;
+                overridingRule: z.ZodOptional<z.ZodEnum<{
+                    "rule.account_age": "rule.account_age";
+                    "rule.network_category": "rule.network_category";
+                    "rule.country": "rule.country";
+                    "rule.banned_account_relationship": "rule.banned_account_relationship";
+                }>>;
+                actionBoundary: z.ZodObject<{
+                    recommendedAction: z.ZodEnum<{
+                        none: "none";
+                        grant_role: "grant_role";
+                        kick: "kick";
+                        ban: "ban";
+                    }>;
+                    allowedActions: z.ZodArray<z.ZodEnum<{
+                        none: "none";
+                        grant_role: "grant_role";
+                        kick: "kick";
+                        ban: "ban";
+                    }>>;
+                }, z.core.$strict>;
+                issuedAt: z.ZodISODateTime;
+                expiresAt: z.ZodISODateTime;
+                resultNonce: z.ZodString;
+            }, z.core.$strict>;
+            signature: z.ZodString;
+            keyId: z.ZodString;
+            algorithm: z.ZodLiteral<"Ed25519">;
+        }, z.core.$strict>;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"privacy.providers.list">;
     }, z.core.$strict>, z.ZodObject<{

package/dist/shard-contracts.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { signedAssessmentEnvelopeSchema } from "@helyx/verification-contracts";
 export const SHARD_CONTRACT_VERSION = 1;
 // Guild dashboard state includes the bounded module catalogue as well as the
 // guild's Discord resources. Keep this aligned with the cloud-control message
@@ -61,7 +62,7 @@ const managedResourceObject = z
     .refine(hasBoundedManagedResourceBytes);
 const managedResourceFilters = z
     .record(z.string().regex(/^[a-z][a-zA-Z0-9_]*$/u), z.string().trim().min(1).max(100))
-    .refine((value) => Object.keys(value).length <= 5);
+    .refine((value) => Object.keys(value).length <= 8);
 const scheduledTaskPayload = z
     .record(z.string().regex(/^[a-z][A-Za-z0-9]{0,62}Id$/u), z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$/u))
     .refine((value) => Object.keys(value).length <= 20)
@@ -221,6 +222,13 @@ export const shardHealthSnapshotSchema = z
 });
 export const shardControlOperationSchema = z.discriminatedUnion("kind", [
     z.object({ kind: z.literal("guild.state.get"), guildId: snowflake }).strict(),
+    z
+        .object({
+        kind: z.literal("guild.presence.list"),
+        guildIds: z.array(snowflake).min(1).max(200),
+        correlationId: z.uuid(),
+    })
+        .strict(),
     z
         .object({
         kind: z.literal("guild.module.status.set"),
@@ -269,6 +277,16 @@ export const shardControlOperationSchema = z.discriminatedUnion("kind", [
         ...mutationContext.shape,
     })
         .strict(),
+    z
+        .object({
+        kind: z.literal("guild.module.resource.access"),
+        guildId: snowflake,
+        moduleId,
+        resourceType,
+        operation: z.enum(["list", "read"]),
+        actorUserId: snowflake,
+    })
+        .strict(),
     z
         .object({
         kind: z.literal("guild.module.resource.list"),
@@ -391,6 +409,12 @@ export const shardControlOperationSchema = z.discriminatedUnion("kind", [
         }),
     })
         .strict(),
+    z
+        .object({
+        kind: z.literal("verification.result.accept"),
+        envelope: signedAssessmentEnvelopeSchema,
+    })
+        .strict(),
     z.object({ kind: z.literal("privacy.providers.list") }).strict(),
     z
         .object({
@@ -856,7 +880,13 @@ export function guildIdToShardId(guildId, shardCount) {
     return Number((BigInt(parsedGuildId) >> 22n) % BigInt(shardCount));
 }
 export function controlOperationGuildId(operation) {
-    return "guildId" in operation ? operation.guildId : undefined;
+    if ("guildId" in operation)
+        return operation.guildId;
+    if (operation.kind === "verification.result.accept")
+        return operation.envelope.payload.guildId;
+    return operation.kind === "guild.presence.list"
+        ? operation.guildIds[0]
+        : undefined;
 }
 export function assertShardMessageSize(value) {
     if (Buffer.byteLength(JSON.stringify(value), "utf8") > SHARD_CONTROL_MAX_BYTES)
@@ -864,8 +894,21 @@ export function assertShardMessageSize(value) {
 }
 export async function executeShardControlOperation(handler, operation) {
     switch (operation.kind) {
+        case "guild.presence.list":
+            return handler.listGuildPresence({
+                guildIds: operation.guildIds,
+                correlationId: operation.correlationId,
+            });
         case "guild.state.get":
             return handler.getGuildState(operation.guildId);
+        case "guild.module.resource.access":
+            return handler.canAccessManagedResource({
+                guildId: operation.guildId,
+                moduleId: operation.moduleId,
+                resourceType: operation.resourceType,
+                operation: operation.operation,
+                actorUserId: operation.actorUserId,
+            });
         case "guild.module.status.set": {
             return handler.setModuleStatus({
                 guildId: operation.guildId,
@@ -1014,6 +1057,8 @@ export async function executeShardControlOperation(handler, operation) {
                 source: operation.source,
             });
         }
+        case "verification.result.accept":
+            return handler.acceptVerificationResult(operation.envelope);
         case "privacy.providers.list":
             return handler.listPrivacyProviders();
         case "privacy.capture": {

package/dist/shard-router.d.ts

@@ -16,6 +16,8 @@ export declare class ShardControlRouter implements BotControlHandler {
         notificationGuildId?: string;
     });
     getGuildState(guildId: string): ReturnType<BotControlHandler["getGuildState"]>;
+    canAccessManagedResource(input: Parameters<BotControlHandler["canAccessManagedResource"]>[0]): ReturnType<BotControlHandler["canAccessManagedResource"]>;
+    listGuildPresence(input: Parameters<BotControlHandler["listGuildPresence"]>[0]): ReturnType<BotControlHandler["listGuildPresence"]>;
     setModuleStatus(input: Parameters<BotControlHandler["setModuleStatus"]>[0]): ReturnType<BotControlHandler["setModuleStatus"]>;
     updateConfiguration(input: Parameters<BotControlHandler["updateConfiguration"]>[0]): ReturnType<BotControlHandler["updateConfiguration"]>;
     updatePermissions(input: Parameters<BotControlHandler["updatePermissions"]>[0]): ReturnType<BotControlHandler["updatePermissions"]>;
@@ -30,6 +32,7 @@ export declare class ShardControlRouter implements BotControlHandler {
     deleteManagedResource(input: Parameters<BotControlHandler["deleteManagedResource"]>[0]): ReturnType<BotControlHandler["deleteManagedResource"]>;
     executeManagedResourceAction(input: Parameters<BotControlHandler["executeManagedResourceAction"]>[0]): ReturnType<BotControlHandler["executeManagedResourceAction"]>;
     sendSupportNotification(input: Parameters<BotControlHandler["sendSupportNotification"]>[0]): ReturnType<BotControlHandler["sendSupportNotification"]>;
+    acceptVerificationResult(envelope: Parameters<BotControlHandler["acceptVerificationResult"]>[0]): ReturnType<BotControlHandler["acceptVerificationResult"]>;
     listPrivacyProviders(): ReturnType<BotControlHandler["listPrivacyProviders"]>;
     capturePrivacy(input: Parameters<BotControlHandler["capturePrivacy"]>[0]): ReturnType<BotControlHandler["capturePrivacy"]>;
     erasePrivacy(input: Parameters<BotControlHandler["erasePrivacy"]>[0]): ReturnType<BotControlHandler["erasePrivacy"]>;

package/dist/shard-router.js

@@ -10,6 +10,42 @@ export class ShardControlRouter {
     getGuildState(guildId) {
         return this.#route({ kind: "guild.state.get", guildId });
     }
+    canAccessManagedResource(input) {
+        return this.#route({
+            kind: "guild.module.resource.access",
+            ...input,
+        });
+    }
+    async listGuildPresence(input) {
+        const observations = new Map();
+        const byShard = new Map();
+        for (const guildId of [...new Set(input.guildIds)]) {
+            const shardId = guildIdToShardId(guildId, this.input.shardCount);
+            const guildIds = byShard.get(shardId) ?? [];
+            guildIds.push(guildId);
+            byShard.set(shardId, guildIds);
+        }
+        await Promise.all([...byShard.values()].map(async (guildIds) => {
+            try {
+                const result = await this.#route({
+                    kind: "guild.presence.list",
+                    guildIds,
+                    correlationId: input.correlationId,
+                });
+                for (const observation of result)
+                    observations.set(observation.guildId, observation);
+            }
+            catch {
+                // A starting, draining, or reassigned shard is unknown, never absent.
+            }
+        }));
+        const observedAt = new Date().toISOString();
+        return [...new Set(input.guildIds)].map((guildId) => observations.get(guildId) ?? {
+            guildId,
+            state: "unknown",
+            observedAt,
+        });
+    }
     setModuleStatus(input) {
         return this.#route({ kind: "guild.module.status.set", ...input });
     }
@@ -85,6 +121,12 @@ export class ShardControlRouter {
             ...input,
         });
     }
+    acceptVerificationResult(envelope) {
+        return this.#route({
+            kind: "verification.result.accept",
+            envelope,
+        });
+    }
     listPrivacyProviders() {
         return this.#routeLeader({ kind: "privacy.providers.list" });
     }

package/dist/shard-supervisor.d.ts

@@ -5,6 +5,7 @@ import { type ShardCloudRequest, type ShardIdentity, type ShardProcessHealth } f
 import { type ShardCoordinator, type ShardGenerationDescriptor, type ShardLeaderLease, type ShardLease } from "./shard-coordinator.js";
 import type { BotHandle } from "./index.js";
 export declare const STEADY_STATE_LEASE_LOSS_BOUND_MS: number;
+export declare function supervisorShutdownExitCode(reason: string): number | undefined;
 export declare function createStartupWorkerHeartbeatMaintenance(heartbeat: () => void, intervalMs?: number): {
     stop(): void;
 };
@@ -20,6 +21,7 @@ export interface SteadyStateOwnershipRenewal {
     leaderRenewed: boolean;
     leaderAvailable: boolean;
 }
+export declare function retryOwnershipRenewal<T>(renew: () => Promise<T>, attempts?: number): Promise<T>;
 export declare function selectFencedShardHealth(input: {
     generation: string;
     shardCount: number;