meocord 4.0.0-beta.0 → 4.0.0-beta.1

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # meocord
 
+## 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)=>{
@@ -593,7 +593,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/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/package.json.js

@@ -1,4 +1,4 @@
-var version = "4.0.0-beta.0";
+var version = "4.0.0-beta.1";
 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);

package/dist/esm/util/meocord-config-loader.util.js

@@ -1,87 +1,43 @@
 import path from 'path';
-import { existsSync, readFileSync } from 'fs';
-import { createJiti } from 'jiti';
-import { fixJSON } from './json.util.js';
+import { existsSync } from 'fs';
+import { createRequire } from 'module';
 
 let cachedConfig;
 let configLoaded = false;
 /**
- * Loads the MeoCord configuration, checking compiled output first then falling back to source.
+ * Loads the configuration a built application runs with: `dist/meocord.config.mjs`, which
+ * `meocord build` compiles from `meocord.config.ts`.
  *
- * Resolution order:
- * 1. `dist/meocord.config.mjs` — pre-compiled by `meocord build`, no tsconfig or source files needed
- * 2. `meocord.config.ts` — loaded via jiti with tsconfig path aliases (dev mode)
+ * 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 successful load.
+ * The result is cached after the first load.
  *
- * @returns {MeoCordConfig | undefined} The loaded configuration object, or undefined if loading fails.
+ * @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() ?? loadSourceConfig();
+    cachedConfig = loadCompiledConfig();
     return cachedConfig;
 }
 /**
- * Loads the pre-compiled config from dist/meocord.config.mjs.
- * This file is generated by `meocord build` and requires no tsconfig or source files.
+ * `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 (!existsSync(compiledPath)) return undefined;
     try {
-        const jiti = createJiti(import.meta.url, {
-            interopDefault: true
-        });
-        return jiti(compiledPath);
-    } catch  {
-        // Fall through to source config
-        return undefined;
-    }
-}
-/**
- * Loads the source config from meocord.config.ts via jiti with tsconfig path alias resolution.
- * Used in development mode where source files and tsconfig.json are available.
- */ /**
- * Loads meocord.config.ts from source, every time, for configuring a build.
- *
- * {@link loadMeoCordConfig} prefers the compiled `dist/meocord.config.mjs` and caches the result,
- * which is right at runtime -- production has no source -- and wrong while building. The compiled
- * file is the previous build's output, so a build that read it ran on the config as it was last
- * time: an edit to `meocord.config.ts` took effect only on the build after next. Whatever read the
- * config first in the process also fixed it for the rest, so the watcher's reload on a config
- * change reloaded nothing. Build time always has the source, so it reads the source.
- */ function loadMeoCordSourceConfig() {
-    return loadSourceConfig();
-}
-function loadSourceConfig() {
-    const configPath = path.resolve(process.cwd(), 'meocord.config.ts');
-    if (!existsSync(configPath)) return undefined;
-    try {
-        const tsConfigPath = path.resolve(process.cwd(), 'tsconfig.json');
-        const aliases = {};
-        if (existsSync(tsConfigPath)) {
-            const tsConfig = JSON.parse(fixJSON(readFileSync(tsConfigPath, 'utf-8')));
-            const paths = tsConfig?.compilerOptions?.paths;
-            if (paths) {
-                for (const [key, values] of Object.entries(paths)){
-                    const aliasKey = key.replace('/*', '');
-                    aliases[aliasKey] = path.resolve(process.cwd(), values[0].replace('/*', ''));
-                }
-            }
-        }
-        const jiti = createJiti(import.meta.url, {
-            interopDefault: true,
-            alias: aliases,
-            moduleCache: false
-        });
-        return jiti(configPath);
+        // 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 = createRequire(import.meta.url);
+        const loaded = load(compiledPath);
+        return loaded.default ?? loaded;
     } catch (error) {
-        if (error instanceof Error) {
-            console.error(`[MeoCord] Failed to load config: ${error.message}`);
-        } else {
-            console.error(`[MeoCord] Failed to load config: Unknown error`);
-        }
+        console.error(`[MeoCord] Failed to load dist/meocord.config.mjs: ${error instanceof Error ? error.message : error}`);
         return undefined;
     }
 }
 
-export { loadMeoCordConfig, loadMeoCordSourceConfig };
+export { loadMeoCordConfig };

package/dist/esm/util/meocord-source-config.util.js

