aws-cdk 2.175.0 → 2.176.0

package/lib/logging.js

@@ -1,67 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.highlight = exports.success = exports.trace = exports.debug = exports.data = exports.print = exports.info = exports.warning = exports.error = exports.LogLevel = void 0;
-exports.setLogLevel = setLogLevel;
+exports.highlight = exports.success = exports.trace = exports.debug = exports.data = exports.info = exports.warning = exports.error = void 0;
+exports.setIoMessageThreshold = setIoMessageThreshold;
 exports.setCI = setCI;
 exports.withCorkedLogging = withCorkedLogging;
-exports.log = log;
-exports.prefix = prefix;
 const util = require("util");
 const chalk = require("chalk");
-/**
- * Available log levels in order of increasing verbosity.
- */
-var LogLevel;
-(function (LogLevel) {
-    LogLevel["ERROR"] = "error";
-    LogLevel["WARN"] = "warn";
-    LogLevel["INFO"] = "info";
-    LogLevel["DEBUG"] = "debug";
-    LogLevel["TRACE"] = "trace";
-})(LogLevel || (exports.LogLevel = LogLevel = {}));
-const { stdout, stderr } = process;
+const cli_io_host_1 = require("./toolkit/cli-io-host");
 // Corking mechanism
 let CORK_COUNTER = 0;
 const logBuffer = [];
-// Style mappings
-const styleMap = {
-    [LogLevel.ERROR]: chalk.red,
-    [LogLevel.WARN]: chalk.yellow,
-    [LogLevel.INFO]: chalk.white,
-    [LogLevel.DEBUG]: chalk.gray,
-    [LogLevel.TRACE]: chalk.gray,
-};
-// Stream selection
-let CI = false;
-/**
- * Determines which output stream to use based on log level and configuration.
- * @param level - The log level to determine stream for
- * @param forceStdout - Whether to force stdout regardless of level
- * @returns The appropriate Writable stream
- */
-const getStream = (level, forceStdout) => {
-    // Special case - data() calls should always go to stdout
-    if (forceStdout) {
-        return stdout;
-    }
-    if (level === LogLevel.ERROR)
-        return stderr;
-    return CI ? stdout : stderr;
-};
 const levelPriority = {
-    [LogLevel.ERROR]: 0,
-    [LogLevel.WARN]: 1,
-    [LogLevel.INFO]: 2,
-    [LogLevel.DEBUG]: 3,
-    [LogLevel.TRACE]: 4,
+    error: 0,
+    warn: 1,
+    info: 2,
+    debug: 3,
+    trace: 4,
 };
-let currentLogLevel = LogLevel.INFO;
+let currentIoMessageThreshold = 'info';
 /**
- * Sets the current log level. Messages with a lower priority level will be filtered out.
- * @param level - The new log level to set
+ * Sets the current threshold. Messages with a lower priority level will be ignored.
+ * @param level The new log level threshold
  */
