@dbx-tools/shared-core 0.3.44 → 0.4.0

package/lib/src/json.js

@@ -0,0 +1,49 @@
+/**
+ * Browser-safe JSON helpers for the parse-untrusted-text case.
+ *
+ * `JSON.parse` throws on malformed input and returns `any`, so almost every
+ * caller in this repo wrapped it in the same try/catch and then re-narrowed the
+ * result by hand. {@link parse} collapses the try/catch (a bad document yields
+ * the fallback instead of throwing) and {@link parseRecord} adds the narrowing
+ * that untrusted JSON almost always needs before it can be indexed.
+ *
+ * Use these when the document comes from OUTSIDE the process - a request body,
+ * an env var, a config file, a subprocess's stdout, a third-party API. Keep
+ * bare `JSON.parse` where a throw is the correct outcome (an internally
+ * produced document that must be well-formed).
+ *
+ * These deliberately do NOT validate shape beyond "is it a record". Reach for
+ * a zod schema when the payload has a contract; these only get you from `string`
+ * to a safely typed starting point.
+ *
+ * @module
+ */
+import { isRecord } from "./object.js";
+export function parse(text, fallback) {
+    if (typeof text !== "string" || text.trim().length === 0)
+        return fallback;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return fallback;
+    }
+}
+/**
+ * Parse JSON text that is expected to be an object, returning `undefined` when
+ * it is absent, malformed, or parses to a non-record (an array, a bare string,
+ * `null`, ...).
+ *
+ * This is the common case for manifests, env-var config blobs, and untyped API
+ * payloads: {@link parse} followed by {@link isRecord}, so the result can be
+ * indexed without an `as Record<string, unknown>` cast.
+ *
+ * @example
+ * const manifest = json.parseRecord(await readFile("package.json", "utf8")) ?? {};
+ * const name = manifest.name;
+ */
+export function parseRecord(text) {
+    const parsed = parse(text);
+    return isRecord(parsed) ? parsed : undefined;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/log.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Tagged, leveled logging for every runtime - the one logger the whole
+ * monorepo shares.
+ *
+ * {@link logger} resolves a tagged {@link Logger} via a {@link LoggerFactory}
+ * chosen once at module load. {@link LogLevel} filtering runs through
+ * {@link shouldEmit} in the consola reporter or in per-level wrappers on the
+ * `console` fallbacks.
+ *
+ * Sink selection chains two factories with nullish coalescing (first match
+ * wins):
+ *
+ * 1. {@link createConsolaLoggerFactory} when consola resolves and
+ *    `LOG_CONSOLA_DISABLED` is not truthy.
+ * 2. {@link createConsoleLoggerFactory} everywhere else.
+ *
+ * The console fallback writes formatted lines to `process.stderr` when it is
+ * available (Bun `inspect` per argument when `LOG_BUN_CONSOLE_DISABLED` is
+ * unset, otherwise `node:util` `formatWithOptions`), or delegates to global
+ * `console.*` when stderr or `node:util` is unavailable. Browser hosts omit
+ * the `LEVEL` text prefix (devtools show severity) and keep only the `[name]`
+ * tag.
+ *
+ * Env toggles (read once at init): `LOG_LEVEL`, `LOG_CONSOLA_DISABLED`,
+ * `LOG_BUN_CONSOLE_DISABLED`.
+ *
+ * Browser-safe: `process` / `Bun` / `window` / `document` are all reached
+ * through `globalThis` and guarded, and consola / `node:util` load lazily, so
+ * the module works in any runtime. Consola is an optional peer; the module
+ * loads fine without it.
+ *
+ * @module
+ */
+import { type NameLike } from "./object.js";
+declare const LOG_LEVELS: readonly ["debug", "info", "warn", "error"];
+/**
+ * Supported severities, lowest to highest: `debug`, `info`, `warn`, `error`.
+ * A call below the active threshold is discarded before any string work or
+ * sink I/O.
+ *
+ * The threshold comes from `process.env.LOG_LEVEL` on every call
+ * (case-insensitive, default `info` when unset, empty, or unknown) so test
+ * runners and embedders can change verbosity after import without restarting
+ * the process.
+ */
+export type LogLevel = (typeof LOG_LEVELS)[number];
+export type Logger = {
+    [K in LogLevel]: (...args: any[]) => void;
+} & {
+    /** Success message (consola `success`; falls back to `info`-level output). */
+    success: (...args: any[]) => void;
+    /** Start / in-progress message (consola `start`; falls back to `info`-level output). */
+    start: (...args: any[]) => void;
+};
+/**
+ * Whether a call at `level` would be emitted at the current
+ * `process.env.LOG_LEVEL` threshold. Use before building expensive debug
+ * payloads.
+ *
+ * @example
+ * if (isLevelEnabled("debug")) {
+ *   log.debug("mounts:resolver", { contribution: await heavySnapshot() });
+ * }
+ */
+export declare function isLevelEnabled(level: LogLevel): boolean;
+/**
+ * Build a tagged logger for a plugin or module.
+ *
+ * The tag is `[name]` when `loggerName` is a non-empty string, a
+ * {@link NameLike} with `name`, or a file / URL path (the basename without
+ * extension is used). Consola applies the tag via `withTag` (render-time).
+ * The `console` fallbacks prepend `LEVEL [name]` on Node/Bun hosts or `[name]`
+ * alone in browsers via {@link createFormatter}.
+ *
+ * Calls below `process.env.LOG_LEVEL` are dropped by {@link shouldEmit} before
+ * the sink formats or writes the line.
+ *
+ * @example
+ * import { log } from "@dbx-tools/shared-core";
+ *
+ * const logger = log.logger("genie/chat");
+ * logger.info("starting");
+ * logger.warn("missing optional config", { reason: "no env var" });
+ */
+export declare function logger(loggerName: NameLike | string | undefined): Logger;
+export {};

package/lib/src/log.js

@@ -0,0 +1,352 @@
+/**
+ * Tagged, leveled logging for every runtime - the one logger the whole
+ * monorepo shares.
+ *
+ * {@link logger} resolves a tagged {@link Logger} via a {@link LoggerFactory}
+ * chosen once at module load. {@link LogLevel} filtering runs through
+ * {@link shouldEmit} in the consola reporter or in per-level wrappers on the
+ * `console` fallbacks.
+ *
+ * Sink selection chains two factories with nullish coalescing (first match
+ * wins):
+ *
+ * 1. {@link createConsolaLoggerFactory} when consola resolves and
+ *    `LOG_CONSOLA_DISABLED` is not truthy.
+ * 2. {@link createConsoleLoggerFactory} everywhere else.
+ *
+ * The console fallback writes formatted lines to `process.stderr` when it is
+ * available (Bun `inspect` per argument when `LOG_BUN_CONSOLE_DISABLED` is
+ * unset, otherwise `node:util` `formatWithOptions`), or delegates to global
+ * `console.*` when stderr or `node:util` is unavailable. Browser hosts omit
+ * the `LEVEL` text prefix (devtools show severity) and keep only the `[name]`
+ * tag.
+ *
+ * Env toggles (read once at init): `LOG_LEVEL`, `LOG_CONSOLA_DISABLED`,
+ * `LOG_BUN_CONSOLE_DISABLED`.
+ *
+ * Browser-safe: `process` / `Bun` / `window` / `document` are all reached
+ * through `globalThis` and guarded, and consola / `node:util` load lazily, so
+ * the module works in any runtime. Consola is an optional peer; the module
+ * loads fine without it.
+ *
+ * @module
+ */
+import { memoize } from "./function.js";
+import { toBoolean } from "./object.js";
+const globalProcess = globalThis.process;
+const globalBun = globalThis.Bun;
+/**
+ * Node `process.stderr` when writable, else `undefined` (stable for the
+ * process). Typed loosely (`any`) because it is handed to consola's
+ * `ctx.options.stdout` (a `WriteStream`) and to the console fallback's
+ * `.write`, neither of which our structural {@link ProcessLike} shape satisfies
+ * nominally.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const globalProcessStdErr = globalProcess && typeof globalProcess.stderr?.write === "function"
+    ? globalProcess.stderr
+    : undefined;
+const LOG_LEVELS = ["debug", "info", "warn", "error"];
+const LOG_LEVEL_RANK = Object.fromEntries(LOG_LEVELS.map((level, index) => [level, index]));
+const LOG_LEVEL_COLORS = Object.fromEntries(LOG_LEVELS.map((level) => {
+    let color = "\x1b[90m"; // gray
+    switch (level) {
+        case "info":
+            color = "\x1b[34m"; // blue
+            break;
+        case "warn":
+            color = "\x1b[33m"; // yellow
+            break;
+        case "error":
+            color = "\x1b[31m"; // red
+            break;
+    }
+    return [level, color];
+}));
+const LOG_LEVEL_COLOR_RESET = "\x1b[0m";
+const DEFAULT_LEVEL = "info";
+/**
+ * Consola-backed {@link LoggerFactory}, or `undefined` when consola is
+ * disabled, fails to import, or throws during setup.
+ *
+ * Builds one `createConsola` instance (badge off, level `verbose`) whose
+ * reporter calls {@link shouldEmit} on `logObj.type` before delegating to
+ * consola's default reporters. In Node, when `globalProcessStdErr` is set,
+ * recognized {@link LogLevel} types are redirected to stderr for that write.
+ * Tags use `withTag` (rendered `[name]`, not merged into args).
+ *
+ * Memoized: the dynamic `consola` import, env checks, and `createConsola`
+ * setup (plus the import/throw fallback) run once; later calls share the one
+ * resolved factory (or the one resolved `undefined`). A rejection is evicted
+ * by {@link memoize} so a later call retries.
+ */
+const createConsolaLoggerFactory = memoize(async () => {
+    const consolaDisabled = toBoolean(globalProcess?.env?.LOG_CONSOLA_DISABLED);
+    if (!consolaDisabled) {
+        try {
+            const { consola, createConsola, LogLevels } = await import(/* @vite-ignore */ "consola");
+            const defaultOptions = consola.options;
+            const createConsolaOptions = {
+                ...consola.options,
+                defaults: { badge: false },
+                // `LOG_LEVEL` is enforced in {@link shouldEmit}; keep consola permissive
+                // so a threshold change after import is not blocked by its own filter.
+                level: LogLevels.verbose,
+                reporters: [
+                    {
+                        log: (logObj, ctx) => {
+                            const logLevel = parseLogLevel(logObj.type);
+                            if (!shouldEmit(logLevel, true))
+                                return;
+                            const ctxStdout = ctx.options.stdout;
+                            try {
+                                if (globalProcessStdErr !== undefined && logLevel !== undefined) {
+                                    ctx.options.stdout = globalProcessStdErr;
+                                }
+                                defaultOptions.reporters.forEach((reporter) => reporter.log(logObj, ctx));
+                            }
+                            finally {
+                                ctx.options.stdout = ctxStdout;
+                            }
+                        },
+                    },
+                ],
+            };
+            const consolaLogger = createConsola(createConsolaOptions);
+            return (name) => {
+                return name ? consolaLogger.withTag(name) : consolaLogger;
+            };
+        }
+        catch (error) {
+            // consola is an OPTIONAL peer - not having it installed is the EXPECTED
+            // path (the module degrades to the console fallback), so this is not an
+            // error. Note it only at debug level, and without a stack trace (the
+            // message, not `console.trace`, so a missing optional dep stays quiet).
+            if (isLevelEnabled("debug")) {
+                console.debug("consola not available; using console fallback:", String(error));
+            }
+        }
+    }
+    return undefined;
+});
+/**
+ * Console {@link LoggerFactory}; always succeeds.
+ *
+ * When `process.stderr` is available, formats each line and writes only to
+ * stderr. Bun `inspect` formats each argument when enabled; otherwise
+ * `util.formatWithOptions` when `node:util` loads, or a `JSON.stringify`
+ * fallback when it does not. When stderr is unavailable, binds
+ * {@link createFormatter} prefixes into global `console.*` calls.
+ */
+async function createConsoleLoggerFactory(globalProcessStdErr) {
+    // Indirect specifier so this browser-safe module doesn't statically pull in
+    // node types: `node:util` is optional (the JSON fallback covers its absence).
+    const nodeUtil = "node:util";
+    const utils = await import(/* @vite-ignore */ nodeUtil).catch(() => undefined);
+    const bunInspect = globalBun !== undefined && !toBoolean(globalBun.env?.LOG_BUN_CONSOLE_DISABLED)
+        ? globalBun.inspect
+        : undefined;
+    const resetColorsPrefix = bunInspect !== undefined;
+    const inspect = (arg, colors) => {
+        if (Array.isArray(arg) || (typeof arg === "object" && arg !== null)) {
+            if (bunInspect !== undefined) {
+                return bunInspect(arg, {
+                    colors: colors,
+                    depth: utils?.inspect?.defaultOptions?.depth ?? undefined,
+                });
+            }
+            else if (utils !== undefined) {
+                return utils.inspect(arg, {
+                    ...utils?.inspect?.defaultOptions,
+                    colors: false,
+                });
+            }
+            else {
+                const seen = new WeakSet();
+                return JSON.stringify(arg, (_, value) => {
+                    if (typeof value === "object" && value !== null) {
+                        if (seen.has(value))
+                            return "[Circular]";
+                        seen.add(value);
+                    }
+                    return value;
+                });
+            }
+        }
+        else {
+            return String(arg);
+        }
+    };
+    const factory = (name) => {
+        const prefixFormatter = createFormatter(name, globalProcessStdErr, resetColorsPrefix);
+        const logger = Object.fromEntries(LOG_LEVELS.map((level) => {
+            const { prefix, colors, resetColors } = prefixFormatter(level);
+            const emitter = (...args) => {
+                if (!shouldEmit(level, true))
+                    return;
+                if (globalProcessStdErr !== undefined) {
+                    const messageParts = prefix ? [prefix] : [];
+                    messageParts.push(...args.map((arg) => inspect(arg, colors)));
+                    if (resetColors)
+                        messageParts.push(LOG_LEVEL_COLOR_RESET);
+                    globalProcessStdErr.write(messageParts.join(" ") + "\n");
+                }
+                else {
+                    let levelFn = console[level];
+                    if (typeof levelFn !== "function") {
+                        levelFn = console.log;
+                    }
+                    if (prefix)
+                        levelFn = levelFn.bind(console, prefix);
+                    levelFn(...args);
+                }
+            };
+            return [level, emitter];
+        }));
+        // consola sugar the console fallback doesn't have natively - route to info.
+        logger.success = logger.info;
+        logger.start = logger.info;
+        return logger;
+    };
+    const defaultFactory = memoize(factory);
+    return (name) => (name ? factory(name) : defaultFactory());
+}
+/**
+ * Module-scoped {@link LoggerFactory}, initialized once via top-level `await`.
+ * Delegates to {@link createConsolaLoggerFactory}, then
+ * {@link createConsoleLoggerFactory}. Each {@link logger} call invokes the
+ * chosen factory with a resolved tag. Env toggles are read only during init.
+ */
+const createLogger = await (async () => {
+    return ((await createConsolaLoggerFactory()) ?? (await createConsoleLoggerFactory(globalProcessStdErr)));
+})();
+/**
+ * Build a line prefix of `LEVEL [name]` on Node/Bun hosts, or `[name]` alone
+ * in browsers (either part omitted when absent). Applies per-level ANSI color
+ * when `streamSupportsColor` is true for the given stderr stream.
+ */
+function createFormatter(name, stream, resetColorsPrefix) {
+    const glob = globalThis;
+    const isBrowser = glob.window !== undefined && glob.document !== undefined;
+    const supportsColor = !isBrowser ? streamSupportsColor(stream) : false;
+    const namePrefix = name ? "[" + name + "]" : undefined;
+    return (level) => {
+        const color = supportsColor && level !== undefined ? LOG_LEVEL_COLORS[level] : undefined;
+        let prefix = [!isBrowser && level ? level.toUpperCase() : undefined, namePrefix]
+            .filter(Boolean)
+            .join(" ");
+        let resetColors = false;
+        if (color) {
+            const applyResetColorsPrefix = resetColorsPrefix || "info" === level;
+            if (!applyResetColorsPrefix)
+                resetColors = true;
+            prefix = applyResetColorsPrefix ? color + prefix + LOG_LEVEL_COLOR_RESET : color + prefix;
+        }
+        return { prefix, colors: color ? true : false, resetColors };
+    };
+}
+/** True when `stream` is a TTY and the terminal is not `dumb`. */
+function streamSupportsColor(stream) {
+    if (globalProcess === undefined || typeof stream !== "object" || stream === null)
+        return false;
+    const { isTTY } = stream;
+    if (isTTY !== true)
+        return false;
+    const term = globalProcess.env?.TERM?.toLowerCase();
+    if ("dumb" == term)
+        return false;
+    return true;
+}
+/** Parse a raw value as {@link LogLevel} (trimmed, case-insensitive). */
+function parseLogLevel(raw) {
+    if (raw === undefined || raw === null) {
+        return undefined;
+    }
+    let text = typeof raw === "string" ? raw : String(raw);
+    for (let i = 0; i < 2; i++) {
+        if (i > 0) {
+            const normalized = text.trim().toLowerCase();
+            if (text === normalized)
+                break;
+            text = normalized;
+        }
+        if (!text) {
+            break;
+        }
+        else if (text in LOG_LEVEL_RANK) {
+            return text;
+        }
+    }
+    return undefined;
+}
+/** Active threshold from `process.env.LOG_LEVEL`, default {@link DEFAULT_LEVEL}. */
+function activeLevel() {
+    return parseLogLevel(globalProcess?.env?.LOG_LEVEL) ?? DEFAULT_LEVEL;
+}
+/**
+ * Whether `raw` meets the current `LOG_LEVEL` threshold.
+ *
+ * Parses `raw` as a {@link LogLevel}; when parsing fails, returns
+ * `defaultResult` if supplied, otherwise `false`. Used for consola reporter
+ * lines where unknown `logObj.type` values should pass through when
+ * `defaultResult` is `true`.
+ */
+function shouldEmit(raw, defaultResult) {
+    const level = parseLogLevel(raw);
+    if (level === undefined)
+        return defaultResult ?? false;
+    return LOG_LEVEL_RANK[level] >= LOG_LEVEL_RANK[activeLevel()];
+}
+/**
+ * Whether a call at `level` would be emitted at the current
+ * `process.env.LOG_LEVEL` threshold. Use before building expensive debug
+ * payloads.
+ *
+ * @example
+ * if (isLevelEnabled("debug")) {
+ *   log.debug("mounts:resolver", { contribution: await heavySnapshot() });
+ * }
+ */
+export function isLevelEnabled(level) {
+    return shouldEmit(level);
+}
+const LOGGER_NAME_REGEX = /^(?:[a-z][a-z0-9+.-]*:\/\/)?.*\/([^/.]+)(?:\.[^/]+)?$/i;
+/**
+ * Derive the tag string from a logger name, plugin, or path. Slash- and
+ * URL-shaped strings use the last path segment (extension stripped); plain
+ * strings pass through unchanged. Empty or missing names -> `undefined`
+ * (untagged sink).
+ */
+function extractLoggerName(loggerName) {
+    if (!loggerName)
+        return undefined;
+    if (typeof loggerName === "string") {
+        const match = loggerName.match(LOGGER_NAME_REGEX);
+        return match?.[1] ?? loggerName;
+    }
+    return extractLoggerName(loggerName.name);
+}
+/**
+ * Build a tagged logger for a plugin or module.
+ *
+ * The tag is `[name]` when `loggerName` is a non-empty string, a
+ * {@link NameLike} with `name`, or a file / URL path (the basename without
+ * extension is used). Consola applies the tag via `withTag` (render-time).
+ * The `console` fallbacks prepend `LEVEL [name]` on Node/Bun hosts or `[name]`
+ * alone in browsers via {@link createFormatter}.
+ *
+ * Calls below `process.env.LOG_LEVEL` are dropped by {@link shouldEmit} before
+ * the sink formats or writes the line.
+ *
+ * @example
+ * import { log } from "@dbx-tools/shared-core";
+ *
+ * const logger = log.logger("genie/chat");
+ * logger.info("starting");
+ * logger.warn("missing optional config", { reason: "no env var" });
+ */
+export function logger(loggerName) {
+    const name = extractLoggerName(loggerName);
+    return createLogger(name);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"log.js","sourceRoot":"","sources":["../../src/log.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Tagged, leveled logging for every runtime - the one logger the whole\n * monorepo shares.\n *\n * {@link logger} resolves a tagged {@link Logger} via a {@link LoggerFactory}\n * chosen once at module load. {@link LogLevel} filtering runs through\n * {@link shouldEmit} in the consola reporter or in per-level wrappers on the\n * `console` fallbacks.\n *\n * Sink selection chains two factories with nullish coalescing (first match\n * wins):\n *\n * 1. {@link createConsolaLoggerFactory} when consola resolves and\n *    `LOG_CONSOLA_DISABLED` is not truthy.\n * 2. {@link createConsoleLoggerFactory} everywhere else.\n *\n * The console fallback writes formatted lines to `process.stderr` when it is\n * available (Bun `inspect` per argument when `LOG_BUN_CONSOLE_DISABLED` is\n * unset, otherwise `node:util` `formatWithOptions`), or delegates to global\n * `console.*` when stderr or `node:util` is unavailable. Browser hosts omit\n * the `LEVEL` text prefix (devtools show severity) and keep only the `[name]`\n * tag.\n *\n * Env toggles (read once at init): `LOG_LEVEL`, `LOG_CONSOLA_DISABLED`,\n * `LOG_BUN_CONSOLE_DISABLED`.\n *\n * Browser-safe: `process` / `Bun` / `window` / `document` are all reached\n * through `globalThis` and guarded, and consola / `node:util` load lazily, so\n * the module works in any runtime. Consola is an optional peer; the module\n * loads fine without it.\n *\n * @module\n */\n\nimport { memoize } from \"./function\";\nimport { type NameLike, toBoolean } from \"./object\";\n\n/** `process`-shaped view off `globalThis`, so no node types are needed. */\ninterface ProcessLike {\n  env?: Record<string, string | undefined>;\n  stderr?: { write?: (chunk: string) => void; isTTY?: unknown };\n}\n\n/** `Bun`-shaped view off `globalThis`, so no `@types/bun` is needed. */\ninterface BunLike {\n  env?: Record<string, string | undefined>;\n  inspect?: (value: unknown, options?: { colors?: boolean; depth?: number }) => string;\n}\n\nconst globalProcess = (globalThis as { process?: ProcessLike }).process;\nconst globalBun = (globalThis as { Bun?: BunLike }).Bun;\n\n/**\n * Node `process.stderr` when writable, else `undefined` (stable for the\n * process). Typed loosely (`any`) because it is handed to consola's\n * `ctx.options.stdout` (a `WriteStream`) and to the console fallback's\n * `.write`, neither of which our structural {@link ProcessLike} shape satisfies\n * nominally.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nconst globalProcessStdErr: any =\n  globalProcess && typeof globalProcess.stderr?.write === \"function\"\n    ? globalProcess.stderr\n    : undefined;\n\nconst LOG_LEVELS = [\"debug\", \"info\", \"warn\", \"error\"] as const;\nconst LOG_LEVEL_RANK = Object.fromEntries(\n  LOG_LEVELS.map((level, index) => [level, index]),\n) as Record<LogLevel, number>;\nconst LOG_LEVEL_COLORS = Object.fromEntries(\n  LOG_LEVELS.map((level) => {\n    let color = \"\\x1b[90m\"; // gray\n    switch (level) {\n      case \"info\":\n        color = \"\\x1b[34m\"; // blue\n        break;\n      case \"warn\":\n        color = \"\\x1b[33m\"; // yellow\n        break;\n      case \"error\":\n        color = \"\\x1b[31m\"; // red\n        break;\n    }\n    return [level, color];\n  }),\n) as Record<LogLevel, string>;\nconst LOG_LEVEL_COLOR_RESET = \"\\x1b[0m\";\nconst DEFAULT_LEVEL: LogLevel = \"info\";\n\n/**\n * Supported severities, lowest to highest: `debug`, `info`, `warn`, `error`.\n * A call below the active threshold is discarded before any string work or\n * sink I/O.\n *\n * The threshold comes from `process.env.LOG_LEVEL` on every call\n * (case-insensitive, default `info` when unset, empty, or unknown) so test\n * runners and embedders can change verbosity after import without restarting\n * the process.\n */\nexport type LogLevel = (typeof LOG_LEVELS)[number];\n\nexport type Logger = {\n  [K in LogLevel]: (...args: any[]) => void;\n} & {\n  /** Success message (consola `success`; falls back to `info`-level output). */\n  success: (...args: any[]) => void;\n  /** Start / in-progress message (consola `start`; falls back to `info`-level output). */\n  start: (...args: any[]) => void;\n};\n\n/** `(name?) => Logger` sink constructor returned by the init-time factory chain. */\ntype LoggerFactory = (name?: string) => Logger;\n\n/**\n * Consola-backed {@link LoggerFactory}, or `undefined` when consola is\n * disabled, fails to import, or throws during setup.\n *\n * Builds one `createConsola` instance (badge off, level `verbose`) whose\n * reporter calls {@link shouldEmit} on `logObj.type` before delegating to\n * consola's default reporters. In Node, when `globalProcessStdErr` is set,\n * recognized {@link LogLevel} types are redirected to stderr for that write.\n * Tags use `withTag` (rendered `[name]`, not merged into args).\n *\n * Memoized: the dynamic `consola` import, env checks, and `createConsola`\n * setup (plus the import/throw fallback) run once; later calls share the one\n * resolved factory (or the one resolved `undefined`). A rejection is evicted\n * by {@link memoize} so a later call retries.\n */\nconst createConsolaLoggerFactory = memoize(async (): Promise<LoggerFactory | undefined> => {\n  const consolaDisabled = toBoolean(globalProcess?.env?.LOG_CONSOLA_DISABLED);\n  if (!consolaDisabled) {\n    try {\n      const { consola, createConsola, LogLevels } = await import(/* @vite-ignore */ \"consola\");\n      const defaultOptions = consola.options;\n      const createConsolaOptions = {\n        ...consola.options,\n        defaults: { badge: false },\n        // `LOG_LEVEL` is enforced in {@link shouldEmit}; keep consola permissive\n        // so a threshold change after import is not blocked by its own filter.\n        level: LogLevels.verbose,\n        reporters: [\n          {\n            log: (logObj, ctx) => {\n              const logLevel = parseLogLevel(logObj.type);\n              if (!shouldEmit(logLevel, true)) return;\n              const ctxStdout = ctx.options.stdout;\n              try {\n                if (globalProcessStdErr !== undefined && logLevel !== undefined) {\n                  ctx.options.stdout = globalProcessStdErr;\n                }\n                defaultOptions.reporters.forEach((reporter) => reporter.log(logObj, ctx));\n              } finally {\n                ctx.options.stdout = ctxStdout;\n              }\n            },\n          },\n        ],\n      } as NonNullable<Parameters<typeof createConsola>[0]>;\n      const consolaLogger = createConsola(createConsolaOptions);\n      return (name?: string) => {\n        return name ? consolaLogger.withTag(name) : consolaLogger;\n      };\n    } catch (error) {\n      // consola is an OPTIONAL peer - not having it installed is the EXPECTED\n      // path (the module degrades to the console fallback), so this is not an\n      // error. Note it only at debug level, and without a stack trace (the\n      // message, not `console.trace`, so a missing optional dep stays quiet).\n      if (isLevelEnabled(\"debug\")) {\n        console.debug(\"consola not available; using console fallback:\", String(error));\n      }\n    }\n  }\n  return undefined;\n});\n\n/**\n * Console {@link LoggerFactory}; always succeeds.\n *\n * When `process.stderr` is available, formats each line and writes only to\n * stderr. Bun `inspect` formats each argument when enabled; otherwise\n * `util.formatWithOptions` when `node:util` loads, or a `JSON.stringify`\n * fallback when it does not. When stderr is unavailable, binds\n * {@link createFormatter} prefixes into global `console.*` calls.\n */\nasync function createConsoleLoggerFactory(globalProcessStdErr: any): Promise<LoggerFactory> {\n  // Indirect specifier so this browser-safe module doesn't statically pull in\n  // node types: `node:util` is optional (the JSON fallback covers its absence).\n  const nodeUtil = \"node:util\";\n  const utils: { inspect?: any } | undefined = await import(/* @vite-ignore */ nodeUtil).catch(\n    () => undefined,\n  );\n  const bunInspect =\n    globalBun !== undefined && !toBoolean(globalBun.env?.LOG_BUN_CONSOLE_DISABLED)\n      ? globalBun.inspect\n      : undefined;\n  const resetColorsPrefix = bunInspect !== undefined;\n\n  const inspect = (arg: any, colors?: boolean) => {\n    if (Array.isArray(arg) || (typeof arg === \"object\" && arg !== null)) {\n      if (bunInspect !== undefined) {\n        return bunInspect(arg, {\n          colors: colors,\n          depth: utils?.inspect?.defaultOptions?.depth ?? undefined,\n        });\n      } else if (utils !== undefined) {\n        return utils.inspect(arg, {\n          ...utils?.inspect?.defaultOptions,\n          colors: false,\n        });\n      } else {\n        const seen = new WeakSet();\n        return JSON.stringify(arg, (_, value) => {\n          if (typeof value === \"object\" && value !== null) {\n            if (seen.has(value)) return \"[Circular]\";\n            seen.add(value);\n          }\n          return value;\n        });\n      }\n    } else {\n      return String(arg);\n    }\n  };\n\n  const factory = (name?: string) => {\n    const prefixFormatter = createFormatter(name, globalProcessStdErr, resetColorsPrefix);\n    const logger = Object.fromEntries(\n      LOG_LEVELS.map((level) => {\n        const { prefix, colors, resetColors } = prefixFormatter(level);\n        const emitter = (...args: any[]) => {\n          if (!shouldEmit(level, true)) return;\n          if (globalProcessStdErr !== undefined) {\n            const messageParts = prefix ? [prefix] : [];\n            messageParts.push(...args.map((arg) => inspect(arg, colors)));\n            if (resetColors) messageParts.push(LOG_LEVEL_COLOR_RESET);\n            globalProcessStdErr.write(messageParts.join(\" \") + \"\\n\");\n          } else {\n            let levelFn = console[level];\n            if (typeof levelFn !== \"function\") {\n              levelFn = console.log;\n            }\n            if (prefix) levelFn = levelFn.bind(console, prefix);\n            levelFn(...args);\n          }\n        };\n        return [level, emitter];\n      }),\n    ) as Logger;\n    // consola sugar the console fallback doesn't have natively - route to info.\n    logger.success = logger.info;\n    logger.start = logger.info;\n    return logger;\n  };\n  const defaultFactory = memoize(factory);\n  return (name?: string) => (name ? factory(name) : defaultFactory());\n}\n\n/**\n * Module-scoped {@link LoggerFactory}, initialized once via top-level `await`.\n * Delegates to {@link createConsolaLoggerFactory}, then\n * {@link createConsoleLoggerFactory}. Each {@link logger} call invokes the\n * chosen factory with a resolved tag. Env toggles are read only during init.\n */\nconst createLogger: LoggerFactory = await (async () => {\n  return (\n    (await createConsolaLoggerFactory()) ?? (await createConsoleLoggerFactory(globalProcessStdErr))\n  );\n})();\n\n/**\n * Build a line prefix of `LEVEL [name]` on Node/Bun hosts, or `[name]` alone\n * in browsers (either part omitted when absent). Applies per-level ANSI color\n * when `streamSupportsColor` is true for the given stderr stream.\n */\nfunction createFormatter(\n  name: any,\n  stream: any,\n  resetColorsPrefix?: boolean,\n): (level?: LogLevel) => { prefix: string; colors: boolean; resetColors: boolean } {\n  const glob = globalThis as { window?: unknown; document?: unknown };\n  const isBrowser = glob.window !== undefined && glob.document !== undefined;\n  const supportsColor = !isBrowser ? streamSupportsColor(stream) : false;\n  const namePrefix = name ? \"[\" + name + \"]\" : undefined;\n  return (level?: LogLevel) => {\n    const color = supportsColor && level !== undefined ? LOG_LEVEL_COLORS[level] : undefined;\n    let prefix = [!isBrowser && level ? level.toUpperCase() : undefined, namePrefix]\n      .filter(Boolean)\n      .join(\" \");\n    let resetColors = false;\n    if (color) {\n      const applyResetColorsPrefix = resetColorsPrefix || \"info\" === level;\n      if (!applyResetColorsPrefix) resetColors = true;\n      prefix = applyResetColorsPrefix ? color + prefix + LOG_LEVEL_COLOR_RESET : color + prefix;\n    }\n    return { prefix, colors: color ? true : false, resetColors };\n  };\n}\n\n/** True when `stream` is a TTY and the terminal is not `dumb`. */\nfunction streamSupportsColor(stream?: unknown): boolean {\n  if (globalProcess === undefined || typeof stream !== \"object\" || stream === null) return false;\n  const { isTTY } = stream as { isTTY?: unknown };\n  if (isTTY !== true) return false;\n  const term = globalProcess.env?.TERM?.toLowerCase();\n  if (\"dumb\" == term) return false;\n  return true;\n}\n\n/** Parse a raw value as {@link LogLevel} (trimmed, case-insensitive). */\nfunction parseLogLevel(raw: unknown): LogLevel | undefined {\n  if (raw === undefined || raw === null) {\n    return undefined;\n  }\n  let text = typeof raw === \"string\" ? raw : String(raw);\n  for (let i = 0; i < 2; i++) {\n    if (i > 0) {\n      const normalized = text.trim().toLowerCase();\n      if (text === normalized) break;\n      text = normalized;\n    }\n    if (!text) {\n      break;\n    } else if (text in LOG_LEVEL_RANK) {\n      return text as LogLevel;\n    }\n  }\n  return undefined;\n}\n\n/** Active threshold from `process.env.LOG_LEVEL`, default {@link DEFAULT_LEVEL}. */\nfunction activeLevel(): LogLevel {\n  return parseLogLevel(globalProcess?.env?.LOG_LEVEL) ?? DEFAULT_LEVEL;\n}\n\n/**\n * Whether `raw` meets the current `LOG_LEVEL` threshold.\n *\n * Parses `raw` as a {@link LogLevel}; when parsing fails, returns\n * `defaultResult` if supplied, otherwise `false`. Used for consola reporter\n * lines where unknown `logObj.type` values should pass through when\n * `defaultResult` is `true`.\n */\nfunction shouldEmit(raw: unknown, defaultResult?: boolean): boolean {\n  const level = parseLogLevel(raw);\n  if (level === undefined) return defaultResult ?? false;\n  return LOG_LEVEL_RANK[level] >= LOG_LEVEL_RANK[activeLevel()];\n}\n\n/**\n * Whether a call at `level` would be emitted at the current\n * `process.env.LOG_LEVEL` threshold. Use before building expensive debug\n * payloads.\n *\n * @example\n * if (isLevelEnabled(\"debug\")) {\n *   log.debug(\"mounts:resolver\", { contribution: await heavySnapshot() });\n * }\n */\nexport function isLevelEnabled(level: LogLevel): boolean {\n  return shouldEmit(level);\n}\n\nconst LOGGER_NAME_REGEX = /^(?:[a-z][a-z0-9+.-]*:\\/\\/)?.*\\/([^/.]+)(?:\\.[^/]+)?$/i;\n\n/**\n * Derive the tag string from a logger name, plugin, or path. Slash- and\n * URL-shaped strings use the last path segment (extension stripped); plain\n * strings pass through unchanged. Empty or missing names -> `undefined`\n * (untagged sink).\n */\nfunction extractLoggerName(loggerName: NameLike | string | undefined): string | undefined {\n  if (!loggerName) return undefined;\n  if (typeof loggerName === \"string\") {\n    const match = loggerName.match(LOGGER_NAME_REGEX);\n    return match?.[1] ?? loggerName;\n  }\n  return extractLoggerName(loggerName.name);\n}\n\n/**\n * Build a tagged logger for a plugin or module.\n *\n * The tag is `[name]` when `loggerName` is a non-empty string, a\n * {@link NameLike} with `name`, or a file / URL path (the basename without\n * extension is used). Consola applies the tag via `withTag` (render-time).\n * The `console` fallbacks prepend `LEVEL [name]` on Node/Bun hosts or `[name]`\n * alone in browsers via {@link createFormatter}.\n *\n * Calls below `process.env.LOG_LEVEL` are dropped by {@link shouldEmit} before\n * the sink formats or writes the line.\n *\n * @example\n * import { log } from \"@dbx-tools/shared-core\";\n *\n * const logger = log.logger(\"genie/chat\");\n * logger.info(\"starting\");\n * logger.warn(\"missing optional config\", { reason: \"no env var\" });\n */\nexport function logger(loggerName: NameLike | string | undefined): Logger {\n  const name = extractLoggerName(loggerName);\n  return createLogger(name);\n}\n"]}