@helyx/bot 1.5.4 → 1.7.0

package/dist/server-overview-control.js

@@ -0,0 +1,362 @@
+import { canAccessGuildDashboard, canUseCommand } from "@helyx/core";
+import { OVERVIEW_SOURCES, overviewResponseSchema, } from "@helyx/control-protocol";
+import { HELYX_SERVICE_NAMES, } from "@helyx/sdk";
+import { BotControlForbiddenError, BotControlTransportError, BotControlValidationError, } from "./control-errors.js";
+import { declaredManagedResourcePermission, managedResourcePermissionId, } from "./control-permissions.js";
+import { requireDashboardFeatures } from "./dashboard-feature-control.js";
+import { overviewProfileContext } from "./server-overview-profile.js";
+const countCollections = {
+    "helyx.automod:automod-rules": { collection: "rules" },
+    "helyx.creator-connections:invites": {
+        collection: "role_invites",
+        status: "state",
+    },
+    "helyx.reactionroles:panels": { collection: "panels" },
+    "helyx.verification:verification-panels": { collection: "panels" },
+    "helyx.account-gate:gate-panel": { collection: "gate_panels" },
+    "helyx.giveaways:giveaways": { collection: "giveaways" },
+    "helyx.community-goals:submissions": {
+        collection: "submissions",
+        status: "state",
+    },
+    "helyx.nexus-economy:redemptions": { collection: "redemptions" },
+    "helyx.nexus-economy:exchange-post": {
+        collection: "settings",
+        status: "post_status",
+    },
+    "helyx.moderation:moderation-cases": { collection: "cases", status: "state" },
+};
+export function createServerOverviewControl(deps) {
+    const counts = new Map();
+    const invalidation = new Map();
+    const authorize = async (input) => {
+        const [actor, policy] = await Promise.all([
+            deps.resolveActor(input.guildId, input.actorUserId),
+            deps.readGuildPolicy(input.guildId),
+        ]);
+        if (!canAccessGuildDashboard(actor, policy))
+            throw new BotControlForbiddenError();
+        if (!deps.directory)
+            throw new BotControlTransportError(503, "Overview is unavailable on this runtime.");
+        return { actor, policy, directory: deps.directory };
+    };
+    const sourceAllowed = async (guildId, actor, policy, moduleId, resourceId, operation) => {
+        const module = deps.modules.get(moduleId);
+        const definition = module?.manifest.dashboard?.resources?.find((resource) => resource.id === resourceId);
+        if (!module ||
+            !definition ||
+            (definition.operations && !definition.operations.includes(operation)))
+            return false;
+        await deps.requireAccessible(guildId, moduleId);
+        await requireDashboardFeatures(deps.services, guildId, moduleId, [
+            definition.featureId,
+        ]);
+        const permissionId = managedResourcePermissionId(module, resourceId, operation, undefined, declaredManagedResourcePermission(module, resourceId, operation));
+        return canUseCommand(actor, await deps.permissions.getEffectivePolicy(guildId, moduleId, permissionId), policy);
+    };
+    const records = () => deps.services.get(HELYX_SERVICE_NAMES.records);
+    const countSource = async (guildId, source) => {
+        const cacheKey = `${guildId}:${source.moduleId}:${source.resourceId}:${invalidation.get(guildId) ?? 0}`;
+        const cached = counts.get(cacheKey);
+        if (cached && cached.expires > Date.now())
+            return cached.value;
+        const value = (async () => {
+            if (source.moduleId === "helyx.verification" &&
+                source.resourceId === "attempts") {
+                const service = deps.services.get(HELYX_SERVICE_NAMES.verification);
+                if (!service.countPendingAttempts)
+                    throw new Error("Verification summary unavailable");
+                const { installation } = await service.getInstallationContext({
+                    guildId,
+                });
+                return service.countPendingAttempts({
+                    installationId: installation.installationId,
+                    guildId,
+                });
+            }
+            const config = countCollections[`${source.moduleId}:${source.resourceId}`];
+            if (!config ||
+                !deps.modules.get(source.moduleId)?.records?.[config.collection])
+                throw new Error("No safe summary adapter");
+            const totals = await Promise.all(source.statuses.map((status) => records().count({
+                moduleId: source.moduleId,
+                collection: source.moduleId === "helyx.community-goals" &&
+                    status === "removal_pending"
+                    ? "removal_requests"
+                    : config.collection,
+                where: {
+                    guild_id: guildId,
+                    [config.status ?? "status"]: source.moduleId === "helyx.community-goals" &&
+                        status === "removal_pending"
+                        ? "pending"
+                        : status,
+                },
+            })));
+            if (totals.some((total) => !Number.isSafeInteger(total) || total < 0))
+                throw new Error("Invalid source count");
+            return totals.reduce((sum, total) => sum + total, 0);
+        })();
+        counts.set(cacheKey, { expires: Date.now() + 60_000, value });
+        void value.catch(() => {
+            if (counts.get(cacheKey)?.value === value)
+                counts.delete(cacheKey);
+        });
+        while (counts.size > 1000)
+            counts.delete(counts.keys().next().value);
+        return value;
+    };
+    const mayManageInvites = (actor) => actor.isServerOwner ||
+        actor.isAdministrator ||
+        actor.permissions.includes("MANAGE_GUILD");
+    const ownership = async (guildId, invites, actor, policy) => {
+        const service = deps.services.has(HELYX_SERVICE_NAMES.creatorInvites)
+            ? deps.services.get(HELYX_SERVICE_NAMES.creatorInvites)
+            : undefined;
+        let owned = [];
+        let ownershipAvailable = !deps.modules.has("helyx.creator-connections");
+        if (service?.identifyInvites) {
+            try {
+                owned = await service.identifyInvites({
+                    guildId,
+                    codes: invites.map((invite) => invite.code),
+                });
+                ownershipAvailable = true;
+            }
+            catch {
+                ownershipAvailable = false;
+            }
+        }
+        return Promise.all(invites.map(async (invite) => {
+            const match = owned.find((item) => item.code === invite.code);
+            const owner = match
+                ? {
+                    kind: "module",
+                    moduleId: "helyx.creator-connections",
+                    label: "Creator Connections",
+                }
+                : ownershipAvailable && invite.inviterIsBot === false
+                    ? { kind: "standalone" }
+                    : { kind: "unknown" };
+            if (match && owner.kind === "module") {
+                // Resolve only this page's known owned references; never expose private ownership rows.
+                for (const [collection, resourceId, field] of [
+                    ["role_invites", "invites", "invite_id"],
+                    ["overview_links", "overviews", "overview_id"],
+                ]) {
+                    if (!deps.modules.get(owner.moduleId)?.records?.[collection])
+                        continue;
+                    try {
+                        if (!(await sourceAllowed(guildId, actor, policy, owner.moduleId, resourceId, "read")))
+                            continue;
+                        const row = await records().findOne({
+                            moduleId: owner.moduleId,
+                            collection,
+                            select: [field],
+                            where: { guild_id: guildId, owned_reference: match.reference },
+                        });
+                        if (typeof row?.[field] === "string") {
+                            owner.resourceId = resourceId;
+                            owner.recordId = row[field];
+                            break;
+                        }
+                    }
+                    catch {
+                        /* Provenance remains protected even if its source record is unavailable. */
+                    }
+                }
+            }
+            return {
+                ...invite,
+                owner,
+                canRevoke: mayManageInvites(actor) && owner.kind === "standalone",
+            };
+        }));
+    };
+    const control = {
+        invalidate(guildId) {
+            invalidation.set(guildId, (invalidation.get(guildId) ?? 0) + 1);
+            for (const key of counts.keys())
+                if (key.startsWith(`${guildId}:`))
+                    counts.delete(key);
+            while (invalidation.size > 1000)
+                invalidation.delete(invalidation.keys().next().value);
+        },
+        async readServerOverview(input) {
+            const { actor, policy, directory } = await authorize(input);
+            const observedAt = new Date().toISOString();
+            const common = { guildId: input.guildId, observedAt };
+            if (input.operation === "members")
+                return overviewResponseSchema.parse({
+                    kind: "members",
+                    ...common,
+                    ...(await directory.members(input)),
+                });
+            const enabled = new Set((await deps.listModules(input.guildId))
+                .filter((module) => module.enabled)
+                .map((module) => module.moduleId));
+            if (input.operation === "summary") {
+                if (input.refresh)
+                    control.invalidate(input.guildId);
+                const sources = [];
+                // One actor lookup per summary; counts are scoped database aggregates, never resource-list/Discord fan-out.
+                for (const source of OVERVIEW_SOURCES) {
+                    if (!enabled.has(source.moduleId))
+                        continue;
+                    try {
+                        if (!(await sourceAllowed(input.guildId, actor, policy, source.moduleId, source.resourceId, "list")))
+                            continue;
+                        let count = null;
+                        let state = "available";
+                        if (source.section === "attention" ||
+                            source.section === "repairs") {
+                            try {
+                                count = await countSource(input.guildId, source);
+                            }
+                            catch {
+                                state = "partial";
+                            }
+                        }
+                        sources.push({
+                            ...source,
+                            statuses: [...source.statuses],
+                            count,
+                            state,
+                        });
+                    }
+                    catch (error) {
+                        if (error instanceof BotControlForbiddenError ||
+                            error instanceof BotControlValidationError)
+                            continue;
+                        sources.push({
+                            ...source,
+                            statuses: [...source.statuses],
+                            count: null,
+                            state: "unavailable",
+                        });
+                    }
+                }
+                return overviewResponseSchema.parse({
+                    kind: "summary",
+                    ...common,
+                    ...(await directory.summary(input.guildId)),
+                    sources,
+                });
+            }
+            if (input.operation === "member") {
+                const memberId = input.memberId;
+                const member = await directory.member(input.guildId, memberId);
+                const profileRecords = [];
+                for (const moduleId of ["helyx.levels", "helyx.achievements"]) {
+                    if (!enabled.has(moduleId))
+                        continue;
+                    try {
+                        if (!(await sourceAllowed(input.guildId, actor, policy, moduleId, "members", "read")))
+                            continue;
+                        const resource = deps.modules
+                            .get(moduleId)
+                            .managedResources?.find((resource) => resource.id === "members");
+                        if (!resource)
+                            continue;
+                        const detail = await resource.read(overviewProfileContext(deps.context(input.guildId, actor), memberId, member.member), memberId);
+                        profileRecords.push({
+                            moduleId,
+                            resourceId: "members",
+                            state: detail ? "available" : "no_data",
+                            record: detail ? { ...detail } : null,
+                        });
+                    }
+                    catch {
+                        profileRecords.push({
+                            moduleId,
+                            resourceId: "members",
+                            state: "unavailable",
+                            record: null,
+                        });
+                    }
+                }
+                if (enabled.has("helyx.moderation")) {
+                    try {
+                        if (await sourceAllowed(input.guildId, actor, policy, "helyx.moderation", "moderation-cases", "list")) {
+                            const resource = deps.modules
+                                .get("helyx.moderation")
+                                ?.managedResources?.find((resource) => resource.id === "moderation-cases");
+                            const page = await resource?.list(deps.context(input.guildId, actor), { limit: 15, search: memberId });
+                            const items = page?.items.filter((item) => item.attributes?.subjectUserId === memberId) ?? [];
+                            profileRecords.push({
+                                moduleId: "helyx.moderation",
+                                resourceId: "moderation-cases",
+                                state: !page
+                                    ? "unavailable"
+                                    : items.length || page.nextCursor
+                                        ? "available"
+                                        : "no_data",
+                                record: page
+                                    ? { items, partial: Boolean(page.nextCursor) }
+                                    : null,
+                            });
+                        }
+                    }
+                    catch {
+                        profileRecords.push({
+                            moduleId: "helyx.moderation",
+                            resourceId: "moderation-cases",
+                            state: "unavailable",
+                            record: null,
+                        });
+                    }
+                }
+                return overviewResponseSchema.parse({
+                    kind: "member",
+                    ...common,
+                    ...member,
+                    records: profileRecords,
+                });
+            }
+            if (!mayManageInvites(actor))
+                throw new BotControlForbiddenError("Manage Server is required to inspect server invite links.");
+            const all = await directory.invites(input.guildId, input.refresh === true);
+            all.sort((a, b) => (a.code < b.code ? -1 : a.code > b.code ? 1 : 0));
+            const cursor = input.cursor;
+            const filtered = all.filter((invite) => (!cursor || invite.code > cursor) &&
+                (!input.search ||
+                    invite.code.toLowerCase().includes(input.search.toLowerCase())));
+            const page = filtered.slice(0, input.limit ?? 15);
+            return overviewResponseSchema.parse({
+                kind: "invites",
+                ...common,
+                items: await ownership(input.guildId, page, actor, policy),
+                total: input.search
+                    ? all.filter((invite) => invite.code.toLowerCase().includes(input.search.toLowerCase())).length
+                    : all.length,
+                nextCursor: filtered.length > page.length ? page.at(-1).code : null,
+            });
+        },
+        async revokeServerOverviewInvite(input) {
+            const { actor, policy, directory } = await authorize(input);
+            if (!mayManageInvites(actor) || input.confirmed !== true)
+                throw new BotControlForbiddenError();
+            const invite = (await directory.invites(input.guildId, true)).find((invite) => invite.code === input.code);
+            if (!invite)
+                throw new BotControlValidationError("This invite is no longer active.");
+            const [current] = await ownership(input.guildId, [invite], actor, policy);
+            if (!current?.canRevoke)
+                throw new BotControlForbiddenError("This invite is module-owned or its ownership cannot be confirmed. Manage it in its source module.");
+            const correlationId = crypto.randomUUID();
+            await deps.auditInviteRevoke?.({
+                ...input,
+                outcome: "requested",
+                correlationId,
+            });
+            await directory.revoke(input.guildId, input.code);
+            control.invalidate(input.guildId);
+            await deps.auditInviteRevoke?.({
+                ...input,
+                outcome: "revoked",
+                correlationId,
+            });
+            return { revoked: true };
+        },
+    };
+    return control;
+}
+//# sourceMappingURL=server-overview-control.js.map

