@helyx/bot 1.5.2 → 1.5.3

package/dist/nexus-command-recovery-control-routes.js

@@ -0,0 +1,48 @@
+import { nexusCommandRecoveryHistoryQuerySchema, nexusCommandRecoveryInputSchema, nexusCommandRecoveryRenameInputSchema, } from "@helyx/control-protocol/nexus-command-recovery";
+import { NexusCommandRecoveryError } from "@helyx/platform";
+import { NexusCoreError } from "@helyx/sdk";
+import { z } from "zod";
+const target = z.object({ guildId: z.string().regex(/^\d{17,20}$/u) });
+const prefix = "/v1/admin-recovery/guilds/:guildId/nexus-command";
+/** Register only on the private control server with its existing bearer hook. */
+export function registerNexusCommandRecoveryControlRoutes(server, recovery) {
+    const run = async (reply, operation) => {
+        reply.header("Cache-Control", "no-store");
+        if (!recovery)
+            return reply
+                .code(503)
+                .send({ message: "Private Nexus command recovery is unavailable" });
+        try {
+            return await operation();
+        }
+        catch (error) {
+            if (error instanceof NexusCommandRecoveryError) {
+                const status = error.code === "invalid_input" ? 400 : 409;
+                return reply.code(status).send({ message: error.message });
+            }
+            if (error instanceof NexusCoreError)
+                return reply.code(409).send({ message: error.message });
+            throw error;
+        }
+    };
+    server.get(prefix, (request, reply) => run(reply, () => recovery.readState(target.parse(request.params).guildId)));
+    server.get(`${prefix}/history`, (request, reply) => run(reply, () => {
+        const filters = nexusCommandRecoveryHistoryQuerySchema.parse(request.query);
+        return recovery.listHistory({
+            ...target.parse(request.params),
+            limit: filters.limit,
+            ...(filters.beforeEventId
+                ? { beforeEventId: filters.beforeEventId }
+                : {}),
+        });
+    }));
+    server.post(`${prefix}/reset-timer`, (request, reply) => run(reply, () => recovery.resetTimer({
+        ...target.parse(request.params),
+        ...nexusCommandRecoveryInputSchema.parse(request.body),
+    })));
+    server.post(`${prefix}/rename`, (request, reply) => run(reply, () => recovery.rename({
+        ...target.parse(request.params),
+        ...nexusCommandRecoveryRenameInputSchema.parse(request.body),
+    })));
+}
+//# sourceMappingURL=nexus-command-recovery-control-routes.js.map

package/dist/nexus-command-references.d.ts

@@ -0,0 +1,6 @@
+import { type ServiceAccess } from "@helyx/sdk";
+import type { DashboardModuleDefinition } from "./dashboard-module-projection.js";
+export declare function nexusObservedRoot(services: ServiceAccess, guildId: string): Promise<string | null>;
+/** Relabel the guild DTO only; permissions, canonical identities and handlers stay unchanged. */
+export declare function nexusModuleLabels(modules: readonly DashboardModuleDefinition[], services: ServiceAccess, guildId: string): Promise<DashboardModuleDefinition[]>;
+//# sourceMappingURL=nexus-command-references.d.ts.map

package/dist/nexus-command-references.js

@@ -0,0 +1,33 @@
+import { HELYX_SERVICE_NAMES, formatNexusCommandReference, observedNexusCommandRoot, } from "@helyx/sdk";
+export async function nexusObservedRoot(services, guildId) {
+    try {
+        if (!services.has(HELYX_SERVICE_NAMES.nexusCore))
+            return "nexus";
+        return await observedNexusCommandRoot(services.get(HELYX_SERVICE_NAMES.nexusCore), guildId);
+    }
+    catch {
+        return null;
+    }
+}
+/** Relabel the guild DTO only; permissions, canonical identities and handlers stay unchanged. */
+export async function nexusModuleLabels(modules, services, guildId) {
+    const copy = structuredClone(modules);
+    if (!copy.some((module) => module.commands.some((command) => command.name.startsWith("/nexus "))))
+        return [...copy];
+    const root = await nexusObservedRoot(services, guildId);
+    return copy.map((module) => ({
+        ...module,
+        commands: module.commands.map((command) => {
+            if (!command.id.startsWith("nexus.") ||
+                !command.name.startsWith("/nexus "))
+                return command;
+            const path = command.name.slice("/nexus ".length).replaceAll(" ", ".");
+            return {
+                ...command,
+                name: formatNexusCommandReference(root, path) ??
+                    `Nexus ${path.replaceAll(".", " ")} (command unavailable)`,
+            };
+        }),
+    }));
+}
+//# sourceMappingURL=nexus-command-references.js.map

