@aws-cdk/toolkit-lib 0.1.1 → 0.1.3

package/lib/api/io/private/codes.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CODES = void 0;
+function codeInfo(info) {
+    return info;
+}
 /**
  * We have a rough system by which we assign message codes:
  * - First digit groups messages by action, e.g. synth or deploy
@@ -9,40 +12,176 @@ exports.CODES = void 0;
  */
 exports.CODES = {
     // 1: Synth
-    CDK_TOOLKIT_I1000: 'Provides synthesis times',
-    CDK_TOOLKIT_I1901: 'Provides stack data',
-    CDK_TOOLKIT_I1902: 'Successfully deployed stacks',
+    CDK_TOOLKIT_I1000: codeInfo({
+        code: 'CDK_TOOLKIT_I1000',
+        description: 'Provides synthesis times.',
+        level: 'info',
+    }),
+    CDK_TOOLKIT_I1901: codeInfo({
+        code: 'CDK_TOOLKIT_I1901',
+        description: 'Provides stack data',
+        level: 'result',
+        interface: 'StackData',
+    }),
+    CDK_TOOLKIT_I1902: codeInfo({
+        code: 'CDK_TOOLKIT_I1902',
+        description: 'Successfully deployed stacks',
+        level: 'result',
+        interface: 'AssemblyData',
+    }),
     // 2: List
-    CDK_TOOLKIT_I2901: 'Provides details on the selected stacks and their dependencies',
+    CDK_TOOLKIT_I2901: codeInfo({
+        code: 'CDK_TOOLKIT_I2901',
+        description: 'Provides details on the selected stacks and their dependencies',
+        level: 'result',
+    }),
     // 3: Import & Migrate
-    CDK_TOOLKIT_E3900: 'Resource import failed',
+    CDK_TOOLKIT_E3900: codeInfo({
+        code: 'CDK_TOOLKIT_E3900',
+        description: 'Resource import failed',
+        level: 'error',
+    }),
     // 4: Diff
     // 5: Deploy & Watch
-    CDK_TOOLKIT_I5000: 'Provides deployment times',
-    CDK_TOOLKIT_I5001: 'Provides total time in deploy action, including synth and rollback',
-    CDK_TOOLKIT_I5002: 'Provides time for resource migration',
-    CDK_TOOLKIT_I5031: 'Informs about any log groups that are traced as part of the deployment',
-    CDK_TOOLKIT_I5050: 'Confirm rollback during deployment',
-    CDK_TOOLKIT_I5060: 'Confirm deploy security sensitive changes',
-    CDK_TOOLKIT_I5900: 'Deployment results on success',
-    CDK_TOOLKIT_E5001: 'No stacks found',
+    CDK_TOOLKIT_I5000: codeInfo({
+        code: 'CDK_TOOLKIT_I5000',
+        description: 'Provides deployment times',
+        level: 'info',
+    }),
+    CDK_TOOLKIT_I5001: codeInfo({
+        code: 'CDK_TOOLKIT_I5001',
+        description: 'Provides total time in deploy action, including synth and rollback',
+        level: 'info',
+        interface: 'Duration',
+    }),
+    CDK_TOOLKIT_I5002: codeInfo({
+        code: 'CDK_TOOLKIT_I5002',
+        description: 'Provides time for resource migration',
+        level: 'info',
+    }),
+    CDK_TOOLKIT_I5031: codeInfo({
+        code: 'CDK_TOOLKIT_I5031',
+        description: 'Informs about any log groups that are traced as part of the deployment',
+        level: 'info',
+    }),
+    CDK_TOOLKIT_I5050: codeInfo({
+        code: 'CDK_TOOLKIT_I5050',
+        description: 'Confirm rollback during deployment',
+        level: 'info',
+    }),
+    CDK_TOOLKIT_I5060: codeInfo({
+        code: 'CDK_TOOLKIT_I5060',
+        description: 'Confirm deploy security sensitive changes',
+        level: 'info',
+    }),
+    CDK_TOOLKIT_I5501: codeInfo({
+        code: 'CDK_TOOLKIT_I5501',
+        description: 'Stack Monitoring: Start monitoring of a single stack',
+        level: 'info',
+        interface: 'StackMonitoringControlEvent',
+    }),
+    CDK_TOOLKIT_I5502: codeInfo({
+        code: 'CDK_TOOLKIT_I5502',
+        description: 'Stack Monitoring: Activity event for a single stack',
+        level: 'info',
+        interface: 'StackActivity',
+    }),
+    CDK_TOOLKIT_I5503: codeInfo({
+        code: 'CDK_TOOLKIT_I5503',
+        description: 'Stack Monitoring: Finished monitoring of a single stack',
+        level: 'info',
+        interface: 'StackMonitoringControlEvent',
+    }),
+    CDK_TOOLKIT_I5900: codeInfo({
+        code: 'CDK_TOOLKIT_I5900',
+        description: 'Deployment results on success',
+        level: 'result',
+        interface: 'SuccessfulDeployStackResult',
+    }),
+    CDK_TOOLKIT_E5001: codeInfo({
+        code: 'CDK_TOOLKIT_E5001',
+        description: 'No stacks found',
+        level: 'error',
+    }),
+    CDK_TOOLKIT_E5500: codeInfo({
+        code: 'CDK_TOOLKIT_E5500',
+        description: 'Stack Monitoring error',
+        level: 'error',
+        interface: 'ErrorPayload',
+    }),
     // 6: Rollback
-    CDK_TOOLKIT_I6000: 'Provides rollback times',
-    CDK_TOOLKIT_E6001: 'No stacks found',
-    CDK_TOOLKIT_E6900: 'Rollback failed',
+    CDK_TOOLKIT_I6000: codeInfo({
+        code: 'CDK_TOOLKIT_I6000',
+        description: 'Provides rollback times',
+        level: 'info',
+    }),
+    CDK_TOOLKIT_E6001: codeInfo({
+        code: 'CDK_TOOLKIT_E6001',
+        description: 'No stacks found',
+        level: 'error',
+    }),
+    CDK_TOOLKIT_E6900: codeInfo({
+        code: 'CDK_TOOLKIT_E6900',
+        description: 'Rollback failed',
+        level: 'error',
+    }),
     // 7: Destroy
-    CDK_TOOLKIT_I7000: 'Provides destroy times',
-    CDK_TOOLKIT_I7010: 'Confirm destroy stacks',
-    CDK_TOOLKIT_E7010: 'Action was aborted due to negative confirmation of request',
-    CDK_TOOLKIT_E7900: 'Stack deletion failed',
+    CDK_TOOLKIT_I7000: codeInfo({
+        code: 'CDK_TOOLKIT_I7000',
+        description: 'Provides destroy times',
+        level: 'info',
+    }),
+    CDK_TOOLKIT_I7010: codeInfo({
+        code: 'CDK_TOOLKIT_I7010',
+        description: 'Confirm destroy stacks',
+        level: 'info',
+    }),
+    CDK_TOOLKIT_E7010: codeInfo({
+        code: 'CDK_TOOLKIT_E7010',
+        description: 'Action was aborted due to negative confirmation of request',
+        level: 'error',
+    }),
+    CDK_TOOLKIT_E7900: codeInfo({
+        code: 'CDK_TOOLKIT_E7900',
+        description: 'Stack deletion failed',
+        level: 'error',
+    }),
     // 9: Bootstrap
     // Assembly codes
-    CDK_ASSEMBLY_I0042: 'Writing updated context',
-    CDK_ASSEMBLY_I0241: 'Fetching missing context',
-    CDK_ASSEMBLY_I1000: 'Cloud assembly output starts',
-    CDK_ASSEMBLY_I1001: 'Output lines emitted by the cloud assembly to stdout',
-    CDK_ASSEMBLY_E1002: 'Output lines emitted by the cloud assembly to stderr',
-    CDK_ASSEMBLY_I1003: 'Cloud assembly output finished',
-    CDK_ASSEMBLY_E1111: 'Incompatible CDK CLI version. Upgrade needed.',
+    CDK_ASSEMBLY_I0042: codeInfo({
+        code: 'CDK_ASSEMBLY_I0042',
+        description: 'Writing updated context',
+        level: 'debug',
+    }),
+    CDK_ASSEMBLY_I0241: codeInfo({
+        code: 'CDK_ASSEMBLY_I0241',
+        description: 'Fetching missing context',
+        level: 'debug',
+    }),
+    CDK_ASSEMBLY_I1000: codeInfo({
+        code: 'CDK_ASSEMBLY_I1000',
+        description: 'Cloud assembly output starts',
+        level: 'debug',
+    }),
+    CDK_ASSEMBLY_I1001: codeInfo({
+        code: 'CDK_ASSEMBLY_I1001',
+        description: 'Output lines emitted by the cloud assembly to stdout',
+        level: 'info',
+    }),
+    CDK_ASSEMBLY_E1002: codeInfo({
+        code: 'CDK_ASSEMBLY_E1002',
+        description: 'Output lines emitted by the cloud assembly to stderr',
+        level: 'error',
+    }),
+    CDK_ASSEMBLY_I1003: codeInfo({
+        code: 'CDK_ASSEMBLY_I1003',
+        description: 'Cloud assembly output finished',
+        level: 'info',
+    }),
+    CDK_ASSEMBLY_E1111: codeInfo({
+        code: 'CDK_ASSEMBLY_E1111',
+        description: 'Incompatible CDK CLI version. Upgrade needed.',
+        level: 'error',
+    }),
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"codes.js","sourceRoot":"","sources":["codes.ts"],"names":[],"mappings":"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","sourcesContent":["import { IoMessageCode, IoMessageLevel } from '../io-message';\n\n/**\n * Information for each IO Message Code.\n */\nexport interface CodeInfo {\n  /**\n   * The message code.\n   */\n  code: IoMessageCode;\n\n  /**\n   * A brief description of the meaning of this IO Message.\n   */\n  description: string;\n\n  /**\n   * The message level\n   */\n  level: IoMessageLevel;\n\n  /**\n   * The name of the payload interface, if applicable.\n   * Some Io Messages include a payload, with a specific interface. The name of\n   * the interface is specified here so that it can be linked with the message\n   * when documentation is generated.\n   *\n   * The interface _must_ be exposed directly from toolkit-lib, so that it will\n   * have a documentation page generated (that can be linked to).\n   */\n  interface?: string;\n}\n\nfunction codeInfo(info: CodeInfo): CodeInfo {\n  return info;\n}\n\n/**\n * We have a rough system by which we assign message codes:\n * - First digit groups messages by action, e.g. synth or deploy\n * - X000-X009 are reserved for timings\n * - X900-X999 are reserved for results\n */\nexport const CODES = {\n  // 1: Synth\n  CDK_TOOLKIT_I1000: codeInfo({\n    code: 'CDK_TOOLKIT_I1000',\n    description: 'Provides synthesis times.',\n    level: 'info',\n  }),\n  CDK_TOOLKIT_I1901: codeInfo({\n    code: 'CDK_TOOLKIT_I1901',\n    description: 'Provides stack data',\n    level: 'result',\n    interface: 'StackData',\n  }),\n  CDK_TOOLKIT_I1902: codeInfo({\n    code: 'CDK_TOOLKIT_I1902',\n    description: 'Successfully deployed stacks',\n    level: 'result',\n    interface: 'AssemblyData',\n  }),\n\n  // 2: List\n  CDK_TOOLKIT_I2901: codeInfo({\n    code: 'CDK_TOOLKIT_I2901',\n    description: 'Provides details on the selected stacks and their dependencies',\n    level: 'result',\n  }),\n\n  // 3: Import & Migrate\n  CDK_TOOLKIT_E3900: codeInfo({\n    code: 'CDK_TOOLKIT_E3900',\n    description: 'Resource import failed',\n    level: 'error',\n  }),\n\n  // 4: Diff\n\n  // 5: Deploy & Watch\n  CDK_TOOLKIT_I5000: codeInfo({\n    code: 'CDK_TOOLKIT_I5000',\n    description: 'Provides deployment times',\n    level: 'info',\n  }),\n  CDK_TOOLKIT_I5001: codeInfo({\n    code: 'CDK_TOOLKIT_I5001',\n    description: 'Provides total time in deploy action, including synth and rollback',\n    level: 'info',\n    interface: 'Duration',\n  }),\n  CDK_TOOLKIT_I5002: codeInfo({\n    code: 'CDK_TOOLKIT_I5002',\n    description: 'Provides time for resource migration',\n    level: 'info',\n  }),\n  CDK_TOOLKIT_I5031: codeInfo({\n    code: 'CDK_TOOLKIT_I5031',\n    description: 'Informs about any log groups that are traced as part of the deployment',\n    level: 'info',\n  }),\n  CDK_TOOLKIT_I5050: codeInfo({\n    code: 'CDK_TOOLKIT_I5050',\n    description: 'Confirm rollback during deployment',\n    level: 'info',\n  }),\n  CDK_TOOLKIT_I5060: codeInfo({\n    code: 'CDK_TOOLKIT_I5060',\n    description: 'Confirm deploy security sensitive changes',\n    level: 'info',\n  }),\n\n  CDK_TOOLKIT_I5501: codeInfo({\n    code: 'CDK_TOOLKIT_I5501',\n    description: 'Stack Monitoring: Start monitoring of a single stack',\n    level: 'info',\n    interface: 'StackMonitoringControlEvent',\n  }),\n  CDK_TOOLKIT_I5502: codeInfo({\n    code: 'CDK_TOOLKIT_I5502',\n    description: 'Stack Monitoring: Activity event for a single stack',\n    level: 'info',\n    interface: 'StackActivity',\n  }),\n  CDK_TOOLKIT_I5503: codeInfo({\n    code: 'CDK_TOOLKIT_I5503',\n    description: 'Stack Monitoring: Finished monitoring of a single stack',\n    level: 'info',\n    interface: 'StackMonitoringControlEvent',\n  }),\n\n  CDK_TOOLKIT_I5900: codeInfo({\n    code: 'CDK_TOOLKIT_I5900',\n    description: 'Deployment results on success',\n    level: 'result',\n    interface: 'SuccessfulDeployStackResult',\n  }),\n\n  CDK_TOOLKIT_E5001: codeInfo({\n    code: 'CDK_TOOLKIT_E5001',\n    description: 'No stacks found',\n    level: 'error',\n  }),\n  CDK_TOOLKIT_E5500: codeInfo({\n    code: 'CDK_TOOLKIT_E5500',\n    description: 'Stack Monitoring error',\n    level: 'error',\n    interface: 'ErrorPayload',\n  }),\n\n  // 6: Rollback\n  CDK_TOOLKIT_I6000: codeInfo({\n    code: 'CDK_TOOLKIT_I6000',\n    description: 'Provides rollback times',\n    level: 'info',\n  }),\n\n  CDK_TOOLKIT_E6001: codeInfo({\n    code: 'CDK_TOOLKIT_E6001',\n    description: 'No stacks found',\n    level: 'error',\n  }),\n  CDK_TOOLKIT_E6900: codeInfo({\n    code: 'CDK_TOOLKIT_E6900',\n    description: 'Rollback failed',\n    level: 'error',\n  }),\n\n  // 7: Destroy\n  CDK_TOOLKIT_I7000: codeInfo({\n    code: 'CDK_TOOLKIT_I7000',\n    description: 'Provides destroy times',\n    level: 'info',\n  }),\n  CDK_TOOLKIT_I7010: codeInfo({\n    code: 'CDK_TOOLKIT_I7010',\n    description: 'Confirm destroy stacks',\n    level: 'info',\n  }),\n\n  CDK_TOOLKIT_E7010: codeInfo({\n    code: 'CDK_TOOLKIT_E7010',\n    description: 'Action was aborted due to negative confirmation of request',\n    level: 'error',\n  }),\n  CDK_TOOLKIT_E7900: codeInfo({\n    code: 'CDK_TOOLKIT_E7900',\n    description: 'Stack deletion failed',\n    level: 'error',\n  }),\n\n  // 9: Bootstrap\n\n  // Assembly codes\n  CDK_ASSEMBLY_I0042: codeInfo({\n    code: 'CDK_ASSEMBLY_I0042',\n    description: 'Writing updated context',\n    level: 'debug',\n  }),\n  CDK_ASSEMBLY_I0241: codeInfo({\n    code: 'CDK_ASSEMBLY_I0241',\n    description: 'Fetching missing context',\n    level: 'debug',\n  }),\n  CDK_ASSEMBLY_I1000: codeInfo({\n    code: 'CDK_ASSEMBLY_I1000',\n    description: 'Cloud assembly output starts',\n    level: 'debug',\n  }),\n  CDK_ASSEMBLY_I1001: codeInfo({\n    code: 'CDK_ASSEMBLY_I1001',\n    description: 'Output lines emitted by the cloud assembly to stdout',\n    level: 'info',\n  }),\n  CDK_ASSEMBLY_E1002: codeInfo({\n    code: 'CDK_ASSEMBLY_E1002',\n    description: 'Output lines emitted by the cloud assembly to stderr',\n    level: 'error',\n  }),\n  CDK_ASSEMBLY_I1003: codeInfo({\n    code: 'CDK_ASSEMBLY_I1003',\n    description: 'Cloud assembly output finished',\n    level: 'info',\n  }),\n  CDK_ASSEMBLY_E1111: codeInfo({\n    code: 'CDK_ASSEMBLY_E1111',\n    description: 'Incompatible CDK CLI version. Upgrade needed.',\n    level: 'error',\n  }),\n};\n"]}