package/dist/server-overview-discord.d.ts

@@ -0,0 +1,33 @@
+import { type Client } from "discord.js";
+import type { OverviewMember, OverviewInvite, OverviewReadInput } from "@helyx/control-protocol";
+type Snapshot = {
+    memberCount: number;
+    cachedMemberCount: number;
+    membersComplete: boolean;
+    roles: Array<{
+        id: string;
+        name: string;
+        colour: string;
+        count: number | null;
+    }>;
+};
+export interface OverviewDiscordDirectory {
+    summary(guildId: string): Promise<Snapshot>;
+    members(input: OverviewReadInput): Promise<{
+        items: OverviewMember[];
+        nextCursor: string | null;
+        total: number | null;
+        complete: boolean;
+        scope: "server" | "cached";
+    }>;
+    member(guildId: string, memberId: string): Promise<{
+        member: OverviewMember | null;
+        banStatus: "banned" | "not_banned" | "unknown";
+    }>;
+    invites(guildId: string, fresh?: boolean): Promise<Array<Omit<OverviewInvite, "owner" | "canRevoke">>>;
+    revoke(guildId: string, code: string): Promise<void>;
+    botUserId(): string | undefined;
+}
+export declare function createOverviewDiscordDirectory(client: Client): OverviewDiscordDirectory;
+export {};
+//# sourceMappingURL=server-overview-discord.d.ts.map

