@helyx/bot 1.5.2 → 1.5.4

package/dist/message-protection-settings.d.ts

@@ -0,0 +1,40 @@
+import type { BoundedModuleConfigurationReader } from "@helyx/database-contracts";
+import type { ModuleDefinition } from "@helyx/sdk";
+import type { MessageProtectionColdResult } from "./message-protection-cold-data.js";
+type Observation = Extract<MessageProtectionColdResult, {
+    kind: "observed";
+}>;
+type Reason = "unsupported-module" | "metadata-mismatch" | "missing" | "oversized" | "read-failed" | "invalid-settings" | "stale";
+export type MessageProtectionSettingsResult = Readonly<{
+    kind: "unavailable";
+    reason: Reason;
+}> | Readonly<{
+    kind: "no-settings";
+    revisionFingerprint: string;
+}> | Readonly<{
+    kind: "validated";
+    revisionFingerprint: string;
+    configuration: Readonly<Record<string, unknown>>;
+}>;
+export interface MessageProtectionSettingsLoader {
+    read(data: Observation): Promise<MessageProtectionSettingsResult>;
+    isCurrent(scope: Readonly<{
+        moduleId: string;
+    }>): boolean;
+}
+interface Bounds {
+    maximumBytes: number;
+    maximumDepth: number;
+    maximumNodes: number;
+    maximumCollectionEntries: number;
+    maximumStringLength: number;
+}
+/** Private cold-path observation only; never writes, calls validateUpdate or grants admission. */
+export declare function createMessageProtectionSettingsLoader(options: {
+    modules: readonly ModuleDefinition[];
+    configurations: BoundedModuleConfigurationReader;
+    bounds: Bounds;
+    now?: () => number;
+}): MessageProtectionSettingsLoader;
+export {};
+//# sourceMappingURL=message-protection-settings.d.ts.map

package/dist/message-protection-settings.js

