@adobe-commerce/aio-toolkit 1.0.8 → 1.0.10

package/dist/index.mjs

@@ -1,10 +1,646 @@
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/framework/telemetry/helpers/input-error/index.ts
+var _TelemetryInputError, TelemetryInputError;
+var init_input_error = __esm({
+  "src/framework/telemetry/helpers/input-error/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    _TelemetryInputError = class _TelemetryInputError extends Error {
+      /**
+       * Creates a new TelemetryInputError
+       *
+       * @param message - Descriptive error message explaining the validation failure
+       */
+      constructor(message) {
+        super(message);
+        this.name = "TelemetryInputError";
+        if (Error.captureStackTrace) {
+          Error.captureStackTrace(this, _TelemetryInputError);
+        }
+      }
+    };
+    __name(_TelemetryInputError, "TelemetryInputError");
+    TelemetryInputError = _TelemetryInputError;
+  }
+});
+
+// src/framework/telemetry/new-relic/validator/index.ts
+var _NewRelicTelemetryValidator, NewRelicTelemetryValidator;
+var init_validator = __esm({
+  "src/framework/telemetry/new-relic/validator/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_input_error();
+    _NewRelicTelemetryValidator = class _NewRelicTelemetryValidator {
+      /**
+       * Checks if New Relic telemetry is configured
+       *
+       * Returns true if:
+       * - ENABLE_TELEMETRY is explicitly set to true
+       * - NEW_RELIC_TELEMETRY is explicitly set to true
+       *
+       * This method does NOT validate the completeness of configuration,
+       * it only checks if the provider is enabled.
+       *
+       * @param params - Runtime parameters to check
+       * @returns true if New Relic telemetry is enabled, false otherwise
+       *
+       * @example
+       * ```typescript
+       * const validator = new NewRelicTelemetryValidator();
+       * const params = { ENABLE_TELEMETRY: true, NEW_RELIC_TELEMETRY: true };
+       * if (validator.isConfigured(params)) {
+       *   // New Relic is enabled, proceed with initialization
+       * }
+       * ```
+       */
+      isConfigured(params) {
+        return params.ENABLE_TELEMETRY === true && params.NEW_RELIC_TELEMETRY === true;
+      }
+      /**
+       * Validates New Relic specific parameters
+       *
+       * IMPORTANT: Only call this method after checking isConfigured() returns true.
+       * This method assumes New Relic telemetry is enabled and validates that
+       * all required parameters are present.
+       *
+       * Required parameters when New Relic is enabled:
+       * - NEW_RELIC_SERVICE_NAME must be provided
+       * - NEW_RELIC_LICENSE_KEY must be provided
+       *
+       * @param params - Runtime parameters to validate
+       * @throws {TelemetryInputError} If NEW_RELIC_SERVICE_NAME is missing
+       * @throws {TelemetryInputError} If NEW_RELIC_LICENSE_KEY is missing
+       *
+       * @example
+       * ```typescript
+       * const validator = new NewRelicTelemetryValidator();
+       * const params = {
+       *   ENABLE_TELEMETRY: true,
+       *   NEW_RELIC_TELEMETRY: true,
+       *   NEW_RELIC_SERVICE_NAME: "my-service",
+       *   NEW_RELIC_LICENSE_KEY: "license-key"
+       * };
+       *
+       * if (validator.isConfigured(params)) {
+       *   validator.validateConfiguration(params); // Validates required fields
+       * }
+       * ```
+       */
+      validateConfiguration(params) {
+        if (params.NEW_RELIC_SERVICE_NAME === void 0 || params.NEW_RELIC_SERVICE_NAME === null || params.NEW_RELIC_SERVICE_NAME === "") {
+          throw new TelemetryInputError("NEW_RELIC_SERVICE_NAME is required");
+        }
+        if (params.NEW_RELIC_LICENSE_KEY === void 0 || params.NEW_RELIC_LICENSE_KEY === null || params.NEW_RELIC_LICENSE_KEY === "") {
+          throw new TelemetryInputError("NEW_RELIC_LICENSE_KEY is required");
+        }
+      }
+    };
+    __name(_NewRelicTelemetryValidator, "NewRelicTelemetryValidator");
+    NewRelicTelemetryValidator = _NewRelicTelemetryValidator;
+  }
+});
+
+// src/framework/telemetry/helpers/resource-factory/index.ts
+import { getAioRuntimeResource } from "@adobe/aio-lib-telemetry";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+var _ResourceFactory, ResourceFactory;
+var init_resource_factory = __esm({
+  "src/framework/telemetry/helpers/resource-factory/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    _ResourceFactory = class _ResourceFactory {
+      /**
+       * Creates a resource with custom environment attributes
+       *
+       * Starts with the base Adobe I/O Runtime resource and optionally
+       * merges environment attributes. These attributes are useful for
+       * filtering and correlating telemetry data by deployment environment.
+       *
+       * Note: Request-specific data (like request IDs) should NOT be added to
+       * Resources as they are created once and reused across all requests.
+       * Use log attributes or span attributes for request-specific data.
+       *
+       * @param params - Runtime parameters containing optional ENVIRONMENT
+       * @param params.ENVIRONMENT - Environment name (e.g., "dev", "stage", "prod")
+       * @returns OpenTelemetry Resource with custom attributes if provided
+       *
+       * @example Without custom attributes
+       * ```typescript
+       * const factory = new ResourceFactory();
+       * const resource = factory.createWithEnvironment({});
+       * // Returns base Adobe I/O Runtime resource
+       * ```
+       *
+       * @example With environment
+       * ```typescript
+       * const factory = new ResourceFactory();
+       * const params = { ENVIRONMENT: "production" };
+       * const resource = factory.createWithEnvironment(params);
+       * // Returns resource with environment="production" attribute
+       * ```
+       */
+      createWithEnvironment(params) {
+        const baseResource = getAioRuntimeResource();
+        const customAttributes = {};
+        if (params.ENVIRONMENT) {
+          customAttributes.environment = params.ENVIRONMENT;
+        }
+        if (Object.keys(customAttributes).length === 0) {
+          return baseResource;
+        }
+        const customResource = resourceFromAttributes(
+          customAttributes
+        );
+        return baseResource.merge(customResource);
+      }
+    };
+    __name(_ResourceFactory, "ResourceFactory");
+    ResourceFactory = _ResourceFactory;
+  }
+});
+
+// src/framework/telemetry/helpers/success-checker/index.ts
+var _SuccessChecker, SuccessChecker;
+var init_success_checker = __esm({
+  "src/framework/telemetry/helpers/success-checker/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    _SuccessChecker = class _SuccessChecker {
+      /**
+       * Determines if an action execution was successful
+       *
+       * Success criteria:
+       * - Response has statusCode 200
+       * - Body does not contain an exception operation
+       *
+       * @param result - The action execution result
+       * @returns true if successful, false otherwise
+       *
+       * @example Success case
+       * ```typescript
+       * const checker = new SuccessChecker();
+       * const result = { statusCode: 200, body: { data: 'success' } };
+       * checker.execute(result); // true
+       * ```
+       *
+       * @example Failure case - wrong status code
+       * ```typescript
+       * const checker = new SuccessChecker();
+       * const result = { statusCode: 500, body: { error: 'Internal error' } };
+       * checker.execute(result); // false
+       * ```
+       *
+       * @example Failure case - exception in body
+       * ```typescript
+       * const checker = new SuccessChecker();
+       * const result = { statusCode: 200, body: { op: 'exception', message: 'Error' } };
+       * checker.execute(result); // false
+       * ```
+       */
+      execute(result) {
+        if (!result || typeof result !== "object") {
+          return false;
+        }
+        const actionResult = result;
+        if (actionResult.statusCode !== 200) {
+          return false;
+        }
+        if (actionResult.body && typeof actionResult.body === "object") {
+          return actionResult.body.op !== "exception";
+        }
+        return true;
+      }
+    };
+    __name(_SuccessChecker, "SuccessChecker");
+    SuccessChecker = _SuccessChecker;
+  }
+});
+
+// src/framework/telemetry/helpers/json-message-processor/index.ts
+var _JsonMessageProcessor, JsonMessageProcessor;
+var init_json_message_processor = __esm({
+  "src/framework/telemetry/helpers/json-message-processor/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    _JsonMessageProcessor = class _JsonMessageProcessor {
+      /**
+       * Creates a new JsonMessageProcessor
+       *
+       * @param wrappedProcessor - The log processor to wrap and enhance
+       *
+       * @example
+       * ```typescript
+       * const exporter = new OTLPLogExporterProto({
+       *   url: "https://otlp.nr-data.net/v1/logs",
+       *   headers: { "api-key": licenseKey }
+       * });
+       * const baseProcessor = new SimpleLogRecordProcessor(exporter);
+       * const processor = new JsonMessageProcessor(baseProcessor);
+       * ```
+       */
+      constructor(wrappedProcessor) {
+        this.wrappedProcessor = wrappedProcessor;
+      }
+      /**
+       * Parse JavaScript object notation and convert to proper object
+       *
+       * Handles Winston's util.inspect format which produces JavaScript
+       * object literals instead of JSON strings.
+       *
+       * Examples:
+       * - { key: 'value' } → {"key":"value"}
+       * - { 'accept-encoding': 'gzip' } → {"accept-encoding":"gzip"}
+       *
+       * @param str - JavaScript object notation string
+       * @returns Parsed object
+       * @throws Error if parsing fails
+       * @private
+       */
+      parseJavaScriptObjectNotation(str) {
+        const func = new Function("return (" + str + ")");
+        return func();
+      }
+      /**
+       * Flatten nested objects into dot-notation keys
+       *
+       * Converts nested structures like:
+       * { headers: { accept: '*' } }
+       *
+       * Into flat structure:
+       * { 'headers.accept': '*' }
+       *
+       * This makes all attributes searchable in observability platforms.
+       *
+       * @param obj - Object to flatten
+       * @param prefix - Current key prefix (used in recursion)
+       * @returns Flattened object with dot-notation keys
+       * @private
+       */
+      flattenObject(obj, prefix = "") {
+        const flattened = {};
+        for (const [key, value] of Object.entries(obj)) {
+          const newKey = prefix ? `${prefix}.${key}` : key;
+          if (value === null || value === void 0) {
+            flattened[newKey] = value;
+          } else if (Array.isArray(value)) {
+            flattened[newKey] = JSON.stringify(value);
+          } else if (typeof value === "object") {
+            if (Object.keys(value).length === 0) {
+              continue;
+            }
+            const nested = this.flattenObject(value, newKey);
+            Object.assign(flattened, nested);
+          } else {
+            flattened[newKey] = value;
+          }
+        }
+        return flattened;
+      }
+      /**
+       * Processes a log record by parsing JSON messages and extracting attributes
+       *
+       * This method intercepts log records, attempts to parse structured data
+       * from the message body, and merges extracted properties as attributes.
+       * Additionally, it extracts the log level from the severity information
+       * and adds it as a 'level' attribute for easier querying.
+       *
+       * The enhanced log record is then passed to the wrapped processor.
+       *
+       * @param logRecord - The log record to process
+       *
+       * @remarks
+       * Processing steps:
+       * 1. Extract log level from severityText or severityNumber
+       * 2. Add 'level' attribute (debug, info, warn, error, etc.)
+       * 3. Parse JSON bodies that start with '{'
+       * 4. Extract properties as individual attributes
+       * 5. Preserve 'message' field as primary log body
+       *
+       * Error handling:
+       * - Silently handles parsing errors to avoid breaking the logging pipeline
+       * - Failed parsing results in unmodified log record
+       */
+      onEmit(logRecord) {
+        try {
+          if (logRecord.severityText) {
+            logRecord.setAttribute("level", logRecord.severityText.toLowerCase());
+          } else if (logRecord.severityNumber !== void 0) {
+            const levelName = this.mapSeverityNumberToLevel(logRecord.severityNumber);
+            if (levelName) {
+              logRecord.setAttribute("level", levelName);
+            }
+          }
+          const body = logRecord.body;
+          if (typeof body === "string" && body.trim().startsWith("{")) {
+            let parsed = null;
+            try {
+              parsed = JSON.parse(body);
+            } catch {
+              try {
+                parsed = this.parseJavaScriptObjectNotation(body);
+              } catch {
+              }
+            }
+            if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+              const messageValue = parsed.message;
+              const { message, ...attributesObj } = parsed;
+              const flattenedAttributes = this.flattenObject(attributesObj);
+              Object.entries(flattenedAttributes).forEach(([key, value]) => {
+                if (value !== void 0 && value !== null) {
+                  logRecord.setAttribute(key, value);
+                }
+              });
+              if (messageValue) {
+                logRecord.body = messageValue;
+              }
+            }
+          }
+        } catch {
+        }
+        this.wrappedProcessor.onEmit(logRecord);
+      }
+      /**
+       * Maps OpenTelemetry severity number to log level name
+       *
+       * OpenTelemetry defines severity numbers from 1-24:
+       * - 1-4: TRACE
+       * - 5-8: DEBUG
+       * - 9-12: INFO
+       * - 13-16: WARN
+       * - 17-20: ERROR
+       * - 21-24: FATAL
+       *
+       * @param severityNumber - OpenTelemetry severity number
+       * @returns Log level name (trace, debug, info, warn, error, fatal) or null
+       * @private
+       */
+      mapSeverityNumberToLevel(severityNumber) {
+        if (severityNumber >= 1 && severityNumber <= 4) return "trace";
+        if (severityNumber >= 5 && severityNumber <= 8) return "debug";
+        if (severityNumber >= 9 && severityNumber <= 12) return "info";
+        if (severityNumber >= 13 && severityNumber <= 16) return "warn";
+        if (severityNumber >= 17 && severityNumber <= 20) return "error";
+        if (severityNumber >= 21 && severityNumber <= 24) return "fatal";
+        return null;
+      }
+      /**
+       * Forces the processor to flush any pending log records
+       *
+       * Delegates to the wrapped processor's forceFlush method.
+       * Useful for ensuring logs are sent before application shutdown.
+       *
+       * @returns Promise that resolves when flush is complete
+       *
+       * @example
+       * ```typescript
+       * await processor.forceFlush();
+       * console.log("All logs have been sent");
+       * ```
+       */
+      async forceFlush() {
+        return this.wrappedProcessor.forceFlush();
+      }
+      /**
+       * Shuts down the processor and releases resources
+       *
+       * Delegates to the wrapped processor's shutdown method.
+       * Should be called when the application is terminating.
+       *
+       * @returns Promise that resolves when shutdown is complete
+       *
+       * @example
+       * ```typescript
+       * await processor.shutdown();
+       * console.log("Processor has been shut down");
+       * ```
+       */
+      async shutdown() {
+        return this.wrappedProcessor.shutdown();
+      }
+    };
+    __name(_JsonMessageProcessor, "JsonMessageProcessor");
+    JsonMessageProcessor = _JsonMessageProcessor;
+  }
+});
+
+// src/framework/telemetry/new-relic/index.ts
+var new_relic_exports = {};
+__export(new_relic_exports, {
+  default: () => new_relic_default
+});
+import {
+  defineTelemetryConfig,
+  getPresetInstrumentations,
+  instrumentEntrypoint
+} from "@adobe/aio-lib-telemetry";
+import {
+  OTLPLogExporterProto,
+  OTLPMetricExporterProto,
+  OTLPTraceExporterProto,
+  PeriodicExportingMetricReader,
+  SimpleLogRecordProcessor
+} from "@adobe/aio-lib-telemetry/otel";
+var _NewRelicTelemetry, NewRelicTelemetry, new_relic_default;
+var init_new_relic = __esm({
+  "src/framework/telemetry/new-relic/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_validator();
+    init_resource_factory();
+    init_success_checker();
+    init_json_message_processor();
+    _NewRelicTelemetry = class _NewRelicTelemetry {
+      /**
+       * Constructor for New Relic telemetry
+       *
+       * @description Constructor for New Relic telemetry
+       * @example
+       * ```typescript
+       * const telemetry = new NewRelicTelemetry();
+       * ```
+       */
+      constructor() {
+        this.validator = new NewRelicTelemetryValidator();
+        this.successChecker = new SuccessChecker();
+        this.resourceFactory = new ResourceFactory();
+      }
+      /**
+       * Checks if New Relic telemetry can be initialized
+       *
+       * Determines if New Relic telemetry is properly configured without actually
+       * attempting initialization. Useful for provider chain fallback logic.
+       *
+       * @param params - Runtime parameters to check
+       * @returns true if New Relic is configured and can be initialized
+       *
+       * @example
+       * ```typescript
+       * const telemetry = new NewRelicTelemetry();
+       * if (telemetry.canInitialize(params)) {
+       *   // New Relic is configured, use it
+       * } else {
+       *   // Try next provider
+       * }
+       * ```
+       */
+      canInitialize(params) {
+        return this.validator.isConfigured(params);
+      }
+      /**
+       * Get the OpenTelemetry instrumentation configuration for New Relic
+       *
+       * Builds and returns the complete instrumentation configuration including:
+       * - Service name and preset instrumentations
+       * - Custom resource attributes (environment)
+       * - OTLP exporters for traces, metrics, and logs
+       * - Success/failure detection for actions
+       *
+       * This method is called internally by `instrumentEntrypoint` to configure
+       * telemetry before wrapping the action.
+       *
+       * @returns Complete entrypoint instrumentation configuration
+       * @throws {TelemetryInputError} If required parameters are missing (service name, license key)
+       *
+       * @example
+       * ```typescript
+       * const telemetry = new NewRelicTelemetry();
+       * const config = telemetry.getConfig();
+       * // Returns configuration with exporters, instrumentations, and resource attributes
+       * ```
+       */
+      getConfig() {
+        return {
+          ...defineTelemetryConfig((params) => {
+            if (!this.validator.isConfigured(params)) {
+              throw new Error("New Relic telemetry is not configured");
+            }
+            this.validator.validateConfiguration(params);
+            const serviceName = params.NEW_RELIC_SERVICE_NAME;
+            return {
+              sdkConfig: {
+                serviceName,
+                instrumentations: getPresetInstrumentations("simple"),
+                resource: this.resourceFactory.createWithEnvironment(params),
+                ...this.getExportersConfig(params)
+              }
+            };
+          }),
+          isSuccessful: this.successChecker.execute.bind(this.successChecker)
+        };
+      }
+      /**
+       * Configure New Relic exporters for traces, metrics, and logs
+       *
+       * Creates OTLP exporters for all three signal types (traces, metrics, logs)
+       * and configures them to send data to New Relic. Log processors are wrapped
+       * with JsonMessageProcessor for better attribute extraction.
+       *
+       * @param params - Runtime parameters containing NEW_RELIC_LICENSE_KEY and optional NEW_RELIC_URL
+       * @returns Configuration object with traceExporter, metricReaders, and logRecordProcessors
+       * @private
+       */
+      getExportersConfig(params) {
+        const licenseKey = params.NEW_RELIC_LICENSE_KEY;
+        const newRelicUrl = params.NEW_RELIC_URL || "https://otlp.nr-data.net";
+        const makeExporterConfig = /* @__PURE__ */ __name((endpoint) => {
+          return {
+            url: `${newRelicUrl}/${endpoint}`,
+            headers: {
+              "api-key": licenseKey
+            }
+          };
+        }, "makeExporterConfig");
+        return {
+          traceExporter: new OTLPTraceExporterProto(makeExporterConfig("v1/traces")),
+          metricReaders: [
+            new PeriodicExportingMetricReader({
+              exporter: new OTLPMetricExporterProto(makeExporterConfig("v1/metrics"))
+            })
+          ],
+          logRecordProcessors: [
+            new JsonMessageProcessor(
+              new SimpleLogRecordProcessor(new OTLPLogExporterProto(makeExporterConfig("v1/logs")))
+            )
+          ]
+        };
+      }
+      /**
+       * Initialize telemetry instrumentation for a runtime action
+       *
+       * Wraps the provided action with OpenTelemetry instrumentation using
+       * New Relic as the backend. The instrumented action will automatically:
+       * - Create spans for the action execution
+       * - Export metrics during runtime
+       * - Forward logs to New Relic
+       * - Track success/failure status
+       *
+       * This method delegates to `instrumentEntrypoint` from `@adobe/aio-lib-telemetry`,
+       * passing the action and New Relic specific configuration.
+       *
+       * @param action - The runtime action function to instrument
+       * @returns The instrumented action function with telemetry enabled
+       * @throws {TelemetryInputError} If required configuration is missing
+       *
+       * @example
+       * ```typescript
+       * async function myAction(params: Record<string, unknown>) {
+       *   const logger = Telemetry.createLogger("my-action", params);
+       *   logger.info("Processing request");
+       *
+       *   return { statusCode: 200, body: { success: true } };
+       * }
+       *
+       * const telemetry = new NewRelicTelemetry();
+       * const instrumentedAction = telemetry.initialize(myAction);
+       *
+       * // instrumentedAction now sends traces, metrics, and logs to New Relic
+       * export const main = instrumentedAction;
+       * ```
+       */
+      initialize(action) {
+        return instrumentEntrypoint(action, this.getConfig());
+      }
+    };
+    __name(_NewRelicTelemetry, "NewRelicTelemetry");
+    NewRelicTelemetry = _NewRelicTelemetry;
+    new_relic_default = NewRelicTelemetry;
+  }
+});
+
+// src/index.ts
+init_esm_shims();
+
+// src/framework/index.ts
+init_esm_shims();
 
 // src/framework/runtime-action/index.ts