package/dist/server-overview-discord.js

@@ -0,0 +1,212 @@
+import { PermissionFlagsBits } from "discord.js";
+import { BotControlNotFoundError, BotControlValidationError, } from "./control-errors.js";
+function memberProjection(member) {
+    return {
+        id: member.id,
+        username: member.user.username,
+        displayName: member.displayName,
+        nickname: member.nickname,
+        avatarUrl: member.displayAvatarURL(),
+        accountCreatedAt: member.user.createdAt.toISOString(),
+        joinedAt: member.joinedAt?.toISOString() ?? null,
+        bot: member.user.bot,
+        screeningPending: member.pending,
+        boostingSince: member.premiumSince?.toISOString() ?? null,
+        timeoutUntil: member.communicationDisabledUntil?.toISOString() ?? null,
+        roles: [...member.roles.cache.values()]
+            .filter((role) => role.id !== member.guild.id)
+            .sort((a, b) => b.position - a.position)
+            .map((role) => ({ id: role.id, name: role.name, colour: role.hexColor })),
+    };
+}
+export function createOverviewDiscordDirectory(client) {
+    const inviteCache = new Map();
+    const guildFor = (guildId) => {
+        const guild = client.guilds.cache.get(guildId);
+        if (!guild?.available)
+            throw new BotControlNotFoundError("This server is not available to this bot.");
+        return guild;
+    };
+    return {
+        botUserId: () => client.user?.id,
+        summary(guildId) {
+            const guild = guildFor(guildId);
+            const complete = guild.members.cache.size >= guild.memberCount;
+            const roleCounts = new Map();
+            if (complete)
+                for (const member of guild.members.cache.values())
+                    for (const id of member.roles.cache.keys())
+                        roleCounts.set(id, (roleCounts.get(id) ?? 0) + 1);
+            return Promise.resolve({
+                memberCount: guild.memberCount,
+                cachedMemberCount: guild.members.cache.size,
+                membersComplete: complete,
+                roles: [...guild.roles.cache.values()]
+                    .filter((role) => role.id !== guild.id && !role.managed)
+                    .sort((a, b) => b.position - a.position)
+                    .map((role) => ({
+                    id: role.id,
+                    name: role.name,
+                    colour: role.hexColor,
+                    count: complete ? (roleCounts.get(role.id) ?? 0) : null,
+                })),
+            });
+        },
+        async members(input) {
+            const guild = guildFor(input.guildId);
+            const limit = input.limit ?? 15;
+            const search = input.search?.toLowerCase() ?? "";
+            const complete = guild.members.cache.size >= guild.memberCount;
+            if (!complete && !input.roleId) {
+                // Discord supports a bounded member page or prefix search; never request an entire guild chunk.
+                if (search) {
+                    if (input.cursor)
+                        throw new BotControlValidationError("Search does not accept a page cursor.");
+                    const found = /^\d{17,20}$/u.test(search)
+                        ? [
+                            await guild.members
+                                .fetch({ user: search, force: false })
+                                .catch((error) => {
+                                if (error &&
+                                    typeof error === "object" &&
+                                    "code" in error &&
+                                    error.code === 10007)
+                                    return null;
+                                throw error;
+                            }),
+                        ].filter((value) => value !== null)
+                        : [
+                            ...(await guild.members.search({ query: input.search, limit })).values(),
+                        ];
+                    return {
+                        items: found.map(memberProjection),
+                        nextCursor: null,
+                        total: null,
+                        complete: false,
+                        scope: "server",
+                    };
+                }
+                if (input.cursor && !/^\d{17,20}$/u.test(input.cursor))
+                    throw new BotControlValidationError("Invalid member cursor.");
+                const rows = [
+                    ...(await guild.members.list({
+                        limit,
+                        ...(input.cursor ? { after: input.cursor } : {}),
+                    })).values(),
+                ];
+                return {
+                    items: rows.map(memberProjection),
+                    nextCursor: rows.length === limit ? rows.at(-1).id : null,
+                    total: guild.memberCount,
+                    complete: true,
+                    scope: "server",
+                };
+            }
+            const scopeKey = JSON.stringify([
+                input.guildId,
+                search,
+                input.roleId ?? "",
+                limit,
+            ]);
+            let offset = 0;
+            if (input.cursor) {
+                try {
+                    const parsed = JSON.parse(Buffer.from(input.cursor, "base64url").toString());
+                    if (parsed.scope !== scopeKey ||
+                        !Number.isSafeInteger(parsed.offset) ||
+                        parsed.offset < 0)
+                        throw new Error();
+                    offset = parsed.offset;
+                }
+                catch {
+                    throw new BotControlValidationError("Invalid member cursor.");
+                }
+            }
+            const rows = [...guild.members.cache.values()]
+                .filter((member) => (!input.roleId || member.roles.cache.has(input.roleId)) &&
+                (!search ||
+                    `${member.id} ${member.user.username} ${member.displayName}`
+                        .toLowerCase()
+                        .includes(search)))
+                .sort((a, b) => a.id.localeCompare(b.id));
+            return {
+                items: rows.slice(offset, offset + limit).map(memberProjection),
+                nextCursor: offset + limit < rows.length
+                    ? Buffer.from(JSON.stringify({ scope: scopeKey, offset: offset + limit })).toString("base64url")
+                    : null,
+                total: rows.length,
+                complete,
+                scope: complete ? "server" : "cached",
+            };
+        },
+        async member(guildId, memberId) {
+            const guild = guildFor(guildId);
+            let member = guild.members.cache.get(memberId) ?? null;
+            let absent = false;
+            if (!member) {
+                try {
+                    member = await guild.members.fetch({ user: memberId, force: false });
+                }
+                catch (error) {
+                    if (error &&
+                        typeof error === "object" &&
+                        "code" in error &&
+                        error.code === 10007)
+                        absent = true;
+                    else
+                        throw error;
+                }
+            }
+            // A missing cached ban is unknown. One explicit profile request can check this exact user.
+            let banStatus = guild.bans.cache.has(memberId)
+                ? "banned"
+                : "unknown";
+            if (guild.members.me?.permissions.has(PermissionFlagsBits.BanMembers)) {
+                try {
+                    await guild.bans.fetch({ user: memberId, force: true });
+                    banStatus = "banned";
+                }
+                catch (error) {
+                    if (error &&
+                        typeof error === "object" &&
+                        "code" in error &&
+                        error.code === 10026)
+                        banStatus = "not_banned";
+                }
+            }
+            if (!member && !absent)
+                throw new BotControlNotFoundError("Member information is unavailable.");
+            return { member: member ? memberProjection(member) : null, banStatus };
+        },
+        async invites(guildId, fresh = false) {
+            const cached = inviteCache.get(guildId);
+            if (!fresh && cached && cached.expires > Date.now())
+                return cached.request;
+            const request = guildFor(guildId)
+                .invites.fetch()
+                .then((invites) => [...invites.values()].map((invite) => ({
+                code: invite.code,
+                channelId: invite.channelId,
+                channelName: invite.channel?.name ?? null,
+                inviterId: invite.inviterId,
+                inviterIsBot: invite.inviter?.bot ?? null,
+                uses: invite.uses ?? 0,
+                maxUses: invite.maxUses ?? 0,
+                expiresAt: invite.expiresAt?.toISOString() ?? null,
+            })));
+            inviteCache.set(guildId, { expires: Date.now() + 60_000, request });
+            void request.catch(() => {
+                if (inviteCache.get(guildId)?.request === request)
+                    inviteCache.delete(guildId);
+            });
+            while (inviteCache.size > 200)
+                inviteCache.delete(inviteCache.keys().next().value);
+            return request;
+        },
+        async revoke(guildId, code) {
+            await guildFor(guildId).invites.delete(code, "Standalone invite revoked through the Helyx dashboard");
+            inviteCache.delete(guildId);
+        },
+    };
+}
+//# sourceMappingURL=server-overview-discord.js.map

