meocord 4.2.0 → 4.2.2

package/dist/esm/testing/catalog.js

@@ -1,7 +1,6 @@
-import { CATALOGS, placeholderNames } from '../common/translator.js';
+import { isPluralShape, CATALOGS, placeholderNames } from '../common/translator.js';
 import { MEOCORD_MESSAGES } from '../common/meocord-messages.js';
 
-const isPlural = (value)=>typeof value === 'object' && value !== null && typeof value.other === 'string';
 /** Every message key of a catalog, and whether it is a plural. */ function leaves(catalog, prefix = '') {
     return Object.entries(catalog).flatMap(([name, value])=>{
         const key = `${prefix}${name}`;
@@ -11,7 +10,7 @@ const isPlural = (value)=>typeof value === 'object' && value !== null && typeof
                 plural: false
             }
         ];
-        if (isPlural(value)) return [
+        if (isPluralShape(value)) return [
             {
                 key,
                 plural: true
@@ -20,8 +19,9 @@ const isPlural = (value)=>typeof value === 'object' && value !== null && typeof
         return leaves(value, `${key}.`);
     });
 }
-function at(catalog, key) {
-    return key.split('.').reduce((current, part)=>current?.[part], catalog);
+/** A translation's text, which an empty string isn't: the translator reads `''` as missing, as tools export one untranslated. */ const isText = (value)=>typeof value === 'string' && value !== '';
+/** The value at a key's path, through own properties only, so `constructor` or `toString` is not read off a prototype. */ function at(catalog, key) {
+    return key.split('.').reduce((current, part)=>typeof current === 'object' && current !== null && Object.hasOwn(current, part) ? current[part] : undefined, catalog);
 }
 const MEOCORD_KEYS = new Set(leaves(MEOCORD_MESSAGES).map(({ key })=>key));
 const isMeoCordKey = (key)=>key.startsWith('meocord.');
@@ -34,7 +34,7 @@ const isMeoCordKey = (key)=>key.startsWith('meocord.');
 /** A message as a report shows it: the text, or a plural's `other` form. */ const shown = (message)=>typeof message === 'string' ? message : String(message.other);
 /** The `{params}` a translation uses that the message it translates doesn't take; a plural's `{count}` is taken. */ function strayParams(translation, original) {
     const taken = placeholders(original);
-    if (isPlural(original)) taken.add('count');
+    if (isPluralShape(original)) taken.add('count');
     return [
         ...placeholders(translation)
     ].filter((name)=>!taken.has(name));
@@ -44,9 +44,11 @@ const isMeoCordKey = (key)=>key.startsWith('meocord.');
  *
  * Use it in a test for a team that wants no fallback in production. It reports the messages a locale lacks, the
  * messages the default catalog doesn't have, the plural forms a language needs but a plural lacks, such as `few` for
- * Russian, and each `{param}` a translation uses that the message it translates doesn't take. It reads the catalogs'
- * own strings, so it checks the params of a catalog from a plain variable or a JSON file too, which the compiler
- * can't.
+ * Russian, a translation of another shape than the default's, a text for a plural or a plural for a text, and each
+ * `{param}` a translation uses that the message it translates doesn't take. An empty translation, `''`, counts as
+ * lacking, as the translator reads it as missing. It reads the catalogs' own strings, so it checks the params of a
+ * catalog from a plain variable or a JSON file too, which the compiler can't. An object counts as a plural only when
+ * its every key is a plural category, so a group with an `other` key is a group.
  *
  * @remarks
  * MeoCord's own texts, a catalog's `meocord` group, fall back to English by design, so only a key MeoCord lacks, and
@@ -93,12 +95,17 @@ const isMeoCordKey = (key)=>key.startsWith('meocord.');
         const categories = new Intl.PluralRules(locale).resolvedOptions().pluralCategories;
         for (const { key, plural } of reference){
             const message = at(catalog, key);
-            if (message === undefined) {
+            if (message === undefined || message === '') {
                 problems.push(`missing ${key}`);
                 continue;
             }
-            if (plural && isPlural(message)) {
-                const missing = categories.filter((category)=>typeof message[category] !== 'string');
+            // A translation of another shape than the default's can't be read as it: a text for a plural, or the reverse
+            if (plural !== isPluralShape(message) || !plural && typeof message !== 'string') {
+                problems.push(`${key} should be a ${plural ? 'plural' : 'text'}, as the default is`);
+                continue;
+            }
+            if (plural) {
+                const missing = categories.filter((category)=>!isText(message[category]));
                 if (missing.length > 0) problems.push(`${key} lacks ${missing.join(', ')}`);
             }
             const original = at(defaultCatalog, key);
@@ -106,7 +113,7 @@ const isMeoCordKey = (key)=>key.startsWith('meocord.');
             for (const name of stray)problems.push(`${key} takes no {${name}}; the default is "${shown(original)}"`);
         }
         if (options.meocord && !locale.startsWith('en-')) {
-            for (const key of MEOCORD_KEYS)if (at(catalog, key) === undefined) problems.push(`missing ${key}`);
+            for (const key of MEOCORD_KEYS)if (at(catalog, key) === undefined || at(catalog, key) === '') problems.push(`missing ${key}`);
         }
         for (const { key } of leaves(catalog)){
             if (isMeoCordKey(key)) {

package/dist/esm/testing/cooldown-store-suite.js

@@ -12,8 +12,9 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
  *
  * @remarks
  * The cases cover what a shared store most often gets wrong: a sliding window rather than fixed buckets,
- * `retryAfterMs` from the oldest call still in the window, calls in the same millisecond kept apart, and concurrent
- * calls at the limit where exactly one may pass. They use real time, with windows short enough that the suite takes
+ * `retryAfterMs` until a use frees up, from the oldest of the newest `uses` calls in the window, calls in the same
+ * millisecond kept apart, concurrent calls at the limit where exactly one may pass, a batch refusal that names the
+ * longest wait, and a release that frees only the call it gave back. They use real time, with windows short enough that the suite takes
  * a few seconds and margins wide enough that a correct store passes when timers fire late, as on a busy CI runner,
  * and each case counts under keys of its own. Each window is a whole number of milliseconds, as
  * `@Cooldown` gives a store: it rounds its `seconds` to the millisecond.
@@ -88,6 +89,30 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
             expect(retryAfterMs).toBeLessThanOrEqual(limit.windowMs - (secondSent - firstDone) + CLOCK_SLACK_MS);
             expect(retryAfterMs).toBeGreaterThanOrEqual(limit.windowMs - (thirdDone - firstSent) - CLOCK_SLACK_MS);
         });
+        // @Cooldown keeps the calls counted so far when a limit is lowered, so a key can hold more calls than `uses`
+        test('counts retryAfterMs from the oldest of the newest `uses` calls when a lowered limit leaves more in the window', async (store)=>{
+            const windowMs = 2000;
+            for(let call = 0; call < 3; call += 1)await store.consume(key('lowered'), {
+                uses: 5,
+                windowMs
+            });
+            await sleep(1000);
+            const newerSent = Date.now();
+            for(let call = 0; call < 2; call += 1)await store.consume(key('lowered'), {
+                uses: 5,
+                windowMs
+            });
+            const { allowed, retryAfterMs } = await store.consume(key('lowered'), {
+                uses: 2,
+                windowMs
+            });
+            const refusedDone = Date.now();
+            expect(allowed).toBe(false);
+            // A use frees up when the older of the two newest calls leaves the window; counted from the oldest call, it would
+            // be a second sooner
+            expect(retryAfterMs).toBeGreaterThanOrEqual(windowMs - (refusedDone - newerSent) - CLOCK_SLACK_MS);
+            expect(retryAfterMs).toBeLessThanOrEqual(windowMs + CLOCK_SLACK_MS);
+        });
         test('counts each key on its own', async (store)=>{
             const limit = {
                 uses: 1,
@@ -149,6 +174,41 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
             expect(refused.retryAfterMs).toBeGreaterThan(short.windowMs);
             expect(refused.retryAfterMs).toBeLessThanOrEqual(long.windowMs);
         });
+        // A refusal names the wait until every cooldown of the batch allows the call; the default consumeMany stops at the first
+        test('names the longest wait when several cooldowns refuse a batch, or with the default consumeMany, the first', async (store)=>{
+            const short = {
+                uses: 1,
+                windowMs: 1000
+            };
+            const long = {
+                uses: 1,
+                windowMs: 2000
+            };
+            const batch = [
+                {
+                    key: key('both-short'),
+                    limit: short
+                },
+                {
+                    key: key('both-long'),
+                    limit: long
+                }
+            ];
+            await store.consume(batch[0].key, short);
+            await store.consume(batch[1].key, long);
+            const refused = await store.consumeMany(batch);
+            expect(refused.allowed).toBe(false);
+            const [blocked, limit] = overridesConsumeMany(store) ? [
+                1,
+                long
+            ] : [
+                0,
+                short
+            ];
+            expect(refused.blocked).toBe(blocked);
+            expect(refused.retryAfterMs).toBeGreaterThan(limit.windowMs - 1000);
+            expect(refused.retryAfterMs).toBeLessThanOrEqual(limit.windowMs);
+        });
         // The default consumeMany counts in order and stops at the first refusal, so the entries before it count
         test('records nothing when one cooldown of a batch refuses it, or with the default consumeMany, counts those before it', async (store)=>{
             const limit = {
@@ -191,10 +251,11 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
             }, ()=>store.consumeMany(batch)));
             expect(verdicts.filter((verdict)=>verdict.allowed).length).toBe(1);
         });
-        // A store without release keeps a counted call counted, as the default consumeMany does
-        test('releases a call it counted when the verdict gives release, or keeps it counted without one', async (store)=>{
+        // A store without release keeps a counted call counted, as the default consumeMany does. Two uses tell a release of
+        // the one call apart from one that frees the key's other calls too
+        test('releases only the call it counted when the verdict gives release, or keeps it counted without one', async (store)=>{
             const limit = {
-                uses: 1,
+                uses: 2,
                 windowMs: 2000
             };
             const entries = [
@@ -207,6 +268,7 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
                     limit
                 }
             ];
+            expect((await store.consumeMany(entries)).allowed).toBe(true);
             const counted = await store.consumeMany(entries);
             expect(counted.allowed).toBe(true);
             if (!counted.release) {

package/dist/esm/testing/discord-defaults.js

@@ -1,10 +1,66 @@
-import { Message, Guild, TextChannel, ThreadChannel, GuildChannel, BaseGuildVoiceChannel, MessageReaction, GuildPremiumTier, GuildVerificationLevel, GuildNSFWLevel, Locale, ClientUser, User, GuildMember, Role, Collection, MessageType, CommandInteraction, AutocompleteInteraction, PermissionsBitField, BaseInteraction, ChannelType, NewsChannel, VoiceChannel, ForumChannel, MediaChannel, DMChannel, BaseChannel, Client, BaseGuild, SnowflakeUtil } from 'discord.js';
-import { createMockChannel, createMockGuild, memberRoles, createMockUser, isRawMember } from './mock-interaction.js';
+import { GuildChannel, MessageReaction, MessageMentions, Message, GuildMember, BaseGuild, Guild, ModalSubmitInteraction, TextChannel, ThreadChannel, BaseGuildVoiceChannel, GuildPremiumTier, GuildVerificationLevel, GuildNSFWLevel, Locale, PresenceManager, ClientUser, UserFlagsBitField, User, GuildMemberFlagsBitField, GuildEmoji, Sticker, GuildScheduledEvent, AutoModerationRule, Invite, Role, Collection, MessageType, ReactionManager, ChatInputCommandInteraction, CommandInteraction, AutocompleteInteraction, ReactionUserManager, BaseInteraction, ChannelType, NewsChannel, VoiceChannel, ForumChannel, MediaChannel, DMChannel, BaseChannel, Client, PermissionsBitField, PermissionFlagsBits } from 'discord.js';
+import { createMockChannel, createMockGuild, createMockMessage, ownedManager, memberRoles, createMockUser, createChatInputOptions, readPlaceAs, botMemberOf, heldChannelOf, isRawMember, isUnsetEveryone, NEW_SERVER_EVERYONE_PERMISSIONS } from './mock-interaction.js';
+import { nextSnowflake } from './snowflake.js';
 import { strictMocks } from './strict-mocks.js';
+import { Logger } from '../common/logger.js';
+import { warnOnce } from '../common/deprecation.js';
 
+const mockLogger = new Logger('Mocks');
+/**
+ * A member's permissions where an interaction was made, as Discord computes them: under strict mocks, every permission
+ * for an Administrator or the owner, else the channel's overwrites on top of `member.permissions`, so a test that sets
+ * those keeps the base; otherwise `member.permissions`, with a warning once where strict mocks would read otherwise.
+ */ function inChannel(interaction, member) {
+    const base = member.permissions;
+    // Only a server the mock caches has the overwrites to apply
+    const { guild } = interaction;
+    if (!(guild instanceof Guild)) return base;
+    const computed = base.has(PermissionFlagsBits.Administrator) || member.id === guild.ownerId ? new PermissionsBitField(PermissionsBitField.All).freeze() : withOverwrites(base, overwritingChannel(interaction, guild), member);
+    if (strictMocks()) return computed;
+    if (!computed.equals(base)) {
+        const lost = new PermissionsBitField(base).remove(computed).toArray();
+        const gained = new PermissionsBitField(computed).remove(base).toArray();
+        const change = lost.length > 0 ? [
+            `without ${lost.join(', ')}`
+        ] : [];
+        if (gained.length > 0) change.push(`with ${gained.join(', ')}`);
+        warnOnce(mockLogger, `${interaction.constructor.name}.memberPermissions reads the member's own permissions here, without the ` + "channel's overwrites or every permission an Administrator or the owner has; in the next major version (5.0) " + `it reads them as Discord computes them in the channel, ${change.join(' and ')}. Set memberPermissions on the ` + 'mock, or call useStrictMocks() to compute them now.');
+    }
+    // Unless the test set them, a member's permissions come from its roles, @everyone's included
+    if (!Object.prototype.hasOwnProperty.call(member, 'permissions')) warnOnUnsetEveryone(interaction, guild, 'memberPermissions', base);
+    return base;
+}
+/**
+ * Warns once, as `key`, where `permissions` read a server's @everyone role default mode made with none, and lack what
+ * strict mocks give @everyone in a new server.
+ */ function warnOnUnsetEveryone(interaction, guild, key, permissions) {
+    const everyone = guild.roles.everyone;
+    if (!everyone || !isUnsetEveryone(everyone) || permissions.has(NEW_SERVER_EVERYONE_PERMISSIONS)) return;
+    warnOnce(mockLogger, `${interaction.constructor.name}.${key} reads the server's @everyone role here with no permissions; in the next major ` + 'version (5.0) it has the permissions Discord gives @everyone in a new server, as strict mocks read it. Set ' + 'guild.roles.everyone.permissions, or call useStrictMocks() to read it so now.');
+}
+/**
+ * The channel whose overwrites apply where an interaction was made, read without making or caching one: a thread's
+ * parent, or undefined where the channel, or a thread's parent, is one the mock would make, which has none.
+ */ function overwritingChannel(interaction, guild) {
+    const channel = heldChannelOf(interaction, guild);
+    // A thread's parent by the id the test gave it or one already read, so strict mocks' parent isn't made for this read
+    const parentId = (thread)=>Object.prototype.hasOwnProperty.call(thread, 'parentId') ? thread.parentId : madeParentIds.get(thread);
+    const at = channel instanceof ThreadChannel ? guild.channels.cache.get(parentId(channel) ?? '') : channel;
+    return at instanceof GuildChannel ? at : undefined;
+}
+// The parent id strict mocks made for each thread made without one, once read
+const madeParentIds = new WeakMap();
+// Private in discord.js's typings, though they are what its own permissionsFor computes with; called on the prototype
+// so a test's stub on the channel stays for its caller
+const channelPermissions = GuildChannel.prototype;
+/** `base` with `channel`'s overwrites for `member` applied, in discord.js's order: @everyone's, the roles', the member's. */ function withOverwrites(base, channel, member) {
+    if (!channel) return base;
+    // Given the member and its roles as verified, as discord.js's memberPermissions does, so it resolves nothing again
+    const overwrites = channelPermissions.overwritesFor.call(channel, member, true, member.roles.cache);
+    return new PermissionsBitField(base).remove(overwrites.everyone?.deny ?? 0n).add(overwrites.everyone?.allow ?? 0n).remove(overwrites.roles.length > 0 ? overwrites.roles.map((role)=>role.deny) : 0n).add(overwrites.roles.length > 0 ? overwrites.roles.map((role)=>role.allow) : 0n).remove(overwrites.member?.deny ?? 0n).add(overwrites.member?.allow ?? 0n).freeze();
+}
 /** A permission set with none, frozen as discord.js freezes the ones it gives. */ const noPermissions = ()=>new PermissionsBitField().freeze();
 /** A property discord.js computes from the others: its own getter runs, reading the mock's values. */ const REAL_GETTER = Symbol('real getter');
-const snowflake = ()=>SnowflakeUtil.generate().toString();
 /** A class and its defaults, typed together so a default that stops fitting its property fails to compile. */ const defaultsOf = (Class, defaults)=>[
         Class.prototype,
         defaults
@@ -17,7 +73,7 @@ const snowflake = ()=>SnowflakeUtil.generate().toString();
     defaultsOf(Guild, {
         name: ()=>'Guild',
         preferredLocale: ()=>Locale.EnglishUS,
-        ownerId: snowflake,
+        ownerId: nextSnowflake,
         memberCount: ()=>1,
         available: ()=>true,
         large: ()=>false,
@@ -30,6 +86,9 @@ const snowflake = ()=>SnowflakeUtil.generate().toString();
         shardId: ()=>0,
         nsfwLevel: ()=>GuildNSFWLevel.Default,
         verificationLevel: ()=>GuildVerificationLevel.None,
+        presences: (guild)=>ownedManager(PresenceManager.prototype, {
+                guild
+            }),
         premiumTier: ()=>GuildPremiumTier.None,
         createdTimestamp: REAL_GETTER,
         createdAt: REAL_GETTER
@@ -44,6 +103,7 @@ const snowflake = ()=>SnowflakeUtil.generate().toString();
         discriminator: ()=>'0',
         avatar: ()=>null,
         system: ()=>false,
+        flags: ()=>new UserFlagsBitField(),
         tag: REAL_GETTER,
         displayName: REAL_GETTER,
         defaultAvatarURL: REAL_GETTER,
@@ -64,12 +124,32 @@ const snowflake = ()=>SnowflakeUtil.generate().toString();
         premiumSinceTimestamp: ()=>null,
         communicationDisabledUntilTimestamp: ()=>null,
         pending: ()=>false,
+        flags: ()=>new GuildMemberFlagsBitField().freeze(),
         displayName: REAL_GETTER,
         roles: (member)=>memberRoles(member, []),
         permissions: REAL_GETTER
     }),
+    // A server's emoji, sticker, scheduled event and AutoMod rule are named, and what discord.js formats from them
+    // computes: an emoji's mention and identifier, an event's and an invite's link
+    defaultsOf(GuildEmoji, {
+        name: ()=>'emoji',
+        animated: ()=>false,
+        identifier: REAL_GETTER
+    }),
+    defaultsOf(Sticker, {
+        name: ()=>'sticker'
+    }),
+    defaultsOf(GuildScheduledEvent, {
+        name: ()=>'event',
+        url: REAL_GETTER
+    }),
+    defaultsOf(AutoModerationRule, {
+        name: ()=>'rule'
+    }),
+    defaultsOf(Invite, {
+        url: REAL_GETTER
+    }),
     defaultsOf(Role, {
-        id: snowflake,
         name: ()=>'role',
         // Above @everyone, which a server's role manager makes at position 0
         position: ()=>1,
@@ -107,37 +187,71 @@ const snowflake = ()=>SnowflakeUtil.generate().toString();
         poll: ()=>null,
         interactionMetadata: ()=>null,
         stickers: ()=>new Collection(),
+        messageSnapshots: ()=>new Collection(),
+        reactions: (message)=>ownedManager(ReactionManager.prototype, {
+                message
+            }),
         url: REAL_GETTER
     }),
     // A command's name and a component's customId say which handler a call is for, so they stay the test's to give
+    defaultsOf(ChatInputCommandInteraction, {
+        options: ()=>createChatInputOptions()
+    }),
     defaultsOf(CommandInteraction, {
-        commandId: snowflake,
+        commandId: nextSnowflake,
         commandGuildId: ()=>null
     }),
     defaultsOf(AutocompleteInteraction, {
-        commandId: snowflake,
-        commandGuildId: ()=>null
+        commandId: nextSnowflake,
+        commandGuildId: ()=>null,
+        options: ()=>createChatInputOptions()
+    }),
+    defaultsOf(MessageReaction, {
+        users: (reaction)=>ownedManager(ReactionUserManager.prototype, {
+                reaction
+            })
     }),
     defaultsOf(BaseInteraction, {
-        applicationId: snowflake,
+        applicationId: nextSnowflake,
         token: ()=>'mock-interaction-token',
         version: ()=>1,
         context: ()=>null,
+        entitlements: ()=>new Collection(),
         // What Discord sends with an interaction in a server, the member's permissions there; typed for a cached one
-        memberPermissions: (interaction)=>{
-            const { guildId } = interaction;
-            const member = interaction.member;
-            if (!guildId) return null;
-            if (member instanceof GuildMember) return member.permissions;
-            // A raw member's permissions are the string Discord sends, read as discord.js reads them
-            return isRawMember(member) && !interaction.guild ? new PermissionsBitField(BigInt(member.permissions)).freeze() : null;
-        },
-        // The bot's permissions where the interaction was made: its member's in the channel, or none outside a server
-        appPermissions: (interaction)=>{
-            const { guild, channel } = interaction;
-            const me = guild instanceof Guild ? guild.members.me : null;
-            return (me && channel instanceof GuildChannel ? channel.permissionsFor(me) : null) ?? noPermissions();
-        }
+        // Each reads where the interaction is as its own, and warns by its own name where strict mocks place it otherwise
+        memberPermissions: (interaction)=>readPlaceAs(interaction, 'memberPermissions', ()=>{
+                const { guildId } = interaction;
+                const member = interaction.member;
+                if (!guildId) return null;
+                if (member instanceof GuildMember) return inChannel(interaction, member);
+                // A raw member's permissions are the string Discord sends, read as discord.js reads them
+                return isRawMember(member) && !interaction.guild ? new PermissionsBitField(BigInt(member.permissions)).freeze() : null;
+            }),
+        // The bot's permissions where the interaction was made: its member's in the channel, or in a thread its parent, as
+        // discord.js computes them; none outside a server
+        appPermissions: (interaction)=>readPlaceAs(interaction, 'appPermissions', ()=>{
+                const { guild } = interaction;
+                const me = guild instanceof Guild ? botMemberOf(guild) : null;
+                if (!(me instanceof GuildMember) || heldChannelOf(interaction, guild) === null) return noPermissions();
+                // discord.js's own computation, given its own overwritesFor over a test's stub on the channel; a channel the
+                // mock would make has no overwrites
+                const at = overwritingChannel(interaction, guild) ?? {
+                    guild,
+                    permissionOverwrites: {
+                        cache: new Collection()
+                    }
+                };
+                const channel = Object.create(at, {
+                    overwritesFor: {
+                        value: channelPermissions.overwritesFor
+                    }
+                });
+                const permissions = channelPermissions.memberPermissions.call(channel, me, true);
+                // The bot's member has @everyone's too
+                warnOnUnsetEveryone(interaction, guild, 'appPermissions', permissions);
+                return permissions;
+            }, // A server the bot isn't in has no guild in either mode, so no permissions in both
+            (place)=>!place.raw)
     }),
     defaultsOf(TextChannel, {
         type: ()=>ChannelType.GuildText,
@@ -173,7 +287,7 @@ const snowflake = ()=>SnowflakeUtil.generate().toString();
     }),
     defaultsOf(GuildChannel, {
         name: ()=>'channel',
-        guildId: (channel)=>typeof channel.guild?.id === 'string' ? channel.guild.id : snowflake(),
+        guildId: (channel)=>typeof channel.guild?.id === 'string' ? channel.guild.id : nextSnowflake(),
         position: ()=>0,
         rawPosition: ()=>0,
         parentId: ()=>null
@@ -197,11 +311,26 @@ const snowflake = ()=>SnowflakeUtil.generate().toString();
  * thread made without one, a thread's parent text channel in it, and data that is otherwise a placeholder.
  */ const STRICT_DEFAULTS = new Map([
     defaultsOf(Message, {
-        content: ()=>''
+        content: ()=>'',
+        editedTimestamp: ()=>null,
+        editedAt: REAL_GETTER
+    }),
+    defaultsOf(MessageMentions, {
+        repliedUser: ()=>null
     }),
     defaultsOf(Guild, {
         rulesChannelId: ()=>null,
-        publicUpdatesChannelId: ()=>null
+        publicUpdatesChannelId: ()=>null,
+        systemChannel: REAL_GETTER
+    }),
+    defaultsOf(BaseGuild, {
+        verified: REAL_GETTER
+    }),
+    defaultsOf(GuildMember, {
+        presence: REAL_GETTER
+    }),
+    defaultsOf(ModalSubmitInteraction, {
+        message: ()=>null
     }),
     defaultsOf(ThreadChannel, {
         guild: ()=>createMockGuild(),
@@ -211,25 +340,91 @@ const snowflake = ()=>SnowflakeUtil.generate().toString();
                 guild: thread.guild
             });
             thread.guild.channels.cache.set(parent.id, parent);
+            madeParentIds.set(thread, parent.id);
             return parent.id;
         },
         parent: REAL_GETTER,
-        ownerId: snowflake,
+        ownerId: nextSnowflake,
         archived: ()=>false,
         locked: ()=>false
     }),
     defaultsOf(GuildChannel, {
-        guild: ()=>createMockGuild()
+        guild: ()=>createMockGuild(),
+        parent: REAL_GETTER
     }),
     // Full once its members reach a user limit, which a voice channel has none of unless given one
     defaultsOf(BaseGuildVoiceChannel, {
         userLimit: ()=>0,
         full: REAL_GETTER
     }),
+    // A reaction's message, as discord.js always has one, is a whole one
     defaultsOf(MessageReaction, {
-        count: ()=>1
+        count: ()=>1,
+        me: ()=>false,
+        message: ()=>createMockMessage()
     })
 ]);
+/**
+ * What a mock reads as a placeholder unless strict mocks read it as discord.js gives it, by the value a test sets for
+ * that, which the warning on reading one names.
+ */ const PLACEHOLDER_VALUES = new Map([
+    [
+        MessageReaction.prototype,
+        {
+            me: 'false',
+            message: 'createMockMessage()'
+        }
+    ],
+    [
+        MessageMentions.prototype,
+        {
+            repliedUser: 'null'
+        }
+    ],
+    [
+        Message.prototype,
+        {
+            editedAt: 'null'
+        }
+    ],
+    [
+        GuildMember.prototype,
+        {
+            presence: 'null'
+        }
+    ],
+    [
+        BaseGuild.prototype,
+        {
+            verified: 'false'
+        }
+    ],
+    [
+        Guild.prototype,
+        {
+            systemChannel: 'null'
+        }
+    ],
+    [
+        GuildChannel.prototype,
+        {
+            parent: 'null'
+        }
+    ],
+    [
+        ModalSubmitInteraction.prototype,
+        {
+            message: 'null'
+        }
+    ]
+]);
+/** The value a test sets for `key` on a mock of `target`'s class, when a mock reads it as a placeholder. */ function placeholderValue(target, key) {
+    for(let proto = Object.getPrototypeOf(target); proto !== null; proto = Object.getPrototypeOf(proto)){
+        const value = PLACEHOLDER_VALUES.get(proto)?.[key];
+        if (value !== undefined) return value;
+    }
+    return undefined;
+}
 /** The default a mock of `target`'s class has for `key`, read from the nearest class that has one, strict ones first. */ function discordDefault(target, key) {
     for (const defaults of strictMocks() ? [
         STRICT_DEFAULTS,
@@ -245,4 +440,4 @@ const snowflake = ()=>SnowflakeUtil.generate().toString();
     return undefined;
 }
 
-export { REAL_GETTER, discordDefault };
+export { REAL_GETTER, discordDefault, placeholderValue };