stratal 0.0.16 → 0.0.17

package/dist/quarry-registry-B2rkO-JS.mjs

@@ -0,0 +1,683 @@
+import { a as __decorate, d as Transient, g as DI_TOKENS, o as __decorateParam, s as __decorateMetadata } from "./logger-CGT91VY6.mjs";
+import { r as getListenerHandlers } from "./events-CvUSgEuN.mjs";
+import { a as green, n as cyan, o as red, s as yellow, t as bold } from "./colors-Y7WIFXs7.mjs";
+import { n as CommandError, r as COMMAND_INTERNALS, t as Command } from "./command-B1CPgsrU.mjs";
+import { n as OPENAPI_TOKENS, t as OpenApiToolsService } from "./openapi-tools.service-B3TxYKoQ.mjs";
+import { inject } from "tsyringe";
+import { z } from "zod";
+//#region src/quarry/commands/api.command.ts
+let ApiCommand = class ApiCommand extends Command {
+	static command = "api {route?} {--method= : HTTP method} {--data= : JSON request body} {--header=* : Headers (Key:Value)} {--query=* : Query params (key=value)}";
+	static description = "Call an API route directly";
+	static aliases = ["api:call"];
+	constructor(app) {
+		super();
+		this.app = app;
+	}
+	async handle() {
+		const route = this.string("route");
+		if (!route) return (await this.call("route:list")).exitCode;
+		return this.callRoute(route);
+	}
+	async callRoute(route) {
+		const method = (this.string("method") || "GET").toUpperCase();
+		const data = this.string("data");
+		const headerArgs = this.array("header");
+		const queryArgs = this.array("query");
+		const headers = {};
+		if (data) headers["Content-Type"] = "application/json";
+		for (const h of headerArgs) {
+			const colonIdx = h.indexOf(":");
+			if (colonIdx > 0) headers[h.slice(0, colonIdx).trim()] = h.slice(colonIdx + 1).trim();
+		}
+		let url = route;
+		if (queryArgs.length > 0) {
+			const parts = queryArgs.map((q) => {
+				const eqIdx = q.indexOf("=");
+				if (eqIdx > 0) return `${encodeURIComponent(q.slice(0, eqIdx))}=${encodeURIComponent(q.slice(eqIdx + 1))}`;
+				return encodeURIComponent(q);
+			});
+			url += `?${parts.join("&")}`;
+		}
+		const request = new Request(`http://localhost${url}`, {
+			method,
+			headers,
+			body: data || void 0
+		});
+		const response = await this.app.hono.fetch(request, this.app.env);
+		const body = await response.text();
+		const statusText = `${response.status} ${response.statusText}`;
+		let coloredStatus;
+		if (response.status >= 200 && response.status < 300) coloredStatus = green(bold(statusText));
+		else if (response.status >= 300 && response.status < 400) coloredStatus = yellow(bold(statusText));
+		else coloredStatus = red(bold(statusText));
+		this.line(`${cyan(method)} ${route} ${coloredStatus}`);
+		this.newLine();
+		const headerLines = [];
+		response.headers.forEach((value, key) => {
+			headerLines.push(`  ${key}: ${value}`);
+		});
+		if (headerLines.length > 0) {
+			this.line(bold("Headers:"));
+			for (const hl of headerLines) this.line(hl);
+			this.newLine();
+		}
+		if (body) {
+			this.line(bold("Body:"));
+			try {
+				this.line(JSON.stringify(JSON.parse(body), null, 2));
+			} catch {
+				this.line(body);
+			}
+		}
+		return response.status >= 400 ? 1 : 0;
+	}
+};
+ApiCommand = __decorate([__decorateParam(0, inject(DI_TOKENS.Application)), __decorateMetadata("design:paramtypes", [Object])], ApiCommand);
+//#endregion
+//#region src/quarry/commands/event-list.command.ts
+let EventListCommand = class EventListCommand extends Command {
+	static command = "event:list";
+	static description = "List all registered event listeners";
+	constructor(modules) {
+		super();
+		this.modules = modules;
+	}
+	handle() {
+		const listeners = this.modules.getAllListeners();
+		if (listeners.length === 0) {
+			this.info("No event listeners found");
+			return 0;
+		}
+		const rows = [];
+		for (const ListenerClass of listeners) {
+			const handlers = getListenerHandlers(ListenerClass);
+			for (const { methodName, event, options } of handlers) rows.push([
+				event,
+				ListenerClass.name,
+				methodName,
+				String(options?.priority ?? 0),
+				options?.blocking ? "Yes" : "No"
+			]);
+		}
+		if (rows.length === 0) {
+			this.info("No event handlers found");
+			return 0;
+		}
+		this.table([
+			"Event",
+			"Listener",
+			"Method",
+			"Priority",
+			"Blocking"
+		], rows);
+	}
+};
+EventListCommand = __decorate([__decorateParam(0, inject(DI_TOKENS.ModuleRegistry)), __decorateMetadata("design:paramtypes", [Object])], EventListCommand);
+//#endregion
+//#region src/quarry/errors/command-not-found.error.ts
+/**
+* Thrown when a command is not found in the Quarry registry.
+*/
+var CommandNotFoundError = class extends Error {
+	constructor(name) {
+		super(`Command "${name}" is not registered.`);
+		this.name = "CommandNotFoundError";
+	}
+};
+//#endregion
+//#region src/quarry/commands/help.command.ts
+let HelpCommand = class HelpCommand extends Command {
+	static command = "help {command?}";
+	static description = "Show help for a command or list all commands";
+	static aliases = ["list"];
+	constructor(quarryRegistry) {
+		super();
+		this.quarryRegistry = quarryRegistry;
+	}
+	async handle() {
+		const commandName = this.string("command");
+		if (!commandName) {
+			const listing = await this.quarryRegistry.listUsage();
+			this.line(listing);
+			return 0;
+		}
+		try {
+			const usage = await this.quarryRegistry.usage(commandName);
+			this.line(usage);
+			return 0;
+		} catch (error) {
+			if (error instanceof CommandNotFoundError) {
+				this.fail(`Unknown command: ${commandName}`);
+				return 1;
+			}
+			throw error;
+		}
+	}
+};
+HelpCommand = __decorate([__decorateParam(0, inject(DI_TOKENS.Quarry)), __decorateMetadata("design:paramtypes", [Object])], HelpCommand);
+//#endregion
+//#region src/quarry/commands/mcp-serve.command.ts
+let McpServeCommand = class McpServeCommand extends Command {
+	static command = "mcp:serve {--url= : Base URL for external dispatch} {--header=* : Headers (Key:Value)} {--tag=* : Only expose routes with these OpenAPI tags} {--path= : Only expose routes matching this path prefix}";
+	static description = "Start an MCP stdio server exposing API routes as tools";
+	constructor(app, openAPIService) {
+		super();
+		this.app = app;
+		this.openAPIService = openAPIService;
+	}
+	async handle() {
+		const { McpServer } = await import("@modelcontextprotocol/sdk/server/mcp.js");
+		const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
+		const baseUrl = this.string("url");
+		const headerArgs = this.array("header");
+		const tags = this.array("tag");
+		const pathPrefix = this.string("path");
+		const headers = {};
+		for (const h of headerArgs) {
+			const colonIdx = h.indexOf(":");
+			if (colonIdx > 0) headers[h.slice(0, colonIdx).trim()] = h.slice(colonIdx + 1).trim();
+		}
+		const spec = this.openAPIService.getSpec(this.app.hono, this.app.container);
+		const service = new OpenApiToolsService(spec, { dispatcher: baseUrl ? async (method, url, opts) => {
+			const fullUrl = `${baseUrl}${url}`;
+			try {
+				return await fetch(fullUrl, {
+					method,
+					headers: {
+						"Content-Type": "application/json",
+						...headers,
+						...opts?.headers
+					},
+					body: opts?.body !== void 0 ? JSON.stringify(opts.body) : void 0
+				});
+			} catch (error) {
+				throw new Error(`MCP dispatch failed: ${method} ${fullUrl} — ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+			}
+		} : async (method, url, opts) => {
+			const request = new Request(`http://localhost${url}`, {
+				method,
+				headers: {
+					"Content-Type": "application/json",
+					...headers,
+					...opts?.headers
+				},
+				body: opts?.body !== void 0 ? JSON.stringify(opts.body) : void 0
+			});
+			try {
+				return await this.app.hono.fetch(request, this.app.env);
+			} catch (error) {
+				throw new Error(`MCP dispatch failed: ${method} ${url} — ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+			}
+		} });
+		const filter = {
+			tags: tags.length > 0 ? tags : void 0,
+			pathPrefix: pathPrefix || void 0
+		};
+		const tools = service.getTools(filter);
+		const config = this.app.container.resolve(OPENAPI_TOKENS.ConfigService).getEffectiveConfig();
+		const server = new McpServer({
+			name: config.info.title,
+			version: config.info.version
+		});
+		for (const tool of tools) {
+			const inputSchema = z.fromJSONSchema(tool.inputSchema);
+			server.registerTool(tool.name, {
+				description: tool.description,
+				inputSchema
+			}, async (args) => {
+				const result = await service.executeTool(tool.name, args);
+				return { content: [{
+					type: "text",
+					text: `Status: ${result.status}\n\n${result.body}`
+				}] };
+			});
+		}
+		server.registerResource("openapi-spec", "openapi://spec", {
+			description: "Full OpenAPI specification",
+			mimeType: "application/json"
+		}, () => ({ contents: [{
+			uri: "openapi://spec",
+			mimeType: "application/json",
+			text: JSON.stringify(spec, null, 2)
+		}] }));
+		const transport = new StdioServerTransport();
+		const closed = new Promise((resolve) => {
+			transport.onclose = resolve;
+		});
+		await server.connect(transport);
+		process.stderr.write(`MCP server started with ${tools.length} tool(s)\n`);
+		await closed;
+		return 0;
+	}
+};
+McpServeCommand = __decorate([
+	__decorateParam(0, inject(DI_TOKENS.Application)),
+	__decorateParam(1, inject(OPENAPI_TOKENS.OpenAPIService)),
+	__decorateMetadata("design:paramtypes", [Object, Object])
+], McpServeCommand);
+//#endregion
+//#region src/quarry/commands/mcp-tools.command.ts
+let McpToolsCommand = class McpToolsCommand extends Command {
+	static command = "mcp:tools {--tag=* : Filter by OpenAPI tags} {--path= : Filter by path prefix}";
+	static description = "List API routes that would be exposed as MCP tools";
+	constructor(app, openAPIService) {
+		super();
+		this.app = app;
+		this.openAPIService = openAPIService;
+	}
+	handle() {
+		const tags = this.array("tag");
+		const pathPrefix = this.string("path");
+		const service = new OpenApiToolsService(this.openAPIService.getSpec(this.app.hono, this.app.container));
+		const filter = {
+			tags: tags.length > 0 ? tags : void 0,
+			pathPrefix: pathPrefix || void 0
+		};
+		const tools = service.getTools(filter);
+		if (tools.length === 0) {
+			this.info("No tools found");
+			return 0;
+		}
+		this.table([
+			"Name",
+			"Method",
+			"Path",
+			"Description"
+		], tools.map((t) => [
+			t.name,
+			t.method,
+			t.path,
+			t.description
+		]));
+		return 0;
+	}
+};
+McpToolsCommand = __decorate([
+	__decorateParam(0, inject(DI_TOKENS.Application)),
+	__decorateParam(1, inject(OPENAPI_TOKENS.OpenAPIService)),
+	__decorateMetadata("design:paramtypes", [Object, Object])
+], McpToolsCommand);
+//#endregion
+//#region src/quarry/commands/queue-list.command.ts
+let QueueListCommand = class QueueListCommand extends Command {
+	static command = "queue:list";
+	static description = "List all registered queue consumers";
+	constructor(consumers) {
+		super();
+		this.consumers = consumers;
+	}
+	handle() {
+		const consumers = this.consumers.getAllConsumers();
+		if (consumers.length === 0) {
+			this.info("No queue consumers found");
+			return 0;
+		}
+		this.table(["Consumer", "Message Types"], consumers.map((c) => [c.constructor.name, c.messageTypes.join(", ")]));
+	}
+};
+QueueListCommand = __decorate([__decorateParam(0, inject(DI_TOKENS.ConsumerRegistry)), __decorateMetadata("design:paramtypes", [Object])], QueueListCommand);
+//#endregion
+//#region src/quarry/commands/route-list.command.ts
+let RouteListCommand = class RouteListCommand extends Command {
+	static command = "route:list {--method= : Filter by HTTP method} {--path= : Filter by path substring}";
+	static description = "List all registered routes";
+	constructor(app) {
+		super();
+		this.app = app;
+	}
+	handle() {
+		const methodFilter = this.string("method").toUpperCase();
+		const pathFilter = this.string("path");
+		const deduped = /* @__PURE__ */ new Map();
+		for (const r of this.app.hono.routes) deduped.set(`${r.method}:${r.path}`, {
+			method: r.method,
+			path: r.path,
+			name: r.handler.name
+		});
+		let routes = [...deduped.values()].filter((r) => r.name);
+		if (methodFilter) routes = routes.filter((r) => r.method.toUpperCase() === methodFilter);
+		if (pathFilter) routes = routes.filter((r) => r.path.includes(pathFilter));
+		if (routes.length === 0) {
+			this.info("No routes found");
+			return 0;
+		}
+		this.table([
+			"Method",
+			"Path",
+			"Action",
+			"Type"
+		], routes.map((r) => {
+			const isWs = r.name.startsWith("ws:");
+			const action = r.name.replace(/^(http|ws):/, "");
+			return [
+				r.method.toUpperCase(),
+				r.path,
+				action || r.name,
+				isWs ? "WS" : "HTTP"
+			];
+		}));
+	}
+};
+RouteListCommand = __decorate([__decorateParam(0, inject(DI_TOKENS.Application)), __decorateMetadata("design:paramtypes", [Object])], RouteListCommand);
+//#endregion
+//#region src/quarry/commands/schedule-list.command.ts
+let ScheduleListCommand = class ScheduleListCommand extends Command {
+	static command = "schedule:list";
+	static description = "List all registered cron jobs";
+	constructor(cron) {
+		super();
+		this.cron = cron;
+	}
+	handle() {
+		const schedules = this.cron.getAllSchedules();
+		if (schedules.length === 0) {
+			this.info("No cron jobs found");
+			return 0;
+		}
+		const rows = [];
+		for (const schedule of schedules) {
+			const jobs = this.cron.getJobsForSchedule(schedule);
+			for (const job of jobs) rows.push([schedule, job.constructor.name]);
+		}
+		this.table(["Schedule", "Job"], rows);
+	}
+};
+ScheduleListCommand = __decorate([__decorateParam(0, inject(DI_TOKENS.Cron)), __decorateMetadata("design:paramtypes", [Object])], ScheduleListCommand);
+//#endregion
+//#region src/quarry/command-internals.ts
+/** @internal Set the flat input values before calling handle() */
+function setCommandInputs(command, values) {
+	command[COMMAND_INTERNALS].inputs = { ...values };
+}
+/** @internal Set the Quarry reference for this.call() support */
+function setCommandQuarry(command, quarry) {
+	command[COMMAND_INTERNALS].quarry = quarry;
+}
+/** @internal Collect the result after handle() completes */
+function getCommandResult(command) {
+	const internals = command[COMMAND_INTERNALS];
+	return {
+		exitCode: internals.exitCode,
+		output: [...internals.output],
+		errors: [...internals.errors]
+	};
+}
+//#endregion
+//#region src/quarry/signature-parser.ts
+/**
+* Parse a Laravel-style command signature string.
+*
+* Signature syntax:
+*   command-name {arg} ...              — flat command
+*   group subcommand {arg} ...          — subcommand hierarchy (space-separated)
+*   namespace:command {arg} ...         — namespaced flat command (colon-separated)
+*   {--flag} {--name=} {--name=default} {--name=*} {--A|name} {--name= : desc}
+*
+* Pure function, zero dependencies, edge-compatible.
+*/
+function parseSignature(signature) {
+	const tokens = extractTokens(signature);
+	const name = extractCommandName(signature);
+	const args = [];
+	const options = [];
+	for (const token of tokens) {
+		const inner = token.slice(1, -1).trim();
+		if (inner.startsWith("--")) options.push(parseOption(inner));
+		else args.push(parseArgument(inner));
+	}
+	return {
+		name,
+		arguments: args,
+		options
+	};
+}
+function extractCommandName(signature) {
+	const match = /^[\w:.-]+(?:\s+[\w:.-]+)*/.exec(signature);
+	if (!match) throw new CommandError(`Invalid signature: cannot extract command name from "${signature}"`);
+	return match[0];
+}
+function extractTokens(signature) {
+	const tokens = [];
+	const regex = /\{[^}]+\}/g;
+	let match;
+	while ((match = regex.exec(signature)) !== null) tokens.push(match[0]);
+	return tokens;
+}
+function parseArgument(inner) {
+	const { value, description } = splitDescription(inner);
+	if (value.endsWith("*")) return {
+		name: value.slice(0, -1).trim(),
+		required: true,
+		isArray: true,
+		description
+	};
+	const eqIdx = value.indexOf("=");
+	if (eqIdx !== -1) return {
+		name: value.slice(0, eqIdx).trim(),
+		required: false,
+		default: value.slice(eqIdx + 1).trim(),
+		isArray: false,
+		description
+	};
+	if (value.endsWith("?")) return {
+		name: value.slice(0, -1).trim(),
+		required: false,
+		isArray: false,
+		description
+	};
+	return {
+		name: value.trim(),
+		required: true,
+		isArray: false,
+		description
+	};
+}
+function parseOption(inner) {
+	const { value, description } = splitDescription(inner.slice(2));
+	let alias;
+	let optBody = value;
+	const pipeIdx = optBody.indexOf("|");
+	if (pipeIdx !== -1) {
+		alias = optBody.slice(0, pipeIdx).trim();
+		optBody = optBody.slice(pipeIdx + 1).trim();
+	}
+	if (optBody.endsWith("=*")) return {
+		name: optBody.slice(0, -2).trim(),
+		alias,
+		isFlag: false,
+		isArray: true,
+		description
+	};
+	const eqIdx = optBody.indexOf("=");
+	if (eqIdx !== -1) {
+		const name = optBody.slice(0, eqIdx).trim();
+		const defaultValue = optBody.slice(eqIdx + 1).trim();
+		return {
+			name,
+			alias,
+			isFlag: false,
+			isArray: false,
+			default: defaultValue || void 0,
+			description
+		};
+	}
+	return {
+		name: optBody.trim(),
+		alias,
+		isFlag: true,
+		isArray: false,
+		description
+	};
+}
+function splitDescription(value) {
+	const colonIdx = value.indexOf(" : ");
+	if (colonIdx === -1) return { value };
+	return {
+		value: value.slice(0, colonIdx).trim(),
+		description: value.slice(colonIdx + 3).trim()
+	};
+}
+//#endregion
+//#region src/quarry/quarry-registry.ts
+let QuarryRegistry = class QuarryRegistry {
+	commands = /* @__PURE__ */ new Map();
+	signatures = /* @__PURE__ */ new Map();
+	aliases = /* @__PURE__ */ new Map();
+	constructor(container) {
+		this.container = container;
+	}
+	/**
+	* Execute a command by name with optional flat input.
+	* A fresh command instance is resolved from the container per invocation.
+	*/
+	async call(name, input) {
+		const resolvedName = this.resolveName(name);
+		const CommandClass = this.commands.get(resolvedName);
+		if (!CommandClass) throw new CommandNotFoundError(name);
+		const signature = this.signatures.get(resolvedName);
+		const mergedInput = this.applyDefaults(input ?? {}, signature);
+		for (const arg of signature.arguments) if (arg.required && (mergedInput[arg.name] === void 0 || mergedInput[arg.name] === null)) throw new CommandError(`Missing required argument: ${arg.name}`);
+		let command;
+		try {
+			command = this.container.resolve(CommandClass);
+			setCommandQuarry(command, this);
+			setCommandInputs(command, mergedInput);
+			const exitCode = await command.handle();
+			const result = getCommandResult(command);
+			if (typeof exitCode === "number") return {
+				...result,
+				exitCode
+			};
+			return result;
+		} catch (error) {
+			if (error instanceof CommandError) {
+				if (command) {
+					const result = getCommandResult(command);
+					return {
+						exitCode: result.exitCode === 0 ? 1 : result.exitCode,
+						output: result.output,
+						errors: [...result.errors, error.message]
+					};
+				}
+				return {
+					exitCode: 1,
+					output: [],
+					errors: [error.message]
+				};
+			}
+			const errorMessage = this.handleError(error);
+			if (command) {
+				const result = getCommandResult(command);
+				return {
+					exitCode: result.exitCode === 0 ? 1 : result.exitCode,
+					output: result.output,
+					errors: [...result.errors, errorMessage]
+				};
+			}
+			return {
+				exitCode: 1,
+				output: [],
+				errors: [errorMessage]
+			};
+		}
+	}
+	/**
+	* Check if a command exists by name or alias.
+	*/
+	has(name) {
+		const resolved = this.resolveName(name);
+		return this.commands.has(resolved);
+	}
+	/**
+	* Get a command constructor by name or alias.
+	*/
+	get(name) {
+		const resolved = this.resolveName(name);
+		return this.commands.get(resolved);
+	}
+	/**
+	* Get all registered command constructors.
+	*/
+	all() {
+		return new Map(this.commands);
+	}
+	/**
+	* List all commands with their descriptions and aliases.
+	*/
+	list() {
+		const result = [];
+		for (const [name, CommandClass] of this.commands) {
+			const staticCommand = CommandClass;
+			const commandAliases = [];
+			for (const [alias, target] of this.aliases) if (target === name) commandAliases.push(alias);
+			result.push({
+				name,
+				description: staticCommand.description,
+				aliases: commandAliases
+			});
+		}
+		return result.sort((a, b) => a.name.localeCompare(b.name));
+	}
+	/**
+	* Generate a compact listing of all commands with visual hierarchy and colors.
+	*/
+	async listUsage(options) {
+		const commands = this.list();
+		const { generateListing } = await import("./usage-generator-CVIsENuE.mjs").then((n) => n.n);
+		return generateListing(commands, this.signatures, options);
+	}
+	/**
+	* Get auto-generated usage text for a command.
+	*/
+	async usage(name) {
+		const resolvedName = this.resolveName(name);
+		const CommandClass = this.commands.get(resolvedName);
+		if (!CommandClass) throw new CommandNotFoundError(name);
+		const signature = this.signatures.get(resolvedName);
+		const staticCommand = CommandClass;
+		const { generateUsage } = await import("./usage-generator-CVIsENuE.mjs").then((n) => n.n);
+		return generateUsage(signature, staticCommand.description);
+	}
+	/**
+	* Register a command constructor with the registry.
+	* @internal Called by Application during bootstrap.
+	*/
+	register(commandClass) {
+		const staticCommand = commandClass;
+		if (!staticCommand.command) throw new CommandError(`Command class ${commandClass.name} is missing static "command" signature`);
+		const signature = parseSignature(staticCommand.command);
+		const name = signature.name;
+		if (this.commands.has(name) || this.aliases.has(name)) throw new CommandError(`Duplicate command name: "${name}" is already registered`);
+		if (staticCommand.aliases) {
+			for (const alias of staticCommand.aliases) if (this.commands.has(alias) || this.aliases.has(alias)) throw new CommandError(`Duplicate alias: "${alias}" conflicts with an existing command or alias`);
+		}
+		this.commands.set(name, commandClass);
+		this.signatures.set(name, signature);
+		if (staticCommand.aliases) for (const alias of staticCommand.aliases) this.aliases.set(alias, name);
+	}
+	handleError(error) {
+		return this.container.resolve(DI_TOKENS.ErrorHandler).handle(error).message;
+	}
+	resolveName(name) {
+		return this.aliases.get(name) ?? name;
+	}
+	applyDefaults(input, signature) {
+		const result = { ...input };
+		for (const arg of signature.arguments) if (result[arg.name] === void 0 && arg.default !== void 0) result[arg.name] = arg.default;
+		for (const opt of signature.options) if (result[opt.name] === void 0) {
+			if (opt.default !== void 0) result[opt.name] = opt.default;
+			else if (opt.isFlag) result[opt.name] = false;
+		}
+		return result;
+	}
+};
+QuarryRegistry = __decorate([
+	Transient(DI_TOKENS.Quarry),
+	__decorateParam(0, inject(DI_TOKENS.Container)),
+	__decorateMetadata("design:paramtypes", [Object])
+], QuarryRegistry);
+//#endregion
+export { QueueListCommand as a, HelpCommand as c, ApiCommand as d, RouteListCommand as i, CommandNotFoundError as l, parseSignature as n, McpToolsCommand as o, ScheduleListCommand as r, McpServeCommand as s, QuarryRegistry as t, EventListCommand as u };
+
+//# sourceMappingURL=quarry-registry-B2rkO-JS.mjs.map