package/dist/scheduled-task-runner.js

@@ -1,7 +1,8 @@
 import { CORE_RECORD_RETENTION_TASK, MODULE_ACTIVATION_RECOVERY_TASK, ScheduledTaskRepository, } from "@helyx/database";
-import { getModuleScheduledTaskContribution, HELYX_SERVICE_NAMES, MODERATION_CASE_RETENTION_TASK, } from "@helyx/sdk";
+import { getModuleScheduledTaskContribution, HELYX_SERVICE_NAMES, NEXUS_COMMAND_LOG_TASK, MODERATION_CASE_RETENTION_TASK, } from "@helyx/sdk";
 import { randomUUID } from "node:crypto";
 import { canAccessModule } from "./premium-access.js";
+import { isInviteRollupMaintenanceTask } from "./invite-rollup-maintenance.js";
 const DEFAULT_POLL_INTERVAL_MS = 1_000;
 const DEFAULT_LEASE_MS = 45_000;
 const DEFAULT_CLAIM_LIMIT = 8;
@@ -295,6 +296,18 @@ export function createScheduledTaskRunner(input) {
                 taskKind: contribution.kind,
                 taskVersion: contribution.version,
                 delivery: contribution.delivery,
+                ...((module.manifest.id === NEXUS_COMMAND_LOG_TASK.moduleId &&
+                    contribution.kind === NEXUS_COMMAND_LOG_TASK.taskKind &&
+                    contribution.version === NEXUS_COMMAND_LOG_TASK.taskVersion &&
+                    contribution.delivery === "one-shot") ||
+                    isInviteRollupMaintenanceTask({
+                        moduleId: module.manifest.id,
+                        taskKind: contribution.kind,
+                        taskVersion: contribution.version,
+                        delivery: contribution.delivery,
+                    }, module)
+                    ? { runWhenDisabled: true }
+                    : {}),
             }))),
             MODERATION_CASE_RETENTION_TASK,
         ],
