@helyx/bot 1.3.1 → 1.4.0

package/dist/modules.d.ts

@@ -10,6 +10,7 @@ interface LoadedDefinition {
 export interface ConfiguredModulePackage extends LoadedDefinition {
     packageRoot: string;
 }
+export declare function assertConfiguredModuleDatabaseCompatibility(modules: readonly ConfiguredModulePackage[], engine: BotEnvironment["DATABASE_ENGINE"]): void;
 export declare const secureRandomSelectionWorkerKeyName = "HELYX_INTERNAL_SECURE_RANDOM_SELECTION_KEY";
 interface PlatformServiceEnvironment extends Pick<BotEnvironment, "HELYX_DATA_ENCRYPTION_KEY"> {
     HELYX_RUNTIME_PROFILE?: BotEnvironment["HELYX_RUNTIME_PROFILE"];

package/dist/modules.js

@@ -1,10 +1,17 @@
-import { orderModuleManifests, parseModuleManifest, } from "@helyx/module-manifest";
+import { getModuleDatabaseEngines, orderModuleManifests, parseModuleManifest, } from "@helyx/module-manifest";
 import { NEXUS_COMMAND_SPECS, NEXUS_ROOT_MODULE_ID, sharedCommandFamilySpec, sharedCommandPathSpec, } from "@helyx/sdk";
 import { createHmac } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import { createRequire } from "node:module";
 import { dirname } from "node:path";
 import { assertCommandPathContract } from "./command-path-contract.js";
+export function assertConfiguredModuleDatabaseCompatibility(modules, engine) {
+    for (const { definition } of modules) {
+        if (!getModuleDatabaseEngines(definition.manifest).includes(engine)) {
+            throw new Error(`Module ${definition.manifest.id} does not support DATABASE_ENGINE=${engine}`);
+        }
+    }
+}
 const officialModulePackage = /^@helyx\/module-[a-z0-9][a-z0-9-]*$/u;
 const giveawaysModuleId = "helyx.giveaways";
 const inviteTrackingModuleId = "helyx.invite-tracking";

package/dist/mysql-runtime-persistence.d.ts

@@ -0,0 +1,46 @@
+import type { BotEnvironment } from "@helyx/config";
+import type { GuildCommandRepository as MysqlGuildCommandRepository, InstallationRepository as MysqlInstallationRepository, MysqlPool, RuntimeStateRepository as MysqlRuntimeStateRepository } from "@helyx/database-mysql";
+import type { MysqlMemberRoleGrantOwnershipStore, createMysqlPlatformServices } from "@helyx/platform";
+import type { ModuleDefinition } from "@helyx/sdk";
+import { type BotDatabaseHandle } from "./database-bootstrap.js";
+import type { CloudConnectorStore } from "./cloud-control-dispatcher.js";
+import { type BotControlPersistence } from "./control-server.js";
+import { type CoreRetentionRepositories } from "./core-retention.js";
+import type { GuildCommandReadRepositories } from "./guild-command-read-service.js";
+import type { GuildCommandWorkerRepositories } from "./guild-command-worker.js";
+import { type GuildTrackingPersistence } from "./guilds.js";
+import type { ModuleLoggingRepositories } from "./module-logging.js";
+import type { ConfiguredModulePackage } from "./modules.js";
+import type { ScheduledTaskRepositoryContract } from "./scheduled-task-runner.js";
+type MysqlRuntimeEnvironment = Pick<BotEnvironment, "DATABASE_ENGINE" | "DATABASE_URL" | "DATABASE_SSL" | "HELYX_RUNTIME_PROFILE" | "HELYX_SHARD_MODE" | "HELYX_HOSTED_MODERATION_ENABLED" | "HELYX_VERIFICATION_ENABLED" | "HELYX_PRIVACY_ENABLED" | "HELYX_PRIVACY_EXECUTOR_DATABASE_URL" | "HELYX_OAUTH_ENABLED" | "HELYX_ECKO_TRANSPORT_SECRET" | "HELYX_SUPPORT_STAFF_CHANNEL_ID" | "STRIPE_ENVIRONMENT">;
+export interface MysqlBotRuntimePersistence {
+    /** The adapter owns this single pool and closes it via database.close(). */
+    readonly database: BotDatabaseHandle<{
+        pool: MysqlPool;
+    }>;
+    readonly pool: MysqlPool;
+    readonly cloudConnector: CloudConnectorStore;
+    readonly guildTracking: GuildTrackingPersistence;
+    readonly control: BotControlPersistence;
+    readonly coreRetention: CoreRetentionRepositories;
+    readonly scheduledTasks: ScheduledTaskRepositoryContract;
+    readonly commandWorker: GuildCommandWorkerRepositories;
+    readonly commandRead: GuildCommandReadRepositories;
+    readonly commandRelease: {
+        installations: Pick<MysqlInstallationRepository, "listActiveGuilds">;
+        commands: Pick<MysqlGuildCommandRepository, "getState" | "schedule">;
+        runtime: Pick<MysqlRuntimeStateRepository, "get" | "compareAndSet">;
+    };
+    readonly logging: ModuleLoggingRepositories;
+    readonly memberRoleOwnership: MysqlMemberRoleGrantOwnershipStore;
+    readonly createPlatformServices: (modules: readonly ModuleDefinition[], options?: Parameters<typeof createMysqlPlatformServices>[2]) => ReturnType<typeof createMysqlPlatformServices>;
+}
+export interface OpenMysqlBotRuntimePersistenceInput {
+    readonly environment: MysqlRuntimeEnvironment;
+    readonly modulePackages: readonly ConfiguredModulePackage[];
+    readonly applicationName?: string;
+}
+/** Connect, migrate, and compose ordinary self-host persistence from one pool. */
+export declare function openMysqlBotRuntimePersistence(input: OpenMysqlBotRuntimePersistenceInput): Promise<MysqlBotRuntimePersistence>;
+export {};
+//# sourceMappingURL=mysql-runtime-persistence.d.ts.map

package/dist/mysql-runtime-persistence.js

@@ -0,0 +1,91 @@
+import { openBotDatabaseWithAdapter, } from "./database-bootstrap.js";
+import { createMysqlBotControlPersistence, } from "./control-server.js";
+import { createMysqlCoreRetentionRepositories, } from "./core-retention.js";
+import { createMysqlGuildTrackingPersistence, } from "./guilds.js";
+/** Connect, migrate, and compose ordinary self-host persistence from one pool. */
+export async function openMysqlBotRuntimePersistence(input) {
+    assertMysqlRuntimeOptions(input.environment);
+    const mysql = await import("@helyx/database-mysql");
+    const adapter = mysql.createMysqlDatabaseAdapter({
+        repositories: (_executor, pool) => ({ pool }),
+    });
+    const database = await openBotDatabaseWithAdapter(input, adapter);
+    try {
+        const pool = database.session.repositories.pool;
+        const installations = new mysql.InstallationRepository(pool);
+        const commands = new mysql.GuildCommandRepository(pool);
+        const availability = new mysql.ModuleAvailabilityRepository(pool);
+        const runtime = new mysql.RuntimeStateRepository(pool);
+        const [guildTracking, control, coreRetention, platform] = await Promise.all([
+            createMysqlGuildTrackingPersistence(pool),
+            createMysqlBotControlPersistence(pool),
+            createMysqlCoreRetentionRepositories(pool),
+            import("@helyx/platform"),
+        ]);
+        return {
+            database,
+            pool,
+            cloudConnector: new mysql.CloudConnectorRepository(pool),
+            guildTracking,
+            control,
+            coreRetention,
+            scheduledTasks: new mysql.ScheduledTaskRepository(pool),
+            commandWorker: {
+                commands,
+                installations,
+                availability,
+            },
+            commandRead: { commands, installations },
+            commandRelease: { commands, installations, runtime },
+            logging: {
+                installations,
+                configuration: new mysql.ModuleConfigurationRepository(pool),
+                policies: new mysql.ModuleLoggingPolicyRepository(pool),
+            },
+            memberRoleOwnership: new platform.MysqlMemberRoleGrantOwnershipStore(pool),
+            createPlatformServices: (modules, options) => platform.createMysqlPlatformServices(pool, modules, {
+                ...options,
+                runtimeProfile: "self-hosted",
+            }),
+        };
+    }
+    catch (error) {
+        await database.close().catch(() => undefined);
+        throw error;
+    }
+}
+function assertMysqlRuntimeOptions(environment) {
+    if (environment.DATABASE_ENGINE !== "mysql") {
+        throw new Error("MySQL bot runtime requires DATABASE_ENGINE=mysql");
+    }
+    if (environment.HELYX_RUNTIME_PROFILE !== "self-hosted") {
+        throw new Error("MySQL bot runtime requires HELYX_RUNTIME_PROFILE=self-hosted");
+    }
+    if (environment.HELYX_SHARD_MODE !== "off") {
+        throw new Error("MySQL bot runtime does not support shard mode");
+    }
+    const unsupported = [
+        [
+            "HELYX_HOSTED_MODERATION_ENABLED",
+            environment.HELYX_HOSTED_MODERATION_ENABLED,
+        ],
+        ["HELYX_VERIFICATION_ENABLED", environment.HELYX_VERIFICATION_ENABLED],
+        ["HELYX_PRIVACY_ENABLED", environment.HELYX_PRIVACY_ENABLED],
+        [
+            "HELYX_PRIVACY_EXECUTOR_DATABASE_URL",
+            environment.HELYX_PRIVACY_EXECUTOR_DATABASE_URL,
+        ],
+        ["HELYX_OAUTH_ENABLED", environment.HELYX_OAUTH_ENABLED],
+        ["HELYX_ECKO_TRANSPORT_SECRET", environment.HELYX_ECKO_TRANSPORT_SECRET],
+        [
+            "HELYX_SUPPORT_STAFF_CHANNEL_ID",
+            environment.HELYX_SUPPORT_STAFF_CHANNEL_ID,
+        ],
+        ["STRIPE_ENVIRONMENT", environment.STRIPE_ENVIRONMENT],
+    ];
+    for (const [name, value] of unsupported) {
+        if (value)
+            throw new Error(`MySQL bot runtime does not support ${name}`);
+    }
+}
+//# sourceMappingURL=mysql-runtime-persistence.js.map

package/dist/oauth-module.js

@@ -204,7 +204,7 @@ export function createOAuthModule() {
                                     text: [
                                         {
                                             content: result.outcome === "processing"
-                                                ? `${providerName(result.provider)} access removal is already in progress. Helyx will finish it automatically.`
+                                                ? `${providerName(result.provider)} access removal is in progress. Helyx is handling local cleanup automatically. Provider-side revocation is not confirmed yet, so you can also remove Helyx from your ${providerName(result.provider)} connected-app settings. Run \`/helyx connections\` to check whether local access remains.`
                                                 : result.outcome === "cleanup_pending"
                                                     ? `${providerName(result.provider)} credentials were deleted. Helyx is still removing related roles and connection records.`
                                                     : result.providerRevocation === "completed"
@@ -235,7 +235,7 @@ function unavailable() {
         componentsV2: {
             text: [
                 {
-                    content: "OAuth access could not be updated right now. Nothing new was retained; please try again.",
+                    content: "Helyx could not confirm the final result. The removal may still be finishing automatically. Run /helyx connections to check before trying again.",
                 },
             ],
         },

package/dist/oauth-service.d.ts

@@ -2,6 +2,13 @@ import type { OAuthConnectionSummary, OAuthConnectionIdentity, OAuthEligibilityR
 export declare class HttpOAuthService implements OAuthService {
     #private;
     private readonly internalSecret;
+    resolveCreatorIdentity(input: {
+        provider: "twitch";
+        login: string;
+    }): Promise<{
+        userId: string;
+        login: string;
+    }>;
     constructor(baseUrl: string, internalSecret: string);
     listConnections(input: {
         discordUserId: string;

package/dist/oauth-service.js

@@ -1,5 +1,8 @@
 export class HttpOAuthService {
     internalSecret;
+    resolveCreatorIdentity(input) {
+        return this.#request("/v1/internal/oauth/creator-identity", input);
+    }
     #baseUrl;
     constructor(baseUrl, internalSecret) {
         this.internalSecret = internalSecret;

package/dist/scheduled-task-runner.d.ts

@@ -1,91 +1,10 @@
-import { type CoalescedTaskRecord, type ScheduledTaskRecord, type ScheduledTaskDefinition, type SchedulerHealth } from "@helyx/database";
+import { ScheduledTaskRepository, type ScheduledTaskDefinition, type SchedulerHealth } from "@helyx/database";
 import { type Logger, type ModuleDefinition, type ModuleScheduledTaskExecution, type ScheduledTaskExecutionResult, type ServiceAccess } from "@helyx/sdk";
 import type { Pool } from "pg";
 export interface ScheduledTaskRoute {
     (task: ModuleScheduledTaskExecution, signal: AbortSignal): Promise<ScheduledTaskExecutionResult>;
 }
-interface ScheduledTaskRepositoryContract {
-    claimDue(input: {
-        workerId: string;
-        leaseMs: number;
-        limit?: number;
-        eligible?: readonly ScheduledTaskDefinition[];
-    }): Promise<ScheduledTaskRecord[]>;
-    claimCoalesced(input: {
-        workerId: string;
-        leaseMs: number;
-        limit?: number;
-        eligible?: readonly ScheduledTaskDefinition[];
-    }): Promise<CoalescedTaskRecord[]>;
-    heartbeat(input: {
-        taskId: string;
-        workerId: string;
-        leaseGeneration: number;
-        leaseMs: number;
-    }): Promise<boolean>;
-    heartbeatCoalesced(input: {
-        laneId: string;
-        workerId: string;
-        leaseGeneration: number;
-        claimedGeneration: number;
-        leaseMs: number;
-    }): Promise<boolean>;
-    complete(input: {
-        taskId: string;
-        workerId: string;
-        leaseGeneration: number;
-    }): Promise<boolean>;
-    completeCoalesced(input: {
-        laneId: string;
-        workerId: string;
-        leaseGeneration: number;
-        claimedGeneration: number;
-    }): Promise<boolean>;
-    defer(input: {
-        taskId: string;
-        workerId: string;
-        leaseGeneration: number;
-        delayMs: number;
-        safeCode: string;
-    }): Promise<boolean>;
-    deferCoalesced(input: {
-        laneId: string;
-        workerId: string;
-        leaseGeneration: number;
-        claimedGeneration: number;
-        delayMs: number;
-        safeCode: string;
-    }): Promise<boolean>;
-    retry(input: {
-        taskId: string;
-        workerId: string;
-        leaseGeneration: number;
-        delayMs: number;
-        safeCode: string;
-    }): Promise<boolean>;
-    retryCoalesced(input: {
-        laneId: string;
-        workerId: string;
-        leaseGeneration: number;
-        claimedGeneration: number;
-        delayMs: number;
-        safeCode: string;
-    }): Promise<boolean>;
-    markRequiresReview(input: {
-        taskId: string;
-        workerId: string;
-        leaseGeneration: number;
-        safeCode: string;
-    }): Promise<boolean>;
-    markCoalescedRequiresReview(input: {
-        laneId: string;
-        workerId: string;
-        leaseGeneration: number;
-        claimedGeneration: number;
-        safeCode: string;
-    }): Promise<boolean>;
-    getHealth(sampleLimit?: number): Promise<SchedulerHealth>;
-}
+export type ScheduledTaskRepositoryContract = Pick<ScheduledTaskRepository, "claimDue" | "claimCoalesced" | "heartbeat" | "heartbeatCoalesced" | "complete" | "completeCoalesced" | "defer" | "deferCoalesced" | "retry" | "retryCoalesced" | "markRequiresReview" | "markCoalescedRequiresReview" | "getHealth">;
 export declare class ScheduledTaskRunner {
     #private;
     constructor(input: {
@@ -107,12 +26,17 @@ export declare class ScheduledTaskRunner {
     getHealth(): Promise<SchedulerHealth>;
 }
 export declare function createScheduledTaskRunner(input: {
-    database: Pool;
     modules: readonly ModuleDefinition[];
     route: ScheduledTaskRoute;
     logger: Logger;
     workerId?: string;
-}): ScheduledTaskRunner;
+} & ({
+    database: Pool;
+    repository?: never;
+} | {
+    repository: ScheduledTaskRepositoryContract;
+    database?: never;
+})): ScheduledTaskRunner;
 export declare function schedulerOperationalHealth(health: SchedulerHealth): {
     status: "available";
     oneShot: ReturnType<typeof mapSchedulerWorkHealth>;

package/dist/scheduled-task-runner.js

@@ -271,7 +271,7 @@ export class ScheduledTaskRunner {
 }
 export function createScheduledTaskRunner(input) {
     return new ScheduledTaskRunner({
-        repository: new ScheduledTaskRepository(input.database),
+        repository: input.repository ?? new ScheduledTaskRepository(input.database),
         route: input.route,
         logger: input.logger,
         eligibleTasks: [

package/dist/shard-contracts.d.ts

@@ -167,6 +167,51 @@ export declare const shardHealthSnapshotSchema: z.ZodObject<{
 }, z.core.$strict>;
 export type ShardHealthSnapshot = z.infer<typeof shardHealthSnapshotSchema>;
 export declare const shardControlOperationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"creator.onboarding">;
+    guildId: z.ZodString;
+    input: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        action: z.ZodLiteral<"page">;
+        guildId: z.ZodString;
+        reference: z.ZodUUID;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"consumer">;
+        guildId: z.ZodString;
+        overviewId: z.ZodUUID;
+        reference: z.ZodOptional<z.ZodUUID>;
+        configurationRevision: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        guildId: z.ZodString;
+        reference: z.ZodUUID;
+        configurationRevision: z.ZodNumber;
+        memberUserId: z.ZodString;
+        accountSlot: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
+        action: z.ZodLiteral<"inspect">;
+    }, z.core.$strict>, z.ZodObject<{
+        guildId: z.ZodString;
+        reference: z.ZodUUID;
+        configurationRevision: z.ZodNumber;
+        memberUserId: z.ZodString;
+        accountSlot: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
+        action: z.ZodLiteral<"check">;
+    }, z.core.$strict>, z.ZodObject<{
+        guildId: z.ZodString;
+        reference: z.ZodUUID;
+        configurationRevision: z.ZodNumber;
+        memberUserId: z.ZodString;
+        accountSlot: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
+        action: z.ZodLiteral<"deliver">;
+    }, z.core.$strict>, z.ZodObject<{
+        sessionId: z.ZodUUID;
+        authorisationReference: z.ZodString;
+        withTwitch: z.ZodBoolean;
+        guildId: z.ZodString;
+        reference: z.ZodUUID;
+        configurationRevision: z.ZodNumber;
+        memberUserId: z.ZodString;
+        accountSlot: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
+        action: z.ZodLiteral<"join">;
+    }, z.core.$strict>], "action">;
+}, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"automod.enhanced.configuration.page">;
     cursor: z.ZodOptional<z.ZodString>;
     limit: z.ZodNumber;
@@ -578,6 +623,51 @@ export declare const shardControlRequestSchema: z.ZodObject<{
     fencingToken: z.ZodNumber;
     deadlineAt: z.ZodISODateTime;
     operation: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"creator.onboarding">;
+        guildId: z.ZodString;
+        input: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            action: z.ZodLiteral<"page">;
+            guildId: z.ZodString;
+            reference: z.ZodUUID;
+        }, z.core.$strict>, z.ZodObject<{
+            action: z.ZodLiteral<"consumer">;
+            guildId: z.ZodString;
+            overviewId: z.ZodUUID;
+            reference: z.ZodOptional<z.ZodUUID>;
+            configurationRevision: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>, z.ZodObject<{
+            guildId: z.ZodString;
+            reference: z.ZodUUID;
+            configurationRevision: z.ZodNumber;
+            memberUserId: z.ZodString;
+            accountSlot: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
+            action: z.ZodLiteral<"inspect">;
+        }, z.core.$strict>, z.ZodObject<{
+            guildId: z.ZodString;
+            reference: z.ZodUUID;
+            configurationRevision: z.ZodNumber;
+            memberUserId: z.ZodString;
+            accountSlot: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
+            action: z.ZodLiteral<"check">;
+        }, z.core.$strict>, z.ZodObject<{
+            guildId: z.ZodString;
+            reference: z.ZodUUID;
+            configurationRevision: z.ZodNumber;
+            memberUserId: z.ZodString;
+            accountSlot: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
+            action: z.ZodLiteral<"deliver">;
+        }, z.core.$strict>, z.ZodObject<{
+            sessionId: z.ZodUUID;
+            authorisationReference: z.ZodString;
+            withTwitch: z.ZodBoolean;
+            guildId: z.ZodString;
+            reference: z.ZodUUID;
+            configurationRevision: z.ZodNumber;
+            memberUserId: z.ZodString;
+            accountSlot: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
+            action: z.ZodLiteral<"join">;
+        }, z.core.$strict>], "action">;
+    }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"automod.enhanced.configuration.page">;
         cursor: z.ZodOptional<z.ZodString>;
         limit: z.ZodNumber;
@@ -1494,6 +1584,51 @@ export declare const supervisorMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObje
     fencingToken: z.ZodNumber;
     deadlineAt: z.ZodISODateTime;
     operation: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"creator.onboarding">;
+        guildId: z.ZodString;
+        input: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            action: z.ZodLiteral<"page">;
+            guildId: z.ZodString;
+            reference: z.ZodUUID;
+        }, z.core.$strict>, z.ZodObject<{
+            action: z.ZodLiteral<"consumer">;
+            guildId: z.ZodString;
+            overviewId: z.ZodUUID;
+            reference: z.ZodOptional<z.ZodUUID>;
+            configurationRevision: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>, z.ZodObject<{
+            guildId: z.ZodString;
+            reference: z.ZodUUID;
+            configurationRevision: z.ZodNumber;
+            memberUserId: z.ZodString;
+            accountSlot: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
+            action: z.ZodLiteral<"inspect">;
+        }, z.core.$strict>, z.ZodObject<{
+            guildId: z.ZodString;
+            reference: z.ZodUUID;
+            configurationRevision: z.ZodNumber;
+            memberUserId: z.ZodString;
+            accountSlot: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
+            action: z.ZodLiteral<"check">;
+        }, z.core.$strict>, z.ZodObject<{
+            guildId: z.ZodString;
+            reference: z.ZodUUID;
+            configurationRevision: z.ZodNumber;
+            memberUserId: z.ZodString;
+            accountSlot: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
+            action: z.ZodLiteral<"deliver">;
+        }, z.core.$strict>, z.ZodObject<{
+            sessionId: z.ZodUUID;
+            authorisationReference: z.ZodString;
+            withTwitch: z.ZodBoolean;
+            guildId: z.ZodString;
+            reference: z.ZodUUID;
+            configurationRevision: z.ZodNumber;
+            memberUserId: z.ZodString;
+            accountSlot: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
+            action: z.ZodLiteral<"join">;
+        }, z.core.$strict>], "action">;
+    }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"automod.enhanced.configuration.page">;
         cursor: z.ZodOptional<z.ZodString>;
         limit: z.ZodNumber;

package/dist/shard-contracts.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { CLOUD_MAX_RESOURCE_IMPORT_BYTES } from "@helyx/control-protocol";
+import { CLOUD_MAX_RESOURCE_IMPORT_BYTES, creatorOnboardingRequestSchema, } from "@helyx/control-protocol";
 import { AUTOMOD_SCANNER_LIMITS } from "@helyx/sdk";
 import { signedAssessmentEnvelopeSchema } from "@helyx/verification-contracts";
 export const SHARD_CONTRACT_VERSION = 1;
@@ -254,6 +254,14 @@ export const shardHealthSnapshotSchema = z
         });
 });
 export const shardControlOperationSchema = z.discriminatedUnion("kind", [
+    z
+        .object({
+        kind: z.literal("creator.onboarding"),
+        guildId: snowflake,
+        input: creatorOnboardingRequestSchema,
+    })
+        .strict()
+        .refine((value) => value.guildId === value.input.guildId),
     z
         .object({
         kind: z.literal("automod.enhanced.configuration.page"),
@@ -1273,6 +1281,10 @@ export async function executeShardControlOperation(handler, operation) {
                     ? { actorAuthenticatedAt: operation.actorAuthenticatedAt }
                     : {}),
             });
+        case "creator.onboarding":
+            if (!handler.creatorOnboarding)
+                throw new Error("Creator onboarding is unavailable");
+            return handler.creatorOnboarding(operation.input);
         case "oauth.consumer.cleanup":
             return handler.cleanupOAuthConsumer({
                 consumerBindingId: operation.consumerBindingId,

package/dist/shard-router.d.ts

@@ -1,4 +1,4 @@
-import { type AutoModerationEnhancedResultOutcome } from "@helyx/sdk";
+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";
 import type { ShardCoordinator, ShardLeaderLease, ShardLease } from "./shard-coordinator.js";
@@ -8,6 +8,7 @@ type LocalDispatcher = (shardId: number, request: ShardControlRequest) => Promis
 export declare class ShardControlRouter implements BotControlHandler {
     #private;
     private readonly input;
+    creatorOnboarding(input: CreatorOnboardingRequest): Promise<CreatorOnboardingResponse>;
     constructor(input: {
         generation: string;
         shardCount: number;

package/dist/shard-router.js

@@ -11,6 +11,13 @@ const LEASE_VALIDATION_TIMEOUT_MS = 3_000;
 const ECKO_RESULT_TIMEOUT_MS = AUTOMOD_SCANNER_LIMITS.resultAcknowledgementSeconds * 1_000;
 export class ShardControlRouter {
     input;
+    creatorOnboarding(input) {
+        return this.#route({
+            kind: "creator.onboarding",
+            guildId: input.guildId,
+            input,
+        });
+    }
     constructor(input) {
         this.input = input;
     }