@callidescope/cli 0.0.1

package/dist/main.module-tKMvFmcY.js

@@ -0,0 +1,1476 @@
+import { CHECK_NAMES as e, ConfigurationModule as t, ConfigurationService as n, DEFAULT_JSON_INDENTATION as r, DEFAULT_PREVIEW_COUNT as i, DEFAULT_RUN_HEADING as a, InputError as o, ProjectConfigurationError as s, ProjectConfigurationFieldNotPermittedError as c } from "@callidescope/configuration";
+import { ConsoleLogger as l, Global as u, Injectable as d, Module as f, Scope as ee } from "@nestjs/common";
+import { ConfigModule as te } from "@nestjs/config";
+import { DiscoveryModule as ne } from "@nestjs/core";
+import { existsSync as re, mkdirSync as ie } from "node:fs";
+import p from "node:path";
+import m from "pino";
+import { z as ae } from "zod";
+import { AddressDepthService as oe, AddressService as h, BreadthService as se, CallablesModule as g, CallablesService as ce, ClassesModule as le, ClassesService as ue, EdgesModule as de, EntriesModule as fe, EntriesService as pe, ExternalService as me, FileFilterService as _, GraphAssemblyService as he, GraphModule as v, ProgramConfigurationError as ge, ProgramModule as _e, ProgramService as y, WorkspaceModule as b, WorkspaceService as x } from "@callidescope/graph";
+import { AddressReportModule as ve, AddressReportService as S, MarkdownReportService as ye, OutputJsonModule as be, OutputJsonService as xe, OutputMarkdownModule as Se, ProjectReportsModule as Ce, ProjectReportsService as we, ReportFindingsModule as Te, ReportFindingsService as Ee, ReportModule as De, WriteDestinationsModule as Oe, WriteDestinationsService as ke } from "@callidescope/output";
+import { Command as C, CommandRunner as w, Option as T } from "nest-commander";
+//#region packages/logger/src/modules/logger/logger.constants.ts
+var Ae = /^(\p{Extended_Pictographic}️?(?:‍\p{Extended_Pictographic}️?)*)\s+/u, je = /^([A-Za-z]+)/, Me = /* @__PURE__ */ new Set([
+	"built",
+	"cut",
+	"found",
+	"got",
+	"kept",
+	"left",
+	"lost",
+	"made",
+	"put",
+	"ran",
+	"read",
+	"rebuilt",
+	"sent",
+	"set",
+	"split",
+	"took",
+	"wrote"
+]), Ne = /* @__PURE__ */ new Set([
+	"CommandFactory",
+	"ExceptionHandler",
+	"GraphQLModule",
+	"InstanceLoader",
+	"NestApplication",
+	"NestFactory",
+	"RouterExplorer",
+	"RoutesResolver",
+	"TypeOrmModule"
+]);
+//#endregion
+//#region \0@oxc-project+runtime@0.151.0/helpers/esm/decorateMetadata.js
+function E(e, t) {
+	if (typeof Reflect == "object" && typeof Reflect.metadata == "function") return Reflect.metadata(e, t);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.151.0/helpers/esm/decorate.js
+function D(e, t, n, r) {
+	var i = arguments.length, a = i < 3 ? t : r === null ? r = Object.getOwnPropertyDescriptor(t, n) : r, o;
+	if (typeof Reflect == "object" && typeof Reflect.decorate == "function") a = Reflect.decorate(e, t, n, r);
+	else for (var s = e.length - 1; s >= 0; s--) (o = e[s]) && (a = (i < 3 ? o(a) : i > 3 ? o(t, n, a) : o(t, n)) || a);
+	return i > 3 && a && Object.defineProperty(t, n, a), a;
+}
+//#endregion
+//#region packages/logger/src/modules/logger/logger.service.ts
+var O, k = class extends l {
+	static {
+		O = this;
+	}
+	constructor() {
+		super();
+	}
+	static isProduction = process.env.NODE_ENV === "production";
+	static rootLogger;
+	static writesToStandardError = !1;
+	child = O.root;
+	static createRootLogger() {
+		let e = process.env.LOG_LEVEL ?? "info";
+		return O.isProduction ? O.writesToStandardError ? m({ level: e }, m.destination(2)) : m({ level: e }) : m({
+			level: e,
+			transport: {
+				options: {
+					colorize: !0,
+					destination: O.writesToStandardError ? 2 : 1,
+					ignore: "pid,hostname,emoji",
+					messageFormat: "{emoji} {msg}",
+					singleLine: !0
+				},
+				target: "pino-pretty"
+			}
+		});
+	}
+	static logToStandardError() {
+		if (O.rootLogger !== void 0) {
+			process.emitWarning("LoggerService.logToStandardError() was called after the first log line, so log lines still go to standard output and anything piping that stream will read them as data. Call it as the first statement of the application's bootstrap.");
+			return;
+		}
+		O.writesToStandardError = !0;
+	}
+	assertConventionalMessage(e) {
+		if (O.isProduction || this.shouldSkipConventionalMessageValidation(e.context)) return;
+		let t = this.getConventionalMessageViolation(e.parsed);
+		if (t !== void 0) throw Error(t);
+	}
+	buildBindings(e) {
+		return this.assertConventionalMessage({
+			context: e.context,
+			parsed: e.parsed
+		}), {
+			...e.data,
+			context: e.context,
+			...O.isProduction ? {} : { emoji: e.parsed.emoji }
+		};
+	}
+	getConventionalMessageViolation(e) {
+		let t = e.emoji, n = e.text;
+		if (t === void 0) return `Log message must start with an emoji naming its subject, then a verb: "${n}"`;
+		let r = je.exec(n)?.[1];
+		if (r === void 0 || !this.isConventionalVerb(r)) return `Log message must begin with a verb in present progressive or past tense, got "${r ?? ""}": "${t} ${n}"`;
+	}
+	isConventionalVerb(e) {
+		let t = e.toLowerCase();
+		return t.endsWith("ing") || t.endsWith("ed") || Me.has(t);
+	}
+	parseMessage(e) {
+		let t = String(e), n = Ae.exec(t), r = n?.[1];
+		return r === void 0 ? {
+			emoji: void 0,
+			text: t
+		} : {
+			emoji: r,
+			text: t.slice(n?.[0].length)
+		};
+	}
+	shouldSkipConventionalMessageValidation(e) {
+		return e !== void 0 && Ne.has(e);
+	}
+	static get root() {
+		return O.rootLogger ??= O.createRootLogger(), O.rootLogger;
+	}
+	buildErrorLogEntry(e, t) {
+		let n = t instanceof Error ? t.stack || t.message : String(t);
+		return {
+			errorMessage: n,
+			logLine: `[${(/* @__PURE__ */ new Date()).toISOString()}] ${e}: ${n}\n`
+		};
+	}
+	createTimestampedOutputLogFilePath(e) {
+		let t = p.join(process.cwd(), "output");
+		return re(t) || ie(t, { recursive: !0 }), p.join(t, `${e}-${(/* @__PURE__ */ new Date()).toISOString().replaceAll(/[:.]/g, "-")}.log`);
+	}
+	debug(e, t, n) {
+		let r = this.parseMessage(e);
+		this.child.debug(this.buildBindings({
+			context: t ?? this.context,
+			data: n,
+			parsed: r
+		}), r.text);
+	}
+	error(e, t, n) {
+		let r = this.parseMessage(e), i = typeof n == "object" ? n : void 0, a = typeof n == "string" ? n : this.context;
+		this.child.error({
+			...this.buildBindings({
+				context: a,
+				data: i,
+				parsed: r
+			}),
+			stack: t
+		}, r.text);
+	}
+	info(e, t, n) {
+		let r = this.parseMessage(e);
+		this.child.info(this.buildBindings({
+			context: t ?? this.context,
+			data: n,
+			parsed: r
+		}), r.text);
+	}
+	log(e, t, n) {
+		this.info(e, t, n);
+	}
+	setContext(e) {
+		super.setContext(e), this.child = O.root.child({ context: e });
+	}
+	verbose(e, t, n) {
+		let r = this.parseMessage(e);
+		this.child.trace(this.buildBindings({
+			context: t ?? this.context,
+			data: n,
+			parsed: r
+		}), r.text);
+	}
+	warn(e, t, n) {
+		let r = this.parseMessage(e);
+		this.child.warn(this.buildBindings({
+			context: t ?? this.context,
+			data: n,
+			parsed: r
+		}), r.text);
+	}
+};
+k = O = D([d({ scope: ee.TRANSIENT }), E("design:paramtypes", [])], k);
+//#endregion
+//#region packages/logger/src/modules/logger/logger.module.ts
+var A = class {};
+A = D([u(), f({
+	controllers: [],
+	exports: [k],
+	imports: [],
+	providers: [k]
+})], A);
+//#endregion
+//#region packages/ic-suite/callidescope/callidescope-cli/src/constants.ts
+var Pe = ae.object({}), Fe = "Check the file path and the qualified name callidescope prints for it in a stack.", Ie = "🔭 Rejected a callable address", Le = (e) => e instanceof s || e instanceof c, j = "🔭 Rejected the command line", Re = "🔭 Rejected a project it could not read", ze = "🔭 Rejected a project configuration", Be = (e) => `${e} is not a callidescope command, and the trace takes no positional arguments. Run one of depth, breadth, or limits, or drop the argument to trace the workspace.`, M = (e) => e instanceof ge ? Re : Le(e) || e instanceof N ? ze : e instanceof o ? j : void 0, N = class e extends Error {
+	constructor(t) {
+		super(e.joinDescriptions(t)), this.name = "UnresolvedEntryPointAddressError";
+	}
+	static joinDescriptions(e) {
+		let [t] = e;
+		if (t !== void 0 && e.length === 1) return t;
+		let n = e.map((e, t) => `(${String(t + 1)}) ${e}`).join(" ");
+		return `${String(e.length)} declared entry points did not resolve. ${n}`;
+	}
+}, P, F = P = class {
+	callablesService;
+	classHierarchyService;
+	entryPointsService;
+	externalService;
+	fileFilterService;
+	graphAssemblyService;
+	programService;
+	configurationService;
+	projectReportsService;
+	workspaceService;
+	logger;
+	constructor(e, t, n, r, i, a, o, s, c, l, u) {
+		this.callablesService = e, this.classHierarchyService = t, this.entryPointsService = n, this.externalService = r, this.fileFilterService = i, this.graphAssemblyService = a, this.programService = o, this.configurationService = s, this.projectReportsService = c, this.workspaceService = l, this.logger = u, this.logger.setContext(P.name);
+	}
+	async discoverCallables(e) {
+		let { fileFilter: t, programSet: n, projects: r, startingProjects: i } = this.discoverPrograms(e), a = r.map((e) => e.name), o = await this.loadProjectDeclarations({
+			authoredLimits: e.authoredLimits,
+			configuration: e.configuration,
+			configurationPath: e.configurationPath,
+			limitOverrides: e.limitOverrides,
+			projectNames: a,
+			workspaceRoot: e.workspaceRoot
+		});
+		this.externalService.configure({
+			ownedFilePaths: new Set(n.ownerByFilePath.keys()),
+			workspaceRoot: e.workspaceRoot
+		}), this.classHierarchyService.build({ programs: n.programs });
+		let s = this.callablesService.collect({
+			fileFilter: this.fileFilterService.buildProjectFileFilter({
+				excludeByProject: o.excludeByProject,
+				fileFilter: t,
+				projects: r
+			}),
+			includeTests: e.configuration.entryPoints.includeTests,
+			includeTestsByProject: new Map([...o.entryPointsByProject].map(([e, t]) => [e, t.includeTests])),
+			ownerByFilePath: n.ownerByFilePath,
+			workspaceRoot: e.workspaceRoot
+		});
+		return {
+			...o,
+			collection: s,
+			projectNames: a,
+			startingProjectRoots: new Map(i.map((e) => [e.name, e.root]))
+		};
+	}
+	discoverPrograms(e) {
+		let t = this.fileFilterService.buildFileFilter({
+			exclude: e.configuration.exclude,
+			excludeFrom: e.configuration.excludeFrom,
+			workspaceRoot: e.workspaceRoot
+		}), n = this.workspaceService.discoverProjects({
+			directories: e.directories,
+			fileFilter: t,
+			workspaceRoot: e.workspaceRoot
+		}), r = e.directories.length === 0 ? n : this.workspaceService.discoverProjects({
+			directories: [],
+			fileFilter: t,
+			workspaceRoot: e.workspaceRoot
+		}), i = this.programService.buildPrograms({
+			startingProjects: n,
+			workspaceProjects: r,
+			workspaceRoot: e.workspaceRoot
+		});
+		return {
+			fileFilter: t,
+			programSet: i,
+			projects: i.programs.map((e) => e.project),
+			startingProjects: n
+		};
+	}
+	async loadProjectDeclarations(e) {
+		let t = await this.configurationService.loadProjectConfigurations({
+			projects: e.projectNames,
+			workspaceConfigurationPath: e.configurationPath,
+			workspaceRoot: e.workspaceRoot
+		});
+		return {
+			entryPointsByProject: new Map(t.map((e) => [e.project, e.configuration.entryPoints])),
+			excludeByProject: new Map(t.filter((e) => (e.authored.exclude ?? []).length > 0).map((e) => [e.project, e.authored.exclude ?? []])),
+			projectLimits: this.configurationService.resolveLimits({
+				limitOverrides: e.limitOverrides,
+				projectConfigurations: t,
+				projects: e.projectNames,
+				workspaceAuthoredLimits: e.authoredLimits,
+				workspaceConfiguration: e.configuration,
+				workspaceConfigurationPath: e.configurationPath
+			}),
+			writeByProject: new Map(t.map((e) => [e.project, e.configuration.write]))
+		};
+	}
+	readMaximumDepth(e) {
+		return e.byComponent.reduce((e, t) => Math.max(e, t.depth), 0);
+	}
+	analyze(e) {
+		let { breadthMeasurement: t, condensed: n, graph: r, measurement: i } = this.graphAssemblyService.assemble({
+			callablesById: e.callablesById,
+			excludeCallees: e.configuration.excludeCallees,
+			includeConstructorEdges: !0,
+			workspaceRoot: e.workspaceRoot
+		}), a = this.entryPointsService.resolve({
+			callablesById: e.callablesById,
+			entryPoints: e.configuration.entryPoints,
+			entryPointsByProject: e.entryPointsByProject,
+			graph: r,
+			workspaceRoot: e.workspaceRoot
+		}), o = this.projectReportsService.build({
+			breadthMeasurement: t,
+			callablesById: e.callablesById,
+			condensed: n,
+			entryPoints: a,
+			fileCountByProject: e.fileCountByProject,
+			graph: r,
+			measurement: i,
+			projectNames: e.projectNames
+		}), s = {
+			callableCount: e.callablesById.size,
+			cyclicComponentCount: n.memberIdsByComponent.filter((e) => e.length > 1).length,
+			edgeCount: r.edges.length,
+			entryPointCount: a.entryPoints.length,
+			fileCount: e.fileCount,
+			maximumDepth: this.readMaximumDepth(i),
+			projectCount: e.projectCount,
+			unresolvedCallCount: r.unresolvedCalls.length
+		};
+		return this.logger.info("🔭 Finished an analysis", void 0, {
+			callableCount: s.callableCount,
+			edgeCount: s.edgeCount,
+			entryPointCount: s.entryPointCount,
+			maximumDepthTraced: s.maximumDepth
+		}), {
+			projectLimits: e.projectLimits,
+			result: {
+				deepStacks: this.projectReportsService.findDeepStacks({
+					limits: e.projectLimits,
+					reports: o
+				}),
+				projects: o,
+				summary: s,
+				wideCallables: this.projectReportsService.findWideCallables({
+					limits: e.projectLimits,
+					reports: o
+				})
+			},
+			unresolvedAddresses: a.unresolvedAddresses
+		};
+	}
+	async locate(e) {
+		let { collection: t, startingProjectRoots: n } = await this.discoverCallables(e), { graph: r } = this.graphAssemblyService.assemble({
+			callablesById: t.byId,
+			excludeCallees: e.configuration.excludeCallees,
+			includeConstructorEdges: !0,
+			workspaceRoot: e.workspaceRoot
+		});
+		return {
+			callablesById: t.byId,
+			graph: r,
+			startingProjectRoots: n
+		};
+	}
+	async trace(e) {
+		this.logger.info("🔭 Tracing a workspace", void 0, { workspaceRoot: e.workspaceRoot });
+		let { collection: t, entryPointsByProject: n, projectLimits: r, projectNames: i, startingProjectRoots: a, writeByProject: o } = await this.discoverCallables(e);
+		return {
+			...this.analyze({
+				callablesById: t.byId,
+				configuration: e.configuration,
+				entryPointsByProject: n,
+				fileCount: t.fileCount,
+				fileCountByProject: t.fileCountByProject,
+				projectCount: i.length,
+				projectLimits: r,
+				projectNames: i,
+				workspaceRoot: e.workspaceRoot
+			}),
+			projectNames: i,
+			startingProjectRoots: a,
+			writeByProject: o
+		};
+	}
+};
+F = P = D([d(), E("design:paramtypes", [
+	ce === void 0 ? Object : ce,
+	ue === void 0 ? Object : ue,
+	pe === void 0 ? Object : pe,
+	me === void 0 ? Object : me,
+	_ === void 0 ? Object : _,
+	he === void 0 ? Object : he,
+	y === void 0 ? Object : y,
+	n === void 0 ? Object : n,
+	we === void 0 ? Object : we,
+	x === void 0 ? Object : x,
+	k === void 0 ? Object : k
+])], F);
+//#endregion
+//#region packages/ic-suite/callidescope/callidescope-cli/src/modules/callidescope/callidescope.command.ts
+var I, L = I = class extends w {
+	addressService;
+	callidescopeService;
+	configurationService;
+	outputJsonService;
+	markdownReportService;
+	reportFindingsService;
+	writeDestinationsService;
+	logger;
+	constructor(e, t, n, r, i, a, o, s) {
+		super(), this.addressService = e, this.callidescopeService = t, this.configurationService = n, this.outputJsonService = r, this.markdownReportService = i, this.reportFindingsService = a, this.writeDestinationsService = o, this.logger = s, this.logger.setContext(I.name);
+	}
+	describeUnresolvedAddress(e) {
+		let t = e.projectName ?? "the workspace configuration", { address: n, resolution: r } = e;
+		return r.kind === "not-found" ? `${t} declares an entryPoints.addresses entry that resolves to nothing: "${n}". ${Fe}` : r.kind === "invalid" ? `${t} declares an invalid entryPoints.addresses entry. ${r.reason}` : `${t} declares an entryPoints.addresses entry that matches more than one declaration: "${n}". ${this.addressService.describeCandidates({
+			address: n,
+			candidates: r.candidates
+		})}`;
+	}
+	reject(e, t) {
+		this.logger.error(e, void 0, t), process.exitCode = 1;
+	}
+	report(e) {
+		let { json: t } = e.configuration.write;
+		if (e.format === "json") {
+			process.stdout.write(this.outputJsonService.buildReport({
+				destination: t ?? {
+					indentation: r,
+					path: ""
+				},
+				result: e.result
+			}));
+			return;
+		}
+		process.stdout.write(this.markdownReportService.renderRun({
+			description: void 0,
+			heading: a,
+			limits: e.projectLimits,
+			previewCount: i,
+			rendering: e.format === "mermaid" ? "diagram" : "tree",
+			result: e.result
+		}));
+	}
+	async traceWorkspace(e) {
+		let t = await this.configurationService.resolveFormatOption(e), { errors: n, run: r } = await this.configurationService.prepareRun(t);
+		if (r === void 0) {
+			this.reject(j, { reasons: n });
+			return;
+		}
+		this.logger.debug("🔭 Starting a call-stack trace", void 0, {
+			format: t.format,
+			workspaceRoot: r.workspaceRoot
+		});
+		let { authoredLimits: i, configuration: a, configurationPath: o, format: s, limitOverrides: c, mode: l, workspaceRoot: u } = r, d = await this.callidescopeService.trace({
+			authoredLimits: i,
+			configuration: a,
+			configurationPath: o,
+			directories: a.directories,
+			limitOverrides: c,
+			workspaceRoot: u
+		});
+		if (d.unresolvedAddresses.length > 0) throw new N(d.unresolvedAddresses.map((e) => this.describeUnresolvedAddress(e)));
+		this.report({
+			configuration: a,
+			format: s,
+			projectLimits: d.projectLimits,
+			result: d.result
+		});
+		let f = this.configurationService.touchesFiles(l) ? this.writeDestinationsService.syncDestinations({
+			check: l.checksReports,
+			configuration: a,
+			projectLimits: d.projectLimits,
+			result: d.result,
+			startingProjectRoots: d.startingProjectRoots,
+			writeByProject: d.writeByProject
+		}) : [];
+		this.logger.info("🔭 Finished a call-stack trace", void 0, {
+			deepStackCount: d.result.deepStacks.length,
+			staleReportCount: f.length,
+			wideCallableCount: d.result.wideCallables.length
+		}), this.reportFindingsService.reportFindings({
+			mode: l,
+			result: d.result,
+			stalePaths: f
+		});
+	}
+	parseCheck(e) {
+		return e;
+	}
+	parseConfig(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	parseDirectories(e) {
+		return this.configurationService.parseCommaDelimitedOption(e);
+	}
+	parseEntryPointAddresses(e) {
+		return this.configurationService.parseCommaDelimitedOption(e);
+	}
+	parseEntryPointDecorators(e) {
+		return this.configurationService.parseCommaDelimitedOption(e);
+	}
+	parseExclude(e) {
+		return this.configurationService.parseCommaDelimitedOption(e);
+	}
+	parseExcludeCallees(e) {
+		return this.configurationService.parseCommaDelimitedOption(e);
+	}
+	parseFormat(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	parseIncludeExportedFunctions(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	parseIncludeOrphans(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	parseIncludeTests(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	parseJson(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	parseMarkdown(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	parseMaximumBreadth(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	parseMaximumDepth(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	parseMermaid(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	parseWrite(e) {
+		return e ?? !0;
+	}
+	async run(e, t) {
+		let [n] = e;
+		if (n !== void 0) {
+			this.reject(j, { reason: Be(n) });
+			return;
+		}
+		try {
+			await this.traceWorkspace(t);
+		} catch (e) {
+			let t = M(e);
+			if (t === void 0 || !(e instanceof Error)) throw e;
+			this.reject(t, { reason: e.message });
+		}
+	}
+};
+D([
+	T({
+		description: `Fail on a comma-separated set drawn from ${e.map((e) => `"${e}"`).join(" and ")}`,
+		flags: "--check [check]"
+	}),
+	E("design:type", Function),
+	E("design:paramtypes", [String]),
+	E("design:returntype", String)
+], L.prototype, "parseCheck", null), D([
+	T({
+		description: "Path to a callidescope configuration file",
+		flags: "--config [config]"
+	}),
+	E("design:type", Function),
+	E("design:paramtypes", [Object]),
+	E("design:returntype", Object)
+], L.prototype, "parseConfig", null), D([
+	T({
+		description: "Comma-separated project directories to trace",
+		flags: "-d, --directories [directories]"
+	}),
+	E("design:type", Function),
+	E("design:paramtypes", [Object]),
+	E("design:returntype", Array)
+], L.prototype, "parseDirectories", null), D([
+	T({
+		description: "Comma-separated callable addresses to root stacks at",
+		flags: "--entry-point-addresses [entryPointAddresses]"
+	}),
+	E("design:type", Function),
+	E("design:paramtypes", [Object]),
+	E("design:returntype", Array)
+], L.prototype, "parseEntryPointAddresses", null), D([
+	T({
+		description: "Comma-separated decorators whose methods a framework invokes",
+		flags: "--entry-point-decorators [entryPointDecorators]"
+	}),
+	E("design:type", Function),
+	E("design:paramtypes", [Object]),
+	E("design:returntype", Array)
+], L.prototype, "parseEntryPointDecorators", null), D([
+	T({
+		description: "Comma-separated globs to leave untraced",
+		flags: "--exclude [exclude]"
+	}),
+	E("design:type", Function),
+	E("design:paramtypes", [Object]),
+	E("design:returntype", Array)
+], L.prototype, "parseExclude", null), D([
+	T({
+		description: "Comma-separated display-name globs to drop calls landing on",
+		flags: "--exclude-callees [excludeCallees]"
+	}),
+	E("design:type", Function),
+	E("design:paramtypes", [Object]),
+	E("design:returntype", Array)
+], L.prototype, "parseExcludeCallees", null), D([
+	T({
+		description: "What to print: markdown, mermaid, or json",
+		flags: "-f, --format [format]"
+	}),
+	E("design:type", Function),
+	E("design:paramtypes", [Object]),
+	E("design:returntype", Object)
+], L.prototype, "parseFormat", null), D([
+	T({
+		description: "Treat every src/index.ts export as a root: \"true\" or \"false\"",
+		flags: "--include-exported-functions [includeExportedFunctions]"
+	}),
+	E("design:type", Function),
+	E("design:paramtypes", [Object]),
+	E("design:returntype", Object)
+], L.prototype, "parseIncludeExportedFunctions", null), D([
+	T({
+		description: "Promote callables nothing calls: \"true\" or \"false\"",
+		flags: "--include-orphans [includeOrphans]"
+	}),
+	E("design:type", Function),
+	E("design:paramtypes", [Object]),
+	E("design:returntype", Object)
+], L.prototype, "parseIncludeOrphans", null), D([
+	T({
+		description: "Trace test files too: \"true\" or \"false\"",
+		flags: "--include-tests [includeTests]"
+	}),
+	E("design:type", Function),
+	E("design:paramtypes", [Object]),
+	E("design:returntype", Object)
+], L.prototype, "parseIncludeTests", null), D([
+	T({
+		description: "Where the JSON report goes when --write or --check reports asks for it",
+		flags: "--json [json]"
+	}),
+	E("design:type", Function),
+	E("design:paramtypes", [Object]),
+	E("design:returntype", Object)
+], L.prototype, "parseJson", null), D([
+	T({
+		description: "Where the markdown block goes when --write or --check reports asks for it",
+		flags: "-m, --markdown [markdown]"
+	}),
+	E("design:type", Function),
+	E("design:paramtypes", [Object]),
+	E("design:returntype", Object)
+], L.prototype, "parseMarkdown", null), D([
+	T({
+		description: "Override the configured limits.maximumBreadth",
+		flags: "--maximum-breadth <maximumBreadth>"
+	}),
+	E("design:type", Function),
+	E("design:paramtypes", [Object]),
+	E("design:returntype", Object)
+], L.prototype, "parseMaximumBreadth", null), D([
+	T({
+		description: "Override the configured limits.maximumDepth",
+		flags: "--maximum-depth <maximumDepth>"
+	}),
+	E("design:type", Function),
+	E("design:paramtypes", [Object]),
+	E("design:returntype", Object)
+], L.prototype, "parseMaximumDepth", null), D([
+	T({
+		description: "Where the mermaid block goes when --write or --check reports asks for it",
+		flags: "--mermaid [mermaid]"
+	}),
+	E("design:type", Function),
+	E("design:paramtypes", [Object]),
+	E("design:returntype", Object)
+], L.prototype, "parseMermaid", null), D([
+	T({
+		description: "Write every configured destination",
+		flags: "--write"
+	}),
+	E("design:type", Function),
+	E("design:paramtypes", [Object]),
+	E("design:returntype", Boolean)
+], L.prototype, "parseWrite", null), L = I = D([
+	C({
+		description: "Run the callidescope command",
+		name: "callidescope",
+		options: { isDefault: !0 }
+	}),
+	d(),
+	E("design:paramtypes", [
+		h === void 0 ? Object : h,
+		F === void 0 ? Object : F,
+		n === void 0 ? Object : n,
+		xe === void 0 ? Object : xe,
+		ye === void 0 ? Object : ye,
+		Ee === void 0 ? Object : Ee,
+		ke === void 0 ? Object : ke,
+		k === void 0 ? Object : k
+	])
+], L);
+//#endregion
+//#region packages/ic-suite/callidescope/callidescope-cli/src/modules/callidescope/callidescope.module.ts
+var R = class {};
+R = D([f({
+	controllers: [],
+	exports: [L, F],
+	imports: [
+		g,
+		t,
+		de,
+		fe,
+		v,
+		le,
+		A,
+		be,
+		Se,
+		_e,
+		Ce,
+		Te,
+		De,
+		b,
+		Oe
+	],
+	providers: [L, F]
+})], R);
+//#endregion
+//#region packages/ic-suite/callidescope/callidescope-cli/src/modules/address-lookup/address-lookup.service.ts
+var z = class {
+	addressService;
+	callidescopeService;
+	configurationService;
+	constructor(e, t, n) {
+		this.addressService = e, this.callidescopeService = t, this.configurationService = n;
+	}
+	describeProblem(e) {
+		let { resolution: t } = e;
+		if (t.kind !== "resolved") return t.kind === "invalid" ? t.reason : t.kind === "not-found" ? `No callable matches "${e.address}". ${Fe}` : `"${e.address}" matches more than one declaration. ${this.addressService.describeCandidates({
+			address: e.address,
+			candidates: t.candidates
+		})}`;
+	}
+	listAddresses(e) {
+		return this.addressService.listAddresses(e.located.callablesById);
+	}
+	async locate(e) {
+		let { authoredLimits: t, configuration: n, configurationPath: r, format: i, workspaceRoot: a } = await this.configurationService.prepareLookup(e);
+		return {
+			configuration: n,
+			format: i,
+			located: await this.callidescopeService.locate({
+				authoredLimits: t,
+				configuration: n,
+				configurationPath: r,
+				directories: n.directories,
+				workspaceRoot: a
+			}),
+			workspaceRoot: a
+		};
+	}
+	resolve(e) {
+		return this.addressService.resolve({
+			address: e.address,
+			callablesById: e.workspace.located.callablesById,
+			workspaceRoot: e.workspace.workspaceRoot
+		});
+	}
+};
+z = D([d(), E("design:paramtypes", [
+	h === void 0 ? Object : h,
+	F === void 0 ? Object : F,
+	n === void 0 ? Object : n
+])], z);
+//#endregion
+//#region packages/ic-suite/callidescope/callidescope-cli/src/modules/address-lookup/address-lookup.module.ts
+var B = class {};
+B = D([f({
+	controllers: [],
+	exports: [z],
+	imports: [
+		g,
+		R,
+		t
+	],
+	providers: [z]
+})], B);
+//#endregion
+//#region packages/ic-suite/callidescope/callidescope-cli/src/modules/breadth/breadth.command.ts
+var V, H = V = class extends w {
+	addressLookupService;
+	addressReportService;
+	breadthService;
+	configurationService;
+	logger;
+	constructor(e, t, n, r, i) {
+		super(), this.addressLookupService = e, this.addressReportService = t, this.breadthService = n, this.configurationService = r, this.logger = i, this.logger.setContext(V.name);
+	}
+	buildReports(e) {
+		let t = [], n = [];
+		for (let r of e.addresses) {
+			let i = this.describeAddress({
+				address: r,
+				workspace: e.workspace
+			});
+			if (typeof i == "string") {
+				n.push(i);
+				continue;
+			}
+			t.push(i);
+		}
+		if (n.length > 0) {
+			this.reject(Ie, { problems: n });
+			return;
+		}
+		return t;
+	}
+	describeAddress(e) {
+		let t = this.addressLookupService.resolve(e), n = this.addressLookupService.describeProblem({
+			address: e.address,
+			resolution: t
+		});
+		if (n !== void 0 || t.kind !== "resolved") return n ?? `"${e.address}" resolved to nothing.`;
+		let { id: r } = t, { located: i } = e.workspace, a = i.callablesById.get(r);
+		return a === void 0 ? `"${e.address}" resolved to a callable that was not traced.` : {
+			address: e.address,
+			directCalls: this.breadthService.describeDirectCalls({
+				callablesById: i.callablesById,
+				graph: i.graph,
+				id: r
+			}),
+			displayName: a.node.displayName,
+			id: r,
+			location: a.node.location
+		};
+	}
+	async printBreadth(e) {
+		let t = await this.configurationService.resolveFormatOption(e), n = await this.addressLookupService.locate(t), r = await this.resolveAddresses({
+			options: t,
+			workspace: n
+		}), i = this.buildReports({
+			addresses: r,
+			workspace: n
+		});
+		i !== void 0 && process.stdout.write(this.addressReportService.renderBreadthReports({
+			format: n.format,
+			reports: i
+		}));
+	}
+	reject(e, t) {
+		this.logger.error(e, void 0, t), process.exitCode = 1;
+	}
+	async resolveAddresses(e) {
+		let t = e.options.addresses ?? [];
+		return t.length > 0 ? t : this.configurationService.promptForAutocompleteMultiselect({
+			message: "Which callables? (file#qualified-name)",
+			subject: "At least one callable address, as in \"breadth --addresses src/foo.service.ts#FooService.bar\"",
+			suggestions: this.addressLookupService.listAddresses(e.workspace)
+		});
+	}
+	parseAddresses(e) {
+		return this.configurationService.parseCommaDelimitedOption(e);
+	}
+	parseConfig(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	parseDirectories(e) {
+		return this.configurationService.parseCommaDelimitedOption(e);
+	}
+	parseEntryPointAddresses(e) {
+		return this.configurationService.parseCommaDelimitedOption(e);
+	}
+	parseEntryPointDecorators(e) {
+		return this.configurationService.parseCommaDelimitedOption(e);
+	}
+	parseExclude(e) {
+		return this.configurationService.parseCommaDelimitedOption(e);
+	}
+	parseExcludeCallees(e) {
+		return this.configurationService.parseCommaDelimitedOption(e);
+	}
+	parseFormat(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	parseIncludeExportedFunctions(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	parseIncludeOrphans(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	parseIncludeTests(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	async run(e, t) {
+		try {
+			await this.printBreadth(t);
+		} catch (e) {
+			let t = M(e);
+			if (t === void 0 || !(e instanceof Error)) throw e;
+			this.reject(t, { reason: e.message });
+		}
+	}
+};
+D([
+	T({
+		description: "Comma-separated callable addresses, each <file>#<qualified-name>",
+		flags: "-a, --addresses [addresses]"
+	}),
+	E("design:type", Function),
+	E("design:paramtypes", [Object]),
+	E("design:returntype", Array)
+], H.prototype, "parseAddresses", null), D([
+	T({
+		description: "Path to a callidescope configuration file",
+		flags: "--config [config]"
+	}),
+	E("design:type", Function),
+	E("design:paramtypes", [Object]),
+	E("design:returntype", Object)
+], H.prototype, "parseConfig", null), D([
+	T({
+		description: "Comma-separated project directories to trace",
+		flags: "-d, --directories [directories]"
+	}),
+	E("design:type", Function),
+	E("design:paramtypes", [Object]),
+	E("design:returntype", Array)
+], H.prototype, "parseDirectories", null), D([
+	T({
+		description: "Comma-separated callable addresses to root stacks at",
+		flags: "--entry-point-addresses [entryPointAddresses]"
+	}),
+	E("design:type", Function),
+	E("design:paramtypes", [Object]),
+	E("design:returntype", Array)
+], H.prototype, "parseEntryPointAddresses", null), D([
+	T({
+		description: "Comma-separated decorators whose methods a framework invokes",
+		flags: "--entry-point-decorators [entryPointDecorators]"
+	}),
+	E("design:type", Function),
+	E("design:paramtypes", [Object]),
+	E("design:returntype", Array)
+], H.prototype, "parseEntryPointDecorators", null), D([
+	T({
+		description: "Comma-separated globs to leave untraced",
+		flags: "--exclude [exclude]"
+	}),
+	E("design:type", Function),
+	E("design:paramtypes", [Object]),
+	E("design:returntype", Array)
+], H.prototype, "parseExclude", null), D([
+	T({
+		description: "Comma-separated display-name globs to drop calls landing on",
+		flags: "--exclude-callees [excludeCallees]"
+	}),
+	E("design:type", Function),
+	E("design:paramtypes", [Object]),
+	E("design:returntype", Array)
+], H.prototype, "parseExcludeCallees", null), D([
+	T({
+		description: "What to print: markdown, mermaid, or json",
+		flags: "-f, --format [format]"
+	}),
+	E("design:type", Function),
+	E("design:paramtypes", [Object]),
+	E("design:returntype", Object)
+], H.prototype, "parseFormat", null), D([
+	T({
+		description: "Treat every src/index.ts export as a root: \"true\" or \"false\"",
+		flags: "--include-exported-functions [includeExportedFunctions]"
+	}),
+	E("design:type", Function),
+	E("design:paramtypes", [Object]),
+	E("design:returntype", Object)
+], H.prototype, "parseIncludeExportedFunctions", null), D([
+	T({
+		description: "Promote callables nothing calls: \"true\" or \"false\"",
+		flags: "--include-orphans [includeOrphans]"
+	}),
+	E("design:type", Function),
+	E("design:paramtypes", [Object]),
+	E("design:returntype", Object)
+], H.prototype, "parseIncludeOrphans", null), D([
+	T({
+		description: "Trace test files too: \"true\" or \"false\"",
+		flags: "--include-tests [includeTests]"
+	}),
+	E("design:type", Function),
+	E("design:paramtypes", [Object]),
+	E("design:returntype", Object)
+], H.prototype, "parseIncludeTests", null), H = V = D([
+	C({
+		description: "Print the direct callers and callees of one or more callables, each addressed as <file>#<qualified-name>",
+		name: "breadth"
+	}),
+	d(),
+	E("design:paramtypes", [
+		z === void 0 ? Object : z,
+		S === void 0 ? Object : S,
+		se === void 0 ? Object : se,
+		n === void 0 ? Object : n,
+		k === void 0 ? Object : k
+	])
+], H);
+//#endregion
+//#region packages/ic-suite/callidescope/callidescope-cli/src/modules/breadth/breadth.module.ts
+var U = class {};
+U = D([f({
+	controllers: [],
+	exports: [H],
+	imports: [
+		B,
+		ve,
+		v,
+		t,
+		A
+	],
+	providers: [H]
+})], U);
+//#endregion
+//#region packages/ic-suite/callidescope/callidescope-cli/src/modules/depth/depth.command.ts
+var W, G = W = class extends w {
+	addressLookupService;
+	addressReportService;
+	addressDepthService;
+	configurationService;
+	logger;
+	constructor(e, t, n, r, i) {
+		super(), this.addressLookupService = e, this.addressReportService = t, this.addressDepthService = n, this.configurationService = r, this.logger = i, this.logger.setContext(W.name);
+	}
+	identifyAddresses(e) {
+		let t = [], n = [];
+		for (let r of e.addresses) {
+			let i = this.addressLookupService.resolve({
+				address: r,
+				workspace: e.workspace
+			}), a = this.addressLookupService.describeProblem({
+				address: r,
+				resolution: i
+			});
+			if (a !== void 0 || i.kind !== "resolved") {
+				n.push(a ?? `"${r}" resolved to nothing.`);
+				continue;
+			}
+			t.push({
+				address: r,
+				id: i.id
+			});
+		}
+		if (n.length > 0) {
+			this.reject(Ie, { problems: n });
+			return;
+		}
+		return t;
+	}
+	async printDepth(e) {
+		let t = await this.configurationService.resolveFormatOption(e), n = await this.addressLookupService.locate(t), r = await this.resolveAddresses({
+			options: t,
+			workspace: n
+		}), i = this.identifyAddresses({
+			addresses: r,
+			workspace: n
+		});
+		i !== void 0 && process.stdout.write(this.addressReportService.renderDepthReports({
+			format: n.format,
+			reports: i.map(({ address: e, id: t }) => ({
+				address: e,
+				downward: this.addressDepthService.buildDownwardStacks({
+					callablesById: n.located.callablesById,
+					graph: n.located.graph,
+					startId: t
+				}),
+				upward: this.addressDepthService.buildUpwardStacks({
+					callablesById: n.located.callablesById,
+					graph: n.located.graph,
+					startId: t
+				})
+			}))
+		}));
+	}
+	reject(e, t) {
+		this.logger.error(e, void 0, t), process.exitCode = 1;
+	}
+	async resolveAddresses(e) {
+		let t = e.options.addresses ?? [];
+		return t.length > 0 ? t : this.configurationService.promptForAutocompleteMultiselect({
+			message: "Which callables? (file#qualified-name)",
+			subject: "At least one callable address, as in \"depth --addresses src/foo.service.ts#FooService.bar\"",
+			suggestions: this.addressLookupService.listAddresses(e.workspace)
+		});
+	}
+	parseAddresses(e) {
+		return this.configurationService.parseCommaDelimitedOption(e);
+	}
+	parseConfig(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	parseDirectories(e) {
+		return this.configurationService.parseCommaDelimitedOption(e);
+	}
+	parseEntryPointAddresses(e) {
+		return this.configurationService.parseCommaDelimitedOption(e);
+	}
+	parseEntryPointDecorators(e) {
+		return this.configurationService.parseCommaDelimitedOption(e);
+	}
+	parseExclude(e) {
+		return this.configurationService.parseCommaDelimitedOption(e);
+	}
+	parseExcludeCallees(e) {
+		return this.configurationService.parseCommaDelimitedOption(e);
+	}
+	parseFormat(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	parseIncludeExportedFunctions(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	parseIncludeOrphans(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	parseIncludeTests(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	async run(e, t) {
+		try {
+			await this.printDepth(t);
+		} catch (e) {
+			let t = M(e);
+			if (t === void 0 || !(e instanceof Error)) throw e;
+			this.reject(t, { reason: e.message });
+		}
+	}
+};
+D([
+	T({
+		description: "Comma-separated callable addresses, each <file>#<qualified-name>",
+		flags: "-a, --addresses [addresses]"
+	}),
+	E("design:type", Function),
+	E("design:paramtypes", [Object]),
+	E("design:returntype", Array)
+], G.prototype, "parseAddresses", null), D([
+	T({
+		description: "Path to a callidescope configuration file",
+		flags: "--config [config]"
+	}),
+	E("design:type", Function),
+	E("design:paramtypes", [Object]),
+	E("design:returntype", Object)
+], G.prototype, "parseConfig", null), D([
+	T({
+		description: "Comma-separated project directories to trace",
+		flags: "-d, --directories [directories]"
+	}),
+	E("design:type", Function),
+	E("design:paramtypes", [Object]),
+	E("design:returntype", Array)
+], G.prototype, "parseDirectories", null), D([
+	T({
+		description: "Comma-separated callable addresses to root stacks at",
+		flags: "--entry-point-addresses [entryPointAddresses]"
+	}),
+	E("design:type", Function),
+	E("design:paramtypes", [Object]),
+	E("design:returntype", Array)
+], G.prototype, "parseEntryPointAddresses", null), D([
+	T({
+		description: "Comma-separated decorators whose methods a framework invokes",
+		flags: "--entry-point-decorators [entryPointDecorators]"
+	}),
+	E("design:type", Function),
+	E("design:paramtypes", [Object]),
+	E("design:returntype", Array)
+], G.prototype, "parseEntryPointDecorators", null), D([
+	T({
+		description: "Comma-separated globs to leave untraced",
+		flags: "--exclude [exclude]"
+	}),
+	E("design:type", Function),
+	E("design:paramtypes", [Object]),
+	E("design:returntype", Array)
+], G.prototype, "parseExclude", null), D([
+	T({
+		description: "Comma-separated display-name globs to drop calls landing on",
+		flags: "--exclude-callees [excludeCallees]"
+	}),
+	E("design:type", Function),
+	E("design:paramtypes", [Object]),
+	E("design:returntype", Array)
+], G.prototype, "parseExcludeCallees", null), D([
+	T({
+		description: "What to print: markdown, mermaid, or json",
+		flags: "-f, --format [format]"
+	}),
+	E("design:type", Function),
+	E("design:paramtypes", [Object]),
+	E("design:returntype", Object)
+], G.prototype, "parseFormat", null), D([
+	T({
+		description: "Treat every src/index.ts export as a root: \"true\" or \"false\"",
+		flags: "--include-exported-functions [includeExportedFunctions]"
+	}),
+	E("design:type", Function),
+	E("design:paramtypes", [Object]),
+	E("design:returntype", Object)
+], G.prototype, "parseIncludeExportedFunctions", null), D([
+	T({
+		description: "Promote callables nothing calls: \"true\" or \"false\"",
+		flags: "--include-orphans [includeOrphans]"
+	}),
+	E("design:type", Function),
+	E("design:paramtypes", [Object]),
+	E("design:returntype", Object)
+], G.prototype, "parseIncludeOrphans", null), D([
+	T({
+		description: "Trace test files too: \"true\" or \"false\"",
+		flags: "--include-tests [includeTests]"
+	}),
+	E("design:type", Function),
+	E("design:paramtypes", [Object]),
+	E("design:returntype", Object)
+], G.prototype, "parseIncludeTests", null), G = W = D([
+	C({
+		description: "Print every call stack above and below one or more callables, each addressed as <file>#<qualified-name>",
+		name: "depth"
+	}),
+	d(),
+	E("design:paramtypes", [
+		z === void 0 ? Object : z,
+		S === void 0 ? Object : S,
+		oe === void 0 ? Object : oe,
+		n === void 0 ? Object : n,
+		k === void 0 ? Object : k
+	])
+], G);
+//#endregion
+//#region packages/ic-suite/callidescope/callidescope-cli/src/modules/depth/depth.module.ts
+var K = class {};
+K = D([f({
+	controllers: [],
+	exports: [G],
+	imports: [
+		B,
+		ve,
+		v,
+		t,
+		A
+	],
+	providers: [G]
+})], K);
+//#endregion
+//#region packages/ic-suite/callidescope/callidescope-cli/src/modules/limits/limits.service.ts
+var q, J = q = class {
+	configurationService;
+	fileFilterService;
+	workspaceService;
+	logger;
+	constructor(e, t, n, r) {
+		this.configurationService = e, this.fileFilterService = t, this.workspaceService = n, this.logger = r, this.logger.setContext(q.name);
+	}
+	discoverProjects(e) {
+		let t = this.fileFilterService.buildFileFilter({
+			exclude: e.configuration.exclude,
+			excludeFrom: e.configuration.excludeFrom,
+			workspaceRoot: e.workspaceRoot
+		});
+		return this.workspaceService.discoverProjects({
+			directories: e.configuration.directories,
+			fileFilter: t,
+			workspaceRoot: e.workspaceRoot
+		}).map((e) => e.name);
+	}
+	toProjectRows(e) {
+		return [this.toRow({
+			...e,
+			limit: "maximumDepth"
+		}), this.toRow({
+			...e,
+			limit: "maximumBreadth"
+		})];
+	}
+	toRow(e) {
+		let t = e.limits[e.limit];
+		return {
+			limit: e.limit,
+			path: e.limits.path === void 0 || t === void 0 ? void 0 : p.relative(e.workspaceRoot, e.limits.path),
+			project: e.project,
+			value: t
+		};
+	}
+	toWorkspaceRows(e) {
+		return [this.toRow({
+			...e,
+			limit: "maximumDepth",
+			project: void 0
+		}), this.toRow({
+			...e,
+			limit: "maximumBreadth",
+			project: void 0
+		})];
+	}
+	async list(e) {
+		let t = process.cwd(), { authored: n, configuration: r, path: i } = await this.configurationService.loadConfigurationFile({
+			configurationPath: e.config,
+			searchDirectory: t
+		}), a = this.discoverProjects({
+			configuration: r,
+			workspaceRoot: t
+		}), o = await this.configurationService.loadProjectConfigurations({
+			projects: a,
+			workspaceConfigurationPath: i,
+			workspaceRoot: t
+		}), s = this.configurationService.resolveLimits({
+			projectConfigurations: o,
+			projects: a,
+			workspaceAuthoredLimits: n.limits,
+			workspaceConfiguration: r,
+			workspaceConfigurationPath: i
+		});
+		return this.logger.info("🔭 Listed every project's limits", void 0, {
+			declaringProjectCount: o.length,
+			projectCount: a.length
+		}), [...this.toWorkspaceRows({
+			limits: s.workspace,
+			workspaceRoot: t
+		}), ...[...s.byProject].flatMap(([e, n]) => this.toProjectRows({
+			limits: n,
+			project: e,
+			workspaceRoot: t
+		}))];
+	}
+};
+J = q = D([d(), E("design:paramtypes", [
+	n === void 0 ? Object : n,
+	_ === void 0 ? Object : _,
+	x === void 0 ? Object : x,
+	k === void 0 ? Object : k
+])], J);
+//#endregion
+//#region packages/ic-suite/callidescope/callidescope-cli/src/modules/limits/limits.constants.ts
+var Ve = [
+	"Project",
+	"Limit",
+	"Value",
+	"Declared in"
+], He = "# 🔭 Callidescope Limits", Ue = "Every project in scope, what it is judged against, and the file each number is written in — which is that project's own `callidescope.config.ts`, every traced project declaring a complete one. The `workspace` row is the starting point those files spread, and the numbers the directory holding this configuration is itself judged by.", We = "none", Ge = "workspace", Y = class {
+	constructor() {}
+	renderProject(e) {
+		return e === void 0 ? Ge : e === "" ? "." : e;
+	}
+	renderRow(e) {
+		return `| ${e.join(" | ")} |`;
+	}
+	renderTable(e) {
+		return [
+			this.renderRow(Ve),
+			this.renderRow(Ve.map(() => "---")),
+			...e.map((e) => this.renderRow([
+				this.renderProject(e.project),
+				`\`${e.limit}\``,
+				e.value === void 0 ? We : String(e.value),
+				e.path === void 0 ? "—" : `\`${e.path}\``
+			]))
+		].join("\n");
+	}
+	render(e) {
+		return [
+			He,
+			"",
+			Ue,
+			"",
+			this.renderTable(e)
+		].join("\n");
+	}
+};
+Y = D([d(), E("design:paramtypes", [])], Y);
+//#endregion
+//#region packages/ic-suite/callidescope/callidescope-cli/src/modules/limits/limits.command.ts
+var X, Z = X = class extends w {
+	limitsService;
+	renderLimitsService;
+	configurationService;
+	logger;
+	constructor(e, t, n, r) {
+		super(), this.limitsService = e, this.renderLimitsService = t, this.configurationService = n, this.logger = r, this.logger.setContext(X.name);
+	}
+	reject(e, t) {
+		this.logger.error(e, void 0, t), process.exitCode = 1;
+	}
+	parseConfig(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	async run(e, t = {}) {
+		try {
+			let e = await this.limitsService.list(t);
+			process.stdout.write(`${this.renderLimitsService.render(e)}\n`);
+		} catch (e) {
+			let t = M(e);
+			if (t === void 0 || !(e instanceof Error)) throw e;
+			this.reject(t, { reason: e.message });
+		}
+	}
+};
+D([
+	T({
+		description: "Path to a callidescope configuration file",
+		flags: "--config [config]"
+	}),
+	E("design:type", Function),
+	E("design:paramtypes", [Object]),
+	E("design:returntype", Object)
+], Z.prototype, "parseConfig", null), Z = X = D([
+	C({
+		description: "List every project's resolved depth and breadth limits, and the file each came from",
+		name: "limits"
+	}),
+	d(),
+	E("design:paramtypes", [
+		J === void 0 ? Object : J,
+		Y === void 0 ? Object : Y,
+		n === void 0 ? Object : n,
+		k === void 0 ? Object : k
+	])
+], Z);
+//#endregion
+//#region packages/ic-suite/callidescope/callidescope-cli/src/modules/limits/limits.module.ts
+var Q = class {};
+Q = D([f({
+	controllers: [],
+	exports: [Z, J],
+	imports: [
+		t,
+		A,
+		b
+	],
+	providers: [
+		Z,
+		J,
+		Y
+	]
+})], Q);
+//#endregion
+//#region packages/ic-suite/callidescope/callidescope-cli/src/main.module.ts
+var $ = class {};
+$ = D([f({ imports: [
+	te.forRoot({
+		envFilePath: ".env",
+		isGlobal: !0,
+		validate: (e) => Pe.parse(e)
+	}),
+	ne,
+	A,
+	U,
+	R,
+	K,
+	Q,
+	t
+] })], $);
+//#endregion
+export { F as a, R as i, B as n, k as o, z as r, $ as t };