-import { Core } from "@adobe/aio-sdk";
+init_esm_shims();
+
+// src/framework/runtime-action/response/index.ts
+init_esm_shims();
 
 // src/framework/runtime-action/types.ts
+init_esm_shims();
 var HttpStatus = /* @__PURE__ */ ((HttpStatus2) => {
   HttpStatus2[HttpStatus2["OK"] = 200] = "OK";
   HttpStatus2[HttpStatus2["BAD_REQUEST"] = 400] = "BAD_REQUEST";
@@ -66,29 +702,8 @@ __name(_RuntimeActionResponse, "RuntimeActionResponse");
 var RuntimeActionResponse = _RuntimeActionResponse;
 var response_default = RuntimeActionResponse;
 
-// src/framework/runtime-action/parameters/index.ts
-var _Parameters = class _Parameters {
-  /**
-   * Returns a log-ready string of the action input parameters.
-   * The `Authorization` header content will be replaced by '<hidden>'.
-   *
-   * @param params action input parameters.
-   *
-   * @returns string
-   */
-  static stringify(params) {
-    let headers = params.__ow_headers || {};
-    if (headers.authorization) {
-      headers = { ...headers, authorization: "<hidden>" };
-    }
-    return JSON.stringify({ ...params, __ow_headers: headers });
-  }
-};
-__name(_Parameters, "Parameters");
-var Parameters = _Parameters;
-var parameters_default = Parameters;
-
 // src/framework/runtime-action/validator/index.ts
+init_esm_shims();
 var _Validator = class _Validator {
   /**
    * Returns the list of missing keys given an object and its required keys.
@@ -153,91 +768,582 @@ __name(_Validator, "Validator");
 var Validator = _Validator;
 var validator_default = Validator;
 
+// src/framework/telemetry/index.ts
+init_esm_shims();
+import { Core } from "@adobe/aio-sdk";
+var _Telemetry = class _Telemetry {
+  /**
+   * Create a logger with standard configuration and automatic metadata injection.
+   *
+   * This method creates a structured logger and wraps it to automatically add
+   * contextual metadata to all log calls:
+   * - `x-adobe-commerce-request-id`: Extracted from `__ow_headers` (when present)
+   * - `action.type`: Extracted from `params.action_type` (when present)
+   *
+   * If ENABLE_TELEMETRY is true, uses OpenTelemetry logger (lazy-loaded); otherwise uses Core.Logger.
+   * The environment from params.ENVIRONMENT is set at the resource level and will
+   * automatically appear in all logs sent to New Relic if ENABLE_TELEMETRY is true.
+   *
+   * @param name - Logger name (typically action name)
+   * @param params - Runtime parameters containing LOG_LEVEL, optional ENABLE_TELEMETRY, ENVIRONMENT, action_type, and __ow_headers
+   * @returns Configured logger instance with automatic metadata injection
+   *
+   * @example Basic string message
+   * ```typescript
+   * const logger = Telemetry.createLogger("my-action", params);
+   * logger.info("Processing started");
+   * // Logs: "Processing started"
+   * ```
+   *
+   * @example JSON object message with automatic metadata
+   * ```typescript
+   * const logger = Telemetry.createLogger("my-action", {
+   *   ...params,
+   *   action_type: "webhook",
+   *   __ow_headers: { 'x-adobe-commerce-request-id': 'req-123' }
+   * });
+   * logger.info({
+   *   message: "User action completed",
+   *   user_id: "123"
+   * });
+   * // In New Relic: {
+   * //   message: "User action completed",
+   * //   user_id: "123",
+   * //   "x-adobe-commerce-request-id": "req-123",
+   * //   "action.type": "webhook",
+   * //   environment: "development",
+   * //   ...
+   * // }
+   * ```
+   */
+  static createLogger(name, params) {
+    const logLevel = params.LOG_LEVEL || "info";
+    if (!params.ENABLE_TELEMETRY) {
+      const baseLogger = Core.Logger(name, { level: logLevel });
+      return _Telemetry.wrapLogger(baseLogger, params);
+    }
+    let telemetryLogger = null;
+    let loadingPromise = null;
+    const fallbackLogger = Core.Logger(name, { level: logLevel });
+    const loadTelemetryLogger = /* @__PURE__ */ __name(async () => {
+      if (telemetryLogger || loadingPromise) {
+        return;
+      }
+      loadingPromise = (async () => {
+        try {
+          const { getLogger } = await import("@adobe/aio-lib-telemetry");
+          telemetryLogger = getLogger(name, { level: logLevel });
+        } catch (error) {
+          telemetryLogger = fallbackLogger;
+        }
+      })();
+      await loadingPromise;
+    }, "loadTelemetryLogger");
+    loadTelemetryLogger().catch(() => {
+    });
+    const proxyLogger = {
+      debug: /* @__PURE__ */ __name((message) => {
+        const logger = telemetryLogger || fallbackLogger;
+        logger.debug(message);
+      }, "debug"),
+      info: /* @__PURE__ */ __name((message) => {
+        const logger = telemetryLogger || fallbackLogger;
+        logger.info(message);
+      }, "info"),
+      warn: /* @__PURE__ */ __name((message) => {
+        const logger = telemetryLogger || fallbackLogger;
+        logger.warn(message);
+      }, "warn"),
+      error: /* @__PURE__ */ __name((message) => {
+        const logger = telemetryLogger || fallbackLogger;
+        logger.error(message);
+      }, "error")
+    };
+    return _Telemetry.wrapLogger(proxyLogger, params);
+  }
+  /**
+   * Wrap a logger with automatic metadata injection
+   *
+   * @private
+   * @param baseLogger - The base logger to wrap
+   * @param params - Runtime parameters containing optional metadata
+   * @returns Wrapped logger with metadata injection
+   */
+  static wrapLogger(baseLogger, params) {
+    const metadata = {};
+    const headers = params.__ow_headers;
+    const requestId = headers?.["x-adobe-commerce-request-id"];
+    if (requestId && requestId !== "") {
+      metadata["x-adobe-commerce-request-id"] = requestId;
+    }
+    const actionType = params.action_type;
+    if (actionType && actionType !== "") {
+      metadata["action.type"] = actionType;
+    }
+    if (Object.keys(metadata).length === 0) {
+      return baseLogger;
+    }
+    const wrapper = {
+      debug: /* @__PURE__ */ __name((message) => {
+        if (typeof message === "object" && message !== null) {
+          baseLogger.debug({ ...metadata, ...message });
+        } else {
+          baseLogger.debug(message);
+        }
+      }, "debug"),
+      info: /* @__PURE__ */ __name((message) => {
+        if (typeof message === "object" && message !== null) {
+          baseLogger.info({ ...metadata, ...message });
+        } else {
+          baseLogger.info(message);
+        }
+      }, "info"),
+      warn: /* @__PURE__ */ __name((message) => {
+        if (typeof message === "object" && message !== null) {
+          baseLogger.warn({ ...metadata, ...message });
+        } else {
+          baseLogger.warn(message);
+        }
+      }, "warn"),
+      error: /* @__PURE__ */ __name((message) => {
+        if (typeof message === "object" && message !== null) {
+          baseLogger.error({ ...metadata, ...message });
+        } else {
+          baseLogger.error(message);
+        }
+      }, "error")
+    };
+    return {
+      ...baseLogger,
+      ...wrapper
+    };
+  }
+  /**
+   * Extract structured error information for logging
+   *
+   * Converts Error objects into a structured format suitable for logging
+   * and telemetry systems like New Relic.
+   *
+   * @param error - Error object or unknown error value
+   * @returns Structured error object with name, message, and stack trace
+   *
+   * @example
+   * ```typescript
+   * try {
+   *   // some operation
+   * } catch (error) {
+   *   logger.error("Operation failed", Telemetry.formatError(error));
+   * }
+   * ```
+   */
+  static formatError(error) {
+    if (error instanceof Error) {
+      return {
+        error_name: error.name,
+        error_message: error.message,
+        error_stack: error.stack
+      };
+    }
+    return { error: String(error) };
+  }
+  /**
+   * Initialize telemetry for a runtime action with provider fallback chain
+   *
+   * Attempts to initialize telemetry providers in the following order:
+   * 1. New Relic (if NEW_RELIC_TELEMETRY=true)
+   * 2. Grafana (if GRAFANA_TELEMETRY=true) - Future support
+   * 3. Original action (no telemetry)
+   *
+   * Telemetry initialization is deferred to runtime when params are available.
+   * This allows proper configuration detection and graceful fallback to the
+   * next provider in the chain.
+   *
+   * **IMPORTANT**: If a provider is explicitly enabled (e.g., NEW_RELIC_TELEMETRY=true)
+   * but has invalid configuration (missing API key, service name), a 500 error response
+   * is returned to alert you of the misconfiguration. This prevents silently running
+   * without telemetry when you expect it to be working.
+   *
+   * Environment Configuration:
+   * Pass params.ENVIRONMENT to set the environment field in all logs.
+   * This can be set via environment variables in your action configuration.
+   *
+   * @param action - The runtime action function to instrument
+   * @returns The instrumented action ready for export
+   *
+   * @example Single provider (New Relic) - Valid configuration
+   * ```typescript
+   * // Environment:
+   * // ENABLE_TELEMETRY=true
+   * // NEW_RELIC_TELEMETRY=true
+   * // NEW_RELIC_SERVICE_NAME=my-service
+   * // NEW_RELIC_LICENSE_KEY=xxxxx
+   *
+   * export const main = Telemetry.initialize(myAction);
+   * // ✅ Uses New Relic telemetry
+   * ```
+   *
+   * @example New Relic enabled but misconfigured - Returns error response
+   * ```typescript
+   * // Environment:
+   * // ENABLE_TELEMETRY=true
+   * // NEW_RELIC_TELEMETRY=true
+   * // NEW_RELIC_SERVICE_NAME=my-service
+   * // Missing NEW_RELIC_LICENSE_KEY!
+   *
+   * export const main = Telemetry.initialize(myAction);
+   * // ❌ Returns { error: { statusCode: 500, body: { error: "Telemetry configuration error: NEW_RELIC_LICENSE_KEY is required" } } }
+   * // This is intentional - you want to know your telemetry config is broken!
+   * ```
+   *
+   * @example Multi-provider fallback
+   * ```typescript
+   * // Environment:
+   * // ENABLE_TELEMETRY=true
+   * // NEW_RELIC_TELEMETRY=false  // Skip New Relic
+   * // GRAFANA_TELEMETRY=true      // Use Grafana instead
+   *
+   * export const main = Telemetry.initialize(myAction);
+   * // ✅ Skips New Relic, tries Grafana (when implemented)
+   * ```
+   *
+   * @example No telemetry
+   * ```typescript
+   * // Environment:
+   * // ENABLE_TELEMETRY=false (or not set)
+   *
+   * export const main = Telemetry.initialize(myAction);
+   * // ✅ Returns original action without instrumentation
+   * ```
+   */
+  static initialize(action) {
+    return async (params) => {
+      if (params.ENABLE_TELEMETRY && params.NEW_RELIC_TELEMETRY) {
+        try {
+          const { default: NewRelicTelemetry2 } = await Promise.resolve().then(() => (init_new_relic(), new_relic_exports));
+          const newRelicTelemetry = new NewRelicTelemetry2();
+          if (newRelicTelemetry.canInitialize(params)) {
+            try {
+              const instrumentedAction = newRelicTelemetry.initialize(action);
+              return await instrumentedAction(params);
+            } catch (error) {
+              const errorMessage = error instanceof Error ? error.message : "Telemetry initialization failed";
+              return response_default.error(
+                500 /* INTERNAL_ERROR */,
+                `Telemetry configuration error: ${errorMessage}`
+              );
+            }
+          }
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : "Failed to load telemetry module";
+          return response_default.error(
+            500 /* INTERNAL_ERROR */,
+            `Telemetry module error: ${errorMessage}`
+          );
+        }
+      }
+      return action(params);
+    };
+  }
+};
+__name(_Telemetry, "Telemetry");
+var Telemetry = _Telemetry;
+var telemetry_default = Telemetry;
+
 // src/framework/runtime-action/index.ts
 var _RuntimeAction = class _RuntimeAction {
   /**
-   * @param name
-   * @param httpMethods
-   * @param requiredParams
-   * @param requiredHeaders
-   * @param action
-   * @returns {(function(*): Promise<any>)|*}
+   * Sets the action type for the next action execution
+   * This is used for logging to identify different action types
+   * (runtime-action, webhook-action, event-consumer-action, etc.)
+   *
+   * @param type - The action type identifier
+   */
+  static setActionType(type) {
+    _RuntimeAction.actionType = type;
+  }
+  /**
+   * Gets the current action type
+   * @returns The current action type identifier
+   */
+  static getActionType() {
+    return _RuntimeAction.actionType;
+  }
+  /**
+   * Creates a runtime action handler with validation, logging, and telemetry
+   *
+   * Wraps a user-defined action function with standardized runtime functionality:
+   * 1. Creates a structured logger with telemetry integration
+   * 2. Logs action start, headers, and body at debug level
+   * 3. Validates required parameters, headers, and HTTP methods
+   * 4. Executes the user action with logger and headers context
+   * 5. Logs the result and handles errors with appropriate status codes
+   * 6. Integrates with OpenTelemetry for distributed tracing
+   *
+   * @param name - Action name used for logging and telemetry spans (default: 'main')
+   * @param httpMethods - Allowed HTTP methods (GET, POST, etc.). Empty array allows all methods
+   * @param requiredParams - Required parameter names in the request body
+   * @param requiredHeaders - Required header names (case-insensitive)
+   * @param action - User-defined action function that receives:
+   *   - params: All request parameters including __ow_* runtime parameters
+   *   - ctx: Context object with logger and headers
+   * @returns Wrapped action function ready to be exported as Adobe I/O Runtime entrypoint
+   *
+   * @example With All Options
+   * ```typescript
+   * const handler = RuntimeAction.execute(
+   *   'processOrder',
+   *   [HttpMethod.POST],
+   *   ['orderId', 'customerId'],
+   *   ['authorization', 'x-api-key'],
+   *   async (params, { logger, headers }) => {
+   *     const { orderId, customerId } = params;
+   *     logger.info({ message: 'Processing order', orderId, customerId });
+   *
+   *     // Your business logic here
+   *     const result = await processOrderLogic(orderId, customerId);
+   *
+   *     return {
+   *       statusCode: 200,
+   *       body: { orderId, status: 'processed', result }
+   *     };
+   *   }
+   * );
+   * ```
+   *
+   * @example Minimal Configuration
+   * ```typescript
+   * const handler = RuntimeAction.execute('simpleAction', [], [], [], async (params, { logger }) => {
+   *   logger.info('Simple action executed');
+   *   return { statusCode: 200, body: { message: 'Success' } };
+   * });
+   * ```
    */
   static execute(name = "main", httpMethods = [], requiredParams = [], requiredHeaders = [], action = async (_params) => {
     return { statusCode: 200 /* OK */, body: {} };
   }) {
-    return async (params) => {
-      const logger = Core.Logger(name, { level: params.LOG_LEVEL || "info" });
+    const runtimeAction = /* @__PURE__ */ __name(async (params) => {
+      if (!params.action_type) {
+        params.action_type = _RuntimeAction.getActionType();
+      }
+      const logger = telemetry_default.createLogger(name, params);
       try {
-        logger.info(`Calling the ${name} action`);
-        logger.debug(parameters_default.stringify(params));
+        logger.debug({
+          message: `${name}-started`,
+          action_name: name
+        });
+        logger.debug({
+          message: `${name}-headers`,
+          headers: params.__ow_headers || {}
+        });
+        logger.debug({
+          message: `${name}-body`,
+          body: params.__ow_body || {}
+        });
         const validationError = _RuntimeAction.validateRequest(
           params,
           requiredParams,
           requiredHeaders,
           httpMethods,
-          logger
+          logger,
+          name
         );
         if (validationError) {
           return validationError;
         }
         const result = await action(params, { logger, headers: params.__ow_headers || {} });
-        logger.info(result);
+        logger.debug({
+          message: `${name}-completed`,
+          result
+        });
         return result;
       } catch (error) {
-        logger.error(error);
+        if (error instanceof Error) {
+          logger.error({
+            message: `${name}-failed`,
+            error: error.message,
+            stack: error.stack
+          });
+        } else {
+          logger.error({
+            message: `${name}-failed`,
+            error
+          });
+        }
         return response_default.error(500 /* INTERNAL_ERROR */, "server error");
       }
-    };
+    }, "runtimeAction");
+    return telemetry_default.initialize(runtimeAction);
   }
-  static validateRequest(params, requiredParams, requiredHeaders, httpMethods, logger) {
+  /**
+   * Validates incoming request against required parameters, headers, and HTTP methods
+   *
+   * This private method performs comprehensive request validation:
+   * 1. Checks for missing required parameters in the request body
+   * 2. Checks for missing required headers (case-insensitive)
+   * 3. Validates the HTTP method against allowed methods list
+   *
+   * @param params - Request parameters including __ow_* runtime parameters
+   * @param requiredParams - List of required parameter names to validate
+   * @param requiredHeaders - List of required header names to validate (case-insensitive)
+   * @param httpMethods - Allowed HTTP methods. Empty array skips HTTP method validation
+   * @param logger - Logger instance for error logging (child logger with request ID if present)
+   * @param name - Action name for logging
+   * @returns RuntimeActionResponseType with error details if validation fails, null if valid
+   *
+   * @private
+   *
+   * @example Validation Error Response
+   * ```typescript
+   * // Missing parameter returns:
+   * {
+   *   statusCode: 400,
+   *   body: { error: 'Missing required parameter: userId' }
+   * }
+   *
+   * // Invalid HTTP method returns:
+   * {
+   *   statusCode: 405,
+   *   body: { error: 'Invalid HTTP method: DELETE. Allowed methods are: GET, POST' }
+   * }
+   * ```
+   */
+  static validateRequest(params, requiredParams, requiredHeaders, httpMethods, logger, name) {
     const errorMessage = validator_default.checkMissingRequestInputs(params, requiredParams, requiredHeaders) ?? "";
     if (errorMessage) {
+      logger.error({
+        message: `${name}-validation-failed`,
+        error: errorMessage
+      });
       return response_default.error(400 /* BAD_REQUEST */, errorMessage);
     }
     const requestMethod = params.__ow_method?.toUpperCase();
     if (httpMethods.length > 0 && !httpMethods.includes(requestMethod)) {
       const errorMessage2 = `Invalid HTTP method: ${params.__ow_method}. Allowed methods are: ${httpMethods.join(", ")}`;
-      logger.error(errorMessage2);
+      logger.error({
+        message: `${name}-validation-failed`,
+        error: errorMessage2
+      });
       return response_default.error(405 /* METHOD_NOT_ALLOWED */, errorMessage2);
     }
     return null;
   }
 };
 __name(_RuntimeAction, "RuntimeAction");
+/**
+ * Private static property to store the action type for logging
+ * Can be set using setActionType() before calling execute()
+ */
+_RuntimeAction.actionType = "runtime-action";
 var RuntimeAction = _RuntimeAction;
 var runtime_action_default = RuntimeAction;
 
+// src/framework/runtime-action/response/types.ts
+init_esm_shims();
+
+// src/framework/runtime-action/parameters/index.ts
+init_esm_shims();
+var _Parameters = class _Parameters {
+  /**
+   * Returns a log-ready string of the action input parameters.
+   * The `Authorization` header content will be replaced by '<hidden>'.
+   *
+   * @param params action input parameters.
+   *
+   * @returns string
+   */
+  static stringify(params) {
+    let headers = params.__ow_headers || {};
+    if (headers.authorization) {
+      headers = { ...headers, authorization: "<hidden>" };
+    }
+    return JSON.stringify({ ...params, __ow_headers: headers });
+  }
+};
+__name(_Parameters, "Parameters");
+var Parameters = _Parameters;
+var parameters_default = Parameters;
+
 // src/framework/event-consumer-action/index.ts
-import { Core as Core2 } from "@adobe/aio-sdk";
+init_esm_shims();
 var _EventConsumerAction = class _EventConsumerAction {
   /**
-   * @param name
-   * @param requiredParams
-   * @param requiredHeaders
-   * @param action
-   * @returns {(function(*): Promise<any>)|*}
+   * Creates an event consumer action handler with telemetry integration
+   *
+   * This method wraps a user-defined action with:
+   * - Structured logging (all logs automatically include x-adobe-commerce-request-id if present)
+   * - Request validation for required parameters and headers
+   * - OpenTelemetry instrumentation
+   * - Standardized error handling
+   *
+   * @param name - Action name for logging and observability
+   * @param requiredParams - List of required parameter names to validate
+   * @param requiredHeaders - List of required header names to validate (case-insensitive)
+   * @param action - User's event consumer function that receives params and context
+   * @returns Wrapped action handler ready for OpenWhisk runtime
+   *
+   * @example
+   * ```typescript
+   * const handler = EventConsumerAction.execute(
+   *   'webhook-processor',
+   *   ['eventType', 'eventData'],
+   *   ['x-webhook-signature'],
+   *   async (params, { logger, headers }) => {
+   *     logger.info({
+   *       message: 'Processing webhook',
+   *       eventType: params.eventType
+   *     });
+   *     // Process event...
+   *     return { statusCode: 200, body: { processed: true } };
+   *   }
+   * );
+   * ```
    */
   static execute(name = "main", requiredParams = [], requiredHeaders = [], action = async (_params) => {
     return { statusCode: 200 /* OK */, body: {} };
   }) {
-    return async (params) => {
-      const logger = Core2.Logger(name, { level: params.LOG_LEVEL || "info" });
+    const eventConsumerAction = /* @__PURE__ */ __name(async (params) => {
+      params.action_type = "event-consumer-action";
+      const logger = telemetry_default.createLogger(name, params);
       try {
-        logger.info(`Calling the ${name} action`);
-        logger.debug(parameters_default.stringify(params));
+        logger.debug({
+          message: `${name}-started`,
+          action_name: name
+        });
+        logger.debug({
+          message: `${name}-headers`,
+          headers: params.__ow_headers || {}
+        });
+        logger.debug({
+          message: `${name}-parameters`,
+          parameters: params
+        });
         const errorMessage = validator_default.checkMissingRequestInputs(params, requiredParams, requiredHeaders) || "";
         if (errorMessage) {
+          logger.error({
+            message: `${name}-validation-failed`,
+            error: errorMessage
+          });
           return response_default.error(400 /* BAD_REQUEST */, errorMessage);
         }
         const result = await action(params, { logger, headers: params.__ow_headers || {} });
-        logger.info(result);
+        logger.debug({
+          message: `${name}-completed`,
+          result
+        });
         return result;
       } catch (error) {
-        logger.error(error);
+        if (error instanceof Error) {
+          logger.error({
+            error: error.message,
+            stack: error.stack
+          });
+        } else {
+          logger.error({ error });
+        }
         return response_default.error(500 /* INTERNAL_ERROR */, "server error");
       }
-    };
+    }, "eventConsumerAction");
+    return telemetry_default.initialize(eventConsumerAction);
   }
 };
 __name(_EventConsumerAction, "EventConsumerAction");
@@ -245,6 +1351,7 @@ var EventConsumerAction = _EventConsumerAction;
 var event_consumer_action_default = EventConsumerAction;
 
 // src/framework/graphql-action/index.ts
+init_esm_shims();
 import { graphql, buildSchema, parse, validate } from "graphql";
 var _GraphQlAction = class _GraphQlAction {
   static execute(schema = `
@@ -322,6 +1429,7 @@ var GraphQlAction = _GraphQlAction;
 var graphql_action_default = GraphQlAction;
 
 // src/framework/openwhisk/index.ts
+init_esm_shims();
 import openwhisk from "openwhisk";
 var _Openwhisk = class _Openwhisk {
   /**
@@ -349,29 +1457,84 @@ var Openwhisk = _Openwhisk;
 var openwhisk_default = Openwhisk;
 
 // src/framework/openwhisk-action/index.ts
-import { Core as Core3 } from "@adobe/aio-sdk";
+init_esm_shims();
 var _OpenwhiskAction = class _OpenwhiskAction {
   /**
-   * @param name
-   * @param action
-   * @returns {(function(*): Promise<any>)|*}
+   * Creates an OpenWhisk webhook action handler with logging and telemetry
+   *
+   * Wraps a user-defined action function with standardized runtime functionality:
+   * 1. Creates a structured logger with telemetry integration
+   * 2. Logs action start with structured data
+   * 3. Logs request parameters at debug level
+   * 4. Executes the user action with logger and headers context
+   * 5. Logs the result and handles errors with appropriate status codes
+   * 6. Integrates with OpenTelemetry for distributed tracing
+   *
+   * The logger automatically includes x-adobe-commerce-request-id and action.type
+   * (if present) in all log messages.
+   *
+   * @param name - Action name used for logging and telemetry spans (default: 'main')
+   * @param action - User-defined action function that receives:
+   *   - params: All request parameters including __ow_* runtime parameters
+   *   - ctx: Context object with logger and headers
+   * @returns Wrapped action function ready to be exported as Adobe I/O Runtime entrypoint
+   *
+   * @example Complete Example
+   * ```typescript
+   * const handler = OpenwhiskAction.execute(
+   *   'processWebhook',
+   *   async (params, { logger, headers }) => {
+   *     logger.info({ message: 'Webhook received', event: params.event });
+   *
+   *     // Your webhook processing logic here
+   *     const result = await processWebhookData(params);
+   *
+   *     return {
+   *       statusCode: 200,
+   *       body: { status: 'processed', result }
+   *     };
+   *   }
+   * );
+   * ```
    */
   static execute(name = "main", action = async (_params) => {
     return { statusCode: 200 /* OK */, body: {} };
   }) {
-    return async (params) => {
-      const logger = Core3.Logger(name, { level: params.LOG_LEVEL || "info" });
+    const openwhiskAction = /* @__PURE__ */ __name(async (params) => {
+      params.action_type = "openwhisk-action";
+      const logger = telemetry_default.createLogger(name, params);
       try {
-        logger.info(`Calling the ${name} webhook action`);
-        logger.debug(parameters_default.stringify(params));
+        logger.debug({
+          message: `${name}-started`,
+          action_name: name
+        });
+        logger.debug({
+          message: `${name}-params`,
+          params
+        });
         const result = await action(params, { logger, headers: params.__ow_headers || {} });
-        logger.info(result);
+        logger.debug({
+          message: `${name}-completed`,
+          result
+        });
         return result;
       } catch (error) {
-        logger.error(error);
+        if (error instanceof Error) {
+          logger.error({
+            message: `${name}-failed`,
+            error: error.message,
+            stack: error.stack
+          });
+        } else {
+          logger.error({
+            message: `${name}-failed`,
+            error
+          });
+        }
         return response_default.error(500 /* INTERNAL_ERROR */, "server error");
       }
-    };
+    }, "openwhiskAction");
+    return telemetry_default.initialize(openwhiskAction);
   }
 };
 __name(_OpenwhiskAction, "OpenwhiskAction");
@@ -379,6 +1542,7 @@ var OpenwhiskAction = _OpenwhiskAction;
 var openwhisk_action_default = OpenwhiskAction;
 
 // src/framework/repository/file-repository/index.ts
+init_esm_shims();
 import { Files } from "@adobe/aio-sdk";
 var _FileRepository = class _FileRepository {
   /**
@@ -535,12 +1699,17 @@ __name(_FileRepository, "FileRepository");
 var FileRepository = _FileRepository;
 var file_repository_default = FileRepository;
 
+// src/framework/repository/file-repository/types.ts
+init_esm_shims();
+
 // src/framework/publish-event/index.ts
+init_esm_shims();
 import { Events } from "@adobe/aio-sdk";
 import { CloudEvent } from "cloudevents";
 import { v4 as uuidv4 } from "uuid";
 
 // src/framework/custom-logger/index.ts
+init_esm_shims();
 var _CustomLogger = class _CustomLogger {
   /**
    * @param logger - External logger instance (can be null)
@@ -675,7 +1844,17 @@ __name(_PublishEvent, "PublishEvent");
 var PublishEvent = _PublishEvent;
 var publish_event_default = PublishEvent;
 
+// src/framework/publish-event/types.ts
+init_esm_shims();
+
+// src/framework/webhook-action/index.ts
+init_esm_shims();
+
+// src/framework/webhook-action/response/index.ts
+init_esm_shims();
+
 // src/framework/webhook-action/response/types.ts
+init_esm_shims();
 var WebhookActionOperation = /* @__PURE__ */ ((WebhookActionOperation2) => {
   WebhookActionOperation2["SUCCESS"] = "success";
   WebhookActionOperation2["EXCEPTION"] = "exception";
@@ -782,10 +1961,10 @@ var _WebhookActionResponse = class _WebhookActionResponse {
    * });
    * ```
    */
-  static add(path, value, instance) {
+  static add(path2, value, instance) {
     const response = {
       op: "add" /* ADD */,
-      path,
+      path: path2,
       value
     };
     if (instance !== void 0) {
@@ -821,10 +2000,10 @@ var _WebhookActionResponse = class _WebhookActionResponse {
    * });
    * ```
    */
-  static replace(path, value, instance) {
+  static replace(path2, value, instance) {
     const response = {
       op: "replace" /* REPLACE */,
-      path,
+      path: path2,
       value
     };
     if (instance !== void 0) {
@@ -862,10 +2041,10 @@ var _WebhookActionResponse = class _WebhookActionResponse {
    * };
    * ```
    */
-  static remove(path) {
+  static remove(path2) {
     return {
       op: "remove" /* REMOVE */,
-      path
+      path: path2
     };
   }
 };
@@ -874,6 +2053,7 @@ var WebhookActionResponse = _WebhookActionResponse;
 var response_default2 = WebhookActionResponse;
 
 // src/framework/webhook-action/types.ts
+init_esm_shims();
 var SignatureVerification = /* @__PURE__ */ ((SignatureVerification2) => {
   SignatureVerification2["ENABLED"] = "enabled";
   SignatureVerification2["DISABLED"] = "disabled";
@@ -924,9 +2104,14 @@ var _WebhookAction = class _WebhookAction {
       return null;
     }, "verifySignature");
     const callback = /* @__PURE__ */ __name(async (params, ctx) => {
+      const { logger } = ctx;
       if (signatureVerification === "enabled" /* ENABLED */) {
         const verificationErrorMessage = await verifySignature(params);
         if (verificationErrorMessage) {
+          logger.error({
+            message: `${name}-signature-verification-failed`,
+            error: verificationErrorMessage
+          });
           const verificationErrorResponse = response_default2.exception(verificationErrorMessage);
           return response_default.success(JSON.stringify(verificationErrorResponse));
         }
@@ -937,12 +2122,17 @@ var _WebhookAction = class _WebhookAction {
       }
       const errorMessage = validator_default.checkMissingRequestInputs(params, requiredParams, requiredHeaders) ?? "";
       if (errorMessage) {
+        logger.error({
+          message: `${name}-validation-failed`,
+          error: errorMessage
+        });
         const errorMessageResponse = response_default2.exception(errorMessage);
         return response_default.success(JSON.stringify(errorMessageResponse));
       }
       const response = await action(params, ctx);
       return response_default.success(JSON.stringify(response));
     }, "callback");
+    runtime_action_default.setActionType("webhook-action");
     return runtime_action_default.execute(name, httpMethods, [], [], callback);
   }
 };
@@ -951,10 +2141,12 @@ var WebhookAction = _WebhookAction;
 var webhook_action_default = WebhookAction;
 
 // src/framework/ims-token/index.ts
+init_esm_shims();
 import { State } from "@adobe/aio-sdk";
 
 // src/commerce/adobe-auth/index.ts
-import { context, getToken } from "@adobe/aio-lib-ims";
+init_esm_shims();
+import * as aioLibIms from "@adobe/aio-lib-ims";
 var _AdobeAuth = class _AdobeAuth {
   /**
    * Retrieves an authentication token from Adobe IMS
@@ -987,9 +2179,9 @@ var _AdobeAuth = class _AdobeAuth {
       ims_org_id: imsOrgId,
       scopes
     };
-    await context.setCurrent(currentContext);
-    await context.set(currentContext, config);
-    return await getToken();
+    await aioLibIms.context.setCurrent(currentContext);
+    await aioLibIms.context.set(currentContext, config);
+    return await aioLibIms.getToken();
   }
 };
 __name(_AdobeAuth, "AdobeAuth");
@@ -997,6 +2189,7 @@ var AdobeAuth = _AdobeAuth;
 var adobe_auth_default = AdobeAuth;
 
 // src/integration/bearer-token/index.ts
+init_esm_shims();
 var _BearerToken = class _BearerToken {
   /**
    * Extracts the Bearer token from HTTP request headers and returns detailed token information.
@@ -1145,6 +2338,9 @@ var _ImsToken = class _ImsToken {
   /**
    * Creates an instance of ImsToken
    *
+   * @deprecated Use `AdobeAuth.getToken()` directly and implement caching in your application.
+   * See class documentation for migration examples.
+   *
    * @param clientId - OAuth client ID for Adobe IMS authentication
    * @param clientSecret - OAuth client secret for Adobe IMS authentication
    * @param technicalAccountId - Technical account ID for service-to-service authentication
@@ -1171,6 +2367,10 @@ var _ImsToken = class _ImsToken {
   /**
    * Executes IMS token generation or retrieves a cached token
    *
+   * @deprecated Use `AdobeAuth.getToken()` directly and implement caching in your application.
+   * The built-in caching mechanism has reliability issues with the State API.
+   * See class documentation for migration examples.
+   *
    * This method first checks for a cached token. If a valid cached token exists,
    * it returns that. Otherwise, it generates a new token, caches it, and returns it.
    *
@@ -1253,6 +2453,14 @@ var _ImsToken = class _ImsToken {
   /**
    * Caches the IMS token in the state store with TTL
    *
+   * @deprecated This method has issues with State API reliability. Use application-level caching instead.
+   *
+   * **Known Issues:**
+   * - State API may not be available in all runtime environments
+   * - Hard-coded 10-minute buffer may not suit all use cases
+   * - Minimum 60-minute TTL is opinionated and inflexible
+   * - No retry mechanism for State API failures
+   *
    * @param result - The token result containing the token and expiration time
    * @returns A promise that resolves to true if caching succeeded, false otherwise
    * @private
@@ -1278,6 +2486,13 @@ var _ImsToken = class _ImsToken {
   /**
    * Retrieves a cached IMS token from the state store
    *
+   * @deprecated This method has issues with State API reliability. Use application-level caching instead.
+   *
+   * **Known Issues:**
+   * - State API may not be available in all runtime environments
+   * - No validation of cached token expiry
+   * - Silent failures may return null without proper error context
+   *
    * @returns A promise that resolves to the cached token string or null if not found
    * @private
    */
@@ -1303,6 +2518,14 @@ var _ImsToken = class _ImsToken {
   /**
    * Initializes and returns the state store instance
    *
+   * @deprecated This method relies on State API which has reliability issues.
+   * Use application-level caching instead.
+   *
+   * **Known Issues:**
+   * - State API initialization may fail silently
+   * - Not available outside Adobe I/O Runtime environments
+   * - Caches the state instance which may become stale
+   *
    * @returns A promise that resolves to the state instance or null if initialization fails
    * @private
    */
@@ -1323,7 +2546,14 @@ __name(_ImsToken, "ImsToken");
 var ImsToken = _ImsToken;
 var ims_token_default = ImsToken;
 
+// src/framework/ims-token/types.ts
+init_esm_shims();
+
+// src/framework/runtime-api-gateway-service/index.ts
+init_esm_shims();
+
 // src/integration/rest-client/index.ts
+init_esm_shims();
 import fetch from "node-fetch";
 var _RestClient = class _RestClient {
   /**
@@ -1500,44 +2730,26 @@ var _RuntimeApiGatewayService = class _RuntimeApiGatewayService {
   /**
    * Creates an instance of RuntimeApiGatewayService
    *
-   * @param clientId - OAuth client ID for Adobe IMS authentication
-   * @param clientSecret - OAuth client secret for Adobe IMS authentication
-   * @param technicalAccountId - Technical account ID for service-to-service authentication
-   * @param technicalAccountEmail - Technical account email for service-to-service authentication
-   * @param imsOrgId - IMS organization ID
-   * @param scopes - Array of scopes required for the token
    * @param namespace - The Adobe I/O Runtime namespace identifier
+   * @param imsOrgId - IMS organization ID
+   * @param imsToken - Bearer token string for authentication
    * @param logger - Optional logger instance for logging operations
    * @example
    * ```typescript
    * const service = new RuntimeApiGatewayService(
-   *   'client-id',
-   *   'client-secret',
-   *   'tech-account-id',
-   *   'tech@example.com',
-   *   'org-id',
-   *   ['openid', 'AdobeID'],
-   *   'my-namespace-12345',
-   *   logger // optional
+   *   'test-namespace',
+   *   'org-id@AdobeOrg',
+   *   'bearer-token-string',
+   *   logger
    * );
    * ```
    */
-  constructor(clientId, clientSecret, technicalAccountId, technicalAccountEmail, imsOrgId, scopes, namespace, logger = null) {
+  constructor(namespace, imsOrgId, imsToken, logger = null) {
     this.namespace = namespace;
     this.imsOrgId = imsOrgId;
-    this.customLogger = new custom_logger_default(logger);
-    this.imsToken = new ims_token_default(
-      clientId,
-      clientSecret,
-      technicalAccountId,
-      technicalAccountEmail,
-      imsOrgId,
-      scopes,
-      logger,
-      "runtime_api_gateway_token",
-      "runtime-api-gateway-context"
-    );
+    this.imsToken = imsToken;
     this.restClient = new rest_client_default();
+    this.customLogger = new custom_logger_default(logger);
   }
   /**
    * Builds the complete API endpoint URL
@@ -1552,21 +2764,13 @@ var _RuntimeApiGatewayService = class _RuntimeApiGatewayService {
   /**
    * Gets the authenticated headers for API requests
    *
-   * @returns A promise that resolves with the headers object including authentication
-   * @throws {Error} If token generation fails
+   * @returns Headers object including authentication
    * @private
    */
-  async getAuthenticatedHeaders() {
-    this.customLogger.debug("Generating authenticated headers for API request");
-    const token = await this.imsToken.execute();
-    if (!token) {
-      this.customLogger.error("Failed to generate IMS token for authenticated headers");
-      throw new Error("Failed to generate IMS token");
-    }
-    this.customLogger.debug("Successfully generated authenticated headers");
+  getAuthenticatedHeaders() {
     return {
       "Content-Type": "application/json",
-      Authorization: `Bearer ${token}`,
+      Authorization: `Bearer ${this.imsToken}`,
       "x-gw-ims-org-id": this.imsOrgId
     };
   }
@@ -1590,7 +2794,7 @@ var _RuntimeApiGatewayService = class _RuntimeApiGatewayService {
     try {
       const url = this.buildEndpoint(endpoint);
       this.customLogger.info(`Performing GET request to: ${url}`);
-      const headers = { ...await this.getAuthenticatedHeaders(), ...additionalHeaders };
+      const headers = { ...this.getAuthenticatedHeaders(), ...additionalHeaders };
       this.customLogger.debug(`GET headers: ${JSON.stringify(headers)}`);
       const response = await this.restClient.get(url, headers, false);
       this.customLogger.debug(`GET response: ${JSON.stringify(response)}`);
@@ -1624,7 +2828,7 @@ var _RuntimeApiGatewayService = class _RuntimeApiGatewayService {
       const url = this.buildEndpoint(endpoint);
       this.customLogger.info(`Performing POST request to: ${url}`);
       this.customLogger.debug(`POST payload: ${JSON.stringify(payload)}`);
-      const headers = { ...await this.getAuthenticatedHeaders(), ...additionalHeaders };
+      const headers = { ...this.getAuthenticatedHeaders(), ...additionalHeaders };
       this.customLogger.debug(`POST headers: ${JSON.stringify(headers)}`);
       const response = await this.restClient.post(url, headers, payload, false);
       this.customLogger.debug(`POST response: ${JSON.stringify(response)}`);
@@ -1658,7 +2862,7 @@ var _RuntimeApiGatewayService = class _RuntimeApiGatewayService {
       const url = this.buildEndpoint(endpoint);
       this.customLogger.info(`Performing PUT request to: ${url}`);
       this.customLogger.debug(`PUT payload: ${JSON.stringify(payload)}`);
-      const headers = { ...await this.getAuthenticatedHeaders(), ...additionalHeaders };
+      const headers = { ...this.getAuthenticatedHeaders(), ...additionalHeaders };
       this.customLogger.debug(`PUT headers: ${JSON.stringify(headers)}`);
       const response = await this.restClient.put(url, headers, payload, false);
       this.customLogger.debug(`PUT response: ${JSON.stringify(response)}`);
@@ -1690,7 +2894,7 @@ var _RuntimeApiGatewayService = class _RuntimeApiGatewayService {
     try {
       const url = this.buildEndpoint(endpoint);
       this.customLogger.info(`Performing DELETE request to: ${url}`);
-      const headers = { ...await this.getAuthenticatedHeaders(), ...additionalHeaders };
+      const headers = { ...this.getAuthenticatedHeaders(), ...additionalHeaders };
       this.customLogger.debug(`DELETE headers: ${JSON.stringify(headers)}`);
       const response = await this.restClient.delete(url, headers, false);
       this.customLogger.debug(`DELETE response: ${JSON.stringify(response)}`);
@@ -1708,10 +2912,35 @@ __name(_RuntimeApiGatewayService, "RuntimeApiGatewayService");
 _RuntimeApiGatewayService.BASE_URL = "https://adobeioruntime.net/apis";
 var RuntimeApiGatewayService = _RuntimeApiGatewayService;
 
+// src/framework/telemetry/types.ts
+init_esm_shims();
+
+// src/framework/index.ts
+init_input_error();
+init_success_checker();
+init_json_message_processor();
+
+// src/integration/index.ts
+init_esm_shims();
+
 // src/integration/onboard-events/index.ts
-import { Core as Core4 } from "@adobe/aio-sdk";
+init_esm_shims();
+import { Core as Core2 } from "@adobe/aio-sdk";
+
+// src/integration/onboard-events/create-providers/index.ts
+init_esm_shims();
+
+// src/io-events/index.ts
+init_esm_shims();
+
+// src/io-events/provider/index.ts
+init_esm_shims();
+
+// src/io-events/provider/list/index.ts
+init_esm_shims();
 
 // src/io-events/types.ts
+init_esm_shims();
 var IoEventsGlobals = {
   BASE_URL: "https://api.adobe.io",
   STATUS_CODES: {
@@ -1948,6 +3177,7 @@ var List = _List;
 var list_default = List;
 
 // src/io-events/provider/get/index.ts
+init_esm_shims();
 var _Get = class _Get {
   /**
    * Constructor for Get provider service
@@ -2124,6 +3354,7 @@ var Get = _Get;
 var get_default = Get;
 
 // src/io-events/provider/create/index.ts
+init_esm_shims();
 var _Create = class _Create {
   /**
    * Constructor for Create provider service
@@ -2291,6 +3522,7 @@ var Create = _Create;
 var create_default = Create;
 
 // src/io-events/provider/delete/index.ts
+init_esm_shims();
 var _Delete = class _Delete {
   /**
    * Creates an instance of Delete service
@@ -2617,7 +3849,11 @@ __name(_ProviderManager, "ProviderManager");
 var ProviderManager = _ProviderManager;
 var provider_default = ProviderManager;
 
+// src/io-events/event-metadata/index.ts
+init_esm_shims();
+
 // src/io-events/event-metadata/list/index.ts
+init_esm_shims();
 var _List2 = class _List2 {
   /**
    * Creates an instance of List service
@@ -2808,6 +4044,7 @@ __name(_List2, "List");
 var List2 = _List2;
 
 // src/io-events/event-metadata/get/index.ts
+init_esm_shims();
 var _Get2 = class _Get2 {
   /**
    * Creates an instance of Get service
@@ -2978,6 +4215,7 @@ __name(_Get2, "Get");
 var Get2 = _Get2;
 
 // src/io-events/event-metadata/create/index.ts
+init_esm_shims();
 var _Create2 = class _Create2 {
   /**
    * Constructor for Create event metadata service
@@ -3242,6 +4480,7 @@ var Create2 = _Create2;
 var create_default2 = Create2;
 
 // src/io-events/event-metadata/delete/index.ts
+init_esm_shims();
 var _Delete2 = class _Delete2 {
   /**
    * Constructor for Delete event metadata service
@@ -3551,7 +4790,11 @@ __name(_EventMetadataManager, "EventMetadataManager");
 var EventMetadataManager = _EventMetadataManager;
 var event_metadata_default = EventMetadataManager;
 
+// src/io-events/registration/index.ts
+init_esm_shims();
+
 // src/io-events/registration/create/index.ts
+init_esm_shims();
 var _Create3 = class _Create3 {
   /**
    * Initialize the Create service
@@ -3736,6 +4979,7 @@ var Create3 = _Create3;
 var create_default3 = Create3;
 
 // src/io-events/registration/delete/index.ts
+init_esm_shims();
 var _Delete3 = class _Delete3 {
   /**
    * Initialize the Delete service
@@ -3854,6 +5098,7 @@ var Delete3 = _Delete3;
 var delete_default2 = Delete3;
 
 // src/io-events/registration/get/index.ts
+init_esm_shims();
 var _Get3 = class _Get3 {
   /**
    * Initialize the Get service
@@ -3973,6 +5218,7 @@ var Get3 = _Get3;
 var get_default2 = Get3;
 
 // src/io-events/registration/list/index.ts
+init_esm_shims();
 var _List3 = class _List3 {
   /**
    * Initialize the List service
@@ -4436,6 +5682,7 @@ var CreateProviders = _CreateProviders;
 var create_providers_default = CreateProviders;
 
 // src/integration/onboard-events/create-events/index.ts
+init_esm_shims();
 var _CreateEvents = class _CreateEvents {
   /**
    * Creates a new CreateEvents instance
@@ -4651,6 +5898,7 @@ var CreateEvents = _CreateEvents;
 var create_events_default = CreateEvents;
 
 // src/integration/onboard-events/create-registrations/index.ts
+init_esm_shims();
 var _CreateRegistrations = class _CreateRegistrations {
   /**
    * Creates a new CreateRegistrations instance
@@ -4924,6 +6172,7 @@ var CreateRegistrations = _CreateRegistrations;
 var create_registrations_default = CreateRegistrations;
 
 // src/integration/onboard-events/input-parser/index.ts
+init_esm_shims();
 var _InputParser = class _InputParser {
   constructor(input) {
     this.entities = {
@@ -5022,7 +6271,7 @@ var _OnboardEvents = class _OnboardEvents {
       throw new Error("Access token is required");
     }
     const loggerName = projectName.toLowerCase().replace(/[^a-z0-9\s-_]/g, "").replace(/\s+/g, "-").replace(/_{2,}/g, "_").replace(/-{2,}/g, "-").trim().concat("-onboard-events");
-    this.logger = Core4.Logger(loggerName, { level: "debug" });
+    this.logger = Core2.Logger(loggerName, { level: "debug" });
     this.createProviders = new create_providers_default(
       consumerId,
       projectId,
@@ -5218,7 +6467,8 @@ var OnboardEvents = _OnboardEvents;
 var onboard_events_default = OnboardEvents;
 
 // src/integration/infinite-loop-breaker/index.ts
-import { Core as Core5, State as State2 } from "@adobe/aio-sdk";
+init_esm_shims();
+import { Core as Core3, State as State2 } from "@adobe/aio-sdk";
 import crypto2 from "crypto";
 var _InfiniteLoopBreaker = class _InfiniteLoopBreaker {
   // seconds
@@ -5236,7 +6486,7 @@ var _InfiniteLoopBreaker = class _InfiniteLoopBreaker {
     event
   }) {
     const logLevel = process.env.LOG_LEVEL || "info";
-    const logger = Core5.Logger("infiniteLoopBreaker", { level: logLevel });
+    const logger = Core3.Logger("infiniteLoopBreaker", { level: logLevel });
     logger.debug(`Checking for potential infinite loop for event: ${event}`);
     if (!eventTypes.includes(event)) {
       logger.debug(`Event type ${event} is not in the infinite loop event types list`);
@@ -5314,7 +6564,11 @@ _InfiniteLoopBreaker.DEFAULT_INFINITE_LOOP_BREAKER_TTL = 60;
 var InfiniteLoopBreaker = _InfiniteLoopBreaker;
 var infinite_loop_breaker_default = InfiniteLoopBreaker;
 
+// src/integration/onboard-commerce/index.ts
+init_esm_shims();
+
 // src/integration/onboard-commerce/configure-provider/index.ts
+init_esm_shims();
 import {
   EventConfigurationService,
   EventProviderService
@@ -5847,7 +7101,11 @@ __name(_OnboardCommerce, "OnboardCommerce");
 var OnboardCommerce = _OnboardCommerce;
 var onboard_commerce_default = OnboardCommerce;
 
+// src/commerce/index.ts
+init_esm_shims();
+
 // src/commerce/adobe-commerce-client/index.ts
+init_esm_shims();
 import got from "got";
 var _AdobeCommerceClient = class _AdobeCommerceClient {
   /**
@@ -5986,7 +7244,11 @@ __name(_AdobeCommerceClient, "AdobeCommerceClient");
 var AdobeCommerceClient = _AdobeCommerceClient;
 var adobe_commerce_client_default = AdobeCommerceClient;
 
+// src/commerce/adobe-commerce-client/basic-auth-connection/index.ts
+init_esm_shims();
+
 // src/commerce/adobe-commerce-client/basic-auth-connection/generate-basic-auth-token/index.ts
+init_esm_shims();
 import { State as State3 } from "@adobe/aio-sdk";
 var _GenerateBasicAuthToken = class _GenerateBasicAuthToken {
   /**
@@ -6188,6 +7450,7 @@ var BasicAuthConnection = _BasicAuthConnection;
 var basic_auth_connection_default = BasicAuthConnection;
 
 // src/commerce/adobe-commerce-client/oauth1a-connection/index.ts
+init_esm_shims();
 import Oauth1a from "oauth-1.0a";
 import * as crypto3 from "crypto";
 var _Oauth1aConnection = class _Oauth1aConnection {
@@ -6247,51 +7510,41 @@ var Oauth1aConnection = _Oauth1aConnection;
 var oauth1a_connection_default = Oauth1aConnection;
 
 // src/commerce/adobe-commerce-client/ims-connection/index.ts
+init_esm_shims();
 var _ImsConnection = class _ImsConnection {
   /**
-   * @param clientId
-   * @param clientSecret
-   * @param technicalAccountId
-   * @param technicalAccountEmail
-   * @param imsOrgId
-   * @param scopes
-   * @param logger
+   * Creates an instance of ImsConnection
+   *
+   * @param imsToken - Bearer token string for IMS authentication (generate using AdobeAuth)
+   * @param logger - Optional logger instance for logging operations
+   * @example
+   * ```typescript
+   * const token = await AdobeAuth.getToken(...);
+   * const connection = new ImsConnection(token, logger);
+   * ```
    */
-  constructor(clientId, clientSecret, technicalAccountId, technicalAccountEmail, imsOrgId, scopes, logger = null) {
-    this.clientId = clientId;
-    this.clientSecret = clientSecret;
-    this.technicalAccountId = technicalAccountId;
-    this.technicalAccountEmail = technicalAccountEmail;
-    this.imsOrgId = imsOrgId;
-    this.scopes = scopes;
+  constructor(imsToken, logger = null) {
+    this.imsToken = imsToken;
     this.customLogger = new custom_logger_default(logger);
   }
   /**
-   * @param commerceGot
+   * Extends the Commerce Got client with IMS authentication headers
+   *
+   * @param commerceGot - The Got instance to extend with authentication
+   * @returns Promise<any> - Extended Got instance with authentication headers
+   * @throws {Error} If token is invalid or empty
    */
   async extend(commerceGot) {
     this.customLogger.info("Using Commerce client with IMS authentication");
-    const tokenGenerator = new ims_token_default(
-      this.clientId,
-      this.clientSecret,
-      this.technicalAccountId,
-      this.technicalAccountEmail,
-      this.imsOrgId,
-      this.scopes,
-      this.customLogger.getLogger(),
-      "adobe_commerce_ims_token",
-      // Use specific cache key for commerce client
-      "adobe-commerce-client"
-      // Use adobe-commerce-client context for backward compatibility
-    );
-    const token = await tokenGenerator.execute();
-    if (token === null) {
+    if (!this.imsToken || this.imsToken.trim() === "") {
       throw new Error("Failed to generate or retrieve IMS token");
     }
-    this.customLogger.info(`IMS token being extended to header: ${token.substring(0, 10)}...`);
+    this.customLogger.info(
+      `IMS token being extended to header: ${this.imsToken.substring(0, 10)}...`
+    );
     return commerceGot.extend({
       headers: {
-        Authorization: `Bearer ${token}`
+        Authorization: `Bearer ${this.imsToken}`
       }
     });
   }
@@ -6300,7 +7553,11 @@ __name(_ImsConnection, "ImsConnection");
 var ImsConnection = _ImsConnection;
 var ims_connection_default = ImsConnection;
 
+// src/commerce/shipping-carrier/index.ts
+init_esm_shims();
+
 // src/commerce/shipping-carrier/method/index.ts
+init_esm_shims();
 var _ShippingCarrierMethod = class _ShippingCarrierMethod {
   constructor(carrierCode, method) {
     this.methodData = { carrier_code: carrierCode, method, additional_data: [] };
@@ -6651,6 +7908,7 @@ var ShippingCarrier = _ShippingCarrier;
 var shipping_carrier_default = ShippingCarrier;
 
 // src/commerce/shipping-carrier/response/index.ts
+init_esm_shims();
 var _ShippingCarrierResponse = class _ShippingCarrierResponse {
   constructor(carrier) {
     this.carrier = carrier;
@@ -6684,7 +7942,11 @@ __name(_ShippingCarrierResponse, "ShippingCarrierResponse");
 var ShippingCarrierResponse = _ShippingCarrierResponse;
 var response_default3 = ShippingCarrierResponse;
 
+// src/experience/index.ts
+init_esm_shims();
+
 // src/experience/admin-ui-sdk/index.ts
+init_esm_shims();
 var _AdminUiSdk = class _AdminUiSdk {
   /**
    * Creates a new AdminUiSdk instance
@@ -6863,6 +8125,7 @@ export {
   ims_token_default as ImsToken,
   infinite_loop_breaker_default as InfiniteLoopBreaker,
   IoEventsGlobals,
+  JsonMessageProcessor,
   oauth1a_connection_default as Oauth1aConnection,
   onboard_commerce_default as OnboardCommerce,
   onboard_events_default as OnboardEvents,
@@ -6881,6 +8144,9 @@ export {
   method_default as ShippingCarrierMethod,
   response_default3 as ShippingCarrierResponse,
   SignatureVerification,
+  SuccessChecker,
+  telemetry_default as Telemetry,
+  TelemetryInputError,
   validator_default as Validator,
   webhook_action_default as WebhookAction,
   WebhookActionOperation,