-function setLogLevel(level) {
-    currentLogLevel = level;
+function setIoMessageThreshold(level) {
+    currentIoMessageThreshold = level;
 }
 /**
  * Sets whether the logger is running in CI mode.
@@ -69,20 +31,11 @@ function setLogLevel(level) {
  * @param newCI - Whether CI mode should be enabled
  */
 function setCI(newCI) {
-    CI = newCI;
-}
-/**
- * Formats a date object into a timestamp string (HH:MM:SS).
- * @param d - Date object to format
- * @returns Formatted time string
- */
-function formatTime(d) {
-    const pad = (n) => n.toString().padStart(2, '0');
-    return `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+    cli_io_host_1.CliIoHost.ci = newCI;
 }
 /**
  * Executes a block of code with corked logging. All log messages during execution
- * are buffered and only written after the block completes.
+ * are buffered and only written when all nested cork blocks complete (when CORK_COUNTER reaches 0).
  * @param block - Async function to execute with corked logging
  * @returns Promise that resolves with the block's return value
  */
@@ -94,93 +47,183 @@ async function withCorkedLogging(block) {
     finally {
         CORK_COUNTER--;
         if (CORK_COUNTER === 0) {
-            logBuffer.forEach(([stream, str]) => stream.write(str + '\n'));
+            // Process each buffered message through notify
+            for (const ioMessage of logBuffer) {
+                void cli_io_host_1.CliIoHost.getIoHost().notify(ioMessage);
+            }
             logBuffer.splice(0);
         }
     }
 }
-function log(levelOrEntry, fmt, ...args) {
-    // Normalize input
-    const entry = typeof levelOrEntry === 'string'
-        ? { level: levelOrEntry, message: util.format(fmt, ...args) }
-        : levelOrEntry;
-    // Check if we should log this level
-    if (levelPriority[entry.level] > levelPriority[currentLogLevel]) {
+/**
+ * Internal core logging function that writes messages through the CLI IO host.
+ * @param options Configuration options for the log message. See  {@link LogOptions}
+ */
+function log(options) {
+    if (levelPriority[options.level] > levelPriority[currentIoMessageThreshold]) {
         return;
     }
-    // Format the message
-    let finalMessage = entry.message;
-    // Add timestamp first if requested
-    if (entry.timestamp) {
-        finalMessage = `[${formatTime(new Date())}] ${finalMessage}`;
-    }
-    // Add prefix AFTER timestamp
-    if (entry.prefix) {
-        finalMessage = `${entry.prefix} ${finalMessage}`;
-    }
-    // Apply custom style if provided, otherwise use level-based style
-    const style = entry.style || styleMap[entry.level];
-    finalMessage = style(finalMessage);
-    // Get appropriate stream - pass through forceStdout flag
-    const stream = getStream(entry.level, entry.forceStdout);
-    // Handle corking
+    const ioMessage = {
+        level: options.level,
+        message: options.message,
+        forceStdout: options.forceStdout,
+        time: new Date(),
+        action: cli_io_host_1.CliIoHost.currentAction ?? 'none',
+        code: options.code,
+    };
     if (CORK_COUNTER > 0) {
-        logBuffer.push([stream, finalMessage]);
+        logBuffer.push(ioMessage);
         return;
     }
-    // Write to stream
-    stream.write(finalMessage + '\n');
+    void cli_io_host_1.CliIoHost.getIoHost().notify(ioMessage);
+}
+/**
+ * Internal helper that processes log inputs into a consistent format.
+ * Handles string interpolation, format strings, and object parameter styles.
+ * Applies optional styling and prepares the final message for logging.
+ */
+function formatMessageAndLog(level, forceStdout, input, style, ...args) {
+    // Extract message and code from input, using new default code format
+    const { message, code = getDefaultCode(level) } = typeof input === 'object' ? input : { message: input };
+    // Format message if args are provided
+    const formattedMessage = args.length > 0
+        ? util.format(message, ...args)
+        : message;
+    // Apply style if provided
+    const finalMessage = style ? style(formattedMessage) : formattedMessage;
+    log({
+        level,
+        message: finalMessage,
+        code,
+        forceStdout,
+    });
+}
+function getDefaultCode(level, category = 'TOOLKIT') {
+    const levelIndicator = level === 'error' ? 'E' :
+        level === 'warn' ? 'W' :
+            'I';
+    return `CDK_${category}_${levelIndicator}0000`;
 }
-// Convenience logging methods
-const error = (fmt, ...args) => log(LogLevel.ERROR, fmt, ...args);
+// Exported logging functions. If any additional logging functionality is required, it should be added as
+// a new logging function here.
+/**
+ * Logs an error level message.
+ *
+ * Can be used in multiple ways:
+ * ```ts
+ * error(`operation failed: ${e}`) // infers default error code `CDK_TOOLKIT_E000`
+ * error('operation failed: %s', e) // infers default error code `CDK_TOOLKIT_E000`
+ * error({ message: 'operation failed', code: 'CDK_SDK_E001' }) // specifies error code `CDK_SDK_E001`
+ * error({ message: 'operation failed: %s', code: 'CDK_SDK_E001' }, e) // specifies error code `CDK_SDK_E001`
+ * ```
+ */
+const error = (input, ...args) => {
+    return formatMessageAndLog('error', false, input, undefined, ...args);
+};
 exports.error = error;
-const warning = (fmt, ...args) => log(LogLevel.WARN, fmt, ...args);
+/**
+ * Logs an warning level message.
+ *
+ * Can be used in multiple ways:
+ * ```ts
+ * warning(`deprected feature: ${message}`) // infers default warning code `CDK_TOOLKIT_W000`
+ * warning('deprected feature: %s', message) // infers default warning code `CDK_TOOLKIT_W000`
+ * warning({ message: 'deprected feature', code: 'CDK_SDK_W001' }) // specifies warning code `CDK_SDK_W001`
+ * warning({ message: 'deprected feature: %s', code: 'CDK_SDK_W001' }, message) // specifies warning code `CDK_SDK_W001`
+ * ```
+ */
+const warning = (input, ...args) => {
+    return formatMessageAndLog('warn', false, input, undefined, ...args);
+};
 exports.warning = warning;
-const info = (fmt, ...args) => log(LogLevel.INFO, fmt, ...args);
+/**
+ * Logs an info level message.
+ *
+ * Can be used in multiple ways:
+ * ```ts
+ * info(`processing: ${message}`) // infers default info code `CDK_TOOLKIT_I000`
+ * info('processing: %s', message) // infers default info code `CDK_TOOLKIT_I000`
+ * info({ message: 'processing', code: 'CDK_TOOLKIT_I001' }) // specifies info code `CDK_TOOLKIT_I001`
+ * info({ message: 'processing: %s', code: 'CDK_TOOLKIT_I001' }, message) // specifies info code `CDK_TOOLKIT_I001`
+ * ```
+ */
+const info = (input, ...args) => {
+    return formatMessageAndLog('info', false, input, undefined, ...args);
+};
 exports.info = info;
-const print = (fmt, ...args) => log(LogLevel.INFO, fmt, ...args);
-exports.print = print;
-const data = (fmt, ...args) => log({
-    level: LogLevel.INFO,
-    message: util.format(fmt, ...args),
-    forceStdout: true,
-});
+/**
+ * Logs an info level message to stdout.
+ *
+ * Can be used in multiple ways:
+ * ```ts
+ * data(`${JSON.stringify(stats)}`) // infers default info code `CDK_TOOLKIT_I000`
+ * data('{"count": %d}', count) // infers default info code `CDK_TOOLKIT_I000`
+ * data({ message: 'stats: %j', code: 'CDK_DATA_I001' }) // specifies info code `CDK_DATA_I001`
+ * data({ message: 'stats: %j', code: 'CDK_DATA_I001' }, stats) // specifies info code `CDK_DATA_I001`
+ * ```
+ */
+const data = (input, ...args) => {
+    return formatMessageAndLog('info', true, input, undefined, ...args);
+};
 exports.data = data;
-const debug = (fmt, ...args) => log({
-    level: LogLevel.DEBUG,
-    message: util.format(fmt, ...args),
-    timestamp: true,
-});
+/**
+ * Logs a debug level message.
+ *
+ * Can be used in multiple ways:
+ * ```ts
+ * debug(`state: ${JSON.stringify(state)}`) // infers default info code `CDK_TOOLKIT_I000`
+ * debug('cache hit ratio: %d%%', ratio) // infers default info code `CDK_TOOLKIT_I000`
+ * debug({ message: 'state update', code: 'CDK_TOOLKIT_I001' }) // specifies info code `CDK_TOOLKIT_I001`
+ * debug({ message: 'ratio: %d%%', code: 'CDK_TOOLKIT_I001' }, ratio) // specifies info code `CDK_TOOLKIT_I001`
+ * ```
+ */
+const debug = (input, ...args) => {
+    return formatMessageAndLog('debug', false, input, undefined, ...args);
+};
 exports.debug = debug;
-const trace = (fmt, ...args) => log({
-    level: LogLevel.TRACE,
-    message: util.format(fmt, ...args),
-    timestamp: true,
-});
+/**
+ * Logs a trace level message.
+ *
+ * Can be used in multiple ways:
+ * ```ts
+ * trace(`entered ${name} with ${args}`) // infers default info code `CDK_TOOLKIT_I000`
+ * trace('method: %s, args: %j', name, args) // infers default info code `CDK_TOOLKIT_I000`
+ * trace({ message: 'entered', code: 'CDK_TOOLKIT_I001' }) // specifies info code `CDK_TOOLKIT_I001`
+ * trace({ message: 'method: %s', code: 'CDK_TOOLKIT_I001' }, name) // specifies info code `CDK_TOOLKIT_I001`
+ * ```
+ */
+const trace = (input, ...args) => {
+    return formatMessageAndLog('trace', false, input, undefined, ...args);
+};
 exports.trace = trace;
-const success = (fmt, ...args) => log({
-    level: LogLevel.INFO,
-    message: util.format(fmt, ...args),
-    style: chalk.green,
-});
+/**
+ * Logs an info level success message in green text.
+ *
+ * Can be used in multiple ways:
+ * ```ts
+ * success(`deployment completed: ${name}`) // infers default info code `CDK_TOOLKIT_I000`
+ * success('processed %d items', count) // infers default info code `CDK_TOOLKIT_I000`
+ * success({ message: 'completed', code: 'CDK_TOOLKIT_I001' }) // specifies info code `CDK_TOOLKIT_I001`
+ * success({ message: 'items: %d', code: 'CDK_TOOLKIT_I001' }, count) // specifies info code `CDK_TOOLKIT_I001`
+ * ```
+ */
+const success = (input, ...args) => {
+    return formatMessageAndLog('info', false, input, chalk.green, ...args);
+};
 exports.success = success;
-const highlight = (fmt, ...args) => log({
-    level: LogLevel.INFO,
-    message: util.format(fmt, ...args),
-    style: chalk.bold,
-});
-exports.highlight = highlight;
 /**
- * Creates a logging function that prepends a prefix to all messages.
- * @param prefixString - String to prepend to all messages
- * @param level - Log level to use (defaults to INFO)
- * @returns Logging function that accepts format string and arguments
+ * Logs an info level message in bold text.
+ *
+ * Can be used in multiple ways:
+ * ```ts
+ * highlight(`important: ${msg}`) // infers default info code `CDK_TOOLKIT_I000`
+ * highlight('attention required: %s', reason) // infers default info code `CDK_TOOLKIT_I000`
+ * highlight({ message: 'notice', code: 'CDK_TOOLKIT_I001' }) // specifies info code `CDK_TOOLKIT_I001`
+ * highlight({ message: 'notice: %s', code: 'CDK_TOOLKIT_I001' }, msg) // specifies info code `CDK_TOOLKIT_I001`
+ * ```
  */
-function prefix(prefixString, level = LogLevel.INFO) {
-    return (fmt, ...args) => log({
-        level,
-        message: util.format(fmt, ...args),
-        prefix: prefixString,
-    });
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"logging.js","sourceRoot":"","sources":["logging.ts"],"names":[],"mappings":"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","sourcesContent":["import { Writable } from 'stream';\nimport * as util from 'util';\nimport * as chalk from 'chalk';\n\n/**\n * Available log levels in order of increasing verbosity.\n */\nexport enum LogLevel {\n  ERROR = 'error',\n  WARN = 'warn',\n  INFO = 'info',\n  DEBUG = 'debug',\n  TRACE = 'trace',\n}\n\n/**\n * Configuration options for a log entry.\n */\nexport interface LogEntry {\n  level: LogLevel;\n  message: string;\n  timestamp?: boolean;\n  prefix?: string;\n  style?: ((str: string) => string);\n  forceStdout?: boolean;\n}\n\nconst { stdout, stderr } = process;\n\n// Corking mechanism\nlet CORK_COUNTER = 0;\nconst logBuffer: [Writable, string][] = [];\n\n// Style mappings\nconst styleMap: Record<LogLevel, (str: string) => string> = {\n  [LogLevel.ERROR]: chalk.red,\n  [LogLevel.WARN]: chalk.yellow,\n  [LogLevel.INFO]: chalk.white,\n  [LogLevel.DEBUG]: chalk.gray,\n  [LogLevel.TRACE]: chalk.gray,\n};\n\n// Stream selection\nlet CI = false;\n\n/**\n * Determines which output stream to use based on log level and configuration.\n * @param level - The log level to determine stream for\n * @param forceStdout - Whether to force stdout regardless of level\n * @returns The appropriate Writable stream\n */\nconst getStream = (level: LogLevel, forceStdout?: boolean): Writable => {\n  // Special case - data() calls should always go to stdout\n  if (forceStdout) {\n    return stdout;\n  }\n  if (level === LogLevel.ERROR) return stderr;\n  return CI ? stdout : stderr;\n};\n\nconst levelPriority: Record<LogLevel, number> = {\n  [LogLevel.ERROR]: 0,\n  [LogLevel.WARN]: 1,\n  [LogLevel.INFO]: 2,\n  [LogLevel.DEBUG]: 3,\n  [LogLevel.TRACE]: 4,\n};\n\nlet currentLogLevel: LogLevel = LogLevel.INFO;\n\n/**\n * Sets the current log level. Messages with a lower priority level will be filtered out.\n * @param level - The new log level to set\n */\nexport function setLogLevel(level: LogLevel) {\n  currentLogLevel = level;\n}\n\n/**\n * Sets whether the logger is running in CI mode.\n * In CI mode, all non-error output goes to stdout instead of stderr.\n * @param newCI - Whether CI mode should be enabled\n */\nexport function setCI(newCI: boolean) {\n  CI = newCI;\n}\n\n/**\n * Formats a date object into a timestamp string (HH:MM:SS).\n * @param d - Date object to format\n * @returns Formatted time string\n */\nfunction formatTime(d: Date): string {\n  const pad = (n: number): string => n.toString().padStart(2, '0');\n  return `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;\n}\n\n/**\n * Executes a block of code with corked logging. All log messages during execution\n * are buffered and only written after the block completes.\n * @param block - Async function to execute with corked logging\n * @returns Promise that resolves with the block's return value\n */\nexport async function withCorkedLogging<T>(block: () => Promise<T>): Promise<T> {\n  CORK_COUNTER++;\n  try {\n    return await block();\n  } finally {\n    CORK_COUNTER--;\n    if (CORK_COUNTER === 0) {\n      logBuffer.forEach(([stream, str]) => stream.write(str + '\\n'));\n      logBuffer.splice(0);\n    }\n  }\n}\n\n/**\n * Core logging function that handles all log output.\n * @param entry - LogEntry object or log level\n * @param fmt - Format string (when using with log level)\n * @param args - Format arguments (when using with log level)\n */\nexport function log(entry: LogEntry): void;\nexport function log(level: LogLevel, fmt: string, ...args: unknown[]): void;\nexport function log(levelOrEntry: LogLevel | LogEntry, fmt?: string, ...args: unknown[]): void {\n  // Normalize input\n  const entry: LogEntry = typeof levelOrEntry === 'string'\n    ? { level: levelOrEntry as LogLevel, message: util.format(fmt!, ...args) }\n    : levelOrEntry;\n\n  // Check if we should log this level\n  if (levelPriority[entry.level] > levelPriority[currentLogLevel]) {\n    return;\n  }\n\n  // Format the message\n  let finalMessage = entry.message;\n\n  // Add timestamp first if requested\n  if (entry.timestamp) {\n    finalMessage = `[${formatTime(new Date())}] ${finalMessage}`;\n  }\n\n  // Add prefix AFTER timestamp\n  if (entry.prefix) {\n    finalMessage = `${entry.prefix} ${finalMessage}`;\n  }\n\n  // Apply custom style if provided, otherwise use level-based style\n  const style = entry.style || styleMap[entry.level];\n  finalMessage = style(finalMessage);\n\n  // Get appropriate stream - pass through forceStdout flag\n  const stream = getStream(entry.level, entry.forceStdout);\n\n  // Handle corking\n  if (CORK_COUNTER > 0) {\n    logBuffer.push([stream, finalMessage]);\n    return;\n  }\n\n  // Write to stream\n  stream.write(finalMessage + '\\n');\n}\n\n// Convenience logging methods\nexport const error = (fmt: string, ...args: unknown[]) => log(LogLevel.ERROR, fmt, ...args);\nexport const warning = (fmt: string, ...args: unknown[]) => log(LogLevel.WARN, fmt, ...args);\nexport const info = (fmt: string, ...args: unknown[]) => log(LogLevel.INFO, fmt, ...args);\nexport const print = (fmt: string, ...args: unknown[]) => log(LogLevel.INFO, fmt, ...args);\nexport const data = (fmt: string, ...args: unknown[]) => log({\n  level: LogLevel.INFO,\n  message: util.format(fmt, ...args),\n  forceStdout: true,\n});\nexport const debug = (fmt: string, ...args: unknown[]) => log({\n  level: LogLevel.DEBUG,\n  message: util.format(fmt, ...args),\n  timestamp: true,\n});\n\nexport const trace = (fmt: string, ...args: unknown[]) => log({\n  level: LogLevel.TRACE,\n  message: util.format(fmt, ...args),\n  timestamp: true,\n});\n\nexport const success = (fmt: string, ...args: unknown[]) => log({\n  level: LogLevel.INFO,\n  message: util.format(fmt, ...args),\n  style: chalk.green,\n});\n\nexport const highlight = (fmt: string, ...args: unknown[]) => log({\n  level: LogLevel.INFO,\n  message: util.format(fmt, ...args),\n  style: chalk.bold,\n});\n\n/**\n * Creates a logging function that prepends a prefix to all messages.\n * @param prefixString - String to prepend to all messages\n * @param level - Log level to use (defaults to INFO)\n * @returns Logging function that accepts format string and arguments\n */\nexport function prefix(prefixString: string, level: LogLevel = LogLevel.INFO): (fmt: string, ...args: unknown[]) => void {\n  return (fmt: string, ...args: unknown[]) => log({\n    level,\n    message: util.format(fmt, ...args),\n    prefix: prefixString,\n  });\n}\n"]}
+const highlight = (input, ...args) => {
+    return formatMessageAndLog('info', false, input, chalk.bold, ...args);
+};
+exports.highlight = highlight;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"logging.js","sourceRoot":"","sources":["logging.ts"],"names":[],"mappings":"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","sourcesContent":["import * as util from 'util';\nimport * as chalk from 'chalk';\nimport { IoMessageLevel, IoMessage, CliIoHost, IoMessageSpecificCode, IoMessageCode, IoMessageCodeCategory, IoCodeLevel } from './toolkit/cli-io-host';\n\n// Corking mechanism\nlet CORK_COUNTER = 0;\nconst logBuffer: IoMessage[] = [];\n\nconst levelPriority: Record<IoMessageLevel, number> = {\n  error: 0,\n  warn: 1,\n  info: 2,\n  debug: 3,\n  trace: 4,\n};\n\nlet currentIoMessageThreshold: IoMessageLevel = 'info';\n\n/**\n * Sets the current threshold. Messages with a lower priority level will be ignored.\n * @param level The new log level threshold\n */\nexport function setIoMessageThreshold(level: IoMessageLevel) {\n  currentIoMessageThreshold = level;\n}\n\n/**\n * Sets whether the logger is running in CI mode.\n * In CI mode, all non-error output goes to stdout instead of stderr.\n * @param newCI - Whether CI mode should be enabled\n */\nexport function setCI(newCI: boolean) {\n  CliIoHost.ci = newCI;\n}\n\n/**\n * Executes a block of code with corked logging. All log messages during execution\n * are buffered and only written when all nested cork blocks complete (when CORK_COUNTER reaches 0).\n * @param block - Async function to execute with corked logging\n * @returns Promise that resolves with the block's return value\n */\nexport async function withCorkedLogging<T>(block: () => Promise<T>): Promise<T> {\n  CORK_COUNTER++;\n  try {\n    return await block();\n  } finally {\n    CORK_COUNTER--;\n    if (CORK_COUNTER === 0) {\n      // Process each buffered message through notify\n      for (const ioMessage of logBuffer) {\n        void CliIoHost.getIoHost().notify(ioMessage);\n      }\n      logBuffer.splice(0);\n    }\n  }\n}\n\ninterface LogOptions {\n  /**\n   * The log level to use\n   */\n  readonly level: IoMessageLevel;\n  /**\n   * The message to log\n   */\n  readonly message: string;\n  /**\n   * Whether to force stdout\n   * @default false\n   */\n  readonly forceStdout?: boolean;\n  /**\n   * Message code of the format [CATEGORY]_[NUMBER_CODE]\n   * @pattern [A-Z]+_[0-2][0-9]{3}\n   * @default TOOLKIT_[0/1/2]000\n   */\n  readonly code: IoMessageCode;\n}\n\n/**\n * Internal core logging function that writes messages through the CLI IO host.\n * @param options Configuration options for the log message. See  {@link LogOptions}\n */\nfunction log(options: LogOptions) {\n  if (levelPriority[options.level] > levelPriority[currentIoMessageThreshold]) {\n    return;\n  }\n\n  const ioMessage: IoMessage = {\n    level: options.level,\n    message: options.message,\n    forceStdout: options.forceStdout,\n    time: new Date(),\n    action: CliIoHost.currentAction ?? 'none',\n    code: options.code,\n  };\n\n  if (CORK_COUNTER > 0) {\n    logBuffer.push(ioMessage);\n    return;\n  }\n\n  void CliIoHost.getIoHost().notify(ioMessage);\n}\n\n/**\n * Internal helper that processes log inputs into a consistent format.\n * Handles string interpolation, format strings, and object parameter styles.\n * Applies optional styling and prepares the final message for logging.\n */\nfunction formatMessageAndLog(\n  level: IoMessageLevel,\n  forceStdout: boolean,\n  input: LogInput<IoCodeLevel>,\n  style?: (str: string) => string,\n  ...args: unknown[]\n): void {\n  // Extract message and code from input, using new default code format\n  const { message, code = getDefaultCode(level) } = typeof input === 'object' ? input : { message: input };\n\n  // Format message if args are provided\n  const formattedMessage = args.length > 0\n    ? util.format(message, ...args)\n    : message;\n\n  // Apply style if provided\n  const finalMessage = style ? style(formattedMessage) : formattedMessage;\n\n  log({\n    level,\n    message: finalMessage,\n    code,\n    forceStdout,\n  });\n}\n\nfunction getDefaultCode(level: IoMessageLevel, category: IoMessageCodeCategory = 'TOOLKIT'): IoMessageCode {\n  const levelIndicator = level === 'error' ? 'E' :\n    level === 'warn' ? 'W' :\n      'I';\n  return `CDK_${category}_${levelIndicator}0000`;\n}\n\n// Type for the object parameter style\ninterface LogParams<L extends IoCodeLevel> {\n  /**\n   * @see {@link IoMessage.code}\n   */\n  readonly code?: IoMessageSpecificCode<L>;\n  /**\n   * @see {@link IoMessage.message}\n   */\n  readonly message: string;\n}\n\n// Type for the exported log function arguments\ntype LogInput<L extends IoCodeLevel> = string | LogParams<L>;\n\n// Exported logging functions. If any additional logging functionality is required, it should be added as\n// a new logging function here.\n\n/**\n * Logs an error level message.\n *\n * Can be used in multiple ways:\n * ```ts\n * error(`operation failed: ${e}`) // infers default error code `CDK_TOOLKIT_E000`\n * error('operation failed: %s', e) // infers default error code `CDK_TOOLKIT_E000`\n * error({ message: 'operation failed', code: 'CDK_SDK_E001' }) // specifies error code `CDK_SDK_E001`\n * error({ message: 'operation failed: %s', code: 'CDK_SDK_E001' }, e) // specifies error code `CDK_SDK_E001`\n * ```\n */\nexport const error = (input: LogInput<'E'>, ...args: unknown[]) => {\n  return formatMessageAndLog('error', false, input, undefined, ...args);\n};\n\n/**\n * Logs an warning level message.\n *\n * Can be used in multiple ways:\n * ```ts\n * warning(`deprected feature: ${message}`) // infers default warning code `CDK_TOOLKIT_W000`\n * warning('deprected feature: %s', message) // infers default warning code `CDK_TOOLKIT_W000`\n * warning({ message: 'deprected feature', code: 'CDK_SDK_W001' }) // specifies warning code `CDK_SDK_W001`\n * warning({ message: 'deprected feature: %s', code: 'CDK_SDK_W001' }, message) // specifies warning code `CDK_SDK_W001`\n * ```\n */\nexport const warning = (input: LogInput<'W'>, ...args: unknown[]) => {\n  return formatMessageAndLog('warn', false, input, undefined, ...args);\n};\n\n/**\n * Logs an info level message.\n *\n * Can be used in multiple ways:\n * ```ts\n * info(`processing: ${message}`) // infers default info code `CDK_TOOLKIT_I000`\n * info('processing: %s', message) // infers default info code `CDK_TOOLKIT_I000`\n * info({ message: 'processing', code: 'CDK_TOOLKIT_I001' }) // specifies info code `CDK_TOOLKIT_I001`\n * info({ message: 'processing: %s', code: 'CDK_TOOLKIT_I001' }, message) // specifies info code `CDK_TOOLKIT_I001`\n * ```\n */\nexport const info = (input: LogInput<'I'>, ...args: unknown[]) => {\n  return formatMessageAndLog('info', false, input, undefined, ...args);\n};\n\n/**\n * Logs an info level message to stdout.\n *\n * Can be used in multiple ways:\n * ```ts\n * data(`${JSON.stringify(stats)}`) // infers default info code `CDK_TOOLKIT_I000`\n * data('{\"count\": %d}', count) // infers default info code `CDK_TOOLKIT_I000`\n * data({ message: 'stats: %j', code: 'CDK_DATA_I001' }) // specifies info code `CDK_DATA_I001`\n * data({ message: 'stats: %j', code: 'CDK_DATA_I001' }, stats) // specifies info code `CDK_DATA_I001`\n * ```\n */\nexport const data = (input: LogInput<'I'>, ...args: unknown[]) => {\n  return formatMessageAndLog('info', true, input, undefined, ...args);\n};\n\n/**\n * Logs a debug level message.\n *\n * Can be used in multiple ways:\n * ```ts\n * debug(`state: ${JSON.stringify(state)}`) // infers default info code `CDK_TOOLKIT_I000`\n * debug('cache hit ratio: %d%%', ratio) // infers default info code `CDK_TOOLKIT_I000`\n * debug({ message: 'state update', code: 'CDK_TOOLKIT_I001' }) // specifies info code `CDK_TOOLKIT_I001`\n * debug({ message: 'ratio: %d%%', code: 'CDK_TOOLKIT_I001' }, ratio) // specifies info code `CDK_TOOLKIT_I001`\n * ```\n */\nexport const debug = (input: LogInput<'I'>, ...args: unknown[]) => {\n  return formatMessageAndLog('debug', false, input, undefined, ...args);\n};\n\n/**\n * Logs a trace level message.\n *\n * Can be used in multiple ways:\n * ```ts\n * trace(`entered ${name} with ${args}`) // infers default info code `CDK_TOOLKIT_I000`\n * trace('method: %s, args: %j', name, args) // infers default info code `CDK_TOOLKIT_I000`\n * trace({ message: 'entered', code: 'CDK_TOOLKIT_I001' }) // specifies info code `CDK_TOOLKIT_I001`\n * trace({ message: 'method: %s', code: 'CDK_TOOLKIT_I001' }, name) // specifies info code `CDK_TOOLKIT_I001`\n * ```\n */\nexport const trace = (input: LogInput<'I'>, ...args: unknown[]) => {\n  return formatMessageAndLog('trace', false, input, undefined, ...args);\n};\n\n/**\n * Logs an info level success message in green text.\n *\n * Can be used in multiple ways:\n * ```ts\n * success(`deployment completed: ${name}`) // infers default info code `CDK_TOOLKIT_I000`\n * success('processed %d items', count) // infers default info code `CDK_TOOLKIT_I000`\n * success({ message: 'completed', code: 'CDK_TOOLKIT_I001' }) // specifies info code `CDK_TOOLKIT_I001`\n * success({ message: 'items: %d', code: 'CDK_TOOLKIT_I001' }, count) // specifies info code `CDK_TOOLKIT_I001`\n * ```\n */\nexport const success = (input: LogInput<'I'>, ...args: unknown[]) => {\n  return formatMessageAndLog('info', false, input, chalk.green, ...args);\n};\n\n/**\n * Logs an info level message in bold text.\n *\n * Can be used in multiple ways:\n * ```ts\n * highlight(`important: ${msg}`) // infers default info code `CDK_TOOLKIT_I000`\n * highlight('attention required: %s', reason) // infers default info code `CDK_TOOLKIT_I000`\n * highlight({ message: 'notice', code: 'CDK_TOOLKIT_I001' }) // specifies info code `CDK_TOOLKIT_I001`\n * highlight({ message: 'notice: %s', code: 'CDK_TOOLKIT_I001' }, msg) // specifies info code `CDK_TOOLKIT_I001`\n * ```\n */\nexport const highlight = (input: LogInput<'I'>, ...args: unknown[]) => {\n  return formatMessageAndLog('info', false, input, chalk.bold, ...args);\n};\n"]}