meocord 3.2.2 → 4.0.0-beta.0

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

@@ -0,0 +1,169 @@
+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');
+    return {
+        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: assetPrefixFor(path.resolve(cwd, 'dist')),
+            // 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';
 
 /**
@@ -36,6 +37,9 @@ class MeoCordFactory {
         if (!meocordConfig) {
             throw new Error('MeoCord config not found. Ensure meocord.config.ts exists.');
         }
+        // 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.0";
 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/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.

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

@@ -40,7 +40,19 @@ let configLoaded = false;
 /**
  * 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.
- */ function loadSourceConfig() {
+ */ /**
+ * 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 {
@@ -72,4 +84,4 @@ let configLoaded = false;
     }
 }
 
-export { loadMeoCordConfig };
+export { loadMeoCordConfig, loadMeoCordSourceConfig };

package/dist/esm/util/platform.util.js

@@ -0,0 +1,66 @@
+import { writeFileSync, existsSync, readFileSync } from 'fs';
+import path from 'path';
+
+/**
+ * File written beside a bundle that carries native addons, naming the platform it was built for.
+ */ const PLATFORM_MANIFEST = 'meocord.platform.json';
+/** The C library this process runs against, when the runtime can say. */ function detectLibc() {
+    if (process.platform !== 'linux') return undefined;
+    try {
+        const report = process.report?.getReport?.();
+        if (!report?.header) return undefined;
+        return report.header.glibcVersionRuntime ? 'glibc' : 'musl';
+    } catch  {
+        return undefined;
+    }
+}
+/** The platform this process is running on. */ function currentPlatform() {
+    const libc = detectLibc();
+    return {
+        platform: process.platform,
+        arch: process.arch,
+        ...libc && {
+            libc
+        }
+    };
+}
+/** `linux-x64 (glibc)`, `darwin-arm64`. */ function describePlatform({ platform, arch, libc }) {
+    return `${platform}-${arch}${libc ? ` (${libc})` : ''}`;
+}
+/**
+ * Whether native binaries built for one platform can load on another.
+ *
+ * The C library is compared only when both sides are known, so a runtime that cannot report it
+ * is not refused on a guess.
+ */ function isSamePlatform(built, running) {
+    if (built.platform !== running.platform || built.arch !== running.arch) return false;
+    return !built.libc || !running.libc || built.libc === running.libc;
+}
+/** Records the platform a bundle's native addons were built for. */ function writePlatformManifest(distDir) {
+    writeFileSync(path.join(distDir, PLATFORM_MANIFEST), `${JSON.stringify(currentPlatform(), null, 2)}\n`);
+}
+/**
+ * Stops a bundle from starting on a platform its native addons were not built for.
+ *
+ * A binary for the wrong platform does not fail at startup. It fails when something first loads
+ * it -- for an image library, the first command that renders one -- with a dynamic linker error
+ * that names a file rather than the cause. Checking the manifest up front turns that into one
+ * clear message before the bot goes online.
+ *
+ * @param distDir - Directory holding the manifest. Defaults to the directory of the entry script.
+ */ function assertBuiltForThisPlatform(distDir = process.argv[1] ? path.dirname(process.argv[1]) : undefined) {
+    if (!distDir) return;
+    const manifest = path.join(distDir, PLATFORM_MANIFEST);
+    if (!existsSync(manifest)) return;
+    let built;
+    try {
+        built = JSON.parse(readFileSync(manifest, 'utf8'));
+    } catch  {
+        return;
+    }
+    const running = currentPlatform();
+    if (isSamePlatform(built, running)) return;
+    throw new Error(`This build carries native addons compiled for ${describePlatform(built)}, but is running on ` + `${describePlatform(running)}. Compiled binaries only load on the platform they were built for. ` + 'Build on the same platform you deploy to -- for a container, run `meocord build` inside the image.');
+}
+
+export { PLATFORM_MANIFEST, assertBuiltForThisPlatform, currentPlatform, describePlatform, isSamePlatform, writePlatformManifest };

package/dist/esm/util/runtime.util.js

@@ -1,8 +1,4 @@
 /**
- * MeoCord Framework
- * Copyright (c) 2025-present Ukasyah Rahmatullah Zada
- * SPDX-License-Identifier: MIT
- */ /**
  * Environment variable that pins the binary the application is spawned with.
  *
  * An escape hatch for pinning a specific install, or for running the application under a
@@ -61,12 +57,29 @@
  * @param runtime - Binary to run the application with.
  * @param mainJsPath - Absolute path to the built entry file.
  */ function buildAppCommand(runtime, mainJsPath) {
+    // With no node_modules directory in reach, bun installs a missing package from the registry
+    // the moment something imports it. A bot bundled with `bundleDependencies` is deployed exactly
+    // that way, so discord.js probing for its optional `zlib-sync` would download it in production
+    // instead of falling back. Nothing should reach the network at startup that the build did not
+    // put there.
+    const args = isBun(runtime) ? [
+        '--no-install',
+        mainJsPath
+    ] : [
+        mainJsPath
+    ];
     return {
         command: runtime,
-        args: [
-            mainJsPath
-        ]
+        args
     };
 }
+/**
+ * Whether a runtime binary is bun, by the name it was resolved to.
+ *
+ * Split on both separators rather than through path.basename, which only knows the separator
+ * of the platform it runs on.
+ */ function isBun(runtime) {
+    return /^bun(\.exe)?$/i.test(runtime.split(/[\\/]/).pop() ?? '');
+}
 
 export { RUNTIME_OVERRIDE_ENV, buildAppCommand, resolveRuntime };

package/dist/esm/util/tsconfig.util.js

@@ -7,7 +7,7 @@ import { fixJSON } from './json.util.js';
 
 const logger = new Logger();
 /**
- * Prepares and modifies the project's `tsconfig.json` file for usage with tools like Webpack.
+ * Prepares and modifies the project's `tsconfig.json` file for the bundler.
  * - Verifies the existence of `tsconfig.json`.
  * - Fixes invalid JSON if necessary by correcting formatting issues like comments or trailing commas.
  * - Updates paths in `compilerOptions` and other sections to absolute paths.

package/dist/esm/util/wait.util.js

@@ -1,8 +1,4 @@
-/**
- * MeoCord Framework
- * Copyright (c) 2025-present Ukasyah Rahmatullah Zada
- * SPDX-License-Identifier: MIT
- */ function wait(ms) {
+function wait(ms) {
     return new Promise((resolve)=>setTimeout(resolve, ms));
 }
 

package/dist/types/common/index.d.ts

@@ -1,10 +1,5 @@
 import { ColorResolvable } from 'discord.js';
 
-/**
- * MeoCord Framework
- * Copyright (c) 2025-present Ukasyah Rahmatullah Zada
- * SPDX-License-Identifier: MIT
- */
 declare class Logger {
     private context?;
     private readonly colorMap;
@@ -19,12 +14,6 @@ declare class Logger {
     private logWithContext;
 }
 
-/**
- * MeoCord Framework
- * Copyright (c) 2025-present Ukasyah Rahmatullah Zada
- * SPDX-License-Identifier: MIT
- */
-
 declare class Theme {
     static successColor: ColorResolvable;
     static infoColor: ColorResolvable;
@@ -32,11 +21,6 @@ declare class Theme {
     static warningColor: ColorResolvable;
 }
 
-/**
- * MeoCord Framework
- * Copyright (c) 2025-present Ukasyah Rahmatullah Zada
- * SPDX-License-Identifier: MIT
- */
 /**
  * Composes multiple class or method decorators into a single decorator.
  *

package/dist/types/core/index.d.ts

@@ -1,12 +1,6 @@
 import { Container, ServiceIdentifier } from 'inversify';
 import { Client, ActivityOptions } from 'discord.js';
 
-/**
- * MeoCord Framework
- * Copyright (c) 2025-present Ukasyah Rahmatullah Zada
- * SPDX-License-Identifier: MIT
- */
-
 declare class MeoCordApp {
     private readonly controllerClasses;
     private readonly container;
@@ -122,12 +116,6 @@ declare class MeoCordApp {
     private gracefulShutdown;
 }
 
-/**
- * MeoCord Framework
- * Copyright (c) 2025-present Ukasyah Rahmatullah Zada
- * SPDX-License-Identifier: MIT
- */
-
 declare class MeoCordFactory {
     private static logger;
     static create(target: ServiceIdentifier): MeoCordApp;

package/dist/types/decorator/index.d.ts

@@ -2,13 +2,7 @@ import { BuildableCommandType, CommandBuilderBase, CommandBuilderConstructor, Co
 import { AutocompleteInteraction, OmitPartialGroupDMChannel, Message, MessageReaction, PartialMessageReaction, ClientOptions, ActivityOptions } from 'discord.js';
 import { CommandType } from '../enum/index.js';
 import { ServiceIdentifier } from 'inversify';
-import 'webpack';
-
-/**
- * MeoCord Framework
- * Copyright (c) 2025-present Ukasyah Rahmatullah Zada
- * SPDX-License-Identifier: MIT
- */
+import '@rsbuild/core';
 
 /**
  * `@Service()` decorator to mark a class as a service that can be injected into controllers or used as standalone services.
@@ -29,12 +23,6 @@ import 'webpack';
  */
 declare function Service<T>(): (target: new (...args: any[]) => T) => void;
 
-/**
- * MeoCord Framework
- * Copyright (c) 2025-present Ukasyah Rahmatullah Zada
- * SPDX-License-Identifier: MIT
- */
-
 /**
  * This decorator is used to mark a class as a Discord command builder that later can be registered on the `@Command` decorator.
  * It defines the command type using metadata and dynamically makes the class injectable if it isn't already.
@@ -55,12 +43,6 @@ declare function Service<T>(): (target: new (...args: any[]) => T) => void;
  */
 declare function CommandBuilder<T extends BuildableCommandType>(commandType: T): (target: new () => CommandBuilderBase<T>) => void;
 
-/**
- * MeoCord Framework
- * Copyright (c) 2025-present Ukasyah Rahmatullah Zada
- * SPDX-License-Identifier: MIT
- */
-
 /**
  * Decorator to register message handlers in the controller.
  *
@@ -229,12 +211,6 @@ declare function Controller(): (target: any) => void;
  */
 declare function findAmbiguousRoutes(patterns: string[]): [string, string][];
 
-/**
- * MeoCord Framework
- * Copyright (c) 2025-present Ukasyah Rahmatullah Zada
- * SPDX-License-Identifier: MIT
- */
-
 /**
  * `@Guard()` decorator to mark a class as a Guard that later can be added on `@UseGuard` decorator.
  *
@@ -317,12 +293,6 @@ interface GuardWithParams {
  */
 declare function UseGuard(...guards: ((new (...args: any[]) => GuardInterface) | GuardWithParams)[]): any;
 
-/**
- * MeoCord Framework
- * Copyright (c) 2025-present Ukasyah Rahmatullah Zada
- * SPDX-License-Identifier: MIT
- */
-
 /**
  * `@MeoCord()` decorator for declaring the MeoCord application class.
  *

package/dist/types/enum/index.d.ts

@@ -1,10 +1,5 @@
 export { C as CommandType, R as ReactionHandlerAction } from '../controller.enum-DYfhYaat.js';
 
-/**
- * MeoCord Framework
- * Copyright (c) 2025-present Ukasyah Rahmatullah Zada
- * SPDX-License-Identifier: MIT
- */
 /**
  * Centralised metadata keys used across the framework's `Reflect` calls.
  *