@confluxjs/conflux 0.1.0

package/dist/pipeline-B7aJQrzJ.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline-B7aJQrzJ.cjs","names":[],"sources":["../src/events/pipeline.ts"],"sourcesContent":["let eventsHalted = false;\n\nexport function resetEventPipeline(): void {\n  eventsHalted = false;\n}\n\nexport function stopAllEvents(): void {\n  eventsHalted = true;\n}\n\nexport function isEventPipelineHalted(): boolean {\n  return eventsHalted;\n}\n"],"mappings":";;AAAA,IAAI,eAAe;AAEnB,SAAgB,qBAA2B;AACzC,gBAAe;;AAGjB,SAAgB,gBAAsB;AACpC,gBAAe;;AAGjB,SAAgB,wBAAiC;AAC/C,QAAO"}

package/dist/pipeline-BkDu0cvJ.js

@@ -0,0 +1,15 @@
+//#region src/events/pipeline.ts
+let eventsHalted = false;
+function resetEventPipeline() {
+	eventsHalted = false;
+}
+function stopAllEvents() {
+	eventsHalted = true;
+}
+function isEventPipelineHalted() {
+	return eventsHalted;
+}
+
+//#endregion
+export { resetEventPipeline as n, stopAllEvents as r, isEventPipelineHalted as t };
+//# sourceMappingURL=pipeline-BkDu0cvJ.js.map

package/dist/pipeline-BkDu0cvJ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline-BkDu0cvJ.js","names":[],"sources":["../src/events/pipeline.ts"],"sourcesContent":["let eventsHalted = false;\n\nexport function resetEventPipeline(): void {\n  eventsHalted = false;\n}\n\nexport function stopAllEvents(): void {\n  eventsHalted = true;\n}\n\nexport function isEventPipelineHalted(): boolean {\n  return eventsHalted;\n}\n"],"mappings":";AAAA,IAAI,eAAe;AAEnB,SAAgB,qBAA2B;AACzC,gBAAe;;AAGjB,SAAgB,gBAAsB;AACpC,gBAAe;;AAGjB,SAAgB,wBAAiC;AAC/C,QAAO"}

package/dist/run-conflux-B_44EsUH.cjs

