@helyx/bot 0.4.24 → 0.4.26

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.4.26
+
+### Patch Changes
+
+- Require the database runner that installs packaged module migration seeds before runtime readiness.
+
+## 0.4.25
+
+### Patch Changes
+
+- Launch the shared gaming statistics foundation and the Achievements, Counting and Trivia module integrations, while removing retired Access Control and Counting storage through guarded migrations.
+
 ## 0.4.24
 
 ### Patch Changes

package/README.md

@@ -23,6 +23,10 @@ resume secure weighted-selection checkpoints without exposing the selection
 key to a module. Keep it stable across deployments; do not rotate it while a
 giveaway is drawing.
 
+Trivia uses questions already imported into PostgreSQL. Multiple Choice and
+Guess both run entirely from the saved question catalogue, and the bot runtime
+does not call an external trivia provider.
+
 The always-available guild-only `/bug` command can be used by any guild member.
 Hosted deployments submit through the dedicated `HELYX_SUPPORT_SERVICE_SECRET`;
 paired self-hosted deployments use their authenticated Cloud Connect session

package/dist/cloud-connector.d.ts

@@ -4,7 +4,7 @@ import { type CloudConnectorConsentRecord, type DatabasePool } from "@helyx/data
 import type { Client } from "discord.js";
 import type { Logger } from "pino";
 import type { ConfiguredModulePackage } from "./modules.js";
