@helyx/bot 1.1.0 → 1.2.1

package/dist/shard-contracts.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import type { ManagedResourceValue } from "@helyx/sdk";
+import { type ManagedResourceValue } from "@helyx/sdk";
 import type { BotControlHandler } from "./control-server.js";
 export declare const SHARD_CONTRACT_VERSION: 1;
 export declare const SHARD_CONTROL_MAX_BYTES: number;
@@ -167,6 +167,31 @@ 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<"automod.enhanced.configuration.page">;
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodNumber;
+    knownFingerprint: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"automod.enhanced.result.accept">;
+    guildId: z.ZodString;
+    result: z.ZodUnknown;
+    evidence: z.ZodOptional<z.ZodObject<{
+        sourceEventId: z.ZodString;
+        configurationRevision: z.ZodString;
+        guildId: z.ZodString;
+        channelId: z.ZodString;
+        messageId: z.ZodString;
+        authorUserId: z.ZodString;
+        content: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"hosted-server.leave.deliver">;
+    guildId: z.ZodString;
+    operationId: z.ZodUUID;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"hosted-server.owner.refresh">;
+    guildId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"guild.state.get">;
     guildId: z.ZodString;
 }, z.core.$strict>, z.ZodObject<{
@@ -224,6 +249,14 @@ export declare const shardControlOperationSchema: z.ZodDiscriminatedUnion<[z.Zod
     moduleId: z.ZodString;
     value: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNull, z.ZodString, z.ZodBoolean, z.ZodNumber, z.ZodArray<z.ZodString>]>>;
     expectedVersion: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    actorUserId: z.ZodString;
+    correlationId: z.ZodString;
+    kind: z.ZodLiteral<"guild.module.configuration.preview">;
+    guildId: z.ZodString;
+    moduleId: z.ZodString;
+    value: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNull, z.ZodString, z.ZodBoolean, z.ZodNumber, z.ZodArray<z.ZodString>]>>;
+    input: z.ZodRecord<z.ZodString, z.ZodCustom<ManagedResourceValue, ManagedResourceValue>>;
 }, z.core.$strict>, z.ZodObject<{
     actorUserId: z.ZodString;
     correlationId: z.ZodString;
@@ -274,6 +307,14 @@ export declare const shardControlOperationSchema: z.ZodDiscriminatedUnion<[z.Zod
     guildId: z.ZodString;
     moduleId: z.ZodString;
     actionId: z.ZodString;
+    inspectionRevision: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    actorUserId: z.ZodString;
+    correlationId: z.ZodString;
+    kind: z.ZodLiteral<"guild.module.action.preview">;
+    guildId: z.ZodString;
+    moduleId: z.ZodString;
+    actionId: z.ZodString;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"guild.module.resource.access">;
     guildId: z.ZodString;
@@ -324,6 +365,15 @@ export declare const shardControlOperationSchema: z.ZodDiscriminatedUnion<[z.Zod
     moduleId: z.ZodString;
     resourceType: z.ZodString;
     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.import">;
+    guildId: z.ZodString;
+    moduleId: z.ZodString;
+    resourceType: z.ZodString;
+    format: z.ZodLiteral<"utf8_text">;
+    content: z.ZodString;
 }, z.core.$strict>, z.ZodObject<{
     actorUserId: z.ZodString;
     correlationId: z.ZodString;
@@ -528,6 +578,31 @@ export declare const shardControlRequestSchema: z.ZodObject<{
     fencingToken: z.ZodNumber;
     deadlineAt: z.ZodISODateTime;
     operation: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"automod.enhanced.configuration.page">;
+        cursor: z.ZodOptional<z.ZodString>;
+        limit: z.ZodNumber;
+        knownFingerprint: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"automod.enhanced.result.accept">;
+        guildId: z.ZodString;
+        result: z.ZodUnknown;
+        evidence: z.ZodOptional<z.ZodObject<{
+            sourceEventId: z.ZodString;
+            configurationRevision: z.ZodString;
+            guildId: z.ZodString;
+            channelId: z.ZodString;
+            messageId: z.ZodString;
+            authorUserId: z.ZodString;
+            content: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"hosted-server.leave.deliver">;
+        guildId: z.ZodString;
+        operationId: z.ZodUUID;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"hosted-server.owner.refresh">;
+        guildId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"guild.state.get">;
         guildId: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
@@ -585,6 +660,14 @@ export declare const shardControlRequestSchema: z.ZodObject<{
         moduleId: z.ZodString;
         value: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNull, z.ZodString, z.ZodBoolean, z.ZodNumber, z.ZodArray<z.ZodString>]>>;
         expectedVersion: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        actorUserId: z.ZodString;
+        correlationId: z.ZodString;
+        kind: z.ZodLiteral<"guild.module.configuration.preview">;
+        guildId: z.ZodString;
+        moduleId: z.ZodString;
+        value: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNull, z.ZodString, z.ZodBoolean, z.ZodNumber, z.ZodArray<z.ZodString>]>>;
+        input: z.ZodRecord<z.ZodString, z.ZodCustom<ManagedResourceValue, ManagedResourceValue>>;
     }, z.core.$strict>, z.ZodObject<{
         actorUserId: z.ZodString;
         correlationId: z.ZodString;
@@ -635,6 +718,14 @@ export declare const shardControlRequestSchema: z.ZodObject<{
         guildId: z.ZodString;
         moduleId: z.ZodString;
         actionId: z.ZodString;
+        inspectionRevision: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        actorUserId: z.ZodString;
+        correlationId: z.ZodString;
+        kind: z.ZodLiteral<"guild.module.action.preview">;
+        guildId: z.ZodString;
+        moduleId: z.ZodString;
+        actionId: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"guild.module.resource.access">;
         guildId: z.ZodString;
@@ -685,6 +776,15 @@ export declare const shardControlRequestSchema: z.ZodObject<{
         moduleId: z.ZodString;
         resourceType: z.ZodString;
         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.import">;
+        guildId: z.ZodString;
+        moduleId: z.ZodString;
+        resourceType: z.ZodString;
+        format: z.ZodLiteral<"utf8_text">;
+        content: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
         actorUserId: z.ZodString;
         correlationId: z.ZodString;
@@ -1394,6 +1494,31 @@ export declare const supervisorMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObje
     fencingToken: z.ZodNumber;
     deadlineAt: z.ZodISODateTime;
     operation: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"automod.enhanced.configuration.page">;
+        cursor: z.ZodOptional<z.ZodString>;
+        limit: z.ZodNumber;
+        knownFingerprint: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"automod.enhanced.result.accept">;
+        guildId: z.ZodString;
+        result: z.ZodUnknown;
+        evidence: z.ZodOptional<z.ZodObject<{
+            sourceEventId: z.ZodString;
+            configurationRevision: z.ZodString;
+            guildId: z.ZodString;
+            channelId: z.ZodString;
+            messageId: z.ZodString;
+            authorUserId: z.ZodString;
+            content: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"hosted-server.leave.deliver">;
+        guildId: z.ZodString;
+        operationId: z.ZodUUID;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"hosted-server.owner.refresh">;
+        guildId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"guild.state.get">;
         guildId: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
@@ -1451,6 +1576,14 @@ export declare const supervisorMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObje
         moduleId: z.ZodString;
         value: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNull, z.ZodString, z.ZodBoolean, z.ZodNumber, z.ZodArray<z.ZodString>]>>;
         expectedVersion: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        actorUserId: z.ZodString;
+        correlationId: z.ZodString;
+        kind: z.ZodLiteral<"guild.module.configuration.preview">;
+        guildId: z.ZodString;
+        moduleId: z.ZodString;
+        value: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNull, z.ZodString, z.ZodBoolean, z.ZodNumber, z.ZodArray<z.ZodString>]>>;
+        input: z.ZodRecord<z.ZodString, z.ZodCustom<ManagedResourceValue, ManagedResourceValue>>;
     }, z.core.$strict>, z.ZodObject<{
         actorUserId: z.ZodString;
         correlationId: z.ZodString;
@@ -1501,6 +1634,14 @@ export declare const supervisorMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObje
         guildId: z.ZodString;
         moduleId: z.ZodString;
         actionId: z.ZodString;
+        inspectionRevision: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        actorUserId: z.ZodString;
+        correlationId: z.ZodString;
+        kind: z.ZodLiteral<"guild.module.action.preview">;
+        guildId: z.ZodString;
+        moduleId: z.ZodString;
+        actionId: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"guild.module.resource.access">;
         guildId: z.ZodString;
@@ -1551,6 +1692,15 @@ export declare const supervisorMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObje
         moduleId: z.ZodString;
         resourceType: z.ZodString;
         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.import">;
+        guildId: z.ZodString;
+        moduleId: z.ZodString;
+        resourceType: z.ZodString;
+        format: z.ZodLiteral<"utf8_text">;
+        content: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
         actorUserId: z.ZodString;
         correlationId: z.ZodString;

package/dist/shard-contracts.js

@@ -1,4 +1,6 @@
 import { z } from "zod";
+import { CLOUD_MAX_RESOURCE_IMPORT_BYTES } from "@helyx/control-protocol";
+import { AUTOMOD_SCANNER_LIMITS } from "@helyx/sdk";
 import { signedAssessmentEnvelopeSchema } from "@helyx/verification-contracts";
 export const SHARD_CONTRACT_VERSION = 1;
 // Guild dashboard state includes the bounded module catalogue as well as the
@@ -9,8 +11,30 @@ export const SHARD_CONTROL_TIMEOUT_MS = 30_000;
 export const SHARD_HEALTH_STALE_MS = 30_000;
 export const SHARD_LEASE_HEARTBEAT_TIMEOUT_MS = 20_000;
 const snowflake = z.string().regex(/^\d{17,20}$/u);
+const operationId = z.uuid();
 const safeIdentifier = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u);
 const dateTime = z.iso.datetime({ offset: true });
+const boundedEnhancedResult = z
+    .unknown()
+    .refine((value) => value !== null &&
+    typeof value === "object" &&
+    boundedJsonBytes(value, AUTOMOD_SCANNER_LIMITS.resultBytes), "Enhanced Auto Moderation result exceeds the transport limit");
+const enhancedEvidence = z
+    .object({
+    sourceEventId: z.string().regex(/^[a-f0-9]{64}$/u),
+    configurationRevision: z.string().min(1).max(160),
+    guildId: snowflake,
+    channelId: snowflake,
+    messageId: snowflake,
+    authorUserId: snowflake,
+    content: z
+        .string()
+        .min(1)
+        .max(AUTOMOD_SCANNER_LIMITS.messageCharacters)
+        .refine((value) => Buffer.byteLength(value, "utf8") <=
+        AUTOMOD_SCANNER_LIMITS.messageUtf8Bytes, "Enhanced Auto Moderation evidence exceeds the transport limit"),
+})
+    .strict();
 const moduleId = z.string().regex(/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)+$/u);
 const mutationContext = z
     .object({
@@ -230,6 +254,39 @@ export const shardHealthSnapshotSchema = z
         });
 });
 export const shardControlOperationSchema = z.discriminatedUnion("kind", [
+    z
+        .object({
+        kind: z.literal("automod.enhanced.configuration.page"),
+        cursor: z.string().min(1).max(512).optional(),
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .max(AUTOMOD_SCANNER_LIMITS.configurationPageServers),
+        knownFingerprint: z.string().min(1).max(128).optional(),
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("automod.enhanced.result.accept"),
+        guildId: snowflake,
+        result: boundedEnhancedResult,
+        evidence: enhancedEvidence.optional(),
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("hosted-server.leave.deliver"),
+        guildId: snowflake,
+        operationId,
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("hosted-server.owner.refresh"),
+        guildId: snowflake,
+    })
+        .strict(),
     z.object({ kind: z.literal("guild.state.get"), guildId: snowflake }).strict(),
     z
         .object({
@@ -300,6 +357,16 @@ export const shardControlOperationSchema = z.discriminatedUnion("kind", [
         ...mutationContext.shape,
     })
         .strict(),
+    z
+        .object({
+        kind: z.literal("guild.module.configuration.preview"),
+        guildId: snowflake,
+        moduleId,
+        value: configurationValue,
+        input: managedResourceObject,
+        ...mutationContext.shape,
+    })
+        .strict(),
     z
         .object({
         kind: z.literal("guild.module.permissions.update"),
@@ -326,6 +393,16 @@ export const shardControlOperationSchema = z.discriminatedUnion("kind", [
         guildId: snowflake,
         moduleId,
         actionId: z.string().regex(/^[a-z][a-z0-9_-]*$/u),
+        inspectionRevision: z.string().min(1).max(200).optional(),
+        ...mutationContext.shape,
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("guild.module.action.preview"),
+        guildId: snowflake,
+        moduleId,
+        actionId: z.string().regex(/^[a-z][a-z0-9_-]*$/u),
         ...mutationContext.shape,
     })
         .strict(),
@@ -387,6 +464,19 @@ export const shardControlOperationSchema = z.discriminatedUnion("kind", [
         ...mutationContext.shape,
     })
         .strict(),
+    z
+        .object({
+        kind: z.literal("guild.module.resource.import"),
+        guildId: snowflake,
+        moduleId,
+        resourceType,
+        format: z.literal("utf8_text"),
+        content: z
+            .string()
+            .refine((value) => Buffer.byteLength(value, "utf8") <= CLOUD_MAX_RESOURCE_IMPORT_BYTES, "Managed resource import exceeds the transport limit"),
+        ...mutationContext.shape,
+    })
+        .strict(),
     z
         .object({
         kind: z.literal("guild.module.resource.create"),
@@ -962,6 +1052,13 @@ export function assertShardMessageSize(value) {
 }
 export async function executeShardControlOperation(handler, operation) {
     switch (operation.kind) {
+        case "automod.enhanced.configuration.page":
+            throw new Error("Enhanced Auto Moderation configuration requires the shard leader");
+        case "automod.enhanced.result.accept":
+            throw new Error("Enhanced Auto Moderation result delivery requires the shard worker");
+        case "hosted-server.leave.deliver":
+        case "hosted-server.owner.refresh":
+            throw new Error("Hosted leave delivery requires the shard worker");
         case "guild.presence.list":
             return handler.listGuildPresence({
                 guildIds: operation.guildIds,
@@ -1022,6 +1119,15 @@ export async function executeShardControlOperation(handler, operation) {
                 correlationId: operation.correlationId,
             });
         }
+        case "guild.module.configuration.preview":
+            return handler.previewConfiguration({
+                guildId: operation.guildId,
+                moduleId: operation.moduleId,
+                value: operation.value,
+                input: operation.input,
+                actorUserId: operation.actorUserId,
+                correlationId: operation.correlationId,
+            });
         case "guild.module.permissions.update": {
             return handler.updatePermissions({
                 guildId: operation.guildId,
@@ -1044,6 +1150,18 @@ export async function executeShardControlOperation(handler, operation) {
         }
         case "guild.module.action.execute": {
             return handler.executeDashboardAction({
+                guildId: operation.guildId,
+                moduleId: operation.moduleId,
+                actionId: operation.actionId,
+                ...(operation.inspectionRevision === undefined
+                    ? {}
+                    : { inspectionRevision: operation.inspectionRevision }),
+                actorUserId: operation.actorUserId,
+                correlationId: operation.correlationId,
+            });
+        }
+        case "guild.module.action.preview": {
+            return handler.previewDashboardAction({
                 guildId: operation.guildId,
                 moduleId: operation.moduleId,
                 actionId: operation.actionId,
@@ -1099,6 +1217,16 @@ export async function executeShardControlOperation(handler, operation) {
                 actorUserId: operation.actorUserId,
                 correlationId: operation.correlationId,
             });
+        case "guild.module.resource.import":
+            return handler.importManagedResource({
+                guildId: operation.guildId,
+                moduleId: operation.moduleId,
+                resourceType: operation.resourceType,
+                format: operation.format,
+                content: operation.content,
+                actorUserId: operation.actorUserId,
+                correlationId: operation.correlationId,
+            });
         case "guild.module.resource.create":
             return handler.createManagedResource({
                 guildId: operation.guildId,
@@ -1158,7 +1286,7 @@ export async function executeShardControlOperation(handler, operation) {
                 correlationId: operation.correlationId,
             });
         case "support.notification.send": {
-            return handler.sendSupportNotification({
+            await handler.sendSupportNotification({
                 notificationId: operation.notificationId,
                 reference: operation.reference,
                 caseType: operation.caseType,
@@ -1166,6 +1294,11 @@ export async function executeShardControlOperation(handler, operation) {
                 reportedSeverity: operation.reportedSeverity,
                 source: operation.source,
             });
+            // Child-process IPC uses JSON serialization. Returning the handler's void
+            // result would remove the required `result` property from the success
+            // envelope, causing the supervisor to discard a successful Discord send
+            // and retry it after a timeout.
+            return null;
         }
         case "verification.result.accept":
             return handler.acceptVerificationResult(operation.envelope);
@@ -1221,4 +1354,12 @@ function isBoundedManagedResourceValue(value, depth = 0, budget = { keys: 0 }) {
 function hasBoundedManagedResourceBytes(value) {
     return (new TextEncoder().encode(JSON.stringify(value)).byteLength <= 48 * 1_024);
 }
+function boundedJsonBytes(value, maximumBytes) {
+    try {
+        return Buffer.byteLength(JSON.stringify(value), "utf8") <= maximumBytes;
+    }
+    catch {
+        return false;
+    }
+}
 //# sourceMappingURL=shard-contracts.js.map

package/dist/shard-coordinator.d.ts

@@ -5,9 +5,9 @@ declare const generationDescriptorSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
     applicationId: z.ZodString;
     environment: z.ZodEnum<{
+        production: "production";
         development: "development";
         test: "test";
-        production: "production";
     }>;
     generation: z.ZodString;
     shardCount: z.ZodNumber;

package/dist/shard-ecko-scanner-registry.d.ts

@@ -0,0 +1,38 @@
+import { type AutoModerationEnhancedResultOutcome, type AutoModerationScannerAdapterSelection, type AutoModerationScannerProviderRegistryService } from "@helyx/sdk";
+import type { TransientViolationEvidenceStore } from "./transient-violation-evidence.js";
+export interface ShardEckoResultRoute {
+    guildId: string;
+    result: unknown;
+    evidence?: {
+        sourceEventId: string;
+        configurationRevision: string;
+        guildId: string;
+        channelId: string;
+        messageId: string;
+        authorUserId: string;
+        content: string;
+    };
+}
+/**
+ * Supervisor-only Ecko facade. Configuration is read from the fenced leader's
+ * allowlisted provider. Results and one-use evidence are routed to the guild
+ * owner, where the worker registry performs all validation and actions.
+ */
+export declare class ShardEckoScannerRegistry implements AutoModerationScannerProviderRegistryService {
+    #private;
+    private readonly input;
+    constructor(input: {
+        configurationRegistry(): AutoModerationScannerProviderRegistryService | undefined;
+        routeConfiguration?(input: {
+            cursor?: string;
+            limit: number;
+            knownFingerprint?: string;
+        }): ReturnType<AutoModerationScannerProviderRegistryService["getConfigurationPage"]>;
+        evidenceStore: TransientViolationEvidenceStore;
+        routeResult(input: ShardEckoResultRoute): Promise<AutoModerationEnhancedResultOutcome>;
+    });
+    select(): Promise<AutoModerationScannerAdapterSelection>;
+    getConfigurationPage(input: Parameters<AutoModerationScannerProviderRegistryService["getConfigurationPage"]>[0]): Promise<import("@helyx/sdk").AutoModerationScannerConfigurationPageV1>;
+    acceptResult(input: Parameters<AutoModerationScannerProviderRegistryService["acceptResult"]>[0]): Promise<AutoModerationEnhancedResultOutcome>;
+}
+//# sourceMappingURL=shard-ecko-scanner-registry.d.ts.map

package/dist/shard-ecko-scanner-registry.js

@@ -0,0 +1,96 @@
+import { AUTOMOD_ENHANCED_CONTRACT_VERSION, AUTOMOD_ENHANCED_PROVIDER_ID, } from "@helyx/sdk";
+/**
+ * Supervisor-only Ecko facade. Configuration is read from the fenced leader's
+ * allowlisted provider. Results and one-use evidence are routed to the guild
+ * owner, where the worker registry performs all validation and actions.
+ */
+export class ShardEckoScannerRegistry {
+    input;
+    constructor(input) {
+        this.input = input;
+    }
+    select() {
+        return Promise.resolve({
+            adapter: "unavailable",
+            available: false,
+            reason: "dependency_unhealthy",
+        });
+    }
+    async getConfigurationPage(input) {
+        const registry = this.input.configurationRegistry();
+        if (registry)
+            return registry.getConfigurationPage(input);
+        if (!this.input.routeConfiguration)
+            throw new Error("Ecko configuration leader is unavailable");
+        return this.input.routeConfiguration({
+            limit: input.limit,
+            ...(input.cursor ? { cursor: input.cursor } : {}),
+            ...(input.knownFingerprint
+                ? { knownFingerprint: input.knownFingerprint }
+                : {}),
+        });
+    }
+    async acceptResult(input) {
+        if (input.adapter !== "hosted_ecko" ||
+            input.providerId !== AUTOMOD_ENHANCED_PROVIDER_ID ||
+            input.contractVersion !== AUTOMOD_ENHANCED_CONTRACT_VERSION) {
+            this.#discard(input.evidenceReference);
+            return rejected("wrong_owner");
+        }
+        const guildId = resultGuildId(input.result);
+        if (!guildId) {
+            this.#discard(input.evidenceReference);
+            return rejected("invalid_envelope");
+        }
+        const evidence = input.evidenceReference
+            ? this.#takeEvidence(input.evidenceReference)
+            : undefined;
+        try {
+            return await this.input.routeResult({
+                guildId,
+                result: input.result,
+                ...(evidence ? { evidence } : {}),
+            });
+        }
+        catch (error) {
+            return rejected(isDeadlineError(error) ? "stale" : "wrong_owner");
+        }
+    }
+    #takeEvidence(reference) {
+        const read = this.input.evidenceStore.consume(reference);
+        if (read.outcome !== "available" ||
+            reference.source !== "enhanced_scanner" ||
+            reference.messageId === null)
+            return undefined;
+        return {
+            sourceEventId: reference.sourceEventId,
+            configurationRevision: reference.configurationRevision,
+            guildId: reference.guildId,
+            channelId: reference.channelId,
+            messageId: reference.messageId,
+            authorUserId: reference.authorUserId,
+            content: read.content,
+        };
+    }
+    #discard(reference) {
+        if (reference)
+            this.input.evidenceStore.discard(reference);
+    }
+}
+function resultGuildId(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const guildId = value["guildId"];
+    return typeof guildId === "string" && /^\d{17,20}$/u.test(guildId)
+        ? guildId
+        : undefined;
+}
+function isDeadlineError(error) {
+    return (error instanceof Error &&
+        (error.message.toLowerCase().includes("time") ||
+            error.message.toLowerCase().includes("expired")));
+}
+function rejected(code) {
+    return { outcome: "rejected", code };
+}
+//# sourceMappingURL=shard-ecko-scanner-registry.js.map

package/dist/shard-router.d.ts

@@ -1,6 +1,9 @@
+import { type AutoModerationEnhancedResultOutcome } 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";
+import type { ShardEckoResultRoute } from "./shard-ecko-scanner-registry.js";
+import type { AutoModerationScannerProviderRegistryService } from "@helyx/sdk";
 type LocalDispatcher = (shardId: number, request: ShardControlRequest) => Promise<ShardControlResponse>;
 export declare class ShardControlRouter implements BotControlHandler {
     #private;
@@ -11,13 +14,30 @@ export declare class ShardControlRouter implements BotControlHandler {
         localLeases: ReadonlyMap<number, ShardLease>;
         dispatchLocal: LocalDispatcher;
         privacy?: Pick<BotControlHandler, "listPrivacyProviders" | "capturePrivacy" | "erasePrivacy">;
+        leaderScannerRegistry?: AutoModerationScannerProviderRegistryService;
         availability?: Pick<BotControlHandler, "listAvailabilityModules">;
         localLeaderLease?: ShardLeaderLease;
         coordinator?: ShardCoordinator;
         notificationGuildId?: string;
     });
     cleanupOAuthConsumer(input: Parameters<BotControlHandler["cleanupOAuthConsumer"]>[0]): ReturnType<BotControlHandler["cleanupOAuthConsumer"]>;
+    deliverHostedServerLeave(input: {
+        operationId: string;
+        guildId: string;
+    }): Promise<"queued" | "completed" | "not_currently_installed" | "accepted_for_retry" | "requires_review">;
+    refreshHostedServerOwner(guildId: string): Promise<{
+        username: string;
+        observedAt: string;
+    }>;
     listAvailabilityModules(): ReturnType<BotControlHandler["listAvailabilityModules"]>;
+    /** Routes an authenticated Ecko result to the current guild owner. */
+    acceptHostedEckoResult(input: ShardEckoResultRoute): Promise<AutoModerationEnhancedResultOutcome>;
+    /** Reads the fenced leader's current Enhanced configuration snapshot. */
+    getHostedEckoConfigurationPage(input: {
+        cursor?: string;
+        limit: number;
+        knownFingerprint?: string;
+    }): ReturnType<AutoModerationScannerProviderRegistryService["getConfigurationPage"]>;
     getGuildState(guildId: string): ReturnType<BotControlHandler["getGuildState"]>;
     canAccessDashboard(input: Parameters<BotControlHandler["canAccessDashboard"]>[0]): ReturnType<BotControlHandler["canAccessDashboard"]>;
     getGuildAccessPolicy(input: Parameters<BotControlHandler["getGuildAccessPolicy"]>[0]): ReturnType<BotControlHandler["getGuildAccessPolicy"]>;
@@ -28,13 +48,16 @@ export declare class ShardControlRouter implements BotControlHandler {
     setModuleStatus(input: Parameters<BotControlHandler["setModuleStatus"]>[0]): ReturnType<BotControlHandler["setModuleStatus"]>;
     completeFirstTimeCommandSetup(input: Parameters<BotControlHandler["completeFirstTimeCommandSetup"]>[0]): ReturnType<BotControlHandler["completeFirstTimeCommandSetup"]>;
     updateConfiguration(input: Parameters<BotControlHandler["updateConfiguration"]>[0]): ReturnType<BotControlHandler["updateConfiguration"]>;
+    previewConfiguration(input: Parameters<BotControlHandler["previewConfiguration"]>[0]): ReturnType<BotControlHandler["previewConfiguration"]>;
     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"]>;
+    previewDashboardAction(input: Parameters<BotControlHandler["previewDashboardAction"]>[0]): ReturnType<BotControlHandler["previewDashboardAction"]>;
     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"]>;
+    importManagedResource(input: Parameters<BotControlHandler["importManagedResource"]>[0]): ReturnType<BotControlHandler["importManagedResource"]>;
     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"]>;