meocord 3.2.2 → 4.0.0-beta.1

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

@@ -0,0 +1,274 @@
+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.
+ *
+ * Takes the innermost `node_modules` segment, so a nested copy is attributed to itself rather
+ * than to the package it is nested under. Undefined for application code.
+ */ function packageFromPath(file) {
+    // A module identifier can carry loaders before the resource (`loader!/path/to/file`) and a
+    // query after it; only the path itself says where the package lives.
+    const resource = file.slice(file.lastIndexOf('!') + 1).split('?')[0];
+    const segments = resource.split(/[\\/]/);
+    const index = segments.lastIndexOf('node_modules');
+    if (index === -1 || index + 1 >= segments.length) return undefined;
+    const scoped = segments[index + 1].startsWith('@');
+    if (scoped && index + 2 >= segments.length) return undefined;
+    const end = index + (scoped ? 3 : 2);
+    return {
+        name: segments.slice(index + 1, end).join('/'),
+        dir: segments.slice(0, end).join(path.sep)
+    };
+}
+/**
+ * Every source file a build pulled into its output.
+ *
+ * Concatenated modules nest their members, and a multi-environment build nests whole
+ * compilations as children, so both are walked.
+ */ function bundledModuleFiles(stats) {
+    if (!stats) return [];
+    const json = stats.toJson({
+        all: false,
+        modules: true,
+        nestedModules: true,
+        // A production build concatenates most of node_modules into a few modules, and the members
+        // of a concatenation are orphans -- hidden from stats unless asked for. Without this every
+        // concatenated package, sharp included, was invisible here.
+        orphanModules: true,
+        modulesSpace: Infinity,
+        nestedModulesSpace: Infinity
+    });
+    const collect = (modules)=>(modules ?? []).flatMap((module)=>[
+                module.nameForCondition ?? module.identifier ?? '',
+                ...collect(module.modules),
+                // Stats may group modules by path, nesting them under `children`.
+                ...collect(module.children)
+            ]);
+    const compilations = json.children?.length ? json.children : [
+        json
+    ];
+    return compilations.flatMap((compilation)=>collect(compilation.modules)).filter(Boolean);
+}
+/** Whether a directory holds a compiled addon, not counting packages nested inside it. */ function containsNativeBinary(dir, depth = 0) {
+    if (depth > 5) return false;
+    let entries;
+    try {
+        entries = readdirSync(dir, {
+            withFileTypes: true
+        });
+    } catch  {
+        return false;
+    }
+    return entries.some((entry)=>{
+        if (entry.isFile()) return entry.name.endsWith('.node');
+        if (!entry.isDirectory() || entry.name === 'node_modules') return false;
+        return containsNativeBinary(path.join(dir, entry.name), depth + 1);
+    });
+}
+/**
+ * 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. 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),
+        path.join(path.dirname(from), name),
+        path.join(path.dirname(path.dirname(from)), name),
+        path.join(root, 'node_modules', name)
+    ];
+    return candidates.find((dir)=>existsSync(path.join(dir, 'package.json')));
+}
+/** A package's declared dependencies, runtime and optional, or none if it cannot be read. */ function readDependencies(dir) {
+    try {
+        const pkg = JSON.parse(readFileSync(path.join(dir, 'package.json'), 'utf8'));
+        return {
+            dependencies: Object.keys(pkg.dependencies ?? {}),
+            optional: Object.keys(pkg.optionalDependencies ?? {})
+        };
+    } catch  {
+        return {
+            dependencies: [],
+            optional: []
+        };
+    }
+}
+/**
+ * The package holding the compiled addon an installed package loads, or undefined for plain
+ * JavaScript.
+ *
+ * The binary is rarely in the package that gets imported. node-gyp packages keep it in their own
+ * directory, under `build/Release`. napi-rs packages and sharp ship a JavaScript loader and publish
+ * each platform's binary as a separate package, declared as an optional dependency so only the
+ * matching one installs. Both layouts are checked.
+ */ function nativeCarrier(dir, name, root) {
+    if (containsNativeBinary(dir)) return name;
+    return readDependencies(dir).optional.find((dependency)=>{
+        const dependencyDir = resolveDependencyDir(dependency, dir, root);
+        return dependencyDir !== undefined && containsNativeBinary(dependencyDir);
+    });
+}
+/** Bundled packages that load a native addon, mapped to the package holding the binary. */ function findBundledNativeAddons(bundledFiles, root) {
+    const packages = new Map();
+    for (const file of bundledFiles){
+        const found = packageFromPath(file);
+        if (found && !packages.has(found.dir)) packages.set(found.dir, found.name);
+    }
+    const natives = new Map();
+    for (const [dir, name] of packages){
+        if (natives.has(name)) continue;
+        const carrier = nativeCarrier(dir, name, root);
+        if (carrier) natives.set(name, carrier);
+    }
+    return natives;
+}
+/**
+ * The package a bare import request names, or undefined for a relative path, an absolute path, or
+ * a Node builtin -- none of which live in node_modules.
+ */ function packageNameOfRequest(request) {
+    if (!request || request.startsWith('.') || request.startsWith('/') || /^[a-z]+:/i.test(request)) return undefined;
+    if (/^[A-Za-z]:[\\/]/.test(request)) return undefined;
+    const [first, second] = request.split('/');
+    if (!first.startsWith('@')) return first;
+    return second ? `${first}/${second}` : undefined;
+}
+/** Where `name` resolves from `context` the way Node would: the nearest node_modules walking up. */ function resolveInstalledPackage(name, context, root) {
+    let dir = context;
+    for(;;){
+        const candidate = path.join(dir, 'node_modules', name);
+        if (existsSync(path.join(candidate, 'package.json'))) return candidate;
+        const parent = path.dirname(dir);
+        if (parent === dir) break;
+        dir = parent;
+    }
+    const hoisted = path.join(root, 'node_modules', name);
+    return existsSync(path.join(hoisted, 'package.json')) ? hoisted : undefined;
+}
+/**
+ * An Rspack `externals` function that keeps every native addon out of the bundle.
+ *
+ * Decided while the bundler resolves imports, so it sees every request -- including one made by a
+ * plain JavaScript dependency deep in the graph -- and never has to be told what to look for. Each
+ * native package it keeps out is recorded in `found`, so the build can copy it into the output.
+ */ function createNativeExternals(root) {
+    const found = new Map();
+    const plain = new Set();
+    const externals = ({ request, context }, callback)=>{
+        const name = request ? packageNameOfRequest(request) : undefined;
+        if (!name || plain.has(name)) return callback();
+        if (found.has(name)) return callback(undefined, request);
+        const dir = resolveInstalledPackage(name, context ?? root, root);
+        const carrier = dir ? nativeCarrier(dir, name, root) : undefined;
+        if (!dir || !carrier) {
+            plain.add(name);
+            return callback();
+        }
+        found.set(name, {
+            dir,
+            carrier
+        });
+        callback(undefined, request);
+    };
+    return {
+        externals,
+        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. 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, 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. The nested ones get the same platform check on the way.
+        cpSync(dir, target, {
+            recursive: true,
+            dereference: true,
+            filter: (source)=>source === dir || !isOtherPlatformPackage(source, platform)
+        });
+        const { dependencies, optional } = readDependencies(dir);
+        for (const dependency of [
+            ...dependencies,
+            ...optional
+        ]){
+            if (existsSync(path.join(dir, 'node_modules', dependency, 'package.json'))) continue;
+            const dependencyDir = resolveDependencyDir(dependency, dir, root);
+            if (dependencyDir && isBuiltFor(dependencyDir, platform)) copy(dependency, dependencyDir);
+        }
+    };
+    for (const [name, dir] of packages)copy(name, dir);
+    return [
+        ...copied
+    ];
+}
+/**
+ * Refuses a bundled build that swallowed a native addon.
+ *
+ * Such a build does not fail on its own. It succeeds, the bot starts, and on the build machine it
+ * even works, because the bundle resolves the addon back into that machine's node_modules by
+ * absolute path. Anywhere else it fails the first time the addon loads -- often a command, long
+ * after startup. Failing the build is the only point this can be caught.
+ */ function assertNoBundledNativeAddons(found) {
+    if (found.size === 0) return;
+    const lines = [
+        ...found
+    ].map(([bundled, carrier])=>carrier === bundled ? `  - ${bundled}` : `  - ${bundled} (its binary ships in ${carrier})`);
+    const names = [
+        ...found.keys()
+    ].map((name)=>`'${name}'`).join(', ');
+    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, isBuiltFor, nativeCarrier, packageFromPath, packageNameOfRequest };

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

