meocord 4.1.2 → 4.2.1

package/dist/esm/core/cooldown-runner.js

@@ -222,19 +222,37 @@ const logger = new Logger('Cooldown');
         const value = by ? await by(context, params) : undefined;
         // Encoded, so a value holding a colon cannot count under another value's key. Without a value, `:by` alone keeps
         // the call apart from a cooldown with no `by` over the same window.
-        const suffix = !by ? '' : value === undefined ? ':by' : `:by:${encodeURIComponent(String(value))}`;
+        const suffix = !by ? '' : value === undefined ? ':by' : `:by:${encodeKeyPart(String(value))}`;
+        const scope = scopeId(per, first);
+        // The caller, for a notice of a refusal under a scope that counts more than one caller
+        const user = scope.startsWith('user:') ? undefined : caller(first).user;
         counted.push({
-            key: `${controller.name}.${methodName}#${id}:${per}:${scopeId(per, first)}${suffix}`,
+            key: `${controller.name}.${methodName}#${id}:${per}:${scope}${suffix}`,
             windowMs,
             uses,
-            per
+            per,
+            user
         });
     }
     return counted;
 }
+// A surrogate with no partner beside it, which encodeURIComponent refuses
+const LONE_SURROGATE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g;
 /**
- * The store key and window of the cooldown each refusal came from, and when its wait ends by the store's clock if
- * the store said, for {@link claimCooldownNotice}.
+ * A value as part of a store key: each well-formed run as `encodeURIComponent` writes it, and each lone surrogate as `%u`
+ * and its four hex digits, which no other value encodes to, since `encodeURIComponent` writes `%` only before two.
+ */ function encodeKeyPart(value) {
+    let encoded = '';
+    let from = 0;
+    for (const { 0: surrogate, index } of value.matchAll(LONE_SURROGATE)){
+        encoded += `${encodeURIComponent(value.slice(from, index))}%u${surrogate.charCodeAt(0).toString(16).toUpperCase()}`;
+        from = index + 1;
+    }
+    return encoded + encodeURIComponent(value.slice(from));
+}
+/**
+ * The store key and window of the cooldown each refusal came from, when its wait ends by the store's clock if the
+ * store said, and the refused caller when the key counts more than one, for {@link claimCooldownNotice}.
  */ const refusalKeys = new WeakMap();
 /** Asks the store about the call under the app's policy, and throws what the answer means for it. */ async function ask(container, counted, peek, call) {
     const store = cooldownStoreOf(container);
@@ -267,7 +285,8 @@ const logger = new Logger('Cooldown');
     refusalKeys.set(refusal, {
         key: blocking.key,
         windowMs: blocking.windowMs,
-        endsAt: verdict.retryTimestamp
+        endsAt: verdict.retryTimestamp,
+        user: blocking.user
     });
     throw refusal;
 }
@@ -290,16 +309,18 @@ const logger = new Logger('Cooldown');
     // retry landing a moment late is refused on the earlier, which its wait holds, before taking the later, which a wait
     // ending then needs for its own notice.
     const bucket = Math.floor(refusal.retryAt.getTime() / NOTICE_BUCKET_MS);
+    // A key counting a server, a channel or everyone is shared by every caller it refuses, each told once
+    const key = refused.user === undefined ? refused.key : `${refused.key}:user:${refused.user}`;
     const notices = refused.endsAt !== undefined ? [
         {
-            key: `${refused.key}:notice:at:${refused.endsAt}`,
+            key: `${key}:notice:at:${refused.endsAt}`,
             limit
         }
     ] : [
         bucket - 1,
         bucket
     ].map((at)=>({
-            key: `${refused.key}:notice:${at}`,
+            key: `${key}:notice:${at}`,
             limit
         }));
     try {

package/dist/esm/core/dispatcher.js

@@ -38,6 +38,7 @@ import { existingResponse } from '../common/response/response-state.js';
     if (state && state !== 'unanswered') return true;
     return 'replied' in interaction && (interaction.replied || interaction.deferred);
 }