@@ -0,0 +1,586 @@
+#!/usr/bin/env node
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let node_path = require("node:path");
+node_path = __toESM(node_path);
+let node_url = require("node:url");
+node_url = __toESM(node_url);
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs);
+let __fluxerjs_core = require("@fluxerjs/core");
+__fluxerjs_core = __toESM(__fluxerjs_core);
+
+//#region src/loader/directory-modules.ts
+const MODULE_EXTENSIONS = [
+	".ts",
+	".js",
+	".mts",
+	".mjs",
+	".cjs"
+];
+function isLoadableModule(name) {
+	return MODULE_EXTENSIONS.some((ext) => name.endsWith(ext));
+}
+function collectEventDirectoryModulePaths(dir) {
+	if (!(0, node_fs.existsSync)(dir)) return [];
+	const paths = [];
+	for (const entry of (0, node_fs.readdirSync)(dir, { withFileTypes: true })) {
+		if (!entry.isDirectory()) continue;
+		const eventDir = (0, node_path.join)(dir, entry.name);
+		const files = (0, node_fs.readdirSync)(eventDir, { withFileTypes: true }).filter((file) => file.isFile() && isLoadableModule(file.name)).map((file) => file.name).sort((a, b) => a.localeCompare(b));
+		for (const file of files) paths.push((0, node_path.join)(eventDir, file));
+	}
+	return paths;
+}
+
+//#endregion
+//#region src/commands/discover-paths.ts
+function stem(name) {
+	const dot = name.lastIndexOf(".");
+	return dot === -1 ? name : name.slice(0, dot);
+}
+function classifyPlusFile(filePath, fileName, out) {
+	const base = stem(fileName);
+	if (base === "+global-middleware") {
+		out.globalMiddlewarePaths.push(filePath);
+		return;
+	}
+	if (base === "+middleware") {
+		out.directoryMiddlewarePaths.set((0, node_path.dirname)(filePath), filePath);
+		return;
+	}
+	if (base.startsWith("+") && base.endsWith(".middleware")) {
+		const commandName = base.slice(1, -11);
+		if (!commandName) throw new Error(`Invalid command middleware file name: ${filePath}`);
+		const key = `${(0, node_path.dirname)(filePath)}\0${commandName}`;
+		out.commandMiddlewarePaths.set(key, filePath);
+		return;
+	}
+	throw new Error(`Unrecognized middleware file: ${filePath}`);
+}
+function walkDirectory(dir, out) {
+	const entries = (0, node_fs.readdirSync)(dir, { withFileTypes: true });
+	for (const entry of entries) {
+		const entryPath = (0, node_path.join)(dir, entry.name);
+		if (entry.isDirectory()) {
+			walkDirectory(entryPath, out);
+			continue;
+		}
+		if (!entry.isFile() || !isLoadableModule(entry.name)) continue;
+		if (entry.name.startsWith("+")) {
+			classifyPlusFile(entryPath, entry.name, out);
+			continue;
+		}
+		out.commandPaths.push(entryPath);
+	}
+}
+function discoverCommandPaths(commandsDir) {
+	const out = {
+		commandPaths: [],
+		globalMiddlewarePaths: [],
+		directoryMiddlewarePaths: /* @__PURE__ */ new Map(),
+		commandMiddlewarePaths: /* @__PURE__ */ new Map()
+	};
+	if (!(0, node_fs.existsSync)(commandsDir)) return out;
+	walkDirectory(commandsDir, out);
+	out.commandPaths.sort((a, b) => a.localeCompare(b));
+	return out;
+}
+
+//#endregion
+//#region src/commands/validate-registry.ts
+function validateDiscoveredMiddleware(discovered, commandsDir) {
+	if (discovered.globalMiddlewarePaths.length > 1) throw new Error(`Only one +global-middleware module is allowed under ${commandsDir}. Found: ${discovered.globalMiddlewarePaths.join(", ")}`);
+}
+function validateCommandTriggers(commands) {
+	const triggerOwners = /* @__PURE__ */ new Map();
+	for (const command of commands) {
+		const triggers = [command.data.name, ...command.data.aliases ?? []];
+		for (const trigger of triggers) {
+			if (!trigger) throw new Error(`Command at ${command.filePath} has an empty trigger name or alias`);
+			const key = trigger.toLowerCase();
+			const existing = triggerOwners.get(key);
+			if (existing) throw new Error(`Duplicate command trigger "${trigger}" in ${command.filePath} (already used by ${existing})`);
+			triggerOwners.set(key, command.filePath);
+		}
+	}
+}
+
+//#endregion
+//#region src/commands/load-registry.ts
+function isCommandData(value) {
+	if (!value || typeof value !== "object") return false;
+	const data = value;
+	return typeof data.name === "string" && data.name.length > 0;
+}
+function isMessageCommand(value) {
+	return typeof value === "function";
+}
+function readMiddleware(module$1) {
+	const candidate = module$1.middleware ?? module$1.default;
+	if (!candidate || typeof candidate !== "object") throw new Error("Middleware module must default-export or export `middleware`");
+	const middleware = candidate;
+	if (typeof middleware.beforeExecute !== "function" || typeof middleware.afterExecute !== "function") throw new Error("Middleware must define beforeExecute and afterExecute functions");
+	return middleware;
+}
+async function loadMiddlewareFile(filePath) {
+	const module$1 = await import((0, node_url.pathToFileURL)(filePath).href);
+	try {
+		return readMiddleware(module$1);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`${message}: ${filePath}`);
+	}
+}
+async function loadCommandFile(filePath) {
+	const module$1 = await import((0, node_url.pathToFileURL)(filePath).href);
+	const data = module$1.data;
+	if (!isCommandData(data)) throw new Error(`Command module must export \`data\` with a non-empty name: ${filePath}`);
+	const message = module$1.message;
+	if (!isMessageCommand(message)) throw new Error(`Command module must export \`message\` function: ${filePath}`);
+	const namedAfter = module$1.after;
+	const after = typeof namedAfter === "function" ? namedAfter : typeof message.after === "function" ? message.after : void 0;
+	return {
+		filePath,
+		directory: (0, node_path.dirname)(filePath),
+		data,
+		message,
+		after
+	};
+}
+async function loadMiddlewareMaps(discovered) {
+	const globalMiddleware = discovered.globalMiddlewarePaths.length === 1 ? await loadMiddlewareFile(discovered.globalMiddlewarePaths[0]) : null;
+	const directoryMiddleware = /* @__PURE__ */ new Map();
+	for (const [dir, filePath] of discovered.directoryMiddlewarePaths) directoryMiddleware.set(dir, await loadMiddlewareFile(filePath));
+	const commandMiddleware = /* @__PURE__ */ new Map();
+	for (const [key, filePath] of discovered.commandMiddlewarePaths) commandMiddleware.set(key, await loadMiddlewareFile(filePath));
+	return {
+		globalMiddleware,
+		directoryMiddleware,
+		commandMiddleware
+	};
+}
+async function loadCommandRegistry(commandsDir) {
+	const discovered = discoverCommandPaths(commandsDir);
+	validateDiscoveredMiddleware(discovered, commandsDir);
+	const commands = [];
+	for (const filePath of discovered.commandPaths) commands.push(await loadCommandFile(filePath));
+	validateCommandTriggers(commands);
+	const middleware = await loadMiddlewareMaps(discovered);
+	const byTrigger = /* @__PURE__ */ new Map();
+	for (const command of commands) {
+		byTrigger.set(command.data.name.toLowerCase(), command);
+		for (const alias of command.data.aliases ?? []) byTrigger.set(alias.toLowerCase(), command);
+	}
+	return {
+		commands,
+		byTrigger,
+		...middleware
+	};
+}
+
+//#endregion
+//#region src/config/defaults.ts
+const CONFIG_FILENAMES = [
+	"conflux.config.ts",
+	"conflux.config.js",
+	"conflux.config.mjs",
+	"conflux.config.cjs",
+	"conflux.config.mts",
+	"conflux.config.cts"
+];
+function resolveConfluxConfig(config, root) {
+	const resolvedRoot = (0, node_path.resolve)(root, config.root ?? ".");
+	return {
+		root: resolvedRoot,
+		outDir: (0, node_path.resolve)(resolvedRoot, config.outDir ?? "dist"),
+		entry: (0, node_path.resolve)(resolvedRoot, config.entry ?? "src/index.ts"),
+		commandsDir: (0, node_path.resolve)(resolvedRoot, config.commandsDir ?? "src/commands"),
+		eventsDir: (0, node_path.resolve)(resolvedRoot, config.eventsDir ?? "src/events"),
+		token: config.token,
+		env: config.env
+	};
+}
+
+//#endregion
+//#region src/config/load-config.ts
+function isResolvedConfig(value) {
+	if (!value || typeof value !== "object") return false;
+	const record = value;
+	return typeof record.root === "string" && typeof record.entry === "string" && typeof record.outDir === "string";
+}
+function findConfigPath(root) {
+	for (const name of CONFIG_FILENAMES) {
+		const path = (0, node_path.join)(root, name);
+		if ((0, node_fs.existsSync)(path)) return path;
+	}
+	return null;
+}
+async function loadConfluxConfig(root) {
+	const configPath = findConfigPath(root);
+	if (!configPath) return resolveConfluxConfig({}, root);
+	const imported = await import((0, node_url.pathToFileURL)(configPath).href);
+	const exported = imported.default ?? imported;
+	if (typeof exported === "function") {
+		const result = await exported();
+		if (isResolvedConfig(result)) return result;
+		return resolveConfluxConfig(result, root);
+	}
+	if (isResolvedConfig(exported)) return exported;
+	return resolveConfluxConfig(exported, root);
+}
+
+//#endregion
+//#region src/commands/check-permissions.ts
+function memberHasPermissions(permissions, required) {
+	if (required.length === 0) return true;
+	if (!permissions) return false;
+	return permissions.has(required);
+}
+async function checkCommandPermissions(message, userPermissions, botPermissions) {
+	const guild = message.guild;
+	if (!guild) {
+		if (userPermissions?.length || botPermissions?.length) return false;
+		return true;
+	}
+	if (userPermissions?.length) {
+		if (!memberHasPermissions((await guild.members.resolve(message.author.id)).permissions, userPermissions)) return false;
+	}
+	if (botPermissions?.length) {
+		if (!memberHasPermissions((guild.members.me ?? await guild.members.fetchMe().catch(() => null))?.permissions, botPermissions)) return false;
+	}
+	return true;
+}
+
+//#endregion
+//#region src/commands/resolve-middleware.ts
+function directoryChain(commandsDir, commandDir) {
+	const dirs = [];
+	let current = commandDir;
+	while (true) {
+		dirs.unshift(current);
+		if (current === commandsDir) break;
+		current = (0, node_path.dirname)(current);
+	}
+	return dirs;
+}
+function resolveMiddlewareChain(registry, command, commandsDir) {
+	const chain = [];
+	if (registry.globalMiddleware) chain.push(registry.globalMiddleware);
+	for (const dir of directoryChain(commandsDir, command.directory)) {
+		const middleware = registry.directoryMiddleware.get(dir);
+		if (middleware) chain.push(middleware);
+	}
+	const commandKey = `${command.directory}\0${command.data.name}`;
+	const commandMiddleware = registry.commandMiddleware.get(commandKey);
+	if (commandMiddleware) chain.push(commandMiddleware);
+	return chain;
+}
+
+//#endregion
+//#region src/commands/dispatch.ts
+function parseWithPrefixes(content, prefixes) {
+	for (const prefix of prefixes) {
+		const parsed = (0, __fluxerjs_core.parsePrefixCommand)(content, prefix);
+		if (parsed) return parsed;
+	}
+	return null;
+}
+function passesGuildFilter(message, guilds) {
+	if (!guilds?.length) return true;
+	if (!message.guildId) return true;
+	return guilds.includes(message.guildId);
+}
+function createCommandContext(message, client, conflux, commandName, args, data) {
+	return {
+		message,
+		client,
+		conflux,
+		data,
+		commandName,
+		args: () => args
+	};
+}
+async function dispatchPrefixCommand(message, client, conflux, registry, commandsDir) {
+	if (message.author.bot) return;
+	const prefixes = await conflux.resolvePrefixes();
+	const parsed = parseWithPrefixes(message.content, prefixes);
+	if (!parsed) return;
+	const command = registry.byTrigger.get(parsed.command.toLowerCase());
+	if (!command) return;
+	if (!passesGuildFilter(message, command.data.guilds)) return;
+	if (!await checkCommandPermissions(message, command.data.userPermissions, command.data.botPermissions)) return;
+	const ctx = createCommandContext(message, client, conflux, parsed.command, parsed.args, command.data);
+	const middlewares = resolveMiddlewareChain(registry, command, commandsDir);
+	for (const middleware of middlewares) await middleware.beforeExecute(ctx);
+	await command.message(ctx);
+	if (command.after) await command.after(ctx);
+	for (let i = middlewares.length - 1; i >= 0; i -= 1) await middlewares[i].afterExecute(ctx);
+}
+
+//#endregion
+//#region src/commands/register-commands.ts
+function registerConfluxCommands(client, conflux, registry, commandsDir) {
+	client.on("messageCreate", (message) => {
+		dispatchPrefixCommand(message, client, conflux, registry, commandsDir);
+	});
+}
+
+//#endregion
+//#region src/core/conflux.ts
+var Conflux = class {
+	options;
+	client = null;
+	prefixResolver = null;
+	constructor(options = {}) {
+		this.options = options;
+	}
+	setPrefix(resolver) {
+		this.prefixResolver = resolver;
+	}
+	async resolvePrefixes() {
+		if (!this.prefixResolver) return ["!"];
+		const result = await this.prefixResolver();
+		return Array.isArray(result) ? result : [result];
+	}
+};
+
+//#endregion
+//#region src/env/project-env.ts
+function parseEnvLine(line) {
+	const trimmed = line.trim();
+	if (!trimmed || trimmed.startsWith("#")) return null;
+	const exportPrefix = trimmed.startsWith("export ") ? trimmed.slice(7).trim() : trimmed;
+	const eq = exportPrefix.indexOf("=");
+	if (eq === -1) return null;
+	const key = exportPrefix.slice(0, eq).trim();
+	let value = exportPrefix.slice(eq + 1).trim();
+	if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
+	return [key, value];
+}
+function loadEnvFile(path) {
+	if (!(0, node_fs.existsSync)(path)) return;
+	const content = (0, node_fs.readFileSync)(path, "utf8");
+	for (const line of content.split(/\r?\n/)) {
+		const parsed = parseEnvLine(line);
+		if (!parsed) continue;
+		const [key, value] = parsed;
+		if (process.env[key] === void 0) process.env[key] = value;
+	}
+}
+function loadProjectEnv(root) {
+	loadEnvFile((0, node_path.join)(root, ".env"));
+	loadEnvFile((0, node_path.join)(root, ".env.local"));
+}
+
+//#endregion
+//#region src/env/resolve-token.ts
+const TOKEN_ENV_CANDIDATES = [
+	"FLUXER_BOT_TOKEN",
+	"BOT_TOKEN",
+	"TOKEN"
+];
+function resolveBotToken(config) {
+	if (config.token) return config.token;
+	if (config.env) {
+		const fromNamed = process.env[config.env];
+		if (fromNamed) return fromNamed;
+		throw new Error(`Bot token env var "${config.env}" is not set (check .env or your environment)`);
+	}
+	for (const name of TOKEN_ENV_CANDIDATES) {
+		const value = process.env[name];
+		if (value) return value;
+	}
+	throw new Error(`No bot token found. Set one of ${TOKEN_ENV_CANDIDATES.join(", ")} in .env or use token/env in conflux.config`);
+}
+
+//#endregion
+//#region src/events/pipeline.ts
+let eventsHalted = false;
+function resetEventPipeline() {
+	eventsHalted = false;
+}
+function stopAllEvents() {
+	eventsHalted = true;
+}
+function isEventPipelineHalted() {
+	return eventsHalted;
+}
+
+//#endregion
+//#region src/events/register-handlers.ts
+function createHandlerContext(client, conflux) {
+	return {
+		client,
+		conflux,
+		stopAllEvents
+	};
+}
+async function runHandlerBatch(handlers, fluxerArgs, ctx) {
+	for (const handler of handlers) {
+		if (isEventPipelineHalted()) break;
+		await handler(...fluxerArgs, ctx);
+	}
+}
+function registerConfluxEventHandlers(client, conflux, registry) {
+	for (const [eventName, handlers] of registry) client.on(eventName, (...fluxerArgs) => {
+		if (isEventPipelineHalted()) return;
+		runHandlerBatch(handlers, fluxerArgs, createHandlerContext(client, conflux));
+	});
+}
+
+//#endregion
+//#region src/loader/entry-client.ts
+function isFluxerClient(value) {
+	if (value instanceof __fluxerjs_core.Client) return true;
+	if (!value || typeof value !== "object") return false;
+	const candidate = value;
+	return typeof candidate.login === "function" && typeof candidate.on === "function" && typeof candidate.once === "function";
+}
+async function loadEntryModule(entryPath) {
+	const entryModule = await import((0, node_url.pathToFileURL)(entryPath).href);
+	const namedExport = entryModule.client;
+	let client = null;
+	if (isFluxerClient(namedExport)) client = namedExport;
+	else if (isFluxerClient(entryModule.default)) client = entryModule.default;
+	if (!client) throw new Error(`Conflux entry must export a @fluxerjs/core Client as named export \`client\` or as default export: ${entryPath}`);
+	const configure = entryModule.configure;
+	if (configure !== void 0 && typeof configure !== "function") throw new Error(`Conflux entry export \`configure\` must be a function: ${entryPath}`);
+	return {
+		client,
+		configure
+	};
+}
+
+//#endregion
+//#region src/loader/event-handlers.ts
+const FLUXER_EVENT_NAMES = new Set(Object.values(__fluxerjs_core.Events));
+function isAnyEventHandler(value) {
+	return typeof value === "function";
+}
+function listEventNames(eventsDir) {
+	if (!(0, node_fs.existsSync)(eventsDir)) return [];
+	return (0, node_fs.readdirSync)(eventsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort((a, b) => a.localeCompare(b));
+}
+function sortedHandlerFiles(eventDir) {
+	return (0, node_fs.readdirSync)(eventDir, { withFileTypes: true }).filter((entry) => entry.isFile() && isLoadableModule(entry.name)).map((entry) => entry.name).sort((a, b) => a.localeCompare(b)).map((name) => (0, node_path.join)(eventDir, name));
+}
+function assertKnownEventName(eventName, eventsDir) {
+	if (!FLUXER_EVENT_NAMES.has(eventName)) throw new Error(`Unknown event folder "${eventName}" under ${eventsDir}. Name the folder with a Fluxer event string (for example ready, messageCreate). See Events in @fluxerjs/core.`);
+}
+async function loadEventHandlerRegistry(eventsDir) {
+	const registry = /* @__PURE__ */ new Map();
+	for (const eventName of listEventNames(eventsDir)) {
+		assertKnownEventName(eventName, eventsDir);
+		const eventDir = (0, node_path.join)(eventsDir, eventName);
+		const handlers = [];
+		for (const filePath of sortedHandlerFiles(eventDir)) {
+			const handler = (await import((0, node_url.pathToFileURL)(filePath).href)).default;
+			if (!isAnyEventHandler(handler)) throw new Error(`Event handler must default-export a function: ${filePath}`);
+			handlers.push(handler);
+		}
+		if (handlers.length > 0) registry.set(eventName, handlers);
+	}
+	return registry;
+}
+
+//#endregion
+//#region src/runtime/state.ts
+const state = { config: null };
+function setConfig(config) {
+	state.config = config;
+}
+
+//#endregion
+//#region src/runtime/run-conflux.ts
+async function runConflux(options = {}) {
+	const root = options.root ?? process.cwd();
+	if (options.production) process.env.NODE_ENV = "production";
+	loadProjectEnv(root);
+	const loaded = await loadConfluxConfig(root);
+	const config = {
+		...loaded,
+		entry: options.entry ?? loaded.entry,
+		eventsDir: options.eventsDir ?? loaded.eventsDir,
+		commandsDir: options.commandsDir ?? loaded.commandsDir
+	};
+	const token = resolveBotToken(config);
+	setConfig(config);
+	resetEventPipeline();
+	if (!(0, node_fs.existsSync)(config.entry)) throw new Error(`Conflux entry not found: ${config.entry}`);
+	const { client, configure } = await loadEntryModule(config.entry);
+	const conflux = new Conflux({ root: config.root });
+	conflux.client = client;
+	await configure?.(conflux);
+	const commandRegistry = await loadCommandRegistry(config.commandsDir);
+	registerConfluxEventHandlers(client, conflux, await loadEventHandlerRegistry(config.eventsDir));
+	registerConfluxCommands(client, conflux, commandRegistry, config.commandsDir);
+	await client.login(token);
+	return conflux;
+}
+
+//#endregion
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});
+Object.defineProperty(exports, 'collectEventDirectoryModulePaths', {
+  enumerable: true,
+  get: function () {
+    return collectEventDirectoryModulePaths;
+  }
+});
+Object.defineProperty(exports, 'discoverCommandPaths', {
+  enumerable: true,
+  get: function () {
+    return discoverCommandPaths;
+  }
+});
+Object.defineProperty(exports, 'findConfigPath', {
+  enumerable: true,
+  get: function () {
+    return findConfigPath;
+  }
+});
+Object.defineProperty(exports, 'loadCommandRegistry', {
+  enumerable: true,
+  get: function () {
+    return loadCommandRegistry;
+  }
+});
+Object.defineProperty(exports, 'loadConfluxConfig', {
+  enumerable: true,
+  get: function () {
+    return loadConfluxConfig;
+  }
+});
+Object.defineProperty(exports, 'runConflux', {
+  enumerable: true,
+  get: function () {
+    return runConflux;
+  }
+});
+//# sourceMappingURL=run-conflux-B_44EsUH.cjs.map