package/lib/api/io/private/messages.d.ts

@@ -1,33 +1,27 @@
 import type { IoMessageLevel } from '../io-message';
-import { type VALID_CODE } from './codes';
-import type { ActionLessMessage, ActionLessRequest, IoMessageCodeCategory, Optional, SimplifiedMessage } from './types';
-/**
- * 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.
- */
-export declare function formatMessage<T>(msg: Optional<SimplifiedMessage<T>, 'code'>, category?: IoMessageCodeCategory): ActionLessMessage<T>;
+import { CodeInfo } from './codes';
+import type { ActionLessMessage, ActionLessRequest, IoMessageCodeCategory } from './types';
 /**
  * Build a message code from level and category. The code must be valid for this function to pass.
  * Otherwise it returns a ToolkitError.
  */
-export declare function defaultMessageCode(level: IoMessageLevel, category?: IoMessageCodeCategory): VALID_CODE;
+export declare function defaultMessageCode(level: IoMessageLevel, category?: IoMessageCodeCategory): CodeInfo;
 /**
  * Requests a yes/no confirmation from the IoHost.
  */
-export declare const confirm: (code: VALID_CODE, question: string, motivation: string, defaultResponse: boolean, concurrency?: number) => ActionLessRequest<{
+export declare const confirm: (code: CodeInfo, question: string, motivation: string, defaultResponse: boolean, concurrency?: number) => ActionLessRequest<{
     motivation: string;
     concurrency?: number;
 }, boolean>;
 /**
- * Prompt for a a response from the IoHost.
+ * Prompt for a response from the IoHost.
  */
-export declare const prompt: <T, U>(code: VALID_CODE, message: string, defaultResponse: U, payload?: T) => ActionLessRequest<T, U>;
+export declare const prompt: <T, U>(code: CodeInfo, message: string, defaultResponse: U, payload?: T) => ActionLessRequest<T, U>;
 /**
  * Creates an error level message.
  * Errors must always have a unique code.
  */
-export declare const error: <T>(message: string, code: VALID_CODE, payload?: T) => ActionLessMessage<T>;
+export declare const error: <T>(message: string, code: CodeInfo, payload?: T) => ActionLessMessage<T>;
 /**
  * Creates a result level message and represents the most important message for a given action.
  *
@@ -35,30 +29,30 @@ export declare const error: <T>(message: string, code: VALID_CODE, payload?: T)
  * However actions that operate on Cloud Assemblies might include a result per Stack.
  * Unlike other messages, results must always have a code and a payload.
  */
-export declare const result: <T>(message: string, code: VALID_CODE, payload: T) => ActionLessMessage<T>;
+export declare const result: <T>(message: string, code: CodeInfo, payload: T) => ActionLessMessage<T>;
 /**
  * Creates a warning level message.
  */
-export declare const warn: <T>(message: string, code?: VALID_CODE, payload?: T) => ActionLessMessage<T>;
+export declare const warn: <T>(message: string, code?: CodeInfo, payload?: T) => ActionLessMessage<T>;
 /**
  * Creates an info level message.
  */
-export declare const info: <T>(message: string, code?: VALID_CODE, payload?: T) => ActionLessMessage<T>;
+export declare const info: <T>(message: string, code?: CodeInfo, payload?: T) => ActionLessMessage<T>;
 /**
  * Creates a debug level message.
  */
-export declare const debug: <T>(message: string, code?: VALID_CODE, payload?: T) => ActionLessMessage<T>;
+export declare const debug: <T>(message: string, code?: CodeInfo, payload?: T) => ActionLessMessage<T>;
 /**
  * Creates a trace level message.
  */
-export declare const trace: <T>(message: string, code?: VALID_CODE, payload?: T) => ActionLessMessage<T>;
+export declare const trace: <T>(message: string, code?: CodeInfo, payload?: T) => ActionLessMessage<T>;
 /**
  * Creates an info level success message in green text.
  * @deprecated
  */
-export declare const success: <T>(message: string, code?: VALID_CODE, payload?: T) => ActionLessMessage<T>;
+export declare const success: <T>(message: string, code?: CodeInfo, payload?: T) => ActionLessMessage<T>;
 /**
  * Creates an info level message in bold text.
  * @deprecated
  */
-export declare const highlight: <T>(message: string, code?: VALID_CODE, payload?: T) => ActionLessMessage<T>;
+export declare const highlight: <T>(message: string, code?: CodeInfo, payload?: T) => ActionLessMessage<T>;

package/lib/api/io/private/messages.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.highlight = exports.success = exports.trace = exports.debug = exports.info = exports.warn = exports.result = exports.error = exports.prompt = exports.confirm = void 0;
-exports.formatMessage = formatMessage;
 exports.defaultMessageCode = defaultMessageCode;
 const chalk = require("chalk");
 /**
@@ -13,7 +12,7 @@ function formatMessage(msg, category = 'TOOLKIT') {
     return {
         time: new Date(),
         level: msg.level,
-        code: msg.code ?? defaultMessageCode(msg.level, category),
+        code: msg.code ?? defaultMessageCode(msg.level, category).code,
         message: msg.message,
         data: msg.data,
     };
@@ -26,7 +25,12 @@ function defaultMessageCode(level, category = 'TOOLKIT') {
     const levelIndicator = level === 'error' ? 'E' :
         level === 'warn' ? 'W' :
             'I';
-    return `CDK_${category}_${levelIndicator}0000`;
+    const code = `CDK_${category}_${levelIndicator}0000`;
+    return {
+        code,
+        description: `Generic ${level} message for CDK_${category}`,
+        level,
+    };
 }
 /**
  * Requests a yes/no confirmation from the IoHost.
@@ -39,14 +43,14 @@ const confirm = (code, question, motivation, defaultResponse, concurrency) => {
 };
 exports.confirm = confirm;
 /**
- * Prompt for a a response from the IoHost.
+ * Prompt for a response from the IoHost.
  */
 const prompt = (code, message, defaultResponse, payload) => {
     return {
         defaultResponse,
         ...formatMessage({
-            level: 'info',
-            code,
+            level: code.level,
+            code: code.code,
             message,
             data: payload,
         }),
@@ -60,7 +64,7 @@ exports.prompt = prompt;
 const error = (message, code, payload) => {
     return formatMessage({
         level: 'error',
-        code,
+        code: code.code,
         message,
         data: payload,
     });
@@ -76,7 +80,7 @@ exports.error = error;
 const result = (message, code, payload) => {
     return formatMessage({
         level: 'result',
-        code,
+        code: code.code,
         message,
         data: payload,
     });
@@ -88,7 +92,7 @@ exports.result = result;
 const warn = (message, code, payload) => {
     return formatMessage({
         level: 'warn',
-        code,
+        code: code?.code,
         message,
         data: payload,
     });
@@ -100,7 +104,7 @@ exports.warn = warn;
 const info = (message, code, payload) => {
     return formatMessage({
         level: 'info',
-        code,
+        code: code?.code,
         message,
         data: payload,
     });
@@ -112,7 +116,7 @@ exports.info = info;
 const debug = (message, code, payload) => {
     return formatMessage({
         level: 'debug',
-        code,
+        code: code?.code,
         message,
         data: payload,
     });
@@ -124,7 +128,7 @@ exports.debug = debug;
 const trace = (message, code, payload) => {
     return formatMessage({
         level: 'trace',
-        code,
+        code: code?.code,
         message,
         data: payload,
     });
@@ -137,7 +141,7 @@ exports.trace = trace;
 const success = (message, code, payload) => {
     return formatMessage({
         level: 'info',
-        code,
+        code: code?.code,
         message: chalk.green(message),
         data: payload,
     });
@@ -150,10 +154,10 @@ exports.success = success;
 const highlight = (message, code, payload) => {
     return formatMessage({
         level: 'info',
-        code,
+        code: code?.code,
         message: chalk.bold(message),
         data: payload,
     });
 };
 exports.highlight = highlight;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"messages.js","sourceRoot":"","sources":["messages.ts"],"names":[],"mappings":"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","sourcesContent":["import * as chalk from 'chalk';\nimport type { IoMessageLevel } from '../io-message';\nimport { type VALID_CODE } from './codes';\nimport type { ActionLessMessage, ActionLessRequest, IoMessageCodeCategory, Optional, SimplifiedMessage } from './types';\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 */\nexport function formatMessage<T>(msg: Optional<SimplifiedMessage<T>, 'code'>, category: IoMessageCodeCategory = 'TOOLKIT'): ActionLessMessage<T> {\n  return {\n    time: new Date(),\n    level: msg.level,\n    code: msg.code ?? defaultMessageCode(msg.level, category),\n    message: msg.message,\n    data: msg.data,\n  };\n}\n\n/**\n * Build a message code from level and category. The code must be valid for this function to pass.\n * Otherwise it returns a ToolkitError.\n */\nexport function defaultMessageCode(level: IoMessageLevel, category: IoMessageCodeCategory = 'TOOLKIT'): VALID_CODE {\n  const levelIndicator = level === 'error' ? 'E' :\n    level === 'warn' ? 'W' :\n      'I';\n  return `CDK_${category}_${levelIndicator}0000` as VALID_CODE;\n}\n\n/**\n * Requests a yes/no confirmation from the IoHost.\n */\nexport const confirm = (\n  code: VALID_CODE,\n  question: string,\n  motivation: string,\n  defaultResponse: boolean,\n  concurrency?: number,\n): ActionLessRequest<{\n  motivation: string;\n  concurrency?: number;\n}, boolean> => {\n  return prompt(code, `${chalk.cyan(question)} (y/n)?`, defaultResponse, {\n    motivation,\n    concurrency,\n  });\n};\n\n/**\n * Prompt for a a response from the IoHost.\n */\nexport const prompt = <T, U>(code: VALID_CODE, message: string, defaultResponse: U, payload?: T): ActionLessRequest<T, U> => {\n  return {\n    defaultResponse,\n    ...formatMessage({\n      level: 'info',\n      code,\n      message,\n      data: payload,\n    }),\n  };\n};\n\n/**\n * Creates an error level message.\n * Errors must always have a unique code.\n */\nexport const error = <T>(message: string, code: VALID_CODE, payload?: T) => {\n  return formatMessage({\n    level: 'error',\n    code,\n    message,\n    data: payload,\n  });\n};\n\n/**\n * Creates a result level message and represents the most important message for a given action.\n *\n * They should be used sparsely, with an action usually having no or exactly one result.\n * However actions that operate on Cloud Assemblies might include a result per Stack.\n * Unlike other messages, results must always have a code and a payload.\n */\nexport const result = <T>(message: string, code: VALID_CODE, payload: T) => {\n  return formatMessage({\n    level: 'result',\n    code,\n    message,\n    data: payload,\n  });\n};\n\n/**\n * Creates a warning level message.\n */\nexport const warn = <T>(message: string, code?: VALID_CODE, payload?: T) => {\n  return formatMessage({\n    level: 'warn',\n    code,\n    message,\n    data: payload,\n  });\n};\n\n/**\n * Creates an info level message.\n */\nexport const info = <T>(message: string, code?: VALID_CODE, payload?: T) => {\n  return formatMessage({\n    level: 'info',\n    code,\n    message,\n    data: payload,\n  });\n};\n\n/**\n * Creates a debug level message.\n */\nexport const debug = <T>(message: string, code?: VALID_CODE, payload?: T) => {\n  return formatMessage({\n    level: 'debug',\n    code,\n    message,\n    data: payload,\n  });\n};\n\n/**\n * Creates a trace level message.\n */\nexport const trace = <T>(message: string, code?: VALID_CODE, payload?: T) => {\n  return formatMessage({\n    level: 'trace',\n    code,\n    message,\n    data: payload,\n  });\n};\n\n/**\n * Creates an info level success message in green text.\n * @deprecated\n */\nexport const success = <T>(message: string, code?: VALID_CODE, payload?: T) => {\n  return formatMessage({\n    level: 'info',\n    code,\n    message: chalk.green(message),\n    data: payload,\n  });\n};\n\n/**\n * Creates an info level message in bold text.\n * @deprecated\n */\nexport const highlight = <T>(message: string, code?: VALID_CODE, payload?: T) => {\n  return formatMessage({\n    level: 'info',\n    code,\n    message: chalk.bold(message),\n    data: payload,\n  });\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"messages.js","sourceRoot":"","sources":["messages.ts"],"names":[],"mappings":"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","sourcesContent":["import * as chalk from 'chalk';\nimport type { IoMessageCode, IoMessageLevel } from '../io-message';\nimport { CodeInfo } from './codes';\nimport type { ActionLessMessage, ActionLessRequest, IoMessageCodeCategory, Optional, SimplifiedMessage } from './types';\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 formatMessage<T>(msg: Optional<SimplifiedMessage<T>, 'code'>, category: IoMessageCodeCategory = 'TOOLKIT'): ActionLessMessage<T> {\n  return {\n    time: new Date(),\n    level: msg.level,\n    code: msg.code ?? defaultMessageCode(msg.level, category).code,\n    message: msg.message,\n    data: msg.data,\n  };\n}\n\n/**\n * Build a message code from level and category. The code must be valid for this function to pass.\n * Otherwise it returns a ToolkitError.\n */\nexport function defaultMessageCode(level: IoMessageLevel, category: IoMessageCodeCategory = 'TOOLKIT'): CodeInfo {\n  const levelIndicator = level === 'error' ? 'E' :\n    level === 'warn' ? 'W' :\n      'I';\n  const code = `CDK_${category}_${levelIndicator}0000` as IoMessageCode;\n  return {\n    code,\n    description: `Generic ${level} message for CDK_${category}`,\n    level,\n  };\n}\n\n/**\n * Requests a yes/no confirmation from the IoHost.\n */\nexport const confirm = (\n  code: CodeInfo,\n  question: string,\n  motivation: string,\n  defaultResponse: boolean,\n  concurrency?: number,\n): ActionLessRequest<{\n  motivation: string;\n  concurrency?: number;\n}, boolean> => {\n  return prompt(code, `${chalk.cyan(question)} (y/n)?`, defaultResponse, {\n    motivation,\n    concurrency,\n  });\n};\n\n/**\n * Prompt for a response from the IoHost.\n */\nexport const prompt = <T, U>(code: CodeInfo, message: string, defaultResponse: U, payload?: T): ActionLessRequest<T, U> => {\n  return {\n    defaultResponse,\n    ...formatMessage({\n      level: code.level,\n      code: code.code,\n      message,\n      data: payload,\n    }),\n  };\n};\n\n/**\n * Creates an error level message.\n * Errors must always have a unique code.\n */\nexport const error = <T>(message: string, code: CodeInfo, payload?: T) => {\n  return formatMessage({\n    level: 'error',\n    code: code.code,\n    message,\n    data: payload,\n  });\n};\n\n/**\n * Creates a result level message and represents the most important message for a given action.\n *\n * They should be used sparsely, with an action usually having no or exactly one result.\n * However actions that operate on Cloud Assemblies might include a result per Stack.\n * Unlike other messages, results must always have a code and a payload.\n */\nexport const result = <T>(message: string, code: CodeInfo, payload: T) => {\n  return formatMessage({\n    level: 'result',\n    code: code.code,\n    message,\n    data: payload,\n  });\n};\n\n/**\n * Creates a warning level message.\n */\nexport const warn = <T>(message: string, code?: CodeInfo, payload?: T) => {\n  return formatMessage({\n    level: 'warn',\n    code: code?.code,\n    message,\n    data: payload,\n  });\n};\n\n/**\n * Creates an info level message.\n */\nexport const info = <T>(message: string, code?: CodeInfo, payload?: T) => {\n  return formatMessage({\n    level: 'info',\n    code: code?.code,\n    message,\n    data: payload,\n  });\n};\n\n/**\n * Creates a debug level message.\n */\nexport const debug = <T>(message: string, code?: CodeInfo, payload?: T) => {\n  return formatMessage({\n    level: 'debug',\n    code: code?.code,\n    message,\n    data: payload,\n  });\n};\n\n/**\n * Creates a trace level message.\n */\nexport const trace = <T>(message: string, code?: CodeInfo, payload?: T) => {\n  return formatMessage({\n    level: 'trace',\n    code: code?.code,\n    message,\n    data: payload,\n  });\n};\n\n/**\n * Creates an info level success message in green text.\n * @deprecated\n */\nexport const success = <T>(message: string, code?: CodeInfo, payload?: T) => {\n  return formatMessage({\n    level: 'info',\n    code: code?.code,\n    message: chalk.green(message),\n    data: payload,\n  });\n};\n\n/**\n * Creates an info level message in bold text.\n * @deprecated\n */\nexport const highlight = <T>(message: string, code?: CodeInfo, payload?: T) => {\n  return formatMessage({\n    level: 'info',\n    code: code?.code,\n    message: chalk.bold(message),\n    data: payload,\n  });\n};\n"]}

package/lib/api/io/private/timer.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Timer = void 0;
+const codes_1 = require("./codes");
 const messages_1 = require("./messages");
 const aws_cdk_1 = require("../../aws-cdk");
 /**
@@ -45,10 +46,10 @@ class Timer {
 exports.Timer = Timer;
 function timerMessageProps(type) {
     switch (type) {
-        case 'synth': return { code: 'CDK_TOOLKIT_I1000', text: 'Synthesis' };
-        case 'deploy': return { code: 'CDK_TOOLKIT_I5000', text: 'Deployment' };
-        case 'rollback': return { code: 'CDK_TOOLKIT_I6000', text: 'Rollback' };
-        case 'destroy': return { code: 'CDK_TOOLKIT_I7000', text: 'Destroy' };
+        case 'synth': return { code: codes_1.CODES.CDK_TOOLKIT_I1000, text: 'Synthesis' };
+        case 'deploy': return { code: codes_1.CODES.CDK_TOOLKIT_I5000, text: 'Deployment' };
+        case 'rollback': return { code: codes_1.CODES.CDK_TOOLKIT_I6000, text: 'Rollback' };
+        case 'destroy': return { code: codes_1.CODES.CDK_TOOLKIT_I7000, text: 'Destroy' };
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGltZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJ0aW1lci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFDQSx5Q0FBa0M7QUFFbEMsMkNBQTJDO0FBRTNDOztHQUVHO0FBQ0gsTUFBYSxLQUFLO0lBQ2hCOzs7T0FHRztJQUNJLE1BQU0sQ0FBQyxLQUFLO1FBQ2pCLE9BQU8sSUFBSSxLQUFLLEVBQUUsQ0FBQztJQUNyQixDQUFDO0lBRWdCLFNBQVMsQ0FBUztJQUVuQztRQUNFLElBQUksQ0FBQyxTQUFTLEdBQUcsSUFBSSxJQUFJLEVBQUUsQ0FBQyxPQUFPLEVBQUUsQ0FBQztJQUN4QyxDQUFDO0lBRUQ7OztPQUdHO0lBQ0ksR0FBRztRQUNSLE1BQU0sV0FBVyxHQUFHLElBQUksSUFBSSxFQUFFLENBQUMsT0FBTyxFQUFFLEdBQUcsSUFBSSxDQUFDLFNBQVMsQ0FBQztRQUMxRCxPQUFPO1lBQ0wsSUFBSSxFQUFFLFdBQVc7WUFDakIsS0FBSyxFQUFFLElBQUEsb0JBQVUsRUFBQyxXQUFXLENBQUM7U0FDL0IsQ0FBQztJQUNKLENBQUM7SUFFRDs7O09BR0c7SUFDSSxLQUFLLENBQUMsS0FBSyxDQUFDLE1BQXlCLEVBQUUsSUFBaUQ7UUFDN0YsTUFBTSxRQUFRLEdBQUcsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDO1FBQzVCLE1BQU0sRUFBRSxJQUFJLEVBQUUsSUFBSSxFQUFFLEdBQUcsaUJBQWlCLENBQUMsSUFBSSxDQUFDLENBQUM7UUFFL0MsTUFBTSxNQUFNLENBQUMsTUFBTSxDQUFDLElBQUEsZUFBSSxFQUFDLFFBQVEsSUFBSSxVQUFVLFFBQVEsQ0FBQyxLQUFLLEtBQUssRUFBRSxJQUFJLEVBQUU7WUFDeEUsUUFBUSxFQUFFLFFBQVEsQ0FBQyxJQUFJO1NBQ3hCLENBQUMsQ0FBQyxDQUFDO1FBRUosT0FBTyxRQUFRLENBQUM7SUFDbEIsQ0FBQztDQUNGO0FBekNELHNCQXlDQztBQUVELFNBQVMsaUJBQWlCLENBQUMsSUFBZ0Q7SUFJekUsUUFBUSxJQUFJLEVBQUUsQ0FBQztRQUNiLEtBQUssT0FBTyxDQUFDLENBQUMsT0FBTyxFQUFFLElBQUksRUFBRSxtQkFBbUIsRUFBRSxJQUFJLEVBQUUsV0FBVyxFQUFFLENBQUM7UUFDdEUsS0FBSyxRQUFRLENBQUMsQ0FBQyxPQUFPLEVBQUUsSUFBSSxFQUFFLG1CQUFtQixFQUFFLElBQUksRUFBRSxZQUFZLEVBQUUsQ0FBQztRQUN4RSxLQUFLLFVBQVUsQ0FBQyxDQUFDLE9BQU8sRUFBRSxJQUFJLEVBQUUsbUJBQW1CLEVBQUUsSUFBSSxFQUFFLFVBQVUsRUFBRSxDQUFDO1FBQ3hFLEtBQUssU0FBUyxDQUFDLENBQUMsT0FBTyxFQUFFLElBQUksRUFBRSxtQkFBbUIsRUFBRSxJQUFJLEVBQUUsU0FBUyxFQUFFLENBQUM7SUFDeEUsQ0FBQztBQUNILENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBWQUxJRF9DT0RFIH0gZnJvbSAnLi9jb2Rlcyc7XG5pbXBvcnQgeyBpbmZvIH0gZnJvbSAnLi9tZXNzYWdlcyc7XG5pbXBvcnQgeyBBY3Rpb25Bd2FyZUlvSG9zdCB9IGZyb20gJy4vdHlwZXMnO1xuaW1wb3J0IHsgZm9ybWF0VGltZSB9IGZyb20gJy4uLy4uL2F3cy1jZGsnO1xuXG4vKipcbiAqIEhlbHBlciBjbGFzcyB0byBtZWFzdXJlIHRoZSB0aW1lIG9mIGNvZGUuXG4gKi9cbmV4cG9ydCBjbGFzcyBUaW1lciB7XG4gIC8qKlxuICAgKiBTdGFydCB0aGUgdGltZXIuXG4gICAqIEByZXR1cm4gdGhlIHRpbWVyIGluc3RhbmNlXG4gICAqL1xuICBwdWJsaWMgc3RhdGljIHN0YXJ0KCk6IFRpbWVyIHtcbiAgICByZXR1cm4gbmV3IFRpbWVyKCk7XG4gIH1cblxuICBwcml2YXRlIHJlYWRvbmx5IHN0YXJ0VGltZTogbnVtYmVyO1xuXG4gIHByaXZhdGUgY29uc3RydWN0b3IoKSB7XG4gICAgdGhpcy5zdGFydFRpbWUgPSBuZXcgRGF0ZSgpLmdldFRpbWUoKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBFbmQgdGhlIGN1cnJlbnQgdGltZXIuXG4gICAqIEByZXR1cm5zIHRoZSBlbGFwc2VkIHRpbWVcbiAgICovXG4gIHB1YmxpYyBlbmQoKSB7XG4gICAgY29uc3QgZWxhcHNlZFRpbWUgPSBuZXcgRGF0ZSgpLmdldFRpbWUoKSAtIHRoaXMuc3RhcnRUaW1lO1xuICAgIHJldHVybiB7XG4gICAgICBhc01zOiBlbGFwc2VkVGltZSxcbiAgICAgIGFzU2VjOiBmb3JtYXRUaW1lKGVsYXBzZWRUaW1lKSxcbiAgICB9O1xuICB9XG5cbiAgLyoqXG4gICAqIEVuZHMgdGhlIGN1cnJlbnQgdGltZXIgYXMgYSBzcGVjaWZpZWQgdGltaW5nIGFuZCBub3RpZmllcyB0aGUgSW9Ib3N0LlxuICAgKiBAcmV0dXJucyB0aGUgZWxhcHNlZCB0aW1lXG4gICAqL1xuICBwdWJsaWMgYXN5bmMgZW5kQXMoaW9Ib3N0OiBBY3Rpb25Bd2FyZUlvSG9zdCwgdHlwZTogJ3N5bnRoJyB8ICdkZXBsb3knIHwgJ3JvbGxiYWNrJyB8ICdkZXN0cm95Jykge1xuICAgIGNvbnN0IGR1cmF0aW9uID0gdGhpcy5lbmQoKTtcbiAgICBjb25zdCB7IGNvZGUsIHRleHQgfSA9IHRpbWVyTWVzc2FnZVByb3BzKHR5cGUpO1xuXG4gICAgYXdhaXQgaW9Ib3N0Lm5vdGlmeShpbmZvKGBcXG7inKggICR7dGV4dH0gdGltZTogJHtkdXJhdGlvbi5hc1NlY31zXFxuYCwgY29kZSwge1xuICAgICAgZHVyYXRpb246IGR1cmF0aW9uLmFzTXMsXG4gICAgfSkpO1xuXG4gICAgcmV0dXJuIGR1cmF0aW9uO1xuICB9XG59XG5cbmZ1bmN0aW9uIHRpbWVyTWVzc2FnZVByb3BzKHR5cGU6ICdzeW50aCcgfCAnZGVwbG95JyB8ICdyb2xsYmFjayd8ICdkZXN0cm95Jyk6IHtcbiAgY29kZTogVkFMSURfQ09ERTtcbiAgdGV4dDogc3RyaW5nO1xufSB7XG4gIHN3aXRjaCAodHlwZSkge1xuICAgIGNhc2UgJ3N5bnRoJzogcmV0dXJuIHsgY29kZTogJ0NES19UT09MS0lUX0kxMDAwJywgdGV4dDogJ1N5bnRoZXNpcycgfTtcbiAgICBjYXNlICdkZXBsb3knOiByZXR1cm4geyBjb2RlOiAnQ0RLX1RPT0xLSVRfSTUwMDAnLCB0ZXh0OiAnRGVwbG95bWVudCcgfTtcbiAgICBjYXNlICdyb2xsYmFjayc6IHJldHVybiB7IGNvZGU6ICdDREtfVE9PTEtJVF9JNjAwMCcsIHRleHQ6ICdSb2xsYmFjaycgfTtcbiAgICBjYXNlICdkZXN0cm95JzogcmV0dXJuIHsgY29kZTogJ0NES19UT09MS0lUX0k3MDAwJywgdGV4dDogJ0Rlc3Ryb3knIH07XG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/shared-public.d.ts

@@ -0,0 +1 @@
+export * from '../../../tmp-toolkit-helpers/src/api';

package/lib/api/shared-public.js

@@ -0,0 +1,100 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// lib/api/shared-public.ts
+var shared_public_exports = {};
+__export(shared_public_exports, {
+  AssemblyError: () => AssemblyError,
+  AuthenticationError: () => AuthenticationError,
+  ContextProviderError: () => ContextProviderError,
+  ToolkitError: () => ToolkitError
+});
+module.exports = __toCommonJS(shared_public_exports);
+
+// ../tmp-toolkit-helpers/src/api/toolkit-error.ts
+var TOOLKIT_ERROR_SYMBOL = Symbol.for("@aws-cdk/toolkit.ToolkitError");
+var AUTHENTICATION_ERROR_SYMBOL = Symbol.for("@aws-cdk/toolkit.AuthenticationError");
+var ASSEMBLY_ERROR_SYMBOL = Symbol.for("@aws-cdk/toolkit.AssemblyError");
+var CONTEXT_PROVIDER_ERROR_SYMBOL = Symbol.for("@aws-cdk/toolkit.ContextProviderError");
+var ToolkitError = class _ToolkitError extends Error {
+  /**
+   * Determines if a given error is an instance of ToolkitError.
+   */
+  static isToolkitError(x) {
+    return x !== null && typeof x === "object" && TOOLKIT_ERROR_SYMBOL in x;
+  }
+  /**
+   * Determines if a given error is an instance of AuthenticationError.
+   */
+  static isAuthenticationError(x) {
+    return this.isToolkitError(x) && AUTHENTICATION_ERROR_SYMBOL in x;
+  }
+  /**
+   * Determines if a given error is an instance of AssemblyError.
+   */
+  static isAssemblyError(x) {
+    return this.isToolkitError(x) && ASSEMBLY_ERROR_SYMBOL in x;
+  }
+  /**
+   * Determines if a given error is an instance of AssemblyError.
+   */
+  static isContextProviderError(x) {
+    return this.isToolkitError(x) && CONTEXT_PROVIDER_ERROR_SYMBOL in x;
+  }
+  /**
+   * The type of the error, defaults to "toolkit".
+   */
+  type;
+  constructor(message, type = "toolkit") {
+    super(message);
+    Object.setPrototypeOf(this, _ToolkitError.prototype);
+    Object.defineProperty(this, TOOLKIT_ERROR_SYMBOL, { value: true });
+    this.name = new.target.name;
+    this.type = type;
+  }
+};
+var AuthenticationError = class _AuthenticationError extends ToolkitError {
+  constructor(message) {
+    super(message, "authentication");
+    Object.setPrototypeOf(this, _AuthenticationError.prototype);
+    Object.defineProperty(this, AUTHENTICATION_ERROR_SYMBOL, { value: true });
+  }
+};
+var AssemblyError = class _AssemblyError extends ToolkitError {
+  constructor(message) {
+    super(message, "assembly");
+    Object.setPrototypeOf(this, _AssemblyError.prototype);
+    Object.defineProperty(this, ASSEMBLY_ERROR_SYMBOL, { value: true });
+  }
+};
+var ContextProviderError = class _ContextProviderError extends ToolkitError {
+  constructor(message) {
+    super(message, "context-provider");
+    Object.setPrototypeOf(this, _ContextProviderError.prototype);
+    Object.defineProperty(this, CONTEXT_PROVIDER_ERROR_SYMBOL, { value: true });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AssemblyError,
+  AuthenticationError,
+  ContextProviderError,
+  ToolkitError
+});
+//# sourceMappingURL=shared-public.js.map