meocord 4.0.0-beta.0 → 4.0.0-beta.2

package/CHANGELOG.md

@@ -1,5 +1,61 @@
 # meocord
 
+## 4.0.0-beta.2
+
+### Major Changes
+
+- [#36](https://github.com/l7aromeo/meocord/pull/36) [`45e564e`](https://github.com/l7aromeo/meocord/commit/45e564e6baff17313037372ec56baa1711a3584c) Thanks [@l7aromeo](https://github.com/l7aromeo)! - **Breaking:** `app.start()` rejects when the login fails. It logged the error and resolved, so a bot
+  with an invalid token went on to log "Application started" and exit with code 0, which Docker's
+  `restart: on-failure`, systemd and CI all read as success. New applications' `main.ts` sets
+  `process.exitCode = 1` when startup fails; add the same to an existing entry point's `catch`. See the
+  [migration guide](https://github.com/l7aromeo/meocord/blob/main/docs/MIGRATING.md#4-build-and-start).
+
+### Patch Changes
+
+- [#37](https://github.com/l7aromeo/meocord/pull/37) Thanks [@l7aromeo](https://github.com/l7aromeo)! - Type the CommonJS build as CommonJS. Every entry point's `require` condition resolved to the ESM
+  declarations, so a CommonJS TypeScript project was told `meocord/core` is an ES module it cannot
+  `require`, even with `skipLibCheck`. Each entry now ships `.d.cts` declarations for `require`, and
+  `meocord/eslint` types its `module.exports` array as what `require` returns.
+
+- [#35](https://github.com/l7aromeo/meocord/pull/35) [`b93a771`](https://github.com/l7aromeo/meocord/commit/b93a771b19664345fec4222d5a2c29dcf5b31a0d) Thanks [@l7aromeo](https://github.com/l7aromeo)! - Generate code that passes a new application's own `lint`. A generated guard failed `tsc` and ESLint
+  — `GuardInterface` imported as a value, and an unused `context` parameter — and generated message and
+  reaction controllers imported names they never used, which only the application's ESLint, run in the
+  background after generating, removed. New applications also typecheck `meocord.config.ts`: the
+  template's `tsconfig.json` includes it instead of excluding it, so a type error in the config fails
+  `lint`, and editors resolve `paths` aliases imported there. `noEmit` stays on, so `tsc` writes nothing
+  beside it.
+
+## 4.0.0-beta.1
+
+### Major Changes
+
+- [#33](https://github.com/l7aromeo/meocord/pull/33) [`21b06ae`](https://github.com/l7aromeo/meocord/commit/21b06ae6810cfe203abadcadc6f7b7247c7b305b) Thanks [@l7aromeo](https://github.com/l7aromeo)! - Require Node.js 22.13 or newer, up from 22.0. A built bot loads its compiled config with `require()`
+  of an ES module. Node 22.12 runs that without a flag but still warns on every start and crashes on a
+  config that throws; 22.13 is the first 22 release that does neither. Bun is unaffected. See the
+  [migration guide](https://github.com/l7aromeo/meocord/blob/main/docs/MIGRATING.md#before-you-start-nodejs-2213).
+
+### Patch Changes
+
+- [#33](https://github.com/l7aromeo/meocord/pull/33) [`21b06ae`](https://github.com/l7aromeo/meocord/commit/21b06ae6810cfe203abadcadc6f7b7247c7b305b) Thanks [@l7aromeo](https://github.com/l7aromeo)! - Keep jiti out of bots built with `bundleDependencies`. A built bot loaded `dist/meocord.config.mjs`,
+  already compiled JavaScript, through jiti, and the logger and the factory both reach that loader,
+  so jiti was bundled into every bot: 190 KB, 89% of a minimal bot's `main.js`, and a
+  `Critical dependency` warning on every build. The compiled config is now loaded with `require()`,
+  and jiti is only used by the CLI to read `meocord.config.ts`. A minimal bot bundles to 22 KB.
+
+  A built bot no longer falls back to reading `meocord.config.ts` when `dist/meocord.config.mjs` is
+  missing, and `meocord build` now fails when the config does not compile, instead of warning and
+  producing a bot that cannot start.
+
+- [#31](https://github.com/l7aromeo/meocord/pull/31) [`f50bafc`](https://github.com/l7aromeo/meocord/commit/f50bafce5bcf04b555a7638fedeb6986cf7ea9d5) Thanks [@l7aromeo](https://github.com/l7aromeo)! - Resolve asset imports to files under `dist` in development builds too. `meocord start --dev` gave
+  `import logo from './logo.png'` the path `/assets/logo.png`, at the root of the filesystem, so a bot
+  reading an imported font or image failed in development while production worked.
+
+- [#32](https://github.com/l7aromeo/meocord/pull/32) [`72b228c`](https://github.com/l7aromeo/meocord/commit/72b228ceaca2dca33ed660aff0ec1bc2aa59bfc2) Thanks [@l7aromeo](https://github.com/l7aromeo)! - Pack only the build platform's native binaries with `bundleDependencies`. Every installed platform
+  package was copied into `dist/node_modules`, and bun installs both the glibc and the musl build on
+  Linux, so a glibc build of a bot using sharp carried about 19 MB of musl binaries it could never
+  load. A package whose `os`, `cpu` or `libc` does not match the platform building is now left out,
+  whichever package manager installed it.
+
 ## 4.0.0-beta.0
 
 ### Major Changes

package/README.md

@@ -53,7 +53,7 @@
 
 ### Prerequisites
 
-- **Runtime**: Node.js 22 or newer, or Bun 1.x+
+- **Runtime**: Node.js 22.13 or newer, or Bun 1.x+
 - **TypeScript**: 5.0+ with `skipLibCheck` enabled, as generated apps have it; 5.8+ with it off
 - **Package manager**: npm, yarn, pnpm, or bun
 - **Peer dependencies**: `discord.js` 14 and `dotenv` 18 — `meocord create` installs both
@@ -1055,7 +1055,7 @@ dist/
 └── meocord.platform.json  (if there are native addons)
 ```
 
-Plain JavaScript dependencies are bundled into `main.js`. **Native addons** — packages that ship a compiled `.node` binary, like `sharp`, canvas bindings or database drivers — cannot be inlined into JavaScript, so MeoCord finds them itself while building, keeps them out of the bundle, and copies each one, with its platform binary and what it needs at runtime, into `dist/node_modules`. There is nothing to list: the build tells you which it packed.
+Plain JavaScript dependencies are bundled into `main.js`. **Native addons** — packages that ship a compiled `.node` binary, like `sharp`, canvas bindings or database drivers — cannot be inlined into JavaScript, so MeoCord finds them itself while building, keeps them out of the bundle, and copies each one, with its platform binary and what it needs at runtime, into `dist/node_modules`. There is nothing to list: the build tells you which it packed. Only binaries for the platform building are copied, going by the `os`, `cpu` and `libc` each platform package declares — so a glibc build carries no musl binaries even where the package manager installed both, as bun does.
 
 ```
 Native addons packed into dist: meo-canvas, sharp

package/dist/cjs/_shared/theme-Dqwlnz0m.cjs

@@ -0,0 +1,124 @@
+'use strict';
+
+var node_util = require('node:util');
+var dayjs = require('dayjs');
+var utc = require('dayjs/plugin/utc.js');
+var timezone = require('dayjs/plugin/timezone.js');
+var path = require('path');
+var fs = require('fs');
+var module$1 = require('module');
+var chalk = require('chalk');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+let cachedConfig;
+let configLoaded = false;
+/**
+ * Loads the configuration a built application runs with: `dist/meocord.config.mjs`, which
+ * `meocord build` compiles from `meocord.config.ts`.
+ *
+ * Reads only the compiled file, which is plain JavaScript and needs no transpiler, tsconfig or
+ * source. Reading `meocord.config.ts` is {@link loadMeoCordSourceConfig}'s job, and it lives in its
+ * own module because it needs jiti: this one is imported by the logger and the factory, so a
+ * bot built with `bundleDependencies` bundles whatever it imports.
+ *
+ * The result is cached after the first load.
+ *
+ * @returns The configuration, or undefined when there is no compiled config or it fails to load.
+ */ function loadMeoCordConfig() {
+    if (configLoaded) return cachedConfig;
+    configLoaded = true;
+    cachedConfig = loadCompiledConfig();
+    return cachedConfig;
+}
+/**
+ * `require` of an ES module, which Node supports cleanly from 22.13 and bun always has.
+ * Synchronous, like the logger and the factory that call it.
+ */ function loadCompiledConfig() {
+    const compiledPath = path.resolve(process.cwd(), 'dist', 'meocord.config.mjs');
+    if (!fs.existsSync(compiledPath)) return undefined;
+    try {
+        // Called through a variable so a bundler does not try to resolve the path while building the
+        // application; the file is only there once the build is done.
+        const load = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('_shared/theme-Dqwlnz0m.cjs', document.baseURI).href)));
+        const loaded = load(compiledPath);
+        return loaded.default ?? loaded;
+    } catch (error) {
+        console.error(`[MeoCord] Failed to load dist/meocord.config.mjs: ${error instanceof Error ? error.message : error}`);
+        return undefined;
+    }
+}
+
+dayjs.extend(utc);
+dayjs.extend(timezone);
+class Logger {
+    log(...args) {
+        this.logWithContext('log', args);
+    }
+    info(...args) {
+        this.logWithContext('log', args);
+    }
+    warn(...args) {
+        this.logWithContext('warn', args);
+    }
+    error(...args) {
+        this.logWithContext('error', args);
+    }
+    debug(...args) {
+        this.logWithContext('debug', args);
+    }
+    verbose(...args) {
+        this.logWithContext('log', args);
+    }
+    formatMessage(message, logType) {
+        if (typeof message === 'object' && message !== null) {
+            return node_util.inspect(message, {
+                showHidden: true,
+                depth: null,
+                colors: true,
+                compact: false,
+                showProxy: true
+            });
+        }
+        return (this.colorMap[logType] || ((msg)=>msg))(message);
+    }
+    logWithContext(logLevel, messages) {
+        if (messages.length === 0) return;
+        const config = loadMeoCordConfig();
+        const logType = logLevel.toUpperCase();
+        const applyColor = this.colorMap[logType] || ((msg)=>msg);
+        const formattedMessages = messages.map((message)=>this.formatMessage(message, logType));
+        const coloredAppName = config?.appName ? applyColor(chalk.bold(`[${config.appName}]`)) : undefined;
+        const timestamp = chalk.bold(dayjs().format('dddd, MMMM D, YYYY HH:mm:ss [UTC]Z'));
+        const coloredLogLevel = applyColor(chalk.bold(`[${logType}]`));
+        const coloredContext = this.context ? chalk.yellow.bold(`[${this.context}]`) : '';
+        const logTexts = [
+            coloredAppName,
+            timestamp,
+            coloredLogLevel,
+            coloredContext,
+            ...formattedMessages
+        ].filter((log)=>!!log);
+        console[logLevel](...logTexts);
+    }
+    constructor(context){
+        this.context = context;
+        this.colorMap = {
+            LOG: chalk.green,
+            INFO: chalk.cyan,
+            WARN: chalk.yellow,
+            ERROR: chalk.red,
+            DEBUG: chalk.magenta
+        };
+    }
+}
+
+class Theme {
+}
+Theme.successColor = '#28A745';
+Theme.infoColor = '#17A2B8';
+Theme.errorColor = '#DC3545';
+Theme.warningColor = '#FFC107';
+
+exports.Logger = Logger;
+exports.Theme = Theme;
+exports.loadMeoCordConfig = loadMeoCordConfig;

package/dist/cjs/common/index.cjs

@@ -1,13 +1,13 @@
 'use strict';
 
-var theme = require('../_shared/theme-BXdSoifk.cjs');
+var theme = require('../_shared/theme-Dqwlnz0m.cjs');
 require('node:util');
 require('dayjs');
 require('dayjs/plugin/utc.js');
 require('dayjs/plugin/timezone.js');
 require('path');
 require('fs');
-require('jiti');
+require('module');
 require('chalk');
 
 /**

package/dist/cjs/core/index.cjs

@@ -3,7 +3,7 @@
 require('reflect-metadata');
 var inversify = require('inversify');
 var discord_js = require('discord.js');
-var theme = require('../_shared/theme-BXdSoifk.cjs');
+var theme = require('../_shared/theme-Dqwlnz0m.cjs');
 var controller_decorator = require('../_shared/controller.decorator-9nIxOp9y.cjs');
 var lodashEs = require('lodash-es');
 var enum_index = require('../enum/index.cjs');
@@ -15,7 +15,7 @@ require('node:util');
 require('dayjs');
 require('dayjs/plugin/utc.js');
 require('dayjs/plugin/timezone.js');
-require('jiti');
+require('module');
 require('chalk');
 
 const createErrorEmbed = (description)=>{
@@ -106,28 +106,30 @@ class MeoCordApp {
         }
         return this.controllerInstancesCache.get(controllerClass);
     }
-    async start() {
-        try {
-            this.logger.log('Starting bot...');
-            this.bot.on('clientReady', ()=>this.runListener('clientReady', async ()=>{
-                    this.activityInterval = setInterval(()=>this.updateActivity(), 10000);
-                    await this.registerCommands();
-                }));
-            this.bot.on('interactionCreate', (interaction)=>this.runListener('interactionCreate', ()=>this.handleInteraction(interaction)));
-            this.bot.on('messageCreate', (message)=>this.runListener('messageCreate', ()=>this.handleMessage(message)));
-            this.bot.on('messageReactionAdd', (reaction, user)=>this.runListener('messageReactionAdd', ()=>this.handleReaction(reaction, {
-                        user,
-                        action: enum_index.ReactionHandlerAction.ADD
-                    })));
-            this.bot.on('messageReactionRemove', (reaction, user)=>this.runListener('messageReactionRemove', ()=>this.handleReaction(reaction, {
-                        user,
-                        action: enum_index.ReactionHandlerAction.REMOVE
-                    })));
-            await this.bot.login(this.discordToken);
-            this.logger.log('Bot is online!');
-        } catch (error) {
-            this.logger.error('Error during bot startup:', error);
-        }
+    /**
+   * Registers the Discord event handlers and logs in.
+   *
+   * Rejects when the login fails -- an invalid token, or Discord unreachable -- so the caller can
+   * stop with a non-zero exit code. A bot that never came online is a failed start, and a
+   * supervisor such as Docker's `restart: on-failure` or systemd can only tell if the process says so.
+   */ async start() {
+        this.logger.log('Starting bot...');
+        this.bot.on('clientReady', ()=>this.runListener('clientReady', async ()=>{
+                this.activityInterval = setInterval(()=>this.updateActivity(), 10000);
+                await this.registerCommands();
+            }));
+        this.bot.on('interactionCreate', (interaction)=>this.runListener('interactionCreate', ()=>this.handleInteraction(interaction)));
+        this.bot.on('messageCreate', (message)=>this.runListener('messageCreate', ()=>this.handleMessage(message)));
+        this.bot.on('messageReactionAdd', (reaction, user)=>this.runListener('messageReactionAdd', ()=>this.handleReaction(reaction, {
+                    user,
+                    action: enum_index.ReactionHandlerAction.ADD
+                })));
+        this.bot.on('messageReactionRemove', (reaction, user)=>this.runListener('messageReactionRemove', ()=>this.handleReaction(reaction, {
+                    user,
+                    action: enum_index.ReactionHandlerAction.REMOVE
+                })));
+        await this.bot.login(this.discordToken);
+        this.logger.log('Bot is online!');
     }
     async registerCommands() {
         // Keyed by type and name together, because that pair is what Discord treats as one
@@ -593,7 +595,7 @@ class MeoCordFactory {
         }
         const meocordConfig = theme.loadMeoCordConfig();
         if (!meocordConfig) {
-            throw new Error('MeoCord config not found. Ensure meocord.config.ts exists.');
+            throw new Error('MeoCord config not found: dist/meocord.config.mjs is missing or failed to load. Run `meocord build`.');
         }
         // Before anything is resolved: a controller or service is what first loads a native addon, and
         // one built for another platform would otherwise fail there with a linker error.

package/dist/esm/bin/app-template/src/main.ts.template

@@ -11,4 +11,8 @@ async function bootstrap() {
   logger.log('Application started')
 }
 
-bootstrap().catch(error => logger.error('Error during startup:', error))
+bootstrap().catch(error => {
+  logger.error('Error during startup:', error)
+  // A bot that never came online is a failed start: exit non-zero, so Docker, systemd or CI see it.
+  process.exitCode = 1
+})

package/dist/esm/bin/app-template/tsconfig.json.template

@@ -25,6 +25,6 @@
     },
     "types": ["node"]
   },
-  "include": ["src/**/*.ts"],
-  "exclude": ["meocord.config.ts", "dist", "vitest.config.ts", "node_modules", "src/**/*.spec.ts"]
+  "include": ["src/**/*.ts", "meocord.config.ts"],
+  "exclude": ["dist", "vitest.config.ts", "node_modules", "src/**/*.spec.ts"]
 }

package/dist/esm/bin/builder-template/controller/message.controller.template

@@ -1,5 +1,5 @@
-import { MessageHandler, Controller, Command } from 'meocord/decorator'
-import { EmbedBuilder, Message } from 'discord.js'
+import { MessageHandler, Controller } from 'meocord/decorator'
+import { Message } from 'discord.js'
 import { Logger } from 'meocord/common'
 
 @Controller()

package/dist/esm/bin/builder-template/controller/reaction.controller.template

@@ -1,7 +1,7 @@
-import { MessageReaction, User } from 'discord.js'
+import { MessageReaction } from 'discord.js'
 import { Controller, ReactionHandler } from 'meocord/decorator'
 import { Logger } from 'meocord/common'
-import { CommandType, ReactionHandlerAction } from 'meocord/enum'
+import { ReactionHandlerAction } from 'meocord/enum'
 import { type ReactionHandlerOptions } from 'meocord/interface'
 
 @Controller()
@@ -10,12 +10,12 @@ export class {{className}}ReactionController {
 
   @ReactionHandler('😋')
   async handleReaction(reaction: MessageReaction, { user, action }: ReactionHandlerOptions) {
-    this.logger.log(`Reaction 😋 ${action === ReactionHandlerAction.ADD ? 'added' : 'removed'}.`);
+    this.logger.log(`Reaction 😋 ${action === ReactionHandlerAction.ADD ? 'added' : 'removed'}.`)
 
-    if (!reaction.message) return;
+    if (!reaction.message) return
 
     if (action === ReactionHandlerAction.ADD) {
-      await reaction.message.reply(`${user.username} reacted with 😋!`);
+      await reaction.message.reply(`${user.username} reacted with 😋!`)
     }
   }
 

package/dist/esm/bin/builder-template/guard.template

@@ -1,10 +1,10 @@
 import { Guard } from 'meocord/decorator'
-import { GuardInterface } from 'meocord/interface'
+import { type GuardInterface } from 'meocord/interface'
 import { BaseInteraction, Message, MessageReaction } from 'discord.js'
 
 @Guard()
 export class {{className}}Guard implements GuardInterface {
-  async canActivate(context: BaseInteraction | Message | MessageReaction): Promise<boolean> {
+  async canActivate(_context: BaseInteraction | Message | MessageReaction): Promise<boolean> {
     // TODO: Implement the guard logic to determine if the interaction is allowed
     return true
   }

package/dist/esm/bin/meocord.js

@@ -23,7 +23,7 @@ import { fileURLToPath } from 'url';
 import { assertNoWebpackHook, createRsbuildConfig, DISCORD_OPTIONAL_NATIVES } from '../build/rsbuild-config.js';
 import { createNativeExternals, nativeCarrier, copyPackagesInto, bundledModuleFiles, assertNoBundledNativeAddons, findBundledNativeAddons } from '../build/native-addons.js';
 import { writePlatformManifest, PLATFORM_MANIFEST } from '../util/platform.util.js';
-import { loadMeoCordSourceConfig } from '../util/meocord-config-loader.util.js';
+import { loadMeoCordSourceConfig } from '../util/meocord-source-config.util.js';
 
 const __filename$1 = fileURLToPath(import.meta.url);
 const __dirname$1 = path.dirname(__filename$1);
@@ -380,8 +380,11 @@ copies or substantial portions of the Software.
             });
             await rsbuild.build();
             this.logger.info('Config compiled to dist/meocord.config.mjs');
-        } catch  {
-            this.logger.warn('Failed to compile meocord.config.ts — runtime will fall back to source config.');
+        } catch (error) {
+            // The built application reads only the compiled config, so without it the bot cannot start.
+            this.logger.error(`Failed to compile meocord.config.ts: ${error instanceof Error ? error.message : error}`);
+            await wait(100);
+            process.exit(1);
         }
     }
     /**

package/dist/esm/build/native-addons.js

@@ -1,5 +1,6 @@
 import { readdirSync, readFileSync, existsSync, cpSync } from 'fs';
 import path from 'path';
+import { currentPlatform } from '../util/platform.util.js';
 
 /**
  * The package a resolved module file belongs to, and the directory it was installed in.
@@ -70,8 +71,9 @@ import path from 'path';
  * Where an optional dependency of the package in `from` was installed, if it was.
  *
  * Nested under the package, beside it (pnpm's layout, and npm's hoisting within a scope), or
- * hoisted to the project root. A platform package that did not match this machine is not
- * installed at all, which is how only the right binary is found.
+ * hoisted to the project root. Being installed does not make it this platform's: some package
+ * managers install platform packages for other C libraries too, so {@link copyPackagesInto} also
+ * checks what each one declares it is built for.
  */ function resolveDependencyDir(name, from, root) {
     const candidates = [
         path.join(from, 'node_modules', name),
@@ -176,28 +178,65 @@ import path from 'path';
         found
     };
 }
+/**
+ * Whether a value passes a package.json `os`, `cpu` or `libc` list, the way npm reads one: a `!`
+ * entry excludes its value, and a list with plain entries admits only those.
+ */ function allowedBy(list, value) {
+    if (!Array.isArray(list) || list.length === 0) return true;
+    const entries = list.filter((entry)=>typeof entry === 'string');
+    if (entries.includes(`!${value}`)) return false;
+    const admitted = entries.filter((entry)=>!entry.startsWith('!'));
+    return admitted.length === 0 || admitted.includes(value);
+}
+/**
+ * Whether an installed package is built for the platform, going by the `os`, `cpu` and `libc` its
+ * package.json declares. A package that declares none of them runs anywhere.
+ *
+ * `libc` is compared only when the build platform's C library is known, so a runtime that cannot
+ * report it keeps the package rather than dropping it on a guess.
+ */ function isBuiltFor(dir, platform) {
+    let pkg;
+    try {
+        pkg = JSON.parse(readFileSync(path.join(dir, 'package.json'), 'utf8'));
+    } catch  {
+        return true;
+    }
+    if (!allowedBy(pkg.os, platform.platform) || !allowedBy(pkg.cpu, platform.arch)) return false;
+    return !platform.libc || allowedBy(pkg.libc, platform.libc);
+}
+/** Whether a path is a package inside a `node_modules` directory, declared for another platform. */ function isOtherPlatformPackage(source, platform) {
+    const parent = path.basename(path.dirname(source));
+    const scopeParent = path.basename(path.dirname(path.dirname(source)));
+    const isPackageDir = parent === 'node_modules' || parent.startsWith('@') && scopeParent === 'node_modules';
+    return isPackageDir && existsSync(path.join(source, 'package.json')) && !isBuiltFor(source, platform);
+}
 /**
  * Copies packages, with everything they need at runtime, into `<outDir>/node_modules`.
  *
  * This is what lets a bundled application run with nothing installed beside it: the packages that
  * could not be bundled travel inside the output directory, where Node finds them by walking up
  * from the bundle. Each package's installed dependencies and optional dependencies are followed --
- * that is where a platform binary lives -- and one not installed for this platform is skipped.
- * Type-only `@types` packages are left behind; some packages list them as runtime dependencies,
- * and they only add weight.
+ * that is where a platform binary lives. A dependency is copied only when its `os`, `cpu` and `libc`
+ * admit the build platform: package managers differ in which of those they filter
+ * installs on -- bun installs both the glibc and the musl build on Linux -- and the output has to
+ * carry only binaries the platform check in `dist` would let load. Type-only `@types` packages are
+ * left behind; some packages list them as runtime dependencies, and they only add weight.
  *
+ * @param platform - What the binaries are for. The platform building, which is what `dist`
+ *   records in its platform manifest.
  * @returns The names copied.
- */ function copyPackagesInto(packages, root, outDir) {
+ */ function copyPackagesInto(packages, root, outDir, platform = currentPlatform()) {
     const copied = new Set();
     const copy = (name, dir)=>{
         if (copied.has(name) || name.startsWith('@types/')) return;
         copied.add(name);
         const target = path.join(outDir, 'node_modules', name);
         // A package's own nested node_modules comes along with it, so only hoisted dependencies
-        // need finding separately.
+        // need finding separately. The nested ones get the same platform check on the way.
         cpSync(dir, target, {
             recursive: true,
-            dereference: true
+            dereference: true,
+            filter: (source)=>source === dir || !isOtherPlatformPackage(source, platform)
         });
         const { dependencies, optional } = readDependencies(dir);
         for (const dependency of [
@@ -206,7 +245,7 @@ import path from 'path';
         ]){
             if (existsSync(path.join(dir, 'node_modules', dependency, 'package.json'))) continue;
             const dependencyDir = resolveDependencyDir(dependency, dir, root);
-            if (dependencyDir) copy(dependency, dependencyDir);
+            if (dependencyDir && isBuiltFor(dependencyDir, platform)) copy(dependency, dependencyDir);
         }
     };
     for (const [name, dir] of packages)copy(name, dir);
@@ -232,4 +271,4 @@ import path from 'path';
     throw new Error(`bundleDependencies bundled ${found.size === 1 ? 'a package that loads' : 'packages that load'} a native addon:\n` + `${lines.join('\n')}\n` + 'A native addon is a compiled binary for one platform and cannot travel inside the bundle. The build ' + 'would run on this machine and fail in production the first time the addon loads. Keep ' + `${found.size === 1 ? 'it' : 'them'} out of the bundle and install ${found.size === 1 ? 'it' : 'them'} ` + `on the server:\n\n  externals: [${names}]`);
 }
 
-export { assertNoBundledNativeAddons, bundledModuleFiles, copyPackagesInto, createNativeExternals, findBundledNativeAddons, nativeCarrier, packageFromPath, packageNameOfRequest };
+export { assertNoBundledNativeAddons, bundledModuleFiles, copyPackagesInto, createNativeExternals, findBundledNativeAddons, isBuiltFor, nativeCarrier, packageFromPath, packageNameOfRequest };

package/dist/esm/build/rsbuild-config.js

@@ -38,7 +38,14 @@ import { prepareModifiedTsConfig } from '../util/tsconfig.util.js';
     const { mode, bundleDependencies = false, externals = [] } = options;
     const cwd = process.cwd();
     const entry = options.entry ?? path.resolve(cwd, 'src', 'main.ts');
+    const assetPrefix = assetPrefixFor(path.resolve(cwd, 'dist'));
     return {
+        // Rsbuild takes the asset prefix from `dev.assetPrefix` in development and from
+        // `output.assetPrefix` in production, and the development default is `/`. Both are set, so an
+        // asset import is the same path on disk in either mode.
+        dev: {
+            assetPrefix
+        },
         source: {
             entry: {
                 main: entry
@@ -108,7 +115,7 @@ import { prepareModifiedTsConfig } from '../util/tsconfig.util.js';
             // What `import image from './x.png'` evaluates to at runtime. A bot passes that string
             // to fs or to a Discord attachment, so it has to be a real path on disk, which Rsbuild's
             // web-oriented default is not.
-            assetPrefix: assetPrefixFor(path.resolve(cwd, 'dist')),
+            assetPrefix,
             // Rsbuild inlines assets under 4 KB as base64 data URIs, so the same import would give a
             // path for a large file and a `data:` string for a small one. A bot reads its assets
             // with fs, where a data URI is ENOENT, so every asset is emitted as a file.

package/dist/esm/core/meocord-factory.js

@@ -35,7 +35,7 @@ class MeoCordFactory {
         }
         const meocordConfig = loadMeoCordConfig();
         if (!meocordConfig) {
-            throw new Error('MeoCord config not found. Ensure meocord.config.ts exists.');
+            throw new Error('MeoCord config not found: dist/meocord.config.mjs is missing or failed to load. Run `meocord build`.');
         }
         // Before anything is resolved: a controller or service is what first loads a native addon, and
         // one built for another platform would otherwise fail there with a linker error.

package/dist/esm/core/meocord.app.js

@@ -88,28 +88,30 @@ class MeoCordApp {
         }
         return this.controllerInstancesCache.get(controllerClass);
     }
-    async start() {
-        try {
-            this.logger.log('Starting bot...');
-            this.bot.on('clientReady', ()=>this.runListener('clientReady', async ()=>{
-                    this.activityInterval = setInterval(()=>this.updateActivity(), 10000);
-                    await this.registerCommands();
-                }));
-            this.bot.on('interactionCreate', (interaction)=>this.runListener('interactionCreate', ()=>this.handleInteraction(interaction)));
-            this.bot.on('messageCreate', (message)=>this.runListener('messageCreate', ()=>this.handleMessage(message)));
-            this.bot.on('messageReactionAdd', (reaction, user)=>this.runListener('messageReactionAdd', ()=>this.handleReaction(reaction, {
-                        user,
-                        action: ReactionHandlerAction.ADD
-                    })));
-            this.bot.on('messageReactionRemove', (reaction, user)=>this.runListener('messageReactionRemove', ()=>this.handleReaction(reaction, {
-                        user,
-                        action: ReactionHandlerAction.REMOVE
-                    })));
-            await this.bot.login(this.discordToken);
-            this.logger.log('Bot is online!');
-        } catch (error) {
-            this.logger.error('Error during bot startup:', error);
-        }
+    /**
+   * Registers the Discord event handlers and logs in.
+   *
+   * Rejects when the login fails -- an invalid token, or Discord unreachable -- so the caller can
+   * stop with a non-zero exit code. A bot that never came online is a failed start, and a
+   * supervisor such as Docker's `restart: on-failure` or systemd can only tell if the process says so.
+   */ async start() {
+        this.logger.log('Starting bot...');
+        this.bot.on('clientReady', ()=>this.runListener('clientReady', async ()=>{
+                this.activityInterval = setInterval(()=>this.updateActivity(), 10000);
+                await this.registerCommands();
+            }));
+        this.bot.on('interactionCreate', (interaction)=>this.runListener('interactionCreate', ()=>this.handleInteraction(interaction)));
+        this.bot.on('messageCreate', (message)=>this.runListener('messageCreate', ()=>this.handleMessage(message)));
+        this.bot.on('messageReactionAdd', (reaction, user)=>this.runListener('messageReactionAdd', ()=>this.handleReaction(reaction, {
+                    user,
+                    action: ReactionHandlerAction.ADD
+                })));
+        this.bot.on('messageReactionRemove', (reaction, user)=>this.runListener('messageReactionRemove', ()=>this.handleReaction(reaction, {
+                    user,
+                    action: ReactionHandlerAction.REMOVE
+                })));
+        await this.bot.login(this.discordToken);
+        this.logger.log('Bot is online!');
     }
     async registerCommands() {
         // Keyed by type and name together, because that pair is what Discord treats as one

package/dist/esm/package.json.js

@@ -1,4 +1,4 @@
-var version = "4.0.0-beta.0";
+var version = "4.0.0-beta.2";
 var packageJson = {
 	version: version};
 

package/dist/esm/util/common.util.js

@@ -1,6 +1,6 @@
 import fs from 'fs';
 import path from 'path';
-import { loadMeoCordConfig } from './meocord-config-loader.util.js';
+import { loadMeoCordCliConfig } from './meocord-source-config.util.js';
 import wait from './wait.util.js';
 import chalk from 'chalk';
 
@@ -47,7 +47,7 @@ import chalk from 'chalk';
         await wait(100);
         process.exit(1);
     }
-    loadMeoCordConfig();
+    loadMeoCordCliConfig();
 }
 /**
  * Ensures a Discord token is configured.
@@ -56,7 +56,7 @@ import chalk from 'chalk';
  * credentials — only connecting to the gateway does. Requiring one to build meant a
  * freshly created application could not be built until a token had been obtained.
  */ async function validateDiscordToken() {
-    if (!loadMeoCordConfig()?.discordToken) {
+    if (!loadMeoCordCliConfig()?.discordToken) {
         console.error(chalk.red('Discord token is missing!'));
         await wait(100);
         process.exit(1);