meocord 4.1.0-beta.7 → 4.1.0-beta.8

package/CHANGELOG.md

@@ -1,5 +1,48 @@
 # meocord
 
+## 4.1.0-beta.8
+
+### Minor Changes
+
+- [#273](https://github.com/meocord/meocord/pull/273) [`ebd546e`](https://github.com/meocord/meocord/commit/ebd546efe1327d1a4353ea014875ba87aad956a7) Thanks [@l7aromeo](https://github.com/l7aromeo)! - A message command can tell its author, in a direct message, what the channel doesn't show. Without a filter, a message command's unexpected error is only logged and a cooldown refusal is skipped silently, since a reply in the channel can't be private. Two options turn on a direct message instead, both off by default:
+
+  - `@MeoCord({ messages: { dmOnError: true } })` tells the author the command failed, naming the command, the channel and the server. The error is still logged.
+  - `@MeoCord({ messages: { dmOnCooldown: true } })` tells the author how long to wait, once per wait: retries before it ends send nothing more. The notice is counted in the app's cooldown store, so it holds across shards with a shared store.
+
+  Only patterned message handlers are answered, and only when no filter handled the error. A command sent in a direct message is answered there. A member whose direct messages are closed is not told, at debug level. Guard, validation, usage and `UserError` replies are unchanged. The texts are `meocord.dm.error` and `meocord.dm.cooldown`, translatable like MeoCord's other texts, in the server's language.
+
+- [#269](https://github.com/meocord/meocord/pull/269) [`a18e948`](https://github.com/meocord/meocord/commit/a18e9482ca6423bb588d967010bb4125126b351b) Thanks [@l7aromeo](https://github.com/l7aromeo)! - `meocord/testing`: `createMockUser(props?)` and `createMockChannel(Class, props?)` take values for the mock's properties, as `createMockInteraction` does, so `createMockUser({ bot: true })` makes a bot and `createMockChannel(TextChannel, { name: 'general' })` a named channel. Neither took any before, so a bot user took `Object.assign`. The managers of a mock channel, `messages`, `threads` and a thread's `members`, and a mock guild's `bans`, have a real, empty `cache`, as a guild's `members`, `roles` and `channels` do, where reading `cache.size` gave a stub object.
+
+### Patch Changes
+
+- [#274](https://github.com/meocord/meocord/pull/274) [`4827e0f`](https://github.com/meocord/meocord/commit/4827e0f81536816df741af2ef25e430fc19c7292) Thanks [@l7aromeo](https://github.com/l7aromeo)! - `meocord start --dev` runs one bot at a time. A build that finished while the previous bot was still shutting down, which happens when the watcher reports one change twice or a file changes again during a slow `onShutdown`, started a second bot at once, alongside the one stopping. Once that one exited, a third started. The second was left running and connected to Discord, and a restart or Ctrl+C no longer reached it. Now builds that finish during a restart start a single bot from the latest build, once the previous one has exited, and a Ctrl+C during a restart waits for the stopping bot and starts nothing.
+
+- [#266](https://github.com/meocord/meocord/pull/266) [`6be7120`](https://github.com/meocord/meocord/commit/6be71205ec145a730137135dc92b76bd70a30cf6) Thanks [@l7aromeo](https://github.com/l7aromeo)! - `meocord start --dev` restarts the bot once per change, and the new bot always starts. The watcher took the tsconfig copy MeoCord writes for each build for a change of its own and rebuilt right after the first build, restarting the bot while it was still logging in. A stop that lands during login also left the old process running: discord.js's `destroy()` does not settle while the gateway waits for READY, so the bot came online after "Shutting down bot..." and the replacement never started.
+
+  - A stop during login now ends the start at once, and ends with "Bot has shut down" as any other stop does: no `onReady` hook runs, `start()` rejects with an error `isExplainedError()` recognises, and the process exits 0. The client is closed once its login completes. This also fixes a Ctrl+C during login in production, which did nothing until a second one forced exit 1.
+  - Edits to `tsconfig.json` now rebuild and restart the bot under `start --dev`, as edits to `meocord.config.ts` do. A changed `meocord.config.ts` is compiled again before the rebuild, and one that does not compile, such as a file saved mid-edit, is reported and leaves the running bot in place instead of ending the session.
+  - If an application still has not exited after its `shutdownTimeout` and a short grace period, `start --dev` kills it with a warning and starts the new build.
+
+- [#265](https://github.com/meocord/meocord/pull/265) [`2d1ca03`](https://github.com/meocord/meocord/commit/2d1ca03384306a45ae34912652738a3eae80d5a2) Thanks [@l7aromeo](https://github.com/l7aromeo)! - An answer MeoCord fails to build is reported as a fault, not passed off as Discord refusing it. When the text of a usage reply, a `UserError` reply or the answer to an interaction's error cannot be written, or a presenter throws while building an error view, the bot logs an error naming the call, and observers are told the call ended in `'error'` with that fault. Before, it was logged only at debug level as "Could not reply", and the message went unanswered with no trace at the default log level. A send that fails is logged at debug level only when Discord refused it, a `DiscordAPIError` such as a missing permission; any other failure is logged as an error. In a testing module, such a fault rejects `dispatch()`. `respond(interaction).error()` still never throws, and logs a presenter that fails as an error.
+
+- [#275](https://github.com/meocord/meocord/pull/275) [`7d70abf`](https://github.com/meocord/meocord/commit/7d70abfbc1b1687ef6ea7d97167be26d7ee08fa4) Thanks [@l7aromeo](https://github.com/l7aromeo)! - Two JSDoc corrections. `@On` and `@Once` said an event handler runs with the app's global guards, interceptors and filters; its class's and its own run too, as they always have. `MeoCordTestingModule.fromApp`'s remarks now say plainly that `compile()` runs no factory and `init()` runs each one the module provides, so a factory the test replaces never runs, and one it keeps runs at `init()`.
+
+- [#270](https://github.com/meocord/meocord/pull/270) [`9cb86a4`](https://github.com/meocord/meocord/commit/9cb86a4db294fe31cb0cfbbc47daa8a627e5ef25) Thanks [@l7aromeo](https://github.com/l7aromeo)! - A mistake MeoCord refuses as the bot loads is reported as one line, and the bot exits 1. This covers an invalid customId pattern, a builder that fails, a `@Cooldown` it cannot count, and what `MeoCordFactory.create()` refuses, such as a message pattern or two handlers for one command. Before, each came out as Node's uncaught-exception report: MeoCord's own source line, a stack through its bundle, and often none of it pointing at your file. Now the line names the handler, and the source file where the stack shows it. Under `start --dev` the watch session keeps running, so the next edit rebuilds. Any other error keeps the runtime's own report.
+
+  - Every refusal begins with what it is on, `Class.method:`, `Class:` or `App:` for `@MeoCord` options, followed by the decorator and the problem, such as `SampleButtonController.handleButtonWithId: Invalid pattern …` or `App: @MeoCord({ guards }): null is not a class.` A test that matches a refusal's whole text may need its expected message updated.
+  - `@Cooldown`, `@Validate` given something that isn't a Standard Schema, and `SetMetadata` with a key MeoCord reserves now throw where they are applied, rather than where they are called, so the message can name `Class.method`. Written as decorators, both happen in the same statement. A composite made with `applyDecorators` that includes one of them throws where it is applied; one that is defined but never applied no longer throws.
+  - New projects' `src/main.ts` calls `MeoCordFactory.create()` inside `bootstrap()`, and sets exit code 1 for any startup error. An existing `main.ts` needs no change: `create()` reports what it refuses itself, and marks it so `isExplainedError()` returns `true`.
+
+- [#268](https://github.com/meocord/meocord/pull/268) [`5a69c71`](https://github.com/meocord/meocord/commit/5a69c710522fed8dfdb46f8e1f436fc68ee8632e) Thanks [@l7aromeo](https://github.com/l7aromeo)! - `meocord/testing`: mocks read the data Discord always sends as Discord sends it. A mock guild's `preferredLocale` was an empty stub object, so `t.forGuild(createMockGuild())`, and a message command's usage reply on a mock message, came out in the translator's default language whatever the test meant. It is now `'en-US'`, and a guild's `name`, a user's `username`, a message's `pinned`, a channel's `type` and the rest have Discord's values: `false` for a flag, `null` for what may be absent, and snowflake ids. `tag`, `displayName`, `createdAt` and `url` are computed from them as discord.js does. `createMockGuild` takes `name` and `preferredLocale`, so `createMockGuild({ preferredLocale: Locale.Indonesian })` gives a server that speaks Indonesian.
+
+  An interaction with a `guildId` has its user as its `member`, and its `guildLocale` is the `preferredLocale` of the `guild` it is given, as Discord sends it, where it was always `'en-US'`. A mock message has its author as its `member` in a server, and `null` in a direct message, and its `inGuild()` answers as discord.js's does, where it returned `undefined`. A test that reads a property a mock has no value for now gets that value instead of a stub object; one that relied on the stub there sets the property itself. `commandName`, `customId` and a message's `content` stay the test's to give.
+
+- [#272](https://github.com/meocord/meocord/pull/272) [`a8f454d`](https://github.com/meocord/meocord/commit/a8f454d20a3f8dc141e90f9aafae5a39caa8761f) Thanks [@l7aromeo](https://github.com/l7aromeo)! - The JSDoc says where every pipeline stage runs, so the API reference can show it on each entry. `@Guard`, `@Interceptor`, `@Catch` and `@Pipe` gain the `@pipeline` tag their `@UseGuard`, `@UseInterceptor`, `@UseFilter` and `@UsePipe` counterparts already had, and so do `GuardInterface`, `InterceptorInterface`, `ExceptionFilter`, `PipeInterface` and `DispatchObserver`. The stage names are those of the pipeline figure on meocord.dev: `@Observer` runs at `observers-start` and `observers-settled`, and `@Defer`'s second step at `defer-lock`.
+
+- [#263](https://github.com/meocord/meocord/pull/263) [`925225d`](https://github.com/meocord/meocord/commit/925225de08e6a25d55760af6cb9501dc27854b0e) Thanks [@l7aromeo](https://github.com/l7aromeo)! - The JSDoc of `ContextMenuCommandBuilder.setType`, as MeoCord types it, says to leave a context menu builder's `build()` return type inferred. Written out as `ContextMenuCommandBuilder`, it drops the kind `setType()` gave, so a handler of the other kind compiles and is caught only as the bot starts.
+
+- [#271](https://github.com/meocord/meocord/pull/271) [`8b1d9db`](https://github.com/meocord/meocord/commit/8b1d9db951b6c89225734c82336a3dba3b672c9c) Thanks [@l7aromeo](https://github.com/l7aromeo)! - A new app's `package.json` has a `start` script, `meocord start --prod`, so `npm start`, `bun run start` and a host that runs `npm start` for you, as many Node hosts do by default, start the production build. `start:prod` is unchanged, and building stays its own step: run `build:prod` before `start`. An existing app can add the line to its `scripts` to get the same.
+
 ## 4.1.0-beta.7
 
 ### Minor Changes

package/dist/cjs/_shared/{providers-CIA3ykpw.cjs → providers-CSLRsJOZ.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
 require('reflect-metadata');
-var themeResolvers = require('./theme-resolvers-B4BV5Ikl.cjs');
+var themeResolvers = require('./theme-resolvers-CVm6n5-Q.cjs');
 var discord_js = require('discord.js');
 var enum_index = require('../enum/index.cjs');
 var node_async_hooks = require('node:async_hooks');
@@ -14,11 +14,11 @@ var inversify = require('inversify');
  */ function defineStageTypes(cls, types, decorator) {
     if (!types) return;
     if (types.length === 0) {
-        throw new Error(`@${decorator}({ types: [] }) on ${cls.name} lists no types, so it would never run. List the types it ` + `runs for, or leave types out to run for every type.`);
+        throw themeResolvers.refuse(new Error(`${cls.name}: @${decorator}({ types: [] }) lists no types, so it would never run. List the types it ` + `runs for, or leave types out to run for every type.`));
     }
     // Interceptors never run for autocomplete, which must answer within three seconds
     if (decorator === 'Interceptor' && types.every((type)=>type === 'autocomplete')) {
-        throw new Error(`@Interceptor({ types: ['autocomplete'] }) on ${cls.name} can never run: interceptors skip autocomplete ` + `handlers. List the types it should run for instead.`);
+        throw themeResolvers.refuse(new Error(`${cls.name}: @Interceptor({ types: ['autocomplete'] }) can never run: interceptors skip autocomplete ` + `handlers. List the types it should run for instead.`));
     }
     Reflect.defineMetadata(STAGE_TYPES, [
         ...types
@@ -46,7 +46,7 @@ var inversify = require('inversify');
         const reason = malformation(entry);
         if (!reason) continue;
         const Kind = `${kind[0].toUpperCase()}${kind.slice(1)}`;
-        throw new Error(`${decorator} on ${where}: ${reason}. Give ${kind === 'interceptor' ? 'an' : 'a'} ${kind} class, or ` + `{ provide: ${Kind}Class, params? } with params an object.`);
+        throw themeResolvers.refuse(new Error(`${where}: ${decorator}: ${reason}. Give ${kind === 'interceptor' ? 'an' : 'a'} ${kind} class, or ` + `{ provide: ${Kind}Class, params? } with params an object.`));
     }
 }
 /** The class of a stage entry. */ function stageClass(entry) {
@@ -80,8 +80,8 @@ function eventDecorator(event, once) {
  * `@ReactionHandler`, which route them.
  *
  * @remarks
- * The handler's parameters are typed from discord.js's `ClientEvents`. It runs through the pipeline, so global
- * guards apply to it, and an error it throws is logged without stopping the bot. Handling `interactionCreate`
+ * The handler's parameters are typed from discord.js's `ClientEvents`. It runs through the pipeline, so the app's
+ * global guards apply to it, and its class's and its own, and an error it throws is logged without stopping the bot. Handling `interactionCreate`
  * or `messageCreate` here runs alongside MeoCord's own dispatch of them.
  *
  * @param event - The client event to handle, such as `'guildMemberAdd'`.
@@ -94,7 +94,7 @@ function eventDecorator(event, once) {
  * }
  * ```
  *
- * @pipeline handler with the global guards, interceptors and filters that apply to events
+ * @pipeline handler with the guards, interceptors and filters that apply to events: the app's global ones, its class's and its own
  * @group Decorators
  * @category Handlers
  * @see {@link Once}
@@ -121,7 +121,7 @@ function eventDecorator(event, once) {
  * }
  * ```
  *
- * @pipeline handler with the global guards, interceptors and filters that apply to events
+ * @pipeline handler with the guards, interceptors and filters that apply to events: the app's global ones, its class's and its own
  * @group Decorators
  * @category Handlers
  * @see {@link On}
@@ -174,7 +174,7 @@ function eventDecorator(event, once) {
  * The error for a class resolved once and shared that asks for the per-call `ExecutionContext`,
  * which would keep the first call's context for every later one.
  */ function singletonContextError(cls) {
-    return new Error(`${cls.name || 'A class'} is resolved once and shared, so it cannot inject ExecutionContext: it would keep ` + `the first call's context for every later call. Inject ExecutionContext only into guards.`);
+    return new Error(`${cls.name || 'A class'}: resolved once and shared, so it cannot inject ExecutionContext: it would keep ` + `the first call's context for every later call. Inject ExecutionContext only into guards.`);
 }
 const needsContextCache = new WeakMap();
 /**
@@ -632,6 +632,7 @@ const logger$1 = new themeResolvers.Logger('Cooldown');
     }
     return counted;
 }
+/** The store key of the cooldown each refusal came from, 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);
     const policy = cooldownPolicyOf(container);
@@ -652,7 +653,35 @@ const logger$1 = new themeResolvers.Logger('Cooldown');
         throw failure;
     }
     reportRecovery(store);
-    if (!verdict.allowed) throw new themeResolvers.CooldownError(verdict.retryAfterMs, counted[verdict.blocked ?? 0]?.per ?? counted[0].per);
+    if (verdict.allowed) return;
+    const blocking = counted[verdict.blocked ?? 0] ?? counted[0];
+    const refusal = new themeResolvers.CooldownError(verdict.retryAfterMs, blocking.per);
+    refusalKeys.set(refusal, blocking.key);
+    throw refusal;
+}
+/**
+ * Whether the caller a cooldown refused is yet to be told so during this wait: a one-use cooldown in the same
+ * store, keyed on the refusing cooldown's own key, over the wait left. The first refusal of a wait claims it;
+ * every retry in that wait is refused it, and the next wait claims its own. A refusal `@Cooldown` did not
+ * make, or a store that fails to answer, claims nothing.
+ */ async function claimCooldownNotice(container, refusal) {
+    const key = refusalKeys.get(refusal);
+    if (key === undefined) return false;
+    const notice = {
+        key: `${key}:notice`,
+        limit: {
+            uses: 1,
+            windowMs: Math.max(1, refusal.retryAfterMs)
+        }
+    };
+    try {
+        return (await askWithin(cooldownStoreOf(container), [
+            notice
+        ], cooldownPolicyOf(container).timeoutMs, false)).allowed;
+    } catch (error) {
+        logger$1.debug(`Could not ask the cooldown store whether to tell a refused caller: ${String(error.cause ?? error)}`);
+        return false;
+    }
 }
 /** Whether the call is one cooldowns count: an interaction's or a message's. */ function isCounted(contextOf) {
     // Only a controller's own cooldowns reach other handlers, and those are not counted there.
@@ -707,7 +736,7 @@ const logger$1 = new themeResolvers.Logger('Cooldown');
     return undefined;
 }
 /** The error for `@Defer` on a handler that cannot be deferred. */ function deferMisuseError(className, methodName, kind) {
-    return new Error(`@Defer is for interaction handlers, but ${className}.${methodName} is ${kind === 'autocomplete' || kind === 'event' ? 'an' : 'a'} ${kind} ` + `handler. Remove @Defer from it.`);
+    return new Error(`${className}.${methodName}: @Defer is for interaction handlers, and this is ${kind === 'autocomplete' || kind === 'event' ? 'an' : 'a'} ${kind} ` + `handler. Remove @Defer from it.`);
 }
 /**
  * `@Defer`'s first step: acknowledge now, or for `'auto'`, at the earlier of `receivedAt + after` and
@@ -769,7 +798,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(themeResolvers.ExecutionContext)) throw singletonContextError(cls);
+    if (injectedTokens(cls).includes(themeResolvers.ExecutionContext)) throw themeResolvers.refuse(singletonContextError(cls));
     themeResolvers.makeInjectable(cls);
     container.bind(cls).toSelf().inSingletonScope();
     for (const dep of injectedTokens(cls)){
@@ -847,7 +876,7 @@ function filterClass(entry) {
 /** Binds a filter as a singleton, after checking it is one. */ function prepareFilter(container, entry) {
     const cls = filterClass(entry);
     if (!Reflect.hasOwnMetadata(CATCH_TYPES, cls)) {
-        throw new Error(`${cls.name || 'A filter'} is used as an exception filter but is not decorated with @Catch().`);
+        throw themeResolvers.refuse(new Error(`${cls.name || 'A filter'}: used as an exception filter, but not decorated with @Catch().`));
     }
     bindShared(container, cls);
 }
@@ -961,7 +990,7 @@ const logger = new themeResolvers.Logger('Observer');
     for (const observer of observers){
         if (typeof observer !== 'function' || !Reflect.getMetadata(OBSERVER_CLASS, observer)) {
             const name = typeof observer === 'function' ? observer.name : String(observer);
-            throw new Error(`${where} takes classes decorated with @Observer(), not ${name}.`);
+            throw themeResolvers.refuse(new Error(`${where} takes classes decorated with @Observer(), not ${name}.`));
         }
     }
 }
@@ -1915,11 +1944,11 @@ const isToken = (value)=>typeof value === 'function' || typeof value === 'string
         // A class listed alone, as Nest takes one: say where a class goes instead
         if (typeof entry === 'function') {
             const name = tokenName(entry);
-            const listing = where.startsWith('@MeoCord') ? 'list a service in @MeoCord({ services })' : 'a class a controller or service injects is bound for you, so it needs no listing';
-            throw new Error(`${name} in ${where} is a class, not a provider: ${listing}. To put something in its place, write ` + `{ provide: ${name}, useValue } or { provide: ${name}, useClass }.`);
+            const listing = where.includes('@MeoCord') ? 'list a service in @MeoCord({ services })' : 'a class a controller or service injects is bound for you, so it needs no listing';
+            throw themeResolvers.refuse(new Error(`${where}: ${name} is a class, not a provider: ${listing}. To put something in its place, write ` + `{ provide: ${name}, useValue } or { provide: ${name}, useClass }.`));
         }
         if (!entry || typeof entry !== 'object' || !isToken(entry.provide)) {
-            throw new Error(`${where} has a provider without a token: set provide to a class, a string or a symbol.`);
+            throw themeResolvers.refuse(new Error(`${where}: a provider has no token: set provide to a class, a string or a symbol.`));
         }
         const name = tokenName(entry.provide);
         const kinds = [
@@ -1928,20 +1957,20 @@ const isToken = (value)=>typeof value === 'function' || typeof value === 'string
             'useFactory'
         ].filter((kind)=>kind in entry);
         if (kinds.length !== 1) {
-            throw new Error(`The provider for ${name} in ${where} needs exactly one of useValue, useClass and useFactory.`);
+            throw themeResolvers.refuse(new Error(`${where}: the provider for ${name} needs exactly one of useValue, useClass and useFactory.`));
         }
         if ('useClass' in entry && typeof entry.useClass !== 'function') {
-            throw new Error(`The provider for ${name} in ${where} has a useClass that is not a class.`);
+            throw themeResolvers.refuse(new Error(`${where}: the provider for ${name} has a useClass that is not a class.`));
         }
         if ('useFactory' in entry) {
             if (typeof entry.useFactory !== 'function') {
-                throw new Error(`The provider for ${name} in ${where} has a useFactory that is not a function.`);
+                throw themeResolvers.refuse(new Error(`${where}: the provider for ${name} has a useFactory that is not a function.`));
             }
             if (entry.inject !== undefined && !(Array.isArray(entry.inject) && entry.inject.every(isToken))) {
-                throw new Error(`The provider for ${name} in ${where} has an inject that is not a list of tokens.`);
+                throw themeResolvers.refuse(new Error(`${where}: the provider for ${name} has an inject that is not a list of tokens.`));
             }
         }
-        if (map.has(entry.provide)) throw new Error(`${name} is provided twice in ${where}.`);
+        if (map.has(entry.provide)) throw themeResolvers.refuse(new Error(`${where}: ${name} is provided twice.`));
         map.set(entry.provide, provider);
     }
     return map;
@@ -1957,7 +1986,7 @@ const isToken = (value)=>typeof value === 'function' || typeof value === 'string
     }
     if (isClassProvider(provider)) {
         const cls = provider.useClass;
-        if (injectedTokens(cls).includes(themeResolvers.ExecutionContext)) throw singletonContextError(cls);
+        if (injectedTokens(cls).includes(themeResolvers.ExecutionContext)) throw themeResolvers.refuse(singletonContextError(cls));
         themeResolvers.makeInjectable(cls);
         container.bind(token).to(cls).inSingletonScope();
         for (const dependency of injectedTokens(cls))if (isAppClassToken(dependency)) bindClass(dependency);
@@ -1977,14 +2006,14 @@ const isToken = (value)=>typeof value === 'function' || typeof value === 'string
     for (const cls of classes){
         const token = injectedTokens(cls).find(missing);
         if (token !== undefined) {
-            throw new Error(`${cls.name} injects ${tokenName(token)}, which nothing provides: add a provider for it to ${where}.`);
+            throw themeResolvers.refuse(new Error(`${cls.name}: it injects ${tokenName(token)}, which nothing provides: add a provider for it to ${where}.`));
         }
     }
     for (const [provided, provider] of providers){
         const dependencies = isFactoryProvider(provider) ? provider.inject ?? [] : isClassProvider(provider) ? injectedTokens(provider.useClass) : [];
         const token = dependencies.find(missing);
         if (token !== undefined) {
-            throw new Error(`The provider for ${tokenName(provided)} injects ${tokenName(token)}, which nothing provides: add a provider for it to ${where}.`);
+            throw themeResolvers.refuse(new Error(`${tokenName(provided)}: its provider injects ${tokenName(token)}, which nothing provides: add a provider for it to ${where}.`));
         }
     }
 }
@@ -2019,7 +2048,7 @@ const isToken = (value)=>typeof value === 'function' || typeof value === 'string
         if (index === -1) continue;
         const injectors = classes.filter((other)=>other !== cls && injectedTokens(other).includes(cls)).map((other)=>other.name);
         const injectedBy = injectors.length === 0 ? '' : ` (${injectors.length === 1 ? injectors[0] : `${injectors.slice(0, -1).join(', ')} and ${injectors.at(-1)}`} ` + `inject${injectors.length === 1 ? 's' : ''} ${cls.name})`;
-        throw new Error(`${cls.name} cannot be created: parameter ${index + 1} of its constructor has no runtime type. Usually ` + `${cls.name} and a class it injects import each other${injectedBy}, or the parameter is typed with an ` + 'interface or an `import type`. Move what they both need into a third service, or inject the parameter ' + 'with @Inject(token).');
+        throw themeResolvers.refuse(new Error(`${cls.name}: parameter ${index + 1} of its constructor has no runtime type, so it cannot be created. Usually ` + `${cls.name} and a class it injects import each other${injectedBy}, or the parameter is typed with an ` + 'interface or an `import type`. Move what they both need into a third service, or inject the parameter ' + 'with @Inject(token).'));
     }
 }
 /**
@@ -2104,6 +2133,7 @@ exports.bindShared = bindShared;
 exports.callFilter = callFilter;
 exports.callGuardedHandler = callGuardedHandler;
 exports.claimAmbientAppTheme = claimAmbientAppTheme;
+exports.claimCooldownNotice = claimCooldownNotice;
 exports.classChain = classChain;
 exports.classLevelGuards = classLevelGuards;
 exports.classUnits = classUnits;