@@ -0,0 +1,275 @@
+import { createHash } from "node:crypto";
+/** Private cold-path observation only; never writes, calls validateUpdate or grants admission. */
+export function createMessageProtectionSettingsLoader(options) {
+    const limits = Object.freeze({ ...options.bounds });
+    for (const [key, maximum] of [
+        ["maximumBytes", 1_048_576],
+        ["maximumDepth", 32],
+        ["maximumNodes", 100_000],
+        ["maximumCollectionEntries", 16_384],
+        ["maximumStringLength", 1_048_576],
+    ]) {
+        if (!Number.isSafeInteger(limits[key]) ||
+            limits[key] < 1 ||
+            limits[key] > maximum)
+            throw new TypeError("Invalid protection settings bounds");
+    }
+    const sourceModules = options.modules;
+    const modules = new Map(sourceModules.map((module, index) => [
+        module.manifest.id,
+        Object.freeze({
+            id: module.manifest.id,
+            source: module,
+            index,
+            manifest: module.manifest,
+            contribution: module.configuration,
+            version: module.manifest.version,
+            schemaVersion: module.configuration?.schemaVersion ?? 1,
+            // eslint-disable-next-line @typescript-eslint/unbound-method -- Identity pin; invoked only with the captured contribution receiver via Reflect.apply.
+            validate: module.configuration?.validate,
+            hasConfiguration: module.configuration !== undefined,
+        }),
+    ]));
+    if (modules.size !== options.modules.length)
+        throw new TypeError("Duplicate protection settings module");
+    const reader = options.configurations;
+    const invalidImplementations = new Set();
+    const implementationCurrent = (module) => {
+        if (invalidImplementations.has(module.id))
+            return false;
+        try {
+            const valid = sourceModules[module.index] === module.source &&
+                module.source.manifest === module.manifest &&
+                module.source.manifest.id === module.id &&
+                module.source.manifest.version === module.version &&
+                module.source.configuration === module.contribution &&
+                (module.source.configuration?.schemaVersion ?? 1) ===
+                    module.schemaVersion &&
+                module.source.configuration?.validate === module.validate;
+            if (valid)
+                return true;
+        }
+        catch {
+            // A failed trusted registry read revokes this implementation witness too.
+        }
+        invalidImplementations.add(module.id);
+        return false;
+    };
+    const clock = options.now ?? (() => performance.now());
+    let lastNow = -Infinity;
+    let failed = false;
+    const current = (expiresAt) => {
+        if (failed)
+            return false;
+        let now;
+        try {
+            now = clock();
+        }
+        catch {
+            failed = true;
+            return false;
+        }
+        if (!Number.isFinite(now) ||
+            now < 0 ||
+            now > Number.MAX_SAFE_INTEGER ||
+            now < lastNow) {
+            failed = true;
+            return false;
+        }
+        lastNow = now;
+        return Number.isFinite(expiresAt) && now < expiresAt;
+    };
+    return Object.freeze({
+        isCurrent(scope) {
+            const module = modules.get(scope.moduleId);
+            return !failed && module !== undefined && implementationCurrent(module);
+        },
+        async read(data) {
+            const module = modules.get(data.scope.moduleId);
+            if (!module)
+                return unavailable("unsupported-module");
+            if (!implementationCurrent(module))
+                return unavailable("metadata-mismatch");
+            const scope = Object.freeze({ ...data.scope });
+            const installation = data.installation && Object.freeze({ ...data.installation });
+            const metadata = data.configuration && Object.freeze({ ...data.configuration });
+            const expiresAt = data.freshness.expiresAt;
+            if (!current(expiresAt))
+                return unavailable("stale");
+            if (!installation ||
+                installation.installedVersion !== module.version ||
+                installation.configurationSchemaVersion !== module.schemaVersion ||
+                !Number.isSafeInteger(module.schemaVersion) ||
+                module.schemaVersion < 1)
+                return unavailable("metadata-mismatch");
+            if (!module.hasConfiguration) {
+                if (metadata !== null)
+                    return unavailable("metadata-mismatch");
+                if (!implementationCurrent(module))
+                    return unavailable("metadata-mismatch");
+                return Object.freeze({
+                    kind: "no-settings",
+                    revisionFingerprint: digest([
+                        1,
+                        scope,
+                        module.id,
+                        module.version,
+                        "none",
+                    ]),
+                });
+            }
+            if (!metadata)
+                return unavailable("missing");
+            if (metadata.schemaVersion !== module.schemaVersion ||
+                !/^[1-9]\d{0,18}$/u.test(metadata.version) ||
+                BigInt(metadata.version) > 9223372036854775807n ||
+                !validDate(metadata.updatedAt) ||
+                typeof module.validate !== "function")
+                return unavailable("metadata-mismatch");
+            let stored;
+            try {
+                stored = await reader.read({
+                    ...scope,
+                    maximumBytes: limits.maximumBytes,
+                });
+            }
+            catch {
+                return unavailable("read-failed");
+            }
+            if (!current(expiresAt))
+                return unavailable("stale");
+            try {
+                if (!implementationCurrent(module))
+                    return unavailable("metadata-mismatch");
+                if (stored.guildId !== scope.guildId ||
+                    stored.moduleId !== scope.moduleId)
+                    return unavailable("metadata-mismatch");
+                if (stored.kind === "missing")
+                    return unavailable("missing");
+                if (stored.kind === "oversized")
+                    return unavailable("oversized");
+                if (stored.kind !== "observed" ||
+                    stored.version !== metadata.version ||
+                    stored.schemaVersion !== metadata.schemaVersion ||
+                    stored.updatedAt !== metadata.updatedAt ||
+                    !Number.isSafeInteger(stored.storedBytes) ||
+                    stored.storedBytes < 2 ||
+                    stored.storedBytes > limits.maximumBytes)
+                    return unavailable("metadata-mismatch");
+                const input = copyPlainConfiguration(stored.configuration, limits, false);
+                const value = Reflect.apply(module.validate, module.contribution, [input]);
+                if (value instanceof Promise) {
+                    // A mistaken async validator must not create an unhandled rejection.
+                    void Promise.prototype.then.call(value, undefined, () => undefined);
+                    return unavailable("invalid-settings");
+                }
+                const configuration = copyPlainConfiguration(value, limits);
+                if (!current(expiresAt))
+                    return unavailable("stale");
+                if (!implementationCurrent(module))
+                    return unavailable("metadata-mismatch");
+                return Object.freeze({
+                    kind: "validated",
+                    configuration,
+                    revisionFingerprint: digest([
+                        1,
+                        scope,
+                        module.id,
+                        module.version,
+                        metadata,
+                        configuration,
+                    ]),
+                });
+            }
+            catch {
+                // Parser errors and raw settings never leave this private boundary.
+                return unavailable("invalid-settings");
+            }
+        },
+    });
+}
+function unavailable(reason) {
+    return Object.freeze({ kind: "unavailable", reason });
+}
+function digest(value) {
+    return createHash("sha256").update(JSON.stringify(value)).digest("hex");
+}
+function validDate(value) {
+    if (typeof value !== "string" ||
+        !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/u.test(value))
+        return false;
+    const date = new Date(value);
+    return Number.isFinite(date.getTime()) && date.toISOString() === value;
+}
+function copyPlainConfiguration(value, bounds, freeze = true) {
+    let nodes = 0;
+    let estimatedBytes = 0;
+    const seen = new Set();
+    const copy = (input, depth) => {
+        if (++nodes > bounds.maximumNodes || depth > bounds.maximumDepth)
+            throw new Error("Settings structure exceeds bounds");
+        if (input === null || typeof input === "boolean")
+            return input;
+        if (typeof input === "number") {
+            if (!Number.isFinite(input))
+                throw new Error("Settings number is invalid");
+            return Object.is(input, -0) ? 0 : input;
+        }
+        if (typeof input === "string") {
+            if (input.length > bounds.maximumStringLength)
+                throw new Error("Settings string exceeds bounds");
+            estimatedBytes += Buffer.byteLength(input, "utf8");
+            if (estimatedBytes > bounds.maximumBytes)
+                throw new Error("Settings bytes exceed bounds");
+            return input;
+        }
+        if (typeof input !== "object")
+            throw new Error("Settings are not JSON");
+        if (seen.has(input))
+            throw new Error("Settings cycle is invalid");
+        const array = Array.isArray(input);
+        const prototype = Object.getPrototypeOf(input);
+        if (!array && prototype !== null && prototype !== Object.prototype)
+            throw new Error("Settings object is not plain");
+        seen.add(input);
+        const descriptors = Object.getOwnPropertyDescriptors(input);
+        const keys = Reflect.ownKeys(descriptors).filter((key) => !(array && key === "length"));
+        if (keys.length > bounds.maximumCollectionEntries)
+            throw new Error("Settings collection exceeds bounds");
+        if (array && keys.length !== input.length)
+            throw new Error("Settings arrays must be dense");
+        const output = array ? [] : {};
+        if (keys.some((key) => typeof key !== "string"))
+            throw new Error("Settings symbols are invalid");
+        for (const key of keys.sort()) {
+            if (typeof key !== "string")
+                throw new Error("Settings symbols are invalid");
+            const descriptor = descriptors[key];
+            if (!descriptor.enumerable || !("value" in descriptor))
+                throw new Error("Settings accessors are invalid");
+            if (array &&
+                (!/^(0|[1-9]\d*)$/u.test(key) || Number(key) >= input.length))
+                throw new Error("Settings array property is invalid");
+            if (key.length > bounds.maximumStringLength)
+                throw new Error("Settings key exceeds bounds");
+            estimatedBytes += Buffer.byteLength(key, "utf8");
+            if (estimatedBytes > bounds.maximumBytes)
+                throw new Error("Settings bytes exceed bounds");
+            Object.defineProperty(output, key, {
+                value: copy(descriptor.value, depth + 1),
+                enumerable: true,
+                configurable: !freeze,
+                writable: !freeze,
+            });
+        }
+        seen.delete(input);
+        return freeze ? Object.freeze(output) : output;
+    };
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("Settings must be an object");
+    const result = copy(value, 0);
+    if (Buffer.byteLength(JSON.stringify(result), "utf8") > bounds.maximumBytes)
+        throw new Error("Settings bytes exceed bounds");
+    return result;
+}
+//# sourceMappingURL=message-protection-settings.js.map

