stratal 0.0.20 → 0.0.22

package/dist/quarry/runner.mjs

@@ -0,0 +1,775 @@
+import { c as DI_TOKENS, m as inject, o as ROUTER_TOKENS } from "../di-BO1QIb5H.mjs";
+import { n as __decorateParam, t as __decorate } from "../decorate-HgTKAYK8.mjs";
+import "../logger/index.mjs";
+import { f as Module } from "../module-xYoHba6B.mjs";
+import { r as getListenerHandlers } from "../events-D1KdDaiP.mjs";
+import { a as green, n as cyan, o as red, s as yellow, t as bold } from "../colors-axmupKdp.mjs";
+import { t as Command } from "../command-BU4ApTo5.mjs";
+import { t as I18N_TOKENS } from "../i18n.tokens-hwRpmjRq.mjs";
+import { a as OPENAPI_TOKENS, t as OpenApiToolsService } from "../openapi-C6lm0RmV.mjs";
+import { r as CommandNotFoundError } from "../quarry-registry-DkraZNwn.mjs";
+import { t as Stratal } from "../stratal-Bdq4IdB3.mjs";
+import { n as DbSeedListCommand, t as DbSeedCommand } from "../seeder-BADTig4n.mjs";
+import { z } from "zod";
+import { writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+//#region src/quarry/commands/api.command.ts
+let ApiCommand = class ApiCommand extends Command {
+	app;
+	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 (await this.app.ensureHono()).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))], ApiCommand);
+//#endregion
+//#region src/quarry/commands/event-list.command.ts
+let EventListCommand = class EventListCommand extends Command {
+	modules;
+	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))], EventListCommand);
+//#endregion
+//#region src/quarry/commands/help.command.ts
+let HelpCommand = class HelpCommand extends Command {
+	quarryRegistry;
+	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))], HelpCommand);
+//#endregion
+//#region src/quarry/commands/i18n-utils.ts
+function computeKeyDiff(baseKeys, targetKeys) {
+	const missing = [];
+	const extra = [];
+	for (const key of baseKeys) if (!targetKeys.has(key)) missing.push(key);
+	for (const key of targetKeys) if (!baseKeys.has(key)) extra.push(key);
+	return {
+		missing: missing.sort(),
+		extra: extra.sort()
+	};
+}
+function extractNamespace(key, depth) {
+	return key.split(".").slice(0, depth).join(".");
+}
+//#endregion
+//#region src/quarry/commands/i18n-check.command.ts
+let I18nCheckCommand = class I18nCheckCommand extends Command {
+	loader;
+	static command = "i18n:check {--locale= : Check a specific locale only} {--prefix= : Filter by namespace prefix}";
+	static description = "Check i18n translations for missing or extra keys";
+	constructor(loader) {
+		super();
+		this.loader = loader;
+	}
+	handle() {
+		const localeFilter = this.string("locale");
+		const prefix = this.string("prefix");
+		const filterOptions = prefix ? { only: [prefix] } : void 0;
+		const enKeys = new Set(Object.keys(this.loader.getFilteredMessages("en", filterOptions)));
+		if (enKeys.size === 0) {
+			this.info("No message keys found");
+			return 0;
+		}
+		const locales = this.loader.getAvailableLocales().filter((l) => l !== "en");
+		const targets = localeFilter ? locales.filter((l) => l === localeFilter) : locales;
+		if (targets.length === 0) {
+			this.info(localeFilter ? `Locale "${localeFilter}" not found` : "No non-en locales configured");
+			return 0;
+		}
+		let totalIssues = 0;
+		const summaryRows = [];
+		for (const locale of targets) {
+			const { missing, extra } = computeKeyDiff(enKeys, new Set(Object.keys(this.loader.getFilteredMessages(locale, filterOptions))));
+			this.newLine();
+			this.info(`Locale: ${locale}`);
+			if (missing.length > 0) {
+				this.warn(`  Missing (${missing.length}):`);
+				for (const key of missing) this.line(`    ${key}`);
+			} else this.line("  Missing (0)");
+			if (extra.length > 0) {
+				this.warn(`  Extra (${extra.length}):`);
+				for (const key of extra) this.line(`    ${key}`);
+			} else this.line("  Extra (0)");
+			totalIssues += missing.length + extra.length;
+			summaryRows.push([
+				locale,
+				String(enKeys.size),
+				String(missing.length),
+				String(extra.length)
+			]);
+		}
+		this.newLine();
+		this.table([
+			"Locale",
+			"Total",
+			"Missing",
+			"Extra"
+		], summaryRows);
+		if (totalIssues > 0) {
+			this.newLine();
+			this.fail(`${totalIssues} issue(s) found`);
+			return;
+		}
+		this.newLine();
+		this.success("All translations are complete");
+		return 0;
+	}
+};
+I18nCheckCommand = __decorate([__decorateParam(0, inject(I18N_TOKENS.MessageLoader))], I18nCheckCommand);
+//#endregion
+//#region src/quarry/commands/i18n-duplicates.command.ts
+let I18nDuplicatesCommand = class I18nDuplicatesCommand extends Command {
+	loader;
+	static command = "i18n:duplicates {--locale= : Locale to check (default: en)} {--prefix= : Filter by namespace prefix}";
+	static description = "Find i18n keys with duplicate translation values";
+	constructor(loader) {
+		super();
+		this.loader = loader;
+	}
+	handle() {
+		const locale = this.string("locale") || "en";
+		const prefix = this.string("prefix");
+		const filterOptions = prefix ? { only: [prefix] } : void 0;
+		const messages = this.loader.getFilteredMessages(locale, filterOptions);
+		const valueToKeys = /* @__PURE__ */ new Map();
+		for (const [key, value] of Object.entries(messages)) {
+			const existing = valueToKeys.get(value);
+			if (existing) existing.push(key);
+			else valueToKeys.set(value, [key]);
+		}
+		const duplicates = [];
+		for (const [value, keys] of valueToKeys) if (keys.length > 1) duplicates.push([value, keys.sort().join(", ")]);
+		if (duplicates.length === 0) {
+			this.info("No duplicate values found");
+			return 0;
+		}
+		duplicates.sort((a, b) => a[0].localeCompare(b[0]));
+		this.table(["Value", "Keys"], duplicates);
+		return 0;
+	}
+};
+I18nDuplicatesCommand = __decorate([__decorateParam(0, inject(I18N_TOKENS.MessageLoader))], I18nDuplicatesCommand);
+//#endregion
+//#region src/quarry/commands/i18n-list.command.ts
+let I18nListCommand = class I18nListCommand extends Command {
+	loader;
+	static command = "i18n:list {--locale= : Show keys for a specific locale} {--prefix= : Filter by namespace prefix} {--values : Show translated values}";
+	static description = "List all i18n message keys";
+	constructor(loader) {
+		super();
+		this.loader = loader;
+	}
+	handle() {
+		const localeFilter = this.string("locale");
+		const prefix = this.string("prefix");
+		const showValues = this.boolean("values");
+		const filterOptions = prefix ? { only: [prefix] } : void 0;
+		const enMessages = this.loader.getFilteredMessages("en", filterOptions);
+		const enKeys = Object.keys(enMessages).sort();
+		if (enKeys.length === 0) {
+			this.info("No message keys found");
+			return 0;
+		}
+		if (localeFilter && showValues) {
+			const localeMessages = this.loader.getFilteredMessages(localeFilter, filterOptions);
+			const rows = enKeys.map((key) => [key, localeMessages[key] ?? "-"]);
+			this.table(["Key", "Value"], rows);
+			return 0;
+		}
+		const locales = localeFilter ? [localeFilter] : this.loader.getAvailableLocales();
+		const localeMessages = /* @__PURE__ */ new Map();
+		for (const locale of locales) localeMessages.set(locale, new Set(Object.keys(this.loader.getFilteredMessages(locale, filterOptions))));
+		const headers = ["Key", ...locales];
+		const rows = enKeys.map((key) => {
+			return [key, ...locales.map((locale) => localeMessages.get(locale).has(key) ? "Y" : "N")];
+		});
+		this.table(headers, rows);
+		return 0;
+	}
+};
+I18nListCommand = __decorate([__decorateParam(0, inject(I18N_TOKENS.MessageLoader))], I18nListCommand);
+//#endregion
+//#region src/quarry/commands/i18n-namespaces.command.ts
+let I18nNamespacesCommand = class I18nNamespacesCommand extends Command {
+	loader;
+	static command = "i18n:namespaces {--depth= : Namespace depth (default: 1)} {--locale= : Show counts for a specific locale}";
+	static description = "List i18n message namespaces with key counts";
+	constructor(loader) {
+		super();
+		this.loader = loader;
+	}
+	handle() {
+		const depth = this.number("depth") || 1;
+		const localeFilter = this.string("locale");
+		const locales = localeFilter ? [localeFilter] : this.loader.getAvailableLocales();
+		const namespaceCounts = /* @__PURE__ */ new Map();
+		for (const locale of locales) {
+			const messages = this.loader.getFilteredMessages(locale);
+			for (const key of Object.keys(messages)) {
+				const ns = extractNamespace(key, depth);
+				if (!namespaceCounts.has(ns)) namespaceCounts.set(ns, /* @__PURE__ */ new Map());
+				const counts = namespaceCounts.get(ns);
+				counts.set(locale, (counts.get(locale) ?? 0) + 1);
+			}
+		}
+		if (namespaceCounts.size === 0) {
+			this.info("No namespaces found");
+			return 0;
+		}
+		const sortedNamespaces = [...namespaceCounts.keys()].sort();
+		const headers = ["Namespace", ...locales];
+		const rows = sortedNamespaces.map((ns) => {
+			const counts = namespaceCounts.get(ns);
+			return [ns, ...locales.map((locale) => String(counts.get(locale) ?? 0))];
+		});
+		this.table(headers, rows);
+		return 0;
+	}
+};
+I18nNamespacesCommand = __decorate([__decorateParam(0, inject(I18N_TOKENS.MessageLoader))], I18nNamespacesCommand);
+//#endregion
+//#region src/quarry/commands/i18n-search.command.ts
+let I18nSearchCommand = class I18nSearchCommand extends Command {
+	loader;
+	static command = "i18n:search {query : Search term (substring match)} {--locale= : Locale to search in (default: en)} {--keys-only : Only match key names, not values}";
+	static description = "Search for i18n message keys or values";
+	constructor(loader) {
+		super();
+		this.loader = loader;
+	}
+	handle() {
+		const query = this.string("query").toLowerCase();
+		const locale = this.string("locale") || "en";
+		const keysOnly = this.boolean("keys-only");
+		const messages = this.loader.getFilteredMessages(locale);
+		const matches = [];
+		for (const [key, value] of Object.entries(messages)) {
+			const keyMatch = key.toLowerCase().includes(query);
+			const valueMatch = !keysOnly && value.toLowerCase().includes(query);
+			if (keyMatch || valueMatch) matches.push([key, value]);
+		}
+		if (matches.length === 0) {
+			this.info(`No keys matching "${this.string("query")}" found`);
+			return 0;
+		}
+		matches.sort((a, b) => a[0].localeCompare(b[0]));
+		this.table(["Key", "Value"], matches);
+		return 0;
+	}
+};
+I18nSearchCommand = __decorate([__decorateParam(0, inject(I18N_TOKENS.MessageLoader))], I18nSearchCommand);
+//#endregion
+//#region src/quarry/commands/i18n-stats.command.ts
+let I18nStatsCommand = class I18nStatsCommand extends Command {
+	loader;
+	static command = "i18n:stats {--prefix= : Filter by namespace prefix}";
+	static description = "Show i18n translation coverage statistics";
+	constructor(loader) {
+		super();
+		this.loader = loader;
+	}
+	handle() {
+		const prefix = this.string("prefix");
+		const filterOptions = prefix ? { only: [prefix] } : void 0;
+		const enKeys = new Set(Object.keys(this.loader.getFilteredMessages("en", filterOptions)));
+		if (enKeys.size === 0) {
+			this.info("No message keys found");
+			return 0;
+		}
+		const locales = this.loader.getAvailableLocales();
+		const rows = [];
+		for (const locale of locales) {
+			const localeKeys = new Set(Object.keys(this.loader.getFilteredMessages(locale, filterOptions)));
+			const isBase = locale === "en";
+			let translated = 0;
+			for (const key of enKeys) if (localeKeys.has(key)) translated++;
+			const missing = enKeys.size - translated;
+			let extra = 0;
+			for (const key of localeKeys) if (!enKeys.has(key)) extra++;
+			const coverage = (translated / enKeys.size * 100).toFixed(1) + "%";
+			rows.push([
+				locale,
+				String(enKeys.size),
+				String(translated),
+				String(missing),
+				isBase ? "-" : String(extra),
+				coverage
+			]);
+		}
+		this.table([
+			"Locale",
+			"Keys",
+			"Translated",
+			"Missing",
+			"Extra",
+			"Coverage"
+		], rows);
+		return 0;
+	}
+};
+I18nStatsCommand = __decorate([__decorateParam(0, inject(I18N_TOKENS.MessageLoader))], I18nStatsCommand);
+//#endregion
+//#region src/quarry/commands/mcp-serve.command.ts
+let McpServeCommand = class McpServeCommand extends Command {
+	app;
+	openAPIService;
+	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 hono = await this.app.ensureHono();
+		const spec = this.openAPIService.getSpec(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 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))], McpServeCommand);
+//#endregion
+//#region src/quarry/commands/mcp-tools.command.ts
+let McpToolsCommand = class McpToolsCommand extends Command {
+	app;
+	openAPIService;
+	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;
+	}
+	async handle() {
+		const tags = this.array("tag");
+		const pathPrefix = this.string("path");
+		const hono = await this.app.ensureHono();
+		const service = new OpenApiToolsService(this.openAPIService.getSpec(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))], McpToolsCommand);
+//#endregion
+//#region src/quarry/commands/queue-list.command.ts
+let QueueListCommand = class QueueListCommand extends Command {
+	consumers;
+	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))], QueueListCommand);
+//#endregion
+//#region src/quarry/commands/route-list.command.ts
+let RouteListCommand = class RouteListCommand extends Command {
+	registry;
+	static command = "route:list {--method= : Filter by HTTP method} {--path= : Filter by path substring} {--name= : Filter by route name} {--hidden : Include hidden routes}";
+	static description = "List all registered routes";
+	constructor(registry) {
+		super();
+		this.registry = registry;
+	}
+	handle() {
+		const methodFilter = this.string("method").toUpperCase();
+		const pathFilter = this.string("path");
+		const nameFilter = this.string("name");
+		const showHidden = this.boolean("hidden");
+		let routes = this.registry.all();
+		if (!showHidden) routes = routes.filter((r) => !r.hidden);
+		if (methodFilter) routes = routes.filter((r) => r.method.toUpperCase() === methodFilter);
+		if (pathFilter) routes = routes.filter((r) => r.path.includes(pathFilter));
+		if (nameFilter) routes = routes.filter((r) => r.name?.includes(nameFilter));
+		if (routes.length === 0) {
+			this.info("No routes found");
+			return 0;
+		}
+		this.table([
+			"Method",
+			"Path",
+			"Name",
+			"Handler",
+			"Domain"
+		], routes.map((r) => this.formatRow(r)));
+	}
+	formatRow(route) {
+		return [
+			route.method.toUpperCase(),
+			route.path,
+			route.name ?? "-",
+			`${route.controller}.${route.action}`,
+			route.domain ?? "-"
+		];
+	}
+};
+RouteListCommand = __decorate([__decorateParam(0, inject(ROUTER_TOKENS.RouteRegistry))], RouteListCommand);
+//#endregion
+//#region src/quarry/commands/route-types.command.ts
+let RouteTypesCommand = class RouteTypesCommand extends Command {
+	registry;
+	localePathService;
+	static command = "route:types {--output=src/stratal.d.ts : Output file path}";
+	static description = "Generate TypeScript types for named routes";
+	constructor(registry, localePathService) {
+		super();
+		this.registry = registry;
+		this.localePathService = localePathService;
+	}
+	handle() {
+		const outputPath = resolve(this.string("output") || "src/stratal.d.ts");
+		const namedRoutes = this.registry.named();
+		if (namedRoutes.length === 0) {
+			this.warn("No named routes found. Add name to your @Route() or @Get()/@Post() decorators.");
+			return 0;
+		}
+		writeFileSync(outputPath, this.generateDeclaration(namedRoutes), "utf-8");
+		this.info(`Generated route types for ${namedRoutes.length} named routes → ${outputPath}`);
+	}
+	/**
+	* Generate the StratalRouteMap declaration content.
+	*/
+	generateDeclaration(routes) {
+		const localeConfig = this.localePathService.enabled ? this.localePathService.localePathConfig : null;
+		const localeType = localeConfig ? localeConfig.allLocales.map((l) => `'${l}'`).join(" | ") : null;
+		const localeOptional = localeConfig ? this.localePathService.prefixDefaultLocale !== true : false;
+		const entries = routes.filter((r) => r.name !== void 0).sort((a, b) => a.name.localeCompare(b.name)).map((route) => {
+			const paramEntries = [...route.paramNames.map((p) => `${p}: string`), ...route.domainParamNames.map((p) => `${p}: string`)];
+			if (localeType && route.localePaths?.length) {
+				const optionalMarker = localeOptional ? "?" : "";
+				paramEntries.push(`locale${optionalMarker}: StratalLocale`);
+			}
+			const indexSignature = localeType && route.localePaths?.length ? "[key: string]: string | StratalLocale | undefined" : "[key: string]: string | undefined";
+			paramEntries.push(indexSignature);
+			const paramsType = `{ ${paramEntries.join("; ")} }`;
+			return `    '${route.name}': { params: ${paramsType} }`;
+		}).join("\n");
+		const lines = ["// Auto-generated by `quarry route:types` — do not edit manually", "declare module 'stratal/router' {"];
+		if (localeType) {
+			lines.push(`  type StratalLocale = ${localeType}`);
+			lines.push("");
+		}
+		lines.push("  interface StratalRouteMap {", entries, "  }", "}");
+		return [
+			...lines,
+			"",
+			"export {}",
+			""
+		].join("\n");
+	}
+};
+RouteTypesCommand = __decorate([__decorateParam(0, inject(ROUTER_TOKENS.RouteRegistry)), __decorateParam(1, inject(ROUTER_TOKENS.LocalePathService))], RouteTypesCommand);
+//#endregion
+//#region src/quarry/commands/schedule-list.command.ts
+let ScheduleListCommand = class ScheduleListCommand extends Command {
+	cron;
+	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 { jobClass } of jobs) rows.push([schedule, jobClass.name]);
+		}
+		this.table(["Schedule", "Job"], rows);
+	}
+};
+ScheduleListCommand = __decorate([__decorateParam(0, inject(DI_TOKENS.Cron))], ScheduleListCommand);
+//#endregion
+//#region src/quarry/builtin-quarry.module.ts
+let BuiltinQuarryModule = class BuiltinQuarryModule {};
+BuiltinQuarryModule = __decorate([Module({ providers: [
+	HelpCommand,
+	DbSeedCommand,
+	DbSeedListCommand,
+	RouteListCommand,
+	RouteTypesCommand,
+	EventListCommand,
+	ScheduleListCommand,
+	QueueListCommand,
+	McpServeCommand,
+	McpToolsCommand,
+	ApiCommand,
+	I18nCheckCommand,
+	I18nDuplicatesCommand,
+	I18nListCommand,
+	I18nNamespacesCommand,
+	I18nSearchCommand,
+	I18nStatsCommand
+] })], BuiltinQuarryModule);
+//#endregion
+//#region src/quarry/quarry-runner.ts
+/**
+* Builds a `Stratal` instance for the quarry CLI entry (`src/quarry.ts`).
+*
+* Synthesizes a wrapper module from the given `imports` and `providers`,
+* so CLI-only classes (seeders, ecosystem CLI commands) stay out of the
+* worker bundle — `src/index.ts` doesn't reference any of them. Forces
+* CLI-friendly logging defaults (`level: 'error'`, `formatter: 'pretty'`).
+*
+* @example
+* ```ts
+* // src/quarry.ts
+* export default QuarryRunner.run({
+*   imports: [AppModule, InertiaQuarryModule],
+*   providers: [GeoSeeder, DemoSeeder],
+* })
+* ```
+*/
+var QuarryRunner = class {
+	static run(options) {
+		let QuarryEntryModule = class QuarryEntryModule {};
+		QuarryEntryModule = __decorate([Module({
+			imports: [BuiltinQuarryModule, ...options.imports],
+			providers: options.providers ?? []
+		})], QuarryEntryModule);
+		return new Stratal({
+			module: QuarryEntryModule,
+			exceptionHandler: options.exceptionHandler,
+			logging: {
+				level: "error",
+				formatter: "pretty"
+			}
+		});
+	}
+};
+//#endregion
+export { ApiCommand, BuiltinQuarryModule, EventListCommand, HelpCommand, McpServeCommand, McpToolsCommand, QuarryRunner, QueueListCommand, RouteListCommand, RouteTypesCommand, ScheduleListCommand };
+
+//# sourceMappingURL=runner.mjs.map