seyfert 4.4.1 → 5.0.0

package/lib/client/plugins/registry.js

@@ -0,0 +1,868 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPluginRuntimeRegistry = createPluginRuntimeRegistry;
+exports.runPluginRegister = runPluginRegister;
+exports.bindPluginClient = bindPluginClient;
+exports.removePluginEventContribution = removePluginEventContribution;
+exports.removePluginAnyEventContribution = removePluginAnyEventContribution;
+exports.removePluginEventErrorContribution = removePluginEventErrorContribution;
+exports.removePluginCommandObserverContribution = removePluginCommandObserverContribution;
+exports.removePluginRestObserverContribution = removePluginRestObserverContribution;
+exports.removePluginGatewayDispatchInterceptorContribution = removePluginGatewayDispatchInterceptorContribution;
+exports.removePluginHookContribution = removePluginHookContribution;
+exports.activatePluginEventListeners = activatePluginEventListeners;
+exports.cleanupPluginEventListeners = cleanupPluginEventListeners;
+exports.cleanupPluginDynamicContributionMutations = cleanupPluginDynamicContributionMutations;
+exports.hasPluginRequirement = hasPluginRequirement;
+exports.pluginIdentity = pluginIdentity;
+exports.resolvePluginIntents = resolvePluginIntents;
+exports.addPluginGlobalMiddlewares = addPluginGlobalMiddlewares;
+exports.addPluginOptionFragment = addPluginOptionFragment;
+exports.addPluginDiagnostic = addPluginDiagnostic;
+exports.clonePluginOptions = clonePluginOptions;
+exports.readonlyPluginOptions = readonlyPluginOptions;
+exports.assertSafePluginResourceName = assertSafePluginResourceName;
+exports.assertCanMutatePluginContribution = assertCanMutatePluginContribution;
+exports.recordContributionMutationDiagnostic = recordContributionMutationDiagnostic;
+exports.createPluginContextFragment = createPluginContextFragment;
+exports.installPluginClientMaps = installPluginClientMaps;
+exports.installPluginMiddlewares = installPluginMiddlewares;
+exports.resolveGatewayIntent = resolveGatewayIntent;
+exports.unknownGatewayIntentBits = unknownGatewayIntentBits;
+exports.validatePluginRequirements = validatePluginRequirements;
+const types_1 = require("../../types");
+const api_1 = require("./api");
+const errors_1 = require("./errors");
+const order_1 = require("./order");
+function createPluginRuntimeRegistry(plugins = []) {
+    const ordered = resolvePluginOrder(plugins);
+    const records = ordered.map((plugin, index) => ({
+        plugin,
+        identity: pluginIdentity(plugin),
+        index,
+        imports: plugin.imports ?? [],
+        clientKeys: Object.keys(plugin.client ?? {}),
+        ctxKeys: Object.keys(plugin.ctx ?? {}),
+        optionFragments: [],
+        status: 'registered',
+    }));
+    assertSafePluginIdentities(records);
+    assertSafeStaticKeys(records, 'clientKeys', 'client');
+    assertSafeStaticKeys(records, 'ctxKeys', 'ctx');
+    assertUniqueStaticKeys(records, 'clientKeys', 'client');
+    assertUniqueStaticKeys(records, 'ctxKeys', 'ctx');
+    const resolved = ordered.slice();
+    const registry = {
+        plugins: resolved,
+        records,
+        commands: [],
+        components: [],
+        modals: [],
+        events: [],
+        anyEvents: [],
+        eventErrors: [],
+        middlewares: [],
+        globalMiddlewares: [],
+        installedMiddlewares: new Map(),
+        contributionMutationDiagnostics: new Set(),
+        autocompleteWrappers: [],
+        gatewayIntents: [],
+        gatewaySendPayloadWrappers: [],
+        gatewayDispatchInterceptors: [],
+        restObservers: [],
+        hooks: [],
+        cacheResources: [],
+        shared: new Map(),
+        sharedOwners: new Map(),
+        sharedMutations: [],
+        sharedDisposals: [],
+        langs: [],
+        diagnostics: [],
+        requirements: [],
+        nextContributionSequence: 0,
+        commandRemovals: [],
+        componentRemovals: [],
+        modalRemovals: [],
+        middlewareRemovals: [],
+        commandObservers: [],
+        pluginDefaults: [],
+        handlerCreators: [],
+        handlerTransformers: [],
+    };
+    addStaticKeyMultiInstanceDiagnostics(registry);
+    validatePluginRequirements(registry, 'plugin');
+    Object.defineProperties(resolved, {
+        resolved: {
+            value: Object.freeze(ordered.slice()),
+        },
+        diagnostics: {
+            get: () => createPluginDiagnostics(registry),
+        },
+    });
+    Object.freeze(resolved);
+    return registry;
+}
+function runPluginRegister(record, registry) {
+    try {
+        const result = record.plugin.register?.((0, api_1.createPluginApi)(record, registry));
+        if (isPromiseLike(result)) {
+            Promise.resolve(result).catch(() => undefined);
+            throw (0, errors_1.createPluginConflictError)(record.plugin.name, 'register', record.index, 'register(api) must be synchronous.', record.plugin.instanceId);
+        }
+    }
+    catch (error) {
+        throw (0, errors_1.wrapPluginError)(record.plugin.name, 'register', record.index, error, undefined, record.plugin.instanceId);
+    }
+}
+function bindPluginClient(registry, client) {
+    registry.client = client;
+}
+function removePluginEventContribution(registry, contribution) {
+    removeContribution(registry.events, contribution);
+}
+function removePluginAnyEventContribution(registry, contribution) {
+    removeContribution(registry.anyEvents, contribution);
+}
+function removePluginEventErrorContribution(registry, contribution) {
+    removeContribution(registry.eventErrors, contribution);
+}
+function removePluginCommandObserverContribution(registry, contribution) {
+    removeContribution(registry.commandObservers, contribution);
+}
+function removePluginRestObserverContribution(registry, contribution) {
+    removeContribution(registry.restObservers, contribution);
+}
+function removePluginGatewayDispatchInterceptorContribution(registry, contribution) {
+    removeContribution(registry.gatewayDispatchInterceptors, contribution);
+}
+function removePluginHookContribution(registry, contribution) {
+    removeContribution(registry.hooks, contribution);
+}
+function activatePluginEventListeners(registry, record) {
+    for (const contribution of eventContributions(registry)) {
+        if (contribution.record === record && contribution.scope === 'register')
+            contribution.active = true;
+    }
+    for (const contribution of registry.commandObservers) {
+        if (contribution.record === record && contribution.scope === 'register')
+            contribution.active = true;
+    }
+    for (const contribution of registry.restObservers) {
+        if (contribution.record === record && contribution.scope === 'register')
+            contribution.active = true;
+    }
+    for (const contribution of registry.hooks) {
+        if (contribution.record === record && contribution.scope === 'register')
+            contribution.active = true;
+    }
+}
+function cleanupPluginEventListeners(registry, record) {
+    cleanupEventContributions(registry.events, record);
+    cleanupEventContributions(registry.anyEvents, record);
+    cleanupEventContributions(registry.eventErrors, record);
+    cleanupCommandObserverContributions(registry.commandObservers, record);
+    cleanupRestObserverContributions(registry.restObservers, record);
+    cleanupHookContributions(registry.hooks, record);
+}
+function cleanupPluginDynamicContributionMutations(registry, record) {
+    cleanupScopedContributions(registry.commands, record);
+    cleanupScopedContributions(registry.commandRemovals, record);
+    cleanupScopedContributions(registry.components, record);
+    cleanupScopedContributions(registry.componentRemovals, record);
+    cleanupScopedContributions(registry.modals, record);
+    cleanupScopedContributions(registry.modalRemovals, record);
+    cleanupScopedContributions(registry.handlerCreators, record);
+    cleanupScopedContributions(registry.handlerTransformers, record);
+    cleanupScopedContributions(registry.autocompleteWrappers, record);
+    cleanupScopedContributions(registry.gatewaySendPayloadWrappers, record);
+    cleanupScopedContributions(registry.gatewayDispatchInterceptors, record);
+    cleanupScopedContributions(registry.gatewayIntents, record);
+    cleanupScopedContributions(registry.pluginDefaults, record);
+    cleanupScopedContributions(registry.middlewares, record);
+    cleanupScopedContributions(registry.middlewareRemovals, record);
+    cleanupScopedContributions(registry.langs, record);
+    cleanupScopedContributions(registry.cacheResources, record);
+    cleanupScopedContributions(record.optionFragments, record);
+    if (registry.globalMiddlewareOptions) {
+        cleanupScopedContributions(registry.globalMiddlewareOptions.pluginOptions, record);
+    }
+}
+function hasPluginRequirement(registry, req) {
+    if (req.startsWith('plugin:')) {
+        const identity = req.slice('plugin:'.length);
+        return registry.records.some(record => record.identity === identity);
+    }
+    return false;
+}
+function pluginIdentity(plugin) {
+    return plugin.instanceId ? `${plugin.name}#${plugin.instanceId}` : plugin.name;
+}
+function resolvePluginIntents(registry, base) {
+    return registry.gatewayIntents.reduce((intents, contribution) => contribution.intents.reduce((current, intent) => current | intent, intents), base);
+}
+function addPluginGlobalMiddlewares(registry, record, names) {
+    for (const name of names) {
+        registry.globalMiddlewares.push({
+            record,
+            name,
+            sequence: registry.nextContributionSequence++,
+        });
+    }
+}
+function addPluginOptionFragment(registry, record, fragment, scope) {
+    const contribution = {
+        record,
+        fragment: clonePluginOptions(fragment),
+        sequence: (0, order_1.nextPluginContributionSequence)(registry),
+        scope,
+    };
+    record.optionFragments.push(contribution);
+    registry.globalMiddlewareOptions?.pluginOptions.push(contribution);
+}
+function addPluginDiagnostic(registry, record, diagnostic) {
+    registry.diagnostics.push({
+        plugin: record.plugin.name,
+        instanceId: record.plugin.instanceId,
+        index: record.index,
+        ...diagnostic,
+    });
+}
+function clonePluginOptions(value) {
+    return clonePlainValue(value);
+}
+function readonlyPluginOptions(value) {
+    return deepFreezePlain(clonePlainValue(value));
+}
+function assertSafePluginResourceName(record, phase, name, reserved) {
+    if (!isSafePluginKey(name) || reserved.has(name)) {
+        throw (0, errors_1.createPluginConflictError)(record.plugin.name, phase, record.index, `Plugin key "${name}" is reserved or unsafe.`, record.plugin.instanceId);
+    }
+}
+function assertCanMutatePluginContribution(registry, record, action, kind, name, owner, phase) {
+    if (!owner) {
+        throw (0, errors_1.createPluginConflictError)(record.plugin.name, phase, record.index, `${capitalize(kind)} "${name}" is already registered outside the plugin registry and cannot be ${action}d by a plugin.`, record.plugin.instanceId);
+    }
+    if (owner === record)
+        return;
+    if (hasSatisfiedPluginRequirement(registry, record, owner))
+        return;
+    throw (0, errors_1.createPluginConflictError)(record.plugin.name, phase, record.index, `${capitalize(kind)} "${name}" is owned by plugin "${owner.identity}"; ${action} requires plugin "${owner.identity}".`, record.plugin.instanceId);
+}
+function recordContributionMutationDiagnostic(registry, contribution, action, kind, name, owner, phase) {
+    const key = [
+        contribution.sequence,
+        action,
+        kind,
+        name,
+        owner?.identity ?? 'external',
+        contribution.record.identity,
+    ].join(':');
+    if (registry.contributionMutationDiagnostics.has(key))
+        return;
+    registry.contributionMutationDiagnostics.add(key);
+    addPluginDiagnostic(registry, contribution.record, {
+        phase,
+        severity: 'info',
+        code: action === 'override' ? 'contribution-override' : 'contribution-removed',
+        message: `Plugin "${contribution.record.plugin.name}" ${action}d ${kind} "${name}".`,
+        data: {
+            kind,
+            name,
+            owner: owner?.identity,
+        },
+    });
+}
+function addStaticKeyMultiInstanceDiagnostics(registry) {
+    for (const record of registry.records) {
+        const instanceId = record.plugin.instanceId;
+        if (!instanceId)
+            continue;
+        const clientKeys = record.clientKeys.filter(key => !key.includes(instanceId));
+        const ctxKeys = record.ctxKeys.filter(key => !key.includes(instanceId));
+        const middlewareKeys = Object.keys(record.plugin.middlewares ?? {}).filter(key => !key.includes(instanceId));
+        const globalMiddlewares = (record.plugin.globalMiddlewares ?? [])
+            .map(String)
+            .filter(key => !key.includes(instanceId));
+        if (!(clientKeys.length || ctxKeys.length || middlewareKeys.length || globalMiddlewares.length))
+            continue;
+        addPluginDiagnostic(registry, record, {
+            phase: 'resolve',
+            severity: 'warn',
+            code: 'static-keys-multi-instance',
+            message: `Plugin "${record.identity}" declares static keys that do not include instanceId "${instanceId}".`,
+            data: {
+                instanceId,
+                clientKeys,
+                ctxKeys,
+                middlewareKeys,
+                globalMiddlewares,
+            },
+        });
+    }
+}
+function assertSafePluginIdentities(records) {
+    for (const record of records) {
+        assertSafePluginResourceName(record, 'resolve', record.plugin.name, emptyReservedKeys);
+        if (record.plugin.instanceId) {
+            assertSafePluginResourceName(record, 'resolve', record.plugin.instanceId, emptyReservedKeys);
+        }
+    }
+}
+function assertSafeStaticKeys(records, key, phase) {
+    const reserved = phase === 'ctx' ? reservedContextKeys : emptyReservedKeys;
+    for (const record of records) {
+        for (const value of record[key]) {
+            assertSafePluginResourceName(record, `${phase}.${value}`, value, reserved);
+        }
+    }
+}
+function createPluginContextFragment(record, registry) {
+    const map = record.plugin.ctx;
+    if (!map)
+        return undefined;
+    return {
+        context(interaction) {
+            if (!registry.client) {
+                throw (0, errors_1.createPluginConflictError)(record.plugin.name, 'ctx', record.index, 'Plugin context used before client bind.', record.plugin.instanceId);
+            }
+            const context = {};
+            for (const [key, factory] of Object.entries(map)) {
+                try {
+                    context[key] = factory(interaction, registry.client);
+                }
+                catch (error) {
+                    throw (0, errors_1.wrapPluginError)(record.plugin.name, `ctx.${key}`, record.index, error, undefined, record.plugin.instanceId);
+                }
+            }
+            return context;
+        },
+    };
+}
+function installPluginClientMaps(client, registry) {
+    const claimed = new Map();
+    for (const record of registry.records) {
+        for (const [key, factory] of Object.entries(record.plugin.client ?? {})) {
+            if (key in client) {
+                throw (0, errors_1.createPluginConflictError)(record.plugin.name, `client.${key}`, record.index, `Client key "${key}" is reserved or already exists.`, record.plugin.instanceId);
+            }
+            const owner = claimed.get(key);
+            if (owner) {
+                throw (0, errors_1.createPluginConflictError)(record.plugin.name, `client.${key}`, record.index, `Client key "${key}" is already claimed by plugin "${owner.plugin.name}".`, record.plugin.instanceId);
+            }
+            claimed.set(key, record);
+            try {
+                Object.defineProperty(client, key, {
+                    configurable: true,
+                    enumerable: true,
+                    value: factory(client),
+                    writable: false,
+                });
+            }
+            catch (error) {
+                throw (0, errors_1.wrapPluginError)(record.plugin.name, `client.${key}`, record.index, error, undefined, record.plugin.instanceId);
+            }
+        }
+    }
+}
+function installPluginMiddlewares(client, registry) {
+    const declared = registry.records.flatMap(record => Object.entries(record.plugin.middlewares ?? {}).map(([name, middleware]) => ({
+        record,
+        name,
+        middleware: middleware,
+        global: (record.plugin.globalMiddlewares ?? []).includes(name),
+        override: false,
+        scope: 'register',
+        sequence: record.index - registry.records.length,
+    })));
+    const mutations = (0, order_1.orderedPluginContributions)([
+        ...declared.map(contribution => ({ ...contribution, kind: 'add' })),
+        ...registry.middlewares.map(contribution => ({ ...contribution, kind: 'add' })),
+        ...registry.middlewareRemovals.map(contribution => ({ ...contribution, kind: 'remove' })),
+    ]);
+    if (!mutations.length && !registry.installedMiddlewares.size)
+        return;
+    const middlewares = new Map();
+    for (const [name, middleware] of Object.entries(client.middlewares ?? {})) {
+        const installed = registry.installedMiddlewares.get(name);
+        if (installed?.middleware === middleware)
+            continue;
+        middlewares.set(name, { middleware });
+    }
+    for (const contribution of mutations) {
+        if (contribution.kind === 'remove') {
+            for (const name of contribution.names) {
+                const existing = middlewares.get(name);
+                if (!existing)
+                    continue;
+                assertCanMutatePluginContribution(registry, contribution.record, 'remove', 'middleware', name, existing.owner, `middlewares.${name}`);
+                middlewares.delete(name);
+                recordMiddlewareMutationDiagnostic(registry, contribution, 'remove', name, existing.owner, `middlewares.${name}`);
+            }
+            continue;
+        }
+        const existing = middlewares.get(contribution.name);
+        if (existing && !contribution.override) {
+            throw (0, errors_1.createPluginConflictError)(contribution.record.plugin.name, `middlewares.${contribution.name}`, contribution.record.index, `Middleware "${contribution.name}" is already registered.`, contribution.record.plugin.instanceId);
+        }
+        if (existing) {
+            assertCanMutatePluginContribution(registry, contribution.record, 'override', 'middleware', contribution.name, existing.owner, `middlewares.${contribution.name}`);
+            recordMiddlewareMutationDiagnostic(registry, contribution, 'override', contribution.name, existing.owner, `middlewares.${contribution.name}`);
+        }
+        middlewares.set(contribution.name, { middleware: contribution.middleware, owner: contribution.record });
+    }
+    registry.installedMiddlewares = new Map([...middlewares]
+        .filter((entry) => !!entry[1].owner)
+        .map(([name, contribution]) => [name, { middleware: contribution.middleware, owner: contribution.owner }]));
+    client.middlewares = Object.fromEntries([...middlewares].map(([name, contribution]) => [name, contribution.middleware]));
+}
+function recordMiddlewareMutationDiagnostic(registry, contribution, action, name, owner, phase) {
+    recordContributionMutationDiagnostic(registry, contribution, action, 'middleware', name, owner, phase);
+}
+function resolvePluginOrder(plugins) {
+    const ordered = [];
+    const seen = new Set();
+    const visiting = new Set();
+    const identities = new Map();
+    const visit = (plugin, chain, index) => {
+        if (!plugin.name) {
+            throw (0, errors_1.createPluginConflictError)('<anonymous>', 'resolve', index, 'Seyfert plugins must have a name.');
+        }
+        const identity = pluginIdentity(plugin);
+        const existing = identities.get(identity);
+        if (existing && existing !== plugin) {
+            const duplicateMessage = plugin.instanceId
+                ? `Duplicate plugin identity "${identity}".`
+                : `Duplicate plugin name "${plugin.name}". Use instanceId to register multiple instances of the same plugin.`;
+            throw (0, errors_1.createPluginConflictError)(plugin.name, 'resolve', ordered.length, duplicateMessage, plugin.instanceId);
+        }
+        identities.set(identity, plugin);
+        if (seen.has(plugin))
+            return;
+        if (visiting.has(plugin)) {
+            throw (0, errors_1.createPluginConflictError)(plugin.name, 'resolve', ordered.length, `Circular plugin import detected: ${[...chain, identity].join(' -> ')}.`, plugin.instanceId);
+        }
+        visiting.add(plugin);
+        for (const imported of plugin.imports ?? [])
+            visit(imported, [...chain, identity], ordered.length);
+        visiting.delete(plugin);
+        seen.add(plugin);
+        ordered.push(plugin);
+    };
+    for (const [index, plugin] of plugins.entries())
+        visit(plugin, [], index);
+    return ordered;
+}
+function assertUniqueStaticKeys(records, key, phase) {
+    const owners = new Map();
+    for (const record of records) {
+        for (const value of record[key]) {
+            const owner = owners.get(value);
+            if (owner) {
+                throw (0, errors_1.createPluginConflictError)(record.plugin.name, `${phase}.${value}`, record.index, `${phase} key "${value}" is already claimed by plugin "${owner.plugin.name}".`, record.plugin.instanceId);
+            }
+            owners.set(value, record);
+        }
+    }
+}
+const pluginDiagnosticsListLimit = 50;
+function snapshotDiagnosticList(values, truncated, key) {
+    if (values.length > pluginDiagnosticsListLimit)
+        truncated[key] = values.length - pluginDiagnosticsListLimit;
+    return Object.freeze(values.slice(0, pluginDiagnosticsListLimit));
+}
+function createPluginDiagnostics(registry) {
+    return Object.freeze(registry.records.map(record => {
+        const truncated = {};
+        const events = registry.events
+            .filter(contribution => contribution.record === record)
+            .map(contribution => contribution.name);
+        const eventErrors = registry.eventErrors.filter(contribution => contribution.record === record).length;
+        const middlewares = registry.middlewares
+            .filter(contribution => contribution.record === record)
+            .map(contribution => contribution.name)
+            .concat(Object.keys(record.plugin.middlewares ?? {}));
+        const requirements = registry.requirements
+            .filter(contribution => contribution.record === record)
+            .map(({ kind, req, range, resolvedVersion, optional, satisfied }) => Object.freeze({
+            kind,
+            req,
+            range,
+            resolvedVersion,
+            optional,
+            satisfied,
+        }));
+        const shared = [...registry.shared.entries()]
+            .filter(([, contribution]) => contribution.record === record)
+            .map(([name]) => name);
+        const cacheResources = registry.cacheResources
+            .filter(contribution => contribution.record === record)
+            .map(contribution => contribution.name);
+        const langs = registry.langs
+            .filter(contribution => contribution.record === record)
+            .map(contribution => `${contribution.locale}:${contribution.prefix}`);
+        const hooks = registry.hooks
+            .filter(contribution => contribution.record === record)
+            .map(contribution => contribution.name);
+        const messages = registry.diagnostics
+            .filter(message => message.index === record.index)
+            .map(message => Object.freeze({
+            ...message,
+            data: message.data ? Object.freeze({ ...message.data }) : undefined,
+        }));
+        return Object.freeze({
+            name: record.plugin.name,
+            instanceId: record.plugin.instanceId,
+            index: record.index,
+            status: record.status,
+            imports: snapshotDiagnosticList(record.imports.map(pluginIdentity), truncated, 'imports'),
+            clientKeys: snapshotDiagnosticList(record.clientKeys, truncated, 'clientKeys'),
+            ctxKeys: snapshotDiagnosticList(record.ctxKeys, truncated, 'ctxKeys'),
+            commands: registry.commands.filter(contribution => contribution.record === record).flatMap(c => c.commands)
+                .length,
+            components: registry.components
+                .filter(contribution => contribution.record === record)
+                .flatMap(c => c.components).length,
+            modals: registry.modals.filter(contribution => contribution.record === record).flatMap(c => c.modals).length,
+            events: snapshotDiagnosticList(events, truncated, 'events'),
+            anyEvents: registry.anyEvents.filter(contribution => contribution.record === record).length,
+            eventErrors,
+            middlewares: snapshotDiagnosticList(middlewares, truncated, 'middlewares'),
+            autocompleteWrappers: registry.autocompleteWrappers.filter(contribution => contribution.record === record)
+                .length,
+            gatewayIntents: registry.gatewayIntents.filter(contribution => contribution.record === record).length,
+            gatewaySendPayloadWrappers: registry.gatewaySendPayloadWrappers.filter(contribution => contribution.record === record).length,
+            gatewayDispatchInterceptors: registry.gatewayDispatchInterceptors.filter(contribution => contribution.record === record).length,
+            requirements: snapshotDiagnosticList(requirements, truncated, 'requirements'),
+            shared: snapshotDiagnosticList(shared, truncated, 'shared'),
+            cacheResources: snapshotDiagnosticList(cacheResources, truncated, 'cacheResources'),
+            langs: snapshotDiagnosticList(langs, truncated, 'langs'),
+            hooks: snapshotDiagnosticList(hooks, truncated, 'hooks'),
+            restObservers: registry.restObservers.filter(contribution => contribution.record === record).length,
+            commandObservers: registry.commandObservers.filter(contribution => contribution.record === record).length,
+            handlerCreators: registry.handlerCreators.filter(contribution => contribution.record === record).length,
+            handlerTransformers: registry.handlerTransformers.filter(contribution => contribution.record === record).length,
+            messages: snapshotDiagnosticList(messages, truncated, 'messages'),
+            truncated: Object.keys(truncated).length ? Object.freeze({ ...truncated }) : undefined,
+        });
+    }));
+}
+function resolveGatewayIntent(intent) {
+    if (typeof intent !== 'string')
+        return intent;
+    const value = types_1.GatewayIntentBits[intent];
+    return typeof value === 'number' ? value : undefined;
+}
+function unknownGatewayIntentBits(intent) {
+    if (typeof intent !== 'number')
+        return 0;
+    return intent & ~knownGatewayIntentMask;
+}
+function normalizeRequirement(input, record) {
+    if (typeof input === 'string')
+        return { kind: 'plugin', req: input, optional: false, satisfied: false };
+    if ('capability' in input && 'req' in input && input.req !== undefined) {
+        throw (0, errors_1.createPluginConflictError)(record.plugin.name, 'requires', record.index, 'Plugin requirement objects must use either "req" or "capability", not both.', record.plugin.instanceId);
+    }
+    const capability = 'capability' in input ? input.capability : undefined;
+    if (capability) {
+        return {
+            kind: 'capability',
+            req: capability.name,
+            optional: input.optional === true,
+            satisfied: false,
+        };
+    }
+    if (!input.req) {
+        throw (0, errors_1.createPluginConflictError)(record.plugin.name, 'requires', record.index, 'Plugin requirement objects must include "req" or "capability".', record.plugin.instanceId);
+    }
+    return {
+        kind: 'plugin',
+        req: input.req,
+        range: input.range,
+        optional: input.optional === true,
+        satisfied: false,
+    };
+}
+function validatePluginRequirements(registry, kind = 'all') {
+    for (const record of registry.records) {
+        for (const input of record.plugin.requires ?? []) {
+            const requirement = normalizeRequirement(input, record);
+            if (kind !== 'all' && requirement.kind !== kind)
+                continue;
+            resolveRequirement(registry, requirement);
+            registry.requirements.push({ record, ...requirement });
+            if (requirement.satisfied) {
+                const target = requiredPluginRecord(registry, requirement);
+                if (target && target.index > record.index) {
+                    addPluginDiagnostic(registry, record, {
+                        phase: 'requires',
+                        severity: 'warn',
+                        code: 'requires-unordered',
+                        message: `Plugin requirement "${requirement.req}" is ordered after "${record.identity}". Add it to imports when mutating its contributions.`,
+                        data: requirementDiagnosticData(requirement),
+                    });
+                }
+                continue;
+            }
+            if (requirement.optional) {
+                addPluginDiagnostic(registry, record, {
+                    phase: 'requires',
+                    severity: 'warn',
+                    code: 'missing-optional-requirement',
+                    message: optionalRequirementMessage(requirement),
+                    data: requirementDiagnosticData(requirement),
+                });
+                continue;
+            }
+            throw (0, errors_1.createPluginConflictError)(record.plugin.name, 'requires', record.index, requiredRequirementMessage(requirement), record.plugin.instanceId);
+        }
+    }
+}
+function resolveRequirement(registry, requirement) {
+    if (requirement.kind === 'capability') {
+        requirement.satisfied = registry.shared.has(requirement.req);
+        return;
+    }
+    if (!String(requirement.req).startsWith('plugin:'))
+        return;
+    const target = requiredPluginRecord(registry, requirement);
+    if (!target)
+        return;
+    const version = pluginVersion(target.plugin);
+    requirement.resolvedVersion = version;
+    requirement.satisfied = requirement.range ? !!version && satisfiesSemverRange(version, requirement.range) : true;
+}
+function optionalRequirementMessage(requirement) {
+    if (requirement.kind === 'capability') {
+        return `Optional capability requirement "${requirement.req}" is not registered.`;
+    }
+    if (requirement.range && requirement.resolvedVersion) {
+        return `Optional plugin requirement "${requirement.req}" does not satisfy range "${requirement.range}" (resolved "${requirement.resolvedVersion}").`;
+    }
+    if (requirement.range) {
+        return `Optional plugin requirement "${requirement.req}" is missing version range "${requirement.range}".`;
+    }
+    return `Optional plugin requirement "${requirement.req}" is not registered.`;
+}
+function requiredRequirementMessage(requirement) {
+    if (requirement.kind === 'capability') {
+        return `Capability requirement "${requirement.req}" is not registered.`;
+    }
+    if (requirement.range && requirement.resolvedVersion) {
+        return `Plugin requirement "${requirement.req}" does not satisfy range "${requirement.range}" (resolved "${requirement.resolvedVersion}").`;
+    }
+    if (requirement.range) {
+        return `Plugin requirement "${requirement.req}" is missing version range "${requirement.range}".`;
+    }
+    return `Plugin requirement "${requirement.req}" is not registered.`;
+}
+function requirementDiagnosticData(requirement) {
+    if (requirement.kind === 'capability')
+        return { kind: requirement.kind, capability: requirement.req };
+    return {
+        kind: requirement.kind,
+        req: requirement.req,
+        range: requirement.range,
+        resolvedVersion: requirement.resolvedVersion,
+    };
+}
+function pluginVersion(plugin) {
+    if (typeof plugin.version === 'string')
+        return plugin.version;
+    const meta = plugin.meta;
+    if (!meta || typeof meta !== 'object' || !('version' in meta))
+        return undefined;
+    const version = meta.version;
+    return typeof version === 'string' ? version : undefined;
+}
+function requiredPluginRecord(registry, requirement) {
+    if (requirement.kind !== 'plugin')
+        return undefined;
+    if (!String(requirement.req).startsWith('plugin:'))
+        return undefined;
+    const identity = String(requirement.req).slice('plugin:'.length);
+    return registry.records.find(record => record.identity === identity);
+}
+function satisfiesSemverRange(version, range) {
+    const parsed = parseSemver(version);
+    if (!parsed)
+        return false;
+    const trimmed = range.trim();
+    if (!trimmed)
+        return true;
+    if (trimmed.startsWith('>=')) {
+        const minimum = parseSemver(trimmed.slice(2).trim());
+        return !!minimum && compareSemver(parsed, minimum) >= 0;
+    }
+    if (trimmed.startsWith('^')) {
+        const minimum = parseSemver(trimmed.slice(1).trim());
+        if (!minimum || compareSemver(parsed, minimum) < 0)
+            return false;
+        if (minimum.major > 0)
+            return parsed.major === minimum.major;
+        if (minimum.minor > 0)
+            return parsed.major === 0 && parsed.minor === minimum.minor;
+        return parsed.major === 0 && parsed.minor === 0 && parsed.patch === minimum.patch;
+    }
+    if (trimmed.startsWith('~')) {
+        const minimum = parseSemver(trimmed.slice(1).trim());
+        if (!minimum || compareSemver(parsed, minimum) < 0)
+            return false;
+        return parsed.major === minimum.major && parsed.minor === minimum.minor;
+    }
+    const exact = parseSemver(trimmed);
+    return !!exact && compareSemver(parsed, exact) === 0;
+}
+function parseSemver(version) {
+    const match = /^(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/.exec(version.trim());
+    if (!match)
+        return undefined;
+    return {
+        major: Number(match[1]),
+        minor: Number(match[2]),
+        patch: Number(match[3]),
+    };
+}
+function compareSemver(left, right) {
+    return left.major - right.major || left.minor - right.minor || left.patch - right.patch;
+}
+const knownGatewayIntentMask = Object.values(types_1.GatewayIntentBits)
+    .filter((value) => typeof value === 'number')
+    .reduce((mask, value) => mask | value, 0);
+function eventContributions(registry) {
+    return [...registry.events, ...registry.anyEvents, ...registry.eventErrors];
+}
+function cleanupEventContributions(contributions, record) {
+    for (let index = contributions.length - 1; index >= 0; index--) {
+        const contribution = contributions[index];
+        if (contribution.record !== record)
+            continue;
+        if (contribution.scope === 'setup') {
+            contributions.splice(index, 1);
+            continue;
+        }
+        contribution.active = false;
+    }
+}
+function cleanupCommandObserverContributions(contributions, record) {
+    for (let index = contributions.length - 1; index >= 0; index--) {
+        const contribution = contributions[index];
+        if (contribution.record !== record)
+            continue;
+        if (contribution.scope === 'setup') {
+            contributions.splice(index, 1);
+            continue;
+        }
+        contribution.active = false;
+    }
+}
+function cleanupRestObserverContributions(contributions, record) {
+    for (let index = contributions.length - 1; index >= 0; index--) {
+        const contribution = contributions[index];
+        if (contribution.record !== record)
+            continue;
+        if (contribution.scope === 'setup') {
+            contributions.splice(index, 1);
+            continue;
+        }
+        contribution.active = false;
+    }
+}
+function cleanupHookContributions(contributions, record) {
+    for (let index = contributions.length - 1; index >= 0; index--) {
+        const contribution = contributions[index];
+        if (contribution.record !== record)
+            continue;
+        if (contribution.scope === 'setup') {
+            contributions.splice(index, 1);
+            continue;
+        }
+        contribution.active = false;
+    }
+}
+function cleanupScopedContributions(contributions, record) {
+    for (let index = contributions.length - 1; index >= 0; index--) {
+        const contribution = contributions[index];
+        if (contribution.record === record && contribution.scope !== 'register')
+            contributions.splice(index, 1);
+    }
+}
+function removeContribution(contributions, contribution) {
+    const index = contributions.indexOf(contribution);
+    if (index !== -1)
+        contributions.splice(index, 1);
+}
+function declaresPluginRequirement(record, owner) {
+    const requirement = `plugin:${owner.identity}`;
+    return (record.plugin.requires ?? []).some(input => {
+        if (typeof input === 'string')
+            return input === requirement;
+        if ('req' in input)
+            return input.req === requirement;
+        return false;
+    });
+}
+function hasSatisfiedPluginRequirement(registry, record, owner) {
+    if (!declaresPluginRequirement(record, owner))
+        return false;
+    const requirement = `plugin:${owner.identity}`;
+    return registry.requirements.some(contribution => contribution.record === record &&
+        contribution.kind === 'plugin' &&
+        contribution.req === requirement &&
+        contribution.satisfied &&
+        owner.index < record.index);
+}
+function clonePlainValue(value) {
+    if (Array.isArray(value))
+        return value.map(clonePlainValue);
+    if (!isPlainObject(value))
+        return value;
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, clonePlainValue(entry)]));
+}
+function deepFreezePlain(value) {
+    if (Array.isArray(value)) {
+        for (const entry of value)
+            deepFreezePlain(entry);
+        return Object.freeze(value);
+    }
+    if (!isPlainObject(value))
+        return value;
+    for (const entry of Object.values(value))
+        deepFreezePlain(entry);
+    return Object.freeze(value);
+}
+function isPlainObject(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function isSafePluginKey(key) {
+    return !!key && !unsafeObjectKeys.has(key) && !(key in Object.prototype);
+}
+const emptyReservedKeys = new Set();
+const unsafeObjectKeys = new Set(['__proto__', 'constructor', 'prototype']);
+const reservedContextKeys = new Set([
+    'author',
+    'channel',
+    'channelId',
+    'client',
+    'command',
+    'constructor',
+    'guild',
+    'guildId',
+    'interaction',
+    'me',
+    'member',
+    'metadata',
+    'shardId',
+]);
+function capitalize(value) {
+    return value[0]?.toUpperCase() + value.slice(1);
+}
+function isPromiseLike(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'then' in value &&
+        typeof value.then === 'function');
+}