+/** How long a message's handler may take, with others waiting after it, before it is named as slow. */ const SLOW_HANDLER_MS = 5000;
 /**
  * Routes interactions, messages and reactions to the handlers that take them, as the bot does, and runs
  * each through its pipeline. The app and the testing module share it, so a test routes exactly as the bot.
@@ -293,22 +294,64 @@ import { existingResponse } from '../common/response/response-state.js';
                 message
             ], error, this.runOptions(call));
         }
+        // The matched handler, then every listener, each resolved from the container only as it starts
+        const runs = [];
         if (target) {
             const { route, params, start, given } = target;
             noteInvocation(message, `${start}${commandWordsOf(route.tokens).join(' ')}`);
             const hooks = messageCommandHooks(route, params, message, start, given, this.messageOptions.types);
-            await this.invokeHandler(this.getInstance(route.controllerClass), route.method, [
-                message,
-                params
-            ], call, hooks);
+            runs.push({
+                name: `${route.controllerClass.name}.${route.method}`,
+                run: (at)=>this.invokeHandler(this.getInstance(route.controllerClass), route.method, [
+                        message,
+                        params
+                    ], at, hooks)
+            });
         }
         for (const { controllerClass, method } of this.messageListeners){
-            await this.invokeHandler(this.getInstance(controllerClass), method, [
-                message
-            ], call);
+            runs.push({
+                name: `${controllerClass.name}.${method}`,
+                run: (at)=>this.invokeHandler(this.getInstance(controllerClass), method, [
+                        message
+                    ], at)
+            });
+        }
+        if (this.messageOptions.handlers === 'concurrent') await this.runTogether(runs, call);
+        else await this.runInTurn(runs, call);
+    }
+    /** Runs a message's handlers one after another, warning once about one that held the rest back for long. */ async runInTurn(runs, call) {
+        const warn = this.messageOptions.slowHandlerWarning ?? this.options.warnSlowMessageHandlers ?? true;
+        for (const [index, { name, run }] of runs.entries()){
+            const started = performance.now();
+            await run(call);
+            const waiting = runs.length - 1 - index;
+            if (warn && waiting > 0) this.warnSlowOnce(name, performance.now() - started, waiting);
         }
     }
     /**
+   * Starts a message's handlers together and settles once all have. Each is reported as settled in the order the
+   * handlers are listed, whichever settles first, and a call that rejects, rejects this once every one has settled.
+   */ async runTogether(runs, call) {
+        const { record } = call;
+        const reports = runs.map(()=>[]);
+        const results = await Promise.allSettled(runs.map(({ run }, index)=>run(record ? {
+                ...call,
+                record: {
+                    settled: (...report)=>reports[index].push(report),
+                    unhandled: (error)=>record.unhandled(error)
+                }
+            } : call)));
+        for (const report of reports.flat())record?.settled(...report);
+        const failed = results.find((result)=>result.status === 'rejected');
+        if (failed) throw failed.reason;
+    }
+    /** Warns, once per handler, that it took `SLOW_HANDLER_MS` or longer with `waiting` handlers held back behind it. */ warnSlowOnce(name, took, waiting) {
+        if (took < SLOW_HANDLER_MS || this.warnedSlow.has(name)) return;
+        this.warnedSlow.add(name);
+        const held = waiting === 1 ? 'the listener after it' : `the ${waiting} listeners after it`;
+        this.logger.warn(`${name} took ${(took / 1000).toFixed(1)} s on a message, and held back ${held}. ` + "@MeoCord({ messages: { handlers: 'concurrent' } }) runs them side by side; messages: { slowHandlerWarning: false } turns this off.");
+    }
+    /**
    * Answers a message that asks the built-in help, when `messages.help` is on and no handler took the message:
    * through the presenter's `messageHelp` when it has one, else in plain text, once the app's guards allow it.
    * `known` is the message's starts when they hold the app's prefixes already. Whether it answered, or a
@@ -429,6 +472,7 @@ import { existingResponse } from '../common/response/response-state.js';
         this.controllerInstancesCache = new Map();
         /** Handler and name pairs already warned about, so a collision warns once, not on every submit or selection. */ this.warnedCollisions = new Set();
         /** The handlers already warned about, so each is named once however often it runs. */ this.warnedUnanswered = new Set();