@@ -398,9 +411,15 @@ export function createLocalScheduledTaskRoute(input) {
                 return deferred("module_globally_disabled", DEFAULT_POLL_INTERVAL_MS * 30);
         }
         if (task.guildId) {
-            const enabled = await input.services
-                .get(HELYX_SERVICE_NAMES.installations)
-                .isModuleEnabled(task.guildId, task.moduleId);
+            const trustedCommandLog = task.moduleId === NEXUS_COMMAND_LOG_TASK.moduleId &&
+                task.taskKind === NEXUS_COMMAND_LOG_TASK.taskKind &&
+                task.taskVersion === NEXUS_COMMAND_LOG_TASK.taskVersion &&
+                task.delivery === "one-shot";
+            const enabled = trustedCommandLog ||
+                isInviteRollupMaintenanceTask(task, module) ||
+                (await input.services
+                    .get(HELYX_SERVICE_NAMES.installations)
+                    .isModuleEnabled(task.guildId, task.moduleId));
             if (!enabled)
                 return deferred("module_disabled", DEFAULT_POLL_INTERVAL_MS * 30);
             if (!(await canAccessModule(input.services, task.guildId, module)))

package/dist/shard-command-startup.d.ts

@@ -0,0 +1,13 @@
+export interface StartupCommandCatalogue {
+    revision: number;
+    fingerprint: string;
+}
+/** Publication failures or ownership loss must never advertise follower readiness. */
+export declare function completeShardCommandStartup(input: {
+    assertOwnership(): void;
+    publishCatalogue(): Promise<void>;
+    synchronise(): Promise<void>;
+    markReady(): Promise<void>;
+}): Promise<void>;
+export declare function shardStartupCatalogueReady(value: unknown, expected: StartupCommandCatalogue | null): boolean;
+//# sourceMappingURL=shard-command-startup.d.ts.map

package/dist/shard-command-startup.js

@@ -0,0 +1,27 @@
+/** Publication failures or ownership loss must never advertise follower readiness. */
+export async function completeShardCommandStartup(input) {
+    input.assertOwnership();
+    await input.publishCatalogue();
+    input.assertOwnership();
+    await input.synchronise();
+    input.assertOwnership();
+    await input.markReady();
+}
+export function shardStartupCatalogueReady(value, expected) {
+    if (!value ||
+        typeof value !== "object" ||
+        !("ready" in value) ||
+        value.ready !== true ||
+        !("commandCatalogue" in value))
+        return false;
+    const actual = value.commandCatalogue;
+    if (expected === null)
+        return actual === null;
+    return (actual !== null &&
+        typeof actual === "object" &&
+        "revision" in actual &&
+        "fingerprint" in actual &&
+        actual.revision === expected.revision &&
+        actual.fingerprint === expected.fingerprint);
+}
+//# sourceMappingURL=shard-command-startup.js.map

package/dist/shard-contracts.d.ts

@@ -239,6 +239,10 @@ export declare const shardControlOperationSchema: z.ZodDiscriminatedUnion<[z.Zod
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"guild.state.get">;
     guildId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    guildId: z.ZodString;
+    userIds: z.ZodArray<z.ZodString>;
+    kind: z.ZodLiteral<"guild.user-identities.read">;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"guild.dashboard.access">;
     guildId: z.ZodString;
@@ -307,12 +311,19 @@ export declare const shardControlOperationSchema: z.ZodDiscriminatedUnion<[z.Zod
     assumptions: z.ZodObject<{
         entryChannelId: z.ZodString;
         beforeRoleIds: z.ZodArray<z.ZodString>;
+        removedRoleIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
         afterRoleId: z.ZodString;
         entrance: z.ZodEnum<{
             public: "public";
             restricted: "restricted";
         }>;
+        entryAfter: z.ZodOptional<z.ZodEnum<{
+            hidden: "hidden";
+            visible: "visible";
+            either: "either";
+        }>>;
         allowedChannelIds: z.ZodArray<z.ZodString>;
+        requiredAfterChannelIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
         reviewChannelId: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>;
 }, z.core.$strict>, z.ZodObject<{
@@ -460,6 +471,13 @@ export declare const shardControlOperationSchema: z.ZodDiscriminatedUnion<[z.Zod
         readonly publish: "publish";
     }>;
     value: z.ZodRecord<z.ZodString, z.ZodCustom<ManagedResourceValue, ManagedResourceValue>>;
+}, z.core.$strict>, z.ZodObject<{
+    actorUserId: z.ZodString;
+    correlationId: z.ZodString;
+    kind: z.ZodLiteral<"guild.module.resource.create-defaults">;
+    guildId: z.ZodString;
+    moduleId: z.ZodString;
+    resourceType: z.ZodString;
 }, z.core.$strict>, z.ZodObject<{
     actorUserId: z.ZodString;
     correlationId: z.ZodString;
@@ -724,6 +742,10 @@ export declare const shardControlRequestSchema: z.ZodObject<{
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"guild.state.get">;
         guildId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        guildId: z.ZodString;
+        userIds: z.ZodArray<z.ZodString>;
+        kind: z.ZodLiteral<"guild.user-identities.read">;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"guild.dashboard.access">;
         guildId: z.ZodString;
@@ -792,12 +814,19 @@ export declare const shardControlRequestSchema: z.ZodObject<{
         assumptions: z.ZodObject<{
             entryChannelId: z.ZodString;
             beforeRoleIds: z.ZodArray<z.ZodString>;
+            removedRoleIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
             afterRoleId: z.ZodString;
             entrance: z.ZodEnum<{
                 public: "public";
                 restricted: "restricted";
             }>;
+            entryAfter: z.ZodOptional<z.ZodEnum<{
+                hidden: "hidden";
+                visible: "visible";
+                either: "either";
+            }>>;
             allowedChannelIds: z.ZodArray<z.ZodString>;
+            requiredAfterChannelIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
             reviewChannelId: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>;
     }, z.core.$strict>, z.ZodObject<{
@@ -945,6 +974,13 @@ export declare const shardControlRequestSchema: z.ZodObject<{
             readonly publish: "publish";
         }>;
         value: z.ZodRecord<z.ZodString, z.ZodCustom<ManagedResourceValue, ManagedResourceValue>>;
+    }, z.core.$strict>, z.ZodObject<{
+        actorUserId: z.ZodString;
+        correlationId: z.ZodString;
+        kind: z.ZodLiteral<"guild.module.resource.create-defaults">;
+        guildId: z.ZodString;
+        moduleId: z.ZodString;
+        resourceType: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
         actorUserId: z.ZodString;
         correlationId: z.ZodString;
@@ -1143,6 +1179,21 @@ export declare const shardControlResponseSchema: z.ZodDiscriminatedUnion<[z.ZodO
     ok: z.ZodLiteral<false>;
     status: z.ZodNumber;
     message: z.ZodString;
+    fieldError: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+        fieldName: z.ZodLiteral<"slashCommandName">;
+        code: z.ZodEnum<{
+            invalid_input: "invalid_input";
+            revision_conflict: "revision_conflict";
+            command_rename_unavailable: "command_rename_unavailable";
+            command_name_policy_unavailable: "command_name_policy_unavailable";
+            command_name_blocked: "command_name_blocked";
+            command_name_reserved: "command_name_reserved";
+            command_rename_cooldown: "command_rename_cooldown";
+            command_sync_unresolved: "command_sync_unresolved";
+        }>;
+        availableAt: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+        serverTime: z.ZodOptional<z.ZodISODateTime>;
+    }, z.core.$strict>>>;
 }, z.core.$strict>], "ok">;
 export type ShardControlResponse = z.infer<typeof shardControlResponseSchema>;
 declare const shardCloudOperationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -1714,6 +1765,10 @@ export declare const supervisorMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObje
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"guild.state.get">;
         guildId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        guildId: z.ZodString;
+        userIds: z.ZodArray<z.ZodString>;
+        kind: z.ZodLiteral<"guild.user-identities.read">;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"guild.dashboard.access">;
         guildId: z.ZodString;
@@ -1782,12 +1837,19 @@ export declare const supervisorMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObje
         assumptions: z.ZodObject<{
             entryChannelId: z.ZodString;
             beforeRoleIds: z.ZodArray<z.ZodString>;
+            removedRoleIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
             afterRoleId: z.ZodString;
             entrance: z.ZodEnum<{
                 public: "public";
                 restricted: "restricted";
             }>;
+            entryAfter: z.ZodOptional<z.ZodEnum<{
+                hidden: "hidden";
+                visible: "visible";
+                either: "either";
+            }>>;
             allowedChannelIds: z.ZodArray<z.ZodString>;
+            requiredAfterChannelIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
             reviewChannelId: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>;
     }, z.core.$strict>, z.ZodObject<{
@@ -1935,6 +1997,13 @@ export declare const supervisorMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObje
             readonly publish: "publish";
         }>;
         value: z.ZodRecord<z.ZodString, z.ZodCustom<ManagedResourceValue, ManagedResourceValue>>;
+    }, z.core.$strict>, z.ZodObject<{
+        actorUserId: z.ZodString;
+        correlationId: z.ZodString;
+        kind: z.ZodLiteral<"guild.module.resource.create-defaults">;
+        guildId: z.ZodString;
+        moduleId: z.ZodString;
+        resourceType: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
         actorUserId: z.ZodString;
         correlationId: z.ZodString;
@@ -2340,6 +2409,21 @@ export declare const workerMessageSchema: z.ZodDiscriminatedUnion<[z.ZodDiscrimi
     ok: z.ZodLiteral<false>;
     status: z.ZodNumber;
     message: z.ZodString;
+    fieldError: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+        fieldName: z.ZodLiteral<"slashCommandName">;
+        code: z.ZodEnum<{
+            invalid_input: "invalid_input";
+            revision_conflict: "revision_conflict";
+            command_rename_unavailable: "command_rename_unavailable";
+            command_name_policy_unavailable: "command_name_policy_unavailable";
+            command_name_blocked: "command_name_blocked";
+            command_name_reserved: "command_name_reserved";
+            command_rename_cooldown: "command_rename_cooldown";
+            command_sync_unresolved: "command_sync_unresolved";
+        }>;
+        availableAt: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+        serverTime: z.ZodOptional<z.ZodISODateTime>;
+    }, z.core.$strict>>>;
 }, z.core.$strict>], "ok">, z.ZodObject<{
     version: z.ZodLiteral<1>;
     type: z.ZodLiteral<"helyx.cloud.request">;

package/dist/shard-contracts.js

@@ -1,4 +1,6 @@
 import { z } from "zod";
+import { discordUserIdentityRequestSchema } from "@helyx/control-protocol/discord-user-identities";
+import { dashboardFieldValidationSchema } from "@helyx/control-protocol/field-validation";
 import { channelAuditModuleIdSchema, channelAuditInputSchema, channelAuditConfigurationSchema, channelAuditReportSchema, } from "@helyx/control-protocol/channel-audit";
 import { CLOUD_MAX_RESOURCE_IMPORT_BYTES, creatorOnboardingRequestSchema, } from "@helyx/control-protocol";
 import { AUTOMOD_SCANNER_LIMITS } from "@helyx/sdk";
@@ -297,6 +299,9 @@ export const shardControlOperationSchema = z.discriminatedUnion("kind", [
     })
         .strict(),
     z.object({ kind: z.literal("guild.state.get"), guildId: snowflake }).strict(),
+    discordUserIdentityRequestSchema.extend({
+        kind: z.literal("guild.user-identities.read"),
+    }),
     z
         .object({
         kind: z.literal("guild.dashboard.access"),
@@ -514,6 +519,15 @@ export const shardControlOperationSchema = z.discriminatedUnion("kind", [
         ...mutationContext.shape,
     })
         .strict(),
+    z
+        .object({
+        kind: z.literal("guild.module.resource.create-defaults"),
+        guildId: snowflake,
+        moduleId,
+        resourceType,
+        ...mutationContext.shape,
+    })
+        .strict(),
     z
         .object({
         kind: z.literal("guild.module.resource.update"),
@@ -652,6 +666,7 @@ export const shardControlResponseSchema = z.discriminatedUnion("ok", [
         ok: z.literal(false),
         status: z.number().int().min(400).max(599),
         message: z.string().min(1).max(300),
+        fieldError: dashboardFieldValidationSchema.optional().catch(undefined),
     })
         .strict(),
 ]);
@@ -1092,6 +1107,14 @@ export async function executeShardControlOperation(handler, operation) {
             });
         case "guild.state.get":
             return handler.getGuildState(operation.guildId);
+        case "guild.user-identities.read": {
+            if (!handler.resolveDiscordUserIdentities)
+                throw new Error("Discord identity lookup is unavailable");
+            return handler.resolveDiscordUserIdentities({
+                guildId: operation.guildId,
+                userIds: operation.userIds,
+            });
+        }
         case "guild.dashboard.access":
             return handler.canAccessDashboard(operation);
         case "guild.access-policy.get":
@@ -1284,6 +1307,16 @@ export async function executeShardControlOperation(handler, operation) {
                 actorUserId: operation.actorUserId,
                 correlationId: operation.correlationId,
             });
+        case "guild.module.resource.create-defaults":
+            if (!handler.getManagedResourceCreateDefaults)
+                throw new Error("Creation defaults are unavailable");
+            return handler.getManagedResourceCreateDefaults({
+                guildId: operation.guildId,
+                moduleId: operation.moduleId,
+                resourceType: operation.resourceType,
+                actorUserId: operation.actorUserId,
+                correlationId: operation.correlationId,
+            });
         case "guild.module.resource.update":
             return handler.updateManagedResource({
                 guildId: operation.guildId,

package/dist/shard-core-readiness.d.ts

@@ -0,0 +1,5 @@
+import { type DatabasePool } from "@helyx/database";
+/** No provisional order: schema readiness precedes the first coordinator tuple. */
+export declare function prepareShardDeploymentOrder(database: DatabasePool, mode: "apply" | "inspect"): Promise<number>;
+export declare function allocateShardDeploymentOrder(database: DatabasePool): Promise<number>;
+//# sourceMappingURL=shard-core-readiness.d.ts.map

package/dist/shard-core-readiness.js

@@ -0,0 +1,19 @@
+import { inspectCoreMigrations, runCoreMigrations, RuntimeStateRepository, } from "@helyx/database";
+/** No provisional order: schema readiness precedes the first coordinator tuple. */
+export async function prepareShardDeploymentOrder(database, mode) {
+    if (mode === "inspect") {
+        const result = await inspectCoreMigrations(database);
+        if (result.pending.length)
+            throw new Error(`Core migrations must be applied before shard admission: ${result.pending.join(", ")}`);
+    }
+    else
+        await runCoreMigrations(database);
+    return allocateShardDeploymentOrder(database);
+}
+export async function allocateShardDeploymentOrder(database) {
+    const value = await new RuntimeStateRepository(database).nextShardDeploymentOrder();
+    if (value < 1n || value > BigInt(Number.MAX_SAFE_INTEGER))
+        throw new Error("Shard deployment order is outside the safe runtime range");
+    return Number(value);
+}
+//# sourceMappingURL=shard-core-readiness.js.map

package/dist/shard-router.d.ts

@@ -1,3 +1,4 @@
+import type { DiscordUserIdentityRequest, DiscordUserIdentityResponse } from "@helyx/control-protocol/discord-user-identities";
 import { type AutoModerationEnhancedResultOutcome, type CreatorOnboardingRequest, type CreatorOnboardingResponse } from "@helyx/sdk";
 import { type BotControlHandler } from "./control-server.js";
 import { type ShardControlRequest, type ShardControlResponse } from "./shard-contracts.js";
@@ -39,6 +40,7 @@ export declare class ShardControlRouter implements BotControlHandler {
         limit: number;
         knownFingerprint?: string;
     }): ReturnType<AutoModerationScannerProviderRegistryService["getConfigurationPage"]>;
+    resolveDiscordUserIdentities(input: DiscordUserIdentityRequest): Promise<DiscordUserIdentityResponse>;
     getGuildState(guildId: string): ReturnType<BotControlHandler["getGuildState"]>;
     canAccessDashboard(input: Parameters<BotControlHandler["canAccessDashboard"]>[0]): ReturnType<BotControlHandler["canAccessDashboard"]>;
     getGuildAccessPolicy(input: Parameters<BotControlHandler["getGuildAccessPolicy"]>[0]): ReturnType<BotControlHandler["getGuildAccessPolicy"]>;
@@ -62,6 +64,7 @@ export declare class ShardControlRouter implements BotControlHandler {
     previewManagedResource(input: Parameters<BotControlHandler["previewManagedResource"]>[0]): ReturnType<BotControlHandler["previewManagedResource"]>;
     importManagedResource(input: Parameters<BotControlHandler["importManagedResource"]>[0]): ReturnType<BotControlHandler["importManagedResource"]>;
     createManagedResource(input: Parameters<BotControlHandler["createManagedResource"]>[0]): ReturnType<BotControlHandler["createManagedResource"]>;
+    getManagedResourceCreateDefaults(input: Parameters<NonNullable<BotControlHandler["getManagedResourceCreateDefaults"]>>[0]): ReturnType<NonNullable<BotControlHandler["getManagedResourceCreateDefaults"]>>;
     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"]>;

package/dist/shard-router.js

@@ -46,6 +46,9 @@ export class ShardControlRouter {
             ...input,
         });
     }
+    resolveDiscordUserIdentities(input) {
+        return this.#route({ kind: "guild.user-identities.read", ...input });
+    }
     getGuildState(guildId) {
         return this.#route({ kind: "guild.state.get", guildId });
     }
@@ -189,6 +192,12 @@ export class ShardControlRouter {
             ...input,
         }));
     }
+    getManagedResourceCreateDefaults(input) {
+        return this.#route(shardControlOperationSchema.parse({
+            kind: "guild.module.resource.create-defaults",
+            ...input,
+        }));
+    }
     updateManagedResource(input) {
         return this.#route(shardControlOperationSchema.parse({
             kind: "guild.module.resource.update",
@@ -391,7 +400,7 @@ function unwrapResponse(response) {
             ? accepted.status
             : accepted.status >= 500
                 ? 503
-                : 502, accepted.message);
+                : 502, accepted.message, accepted.fieldError);
     return accepted.result;
 }
 function sameShardLease(left, right) {

package/dist/shard-supervisor.d.ts

@@ -30,7 +30,7 @@ export declare function shardHostedControlCallbacks(router: Pick<ShardControlRou
 };
 export declare function splitNumericCommittedBatch(batch: NumericWriteBehindCommittedBatch, index: number): NumericWriteBehindCommittedBatch;
 export declare function buildShardWorkerEnvironment(source: NodeJS.ProcessEnv, identity: ShardIdentity, restartCount: number): NodeJS.ProcessEnv;
-export declare function shardRuntimeCompositionHash(modules: readonly ModuleDefinition[], internalGuildId?: string, globalCommandMode?: Parameters<typeof buildApplicationCommandDefinitions>[2]): string;
+export declare function shardRuntimeCompositionHash(modules: readonly ModuleDefinition[], internalGuildId?: string, globalCommandMode?: Parameters<typeof buildApplicationCommandDefinitions>[2], commandCatalogueFingerprint?: string): string;
 export declare function coordinatedFollowerReady(input: {
     health: ShardHealthSnapshot;
     activeLeader: ShardLeaderLease | undefined;