@helyx/bot 0.4.2 → 0.4.4

package/dist/shard-contracts.js

@@ -43,6 +43,36 @@ const configurationValue = z.record(z.string().min(1).max(100), z.union([
     z.number().finite(),
     z.array(z.string().max(4_000)).max(100),
 ]));
+const resourceType = z.string().regex(/^[a-z][a-z0-9_-]*$/u);
+const resourceId = z.string().trim().min(1).max(100);
+const resourceCursor = z.string().min(1).max(2_048);
+const managedResourceValue = z.custom((value) => isBoundedManagedResourceValue(value), "Managed resource value exceeds the transport limits");
+const managedResourceObject = z
+    .record(z.string().min(1).max(100), managedResourceValue)
+    .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);
+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)
+    .refine((value) => Buffer.byteLength(JSON.stringify(value), "utf8") <= 2_048);
+const scheduledTaskResult = z.discriminatedUnion("outcome", [
+    z.object({ outcome: z.literal("completed") }).strict(),
+    z
+        .object({
+        outcome: z.enum(["deferred", "retry"]),
+        delayMs: z.number().int().min(100).max(86_400_000),
+        safeCode: z.string().regex(/^[a-z0-9][a-z0-9._-]{0,99}$/u),
+    })
+        .strict(),
+    z
+        .object({
+        outcome: z.literal("requires_review"),
+        safeCode: z.string().regex(/^[a-z0-9][a-z0-9._-]{0,99}$/u),
+    })
+        .strict(),
+]);
 export const shardIdentitySchema = z
     .object({
     version: z.literal(SHARD_CONTRACT_VERSION),
@@ -108,6 +138,27 @@ const sessionStartBudgetSchema = z
     observedAt: dateTime,
 })
     .strict();
+const schedulerWorkHealthSchema = z
+    .object({
+    sampleLimit: z.number().int().min(1).max(5_000),
+    sampled: z.number().int().min(0),
+    ready: z.number().int().min(0),
+    expiredLeases: z.number().int().min(0),
+    retried: z.number().int().min(0),
+    requiresReview: z.number().int().min(0),
+    oldestReadyAt: dateTime.nullable(),
+})
+    .strict();
+export const schedulerOperationalHealthSchema = z.discriminatedUnion("status", [
+    z
+        .object({
+        status: z.literal("available"),
+        oneShot: schedulerWorkHealthSchema,
+        coalesced: schedulerWorkHealthSchema,
+    })
+        .strict(),
+    z.object({ status: z.literal("unavailable") }).strict(),
+]);
 export const shardHealthSnapshotSchema = z
     .object({
     version: z.literal(SHARD_CONTRACT_VERSION),
@@ -125,6 +176,7 @@ export const shardHealthSnapshotSchema = z
         database: z.enum(["healthy", "degraded", "unavailable"]),
     })
         .strict(),
+    scheduler: schedulerOperationalHealthSchema.optional(),
     sessionStarts: sessionStartBudgetSchema.optional(),
     shards: z.array(shardProcessHealthSchema).max(4_096),
 })
@@ -193,6 +245,118 @@ export const shardControlOperationSchema = z.discriminatedUnion("kind", [
         ...mutationContext.shape,
     })
         .strict(),
