@helyx/bot 1.5.2 → 1.5.3

package/dist/dashboard-feature-control.d.ts

@@ -16,10 +16,11 @@ export declare function isBoundedManagedResourceValue(value: unknown, depth?: nu
     keys: number;
 }): value is ManagedResourceValue;
 export declare function hasBoundedManagedResourceBytes(value: unknown): boolean;
-export declare function normalizeManagedResourceDetail(value: Omit<ManagedResourceDetail, "description" | "attributes" | "availableActionIds"> & {
+export declare function normalizeManagedResourceDetail(value: Omit<ManagedResourceDetail, "description" | "attributes" | "availableActionIds" | "notices"> & {
     description?: string | undefined;
     attributes?: Readonly<Record<string, ManagedResourceValue>> | undefined;
     availableActionIds?: readonly string[] | undefined;
+    notices?: ManagedResourceDetail["notices"] | undefined;
 }, attributeKeys: readonly string[]): ManagedResourceDetail;
 export declare function normalizeManagedResourcePage(value: {
     items: readonly (Omit<ManagedResourcePage["items"][number], "description" | "attributes"> & {

package/dist/dashboard-feature-control.js

@@ -154,6 +154,7 @@ export function normalizeManagedResourceDetail(value, attributeKeys) {
         ...(value.availableActionIds === undefined
             ? {}
             : { availableActionIds: value.availableActionIds }),
+        ...(value.notices === undefined ? {} : { notices: value.notices }),
     };
 }
 export function normalizeManagedResourcePage(value, attributeKeys) {

package/dist/dashboard-logging.d.ts

@@ -0,0 +1,20 @@
+import { type ModuleDefinition } from "@helyx/sdk";
+type Event = NonNullable<ModuleDefinition["logging"]>["events"][number];
+interface LoggingPolicy {
+    eventId: string;
+    enabled: boolean;
+    version: number;
+}
+export declare function dashboardLogEvents(module: ModuleDefinition, modules: readonly ModuleDefinition[]): Event[];
+/** Visible aliases and the hidden owner all read the same canonical stored row. */
+export declare function dashboardLoggingPolicies(modules: readonly {
+    id: string;
+    logEvents: readonly Event[];
+}[], stored: readonly {
+    sourceModuleId: string;
+    eventId: string;
+    enabled: boolean;
+    version: bigint;
+}[]): Record<string, LoggingPolicy[]>;
+export {};
+//# sourceMappingURL=dashboard-logging.d.ts.map

package/dist/dashboard-logging.js

@@ -0,0 +1,39 @@
+import { nexusCommandLoggingControlOwner, } from "@helyx/sdk";
+import { safeVersion } from "./control-permissions.js";
+export function dashboardLogEvents(module, modules) {
+    const own = module.logging?.events ?? [];
+    const shared = modules
+        .find(({ manifest }) => manifest.id === "helyx.nexus-core")
+        ?.logging?.events.filter(({ id }) => nexusCommandLoggingControlOwner(module.manifest.id, id) !==
+        module.manifest.id) ?? [];
+    return [
+        ...new Map([...own, ...shared].map((event) => [event.id, { ...event }])).values(),
+    ];
+}
+/** Visible aliases and the hidden owner all read the same canonical stored row. */
+export function dashboardLoggingPolicies(modules, stored) {
+    const source = new Map(stored.map((policy) => [
+        `${policy.sourceModuleId}:${policy.eventId}`,
+        policy,
+    ]));
+    const result = {};
+    for (const module of modules) {
+        result[module.id] = module.logEvents.map((event) => {
+            const owner = nexusCommandLoggingControlOwner(module.id, event.id);
+            const current = source.get(`${owner}:${event.id}`);
+            const policy = {
+                eventId: event.id,
+                enabled: current?.enabled ?? event.defaultEnabled,
+                version: current ? safeVersion(current.version) : 0,
+            };
+            if (owner !== module.id) {
+                const canonical = (result[owner] ??= []);
+                if (!canonical.some((item) => item.eventId === event.id))
+                    canonical.push({ ...policy });
+            }
+            return policy;
+        });
+    }
+    return result;
+}
+//# sourceMappingURL=dashboard-logging.js.map

package/dist/dashboard-module-projection.d.ts

@@ -43,6 +43,6 @@ export interface DashboardModuleDefinition {
     resources: readonly DashboardResourceDefinition[];
     workspace?: NonNullable<ModuleDefinition["manifest"]["dashboard"]>["workspace"];
 }
-export declare function mapDashboardModule(module: ModuleDefinition): DashboardModuleDefinition;
+export declare function mapDashboardModule(module: ModuleDefinition, modules?: readonly ModuleDefinition[]): DashboardModuleDefinition;
 export {};
 //# sourceMappingURL=dashboard-module-projection.d.ts.map

package/dist/dashboard-module-projection.js

@@ -1,7 +1,10 @@
 import { getModuleTier } from "@helyx/module-manifest";
 import { dashboardCategoryLabel } from "./dashboard-category.js";
+import { dashboardLogEvents } from "./dashboard-logging.js";
 import { dashboardCommands, } from "./dashboard-commands.js";
-export function mapDashboardModule(module) {
+export function mapDashboardModule(module, modules = []) {
+    if (module.manifest.releaseStatus === "alpha")
+        throw new Error("Alpha modules have no runtime dashboard projection");
     const dashboard = module.manifest.dashboard;
     return {
         id: module.manifest.id,
@@ -31,7 +34,7 @@ export function mapDashboardModule(module) {
             ? module.manifest.permissionOperations.map((operation) => structuredClone(operation))
             : [],
         commands: dashboardCommands(module),
-        logEvents: (module.logging?.events ?? []).map((event) => ({ ...event })),
+        logEvents: dashboardLogEvents(module, modules),
         actions: (dashboard.actions ?? []).map((action) => ({ ...action })),
         achievementTriggers: (module.manifest.contributions?.achievementTriggers ?? []).map((trigger) => structuredClone(trigger)),
         resources: (dashboard.resources ?? []).map((resource) => structuredClone(resource)),

package/dist/dashboard-preview-import-routes.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { BotControlNotFoundError } from "./control-errors.js";
 import { hasBoundedManagedResourceBytes, isBoundedManagedResourceValue, } from "./dashboard-feature-control.js";
 const snowflake = z.string().regex(/^\d{17,20}$/u);
 const moduleId = z.string().regex(/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)+$/u);
@@ -56,6 +57,13 @@ export function registerDashboardResourceMutationRoutes(server, service) {
     const identifiedResourceParams = resourceParams.extend({
         resourceId: z.string().trim().min(1).max(100),
     });
+    server.post("/v1/guilds/:guildId/modules/:moduleId/resources/:resourceType/create-defaults", async (request) => {
+        const params = resourceParams.parse(request.params);
+        const body = mutationContext.strict().parse(request.body);
+        if (!service.getManagedResourceCreateDefaults)
+            throw new BotControlNotFoundError("Creation defaults are unavailable");
+        return service.getManagedResourceCreateDefaults({ ...params, ...body });
+    });
     server.post("/v1/guilds/:guildId/modules/:moduleId/resources/:resourceType/preview", async (request) => {
         const params = resourceParams.parse(request.params);
         const body = mutationContext

package/dist/database-bootstrap.d.ts

@@ -31,6 +31,6 @@ export interface BotDatabaseBootstrapInput {
  */
 export declare function openBotDatabase(input: BotDatabaseBootstrapInput, resolveAdapter?: typeof resolveDatabaseAdapter): Promise<BotDatabaseHandle>;
 /** Connect with an explicit repository-bearing adapter and the same startup checks. */
-export declare function openBotDatabaseWithAdapter<Repositories>(input: BotDatabaseBootstrapInput, adapter: DatabaseAdapter<Repositories>): Promise<BotDatabaseHandle<Repositories>>;
+export declare function openBotDatabaseWithAdapter<Repositories>(input: BotDatabaseBootstrapInput, adapter: DatabaseAdapter<Repositories>, onCoreReady?: (session: DatabaseSession<Repositories>) => Promise<void>): Promise<BotDatabaseHandle<Repositories>>;
 export {};
 //# sourceMappingURL=database-bootstrap.d.ts.map

package/dist/database-bootstrap.js

@@ -13,9 +13,9 @@ export async function openBotDatabase(input, resolveAdapter = resolveDatabaseAda
     return connectPreparedBotDatabase(input, prepared, adapter);
 }
 /** Connect with an explicit repository-bearing adapter and the same startup checks. */
-export async function openBotDatabaseWithAdapter(input, adapter) {
+export async function openBotDatabaseWithAdapter(input, adapter, onCoreReady) {
     const prepared = await prepareBotDatabase(input);
-    return connectPreparedBotDatabase(input, prepared, adapter);
+    return connectPreparedBotDatabase(input, prepared, adapter, onCoreReady);
 }
 async function prepareBotDatabase(input) {
     const { environment, modulePackages } = input;
@@ -55,7 +55,7 @@ async function prepareBotDatabase(input) {
     }));
     return { engine, migrationSources };
 }
-async function connectPreparedBotDatabase(input, prepared, adapter) {
+async function connectPreparedBotDatabase(input, prepared, adapter, onCoreReady) {
     const { environment } = input;
     const { engine, migrationSources } = prepared;
     if (adapter.engine !== engine) {
@@ -71,6 +71,7 @@ async function connectPreparedBotDatabase(input, prepared, adapter) {
             throw new Error(`Database identity mismatch: requested ${engine}, received ${session.identity.engine}`);
         }
         const core = await session.migrations.runCore();
+        await onCoreReady?.(session);
         const modules = [];
         for (const source of migrationSources) {
             const result = await session.migrations.runModule(source);

package/dist/discord-channel-audit.js

@@ -126,6 +126,7 @@ export async function inspectDiscordChannelAudit(client, input) {
     const selected = new Set([
         assumptions.entryChannelId,
         ...assumptions.allowedChannelIds,
+        ...(assumptions.requiredAfterChannelIds ?? []),
         ...(assumptions.reviewChannelId ? [assumptions.reviewChannelId] : []),
     ]);
     snapshot.invalidSelectedChannels = [];

package/dist/discord-user-identities.d.ts

@@ -0,0 +1,14 @@
+import type { Client } from "discord.js";
+import { type DiscordUserIdentity, type DiscordUserIdentityRequest, type DiscordUserIdentityResponse } from "@helyx/control-protocol/discord-user-identities";
+type FetchIdentity = (guildId: string, userId: string) => Promise<DiscordUserIdentity>;
+/** Bounded singular member reads; never downloads a guild member directory. */
+export declare class DiscordUserIdentityLookup {
+    #private;
+    private readonly fetchIdentity;
+    private readonly now;
+    constructor(fetchIdentity: FetchIdentity, now?: () => number);
+    resolve(input: DiscordUserIdentityRequest): Promise<DiscordUserIdentityResponse>;
+}
+export declare function createDiscordUserIdentityLookup(client: Client): DiscordUserIdentityLookup;
+export {};
+//# sourceMappingURL=discord-user-identities.d.ts.map

package/dist/discord-user-identities.js

@@ -0,0 +1,64 @@
+import { discordUserIdentityRequestSchema, } from "@helyx/control-protocol/discord-user-identities";
+/** Bounded singular member reads; never downloads a guild member directory. */
+export class DiscordUserIdentityLookup {
+    fetchIdentity;
+    now;
+    #cache = new Map();
+    #waiting = [];
+    #active = 0;
+    constructor(fetchIdentity, now = Date.now) {
+        this.fetchIdentity = fetchIdentity;
+        this.now = now;
+    }
+    async resolve(input) {
+        const parsed = discordUserIdentityRequestSchema.parse(input);
+        const users = await Promise.all([...new Set(parsed.userIds)].map((id) => this.#read(parsed.guildId, id)));
+        return { guildId: parsed.guildId, users };
+    }
+    #read(guildId, userId) {
+        const key = `${guildId}:${userId}`;
+        const cached = this.#cache.get(key);
+        if (cached && cached.expiresAt > this.now())
+            return cached.value;
+        const value = this.#load(guildId, userId);
+        this.#cache.delete(key);
+        this.#cache.set(key, { expiresAt: this.now() + 120_000, value });
+        while (this.#cache.size > 4096)
+            this.#cache.delete(this.#cache.keys().next().value);
+        return value;
+    }
+    async #load(guildId, userId) {
+        if (this.#active >= 4)
+            await new Promise((resolve) => this.#waiting.push(resolve));
+        else
+            this.#active++;
+        try {
+            return await this.fetchIdentity(guildId, userId);
+        }
+        catch {
+            // Failed or unavailable names are not invented and must be retried sooner.
+            this.#cache.delete(`${guildId}:${userId}`);
+            return { userId, username: null, displayName: null };
+        }
+        finally {
+            const next = this.#waiting.shift();
+            if (next)
+                next();
+            else
+                this.#active--;
+        }
+    }
+}
+export function createDiscordUserIdentityLookup(client) {
+    return new DiscordUserIdentityLookup(async (guildId, userId) => {
+        const guild = client.guilds.cache.get(guildId) ?? (await client.guilds.fetch(guildId));
+        const member = guild.members.cache.get(userId) ??
+            (await guild.members.fetch({ user: userId, cache: false }));
+        return {
+            userId,
+            username: member.user.username,
+            displayName: member.displayName,
+        };
+    });
+}
+//# sourceMappingURL=discord-user-identities.js.map

package/dist/emergency-deletion-dispatcher.d.ts

@@ -0,0 +1,68 @@
+import type { CachedMessageDeletionAuthority } from "./cached-message-deletion-authority.js";
+import type { GuildMessageProtectionDeletionResult } from "@helyx/sdk";
+export interface EmergencyMessageDeletion {
+    readonly guildId: string;
+    readonly moduleId: string;
+    readonly channelId: string;
+    readonly messageId: string;
+    readonly admissionToken: string;
+}
+type Terminal = "deleted" | "already-absent" | "missing-permission" | "invalid-request" | "failed";
+export type EmergencyDeletionTransportResult = Readonly<{
+    kind: Terminal | "transient";
+}> | Readonly<{
+    kind: "retry";
+    afterMs: number;
+    scope: "route" | "global";
+}>;
+export type EmergencyDeletionResult = Readonly<{
+    kind: Terminal | "revoked" | "expired" | "capacity" | "stopped" | "attempts-exhausted";
+    issued: boolean;
+    attempts: number;
+}>;
+export interface EmergencyDeletionTransport {
+    deleteExact(input: EmergencyMessageDeletion, attempt: EmergencyDeletionAttemptContext, authority?: CachedMessageDeletionAuthority): Promise<EmergencyDeletionTransportResult>;
+}
+/** Private exact attempt witness; no module receives it or supplies its clock. */
+export interface EmergencyDeletionAttemptContext {
+    /** Also fences original queue age, stop and actual attempt settlement. */
+    isCurrent(this: void): boolean;
+}
+interface Options {
+    transport: EmergencyDeletionTransport;
+    isCurrent(this: void, input: EmergencyMessageDeletion): boolean;
+    capacity: number;
+    perChannelCapacity: number;
+    perGuildCapacity: number;
+    concurrency: number;
+    maximumAgeMs: number;
+    maximumAttempts: number;
+    transientBackoffMs: number;
+    maximumBackoffMs: number;
+    maximumRetryAfterMs: number;
+    now?: () => number;
+}
+export interface CapturedEmergencyDeletion {
+    readonly result: Promise<GuildMessageProtectionDeletionResult>;
+    readonly retainedProvidedAuthority: boolean;
+}
+/** Dormant private queue. No SDK service, provider adapter or runtime registration. */
+export declare class EmergencyDeletionDispatcher {
+    #private;
+    constructor(options: Options);
+    enqueue(input: EmergencyMessageDeletion, authority?: CachedMessageDeletionAuthority): Promise<EmergencyDeletionResult>;
+    /** Synchronous Core ownership result; duplicate entries share their SDK promise. */
+    enqueueCaptured(input: EmergencyMessageDeletion, authority?: CachedMessageDeletionAuthority): Readonly<CapturedEmergencyDeletion>;
+    /** Lifecycle callers can synchronously discard waiting work after revocation. */
+    revalidate(): void;
+    stop(): void;
+    stats(): Readonly<{
+        pending: number;
+        inFlight: number;
+        retainedRoutes: number;
+        dropped: number;
+        stopped: boolean;
+    }>;
+}
+export {};
+//# sourceMappingURL=emergency-deletion-dispatcher.d.ts.map