package/dist/message-protection-summary.d.ts

@@ -0,0 +1,8 @@
+import type { GuildMessageProtectionSnapshot } from "@helyx/sdk";
+import { type Message } from "discord.js";
+export declare function unavailableProtectionSnapshot(reason: Extract<GuildMessageProtectionSnapshot, {
+    available: false;
+}>["reason"]): GuildMessageProtectionSnapshot;
+/** Pure, bounded extraction. The Discord source never leaves this adapter. */
+export declare function summarizeProtectionMessage(message: Pick<Message, "content" | "attachments" | "embeds" | "flags" | "stickers" | "poll" | "partial">): GuildMessageProtectionSnapshot;
+//# sourceMappingURL=message-protection-summary.d.ts.map

package/dist/message-protection-summary.js

@@ -0,0 +1,98 @@
+import { Collection, MessageFlags } from "discord.js";
+import { classifyGuildMessage } from "./message-classification.js";
+export function unavailableProtectionSnapshot(reason) {
+    return Object.freeze({ available: false, reason });
+}
+/** Pure, bounded extraction. The Discord source never leaves this adapter. */
+export function summarizeProtectionMessage(message) {
+    try {
+        if (message.partial)
+            return unavailableProtectionSnapshot("source-unavailable");
+        if (message.flags.has(MessageFlags.IsComponentsV2))
+            return unavailableProtectionSnapshot("unsupported-shape");
+        const content = message.content;
+        const attachments = message.attachments;
+        const embeds = message.embeds;
+        const stickers = message.stickers;
+        if (typeof content !== "string" ||
+            content.length > 4096 ||
+            attachments.size > 10 ||
+            embeds.length > 10 ||
+            stickers.size > 3)
+            return unavailableProtectionSnapshot("source-unavailable");
+        // Check every string the legacy recognizer can inspect before invoking it.
+        for (const attachment of attachments.values()) {
+            if (!bounded(attachment.name) || !bounded(attachment.contentType))
+                return unavailableProtectionSnapshot("source-unavailable");
+        }
+        for (const embed of embeds) {
+            if (![embed.url, embed.image?.url, embed.thumbnail?.url].every(bounded))
+                return unavailableProtectionSnapshot("source-unavailable");
+        }
+        const legacy = classifyGuildMessage({
+            content,
+            attachments: new Collection(),
+            embeds,
+            flags: message.flags,
+            stickers,
+        });
+        const kinds = new Set();
+        if (legacy.available)
+            for (const kind of legacy.kinds) {
+                if (kind === "text" || kind === "emoji")
+                    kinds.add("text");
+                if (kind === "link")
+                    kinds.add("link-or-embed");
+                if (kind === "image")
+                    kinds.add("image");
+                if (kind === "gif" || kind === "sticker")
+                    kinds.add("gif-or-sticker");
+                if (kind === "voice-message")
+                    kinds.add("voice-message");
+            }
+        const voice = message.flags.has(MessageFlags.IsVoiceMessage);
+        if (!voice)
+            for (const attachment of attachments.values()) {
+                const type = attachment.contentType?.toLowerCase() ?? "";
+                if (type === "image/gif" ||
+                    attachment.name.toLowerCase().endsWith(".gif"))
+                    kinds.add("gif-or-sticker");
+                else if (type.startsWith("image/"))
+                    kinds.add("image");
+                else if (type.startsWith("video/"))
+                    kinds.add("video");
+                else
+                    kinds.add("file");
+            }
+        if (embeds.length)
+            kinds.add("link-or-embed");
+        if (embeds.some((embed) => Boolean(embed.video)))
+            kinds.add("video");
+        if (message.poll)
+            kinds.add("poll");
+        const order = [
+            "text",
+            "image",
+            "video",
+            "file",
+            "link-or-embed",
+            "gif-or-sticker",
+            "voice-message",
+            "poll",
+        ];
+        return Object.freeze({
+            available: true,
+            version: 1,
+            kinds: Object.freeze(order.filter((kind) => kinds.has(kind))),
+        });
+    }
+    catch {
+        return unavailableProtectionSnapshot("source-unavailable");
+    }
+}
+function bounded(value) {
+    return (value === null ||
+        value === undefined ||
+        (typeof value === "string" && value.length <= 4096));
+}
+//# sourceMappingURL=message-protection-summary.js.map

