@seedcord/cli 0.0.1 → 0.1.0-next.0

package/dist/index.mjs

@@ -1,718 +1,3 @@
-import { createRequire } from 'node:module';
-import { SeedcordError, SeedcordErrorCode, isSeedcordError } from '@seedcord/services';
-import { dirname, resolve, isAbsolute, relative, join, extname, basename } from 'path';
-import { existsSync } from 'fs';
-import { pathToFileURL } from 'url';
-import { createJiti } from 'jiti';
-import { tsImport } from 'tsx/esm/api';
-import { mkdir, writeFile, readdir, readFile } from 'fs/promises';
-import { build } from 'tsup';
-import ts2 from 'typescript';
+import { n as SEEDCORD_CONFIG_FILENAMES, r as defineConfig, t as version } from "./src-CCX-T6t_.mjs";
 
-createRequire(import.meta.url);
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
-// src/utils/resolveDefaultExport.ts
-function resolveDefaultExport(moduleExport) {
-  let current = moduleExport;
-  const visited = /* @__PURE__ */ new Set();
-  while (isObjectWithDefault(current) && !visited.has(current)) {
-    visited.add(current);
-    current = current.default;
-  }
-  return current;
-}
-__name(resolveDefaultExport, "resolveDefaultExport");
-function isObjectWithDefault(value) {
-  return Boolean(value && typeof value === "object" && "default" in value);
-}
-__name(isObjectWithDefault, "isObjectWithDefault");
-
-// src/runtime/SeedcordInstanceLoader.ts
-var SeedcordInstanceLoader = class {
-  static {
-    __name(this, "SeedcordInstanceLoader");
-  }
-  modules;
-  logger;
-  constructor(modules, logger) {
-    this.modules = modules;
-    this.logger = logger;
-  }
-  async load(instancePath) {
-    const loadedModule = await this.modules.importModule(instancePath);
-    const exported = resolveDefaultExport(loadedModule);
-    const instance = await Promise.resolve(exported);
-    if (!this.isSeedcordLike(instance)) {
-      throw new SeedcordError(SeedcordErrorCode.CliInstanceInvalid);
-    }
-    this.logger.info(`Loaded Seedcord instance from ${instancePath}`);
-    return instance;
-  }
-  isSeedcordLike(candidate) {
-    return Boolean(candidate) && typeof candidate.start === "function";
-  }
-};
-var ConfigLoader = class {
-  static {
-    __name(this, "ConfigLoader");
-  }
-  modules;
-  logger;
-  constructor(modules, logger) {
-    this.modules = modules;
-    this.logger = logger;
-  }
-  async load(configPath) {
-    const loadedModule = await this.modules.importModule(configPath);
-    const rawExport = resolveDefaultExport(loadedModule);
-    const config = await this.unwrapConfig(rawExport);
-    const configDir = dirname(configPath);
-    const root = resolve(configDir, config.root ?? ".");
-    const instance = this.resolveWithinRoot(root, config.instance);
-    const entry = this.resolveWithinRoot(root, config.entry);
-    this.assertEntryWithinRoot(root, entry);
-    const build = this.resolveBuildOptions(configDir, config.build);
-    this.logger.info(`Loaded configuration from ${configPath}`);
-    this.logger.debug(`Resolved root: ${root}`);
-    this.logger.debug(`Resolved instance: ${instance}`);
-    this.logger.debug(`Resolved entry: ${entry}`);
-    this.logger.debug(`Resolved build outDir: ${build.outDir}`);
-    if (build.tsconfig) this.logger.debug(`Resolved build tsconfig: ${build.tsconfig}`);
-    this.logger.debug(`Resolved bootstrap: ${build.bootstrap}`);
-    return {
-      instance,
-      root,
-      configFile: configPath,
-      entry,
-      build
-    };
-  }
-  // eslint-disable-next-line complexity
-  async unwrapConfig(raw) {
-    const resolved = await Promise.resolve(raw);
-    if (!resolved || typeof resolved !== "object") {
-      throw new SeedcordError(SeedcordErrorCode.CliConfigInvalidExport);
-    }
-    const cfg = resolved;
-    if (!cfg.instance || typeof cfg.instance !== "string") {
-      throw new SeedcordError(SeedcordErrorCode.CliConfigMissingInstance);
-    }
-    if (!cfg.entry || typeof cfg.entry !== "string") {
-      throw new SeedcordError(SeedcordErrorCode.CliConfigMissingEntry);
-    }
-    if (typeof cfg.root !== "undefined" && typeof cfg.root !== "string") {
-      throw new SeedcordError(SeedcordErrorCode.CliConfigInvalidRoot);
-    }
-    if (typeof cfg.build !== "undefined" && typeof cfg.build !== "object") {
-      throw new SeedcordError(SeedcordErrorCode.CliConfigInvalidBuild);
-    }
-    if (cfg.build) {
-      const { outDir, tsconfig, bootstrap } = cfg.build;
-      if (typeof outDir !== "undefined" && typeof outDir !== "string") {
-        throw new SeedcordError(SeedcordErrorCode.CliConfigInvalidBuildOutDir);
-      }
-      if (typeof tsconfig !== "undefined" && typeof tsconfig !== "string") {
-        throw new SeedcordError(SeedcordErrorCode.CliConfigInvalidBuildTsconfig);
-      }
-      if (typeof bootstrap !== "undefined" && typeof bootstrap !== "string") {
-        throw new SeedcordError(SeedcordErrorCode.CliConfigInvalidBuildBootstrap);
-      }
-    }
-    const normalized = {
-      instance: cfg.instance,
-      entry: cfg.entry
-    };
-    if (typeof cfg.root === "string") normalized.root = cfg.root;
-    if (cfg.build) normalized.build = cfg.build;
-    return normalized;
-  }
-  resolveWithinRoot(root, target) {
-    if (isAbsolute(target)) return target;
-    return resolve(root, target);
-  }
-  assertEntryWithinRoot(root, entry) {
-    const relativePath = relative(root, entry);
-    if (relativePath.startsWith("..") || isAbsolute(relativePath)) {
-      throw new SeedcordError(SeedcordErrorCode.CliConfigEntryOutsideRoot, [
-        entry,
-        root
-      ]);
-    }
-  }
-  resolveBuildOptions(configDir, build) {
-    const outDir = resolve(configDir, build?.outDir ?? "dist");
-    const bootstrapValue = build?.bootstrap;
-    const bootstrap = bootstrapValue ? this.resolveBootstrap(outDir, bootstrapValue) : resolve(outDir, "index.mjs");
-    const tsconfig = build?.tsconfig ? resolve(configDir, build.tsconfig) : void 0;
-    const resolvedBuild = tsconfig ? {
-      outDir,
-      bootstrap,
-      tsconfig
-    } : {
-      outDir,
-      bootstrap
-    };
-    return resolvedBuild;
-  }
-  resolveBootstrap(outDir, bootstrap) {
-    if (isAbsolute(bootstrap)) return bootstrap;
-    return resolve(outDir, bootstrap);
-  }
-};
-
-// src/config/schema.ts
-var SEEDCORD_CONFIG_FILENAMES = [
-  "seedcord.config.ts",
-  "seedcord.config.mts"
-];
-function defineConfig(config) {
-  return config;
-}
-__name(defineConfig, "defineConfig");
-
-// src/config/ConfigLocator.ts
-var ConfigLocator = class {
-  static {
-    __name(this, "ConfigLocator");
-  }
-  logger;
-  constructor(logger) {
-    this.logger = logger;
-  }
-  locate(baseDir = process.cwd()) {
-    const normalizedBase = resolve(baseDir);
-    for (const candidate of SEEDCORD_CONFIG_FILENAMES) {
-      const fullPath = join(normalizedBase, candidate);
-      if (existsSync(fullPath)) {
-        this.logger.debug(`Found config at ${fullPath}`);
-        return fullPath;
-      }
-    }
-    throw new SeedcordError(SeedcordErrorCode.CliConfigNotFound, [
-      normalizedBase,
-      SEEDCORD_CONFIG_FILENAMES
-    ]);
-  }
-};
-var TS_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".ts",
-  ".tsx",
-  ".mts",
-  ".cts"
-]);
-var RuntimeModuleLoader = class {
-  static {
-    __name(this, "RuntimeModuleLoader");
-  }
-  options;
-  jiti = createJiti(import.meta.url, {
-    cache: false,
-    interopDefault: true,
-    extensions: [
-      ".ts",
-      ".tsx",
-      ".mts",
-      ".cts",
-      ".js",
-      ".mjs",
-      ".cjs"
-    ]
-  });
-  constructor(options = {}) {
-    this.options = options;
-  }
-  async importModule(entryPath) {
-    const normalized = resolve(entryPath);
-    if (!existsSync(normalized)) {
-      throw new SeedcordError(SeedcordErrorCode.CliEntryNotFound, [
-        normalized
-      ]);
-    }
-    if (this.shouldUseTsx(normalized)) {
-      return this.importWithTsx(normalized);
-    }
-    return this.importWithNode(normalized);
-  }
-  shouldUseTsx(filePath) {
-    if (this.options.forceTsx) return true;
-    return TS_EXTENSIONS.has(extname(filePath).toLowerCase());
-  }
-  async importWithTsx(entryPath) {
-    const specifier = pathToFileURL(entryPath).href;
-    const tsconfig = this.resolveTsconfig(entryPath);
-    try {
-      return await tsImport(specifier, {
-        parentURL: import.meta.url,
-        tsconfig
-      });
-    } catch (error) {
-      const reason = error instanceof Error ? error.message : "Unknown tsx error";
-      throw new SeedcordError(SeedcordErrorCode.CliTsxImportFailed, [
-        entryPath,
-        reason
-      ]);
-    }
-  }
-  async importWithNode(entryPath) {
-    const specifier = pathToFileURL(entryPath).href;
-    try {
-      return await import(specifier);
-    } catch (nativeError) {
-      try {
-        return await this.jiti.import(entryPath);
-      } catch (fallbackError) {
-        const nativeReason = nativeError instanceof Error ? nativeError.message : "Unknown ESM import error";
-        const fallbackReason = fallbackError instanceof Error ? fallbackError.message : "Unknown jiti error";
-        throw new SeedcordError(SeedcordErrorCode.CliImportFailed, [
-          entryPath,
-          nativeReason,
-          fallbackReason
-        ]);
-      }
-    }
-  }
-  resolveTsconfig(entryPath) {
-    if (typeof this.options.tsconfig !== "undefined") {
-      return this.options.tsconfig;
-    }
-    return this.findNearestTsconfig(dirname(entryPath)) ?? false;
-  }
-  findNearestTsconfig(startDir) {
-    const candidate = resolve(startDir, "tsconfig.json");
-    if (existsSync(candidate)) return candidate;
-    const parent = dirname(startDir);
-    if (parent === startDir) return void 0;
-    return this.findNearestTsconfig(parent);
-  }
-};
-
-// src/runtime/SeedcordDevRunner.ts
-var SeedcordDevSession = class SeedcordDevSession2 {
-  static {
-    __name(this, "SeedcordDevSession");
-  }
-  config;
-  instanceLoader;
-  logger;
-  constructor(config, instanceLoader, logger) {
-    this.config = config;
-    this.instanceLoader = instanceLoader;
-    this.logger = logger;
-  }
-  async start() {
-    const instance = await this.instanceLoader.load(this.config.instance);
-    try {
-      this.logger.info("Starting Seedcord instance...");
-      await instance.start();
-      this.logger.info("Seedcord is running.");
-    } catch (error) {
-      const reason = error instanceof Error ? error.message : "Unknown error";
-      throw new SeedcordError(SeedcordErrorCode.CliStartFailed, [
-        this.config.instance,
-        reason
-      ]);
-    }
-  }
-};
-var SeedcordDevRunner = class _SeedcordDevRunner {
-  static {
-    __name(this, "SeedcordDevRunner");
-  }
-  locator;
-  configLoader;
-  instanceLoader;
-  logger;
-  constructor(locator, configLoader, instanceLoader, logger) {
-    this.locator = locator;
-    this.configLoader = configLoader;
-    this.instanceLoader = instanceLoader;
-    this.logger = logger;
-  }
-  static create(logger) {
-    const moduleLoader = new RuntimeModuleLoader();
-    const locator = new ConfigLocator(logger);
-    const configLoader = new ConfigLoader(moduleLoader, logger);
-    const instanceLoader = new SeedcordInstanceLoader(moduleLoader, logger);
-    return new _SeedcordDevRunner(locator, configLoader, instanceLoader, logger);
-  }
-  async run() {
-    const config = await this.loadConfig();
-    const session = new SeedcordDevSession(config, this.instanceLoader, this.logger);
-    await session.start();
-  }
-  async loadConfig() {
-    const configPath = this.locator.locate();
-    return this.configLoader.load(configPath);
-  }
-};
-
-// src/commands/DevCommand.ts
-var DevCommand = class _DevCommand {
-  static {
-    __name(this, "DevCommand");
-  }
-  runner;
-  logger;
-  constructor(runner, logger) {
-    this.runner = runner;
-    this.logger = logger;
-  }
-  register(program) {
-    program.command("dev").description("Run a Seedcord instance from seedcord.config.ts").action(async () => {
-      try {
-        await this.runner.run();
-      } catch (error) {
-        this.logger.error("Seedcord dev failed", error);
-        if (isSeedcordError(error)) process.exitCode = 1;
-        else process.exit(1);
-      }
-    });
-  }
-  static create(logger) {
-    return new _DevCommand(SeedcordDevRunner.create(logger), logger);
-  }
-};
-var BootstrapWriter = class {
-  static {
-    __name(this, "BootstrapWriter");
-  }
-  logger;
-  constructor(logger) {
-    this.logger = logger;
-  }
-  async write(config, emittedEntry) {
-    const target = config.build.bootstrap;
-    const relativeImport = this.formatImportPath(relative(dirname(target), emittedEntry));
-    const contents = `import '${relativeImport}';
-`;
-    try {
-      await mkdir(dirname(target), {
-        recursive: true
-      });
-      await writeFile(target, contents, "utf8");
-    } catch (error) {
-      const reason = error instanceof Error ? error.message : "Unknown error";
-      throw new SeedcordError(SeedcordErrorCode.CliBootstrapWriteFailed, [
-        target,
-        reason
-      ]);
-    }
-    this.logger.info(`Bootstrap file created at ${target}`);
-  }
-  formatImportPath(fragment) {
-    let normalized = fragment.replace(/\\/g, "/");
-    if (!normalized.startsWith(".")) normalized = `./${normalized}`;
-    return normalized;
-  }
-};
-var EntryPointCollector = class {
-  static {
-    __name(this, "EntryPointCollector");
-  }
-  collect(config, tsconfigPath) {
-    const parsed = this.parseTsconfig(tsconfigPath);
-    const entries = /* @__PURE__ */ new Map();
-    for (const filePath of parsed.fileNames) {
-      if (!this.shouldEmitFile(config, filePath)) continue;
-      entries.set(this.createEntryKey(config, filePath), filePath);
-    }
-    const entryKey = this.createEntryKey(config, config.entry);
-    if (!entries.size || !entries.has(entryKey)) entries.set(entryKey, config.entry);
-    return {
-      entryMap: Object.fromEntries(entries),
-      primaryKey: entryKey
-    };
-  }
-  parseTsconfig(tsconfigPath) {
-    const configFile = ts2.readConfigFile(tsconfigPath, (filePath) => ts2.sys.readFile(filePath));
-    if (configFile.error) {
-      const reason = this.formatDiagnostics([
-        configFile.error
-      ]);
-      throw new SeedcordError(SeedcordErrorCode.CliBuildTsconfigInvalid, [
-        tsconfigPath,
-        reason
-      ]);
-    }
-    const parsed = ts2.parseJsonConfigFileContent(configFile.config, ts2.sys, dirname(tsconfigPath), void 0, tsconfigPath);
-    if (parsed.errors.length) {
-      const reason = this.formatDiagnostics(parsed.errors);
-      throw new SeedcordError(SeedcordErrorCode.CliBuildTsconfigInvalid, [
-        tsconfigPath,
-        reason
-      ]);
-    }
-    return parsed;
-  }
-  shouldEmitFile(config, filePath) {
-    if (!this.isWithinRoot(config.root, filePath)) return false;
-    if (/\.d\.[cm]?ts$/i.test(filePath)) return false;
-    return /\.[cm]?tsx?$/i.test(filePath);
-  }
-  isWithinRoot(root, target) {
-    const relativePath = relative(root, target);
-    return relativePath === "" || !relativePath.startsWith("..") && !relativePath.startsWith("..\\");
-  }
-  createEntryKey(config, filePath) {
-    const relativePath = relative(config.root, filePath);
-    const fallback = this.createEntryFallback(filePath);
-    if (relativePath.startsWith("..")) return fallback;
-    const sanitized = relativePath.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\.[^.]+$/, "").replace(/[^a-zA-Z0-9\-/_]/g, "-");
-    return sanitized || fallback;
-  }
-  createEntryFallback(filePath) {
-    const base = basename(filePath, extname(filePath)) || "seedcord-entry";
-    return base.replace(/[^a-zA-Z0-9-_]/g, "-");
-  }
-  formatDiagnostics(diagnostics) {
-    return diagnostics.map((diagnostic) => {
-      const message = ts2.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
-      if (diagnostic.file && typeof diagnostic.start === "number") {
-        const { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
-        return `${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`;
-      }
-      return message;
-    }).join("\n");
-  }
-};
-var RelativeSpecifierTransformer = class {
-  static {
-    __name(this, "RelativeSpecifierTransformer");
-  }
-  async transform(outDir) {
-    const files = await this.collectJavaScriptFiles(outDir);
-    for (const filePath of files) {
-      await this.rewriteFile(filePath);
-    }
-  }
-  async collectJavaScriptFiles(rootDir) {
-    const pending = [
-      rootDir
-    ];
-    const files = [];
-    while (pending.length) {
-      const current = pending.pop();
-      if (!current) continue;
-      const entries = await readdir(current, {
-        withFileTypes: true
-      });
-      for (const entry of entries) {
-        const fullPath = resolve(current, entry.name);
-        if (entry.isDirectory()) pending.push(fullPath);
-        else if (entry.isFile() && entry.name.endsWith(".js")) files.push(fullPath);
-      }
-    }
-    return files;
-  }
-  async rewriteFile(filePath) {
-    const source = await readFile(filePath, "utf8");
-    const replacements = this.extractSpecifierReplacements(source);
-    if (!replacements.length) return;
-    let mutated = source;
-    for (const replacement of replacements.sort((a, b) => b.start - a.start)) {
-      mutated = `${mutated.slice(0, replacement.start)}${replacement.text}${mutated.slice(replacement.end)}`;
-    }
-    await writeFile(filePath, mutated, "utf8");
-  }
-  extractSpecifierReplacements(sourceText) {
-    const sourceFile = ts2.createSourceFile("generated.js", sourceText, ts2.ScriptTarget.ES2022, true, ts2.ScriptKind.JS);
-    const replacements = [];
-    const visit = /* @__PURE__ */ __name((node) => {
-      if (ts2.isImportDeclaration(node) && ts2.isStringLiteralLike(node.moduleSpecifier)) {
-        this.scheduleReplacement(sourceFile, node.moduleSpecifier, replacements);
-      } else if (ts2.isExportDeclaration(node) && node.moduleSpecifier && ts2.isStringLiteralLike(node.moduleSpecifier)) {
-        this.scheduleReplacement(sourceFile, node.moduleSpecifier, replacements);
-      } else if (ts2.isCallExpression(node) && node.expression.kind === ts2.SyntaxKind.ImportKeyword && node.arguments.length === 1) {
-        const [arg] = node.arguments;
-        if (arg && ts2.isStringLiteralLike(arg)) {
-          this.scheduleReplacement(sourceFile, arg, replacements);
-        }
-      }
-      ts2.forEachChild(node, visit);
-    }, "visit");
-    visit(sourceFile);
-    return replacements;
-  }
-  scheduleReplacement(sourceFile, literal, replacements) {
-    const updated = this.appendJsExtension(literal.text);
-    if (updated === literal.text) return;
-    const literalText = literal.getText(sourceFile);
-    const quote = literalText.startsWith("`") ? "`" : literalText.startsWith("'") ? "'" : '"';
-    replacements.push({
-      start: literal.getStart(sourceFile),
-      end: literal.getEnd(),
-      text: `${quote}${updated}${quote}`
-    });
-  }
-  appendJsExtension(specifier) {
-    if (!specifier.startsWith("./") && !specifier.startsWith("../")) return specifier;
-    if (/\.(?:[cm]?js|json)$/i.test(specifier)) return specifier;
-    return `${specifier}.js`;
-  }
-};
-
-// src/builder/TypeScriptProjectBuilder.ts
-var TypeScriptProjectBuilder = class {
-  static {
-    __name(this, "TypeScriptProjectBuilder");
-  }
-  logger;
-  entries;
-  specifierTransformer;
-  constructor(logger, entries = new EntryPointCollector(), specifierTransformer = new RelativeSpecifierTransformer()) {
-    this.logger = logger;
-    this.entries = entries;
-    this.specifierTransformer = specifierTransformer;
-  }
-  async build(config) {
-    const tsconfigPath = this.resolveTsconfig(config);
-    const { entryMap, primaryKey } = this.entries.collect(config, tsconfigPath);
-    this.logger.info(`Building Seedcord project via ${tsconfigPath}`);
-    try {
-      await build({
-        entry: entryMap,
-        outDir: config.build.outDir,
-        format: [
-          "esm"
-        ],
-        outExtension: /* @__PURE__ */ __name(() => ({
-          js: ".js"
-        }), "outExtension"),
-        shims: false,
-        splitting: false,
-        sourcemap: true,
-        clean: false,
-        skipNodeModulesBundle: true,
-        minify: false,
-        bundle: false,
-        dts: false,
-        target: "node22",
-        platform: "node",
-        keepNames: true,
-        treeshake: false,
-        tsconfig: tsconfigPath,
-        silent: true
-      });
-      await this.specifierTransformer.transform(config.build.outDir);
-    } catch (error) {
-      const reason = error instanceof Error ? error.message : "Unknown build error";
-      throw new SeedcordError(SeedcordErrorCode.CliBuildFailed, [
-        reason
-      ]);
-    }
-    const emittedEntry = this.resolveEmittedEntry(config.build.outDir, primaryKey);
-    if (!existsSync(emittedEntry)) {
-      throw new SeedcordError(SeedcordErrorCode.CliBuildFailed, [
-        `Expected output file ${emittedEntry} missing after build`
-      ]);
-    }
-    this.logger.info(`Emitted entry: ${emittedEntry}`);
-    return {
-      emittedEntry
-    };
-  }
-  resolveTsconfig(config) {
-    if (config.build.tsconfig) {
-      if (!existsSync(config.build.tsconfig)) {
-        throw new SeedcordError(SeedcordErrorCode.CliBuildTsconfigNotFound, [
-          config.build.tsconfig
-        ]);
-      }
-      return config.build.tsconfig;
-    }
-    const configDir = dirname(config.configFile);
-    const candidates = [
-      "tsconfig.build.json",
-      "tsconfig.json"
-    ].map((file) => resolve(configDir, file)).filter((candidate) => existsSync(candidate));
-    const [firstCandidate] = candidates;
-    if (firstCandidate) return firstCandidate;
-    throw new SeedcordError(SeedcordErrorCode.CliBuildTsconfigNotFound, [
-      configDir
-    ]);
-  }
-  resolveEmittedEntry(outDir, entryKey) {
-    return resolve(outDir, `${entryKey}.js`);
-  }
-};
-
-// src/runtime/SeedcordBuildRunner.ts
-var SeedcordBuildRunner = class _SeedcordBuildRunner {
-  static {
-    __name(this, "SeedcordBuildRunner");
-  }
-  locator;
-  configLoader;
-  builder;
-  bootstrapWriter;
-  logger;
-  constructor(locator, configLoader, builder, bootstrapWriter, logger) {
-    this.locator = locator;
-    this.configLoader = configLoader;
-    this.builder = builder;
-    this.bootstrapWriter = bootstrapWriter;
-    this.logger = logger;
-  }
-  static create(logger) {
-    const moduleLoader = new RuntimeModuleLoader();
-    const locator = new ConfigLocator(logger);
-    const configLoader = new ConfigLoader(moduleLoader, logger);
-    const builder = new TypeScriptProjectBuilder(logger);
-    const bootstrapWriter = new BootstrapWriter(logger);
-    return new _SeedcordBuildRunner(locator, configLoader, builder, bootstrapWriter, logger);
-  }
-  async run() {
-    const config = await this.loadConfig();
-    this.assertEntryExists(config.entry);
-    const { emittedEntry } = await this.builder.build(config);
-    await this.bootstrapWriter.write(config, emittedEntry);
-    this.logger.info("Seedcord build finished successfully.");
-  }
-  async loadConfig() {
-    const configPath = this.locator.locate();
-    return this.configLoader.load(configPath);
-  }
-  assertEntryExists(entryPath) {
-    if (!existsSync(entryPath)) {
-      throw new SeedcordError(SeedcordErrorCode.CliEntryNotFound, [
-        entryPath
-      ]);
-    }
-  }
-};
-
-// src/commands/BuildCommand.ts
-var BuildCommand = class _BuildCommand {
-  static {
-    __name(this, "BuildCommand");
-  }
-  runner;
-  logger;
-  constructor(runner, logger) {
-    this.runner = runner;
-    this.logger = logger;
-  }
-  register(program) {
-    program.command("build").description("Compile a Seedcord project using seedcord.config.ts").action(async () => {
-      try {
-        await this.runner.run();
-      } catch (error) {
-        this.logger.error("Seedcord build failed", error);
-        if (isSeedcordError(error)) process.exitCode = 1;
-        else process.exit(1);
-      }
-    });
-  }
-  static create(logger) {
-    return new _BuildCommand(SeedcordBuildRunner.create(logger), logger);
-  }
-};
-
-// src/index.ts
-var version = "0.0.1";
-
-export { BootstrapWriter, BuildCommand, ConfigLoader, ConfigLocator, DevCommand, RuntimeModuleLoader, SEEDCORD_CONFIG_FILENAMES, SeedcordBuildRunner, SeedcordDevRunner, SeedcordInstanceLoader, TypeScriptProjectBuilder, defineConfig, resolveDefaultExport, version };
-//# sourceMappingURL=index.mjs.map
-//# sourceMappingURL=index.mjs.map
+export { SEEDCORD_CONFIG_FILENAMES, defineConfig, version };