@@ -0,0 +1,176 @@
+import path from 'path';
+import { prepareModifiedTsConfig } from '../util/tsconfig.util.js';
+
+/**
+ * Native accelerators discord.js reaches for at runtime and works without.
+ *
+ * `bufferutil` and `utf-8-validate` are `ws`'s optional peers; `zlib-sync` is loaded by
+ * `@discordjs/ws` without being declared at all, falling back to uncompressed identify when it
+ * is absent. A bundler cannot tell "optional" from "missing", so bundling dependencies failed on
+ * `Can't resolve 'zlib-sync'` for every bot until these were left as runtime imports -- where a
+ * missing one is caught and ignored, exactly as it is when nothing is bundled.
+ *
+ * They are externalised as `node-commonjs` rather than plain names. A plain name in an ESM build
+ * becomes a hoisted top-level `import`, which throws `Cannot find package 'bufferutil'` before the
+ * bot runs a line -- the opposite of the try/catch `ws` wraps around it. `node-commonjs` keeps a
+ * runtime `require` at the original call site, so the library's own fallback still applies.
+ */ const DISCORD_OPTIONAL_NATIVES = [
+    'zlib-sync',
+    'bufferutil',
+    'utf-8-validate'
+];
+/**
+ * The prefix an asset import is joined to at runtime: the output directory, with forward slashes.
+ *
+ * Rspack writes this into the bundle as a string literal without escaping it. A Windows path
+ * came through as `"D:\\a\\meocord\\dist/"` in the source, where `\\a` is a bell character and
+ * the other backslashes vanish -- every asset import evaluated to `D:ameocorddist/assets/...`.
+ * Windows accepts forward slashes everywhere a path is read, so they are used on every platform.
+ */ function assetPrefixFor(distDir) {
+    return `${distDir.replace(/\\/g, '/').replace(/\/+$/, '')}/`;
+}
+/**
+ * The bundler configuration MeoCord builds an application with.
+ *
+ * Built in code rather than read from a config file, so it is typed, testable, and not
+ * something a consumer can edit by accident.
+ */ function createRsbuildConfig(options) {
+    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
+            },
+            // Equivalent to experimentalDecorators. The decorators themselves are only half of
+            // what MeoCord needs -- see tools.swc below for the half that carries the metadata.
+            decorators: {
+                version: 'legacy'
+            },
+            tsconfigPath: prepareModifiedTsConfig()
+        },
+        tools: {
+            swc: {
+                jsc: {
+                    // Rsbuild leaves externalHelpers on, which emits the decorator helpers as imports
+                    // from `@swc/helpers` -- which in turn wants `tslib` resolvable in the application.
+                    // Inlining them keeps the output self-contained, which matters most when
+                    // bundleDependencies is on and there is no node_modules to resolve through.
+                    externalHelpers: false,
+                    transform: {
+                        legacyDecorator: true,
+                        // Inversify resolves constructor arguments from `design:paramtypes`, which swc
+                        // emits only with this on. Without it every @Controller throws while its class is
+                        // being defined. It is deep-merged into builtin:swc-loader rather than replacing
+                        // it, so the rest of Rsbuild's swc defaults still apply.
+                        decoratorMetadata: true
+                    }
+                }
+            }
+        },
+        output: {
+            target: 'node',
+            // Rsbuild 2 already defaults Node builds to ESM; stated so the output format does not
+            // silently change with a future default.
+            module: true,
+            // Inverted deliberately: autoExternal leaves dependencies as runtime imports, so
+            // bundling them means turning it off.
+            autoExternal: !bundleDependencies,
+            externals: [
+                Object.fromEntries(DISCORD_OPTIONAL_NATIVES.map((name)=>[
+                        name,
+                        `node-commonjs ${name}`
+                    ])),
+                ...externals
+            ],
+            // Rsbuild would put the bundle in dist/static/js and assets in dist/static/*. The
+            // application's entry is dist/main.js, which is what `meocord start` runs.
+            distPath: {
+                root: path.resolve(cwd, 'dist'),
+                js: '',
+                image: 'assets',
+                svg: 'assets',
+                font: 'assets',
+                media: 'assets'
+            },
+            // No content hash: a bot reads its assets from disk rather than serving them from a CDN,
+            // so there is no cache to bust, and stable names keep `dist/assets/` predictable. Each
+            // accepts a function too, for applications whose same-named files in different folders
+            // would otherwise collide.
+            filename: {
+                js: '[name].js',
+                image: '[name][ext]',
+                svg: '[name][ext]',
+                font: '[name][ext]',
+                media: '[name][ext]'
+            },
+            // 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,
+            // 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.
+            dataUriLimit: 0,
+            // Rsbuild emits no source maps in production by default, which would leave a crashed
+            // bot's stack trace pointing into the bundle instead of the source.
+            sourceMap: {
+                js: mode === 'production' ? 'source-map' : 'eval-source-map'
+            },
+            // Rsbuild empties dist before building by default. MeoCord runs two builds into the same
+            // directory -- the application, and meocord.config.ts into dist/meocord.config.mjs -- so
+            // cleaning would let whichever runs second erase the other.
+            cleanDistPath: false,
+            minify: {
+                // Off by default for Node targets in Rsbuild 2, so production builds would ship
+                // unminified unless this is stated.
+                js: mode === 'production',
+                jsOptions: {
+                    minimizerOptions: {
+                        // Inversify resolves dependencies by class identity, so a mangled class name
+                        // breaks injection in production while development stays fine.
+                        mangle: {
+                            keep_classnames: true,
+                            keep_fnames: true
+                        },
+                        compress: {
+                            keep_classnames: true,
+                            keep_fnames: true
+                        }
+                    }
+                }
+            }
+        },
+        mode,
+        performance: {
+            // The bot is not served over a network; splitting it only makes startup resolve more files.
+            chunkSplit: {
+                strategy: 'all-in-one'
+            }
+        }
+    };
+}
+/**
+ * Refuses a MeoCord config that declares a `webpack` hook, which MeoCord does not run.
+ *
+ * Without this, such a config builds "successfully" with the customisation silently dropped --
+ * assets landing in the wrong place, markdown imported as a path instead of its text. Refusing
+ * is kinder than a green build that ships something else.
+ *
+ * Read as a property rather than tested with `in`: a config loaded from source comes back as
+ * jiti's interop proxy, where property access reaches the default export but `in` and
+ * Object.keys only see `default` -- so `'webpack' in config` is false even when it is set.
+ */ function assertNoWebpackHook(config) {
+    if (config?.webpack === undefined) return;
+    throw new Error('meocord.config.ts still declares a `webpack` hook, which MeoCord no longer runs. ' + 'Rename it to `rsbuild` and reshape its body for Rsbuild: images, fonts, svg and media ' + 'need no rules any more, `output.filename` accepts a function for custom asset paths, ' + 'and raw rules go through `tools.rspack`. See the 4.0.0 release notes.');
+}
+
+export { DISCORD_OPTIONAL_NATIVES, assertNoWebpackHook, assetPrefixFor, createRsbuildConfig };