@@ -0,0 +1,55 @@
+import path from 'path';
+import { existsSync, readFileSync } from 'fs';
+import { createJiti } from 'jiti';
+import { fixJSON } from './json.util.js';
+import { loadMeoCordConfig } from './meocord-config-loader.util.js';
+
+/**
+ * Loads meocord.config.ts from source, every time, for configuring a build.
+ *
+ * {@link loadMeoCordConfig} reads the compiled `dist/meocord.config.mjs` and caches the result,
+ * which is right at runtime -- production has no source -- and wrong while building. The compiled
+ * file is the previous build's output, so a build that read it would run on the config as it was
+ * last time, and the watcher's reload on a config change would reload nothing. Build time always
+ * has the source, so it reads the source.
+ *
+ * Only the CLI imports this module. It needs jiti to run TypeScript, and a bot has no use for jiti.
+ */ function loadMeoCordSourceConfig() {
+    const configPath = path.resolve(process.cwd(), 'meocord.config.ts');
+    if (!existsSync(configPath)) return undefined;
+    try {
+        const tsConfigPath = path.resolve(process.cwd(), 'tsconfig.json');
+        const aliases = {};
+        if (existsSync(tsConfigPath)) {
+            const tsConfig = JSON.parse(fixJSON(readFileSync(tsConfigPath, 'utf-8')));
+            const paths = tsConfig?.compilerOptions?.paths;
+            if (paths) {
+                for (const [key, values] of Object.entries(paths)){
+                    const aliasKey = key.replace('/*', '');
+                    aliases[aliasKey] = path.resolve(process.cwd(), values[0].replace('/*', ''));
+                }
+            }
+        }
+        const jiti = createJiti(import.meta.url, {
+            interopDefault: true,
+            alias: aliases,
+            moduleCache: false
+        });
+        return jiti(configPath);
+    } catch (error) {
+        if (error instanceof Error) {
+            console.error(`[MeoCord] Failed to load config: ${error.message}`);
+        } else {
+            console.error(`[MeoCord] Failed to load config: Unknown error`);
+        }
+        return undefined;
+    }
+}
+/**
+ * The configuration as the CLI sees it: the compiled config when a build has produced one, and the
+ * source otherwise -- `meocord start` checks the token before anything has been built.
+ */ function loadMeoCordCliConfig() {
+    return loadMeoCordConfig() ?? loadMeoCordSourceConfig();
+}
+
+export { loadMeoCordCliConfig, loadMeoCordSourceConfig };

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "meocord",
   "description": "Decorator-based Discord bot framework built on discord.js. Brings NestJS-style controllers, dependency injection, guards, and testing utilities to bot development — with a full CLI and TypeScript-first design.",
-  "version": "4.0.0-beta.0",
+  "version": "4.0.0-beta.1",
   "type": "module",
   "engines": {
-    "node": ">=22"
+    "node": ">=22.13"
   },
   "scripts": {
     "format": "prettier --write \"**/*.md\" \"src/bin/app-template/**/*.template\"",

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

@@ -1,168 +0,0 @@
-'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 jiti = require('jiti');
-var chalk = require('chalk');
-
-var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
-/**
- * Helper function to fix common JSON formatting issues in tsconfig.json, such as:
- * - Removing single-line comments.
- * - Removing trailing commas.
- * - Stripping newlines.
- *
- * @param {string} jsonString - The raw JSON string to fix.
- * @returns {string} The corrected JSON string.
- */ function fixJSON(jsonString) {
-    return jsonString.replace(/\/\/.*$/gm, '') // Remove single-line comments
-    .replace(/,(\s*[}\]])/g, '$1') // Remove trailing commas before } or ]
-    .replace(/,\s*$/, '') // Remove trailing commas at the end of the file
-    .replace(/^\s*[\r\n]/gm, '') // Replace empty lines only
-    ;
-}
-
-let cachedConfig;
-let configLoaded = false;
-/**
- * Loads the MeoCord configuration, checking compiled output first then falling back to source.
- *
- * Resolution order:
- * 1. `dist/meocord.config.mjs` — pre-compiled by `meocord build`, no tsconfig or source files needed
- * 2. `meocord.config.ts` — loaded via jiti with tsconfig path aliases (dev mode)
- *
- * The result is cached after the first successful load.
- *
- * @returns {MeoCordConfig | undefined} The loaded configuration object, or undefined if loading fails.
- */ function loadMeoCordConfig() {
-    if (configLoaded) return cachedConfig;
-    configLoaded = true;
-    cachedConfig = loadCompiledConfig() ?? loadSourceConfig();
-    return cachedConfig;
-}
-/**
- * Loads the pre-compiled config from dist/meocord.config.mjs.
- * This file is generated by `meocord build` and requires no tsconfig or source files.
- */ function loadCompiledConfig() {
-    const compiledPath = path.resolve(process.cwd(), 'dist', 'meocord.config.mjs');
-    if (!fs.existsSync(compiledPath)) return undefined;
-    try {
-        const jiti$1 = jiti.createJiti((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('_shared/theme-BXdSoifk.cjs', document.baseURI).href)), {
-            interopDefault: true
-        });
-        return jiti$1(compiledPath);
-    } catch  {
-        // Fall through to source config
-        return undefined;
-    }
-}
-function loadSourceConfig() {
-    const configPath = path.resolve(process.cwd(), 'meocord.config.ts');
-    if (!fs.existsSync(configPath)) return undefined;
-    try {
-        const tsConfigPath = path.resolve(process.cwd(), 'tsconfig.json');
-        const aliases = {};
-        if (fs.existsSync(tsConfigPath)) {
-            const tsConfig = JSON.parse(fixJSON(fs.readFileSync(tsConfigPath, 'utf-8')));
-            const paths = tsConfig?.compilerOptions?.paths;
-            if (paths) {
-                for (const [key, values] of Object.entries(paths)){
-                    const aliasKey = key.replace('/*', '');
-                    aliases[aliasKey] = path.resolve(process.cwd(), values[0].replace('/*', ''));
-                }
-            }
-        }
-        const jiti$1 = jiti.createJiti((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('_shared/theme-BXdSoifk.cjs', document.baseURI).href)), {
-            interopDefault: true,
-            alias: aliases,
-            moduleCache: false
-        });
-        return jiti$1(configPath);
-    } catch (error) {
-        if (error instanceof Error) {
-            console.error(`[MeoCord] Failed to load config: ${error.message}`);
-        } else {
-            console.error(`[MeoCord] Failed to load config: Unknown 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;