+        /** The message handlers already warned about as slow, so each is named once. */ this.warnedSlow = new Set();
         this.container = options.container;
         this.controllerClasses = options.controllerClasses;
         this.messageOptions = options.messageOptions ?? {};

package/dist/esm/core/fallback.js

@@ -7,7 +7,7 @@ import { themeForInteraction, useTheme } from './theme-scope.js';
 import { errorText } from '../common/translate-error.js';
 import { interactionLocale, translatorOfClient, messageLocale, renderText } from '../common/meocord-text.js';
 import { logFailedSend } from '../common/response/send-failure.js';
-import { presenterFor, withSendableFiles, DEFAULT_ATTACHMENT_SIZE_LIMIT, attachmentsOf, renderEmbed, withoutFiles, isTooLarge, REFUSED_AS_TOO_LARGE } from '../common/response/presenter.js';
+import { presenterFor, fitText, TEXT_LIMITS, withSendableFiles, DEFAULT_ATTACHMENT_SIZE_LIMIT, attachmentsOf, renderEmbed, withoutFiles, isTooLarge, REFUSED_AS_TOO_LARGE } from '../common/response/presenter.js';
 import { escapeForLog, quoteForLog } from '../util/user-text.util.js';
 
 const UNKNOWN_INTERACTION = 10062;
@@ -79,7 +79,10 @@ function errorCode(error) {
         return send(reply.withoutFiles);
     }
 }