package/dist/esm/common/decorator.js

@@ -1,8 +1,4 @@
 /**
- * MeoCord Framework
- * Copyright (c) 2025-present Ukasyah Rahmatullah Zada
- * SPDX-License-Identifier: MIT
- */ /**
  * Composes multiple class or method decorators into a single decorator.
  *
  * @example

package/dist/esm/common/theme.js

@@ -1,8 +1,4 @@
-/**
- * MeoCord Framework
- * Copyright (c) 2025-present Ukasyah Rahmatullah Zada
- * SPDX-License-Identifier: MIT
- */ class Theme {
+class Theme {
 }
 Theme.successColor = '#28A745';
 Theme.infoColor = '#17A2B8';

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

@@ -5,6 +5,7 @@ import { Logger } from '../common/logger.js';
 import '../common/theme.js';
 import { MeoCordApp } from './meocord.app.js';
 import { loadMeoCordConfig } from '../util/meocord-config-loader.util.js';
+import { assertBuiltForThisPlatform } from '../util/platform.util.js';
 import { MetadataKey } from '../enum/metadata-key.enum.js';
 
 /**
@@ -34,8 +35,11 @@ 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.
+        assertBuiltForThisPlatform();
         const container = new Container();
         // Bind the Discord client as a constant value
         const discordClient = new Client(options.clientOptions);

package/dist/esm/enum/controller.enum.js

@@ -1,8 +1,4 @@
-/**
- * MeoCord Framework
- * Copyright (c) 2025-present Ukasyah Rahmatullah Zada
- * SPDX-License-Identifier: MIT
- */ var ControllerType = /*#__PURE__*/ function(ControllerType) {
+var ControllerType = /*#__PURE__*/ function(ControllerType) {
     ControllerType["BUTTON"] = "button";
     ControllerType["MODAL_SUBMIT"] = "modal-submit";
     ControllerType["SELECT_MENU"] = "select-menu";

package/dist/esm/enum/metadata-key.enum.js

@@ -1,8 +1,4 @@
 /**
- * MeoCord Framework
- * Copyright (c) 2025-present Ukasyah Rahmatullah Zada
- * SPDX-License-Identifier: MIT
- */ /**
  * Centralised metadata keys used across the framework's `Reflect` calls.
  *
  * Keeping them here prevents typos, documents the Inversify 8 key rename,

package/dist/esm/package.json.js

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

package/dist/esm/testing/mock-fn.js

@@ -1,8 +1,4 @@
-/**
- * MeoCord Framework
- * Copyright (c) 2025-present Ukasyah Rahmatullah Zada
- * SPDX-License-Identifier: MIT
- */ // ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
 // Framework-agnostic mock function
 //
 // A minimal mock-fn implementation used internally by the testing utilities so

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/generator-cli.util.js

@@ -31,14 +31,15 @@ const logger = new Logger('MeoCord');
  * @throws Will exit the process if the name is undefined, invalid,
  *         or the generated class name is invalid.
  */ function validateAndFormatName(originalName) {
+    // Shared by every generator -- controllers, services and guards -- so the messages name none.
     if (!originalName) {
-        logger.error('Guard name is required.');
+        logger.error('A name is required.');
         process.exit(1);
     }
     const parts = originalName.split('/');
     const fileName = parts.pop();
     if (!fileName) {
-        logger.error('Invalid guard name.');
+        logger.error(`Invalid name: "${originalName}".`);
         process.exit(1);
     }
     const kebabCaseName = kebabCase(fileName);
@@ -46,9 +47,39 @@ const logger = new Logger('MeoCord');
     return {
         parts,
         kebabCaseName,
-        className
+        className,
+        commandName: commandNameFor(parts, kebabCaseName)
     };
 }
+/**
+ * The Discord command name a generated controller registers.
+ *
+ * The whole path, not only its last segment: `admin/ban` becomes `admin-ban`. Files are kept
+ * apart by their directories, but a Discord command name is global to the application, so two
+ * controllers named `ban` in different folders must not both register `ban`.
+ *
+ * @param parts - The folders the name is nested in.
+ * @param kebabCaseName - The name's last segment, already kebab-cased.
+ */ function commandNameFor(parts, kebabCaseName) {
+    return [
+        ...parts.map((part)=>kebabCase(part)),
+        kebabCaseName
+    ].filter(Boolean).join('-');
+}
+/**
+ * Stops a generator before it writes anything, if any file it would write already exists.
+ *
+ * Checked for every file up front rather than one at a time, so a refusal never leaves half a
+ * component behind, and a file the user has edited is never replaced.
+ *
+ * @param filePaths - Absolute paths the generator is about to create.
+ */ function assertFilesAbsent(filePaths) {
+    const existing = filePaths.filter((filePath)=>fs.existsSync(filePath));
+    if (existing.length === 0) return;
+    const names = existing.map((filePath)=>path.relative(process.cwd(), filePath)).join(', ');
+    logger.error(`Refusing to overwrite ${existing.length === 1 ? 'an existing file' : 'existing files'}: ${names}. ` + 'Nothing was generated. Choose another name, or move the existing file first.');
+    process.exit(1);
+}
 /**
  * Ensures that a given directory exists. Creates the directory and any necessary parent directories if they do not exist.
  * @param directory - The absolute path of the directory to create.
@@ -60,17 +91,30 @@ const logger = new Logger('MeoCord');
     }
 }
 /**
- * Writes the provided content to a file and runs ESLint on the file for formatting.
- * @param filePath - The absolute path of the file to create or overwrite.
+ * Writes the provided content to a new file and runs ESLint on the file for formatting.
+ *
+ * Never replaces a file: the write is exclusive, so an existing file is left exactly as it was.
+ * Generators check with {@link assertFilesAbsent} before writing anything; this is the last line
+ * behind that. A failed write sets a non-zero exit code rather than ending with the success status
+ * of a run that produced nothing.
+ *
+ * @param filePath - The absolute path of the file to create.
  * @param content - The content to write to the file.
- * @throws Logs an error if the file creation or ESLint command fails.
  */ function generateFile(filePath, content) {
+    const relative = path.relative(process.cwd(), filePath);
     try {
-        fs.writeFileSync(filePath, content);
-        logger.log(`Created ${path.relative(process.cwd(), filePath)}`);
+        fs.writeFileSync(filePath, content, {
+            flag: 'wx'
+        });
+        logger.log(`Created ${relative}`);
         formatWithLocalESLint(filePath);
     } catch (error) {
-        logger.error(`Failed to create ${filePath}`, error);
+        process.exitCode = 1;
+        if (error?.code === 'EEXIST') {
+            logger.error(`${relative} already exists; left it untouched.`);
+            return;
+        }
+        logger.error(`Failed to create ${relative}`, error);
     }
 }
 /**
@@ -121,4 +165,4 @@ const logger = new Logger('MeoCord');
     return template;
 }
 
-export { buildTemplate, createDirectoryIfNotExists, generateFile, populateTemplate, toClassName, validateAndFormatName };
+export { assertFilesAbsent, buildTemplate, commandNameFor, createDirectoryIfNotExists, generateFile, populateTemplate, toClassName, validateAndFormatName };

package/dist/esm/util/json.util.js

@@ -1,8 +1,4 @@
 /**
- * MeoCord Framework
- * Copyright (c) 2025-present Ukasyah Rahmatullah Zada
- * SPDX-License-Identifier: MIT
- */ /**
  * Helper function to fix common JSON formatting issues in tsconfig.json, such as:
  * - Removing single-line comments.
  * - Removing trailing commas.