package/dist/server-overview-profile.d.ts

@@ -0,0 +1,8 @@
+import { type ManagedResourceContext, type PermissionActor, type ServiceAccess } from "@helyx/sdk";
+import type { OverviewMember } from "@helyx/control-protocol";
+/** Canonical profile resources reuse the member snapshot already read for this request.
+ * They cannot silently add Discord lookups as more fields are added to a module. */
+export declare function overviewProfileContext(context: ManagedResourceContext, memberId: string, member: OverviewMember | null): ManagedResourceContext;
+/** Overview readers have no Discord write capability; actions stay in module routes. */
+export declare function overviewReadContext(guildId: string, actor: PermissionActor, services: ServiceAccess): ManagedResourceContext;
+//# sourceMappingURL=server-overview-profile.d.ts.map

package/dist/server-overview-profile.js

@@ -0,0 +1,62 @@
+import { HELYX_SERVICE_NAMES, } from "@helyx/sdk";
+/** Canonical profile resources reuse the member snapshot already read for this request.
+ * They cannot silently add Discord lookups as more fields are added to a module. */
+export function overviewProfileContext(context, memberId, member) {
+    const scoped = (query) => {
+        if (query.guildId !== context.guildId ||
+            query.userIds.some((id) => id !== memberId))
+            throw new Error("Overview profile lookup is outside its member scope.");
+    };
+    const replacements = {
+        resolveMembers(query) {
+            scoped(query);
+            return Promise.resolve(query.userIds.map((userId) => ({
+                userId,
+                displayName: member?.displayName ?? null,
+                ...(member ? { isBot: member.bot } : {}),
+                ...(member?.avatarUrl ? { avatarUrl: member.avatarUrl } : {}),
+            })));
+        },
+        resolveMemberSnapshots(query) {
+            scoped(query);
+            return Promise.resolve(query.userIds.map((userId) => ({
+                userId,
+                exists: member !== null,
+                isBot: member?.bot ?? false,
+                roleIds: member?.roles.map((role) => role.id) ?? [],
+                joinedAt: member?.joinedAt ? new Date(member.joinedAt) : null,
+            })));
+        },
+    };
+    const services = {
+        has: (name) => context.services.has(name),
+        get(name) {
+            if (name !== HELYX_SERVICE_NAMES.discordResources)
+                return context.services.get(name);
+            return new Proxy(replacements, {
+                get(target, property) {
+                    if (Object.hasOwn(target, property))
+                        return Reflect.get(target, property);
+                    throw new Error("Additional Discord lookups are unavailable in an Overview profile.");
+                },
+            });
+        },
+    };
+    return { ...context, services };
+}
+/** Overview readers have no Discord write capability; actions stay in module routes. */
+export function overviewReadContext(guildId, actor, services) {
+    const denied = () => Promise.reject(new Error("Overview reads cannot change Discord resources."));
+    return {
+        guildId,
+        actor,
+        services,
+        authorizationScope: "full",
+        correlationId: crypto.randomUUID(),
+        sendToChannel: denied,
+        deleteChannelMessage: denied,
+        editChannelMessage: denied,
+        addChannelMessageReaction: denied,
+    };
+}
+//# sourceMappingURL=server-overview-profile.js.map