-/** The text of a reply to a message, after the call's `emojis.warning` when `withEmoji`. */ const replyText = (text, withEmoji)=>withEmoji ? `${useTheme().emojis.warning} ${text}` : text;
+/** The text of a reply to a message, after the call's `emojis.warning` when `withEmoji`, cut to fit a message's content. */ function replyText(text, withEmoji) {
+    const emoji = withEmoji ? `${useTheme().emojis.warning} ` : '';
+    return emoji + fitText(text, TEXT_LIMITS.content - emoji.length);
+}
 /**
  * `text`, answering `error` for `message`: plain, after the call's `emojis.warning` when `withEmoji`, unless the
  * presenter's `messageError` draws it as an embed, coloured as an interaction's view is, with that emoji when it has
@@ -87,28 +90,33 @@ function errorCode(error) {
  * the failure comes back with it, for the caller to report once sent.
  */ async function presentedReply(message, error, text, withEmoji, logger) {
     const presenter = presenterFor(message.client);
+    const translator = translatorOfClient(message.client);
+    const locale = messageLocale(message) ?? translator?.defaultLocale ?? 'en-US';
+    // An empty or whitespace-only message, which Discord refuses, reads as MeoCord's generic error text, so neither the plain reply nor a presenter is left without one
+    const shown = text.trim() === '' ? renderText(translator, locale, {
+        key: 'meocord.fallback.error'
+    }) : text;
     const plain = {
         body: {
-            content: replyText(text, withEmoji)
+            content: replyText(shown, withEmoji)
         }
     };
     const { messageError } = presenter;
     if (!messageError) return plain;
     try {
         const theme = await themeForInteraction(message);
-        const translator = translatorOfClient(message.client);
-        const locale = messageLocale(message) ?? translator?.defaultLocale ?? 'en-US';
         const tone = isUserOutcome(error, message) ? 'warning' : 'danger';
+        const presented = {
+            message: fitText(shown, TEXT_LIMITS.embed),
+            error,
+            tone
+        };
         const drawn = await messageError.call(presenter, {
             message,
             locale,
             mode: 'embed',
             theme
-        }, {
-            message: text,
-            error,
-            tone
-        });
+        }, presented);
         let view = drawn.color === undefined ? {
             ...drawn,
             color: theme.colors.primary
@@ -165,7 +173,8 @@ async function replyToMessage(message, error, logger, withEmoji, answering) {
         await sendReply(reply, (body)=>message.reply({
                 ...body,
                 allowedMentions: {
-                    repliedUser: false
+                    repliedUser: false,
+                    parse: []
                 }
             }));
     } catch (replyError) {

package/dist/esm/core/filter-runner.js

@@ -1,7 +1,7 @@
 import 'reflect-metadata';
 import { perHandler, sourcePrototype, stageClasses } from './guard-runner.js';
 import { bindShared } from './interceptor-runner.js';
-import { refuse } from '../util/refusal.util.js';
+import { startupError } from '../util/refusal.util.js';
 import { isConstructor } from '../util/value.util.js';
 import { META } from '../util/metadata-keys.js';
 
@@ -41,7 +41,7 @@ import { META } from '../util/metadata-keys.js';
 /** Binds a filter as a singleton, after checking it is one. */ function prepareFilter(container, entry) {
     const cls = filterClass(entry);
     if (!Reflect.hasOwnMetadata(META.catchTypes, cls)) {
-        throw refuse(new Error(`${cls.name || 'A filter'}: used as an exception filter, but not decorated with @Catch().`));
+        return startupError(new Error(`${cls.name || 'A filter'}: used as an exception filter, but not decorated with @Catch().`));
     }
     bindShared(container, cls);
 }

package/dist/esm/core/guard-runner.js

@@ -338,14 +338,27 @@ const wrapperCount = perHandler((prototype, methodName)=>{
     else marks.delete(methodName);
     return true;
 }
+/** The container that made each instance, so a direct call runs in its own app or testing module. */ const instanceContainers = new WeakMap();
+/**
+ * Records each instance `container` makes of `classes` as its own. Two testing modules made from one class each run a
+ * direct call on their own instance in themselves, where the class's metadata names only the last.
+ */ function recordInstanceContainers(container, classes) {
+    for (const cls of classes){
+        container.onActivation(cls, (_context, instance)=>{
+            if (typeof instance === 'object' && instance !== null) instanceContainers.set(instance, container);
+            return instance;
+        });
+    }
+}
 /**
  * Runs a direct call to a guarded handler: the handler's guards, as dispatch resolves them, then the
  * call with a pass for each wrapper inside the one entered, so no guard runs twice.
  */ async function runDirectCall(instance, methodName, args, call) {
     const prototype = Object.getPrototypeOf(instance);
     const controller = instance.constructor;
-    // The app that made the class, or a class it extends: a subclass the app's code makes runs as its base does
-    const container = Reflect.getMetadata(META.container, controller);
+    // The container that made the instance, or else the app that made the class or a class it extends: a subclass the
+    // app's code makes runs as its base does
+    const container = instanceContainers.get(instance) ?? Reflect.getMetadata(META.container, controller);
     if (!container) {
         throw new Error(`${controller.name}.${methodName}: @UseGuard runs its guards through the app that made ${controller.name}, and this ` + `instance was made outside one. Inject ${controller.name}, or call it on an instance the app made.`);
     }
@@ -384,4 +397,4 @@ const wrapperCount = perHandler((prototype, methodName)=>{
     }
 }
 
-export { callGuardedHandler, classChain, classLevelGuards, consumeDispatchMark, declaringPrototype, handlerGuards, handlerMethods, injectedTokens, isGuardWithParams, perHandler, runDirectCall, runGuards, singletonContextError, sourcePrototype, stageClasses, undecoratedConstructor, untypedParameter };
+export { callGuardedHandler, classChain, classLevelGuards, consumeDispatchMark, declaringPrototype, handlerGuards, handlerMethods, injectedTokens, isGuardWithParams, perHandler, recordInstanceContainers, runDirectCall, runGuards, singletonContextError, sourcePrototype, stageClasses, undecoratedConstructor, untypedParameter };

package/dist/esm/core/handler-input.js

@@ -2,6 +2,7 @@ import { ModalSubmitInteraction, ComponentType, StringSelectMenuInteraction, Use
 import { getCommandMap } from '../decorator/controller.decorator.js';
 import { matchComponentRoute } from './component-routes.js';
 import { hasCustomId, isCustomIdRouted, matchesHandler, resolveOptionParams, matchesCommandType } from '../util/interaction.util.js';
+import { setOwn } from '../util/value.util.js';
 import { commandRouteKeys, matchCommandRoute } from './command-routes.js';
 
 /** The entries of a discord.js Collection, or none for anything else, such as a test double's stub. */ const entriesOf = (collection)=>collection instanceof Map ? [
@@ -18,8 +19,8 @@ import { commandRouteKeys, matchCommandRoute } from './command-routes.js';
     for (const [customId, field] of fields){
         const data = field;
         // An upload's `values` are the attachments' ids; discord.js resolves the attachments themselves alongside
-        if (data.type === ComponentType.FileUpload) values[customId] = entriesOf(interaction.fields.getUploadedFiles(customId));
-        else values[customId] = 'value' in data ? data.value : data.values;
+        if (data.type === ComponentType.FileUpload) setOwn(values, customId, entriesOf(interaction.fields.getUploadedFiles(customId)));
+        else setOwn(values, customId, 'value' in data ? data.value : data.values);
     }
     return values;
 }
@@ -78,7 +79,7 @@ import { commandRouteKeys, matchCommandRoute } from './command-routes.js';
         collisions: []
     };
     const fields = interaction instanceof ModalSubmitInteraction ? modalFields(interaction) : selectChoices(interaction);
-    const collisions = Object.keys(routeParams).filter((name)=>name in fields);
+    const collisions = Object.keys(routeParams).filter((name)=>Object.hasOwn(fields, name));
     return {
         params: {
             ...fields,

package/dist/esm/core/handler-pipeline.js

@@ -1,17 +1,17 @@
 import 'reflect-metadata';
-import { refuse } from '../util/refusal.util.js';
+import { refuse, startupError } from '../util/refusal.util.js';
 import { setPresenter } from '../common/response/presenter.js';
 import { responseOf } from '../common/response/response-state.js';
 import { handlerDefer, nonInteractionHandler, deferMisuseError, startDefer } from './defer.js';
-import { perHandler, handlerGuards, runGuards, callGuardedHandler, isGuardWithParams } from './guard-runner.js';
-import { prepareInterceptor, handlerInterceptors, bindShared, interceptorClass, runInterceptors } from './interceptor-runner.js';
+import { perHandler, runGuards, callGuardedHandler, handlerGuards, isGuardWithParams } from './guard-runner.js';
+import { prepareInterceptor, handlerInterceptors, bindShared, runInterceptors, interceptorClass } from './interceptor-runner.js';
 import { inferContextType, HandlerExecutionContext, UnroutedExecutionContext } from '../common/execution-context.js';
 import { prepareFilter, handlerFilterLevels, filterClass, matchFilter, callFilter } from './filter-runner.js';
-import { handlerInputStages, preparePipe, pipeClass, prepareHandlerArgs } from './input-runner.js';
+import { handlerInputStages, preparePipe, prepareHandlerArgs, pipeClass } from './input-runner.js';
 import { hasObservers, notifyStart, outcomeOf, responsePhaseOf, notifyObservers } from './observer-runner.js';
-import { methodCooldowns, handlerCooldowns, peekCooldowns } from './cooldown-runner.js';
+import { handlerCooldowns, peekCooldowns, methodCooldowns } from './cooldown-runner.js';
 import { Logger } from '../common/logger.js';
-import { configureThemes, beginCallTheme } from './theme-runtime.js';
+import { beginCallTheme, configureThemes } from './theme-runtime.js';
 import { runInThemeScope } from './theme-scope.js';
 import { getEventHandlers } from '../decorator/event.decorator.js';
 import { getCommandMap, getMessageHandlers, getReactionHandlers, getAutocompleteHandlers } from '../decorator/controller.decorator.js';
@@ -57,12 +57,16 @@ const NO_GLOBAL_STAGES = {
  */ function bindAppPresenter(container, app, client) {
     const options = Reflect.getMetadata(META.appOptions, app);
     if (!options?.presenter) return undefined;
-    bindShared(container, options.presenter);
+    prepareAppPresenter(container, app);
     const presenter = container.get(options.presenter);
     container.bind(APP_PRESENTER).toConstantValue(presenter);
     if (client) setPresenter(client, presenter);
     return presenter;
 }
+/** Binds the app's presenter class as a shared stage, checking it as one, without making it. */ function prepareAppPresenter(container, app) {
+    const options = Reflect.getMetadata(META.appOptions, app);
+    if (options?.presenter) bindShared(container, options.presenter);
+}
 /** Where a container keeps the application's presenter. */ const APP_PRESENTER = Symbol('app_presenter');
 /** The presenter `bindAppPresenter` resolved into `container`, if any. */ function appPresenterOf(container) {
     return container.isBound(APP_PRESENTER) ? container.get(APP_PRESENTER) : undefined;
@@ -152,18 +156,21 @@ const stagesByGlobals = new WeakMap();
 /**
  * Binds the interceptors, filters and pipes every handler of `controllers` uses, and the global ones, as singletons, so
  * one that cannot be shared, or a filter without `@Catch`, fails at startup; refuses there `@Defer`, `@Validate`,
- * `@UsePipe` and `@Cooldown` where they cannot apply, and two classes that keep state under one name.
+ * `@UsePipe` and `@Cooldown` where they cannot apply, and two classes that keep state under one name. Binds only; it
+ * makes nothing, so it runs with the other startup checks.
  */ function prepareHandlerStages(container, controllers) {
     assertDistinctNamesWhereKeyed(controllers);
     const globals = globalStagesOf(container);
-    configureThemes(container, globals.theme, controllers, globals.themeFor);
     for (const entry of globals.interceptors)prepareInterceptor(container, entry);
     for (const entry of globals.filters)prepareFilter(container, entry);
     for (const controller of controllers){
         const prototype = controller.prototype;
         for (const method of handlerMethods(prototype)){
             const kind = handlerDefer(prototype, method) ? nonInteractionHandler(prototype, method) : undefined;
-            if (kind) throw refuse(deferMisuseError(controller.name, method, kind));
+            if (kind) {
+                startupError(deferMisuseError(controller.name, method, kind));
+                continue;
+            }
             for (const entry of handlerInterceptors(prototype, method))prepareInterceptor(container, entry);
             for (const entry of handlerFilterLevels(prototype, method, []).flat())prepareFilter(container, entry);
             for (const { entry } of handlerInputStages(prototype, method).pipes)preparePipe(container, entry);
@@ -171,6 +178,10 @@ const stagesByGlobals = new WeakMap();
         assertInputStagesOnInteractions(controller, prototype);
     }
 }
+/** Records the app's theme for the handlers of `controllers`, once the startup checks have passed: it makes the theme cache. */ function prepareThemes(container, controllers) {
+    const globals = globalStagesOf(container);
+    configureThemes(container, globals.theme, controllers, globals.themeFor);
+}
 /** Whether a class has state keyed by its name: a cooldown on a handler, or a `@Once` handler. */ function keyedByName(cls) {
     const prototype = cls.prototype;
     const handlers = [
@@ -187,7 +198,8 @@ const stagesByGlobals = new WeakMap();
     for (const cls of classes){
         const other = byName.get(cls.name);
         if (other && other !== cls && (keyedByName(cls) || keyedByName(other))) {
-            throw refuse(new Error(`${cls.name}: two classes have this name; @Cooldown and @Once tell classes apart by name, so they would share ` + `their counts. Rename one of them.`));
+            startupError(new Error(`${cls.name}: two classes have this name; @Cooldown and @Once tell classes apart by name, so they would share ` + `their counts. Rename one of them.`));
+            continue;
         }
         byName.set(cls.name, cls);
     }
@@ -215,11 +227,12 @@ const stagesByGlobals = new WeakMap();
         const { schema, pipes } = handlerInputStages(prototype, method);
         const handler = kind === 'message' ? 'a message handler without a pattern' : `${kind === 'autocomplete' || kind === 'event' ? 'an' : 'a'} ${kind} handler`;
         if (schema || pipes.length > 0) {
-            throw refuse(new Error(`${controller.name}.${method}: @Validate and @UsePipe are for interaction and patterned message handlers, ` + `whose options, customId params, modal fields and pattern params they check, and this is ${handler}.`));
+            startupError(new Error(`${controller.name}.${method}: @Validate and @UsePipe are for interaction and patterned message handlers, ` + `whose options, customId params, modal fields and pattern params they check, and this is ${handler}.`));
+            continue;
         }
         // A controller's own @Cooldown skips these handlers; one on the method itself is a mistake.
         if (kind !== 'message' && methodCooldowns(prototype, method).length > 0) {
-            throw refuse(new Error(`${controller.name}.${method}: @Cooldown is for interaction and message handlers, and this is ${handler}.`));
+            startupError(new Error(`${controller.name}.${method}: @Cooldown is for interaction and message handlers, and this is ${handler}.`));
         }
     }
 }
@@ -462,4 +475,4 @@ const logger = new Logger('ExceptionFilter');
     }, options);
 }
 
-export { appPresenterOf, appStages, bindAppPresenter, bindGlobalStages, classDecorators, globalStagesOf, handleUnroutedError, handlerStageClasses, handlerStages, observeUnclaimed, prepareHandlerStages, runHandler, runInAppTheme };
+export { appPresenterOf, appStages, bindAppPresenter, bindGlobalStages, classDecorators, globalStagesOf, handleUnroutedError, handlerStageClasses, handlerStages, observeUnclaimed, prepareAppPresenter, prepareHandlerStages, prepareThemes, runHandler, runInAppTheme };

package/dist/esm/core/handler-registry.js

@@ -97,7 +97,7 @@ const COMMAND_TYPES = new Set([
  *
  * @group Controllers
  * @see {@link HandlerEntry}
- * @see {@link https://meocord.dev/docs/4.1/handler-discovery | Handler discovery}
+ * @see {@link https://meocord.dev/docs/4.2/handler-discovery | Handler discovery}
  */ class HandlerRegistry {
     /**
    * Lists the registered handlers.

package/dist/esm/core/interceptor-runner.js

@@ -4,7 +4,7 @@ import { perHandler, injectedTokens, singletonContextError, sourcePrototype, sta
 import { ExecutionContext } from '../common/execution-context.js';
 import { makeInjectable } from '../util/injectable.util.js';
 import { isAppClassToken } from './lifecycle-order.js';
-import { refuse } from '../util/refusal.util.js';
+import { startupError } from '../util/refusal.util.js';
 import { Logger } from '../common/logger.js';
 import { META } from '../util/metadata-keys.js';
 
@@ -35,7 +35,7 @@ function isInterceptorWithParams(entry) {
 });
 /** Binds `cls` and its unbound dependencies as singletons, refusing any that injects `ExecutionContext`. */ function bindShared(container, cls) {
     if (container.isBound(cls)) return;
-    if (injectedTokens(cls).includes(ExecutionContext)) throw refuse(singletonContextError(cls));
+    if (injectedTokens(cls).includes(ExecutionContext)) return startupError(singletonContextError(cls));
     assertStartupChecked(container, cls);
     makeInjectable(cls);
     container.bind(cls).toSelf().inSingletonScope();