package/dist/module-availability-control.js

@@ -4,22 +4,30 @@ import { createHash } from "node:crypto";
 export function availabilityCatalogueDefinitions(modules) {
     return modules
         .filter((module) => isCustomerSelectableModule(module.manifest))
-        .map(({ manifest }) => ({
-        id: manifest.id,
-        name: manifest.name,
-        version: manifest.version,
-        releaseStatus: manifest.releaseStatus,
-    }))
+        .map(({ manifest }) => {
+        if (manifest.releaseStatus === "alpha")
+            throw new Error("Alpha modules have no persisted availability projection");
+        return {
+            id: manifest.id,
+            name: manifest.name,
+            version: manifest.version,
+            releaseStatus: manifest.releaseStatus,
+        };
+    })
         .sort((left, right) => left.name.localeCompare(right.name, "en-GB"));
 }
 export function statusCatalogueDefinitions(modules) {
     return modules
-        .map(({ manifest }) => ({
-        id: manifest.id,
-        name: manifest.name,
-        version: manifest.version,
-        releaseStatus: manifest.releaseStatus,
-    }))
+        .map(({ manifest }) => {
+        if (manifest.releaseStatus === "alpha")
+            throw new Error("Alpha modules have no persisted status projection");
+        return {
+            id: manifest.id,
+            name: manifest.name,
+            version: manifest.version,
+            releaseStatus: manifest.releaseStatus,
+        };
+    })
         .sort((left, right) => left.name.localeCompare(right.name, "en-GB"));
 }
 function catalogueDigest(definitions) {

package/dist/module-logging.d.ts

@@ -1,9 +1,10 @@
-import { InstallationRepository, ModuleConfigurationRepository, ModuleLoggingPolicyRepository, type DatabasePool } from "@helyx/database";
-import type { InstallationRepository as MysqlInstallationRepository, ModuleConfigurationRepository as MysqlModuleConfigurationRepository, ModuleLoggingPolicyRepository as MysqlModuleLoggingPolicyRepository } from "@helyx/database-mysql";
+import { InstallationRepository, ModuleAvailabilityRepository, ModuleConfigurationRepository, ModuleLoggingPolicyRepository, type DatabasePool } from "@helyx/database";
+import type { InstallationRepository as MysqlInstallationRepository, ModuleAvailabilityRepository as MysqlModuleAvailabilityRepository, ModuleConfigurationRepository as MysqlModuleConfigurationRepository, ModuleLoggingPolicyRepository as MysqlModuleLoggingPolicyRepository } from "@helyx/database-mysql";
 import type { ModuleDefinition, ModuleLogDetail, ModuleLoggingService } from "@helyx/sdk";
 import type { Client } from "discord.js";
 import { type InteractionLogger } from "./interactions.js";
 export interface ModuleLoggingRepositories {
+    availability: Pick<ModuleAvailabilityRepository, "get"> & Pick<MysqlModuleAvailabilityRepository, "get">;
     installations: Pick<InstallationRepository, "isModuleEnabled"> & Pick<MysqlInstallationRepository, "isModuleEnabled">;
     configuration: Pick<ModuleConfigurationRepository, "get"> & Pick<MysqlModuleConfigurationRepository, "get">;
     policies: Pick<ModuleLoggingPolicyRepository, "get"> & Pick<MysqlModuleLoggingPolicyRepository, "get">;

package/dist/module-logging.js

@@ -1,4 +1,4 @@
-import { InstallationRepository, ModuleConfigurationRepository, ModuleLoggingPolicyRepository, } from "@helyx/database";
+import { InstallationRepository, ModuleAvailabilityRepository, ModuleConfigurationRepository, ModuleLoggingPolicyRepository, } from "@helyx/database";
 import { safeError } from "@helyx/core";
 import { toReplyOptions } from "./interactions.js";
 import { createHash } from "node:crypto";
@@ -17,6 +17,7 @@ export class DiscordModuleLoggingService {
             "installations" in databaseOrRepositories
                 ? databaseOrRepositories
                 : {
+                    availability: new ModuleAvailabilityRepository(databaseOrRepositories),
                     installations: new InstallationRepository(databaseOrRepositories),
                     configuration: new ModuleConfigurationRepository(databaseOrRepositories),
                     policies: new ModuleLoggingPolicyRepository(databaseOrRepositories),
@@ -33,6 +34,10 @@ export class DiscordModuleLoggingService {
             if (!source || !event) {
                 throw new Error("Module emitted an undeclared logging event");
             }
+            if ((await this.#repositories.availability.get(LOGGING_MODULE_ID))
+                ?.globallyDisabled) {
+                return { delivered: false, retryable: false };
+            }
             if (!(await this.#repositories.installations.isModuleEnabled(input.guildId, LOGGING_MODULE_ID))) {
                 return { delivered: false, retryable: false };
             }

package/dist/modules.js

@@ -4,7 +4,7 @@ import { createHmac } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import { createRequire } from "node:module";
 import { dirname } from "node:path";
-import { assertCommandPathContract } from "./command-path-contract.js";
+import { assertCommandPathContract, collectExecutableCommandPaths, } from "./command-path-contract.js";
 export function assertConfiguredModuleDatabaseCompatibility(modules, engine) {
     for (const { definition } of modules) {
         if (!getModuleDatabaseEngines(definition.manifest).includes(engine)) {
@@ -133,6 +133,8 @@ async function loadDefinitions(specifiers, importer) {
             throw new Error(`Module package has no valid default export: ${specifier}`);
         }
         definition.manifest = parseModuleManifest(definition.manifest);
+        if (definition.manifest.releaseStatus === "alpha")
+            throw new Error(`Alpha module cannot be loaded into the runtime: ${specifier}`);
         validateContributionParity(definition);
         loaded.push({ specifier, definition });
     }
@@ -147,6 +149,54 @@ export function validateContributionParity(definition) {
         requiredDiscordCapabilities.some((capability) => capability !== "guild-members" && capability !== "message-content")) {
         throw new Error("Module requests an unsupported or duplicate Discord capability");
     }
+    for (const contribution of definition.events?.guildMessageCreate ?? []) {
+        const protection = contribution.protection;
+        if (protection === undefined)
+            continue;
+        if (!protection ||
+            typeof protection !== "object" ||
+            Array.isArray(protection) ||
+            (Object.getPrototypeOf(protection) !== Object.prototype &&
+                Object.getPrototypeOf(protection) !== null) ||
+            protection.version !== 1 ||
+            Object.keys(protection).some((key) => ![
+                "version",
+                "otherBots",
+                "webhooks",
+                "summary",
+                "deleteMessage",
+            ].includes(key)) ||
+            (protection.otherBots !== undefined &&
+                typeof protection.otherBots !== "boolean") ||
+            (protection.webhooks !== undefined &&
+                typeof protection.webhooks !== "boolean") ||
+            (protection.summary !== undefined && protection.summary !== true) ||
+            (protection.deleteMessage !== undefined &&
+                protection.deleteMessage !== true))
+            throw new Error("Module requests unsupported guild message protection options");
+        if (protection.summary &&
+            !requiredDiscordCapabilities.includes("message-content"))
+            throw new Error("Message protection summary requires explicit message-content capability");
+        if (protection.deleteMessage &&
+            !definition.manifest.permissions.includes("MANAGE_MESSAGES"))
+            throw new Error("Message protection deletion requires declared MANAGE_MESSAGES permission");
+    }
+    for (const contribution of definition.events?.guildMessageUpdateMetadata ??
+        []) {
+        const metadata = contribution.metadata;
+        if (!metadata ||
+            typeof metadata !== "object" ||
+            Array.isArray(metadata) ||
+            (Object.getPrototypeOf(metadata) !== Object.prototype &&
+                Object.getPrototypeOf(metadata) !== null) ||
+            metadata.version !== 1 ||
+            Object.keys(metadata).some((key) => !["version", "otherBots", "webhooks"].includes(key)) ||
+            (metadata.otherBots !== undefined &&
+                typeof metadata.otherBots !== "boolean") ||
+            (metadata.webhooks !== undefined &&
+                typeof metadata.webhooks !== "boolean"))
+            throw new Error("Module requests unsupported update metadata options");
+    }
     const executableCommands = (definition.interactions?.commands ?? []).map(({ name }) => name);
     const sharedCommandPaths = new Set();
     for (const command of definition.sharedCommands ?? []) {
@@ -198,6 +248,7 @@ export function validateContributionParity(definition) {
         ...(definition.events?.messageReactionRemoveAll ?? []),
         ...(definition.events?.messageReactionRemoveEmoji ?? []),
         ...(definition.events?.guildMessageUpdate ?? []),
+        ...(definition.events?.guildMessageUpdateMetadata ?? []),
         ...(definition.events?.messageDelete ?? []),
         ...(definition.events?.guildMessageDeleteBulk ?? []),
         ...(definition.events?.guildMemberAdd ?? []),
@@ -240,6 +291,10 @@ export function validateContributionParity(definition) {
         assertCommandPathContract(definition);
     }
     if (definition.manifest.manifestVersion === "0.5") {
+        const commandIds = new Set(collectExecutableCommandPaths(definition).map(({ permissionId }) => permissionId));
+        for (const id of definition.manifest.commandPermissionReferences ?? [])
+            if (!commandIds.has(id))
+                throw new Error(`Command permission reference ${id} does not resolve to an executable command in ${definition.manifest.id}`);
         assertSameContributionIds(definition.manifest.permissionOperations.map(({ id }) => id), (definition.permissionOperations ?? []).map(({ id }) => id), "permission operations");
     }
     else if ((definition.permissionOperations?.length ?? 0) > 0) {

package/dist/mysql-runtime-persistence.d.ts

@@ -39,6 +39,7 @@ export interface OpenMysqlBotRuntimePersistenceInput {
     readonly environment: MysqlRuntimeEnvironment;
     readonly modulePackages: readonly ConfiguredModulePackage[];
     readonly applicationName?: string;
+    readonly onCoreReady?: (pool: MysqlPool) => Promise<void>;
 }
 /** Connect, migrate, and compose ordinary self-host persistence from one pool. */
 export declare function openMysqlBotRuntimePersistence(input: OpenMysqlBotRuntimePersistenceInput): Promise<MysqlBotRuntimePersistence>;

package/dist/mysql-runtime-persistence.js

@@ -9,7 +9,9 @@ export async function openMysqlBotRuntimePersistence(input) {
     const adapter = mysql.createMysqlDatabaseAdapter({
         repositories: (_executor, pool) => ({ pool }),
     });
-    const database = await openBotDatabaseWithAdapter(input, adapter);
+    const database = await openBotDatabaseWithAdapter(input, adapter, input.onCoreReady
+        ? (session) => input.onCoreReady(session.repositories.pool)
+        : undefined);
     try {
         const pool = database.session.repositories.pool;
         const installations = new mysql.InstallationRepository(pool);
@@ -38,6 +40,7 @@ export async function openMysqlBotRuntimePersistence(input) {
             commandRead: { commands, installations },
             commandRelease: { commands, installations, runtime },
             logging: {
+                availability,
                 installations,
                 configuration: new mysql.ModuleConfigurationRepository(pool),
                 policies: new mysql.ModuleLoggingPolicyRepository(pool),

package/dist/nexus-command-recovery-control-routes.d.ts

@@ -0,0 +1,5 @@
+import type { NexusCommandRecoveryService } from "@helyx/platform";
+import type { FastifyInstance } from "fastify";
+/** Register only on the private control server with its existing bearer hook. */
+export declare function registerNexusCommandRecoveryControlRoutes(server: FastifyInstance, recovery: NexusCommandRecoveryService | undefined): void;
+//# sourceMappingURL=nexus-command-recovery-control-routes.d.ts.map