+    z
+        .object({
+        kind: z.literal("guild.module.resource.list"),
+        guildId: snowflake,
+        moduleId,
+        resourceType,
+        cursor: resourceCursor.optional(),
+        limit: z.number().int().min(1).max(50),
+        search: z.string().trim().min(1).max(200).optional(),
+        filters: managedResourceFilters.optional(),
+        ...mutationContext.shape,
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("guild.module.resource.read"),
+        guildId: snowflake,
+        moduleId,
+        resourceType,
+        resourceId,
+        ...mutationContext.shape,
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("guild.module.resource.relation.list"),
+        guildId: snowflake,
+        moduleId,
+        resourceType,
+        resourceId,
+        relationId: resourceType,
+        cursor: resourceCursor.optional(),
+        limit: z.number().int().min(1).max(50),
+        ...mutationContext.shape,
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("guild.module.resource.preview"),
+        guildId: snowflake,
+        moduleId,
+        resourceType,
+        value: managedResourceObject,
+        ...mutationContext.shape,
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("guild.module.resource.create"),
+        guildId: snowflake,
+        moduleId,
+        resourceType,
+        intent: z.enum(["draft", "publish"]),
+        value: managedResourceObject,
+        ...mutationContext.shape,
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("guild.module.resource.update"),
+        guildId: snowflake,
+        moduleId,
+        resourceType,
+        resourceId,
+        expectedRevision: z.number().int().min(0),
+        value: managedResourceObject,
+        ...mutationContext.shape,
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("guild.module.resource.delete"),
+        guildId: snowflake,
+        moduleId,
+        resourceType,
+        resourceId,
+        expectedRevision: z.number().int().min(0),
+        ...mutationContext.shape,
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("guild.module.resource.action.execute"),
+        guildId: snowflake,
+        moduleId,
+        resourceType,
+        resourceId,
+        actionId: resourceType,
+        expectedRevision: z.number().int().min(0),
+        value: managedResourceObject,
+        ...mutationContext.shape,
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("support.notification.send"),
+        guildId: snowflake,
+        notificationId: z.uuid(),
+        reference: z.string().trim().min(1).max(40),
+        caseType: z.enum(["bug", "general_support", "security"]),
+        categoryOrModule: z.string().trim().min(1).max(100),
+        reportedSeverity: z
+            .enum(["low", "medium", "high", "critical"])
+            .nullable(),
+        source: z.enum([
+            "dashboard_bug",
+            "dashboard_support",
+            "dashboard_security",
+            "discord_command",
+        ]),
+    })
+        .strict(),
     z.object({ kind: z.literal("privacy.providers.list") }).strict(),
     z
         .object({
@@ -269,6 +433,19 @@ const shardCloudOperationSchema = z.discriminatedUnion("kind", [
         .strict(),
     z.object({ kind: z.literal("cloud.disconnect") }).strict(),
     z.object({ kind: z.literal("cloud.rotate") }).strict(),
+    z
+        .object({
+        kind: z.literal("support.bug.create"),
+        reporterDiscordUserId: snowflake,
+        guildId: snowflake,
+        moduleOrArea: z.string().trim().min(1).max(100),
+        summary: z.string().trim().min(10).max(200),
+        whatHappened: z.string().trim().min(10).max(1_000),
+        extraDetail: z.string().trim().min(1).max(1_000).optional(),
+        interactionId: snowflake,
+        correlationId: z.uuid(),
+    })
+        .strict(),
 ]);
 export const shardCloudRequestSchema = z
     .object({
@@ -315,10 +492,53 @@ export const shardOperationsHealthResponseSchema = z
     health: shardHealthSnapshotSchema,
 })
     .strict();
+export const shardScheduledTaskRequestSchema = z
+    .object({
+    version: z.literal(SHARD_CONTRACT_VERSION),
+    type: z.literal("helyx.scheduled.request"),
+    requestId: z.uuid(),
+    deadlineAt: dateTime,
+    identity: shardIdentitySchema,
+    task: z.discriminatedUnion("delivery", [
+        z
+            .object({
+            delivery: z.literal("one-shot"),
+            taskId: z.uuid(),
+            moduleId,
+            taskKind: z.string().regex(/^[a-z][a-z0-9]*(?:[._-][a-z0-9]+)*$/u),
+            taskVersion: z.number().int().positive(),
+            guildId: snowflake,
+            payload: scheduledTaskPayload,
+        })
+            .strict(),
+        z
+            .object({
+            delivery: z.literal("coalesced"),
+            taskId: z.uuid(),
+            moduleId,
+            taskKind: z.string().regex(/^[a-z][a-z0-9]*(?:[._-][a-z0-9]+)*$/u),
+            taskVersion: z.number().int().positive(),
+            guildId: snowflake,
+            payload: scheduledTaskPayload,
+            claimedGeneration: z.number().int().positive(),
+        })
+            .strict(),
+    ]),
+})
+    .strict();
+export const shardScheduledTaskResponseSchema = z
+    .object({
+    version: z.literal(SHARD_CONTRACT_VERSION),
+    type: z.literal("helyx.scheduled.response"),
+    requestId: z.uuid(),
+    result: scheduledTaskResult,
+})
+    .strict();
 export const supervisorMessageSchema = z.discriminatedUnion("type", [
     shardControlRequestSchema,
     shardCloudResponseSchema,
     shardOperationsHealthResponseSchema,
+    shardScheduledTaskRequestSchema,
     z
         .object({
         version: z.literal(SHARD_CONTRACT_VERSION),
@@ -344,6 +564,7 @@ export const workerMessageSchema = z.discriminatedUnion("type", [
     shardControlResponseSchema,
     shardCloudRequestSchema,
     shardOperationsHealthRequestSchema,
+    shardScheduledTaskResponseSchema,
     z
         .object({
         version: z.literal(SHARD_CONTRACT_VERSION),
@@ -418,6 +639,103 @@ export async function executeShardControlOperation(handler, operation) {
                 correlationId: operation.correlationId,
             });
         }
+        case "guild.module.resource.list":
+            return handler.listManagedResources({
+                guildId: operation.guildId,
+                moduleId: operation.moduleId,
+                resourceType: operation.resourceType,
+                ...(operation.cursor === undefined ? {} : { cursor: operation.cursor }),
+                ...(operation.search === undefined ? {} : { search: operation.search }),
+                ...(operation.filters === undefined
+                    ? {}
+                    : { filters: operation.filters }),
+                limit: operation.limit,
+                actorUserId: operation.actorUserId,
+                correlationId: operation.correlationId,
+            });
+        case "guild.module.resource.read":
+            return handler.readManagedResource({
+                guildId: operation.guildId,
+                moduleId: operation.moduleId,
+                resourceType: operation.resourceType,
+                resourceId: operation.resourceId,
+                actorUserId: operation.actorUserId,
+                correlationId: operation.correlationId,
+            });
+        case "guild.module.resource.relation.list":
+            return handler.listManagedResourceRelation({
+                guildId: operation.guildId,
+                moduleId: operation.moduleId,
+                resourceType: operation.resourceType,
+                resourceId: operation.resourceId,
+                relationId: operation.relationId,
+                ...(operation.cursor === undefined ? {} : { cursor: operation.cursor }),
+                limit: operation.limit,
+                actorUserId: operation.actorUserId,
+                correlationId: operation.correlationId,
+            });
+        case "guild.module.resource.preview":
+            return handler.previewManagedResource({
+                guildId: operation.guildId,
+                moduleId: operation.moduleId,
+                resourceType: operation.resourceType,
+                value: operation.value,
+                actorUserId: operation.actorUserId,
+                correlationId: operation.correlationId,
+            });
+        case "guild.module.resource.create":
+            return handler.createManagedResource({
+                guildId: operation.guildId,
+                moduleId: operation.moduleId,
+                resourceType: operation.resourceType,
+                intent: operation.intent,
+                value: operation.value,
+                actorUserId: operation.actorUserId,
+                correlationId: operation.correlationId,
+            });
+        case "guild.module.resource.update":
+            return handler.updateManagedResource({
+                guildId: operation.guildId,
+                moduleId: operation.moduleId,
+                resourceType: operation.resourceType,
+                resourceId: operation.resourceId,
+                expectedRevision: operation.expectedRevision,
+                value: operation.value,
+                actorUserId: operation.actorUserId,
+                correlationId: operation.correlationId,
+            });
+        case "guild.module.resource.delete":
+            return handler.deleteManagedResource({
+                guildId: operation.guildId,
+                moduleId: operation.moduleId,
+                resourceType: operation.resourceType,
+                resourceId: operation.resourceId,
+                expectedRevision: operation.expectedRevision,
+                actorUserId: operation.actorUserId,
+                correlationId: operation.correlationId,
+            });
+        case "guild.module.resource.action.execute":
+            return handler.executeManagedResourceAction({
+                guildId: operation.guildId,
+                moduleId: operation.moduleId,
+                resourceType: operation.resourceType,
+                resourceId: operation.resourceId,
+                actionId: operation.actionId,
+                expectedRevision: operation.expectedRevision,
+                value: operation.value,
+                actorUserId: operation.actorUserId,
+                correlationId: operation.correlationId,
+            });
+        case "support.notification.send": {
+            return handler.sendSupportNotification({
+                notificationId: operation.notificationId,
+                reference: operation.reference,
+                caseType: operation.caseType,
+                categoryOrModule: operation.categoryOrModule,
+                reportedSeverity: operation.reportedSeverity,
+                source: operation.source,
+            });
+        }
         case "privacy.providers.list":
             return handler.listPrivacyProviders();
         case "privacy.capture": {
@@ -442,4 +760,32 @@ export async function executeShardControlOperation(handler, operation) {
         }
     }
 }
+function isBoundedManagedResourceValue(value, depth = 0, budget = { keys: 0 }) {
+    if (depth > 8)
+        return false;
+    if (value === null ||
+        typeof value === "boolean" ||
+        (typeof value === "number" && Number.isFinite(value)))
+        return true;
+    if (typeof value === "string")
+        return value.length <= 4_000;
+    if (Array.isArray(value))
+        return (value.length <= 100 &&
+            value.every((item) => isBoundedManagedResourceValue(item, depth + 1, budget)));
+    if (typeof value !== "object")
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null)
+        return false;
+    const entries = Object.entries(value);
+    budget.keys += entries.length;
+    return (entries.length <= 100 &&
+        budget.keys <= 500 &&
+        entries.every(([key, item]) => key.length >= 1 &&
+            key.length <= 100 &&
+            isBoundedManagedResourceValue(item, depth + 1, budget)));
+}
+function hasBoundedManagedResourceBytes(value) {
+    return (new TextEncoder().encode(JSON.stringify(value)).byteLength <= 48 * 1_024);
+}
 //# sourceMappingURL=shard-contracts.js.map

package/dist/shard-coordinator.d.ts

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { z } from "zod";
-import { type ShardControlRequest, type ShardControlResponse, type ShardCloudRequest, type ShardCloudResponse, type ShardIdentity, type ShardProcessHealth } from "./shard-contracts.js";
+import { type ShardControlRequest, type ShardControlResponse, type ShardCloudRequest, type ShardCloudResponse, type ShardIdentity, type ShardProcessHealth, type ShardScheduledTaskRequest, type ShardScheduledTaskResponse } from "./shard-contracts.js";
 declare const generationDescriptorSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
     applicationId: z.ZodString;
@@ -30,7 +30,7 @@ declare const leaderLeaseSchema: z.ZodObject<{
 export type ShardLeaderLease = z.infer<typeof leaderLeaseSchema>;
 export interface ShardCoordinator {
     readonly supervisorId: ReturnType<typeof randomUUID>;
-    start(handler: (targetShardId: number, request: ShardControlRequest) => Promise<ShardControlResponse>, leaderHandler?: (request: ShardControlRequest) => Promise<ShardControlResponse>, cloudHandler?: (request: ShardCloudRequest) => Promise<ShardCloudResponse>): Promise<void>;
+    start(handler: (targetShardId: number, request: ShardControlRequest) => Promise<ShardControlResponse>, leaderHandler?: (request: ShardControlRequest) => Promise<ShardControlResponse>, cloudHandler?: (request: ShardCloudRequest) => Promise<ShardCloudResponse>, scheduledHandler?: (targetShardId: number, request: ShardScheduledTaskRequest) => Promise<ShardScheduledTaskResponse>): Promise<void>;
     checkReady(): Promise<void>;
     assertGeneration(descriptor: ShardGenerationDescriptor, proposedDeploymentOrder: number): Promise<number>;
     refreshGeneration(descriptor: ShardGenerationDescriptor, deploymentOrder: number): Promise<boolean>;
@@ -44,6 +44,7 @@ export interface ShardCoordinator {
     releaseLeader(lease: ShardLeaderLease): Promise<boolean>;
     getLeaderLease(): Promise<ShardLeaderLease | undefined>;
     routeRemote(lease: ShardLease, request: ShardControlRequest): Promise<ShardControlResponse>;
+    routeRemoteScheduled(lease: ShardLease, request: ShardScheduledTaskRequest): Promise<ShardScheduledTaskResponse>;
     routeLeader(lease: ShardLeaderLease, request: ShardControlRequest): Promise<ShardControlResponse>;
     routeLeaderCloud(lease: ShardLeaderLease, request: ShardCloudRequest): Promise<ShardCloudResponse>;
     reserveSessionStarts(count: number, available: number, resetAfterMs: number): Promise<boolean>;
@@ -61,7 +62,7 @@ export declare class RedisShardCoordinator implements ShardCoordinator {
     constructor(redisUrl: string, namespace: string, options?: {
         onError?: (error: Error) => void;
     });
-    start(handler: (targetShardId: number, request: ShardControlRequest) => Promise<ShardControlResponse>, leaderHandler?: (request: ShardControlRequest) => Promise<ShardControlResponse>, cloudHandler?: (request: ShardCloudRequest) => Promise<ShardCloudResponse>): Promise<void>;
+    start(handler: (targetShardId: number, request: ShardControlRequest) => Promise<ShardControlResponse>, leaderHandler?: (request: ShardControlRequest) => Promise<ShardControlResponse>, cloudHandler?: (request: ShardCloudRequest) => Promise<ShardCloudResponse>, scheduledHandler?: (targetShardId: number, request: ShardScheduledTaskRequest) => Promise<ShardScheduledTaskResponse>): Promise<void>;
     checkReady(): Promise<void>;
     assertGeneration(descriptor: ShardGenerationDescriptor, proposedDeploymentOrder: number): Promise<number>;
     refreshGeneration(descriptor: ShardGenerationDescriptor, deploymentOrder: number): Promise<boolean>;
@@ -75,6 +76,7 @@ export declare class RedisShardCoordinator implements ShardCoordinator {
     releaseLeader(lease: ShardLeaderLease): Promise<boolean>;
     getLeaderLease(): Promise<ShardLeaderLease | undefined>;
     routeRemote(lease: ShardLease, request: ShardControlRequest): Promise<ShardControlResponse>;
+    routeRemoteScheduled(lease: ShardLease, request: ShardScheduledTaskRequest): Promise<ShardScheduledTaskResponse>;
     routeLeader(lease: ShardLeaderLease, request: ShardControlRequest): Promise<ShardControlResponse>;
     routeLeaderCloud(lease: ShardLeaderLease, request: ShardCloudRequest): Promise<ShardCloudResponse>;
     reserveSessionStarts(count: number, available: number, resetAfterMs: number): Promise<boolean>;

package/dist/shard-coordinator.js

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { createClient } from "redis";
 import { z } from "zod";
-import { SHARD_CONTROL_MAX_BYTES, assertShardMessageSize, shardCloudRequestSchema, shardCloudResponseSchema, shardControlRequestSchema, shardControlResponseSchema, shardIdentitySchema, shardProcessHealthSchema, } from "./shard-contracts.js";
+import { SHARD_CONTROL_MAX_BYTES, assertShardMessageSize, shardCloudRequestSchema, shardCloudResponseSchema, shardControlRequestSchema, shardControlResponseSchema, shardIdentitySchema, shardProcessHealthSchema, shardScheduledTaskRequestSchema, shardScheduledTaskResponseSchema, } from "./shard-contracts.js";
 const LEASE_TTL_MS = 30_000;
 const HEALTH_TTL_MS = 30_000;
 const GENERATION_TTL_MS = 30_000;
@@ -52,6 +52,15 @@ const remoteRequestSchema = z.discriminatedUnion("target", [
         request: shardControlRequestSchema,
     })
         .strict(),
+    z
+        .object({
+        version: z.literal(1),
+        type: z.literal("helyx.remote.request"),
+        target: z.literal("scheduled"),
+        targetShardId: z.number().int().min(0).max(4_095),
+        request: shardScheduledTaskRequestSchema,
+    })
+        .strict(),
     z
         .object({
         version: z.literal(1),
@@ -86,6 +95,7 @@ export class RedisShardCoordinator {
     #handler;
     #leaderHandler;
     #cloudHandler;
+    #scheduledHandler;
     constructor(redisUrl, namespace, options = {}) {
         this.#prefix = `helyx:shard:v1:${namespace}`;
         this.#command = createClient({ url: redisUrl });
@@ -94,10 +104,11 @@ export class RedisShardCoordinator {
         this.#command.on("error", (error) => this.#report(error));
         this.#subscriber.on("error", (error) => this.#report(error));
     }
-    async start(handler, leaderHandler, cloudHandler) {
+    async start(handler, leaderHandler, cloudHandler, scheduledHandler) {
         this.#handler = handler;
         this.#leaderHandler = leaderHandler;
         this.#cloudHandler = cloudHandler;
+        this.#scheduledHandler = scheduledHandler;
         await Promise.all([this.#command.connect(), this.#subscriber.connect()]);
         await this.#subscriber.subscribe(this.#requestChannel(), (raw) => {
             void this.#handleRemoteRequest(raw).catch((error) => this.#report(error));
@@ -305,6 +316,26 @@ export class RedisShardCoordinator {
         }
         throw new Error("Shard control request timed out");
     }
+    async routeRemoteScheduled(lease, request) {
+        const acceptedLease = leaseSchema.parse(lease);
+        const acceptedRequest = shardScheduledTaskRequestSchema.parse(request);
+        if (acceptedRequest.identity.generation !== acceptedLease.generation ||
+            acceptedRequest.identity.fencingToken !== acceptedLease.fencingToken ||
+            acceptedRequest.identity.shardId !== acceptedLease.shardId)
+            throw new Error("Scheduled shard route ownership changed");
+        const envelope = remoteRequestSchema.parse({
+            version: 1,
+            type: "helyx.remote.request",
+            target: "scheduled",
+            targetShardId: acceptedLease.shardId,
+            request: acceptedRequest,
+        });
+        assertShardMessageSize(envelope);
+        const listeners = await this.#command.publish(this.#requestChannel(acceptedLease.supervisorId), JSON.stringify(envelope));
+        if (listeners < 1)
+            throw new Error("Owning shard supervisor is unavailable");
+        return this.#waitForScheduledResponse(acceptedRequest);
+    }
     async routeLeader(lease, request) {
         const acceptedLease = leaderLeaseSchema.parse(lease);
         const acceptedRequest = shardControlRequestSchema.parse(request);
@@ -482,6 +513,38 @@ export class RedisShardCoordinator {
             await this.#writeResponse(response);
             return;
         }
+        if (envelope.data.target === "scheduled") {
+            const { targetShardId, request } = envelope.data;
+            const lease = await this.getShardLease(targetShardId);
+            if (!lease ||
+                lease.supervisorId !== this.supervisorId ||
+                lease.generation !== request.identity.generation ||
+                lease.fencingToken !== request.identity.fencingToken ||
+                lease.shardId !== request.identity.shardId ||
+                !this.#scheduledHandler)
+                return this.#writeScheduledResponse({
+                    version: 1,
+                    type: "helyx.scheduled.response",
+                    requestId: request.requestId,
+                    result: {
+                        outcome: "deferred",
+                        delayMs: 1_000,
+                        safeCode: "shard_ownership_changed",
+                    },
+                });
+            const response = await this.#scheduledHandler(targetShardId, request).catch(() => ({
+                version: 1,
+                type: "helyx.scheduled.response",
+                requestId: request.requestId,
+                result: {
+                    outcome: "deferred",
+                    delayMs: 1_000,
+                    safeCode: "shard_unavailable",
+                },
+            }));
+            await this.#writeScheduledResponse(response);
+            return;
+        }
         const { targetShardId, request } = envelope.data;
         const lease = await this.getShardLease(targetShardId);
         if (!lease ||
@@ -516,6 +579,11 @@ export class RedisShardCoordinator {
         assertShardMessageSize(accepted);
         await this.#command.set(this.#responseKey(accepted.requestId), JSON.stringify(accepted), { EX: RESPONSE_TTL_SECONDS });
     }
+    async #writeScheduledResponse(response) {
+        const accepted = shardScheduledTaskResponseSchema.parse(response);
+        assertShardMessageSize(accepted);
+        await this.#command.set(this.#responseKey(accepted.requestId), JSON.stringify(accepted), { EX: RESPONSE_TTL_SECONDS });
+    }
     async #waitForResponse(request) {
         const deadline = new Date(request.deadlineAt).getTime();
         const responseKey = this.#responseKey(request.requestId);
@@ -531,6 +599,21 @@ export class RedisShardCoordinator {
         }
         throw new Error("Shard control request timed out");
     }
+    async #waitForScheduledResponse(request) {
+        const deadline = new Date(request.deadlineAt).getTime();
+        const responseKey = this.#responseKey(request.requestId);
+        while (Date.now() < deadline) {
+            const raw = await this.#command.get(responseKey);
+            if (raw) {
+                await this.#command.del(responseKey);
+                const parsed = shardScheduledTaskResponseSchema.parse(parseJson(raw));
+                assertShardMessageSize(parsed);
+                return parsed;
+            }
+            await wait(ROUTE_POLL_MS);
+        }
+        throw new Error("Scheduled shard request timed out");
+    }
     #generationKey() {
         return `${this.#prefix}:generation`;
     }

package/dist/shard-router.d.ts

@@ -13,6 +13,7 @@ export declare class ShardControlRouter implements BotControlHandler {
         privacy?: Pick<BotControlHandler, "listPrivacyProviders" | "capturePrivacy" | "erasePrivacy">;
         localLeaderLease?: ShardLeaderLease;
         coordinator?: ShardCoordinator;
+        notificationGuildId?: string;
     });
     getGuildState(guildId: string): ReturnType<BotControlHandler["getGuildState"]>;
     setModuleStatus(input: Parameters<BotControlHandler["setModuleStatus"]>[0]): ReturnType<BotControlHandler["setModuleStatus"]>;
@@ -20,6 +21,15 @@ export declare class ShardControlRouter implements BotControlHandler {
     updatePermissions(input: Parameters<BotControlHandler["updatePermissions"]>[0]): ReturnType<BotControlHandler["updatePermissions"]>;
     updateLoggingPolicy(input: Parameters<BotControlHandler["updateLoggingPolicy"]>[0]): ReturnType<BotControlHandler["updateLoggingPolicy"]>;
     executeDashboardAction(input: Parameters<BotControlHandler["executeDashboardAction"]>[0]): ReturnType<BotControlHandler["executeDashboardAction"]>;
+    listManagedResources(input: Parameters<BotControlHandler["listManagedResources"]>[0]): ReturnType<BotControlHandler["listManagedResources"]>;
+    readManagedResource(input: Parameters<BotControlHandler["readManagedResource"]>[0]): ReturnType<BotControlHandler["readManagedResource"]>;
+    listManagedResourceRelation(input: Parameters<BotControlHandler["listManagedResourceRelation"]>[0]): ReturnType<BotControlHandler["listManagedResourceRelation"]>;
+    previewManagedResource(input: Parameters<BotControlHandler["previewManagedResource"]>[0]): ReturnType<BotControlHandler["previewManagedResource"]>;
+    createManagedResource(input: Parameters<BotControlHandler["createManagedResource"]>[0]): ReturnType<BotControlHandler["createManagedResource"]>;
+    updateManagedResource(input: Parameters<BotControlHandler["updateManagedResource"]>[0]): ReturnType<BotControlHandler["updateManagedResource"]>;
+    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"]>;
     listPrivacyProviders(): ReturnType<BotControlHandler["listPrivacyProviders"]>;
     capturePrivacy(input: Parameters<BotControlHandler["capturePrivacy"]>[0]): ReturnType<BotControlHandler["capturePrivacy"]>;
     erasePrivacy(input: Parameters<BotControlHandler["erasePrivacy"]>[0]): ReturnType<BotControlHandler["erasePrivacy"]>;