@callidescope/cli 0.0.1

package/dist/src/index.d.ts

@@ -0,0 +1,649 @@
+import { AddressCommandOptions } from '@callidescope/configuration';
+import { AddressService } from '@callidescope/graph';
+import { CallableAddressResolution } from '@callidescope/graph';
+import { CallableId } from '@callidescope/core';
+import { CallablesService } from '@callidescope/graph';
+import { CallGraph } from '@callidescope/graph';
+import { CallGraphResult } from '@callidescope/core';
+import { CallidescopeLimitOverrides } from '@callidescope/configuration';
+import { CallidescopeLimits } from '@callidescope/configuration';
+import { CallidescopeOutputFormat } from '@callidescope/configuration';
+import { ClassesService } from '@callidescope/graph';
+import { ConfigurationService } from '@callidescope/configuration';
+import { ConsoleLogger } from '@nestjs/common';
+import { DiscoveredCallable } from '@callidescope/graph';
+import { EntriesService } from '@callidescope/graph';
+import { ExternalService } from '@callidescope/graph';
+import { FileFilterService } from '@callidescope/graph';
+import { GraphAssemblyService } from '@callidescope/graph';
+import pino from 'pino';
+import { ProgramService } from '@callidescope/graph';
+import { ProjectLimitsLookup } from '@callidescope/configuration';
+import { ProjectReportsService } from '@callidescope/output';
+import { ResolvedCallidescopeConfiguration } from '@callidescope/configuration';
+import { ResolvedCallidescopeEntryPoints } from '@callidescope/configuration';
+import { ResolvedCallidescopeWriteConfiguration } from '@callidescope/configuration';
+import { UnresolvedEntryPointAddress } from '@callidescope/graph';
+import { WorkspaceService } from '@callidescope/graph';
+
+/**
+ * NestJS module that wires `depth` and `breadth`'s shared address resolution.
+ */
+export declare class AddressLookupModule {
+}
+
+/**
+ * Resolves `depth` and `breadth`'s callable address into a callable, sharing
+ * every step the two commands would otherwise duplicate: loading the
+ * configuration, tracing the workspace, and matching the address against
+ * what was found.
+ */
+export declare class AddressLookupService {
+    private readonly addressService;
+    private readonly callidescopeService;
+    private readonly configurationService;
+    constructor(addressService: AddressService, callidescopeService: CallidescopeService, configurationService: ConfigurationService);
+    /**
+     * States why a resolution cannot be acted on, or nothing when it can.
+     *
+     * One message per failure kind rather than a generic "not found": an
+     * invalid address, an address matching nothing, and an address matching
+     * several declarations are each fixed a different way, and only the message
+     * for the one that actually happened tells the caller which.
+     *
+     * The candidates of an ambiguous address are rendered by `AddressService`,
+     * the same renderer the workspace run's own refusal prints, so one concept
+     * reaches a reader one way — as an address they can paste back, rather than
+     * a file location they cannot.
+     */
+    describeProblem(args: {
+        address: string;
+        resolution: CallableAddressResolution;
+    }): string | undefined;
+    /**
+     * Every callable the trace found, written as an address that resolves to it.
+     *
+     * What a prompt completes against, so a caller picks from what is actually
+     * there rather than recalling a qualified name it has no way to look up.
+     */
+    listAddresses(workspace: LocatedWorkspace): string[];
+    /** Loads the configuration and traces the workspace, matching nothing yet. */
+    locate(options: AddressCommandOptions): Promise<LocatedWorkspace>;
+    /** Matches an address against a workspace already traced. */
+    resolve(args: ResolveAddressArguments): CallableAddressResolution;
+}
+
+/** What analyzing one run's callables produced. */
+declare interface AnalyzeOutcome {
+    /**
+     * The depth and breadth limits each traced project is judged against.
+     *
+     * Held beside the result rather than inside it, the same as
+     * `unresolvedAddresses`: whether `--check breadth` even has a limit to gate
+     * on is a fact about the projects a run reached, not part of the report
+     * every destination writes.
+     */
+    readonly projectLimits: ProjectLimitsLookup;
+    readonly result: CallGraphResult;
+    /**
+     * Declared entry-point addresses that named no callable, or more than one.
+     *
+     * Held beside the result rather than inside it: the report shape is what
+     * gets written to every destination, and an address that stopped resolving
+     * is a fact about the configuration rather than about the code it traced.
+     */
+    readonly unresolvedAddresses: readonly UnresolvedEntryPointAddress[];
+}
+
+/**
+ * NestJS module that wires the callidescope command and its analysis services.
+ */
+export declare class CallidescopeModule {
+}
+
+/**
+ * Runs one trace of a workspace, from tsconfig files to findings.
+ */
+export declare class CallidescopeService {
+    private readonly callablesService;
+    private readonly classHierarchyService;
+    private readonly entryPointsService;
+    private readonly externalService;
+    private readonly fileFilterService;
+    private readonly graphAssemblyService;
+    private readonly programService;
+    private readonly configurationService;
+    private readonly projectReportsService;
+    private readonly workspaceService;
+    private readonly logger;
+    constructor(callablesService: CallablesService, classHierarchyService: ClassesService, entryPointsService: EntriesService, externalService: ExternalService, fileFilterService: FileFilterService, graphAssemblyService: GraphAssemblyService, programService: ProgramService, configurationService: ConfigurationService, projectReportsService: ProjectReportsService, workspaceService: WorkspaceService, logger: LoggerService);
+    /**
+     * Walks the workspace and collects every callable, without analyzing them.
+     *
+     * Shared by `trace`, which goes on to run the full analysis, and `locate`,
+     * which only needs the collected callables and their graph to resolve one
+     * address — entry points and project reports are work `locate`'s callers
+     * never asked for. Both read the same declarations, because a
+     * project's own `exclude` decides which files exist to be collected at all,
+     * and an address resolved against a different set of files from the one a
+     * gated run measures would be an address about a different codebase.
+     */
+    private discoverCallables;
+    /**
+     * Finds the projects a run covers and builds a program for each.
+     *
+     * Split from `discoverCallables` because the projects have to exist before
+     * anything can be read from beside them, and the run's own filter has to
+     * exist before the projects: a project the run excludes must be dropped
+     * before its `tsconfig.json` is opened, since opening it is what fails.
+     */
+    private discoverPrograms;
+    /**
+     * Reads what each traced project declared for itself: the callables that
+     * root its stacks, and the limits those stacks are judged against.
+     *
+     * Over the whole closure rather than the projects the run was pointed at: a
+     * dependency's callables are measured by this run, and the project that owns
+     * them is the one entitled to say what roots a stack through them. A run
+     * scoped elsewhere would otherwise judge them by whoever happened to reach
+     * them.
+     *
+     * One load for both, because the two answers come out of the same files, and
+     * reading those files twice is how a run ends up gating against limits from
+     * one read and rooting stacks from another.
+     *
+     * A project declaring no entry-point rules is simply absent from that map,
+     * and `EntriesService` falls back to the run's own configuration for it —
+     * which is why this returns rules rather than a whole configuration. Limits
+     * resolve the other way round, naming every project, because a limit has to
+     * be printable per project whether or not the project chose it.
+     *
+     * Exclusions are read from the file exactly as authored rather than from the
+     * resolved configuration, which is the split `readDeclaredLimit` already makes
+     * for
+     * a limit: resolution folds the tool's own default globs into every project's
+     * `exclude`, so the resolved array can never say whether this project
+     * excluded anything. A project that excluded nothing is left out of the map
+     * entirely, so a run in which no project excludes anything is handed back the
+     * run's own filter untouched.
+     */
+    private loadProjectDeclarations;
+    /**
+     * Reads the deepest depth any component reached, closure included.
+     *
+     * The whole trace's number, closure included, which is what belongs in a
+     * summary describing everything a run measured. It is **not** what a scoped
+     * run is judged on, which is why the log line names it `maximumDepthTraced`
+     * rather than `maximumDepth`.
+     */
+    private readMaximumDepth;
+    /** Derives every finding from the collected callables. */
+    analyze(args: {
+        callablesById: ReadonlyMap<CallableId, DiscoveredCallable>;
+        configuration: ResolvedCallidescopeConfiguration;
+        /** Entry-point rules a project declared for itself, keyed by project name. */
+        entryPointsByProject: ReadonlyMap<string, ResolvedCallidescopeEntryPoints>;
+        fileCount: number;
+        fileCountByProject: ReadonlyMap<string, number>;
+        projectCount: number;
+        /** The depth and breadth limits each traced project is judged against. */
+        projectLimits: ProjectLimitsLookup;
+        projectNames: readonly string[];
+        workspaceRoot: string;
+    }): AnalyzeOutcome;
+    /**
+     * Collects every callable and assembles the graph over them, without
+     * running the analysis a full trace does.
+     *
+     * For the `depth` and `breadth` commands, which resolve one address against
+     * the collected callables and then walk the graph from it — neither needs
+     * entry points or project reports, both of which `analyze` builds
+     * unconditionally.
+     *
+     * Asynchronous because discovery is: every project's own configuration is
+     * read before a callable is collected, since a project's `exclude` decides
+     * which files there are to collect. The limits those same files declare are
+     * loaded and thrown away here, which is the price of one answer about what a
+     * run's callables are rather than two.
+     */
+    locate(args: TraceArguments): Promise<LocateOutcome>;
+    /** Traces a workspace and returns everything the run found. */
+    trace(args: TraceArguments): Promise<TraceOutcome>;
+}
+
+/**
+ * A traced workspace, before any address has been matched against it.
+ *
+ * Held apart from the match so one trace can serve both the list a prompt
+ * completes against and the lookup that follows it. Tracing twice to offer a
+ * choice and then act on it would double the slowest thing either command
+ * does.
+ */
+export declare interface LocatedWorkspace {
+    readonly configuration: ResolvedCallidescopeConfiguration;
+    /** What the lookup prints, resolved from the command line and refused if unknown. */
+    readonly format: CallidescopeOutputFormat;
+    readonly located: LocateOutcome;
+    readonly workspaceRoot: string;
+}
+
+/** The collected callables and their graph, without any analysis run over them. */
+export declare interface LocateOutcome {
+    readonly callablesById: ReadonlyMap<CallableId, DiscoveredCallable>;
+    readonly graph: CallGraph;
+    /** Workspace-relative root of each project the run was scoped to, keyed by name. */
+    readonly startingProjectRoots: ReadonlyMap<string, string>;
+}
+
+/**
+ * Structured values that belong beside a log line rather than inside it.
+ *
+ * Counts, percentages, and durations are the values that change on every
+ * occurrence, so they are carried as fields: the message stays constant and
+ * groupable in telemetry, and the numbers stay queryable instead of having to
+ * be parsed back out of prose.
+ *
+ * The named members are the recurring ones; the index signature keeps the
+ * argument open for whatever a given call site needs to attach.
+ */
+declare interface LogData {
+    [key: string]: unknown;
+    /** How many things the operation handled. */
+    count?: number;
+    /** Wall-clock milliseconds the operation took. */
+    durationMs?: number;
+    /** Completion between 0 and 100. */
+    percent?: number;
+    /** How many things the operation set out to handle. */
+    total?: number;
+}
+
+/**
+ * Transient-scoped logger so each injecting class gets its own instance.
+ * Each consumer calls `setContext(ClassName.name)` to tag every log line
+ * with the originating class. Backed by pino for structured JSON output in
+ * production and human-readable pretty-print in development.
+ *
+ * Messages follow one grammar: an emoji naming the subject, a verb in present
+ * progressive or past tense, then the object. Values that vary per call —
+ * counts, percentages, durations — go in the `data` argument rather than the
+ * message, so the message stays constant enough for telemetry to group on.
+ *
+ * ```ts
+ * this.logger.info("📥 Downloading CSEL sources", undefined, { total: 428 });
+ * this.logger.info("📥 Downloaded CSEL sources", undefined, { count: 412 });
+ * ```
+ */
+declare @Injectable({ scope: Scope.TRANSIENT })
+class LoggerService extends ConsoleLogger {
+    // 🏗 Dependency Injection
+
+    constructor() {
+        super();
+    }
+
+    // 🔐 Private Fields
+
+    private static readonly isProduction =
+    process.env["NODE_ENV"] === "production";
+
+    /**
+     * Built on first use, not when this file is evaluated.
+     *
+     * A destination fixed at import time could only ever be chosen by this
+     * package, since every consumer's own code runs after its imports.
+     */
+    private static rootLogger: pino.Logger | undefined;
+
+    /** Whether lines go to standard error instead of standard output. */
+    private static writesToStandardError = false;
+
+    private child: pino.Logger = LoggerService.root;
+
+    // 🔑 Public Fields
+
+    // 🔏 Private Methods
+
+    /** Build the pino instance for production or local development output. */
+    private static createRootLogger(): pino.Logger {
+        const level = process.env["LOG_LEVEL"] ?? "info";
+
+        if (LoggerService.isProduction) {
+            return LoggerService.writesToStandardError
+            ? pino({ level }, pino.destination(STANDARD_ERROR_DESCRIPTOR))
+            : pino({ level });
+        }
+
+        return pino({
+            level,
+            transport: {
+                options: {
+                    colorize: true,
+                    destination: LoggerService.writesToStandardError
+                    ? STANDARD_ERROR_DESCRIPTOR
+                    : STANDARD_OUTPUT_DESCRIPTOR,
+                    // The emoji is a field, not part of the message, so the console can
+                    // show it while telemetry stores unadorned prose. `ignore` then keeps
+                    // it from being printed a second time in the trailing object.
+                    ignore: "pid,hostname,emoji",
+                    messageFormat: "{emoji} {msg}",
+                    singleLine: true,
+                },
+                target: "pino-pretty",
+            },
+        });
+    }
+
+    /**
+     * Sends every subsequent line to standard error instead of standard output.
+     *
+     * For a command-line application whose standard output *is* its result. A log
+     * line sharing that stream is not a diagnostic beside the data, it is a
+     * corruption of it. Call it before anything logs — the first statement of the
+     * application's bootstrap.
+     *
+     * A call after the first line warns and changes nothing: the destination is
+     * fixed when the pino instance is built, and tearing down a transport
+     * somebody is writing through would be worse than refusing. The warning is
+     * the point — silently leaving the lines on standard output is how a caller
+     * would ship a corrupted pipe without ever being told.
+     */
+    static logToStandardError(): void {
+        if (LoggerService.rootLogger !== undefined) {
+            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;
+        }
+
+        LoggerService.writesToStandardError = true;
+    }
+
+    /**
+     * Fails a malformed message in development, and never in production.
+     *
+     * A logger that throws in production turns an observability call into an
+     * outage, so the check runs only where a developer is present to fix it.
+     */
+    private assertConventionalMessage(args: {
+        context: string | undefined;
+        parsed: ParsedLogMessage;
+    }): void {
+        if (
+        LoggerService.isProduction ||
+        this.shouldSkipConventionalMessageValidation(args.context)
+        ) {
+            return;
+        }
+
+        const violation = this.getConventionalMessageViolation(args.parsed);
+
+        if (violation !== undefined) {
+            throw new Error(violation);
+        }
+    }
+
+    /** Assembles the object pino merges into the line. */
+    private buildBindings(args: {
+        context: string | undefined;
+        data: LogData | undefined;
+        parsed: ParsedLogMessage;
+    }): Record<string, unknown> {
+        this.assertConventionalMessage({
+            context: args.context,
+            parsed: args.parsed,
+        });
+
+        return {
+            ...args.data,
+            context: args.context,
+            // Telemetry gets prose; only the console-bound transport reads this.
+            ...(LoggerService.isProduction ? {} : { emoji: args.parsed.emoji }),
+        };
+    }
+
+    /** Returns a human-readable explanation when the message format is invalid. */
+    private getConventionalMessageViolation(
+    parsed: ParsedLogMessage,
+    ): string | undefined {
+        const emoji = parsed.emoji;
+        const text = parsed.text;
+
+        if (emoji === undefined) {
+            return `Log message must start with an emoji naming its subject, then a verb: "${text}"`;
+        }
+
+        const firstWord = FIRST_WORD_PATTERN.exec(text)?.[1];
+
+        if (firstWord === undefined || !this.isConventionalVerb(firstWord)) {
+            return `Log message must begin with a verb in present progressive or past tense, got "${firstWord ?? ""}": "${emoji} ${text}"`;
+        }
+
+        return undefined;
+    }
+
+    /**
+     * Whether a word is a verb in one of the two tenses the convention allows.
+     *
+     * Present progressive means the operation is under way; past means it
+     * finished. Regular morphology covers both, so a new verb needs no
+     * registration anywhere — only irregular pasts are enumerated.
+     */
+    private isConventionalVerb(word: string): boolean {
+        const lowercased = word.toLowerCase();
+
+        return (
+        lowercased.endsWith("ing") ||
+        lowercased.endsWith("ed") ||
+        IRREGULAR_PAST_VERBS.has(lowercased)
+        );
+    }
+
+    /** Splits a leading emoji off a message, leaving prose behind. */
+    private parseMessage(message: unknown): ParsedLogMessage {
+        const text = String(message);
+        const match = LEADING_EMOJI_PATTERN.exec(text);
+        const emoji = match?.[1];
+
+        return emoji === undefined
+        ? { emoji: undefined, text }
+        : { emoji, text: text.slice(match?.[0].length) };
+    }
+
+    /** Whether a context is intentionally exempt from the validation rule. */
+    private shouldSkipConventionalMessageValidation(
+    context: string | undefined,
+    ): boolean {
+        return context !== undefined && UNVALIDATED_LOG_CONTEXTS.has(context);
+    }
+
+    // 🌎 Public Methods
+
+    /** The pino instance every logger's child is taken from. */
+    private static get root(): pino.Logger {
+        LoggerService.rootLogger ??= LoggerService.createRootLogger();
+
+        return LoggerService.rootLogger;
+    }
+
+    /** Normalizes unknown errors into a stable message and timestamped log line. */
+    buildErrorLogEntry(
+    context: string,
+    error: unknown,
+    ): { errorMessage: string; logLine: string } {
+        const errorMessage =
+        error instanceof Error ? error.stack || error.message : String(error);
+
+        return {
+            errorMessage,
+            logLine: `[${new Date().toISOString()}] ${context}: ${errorMessage}\n`,
+        };
+    }
+
+    /** Builds a timestamped output log file path and ensures the output directory exists. */
+    createTimestampedOutputLogFilePath(filePrefix: string): string {
+        const outputDirectory = path.join(process.cwd(), "output");
+        if (!existsSync(outputDirectory)) {
+            mkdirSync(outputDirectory, { recursive: true });
+        }
+
+        return path.join(
+        outputDirectory,
+        `${filePrefix}-${new Date().toISOString().replaceAll(/[:.]/g, "-")}.log`,
+        );
+    }
+
+    /** Logs a debug message at the `debug` level. */
+    override debug(message: unknown, context?: string, data?: LogData): void {
+        const parsed = this.parseMessage(message);
+        this.child.debug(
+        this.buildBindings({ context: context ?? this.context, data, parsed }),
+        parsed.text,
+        );
+    }
+
+    /**
+     * Logs an error message at the `error` level, optionally including a stack trace.
+     *
+     * `ConsoleLogger.error` spends a third slot on a context string that the
+     * other levels do not have, so this one accepts either: a string keeps
+     * NestJS's meaning, an object is structured data like everywhere else.
+     */
+    override error(
+    message: unknown,
+    stackOrContext?: string,
+    contextOrData?: LogData | string,
+    ): void {
+        const parsed = this.parseMessage(message);
+        const data = typeof contextOrData === "object" ? contextOrData : undefined;
+        const context =
+        typeof contextOrData === "string" ? contextOrData : this.context;
+
+        this.child.error(
+            {
+            ...this.buildBindings({ context, data, parsed }),
+            stack: stackOrContext,
+        },
+        parsed.text,
+        );
+    }
+
+    /** Logs an informational message at the `info` level. */
+    info(message: unknown, context?: string, data?: LogData): void {
+        const parsed = this.parseMessage(message);
+        this.child.info(
+        this.buildBindings({ context: context ?? this.context, data, parsed }),
+        parsed.text,
+        );
+    }
+
+    /**
+     * Logs an informational message at the `info` level.
+     *
+     * NestJS and `nest-commander` call this method directly as part of the
+     * framework's own `LoggerService` contract, so it must keep working
+     * exactly as before. Application code should call `info` instead — the
+     * same behavior under a name that says what level it logs at.
+     */
+    override log(message: unknown, context?: string, data?: LogData): void {
+        this.info(message, context, data);
+    }
+
+    /** Sets the context label included in every subsequent log line. */
+    override setContext(context: string): void {
+        super.setContext(context);
+        this.child = LoggerService.root.child({ context });
+    }
+
+    /** Logs a verbose message at the `trace` level. */
+    override verbose(message: unknown, context?: string, data?: LogData): void {
+        const parsed = this.parseMessage(message);
+        this.child.trace(
+        this.buildBindings({ context: context ?? this.context, data, parsed }),
+        parsed.text,
+        );
+    }
+
+    /** Logs a warning message at the `warn` level. */
+    override warn(message: unknown, context?: string, data?: LogData): void {
+        const parsed = this.parseMessage(message);
+        this.child.warn(
+        this.buildBindings({ context: context ?? this.context, data, parsed }),
+        parsed.text,
+        );
+    }
+}
+
+/**
+ * Root NestJS application module.
+ */
+export declare class MainModule {
+}
+
+/** A message split into the emoji the console shows and the prose telemetry stores. */
+declare interface ParsedLogMessage {
+    emoji: string | undefined;
+    text: string;
+}
+
+/** Arguments for matching an address against an already-traced workspace. */
+declare interface ResolveAddressArguments {
+    readonly address: string;
+    readonly workspace: LocatedWorkspace;
+}
+
+/** Arguments for one full trace of a workspace. */
+export declare interface TraceArguments {
+    /**
+     * The limits the workspace file itself wrote down, exactly as authored.
+     *
+     * Carried so the workspace row names the workspace file only when that file
+     * really wrote the number: resolution defaults `maximumDepth` for every run,
+     * and a path stamped from the resolved object alone would name a file for a
+     * number it never mentions.
+     */
+    readonly authoredLimits?: CallidescopeLimits | undefined;
+    readonly configuration: ResolvedCallidescopeConfiguration;
+    /**
+     * The file `configuration` was read from, when a file was found at all.
+     *
+     * Carried so the trace can skip it while resolving a configuration beside
+     * every project it reaches: one file holds one role per run, and a package
+     * whose task names its own file would otherwise have it read a second time
+     * as that package's project configuration.
+     */
+    readonly configurationPath?: string | undefined;
+    /** Project directories to trace. Every project in the workspace when empty. */
+    readonly directories: readonly string[];
+    /**
+     * The limits this run's command line overrode, if any.
+     *
+     * Carried into the trace because a limit is enforced per project: each
+     * project's own file declares the number its gate reads, so an override that
+     * stopped at the run's own configuration would be a flag no gate looks at.
+     */
+    readonly limitOverrides?: CallidescopeLimitOverrides | undefined;
+    readonly workspaceRoot: string;
+}
+
+/** What one trace produced, alongside the projects it covered. */
+export declare interface TraceOutcome extends AnalyzeOutcome {
+    /** Every project the run measured, its dependency closure included. */
+    readonly projectNames: readonly string[];
+    /**
+     * Workspace-relative root of each project the run was scoped to, keyed by
+     * name — the starting projects, not the closure they reached.
+     */
+    readonly startingProjectRoots: ReadonlyMap<string, string>;
+    /**
+     * The written destinations each project declared for itself, by name.
+     *
+     * Carried out of the trace rather than re-read at write time: the files were
+     * already opened once to decide what the run measures, and reading them a
+     * second time is how a run comes to publish against one answer and measure
+     * against another.
+     */
+    readonly writeByProject: ReadonlyMap<string, ResolvedCallidescopeWriteConfiguration>;
+}
+
+export { }

package/dist/src/index.js

@@ -0,0 +1,2 @@
+import { a as e, i as t, n, r, t as i } from "../main.module-tKMvFmcY.js";
+export { n as AddressLookupModule, r as AddressLookupService, t as CallidescopeModule, e as CallidescopeService, i as MainModule };

package/dist/src/main.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/src/main.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import { o as e, t } from "../main.module-tKMvFmcY.js";
+import { CommandFactory as n } from "nest-commander";
+import "reflect-metadata";
+//#region packages/ic-suite/callidescope/callidescope-cli/src/main.ts
+async function r() {
+	let r = new e();
+	r.setContext("CommandFactory"), await n.run(t, {
+		bufferLogs: !0,
+		logger: r,
+		serviceErrorHandler: (e) => {
+			r.error("🔭 Failed a run", e.stack, { reason: e.message }), process.exitCode = 1;
+		}
+	});
+}
+r();
+//#endregion