-import type { BotControlHandler } from "./control-server.js";
+import { type BotControlHandler } from "./control-server.js";
 type ConnectorState = "disabled" | "unpaired" | "connecting" | "online" | "offline" | "recovery_required" | "revoked" | "stopped";
 export interface CloudConnectorStatus {
     state: ConnectorState;
@@ -80,5 +80,7 @@ export declare class CloudConnectorController implements CloudConnector {
 export declare class CloudConnectorUserError extends Error {
     constructor(message: string);
 }
+export declare function mapControlError(error: unknown): "not_found" | "conflict" | "bad_request" | "forbidden" | "temporarily_unavailable" | "internal_error";
+export declare function safeControlMessage(error: unknown): string;
 export {};
 //# sourceMappingURL=cloud-connector.d.ts.map

package/dist/cloud-connector.js

@@ -6,6 +6,7 @@ import { resolve } from "node:path";
 import WebSocket from "ws";
 import { z } from "zod";
 import { CloudControlDeniedError, CloudControlDispatcher, } from "./cloud-control-dispatcher.js";
+import { BotControlTransportError, } from "./control-server.js";
 const enrolmentFileSchema = z
     .object({
     schemaVersion: z.literal(1),
@@ -718,6 +719,7 @@ function connectorCapabilities() {
     return [
         "installation.health.read.v1",
         "guild.state.read.v1",
+        "guild.module.public.read.v1",
         "guild.module.status.write.v1",
         "guild.module.configuration.write.v1",
         "guild.module.permissions.write.v1",
@@ -786,7 +788,19 @@ function connectedMessage(input) {
         payload: input.payload,
     });
 }
-function mapControlError(error) {
+export function mapControlError(error) {
+    if (error instanceof BotControlTransportError) {
+        if (error.status === 400)
+            return "bad_request";
+        if (error.status === 403)
+            return "forbidden";
+        if (error.status === 404)
+            return "not_found";
+        if (error.status === 409)
+            return "conflict";
+        if (error.status >= 502)
+            return "temporarily_unavailable";
+    }
     const name = error instanceof Error ? error.name : "";
     if (name.includes("NotFound"))
         return "not_found";
@@ -798,7 +812,7 @@ function mapControlError(error) {
         return "temporarily_unavailable";
     return "internal_error";
 }
-function safeControlMessage(error) {
+export function safeControlMessage(error) {
     const code = mapControlError(error);
     if (code === "not_found")
         return "The requested Helyx resource was not found";
@@ -808,6 +822,8 @@ function safeControlMessage(error) {
         return error instanceof Error
             ? error.message.slice(0, 300)
             : "The requested change was not valid";
+    if (code === "forbidden")
+        return "You do not have permission to make this change";
     if (code === "temporarily_unavailable")
         return "The self-hosted bot is temporarily unavailable";
     return "The self-hosted bot could not complete the request";

package/dist/cloud-control-dispatcher.js

@@ -25,6 +25,19 @@ export class CloudControlDispatcher {
                 result = await this.control.getGuildState(input.guildId);
                 break;
             }
+            case "guild.module.public.read.v1": {
+                const input = parseOperationInput(request.operation, request.input);
+                if (request.actor.kind !== "public")
+                    throw new CloudControlDeniedError("public_actor_required");
+                result = await this.control.readPublicModuleProjection({
+                    guildId: input.guildId,
+                    moduleId: input.moduleId,
+                    ...(input.memberUserId ? { subjectUserId: input.memberUserId } : {}),
+                    ...(input.cursor ? { cursor: input.cursor } : {}),
+                    limit: input.limit,
+                });
+                break;
+            }
             case "guild.module.status.write.v1": {
                 const input = parseOperationInput(request.operation, request.input);
                 result = await this.control.setModuleStatus({

package/dist/control-server.d.ts

@@ -1,5 +1,5 @@
 import { type DatabasePool, type GuildShardOwnership } from "@helyx/database";
-import { type DashboardActionResult, type ManagedResourceCreationIntent, type ManagedResourceDetail, type ManagedResourcePage, type ManagedResourceRelationPage, type ManagedResourceValue, type MessageResponse, type ModuleDefinition, type PermissionActor, type PrivacyCapturePage, type PrivacyErasePage, type PrivacyProviderExecutor, type ServiceAccess } from "@helyx/sdk";
+import { type DashboardActionResult, type ManagedResourceCreationIntent, type ManagedResourceDetail, type ManagedResourcePage, type ManagedResourceRelationPage, type ManagedResourceValue, type MessageResponse, type ModuleDefinition, type PermissionActor, type PrivacyCapturePage, type PrivacyErasePage, type PrivacyProviderExecutor, type PublicAchievementProjectionPage, type ServiceAccess } from "@helyx/sdk";
 import { type ActionReceipt, type SignedAssessmentEnvelope } from "@helyx/verification-contracts";
 import { type Client } from "discord.js";
 import { type FastifyInstance } from "fastify";
@@ -43,6 +43,7 @@ interface DashboardModuleDefinition {
     commands: DashboardCommandDefinition[];
     logEvents: DashboardLogEventDefinition[];
     actions: DashboardActionDefinition[];
+    achievementTriggers: NonNullable<ModuleDefinition["manifest"]["contributions"]["achievementTriggers"]>;
     resources: readonly DashboardResourceDefinition[];
 }
 interface DashboardLoggingPolicy {
@@ -72,6 +73,14 @@ export interface BotControlGuildResources {
         colour: string;
     }>;
 }
+export interface BotPublicModuleProjection {
+    server: {
+        id: string;
+        name: string;
+        memberCount: number;
+    };
+    projection: PublicAchievementProjectionPage;
+}
 export type BotGuildPresenceState = "installed" | "not_installed" | "unknown" | "unavailable";
 export interface BotGuildPresenceObservation {
     guildId: string;
@@ -81,6 +90,11 @@ export interface BotGuildPresenceObservation {
 export interface BotControlGuildResourceDirectory {
     listGuildPresence(guildIds: readonly string[]): Promise<BotGuildPresenceObservation[]>;
     getGuildResources(guildId: string): Promise<BotControlGuildResources>;
+    getGuildPublicSummary(guildId: string): Promise<{
+        id: string;
+        name: string;
+        memberCount: number;
+    }>;
     sendToChannel(channelId: string, response: MessageResponse): Promise<{
         messageId: string;
     }>;
@@ -95,6 +109,11 @@ export declare class DiscordGuildResourceDirectory implements BotControlGuildRes
     constructor(client: Client);
     listGuildPresence(guildIds: readonly string[]): Promise<BotGuildPresenceObservation[]>;
     getGuildResources(guildId: string): Promise<BotControlGuildResources>;
+    getGuildPublicSummary(guildId: string): Promise<{
+        id: string;
+        name: string;
+        memberCount: number;
+    }>;
     sendToChannel(channelId: string, response: MessageResponse): Promise<{
         messageId: string;
     }>;
@@ -134,6 +153,13 @@ export interface BotControlHandler {
         correlationId: string;
     }): Promise<BotGuildPresenceObservation[]>;
     getGuildState(guildId: string): Promise<BotControlState>;
+    readPublicModuleProjection(input: {
+        guildId: string;
+        moduleId: string;
+        subjectUserId?: string;
+        cursor?: string;
+        limit: number;
+    }): Promise<BotPublicModuleProjection>;
     canAccessManagedResource(input: {
         guildId: string;
         moduleId: string;
@@ -328,6 +354,13 @@ export declare class BotControlService implements BotControlHandler {
         cursor?: string;
     }): Promise<PrivacyErasePage>;
     getGuildState(guildId: string): Promise<BotControlState>;
+    readPublicModuleProjection(input: {
+        guildId: string;
+        moduleId: string;
+        subjectUserId?: string;
+        cursor?: string;
+        limit: number;
+    }): Promise<BotPublicModuleProjection>;
     canAccessManagedResource(input: {
         guildId: string;
         moduleId: string;

package/dist/control-server.js

@@ -155,6 +155,17 @@ export class DiscordGuildResourceDirectory {
             throw error;
         }
     }
+    async getGuildPublicSummary(guildId) {
+        try {
+            const guild = await this.client.guilds.fetch(guildId);
+            return { id: guild.id, name: guild.name, memberCount: guild.memberCount };
+        }
+        catch (error) {
+            if (isUnknownGuildError(error))
+                throw new BotControlNotFoundError();
+            throw error;
+        }
+    }
     sendToChannel(channelId, response) {
         return sendDiscordMessageToChannel(this.client, channelId, response);
     }
@@ -414,6 +425,39 @@ export class BotControlService {
             logging,
         };
     }
+    async readPublicModuleProjection(input) {
+        const module = this.#requireModule(input.moduleId);
+        if (!module.publicProjection)
+            throw new BotControlNotFoundError("Public module projection was not found");
+        if (!(await new InstallationRepository(this.database).isModuleEnabled(input.guildId, input.moduleId)))
+            throw new BotControlValidationError("This module is not enabled");
+        if (input.subjectUserId) {
+            if (!this.#services.has(HELYX_SERVICE_NAMES.discordResources))
+                throw new BotControlTransportError(503, "Discord membership confirmation is unavailable");
+            const [member] = await this.#services
+                .get(HELYX_SERVICE_NAMES.discordResources)
+                .resolveMemberSnapshots({
+                guildId: input.guildId,
+                userIds: [input.subjectUserId],
+            });
+            if (!member?.exists)
+                throw new BotControlForbiddenError("Server membership is required");
+        }
+        const [server, projection] = await Promise.all([
+            this.resources.getGuildPublicSummary(input.guildId),
+            module.publicProjection.read({
+                guildId: input.guildId,
+                ...(input.subjectUserId
+                    ? { subjectUserId: input.subjectUserId }
+                    : {}),
+                services: this.#services,
+            }, {
+                ...(input.cursor ? { cursor: input.cursor } : {}),
+                limit: Math.min(10, Math.max(1, input.limit)),
+            }),
+        ]);
+        return { server, projection };
+    }
     async canAccessManagedResource(input) {
         try {
             const { module } = await this.#prepareManagedResource(input);
@@ -1095,6 +1139,26 @@ export async function createBotControlServer(input) {
         const { guildId } = z.object({ guildId: snowflake }).parse(request.params);
         return input.service.getGuildState(guildId);
     });
+    server.get("/v1/guilds/:guildId/modules/:moduleId/public-projection", async (request) => {
+        const params = z
+            .object({ guildId: snowflake, moduleId })
+            .strict()
+            .parse(request.params);
+        const query = z
+            .object({
+            subjectUserId: snowflake.optional(),
+            cursor: z.string().min(1).max(2_048).optional(),
+            limit: z.coerce.number().int().min(1).max(10).default(10),
+        })
+            .strict()
+            .parse(request.query);
+        return input.service.readPublicModuleProjection({
+            ...params,
+            ...(query.subjectUserId ? { subjectUserId: query.subjectUserId } : {}),
+            ...(query.cursor ? { cursor: query.cursor } : {}),
+            limit: query.limit,
+        });
+    });
     server.post("/v1/guilds/:guildId/modules/:moduleId/resources/:resourceType/access", async (request) => {
         const params = z
             .object({
@@ -1602,6 +1666,7 @@ function mapDashboardModule(module) {
         commands: dashboardCommands(module),
         logEvents: (module.logging?.events ?? []).map((event) => ({ ...event })),
         actions: (dashboard.actions ?? []).map((action) => ({ ...action })),
+        achievementTriggers: (module.manifest.contributions?.achievementTriggers ?? []).map((trigger) => structuredClone(trigger)),
         resources: (dashboard.resources ?? []).map((resource) => structuredClone(resource)),
     };
 }

package/dist/events.js

@@ -14,6 +14,10 @@ export function installModuleEvents(client, modules, logger, services) {
             false,
         contribution,
     })));
+    const guildVoiceSessionContributions = modules.flatMap((module) => (module.events?.guildVoiceSession ?? []).map((contribution) => ({
+        moduleId: module.manifest.id,
+        contribution,
+    })));
     const messageClassificationRequested = modules.some((module) => module.requiredDiscordCapabilities?.includes("message-content"));
     const messageClassificationAvailable = messageClassificationRequested &&
         client.options.intents.has(GatewayIntentBits.MessageContent);
@@ -63,6 +67,7 @@ export function installModuleEvents(client, modules, logger, services) {
     })));
     if (privilegedMessageContributions.length === 0 &&
         guildMessageContributions.length === 0 &&
+        guildVoiceSessionContributions.length === 0 &&
         reactionContributions.length === 0 &&
         reactionRemoveContributions.length === 0 &&
         messageDeleteContributions.length === 0 &&
@@ -76,6 +81,7 @@ export function installModuleEvents(client, modules, logger, services) {
         guildEmojiUpdateContributions.length === 0)
         return { stop: () => Promise.resolve(), queueDepth: () => 0 };
     const queue = new BoundedGuildEventQueue(logger);
+    const voiceSessions = new Map();
     const privilegedEligibilityQueue = privilegedMessageContributions.length > 0
         ? new BoundedGuildEventQueue(logger)
         : null;
@@ -129,6 +135,13 @@ export function installModuleEvents(client, modules, logger, services) {
             guildMessageQueue.enqueue(message.guildId, () => handleGuildMessageCreate(message));
         });
     }
+    if (guildVoiceSessionContributions.length > 0) {
+        client.on(Events.VoiceStateUpdate, (before, after) => {
+            if ((after.member ?? before.member)?.user.bot)
+                return;
+            queue.enqueue(after.guild.id, () => handleVoiceState(before, after));
+        });
+    }
     if (reactionContributions.length > 0) {
         client.on(Events.MessageReactionAdd, (reaction, user, details) => {
             const guildId = reaction.message.guildId;
@@ -271,6 +284,8 @@ export function installModuleEvents(client, modules, logger, services) {
                     channelId: message.channelId,
                     ...(parentChannelId ? { parentChannelId } : {}),
                     messageId: message.id,
+                    isReply: message.reference?.messageId !== null &&
+                        message.reference?.messageId !== undefined,
                     authorId: message.author.id,
                     authorDisplayName,
                     authorRoleIds,
@@ -514,11 +529,64 @@ export function installModuleEvents(client, modules, logger, services) {
             }
         }
     }
+    async function handleVoiceState(before, after) {
+        const memberId = after.id;
+        const key = `${after.guild.id}:${memberId}`;
+        const previous = voiceSessions.get(key);
+        const channelId = eligibleVoiceChannel(after);
+        if (previous && previous.channelId !== channelId) {
+            voiceSessions.delete(key);
+            const endedAt = new Date();
+            const durationSeconds = Math.max(1, Math.floor((endedAt.getTime() - previous.startedAt.getTime()) / 1_000));
+            const installations = services.get(HELYX_SERVICE_NAMES.installations);
+            for (const { moduleId, contribution } of guildVoiceSessionContributions) {
+                try {
+                    if (!(await installations.isModuleEnabled(previous.guildId, moduleId)))
+                        continue;
+                    await contribution.execute({
+                        serverId: previous.guildId,
+                        channelId: previous.channelId,
+                        memberId,
+                        startedAt: previous.startedAt,
+                        endedAt,
+                        durationSeconds,
+                        services,
+                    });
+                }
+                catch (error) {
+                    logger.warn({
+                        event: "module.guild_voice_session_failed",
+                        moduleId,
+                        guildId: previous.guildId,
+                        error: safeError(error),
+                    }, "Module guild voice session event failed");
+                }
+            }
+        }
+        if (channelId && (!previous || previous.channelId !== channelId)) {
+            voiceSessions.set(key, {
+                guildId: after.guild.id,
+                memberId,
+                channelId,
+                startedAt: new Date(),
+            });
+        }
+    }
+    function eligibleVoiceChannel(state) {
+        if (!state.channelId || !state.channel)
+            return null;
+        if (state.channel.type !== ChannelType.GuildVoice)
+            return null;
+        if (state.guild.afkChannelId === state.channelId)
+            return null;
+        return state.channelId;
+    }
     return {
         stop: async () => {
             await privilegedEligibilityQueue?.stop();
             await guildMessageQueue?.stop();
             await queue.stop();
+            voiceSessions.clear();
         },
         queueDepth: () => queue.queueDepth() +
             (privilegedEligibilityQueue?.queueDepth() ?? 0) +

package/dist/index.js

@@ -2,7 +2,7 @@ import { parseBotEnvironment } from "@helyx/config";
 import { safeError, ServiceRegistry } from "@helyx/core";
 import { checkDatabaseConnection, createDatabasePool, AuditRepository, InteractionSessionRepository, RateLimitRepository, runCoreMigrations, runConfiguredModuleMigrations, } from "@helyx/database";
 import { createRuntime } from "@helyx/framework";
-import { createPlatformServices, PostgresPrivacyProviderExecutor, } from "@helyx/platform";
+import { createPlatformServices, gamingStatisticsRecordOwner, achievementContributionRecordOwner, PostgresPrivacyProviderExecutor, } from "@helyx/platform";
 import { HELYX_SERVICE_NAMES, } from "@helyx/sdk";
 import { Client, Events, GatewayIntentBits, Partials } from "discord.js";
 import pino from "pino";
@@ -292,11 +292,19 @@ async function startUnshardedBot(processEnvironment) {
             ]),
         }, bootstrapLogger, serviceAccess);
         const moduleEvents = installModuleEvents(client, publicModules, bootstrapLogger, serviceAccess);
-        const controlService = new BotControlService(database, publicModules, guildResources, serviceAccess, privacyDatabase
+        const controlService = new BotControlService(database, [
+            ...publicModules,
+            gamingStatisticsRecordOwner,
+            achievementContributionRecordOwner,
+        ], guildResources, serviceAccess, privacyDatabase
             ? new PostgresPrivacyProviderExecutor({
                 readPool: database,
                 executorPool: privacyDatabase,
-                modules: featureModules,
+                modules: [
+                    ...featureModules,
+                    gamingStatisticsRecordOwner,
+                    achievementContributionRecordOwner,
+                ],
             })
             : undefined, environment.DISCORD_INTERNAL_GUILD_ID &&
             environment.HELYX_SUPPORT_STAFF_CHANNEL_ID
@@ -484,6 +492,9 @@ export function gatewayIntentsForModules(modules, messageContentEnabled = false)
         module.events?.guildMemberRemove?.length)) {
         intents.push(GatewayIntentBits.GuildMembers);
     }
+    if (modules.some((module) => module.events?.guildVoiceSession?.length)) {
+        intents.push(GatewayIntentBits.GuildVoiceStates);
+    }
     if (modules.some((module) => module.events?.guildEmojiDelete?.length ||
         module.events?.guildEmojiUpdate?.length)) {
         intents.push(GatewayIntentBits.GuildExpressions);

package/dist/interactions.js

@@ -277,6 +277,20 @@ function addCommandOption(builder, option) {
             .setRequired(option.required ?? false));
         return;
     }
+    if (option.type === "integer") {
+        builder.addIntegerOption((optionBuilder) => {
+            optionBuilder
+                .setName(option.name)
+                .setDescription(option.description)
+                .setRequired(option.required ?? false);
+            if (option.minimum !== undefined)
+                optionBuilder.setMinValue(option.minimum);
+            if (option.maximum !== undefined)
+                optionBuilder.setMaxValue(option.maximum);
+            return optionBuilder;
+        });
+        return;
+    }
     if (option.type === "user") {
         builder.addUserOption((optionBuilder) => optionBuilder
             .setName(option.name)
@@ -399,6 +413,7 @@ function createCommandContext(interaction, services) {
         ...createContext(interaction, services),
         getStringOption: (name) => interaction.options.getString(name),
         getBooleanOption: (name) => interaction.options.getBoolean(name),
+        getIntegerOption: (name) => interaction.options.getInteger(name),
         getUserOption: (name) => {
             const user = interaction.options.getUser(name);
             return user

package/dist/modules.js

@@ -100,6 +100,7 @@ export function validateContributionParity(definition) {
     const executableEvents = [
         ...(definition.events?.privilegedMessageCreate ?? []),
         ...(definition.events?.guildMessageCreate ?? []),
+        ...(definition.events?.guildVoiceSession ?? []),
         ...(definition.events?.messageReactionAdd ?? []),
         ...(definition.events?.messageReactionRemove ?? []),
         ...(definition.events?.messageDelete ?? []),

package/dist/numeric-write-behind-proxy.js

@@ -275,8 +275,10 @@ function encodeRecord(input) {
             result[field] = { type: "string", value };
         else if (typeof value === "boolean")
             result[field] = { type: "boolean", value };
-        else
+        else if (typeof value === "number")
             result[field] = { type: "number", value };
+        else
+            throw new Error("Numeric write-behind values must be scalar");
     }
     return result;
 }

package/dist/shard-contracts.d.ts

@@ -169,6 +169,13 @@ export type ShardHealthSnapshot = z.infer<typeof shardHealthSnapshotSchema>;
 export declare const shardControlOperationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"guild.state.get">;
     guildId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"guild.module.public.read">;
+    guildId: z.ZodString;
+    moduleId: z.ZodString;
+    subjectUserId: z.ZodOptional<z.ZodString>;
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodNumber;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"guild.presence.list">;
     guildIds: z.ZodArray<z.ZodString>;
@@ -478,6 +485,13 @@ export declare const shardControlRequestSchema: z.ZodObject<{
     operation: z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"guild.state.get">;
         guildId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"guild.module.public.read">;
+        guildId: z.ZodString;
+        moduleId: z.ZodString;
+        subjectUserId: z.ZodOptional<z.ZodString>;
+        cursor: z.ZodOptional<z.ZodString>;
+        limit: z.ZodNumber;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"guild.presence.list">;
         guildIds: z.ZodArray<z.ZodString>;
@@ -1292,6 +1306,13 @@ export declare const supervisorMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObje
     operation: z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"guild.state.get">;
         guildId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"guild.module.public.read">;
+        guildId: z.ZodString;
+        moduleId: z.ZodString;
+        subjectUserId: z.ZodOptional<z.ZodString>;
+        cursor: z.ZodOptional<z.ZodString>;
+        limit: z.ZodNumber;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"guild.presence.list">;
         guildIds: z.ZodArray<z.ZodString>;

package/dist/shard-contracts.js

@@ -222,6 +222,16 @@ export const shardHealthSnapshotSchema = z
 });
 export const shardControlOperationSchema = z.discriminatedUnion("kind", [
     z.object({ kind: z.literal("guild.state.get"), guildId: snowflake }).strict(),
+    z
+        .object({
+        kind: z.literal("guild.module.public.read"),
+        guildId: snowflake,
+        moduleId,
+        subjectUserId: snowflake.optional(),
+        cursor: resourceCursor.optional(),
+        limit: z.number().int().min(1).max(10),
+    })
+        .strict(),
     z
         .object({
         kind: z.literal("guild.presence.list"),
@@ -901,6 +911,16 @@ export async function executeShardControlOperation(handler, operation) {
             });
         case "guild.state.get":
             return handler.getGuildState(operation.guildId);
+        case "guild.module.public.read":
+            return handler.readPublicModuleProjection({
+                guildId: operation.guildId,
+                moduleId: operation.moduleId,
+                ...(operation.subjectUserId
+                    ? { subjectUserId: operation.subjectUserId }
+                    : {}),
+                ...(operation.cursor ? { cursor: operation.cursor } : {}),
+                limit: operation.limit,
+            });
         case "guild.module.resource.access":
             return handler.canAccessManagedResource({
                 guildId: operation.guildId,

package/dist/shard-router.d.ts

@@ -16,6 +16,7 @@ export declare class ShardControlRouter implements BotControlHandler {
         notificationGuildId?: string;
     });
     getGuildState(guildId: string): ReturnType<BotControlHandler["getGuildState"]>;
+    readPublicModuleProjection(input: Parameters<BotControlHandler["readPublicModuleProjection"]>[0]): ReturnType<BotControlHandler["readPublicModuleProjection"]>;
     canAccessManagedResource(input: Parameters<BotControlHandler["canAccessManagedResource"]>[0]): ReturnType<BotControlHandler["canAccessManagedResource"]>;
     listGuildPresence(input: Parameters<BotControlHandler["listGuildPresence"]>[0]): ReturnType<BotControlHandler["listGuildPresence"]>;
     setModuleStatus(input: Parameters<BotControlHandler["setModuleStatus"]>[0]): ReturnType<BotControlHandler["setModuleStatus"]>;

package/dist/shard-router.js

@@ -10,6 +10,9 @@ export class ShardControlRouter {
     getGuildState(guildId) {
         return this.#route({ kind: "guild.state.get", guildId });
     }
+    readPublicModuleProjection(input) {
+        return this.#route({ kind: "guild.module.public.read", ...input });
+    }
     canAccessManagedResource(input) {
         return this.#route({
             kind: "guild.module.resource.access",

package/dist/shard-supervisor.js

@@ -1,6 +1,6 @@
 import { safeError, ServiceRegistry } from "@helyx/core";
 import { checkDatabaseConnection, createDatabasePool, AuditRepository, InteractionSessionRepository, RateLimitRepository, runConfiguredModuleMigrations, runCoreMigrations, RuntimeStateRepository, } from "@helyx/database";
-import { createPlatformServices, PostgresPrivacyProviderExecutor, } from "@helyx/platform";
+import { createPlatformServices, gamingStatisticsRecordOwner, achievementContributionRecordOwner, PostgresPrivacyProviderExecutor, } from "@helyx/platform";
 import { HELYX_SERVICE_NAMES } from "@helyx/sdk";
 import { Client, ShardingManager } from "discord.js";
 import { createHash, randomUUID } from "node:crypto";
@@ -169,6 +169,7 @@ export async function startShardSupervisor(environment, processEnvironment, work
                 observedAt: new Date().toISOString(),
             }))),
             getGuildResources: () => Promise.reject(new Error("Guild resources are worker-owned")),
+            getGuildPublicSummary: () => Promise.reject(new Error("Guild resources are worker-owned")),
             sendToChannel: () => Promise.reject(new Error("Guild resources are worker-owned")),
             deleteChannelMessage: () => Promise.reject(new Error("Guild resources are worker-owned")),
             editChannelMessage: () => Promise.reject(new Error("Guild resources are worker-owned")),
@@ -230,11 +231,19 @@ export async function startShardSupervisor(environment, processEnvironment, work
             const services = new Map(createPlatformServices(database, publicModules, platformServiceOptions(environment, publicModules)));
             if (numericWriteBehind)
                 services.set(HELYX_SERVICE_NAMES.numericWriteBehind, numericWriteBehind);
-            privacyService = new BotControlService(database, publicModules, unavailableResources, new ServiceRegistry(services), privacyDatabase
+            privacyService = new BotControlService(database, [
+                ...publicModules,
+                gamingStatisticsRecordOwner,
+                achievementContributionRecordOwner,
+            ], unavailableResources, new ServiceRegistry(services), privacyDatabase
                 ? new PostgresPrivacyProviderExecutor({
                     readPool: database,
                     executorPool: privacyDatabase,
-                    modules: featureModules,
+                    modules: [
+                        ...featureModules,
+                        gamingStatisticsRecordOwner,
+                        achievementContributionRecordOwner,
+                    ],
                 })
                 : undefined);
             cloudConnector?.setControlHandler(new ShardControlRouter({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@helyx/bot",
-  "version": "0.4.24",
+  "version": "0.4.26",
   "description": "Production Discord runtime for the modular Helyx platform.",
   "keywords": [
     "helyx",
@@ -51,7 +51,7 @@
     "@helyx/config": ">=0.5.0 <0.6.0",
     "@helyx/control-protocol": ">=0.3.0 <0.4.0",
     "@helyx/core": ">=0.1.0 <0.2.0",
-    "@helyx/database": ">=0.7.0 <0.8.0",
+    "@helyx/database": ">=0.7.10 <0.8.0",
     "@helyx/framework": ">=0.1.0 <0.2.0",
     "@helyx/module-manifest": ">=0.6.0 <0.7.0",
     "@helyx/platform": ">=0.4.0 <0.5.0",