minercon 3.0.0

package/out/localCommandTree.js

@@ -0,0 +1,541 @@
+"use strict";
+// src/localCommandTree.ts
+//
+// The command tree for "local" (no-plugin) mode: built by crawling a
+// server's `/help` and `minecraft:help` output, cached to disk between runs
+// via `CommandTreeCache`, and consumed by `LocalCompletionsBackend` (which
+// turns it into completions/usage text via `commandSuggestions.ts`'s
+// `getSuggestions`). All the text parsing this crawl relies on is in
+// `helpTextParsing.ts` as pure functions - this file is the stateful
+// orchestration: deciding what to fetch, in what order, and how to merge and
+// store the results. See docs/technical/NO_PLUGIN_HELP_CRAWL.md.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalCommandTree = void 0;
+const path = __importStar(require("path"));
+const ansi_1 = require("./ansi");
+const commandTree_1 = require("./commandTree");
+const helpTextParsing_1 = require("./helpTextParsing");
+const bukkitHelpParsing_1 = require("./bukkitHelpParsing");
+const commandTreeCache_1 = require("./commandTreeCache");
+const commandSuggestions_1 = require("./commandSuggestions");
+class LocalCommandTree {
+    sendCommand;
+    logger;
+    rootCommands = new Map();
+    isLoading = false;
+    loadingProgress = 0;
+    totalCommands = 0;
+    isReady = false;
+    // Whether the `minecraft:` command namespace prefix is registered on this
+    // server. Paper/Spigot (Bukkit-based) accept `minecraft:help ...` and use
+    // it to get Brigadier-accurate `<args>` syntax for vanilla commands; pure
+    // Vanilla/Fabric reject it as an unknown namespace (Brigadier syntax
+    // error), but their plain `/help [<cmd>]` already returns full `<args>`
+    // syntax directly. Detected once in fetchRootCommands() and reused for
+    // every per-command detail fetch. See docs/technical/NO_PLUGIN_HELP_CRAWL.md.
+    supportsMinecraftNamespace = true;
+    // For each root command, whether its summary line in the root
+    // `minecraft:help` dump carried no real Brigadier info (empty or the
+    // generic `[<args>]` placeholder). When true, `loadCommandDetails` tries
+    // Bukkit's `help <command>` first, since `minecraft:help <command>` is
+    // unlikely to do better; when false (or absent), it tries
+    // `minecraft:help <command>` first. Either way, the other source is only
+    // fetched if the first one turns out insufficient. Populated once during
+    // fetchRootCommands(), not persisted to the cache.
+    rootSummaryIsPlaceholder = new Map();
+    cache;
+    // Set for the duration of `initialize()`: receives the crawl's blow-by-blow
+    // narration ("Loading details for command: X", ...). When provided (no log
+    // file - the narration would otherwise corrupt the console's progress bar),
+    // narration is routed here instead of to `this.logger`. See `report()`.
+    onMessage;
+    constructor(sendCommand, logger, cacheDir, serverHost, serverPort) {
+        this.sendCommand = sendCommand;
+        this.logger = logger;
+        this.cache = new commandTreeCache_1.CommandTreeCache(path.join(cacheDir, 'command-cache'), serverHost, serverPort, logger, (message) => this.report(message));
+    }
+    /** Reports crawl narration: to `onMessage` (e.g. a progress bar's message) if set, else logged. */
+    report(message) {
+        if (this.onMessage) {
+            this.onMessage(message);
+        }
+        else {
+            this.logger.info(message);
+        }
+    }
+    /**
+     * Initialize command database
+     */
+    async initialize(onProgress, onMessage, forceRefresh = false) {
+        if (this.isLoading) {
+            return;
+        }
+        this.isLoading = true;
+        this.loadingProgress = 0;
+        this.onMessage = onMessage;
+        try {
+            // Try to load from cache first
+            if (!forceRefresh) {
+                const loaded = this.cache.load();
+                if (loaded) {
+                    this.rootCommands = loaded;
+                    onProgress?.(100, 'cache-hit');
+                    this.isReady = true;
+                    return;
+                }
+            }
+            // Aliases discovered while crawling (`<alias> -> <target>` redirect
+            // lines, Bukkit `Aliases:` lines) - resolved into rootCommands once
+            // their targets have been fully loaded, below.
+            const pendingAliases = new Map();
+            // Fetch commands from server
+            onProgress?.(10, 'fetching');
+            await this.fetchRootCommands(pendingAliases);
+            // Load details for each command. Namespaced commands (`minecraft:foo`,
+            // `bukkit:foo`, ...) are loaded first, so that their bare counterparts
+            // (`foo`) can reuse the already-fetched details instead of issuing a
+            // second, near-identical pair of `help`/`minecraft:help` round trips
+            // (see loadCommandDetails).
+            const commands = Array.from(this.rootCommands.keys())
+                .sort((a, b) => Number(b.includes(':')) - Number(a.includes(':')));
+            this.report(`Loading details for ${commands.length} commands...`);
+            for (let i = 0; i < commands.length; i++) {
+                const progress = 10 + (80 * (i / commands.length));
+                onProgress?.(progress, 'loading');
+                const node = this.rootCommands.get(commands[i]);
+                try {
+                    await this.loadCommandDetails(node, node.members, pendingAliases);
+                }
+                catch (error) {
+                    this.logger.warn(`Warning: Failed to load details for ${commands[i]}: ${error}`);
+                    // Continue with other commands even if one fails
+                }
+            }
+            // Expand aliases into rootCommands now that their targets are fully
+            // loaded, sharing the target's node so alias entries stay in sync.
+            for (const [alias, target] of pendingAliases) {
+                const targetNode = this.rootCommands.get(target);
+                if (targetNode && !this.rootCommands.has(alias)) {
+                    this.rootCommands.set(alias, targetNode);
+                }
+            }
+            // Save to cache
+            this.cache.save(this.rootCommands);
+            onProgress?.(100, 'complete');
+            this.isReady = true;
+        }
+        catch (error) {
+            this.logger.error(`Error initializing commands: ${error}`);
+            // Try to provide basic functionality even if initialization fails
+            this.isReady = true; // Mark as ready with whatever we have
+            throw error;
+        }
+        finally {
+            this.isLoading = false;
+        }
+    }
+    async fetchPaginatedCommand(command) {
+        let output = await this.sendCommand(command);
+        const match = output.match(/Help:\s+.*?\((\d+)\/(\d+)\)/i);
+        if (!match) {
+            return output; // No pagination info, return original output
+        }
+        else {
+            const pageCount = parseInt(match[2]);
+            this.report(`Detected paginated output: ${pageCount} pages total`);
+            for (let page = 2; page <= pageCount; page++) {
+                const pageOutput = await this.sendCommand(`${command} ${page}`);
+                if (pageOutput) {
+                    this.report(`Fetched page ${page}/${pageCount} (${pageOutput.length} bytes)`);
+                    output += pageOutput;
+                }
+            }
+            return output;
+        }
+    }
+    /**
+     * Fetch root commands from server
+     */
+    async fetchRootCommands(pendingAliases) {
+        try {
+            this.report('Fetching root commands with /help...');
+            const mcResponse = await this.sendCommand('minecraft:help');
+            if ((0, helpTextParsing_1.isUnsupportedNamespaceError)(mcResponse)) {
+                // Vanilla/Fabric: the `minecraft:` namespace prefix isn't
+                // registered. Plain `/help` (paginated) already gives a complete,
+                // accurate, one-shot command list with full <args> syntax.
+                this.report('minecraft: namespace not supported; using /help for root commands');
+                this.supportsMinecraftNamespace = false;
+                const response = await this.fetchPaginatedCommand('help');
+                this.report(`Help response received: ${response.length} bytes`);
+                if (!response || response.length === 0) {
+                    throw new Error('Unable to fetch command list from server');
+                }
+                this.ingestHelpResponse(response, pendingAliases);
+                return;
+            }
+            this.supportsMinecraftNamespace = true;
+            this.report(`Help response received: ${mcResponse.length} bytes`);
+            if (!mcResponse || mcResponse.length === 0) {
+                this.logger.warn('Warning: Empty response from help command');
+                // Try alternative help format
+                const altResponse = await this.sendCommand('?');
+                if (altResponse && altResponse.length > 0) {
+                    this.report('Using alternative help command (?)');
+                    this.ingestHelpResponse(altResponse, pendingAliases);
+                }
+                else {
+                    throw new Error('Unable to fetch command list from server');
+                }
+            }
+            else {
+                this.ingestHelpResponse(mcResponse, pendingAliases);
+            }
+        }
+        catch (error) {
+            this.logger.error(`Error fetching root commands: ${error}`);
+            // Provide fallback common commands if help fails
+            this.addFallbackCommands();
+            throw error;
+        }
+    }
+    /**
+     * Parse a help response and merge the commands/aliases it describes into
+     * `rootCommands`, `rootSummaryIsPlaceholder`, and `pendingAliases`.
+     */
+    ingestHelpResponse(response, pendingAliases) {
+        const { commands, aliases } = (0, helpTextParsing_1.parseHelpResponse)(response);
+        for (const { alias, target } of aliases) {
+            pendingAliases.set(alias, target);
+        }
+        for (const { name, isPlaceholder } of commands) {
+            this.rootCommands.set(name, (0, commandTree_1.newCommandNode)(name));
+            this.rootSummaryIsPlaceholder.set(name, isPlaceholder);
+        }
+        this.report(`Found ${this.rootCommands.size} root commands`);
+        if (commands.length === 0) {
+            this.logger.warn('Warning: No commands found in help response');
+            this.report('First few lines of response:');
+            (0, helpTextParsing_1.splitConcatenatedHelpLines)(response).split('\n').slice(0, 10).forEach(line => {
+                this.report(`  > ${(0, ansi_1.stripColors)(line)}`);
+            });
+            // Add fallback commands
+            this.addFallbackCommands();
+        }
+    }
+    /**
+     * Add fallback commands if help parsing fails
+     */
+    addFallbackCommands() {
+        this.report('Adding common Minecraft commands as fallback...');
+        const commonCommands = [
+            'gamemode', 'give', 'tp', 'teleport', 'kill', 'kick', 'ban', 'pardon',
+            'op', 'deop', 'whitelist', 'reload', 'save-all', 'save-on', 'save-off',
+            'stop', 'list', 'say', 'tell', 'msg', 'w', 'me', 'trigger', 'scoreboard',
+            'effect', 'enchant', 'xp', 'experience', 'clear', 'difficulty', 'gamerule',
+            'defaultgamemode', 'setworldspawn', 'spawnpoint', 'time', 'weather', 'worldborder',
+            'locate', 'particle', 'playsound', 'stopsound', 'title', 'tellraw', 'help',
+            'seed', 'clone', 'fill', 'setblock', 'summon', 'execute',
+            'recipe', 'advancement', 'function', 'tag', 'team',
+            'bossbar', 'data', 'datapack', 'debug', 'forceload', 'locatebiome', 'loot',
+            'publish', 'schedule', 'spreadplayers', 'spectate'
+        ];
+        for (const cmd of commonCommands) {
+            if (!this.rootCommands.has(cmd)) {
+                this.rootCommands.set(cmd, (0, commandTree_1.newCommandNode)(cmd));
+            }
+        }
+        this.report(`Added ${commonCommands.length} fallback commands`);
+    }
+    /**
+     * Find an already-loaded root command that's a namespaced form of the bare
+     * `commandPath` (e.g. "minecraft:version" or "bukkit:version" for
+     * "version"), if any. Returns the first match in `rootCommands`'
+     * iteration order, or `undefined` if `commandPath` itself is namespaced or
+     * no such sibling exists yet.
+     */
+    findNamespacedSibling(commandPath) {
+        if (commandPath.includes(':')) {
+            return undefined;
+        }
+        for (const [name, node] of this.rootCommands) {
+            if (node.isComplete && name.endsWith(`:${commandPath}`)) {
+                return node;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Merge the two help sources for `commandPath`'s syntax into one
+     * `HelpLinesResult`. `mcResponse` (from `minecraft:help <commandPath>`,
+     * only fetched when `supportsMinecraftNamespace`, and sometimes skipped
+     * even then as an optimization - see `loadCommandDetails`) wins unless
+     * it's empty or the generic `[<args>]` placeholder Bukkit emits for
+     * non-Brigadier commands, in which case `helpResponse` (from `help
+     * <commandPath>`) is used instead.
+     *
+     * Which shape `helpResponse` is in follows directly from
+     * `this.supportsMinecraftNamespace`, not from sniffing its content: when
+     * `minecraft:` is supported, Paper/Spigot's `help <path>` is *always* a
+     * Bukkit `Description:`/`Usage:`/`Aliases:` page (even for vanilla-backed
+     * commands), extracted via `extractBukkitUsageLines`; when it isn't,
+     * vanilla/fabric's `help <path>` is *always* a flat Brigadier blob. See
+     * docs/technical/NO_PLUGIN_HELP_CRAWL.md.
+     */
+    mergeHelpSources(helpResponse, mcResponse, commandPath) {
+        // mcResponse is always a flat Brigadier blob - never a Bukkit help page.
+        const mc = mcResponse !== null
+            ? (0, helpTextParsing_1.parseHelpLines)((0, helpTextParsing_1.splitConcatenatedHelpLines)(mcResponse), commandPath)
+            : { variants: new Map(), direct: null };
+        let result;
+        if (mc.direct !== null && !(0, helpTextParsing_1.isGenericArgsPlaceholder)(mc.direct)) {
+            result = { variants: new Map(), direct: mc.direct };
+        }
+        else if (mc.variants.size > 0) {
+            result = { variants: mc.variants, direct: null };
+        }
+        else if (this.supportsMinecraftNamespace) {
+            // helpResponse is always a Bukkit Description:/Usage:/Aliases: page -
+            // extract its Usage line(s).
+            result = (0, helpTextParsing_1.parseHelpLines)((0, bukkitHelpParsing_1.extractBukkitUsageLines)(helpResponse, commandPath).join('\n'), commandPath);
+        }
+        else {
+            // helpResponse is always a flat Brigadier blob. Like `mcResponse`,
+            // vanilla's `help <path>` responses for commands with multiple
+            // variants (team, gamerule, debug, ...) pack each `/path ...` onto one
+            // line with no separators - re-split the same way.
+            result = (0, helpTextParsing_1.parseHelpLines)((0, helpTextParsing_1.splitConcatenatedHelpLines)(helpResponse), commandPath);
+        }
+        // The generic `[<args>]` placeholder (from either source) means "no
+        // further arguments", not a real <args> token.
+        if (result.direct !== null && (0, helpTextParsing_1.isGenericArgsPlaceholder)(result.direct)) {
+            result = { variants: result.variants, direct: [] };
+        }
+        return result;
+    }
+    /**
+     * Load details for a command or subcommand
+     */
+    async loadCommandDetails(parent, parameters, pendingAliases) {
+        const commandPath = parent.name || parent.literal || '';
+        // A bare command (e.g. "version") and its namespaced counterparts (e.g.
+        // "bukkit:version", "minecraft:version") describe the same underlying
+        // command and have identical `help`/`minecraft:help` output - fetching
+        // both is wasteful. Namespaced commands are loaded first (see
+        // initialize()), so if one is already complete, reuse its parameters
+        // instead of repeating the round trips.
+        const sibling = this.findNamespacedSibling(commandPath);
+        if (sibling) {
+            parameters.length = 0;
+            parameters.push(...(sibling.members ?? []));
+            parent.isComplete = true;
+            this.report(`Reusing ${sibling.name}'s details for ${commandPath}`);
+            return;
+        }
+        // Reported before the round trips below (rather than after) so it's
+        // visible while they're in flight, instead of being instantly
+        // overwritten by the next command's report.
+        this.report(`Loading details for command: ${commandPath}`);
+        try {
+            let helpResponse = '';
+            let mcResponse = null;
+            if (!this.supportsMinecraftNamespace) {
+                helpResponse = await this.fetchPaginatedCommand(`help ${commandPath}`);
+            }
+            else if (this.rootSummaryIsPlaceholder.get(commandPath)) {
+                // The root `minecraft:help` summary for this command had no real
+                // syntax (empty or `[<args>]`) - `minecraft:help <commandPath>` is
+                // unlikely to do better, so try Bukkit's `help <commandPath>` first
+                // and only fall back to `minecraft:help` if it doesn't pan out.
+                helpResponse = await this.fetchPaginatedCommand(`help ${commandPath}`);
+                const fromHelp = (0, helpTextParsing_1.parseHelpLines)((0, bukkitHelpParsing_1.extractBukkitUsageLines)(helpResponse, commandPath).join('\n'), commandPath);
+                if (!(0, helpTextParsing_1.hasRealUsage)(fromHelp)) {
+                    mcResponse = await this.fetchPaginatedCommand(`minecraft:help ${commandPath}`);
+                }
+            }
+            else {
+                // The root summary already had real syntax info - `minecraft:help
+                // <commandPath>` is at least as detailed, so try it first and only
+                // fall back to Bukkit's `help <commandPath>` if it doesn't pan out.
+                mcResponse = await this.fetchPaginatedCommand(`minecraft:help ${commandPath}`);
+                const fromMc = (0, helpTextParsing_1.parseHelpLines)((0, helpTextParsing_1.splitConcatenatedHelpLines)(mcResponse), commandPath);
+                if (!(0, helpTextParsing_1.hasRealUsage)(fromMc)) {
+                    helpResponse = await this.fetchPaginatedCommand(`help ${commandPath}`);
+                }
+            }
+            // Check if we got a valid response from at least one source
+            if (!helpResponse && !mcResponse) {
+                this.logger.warn(`Empty help response for: ${commandPath}`);
+                return;
+            }
+            // Bukkit `/help <command>` pages list aliases on their own
+            // `Aliases: a, b, c` line - returns [] for Brigadier blobs, which
+            // have no such line.
+            for (const alias of (0, bukkitHelpParsing_1.extractBukkitAliases)(helpResponse)) {
+                pendingAliases.set(alias, commandPath);
+            }
+            const { variants, direct } = this.mergeHelpSources(helpResponse, mcResponse, commandPath);
+            parameters.length = 0;
+            if (direct !== null) {
+                parameters.push(...direct);
+            }
+            else {
+                parameters.push(...(0, helpTextParsing_1.buildParameterStructureFromVariants)(variants));
+            }
+            this.report(`Loaded ${parameters.length} parameter(s) for ${commandPath}`);
+            // Mark as complete
+            parent.isComplete = true;
+            // Recursively load details for all subcommands
+            await this.loadSubcommandsIn(commandPath, parameters);
+        }
+        catch (error) {
+            this.logger.error(`Error loading details for ${commandPath}: ${error}`);
+            // Mark as complete even on error to avoid infinite loops
+            parent.isComplete = true;
+        }
+    }
+    /**
+     * Load details for a subcommand by fetching its help
+     */
+    async loadSubcommandDetails(parentPath, subcommand) {
+        if (subcommand.type !== commandTree_1.ParameterType.SUBCOMMAND || !subcommand.name) {
+            return;
+        }
+        // Build the full command path for this subcommand
+        const fullPath = `${parentPath} ${subcommand.name}`;
+        // The variant line that introduced this subcommand (e.g. "/gamerule
+        // doDaylightCycle [<value>]") already gave us its argument list - trust
+        // it instead of spending a `help`/`minecraft:help` round trip per
+        // subcommand (e.g. once per gamerule, scoreboard objectives subcommand,
+        // ...). Only fall through to fetching when that usage is empty or just
+        // the generic `<args>` placeholder, i.e. we don't actually know its args.
+        if (subcommand.members && (0, helpTextParsing_1.hasUsableArguments)(subcommand.members)) {
+            subcommand.isComplete = true;
+            await this.loadSubcommandsIn(fullPath, subcommand.members);
+            return;
+        }
+        // A variant whose name came from a `[bracketed]` token with no further
+        // arguments (e.g. "[peaceful]" in "/minecraft:difficulty [peaceful]")
+        // is one literal value of an enum-style argument, not a subcommand verb
+        // - "peaceful" has no syntax of its own to discover, so
+        // "help"/"minecraft:help <fullPath>" would just be wasted round trips
+        // (confirmed: minecraft:help returns empty, help returns "not found").
+        if (subcommand.members && subcommand.members.length === 0 && subcommand.optional) {
+            subcommand.isComplete = true;
+            return;
+        }
+        try {
+            const helpResponse = await this.fetchPaginatedCommand(`help ${fullPath}`);
+            const mcResponse = this.supportsMinecraftNamespace
+                ? await this.fetchPaginatedCommand(`minecraft:help ${fullPath}`)
+                : null;
+            // Check for a valid response from at least one source
+            if (!helpResponse && !mcResponse) {
+                subcommand.isComplete = true;
+                return;
+            }
+            const { variants, direct } = this.mergeHelpSources(helpResponse, mcResponse, fullPath);
+            if (variants.size === 0 && direct === null) {
+                // Neither source described `fullPath` directly (e.g. it's an enum
+                // value like a gamerule name, not a queryable command path) - keep
+                // whatever members were already known from the parent's syntax line.
+                subcommand.isComplete = true;
+                return;
+            }
+            // Clear existing members to avoid duplicates
+            if (!subcommand.members) {
+                subcommand.members = [];
+            }
+            subcommand.members.length = 0;
+            if (direct !== null) {
+                subcommand.members.push(...direct);
+            }
+            else {
+                subcommand.members.push(...(0, helpTextParsing_1.buildParameterStructureFromVariants)(variants));
+            }
+            subcommand.isComplete = true;
+            // Recursively load any nested subcommands
+            if (subcommand.members) {
+                await this.loadSubcommandsIn(fullPath, subcommand.members);
+            }
+        }
+        catch {
+            // Subcommand might not have its own help, that's okay
+            subcommand.isComplete = true;
+        }
+    }
+    /**
+     * Recursively loads details for any not-yet-complete SUBCOMMAND parameters
+     * in `parameters` — both direct ones and those nested inside CHOICE_LIST
+     * choices — fetching each via `loadSubcommandDetails(path, ...)`.
+     */
+    async loadSubcommandsIn(path, parameters) {
+        for (const param of parameters) {
+            if (param.type === commandTree_1.ParameterType.CHOICE_LIST && param.choices) {
+                // For choice lists, recurse into each subcommand choice
+                for (const choice of param.choices) {
+                    if (choice.type === commandTree_1.ParameterType.SUBCOMMAND && !choice.isComplete) {
+                        await this.loadSubcommandDetails(path, choice);
+                    }
+                }
+            }
+            else if (param.type === commandTree_1.ParameterType.SUBCOMMAND && !param.isComplete) {
+                // Direct subcommand parameter
+                await this.loadSubcommandDetails(path, param);
+            }
+        }
+    }
+    /**
+     * Get suggestions based on current input
+     */
+    getSuggestions(input) {
+        return (0, commandSuggestions_1.getSuggestions)(this.rootCommands, this.isReady, input);
+    }
+    /**
+     * Get cache information
+     */
+    getCacheInfo() {
+        return this.cache.getInfo();
+    }
+    /**
+     * Clear the cache
+     */
+    clearCache() {
+        this.cache.clear();
+    }
+}
+exports.LocalCommandTree = LocalCommandTree;
+//# sourceMappingURL=localCommandTree.js.map

package/out/logger.js

@@ -0,0 +1,14 @@
+"use strict";
+// src/logger.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorMessage = errorMessage;
+/**
+ * Safely render a caught `unknown` value as a string for logging/display —
+ * `Error`s contribute their `message`, anything else is stringified directly.
+ * Replaces the `(err as any).message ?? err` pattern that was scattered
+ * across every catch block that needed to report what went wrong.
+ */
+function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+//# sourceMappingURL=logger.js.map