@helyx/bot 1.5.1 → 1.5.3

package/dist/creator-invite-key.d.ts

@@ -0,0 +1,6 @@
+/** Internal launch material, never the application-wide data encryption key. */
+export declare const creatorInviteWorkerKeyName = "HELYX_INTERNAL_CREATOR_INVITE_KEY";
+export declare function decodeCreatorInviteKey(encodedKey: string): Buffer;
+/** Keep the existing v1 derivation: old ciphertext and fingerprints stay valid. */
+export declare function deriveCreatorInviteKey(encodedDataEncryptionKey: string): Buffer;
+//# sourceMappingURL=creator-invite-key.d.ts.map

package/dist/creator-invite-key.js

@@ -0,0 +1,16 @@
+import { createHmac } from "node:crypto";
+/** Internal launch material, never the application-wide data encryption key. */
+export const creatorInviteWorkerKeyName = "HELYX_INTERNAL_CREATOR_INVITE_KEY";
+export function decodeCreatorInviteKey(encodedKey) {
+    const key = Buffer.from(encodedKey, "base64");
+    if (key.length !== 32)
+        throw new Error("Creator invites require a 32-byte encryption key");
+    return key;
+}
+/** Keep the existing v1 derivation: old ciphertext and fingerprints stay valid. */
+export function deriveCreatorInviteKey(encodedDataEncryptionKey) {
+    return createHmac("sha256", decodeCreatorInviteKey(encodedDataEncryptionKey))
+        .update("helyx.creator-owned-invites.v1")
+        .digest();
+}
+//# sourceMappingURL=creator-invite-key.js.map

package/dist/creator-invite-service.d.ts

@@ -8,7 +8,9 @@ export declare class DiscordCreatorInviteService implements CreatorInviteService
     private readonly repository;
     private readonly services;
     private readonly module;
-    constructor(client: Client, repository: CreatorInviteRepository, services: ServiceAccess, module: ModuleDefinition | undefined, encodedEncryptionKey: string);
+    constructor(client: Client, repository: CreatorInviteRepository, services: ServiceAccess, module: ModuleDefinition | undefined, encryption: string | {
+        inviteEncryptionKey: string;
+    });
     selectableRoles(input: Parameters<CreatorInviteService["selectableRoles"]>[0]): ReturnType<CreatorInviteService["selectableRoles"]>;
     create(input: Parameters<CreatorInviteService["create"]>[0]): Promise<CreatorOwnedInvite>;
     inspect(input: Parameters<CreatorInviteService["inspect"]>[0]): Promise<CreatorOwnedInvite>;

package/dist/creator-invite-service.js

@@ -5,6 +5,7 @@ import { createCipheriv, createDecipheriv, createHmac, createHash, randomBytes,
 import { normalizeDiscordPermission } from "./interactions.js";
 import { canAccessModule } from "./premium-access.js";
 import { discordRestOptions } from "./discord-rest.js";
+import { decodeCreatorInviteKey, deriveCreatorInviteKey, } from "./creator-invite-key.js";
 const MODULE_ID = "helyx.creator-connections";
 const snowflake = /^\d{17,20}$/u;
 const uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu;
@@ -18,17 +19,17 @@ export class DiscordCreatorInviteService {
     #key;
     #rest = null;
     #cleanupCursor;
-    constructor(client, repository, services, module, encodedEncryptionKey) {
+    constructor(client, repository, services, module, encryption) {
         this.client = client;
         this.repository = repository;
         this.services = services;
         this.module = module;
-        const rootKey = Buffer.from(encodedEncryptionKey, "base64");
-        if (rootKey.length !== 32)
-            throw new Error("Creator invites require a 32-byte data encryption key");
-        this.#key = createHmac("sha256", rootKey)
-            .update("helyx.creator-owned-invites.v1")
-            .digest();
+        // Unsharded runtimes derive locally; workers receive only this scoped key.
+        // Do not derive again in workers: existing v1 records use this exact key.
+        this.#key =
+            typeof encryption === "string"
+                ? deriveCreatorInviteKey(encryption)
+                : decodeCreatorInviteKey(encryption.inviteEncryptionKey);
     }
     async selectableRoles(input) {
         validateId(input.guildId);

package/dist/creator-onboarding-platform.d.ts

@@ -8,6 +8,7 @@ export declare function installCreatorInvitePlatform(input: {
     services: ServiceAccess;
     modules: readonly ModuleDefinition[];
     encryptionKey: string | undefined;
+    inviteEncryptionKey?: string;
     oauthBroker?: {
         baseUrl: string;
         secret: string;

package/dist/creator-onboarding-platform.js

@@ -8,9 +8,12 @@ export async function installCreatorInvitePlatform(input) {
     const repository = new CreatorInviteRepository(input.database);
     if (!module && !(await repository.isInstalled()))
         return undefined;
-    if (!input.encryptionKey)
+    const encryption = input.inviteEncryptionKey
+        ? { inviteEncryptionKey: input.inviteEncryptionKey }
+        : input.encryptionKey;
+    if (!encryption)
         throw new Error("Hosted Creator Connections invites require HELYX_DATA_ENCRYPTION_KEY");
-    const service = new DiscordCreatorInviteService(input.client, repository, input.services, module, input.encryptionKey);
+    const service = new DiscordCreatorInviteService(input.client, repository, input.services, module, encryption);
     input.register(HELYX_SERVICE_NAMES.creatorInvites, service);
     if (input.oauthBroker) {
         const broker = input.oauthBroker;

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