@adobe-commerce/aio-toolkit 1.0.10 → 1.0.11

package/dist/index.mjs

@@ -1,646 +1,435 @@
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 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 });
-};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
-// 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"() {
+// node_modules/@opentelemetry/api/build/esm/platform/node/globalThis.js
+var _globalThis;
+var init_globalThis = __esm({
+  "node_modules/@opentelemetry/api/build/esm/platform/node/globalThis.js"() {
     "use strict";
+    _globalThis = typeof globalThis === "object" ? globalThis : global;
   }
 });
 
-// src/framework/telemetry/helpers/input-error/index.ts
-var _TelemetryInputError, TelemetryInputError;
-var init_input_error = __esm({
-  "src/framework/telemetry/helpers/input-error/index.ts"() {
+// node_modules/@opentelemetry/api/build/esm/platform/node/index.js
+var init_node = __esm({
+  "node_modules/@opentelemetry/api/build/esm/platform/node/index.js"() {
     "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;
+    init_globalThis();
   }
 });
 
-// src/framework/telemetry/new-relic/validator/index.ts
-var _NewRelicTelemetryValidator, NewRelicTelemetryValidator;
-var init_validator = __esm({
-  "src/framework/telemetry/new-relic/validator/index.ts"() {
+// node_modules/@opentelemetry/api/build/esm/platform/index.js
+var init_platform = __esm({
+  "node_modules/@opentelemetry/api/build/esm/platform/index.js"() {
     "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;
+    init_node();
   }
 });
 
-// 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"() {
+// node_modules/@opentelemetry/api/build/esm/version.js
+var VERSION;
+var init_version = __esm({
+  "node_modules/@opentelemetry/api/build/esm/version.js"() {
     "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);
-      }
+    VERSION = "1.9.0";
+  }
+});
+
+// node_modules/@opentelemetry/api/build/esm/internal/semver.js
+function _makeCompatibilityCheck(ownVersion) {
+  var acceptedVersions = /* @__PURE__ */ new Set([ownVersion]);
+  var rejectedVersions = /* @__PURE__ */ new Set();
+  var myVersionMatch = ownVersion.match(re);
+  if (!myVersionMatch) {
+    return function() {
+      return false;
     };
-    __name(_ResourceFactory, "ResourceFactory");
-    ResourceFactory = _ResourceFactory;
+  }
+  var ownVersionParsed = {
+    major: +myVersionMatch[1],
+    minor: +myVersionMatch[2],
+    patch: +myVersionMatch[3],
+    prerelease: myVersionMatch[4]
+  };
+  if (ownVersionParsed.prerelease != null) {
+    return /* @__PURE__ */ __name(function isExactmatch(globalVersion) {
+      return globalVersion === ownVersion;
+    }, "isExactmatch");
+  }
+  function _reject(v) {
+    rejectedVersions.add(v);
+    return false;
+  }
+  __name(_reject, "_reject");
+  function _accept(v) {
+    acceptedVersions.add(v);
+    return true;
+  }
+  __name(_accept, "_accept");
+  return /* @__PURE__ */ __name(function isCompatible2(globalVersion) {
+    if (acceptedVersions.has(globalVersion)) {
+      return true;
+    }
+    if (rejectedVersions.has(globalVersion)) {
+      return false;
+    }
+    var globalVersionMatch = globalVersion.match(re);
+    if (!globalVersionMatch) {
+      return _reject(globalVersion);
+    }
+    var globalVersionParsed = {
+      major: +globalVersionMatch[1],
+      minor: +globalVersionMatch[2],
+      patch: +globalVersionMatch[3],
+      prerelease: globalVersionMatch[4]
+    };
+    if (globalVersionParsed.prerelease != null) {
+      return _reject(globalVersion);
+    }
+    if (ownVersionParsed.major !== globalVersionParsed.major) {
+      return _reject(globalVersion);
+    }
+    if (ownVersionParsed.major === 0) {
+      if (ownVersionParsed.minor === globalVersionParsed.minor && ownVersionParsed.patch <= globalVersionParsed.patch) {
+        return _accept(globalVersion);
+      }
+      return _reject(globalVersion);
+    }
+    if (ownVersionParsed.minor <= globalVersionParsed.minor) {
+      return _accept(globalVersion);
+    }
+    return _reject(globalVersion);
+  }, "isCompatible");
+}
+var re, isCompatible;
+var init_semver = __esm({
+  "node_modules/@opentelemetry/api/build/esm/internal/semver.js"() {
+    "use strict";
+    init_version();
+    re = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
+    __name(_makeCompatibilityCheck, "_makeCompatibilityCheck");
+    isCompatible = _makeCompatibilityCheck(VERSION);
   }
 });
 
-// src/framework/telemetry/helpers/success-checker/index.ts
-var _SuccessChecker, SuccessChecker;
-var init_success_checker = __esm({
-  "src/framework/telemetry/helpers/success-checker/index.ts"() {
+// node_modules/@opentelemetry/api/build/esm/internal/global-utils.js
+function registerGlobal(type, instance, diag2, allowOverride) {
+  var _a;
+  if (allowOverride === void 0) {
+    allowOverride = false;
+  }
+  var api = _global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a !== void 0 ? _a : {
+    version: VERSION
+  };
+  if (!allowOverride && api[type]) {
+    var err = new Error("@opentelemetry/api: Attempted duplicate registration of API: " + type);
+    diag2.error(err.stack || err.message);
+    return false;
+  }
+  if (api.version !== VERSION) {
+    var err = new Error("@opentelemetry/api: Registration of version v" + api.version + " for " + type + " does not match previously registered API v" + VERSION);
+    diag2.error(err.stack || err.message);
+    return false;
+  }
+  api[type] = instance;
+  diag2.debug("@opentelemetry/api: Registered a global for " + type + " v" + VERSION + ".");
+  return true;
+}
+function getGlobal(type) {
+  var _a, _b;
+  var globalVersion = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a === void 0 ? void 0 : _a.version;
+  if (!globalVersion || !isCompatible(globalVersion)) {
+    return;
+  }
+  return (_b = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b === void 0 ? void 0 : _b[type];
+}
+function unregisterGlobal(type, diag2) {
+  diag2.debug("@opentelemetry/api: Unregistering a global for " + type + " v" + VERSION + ".");
+  var api = _global[GLOBAL_OPENTELEMETRY_API_KEY];
+  if (api) {
+    delete api[type];
+  }
+}
+var major, GLOBAL_OPENTELEMETRY_API_KEY, _global;
+var init_global_utils = __esm({
+  "node_modules/@opentelemetry/api/build/esm/internal/global-utils.js"() {
     "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;
+    init_platform();
+    init_version();
+    init_semver();
+    major = VERSION.split(".")[0];
+    GLOBAL_OPENTELEMETRY_API_KEY = /* @__PURE__ */ Symbol.for("opentelemetry.js.api." + major);
+    _global = _globalThis;
+    __name(registerGlobal, "registerGlobal");
+    __name(getGlobal, "getGlobal");
+    __name(unregisterGlobal, "unregisterGlobal");
   }
 });
 
-// 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"() {
+// node_modules/@opentelemetry/api/build/esm/diag/ComponentLogger.js
+function logProxy(funcName, namespace, args) {
+  var logger = getGlobal("diag");
+  if (!logger) {
+    return;
+  }
+  args.unshift(namespace);
+  return logger[funcName].apply(logger, __spreadArray([], __read(args), false));
+}
+var __read, __spreadArray, DiagComponentLogger;
+var init_ComponentLogger = __esm({
+  "node_modules/@opentelemetry/api/build/esm/diag/ComponentLogger.js"() {
     "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) {
+    init_global_utils();
+    __read = function(o, n) {
+      var m = typeof Symbol === "function" && o[Symbol.iterator];
+      if (!m) return o;
+      var i = m.call(o), r, ar = [], e;
+      try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+      } catch (error) {
+        e = { error };
+      } finally {
         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 {
+          if (r && !r.done && (m = i["return"])) m.call(i);
+        } finally {
+          if (e) throw e.error;
         }
-        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();
+      return ar;
+    };
+    __spreadArray = function(to, from, pack) {
+      if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+          ar[i] = from[i];
+        }
       }
+      return to.concat(ar || Array.prototype.slice.call(from));
     };
-    __name(_JsonMessageProcessor, "JsonMessageProcessor");
-    JsonMessageProcessor = _JsonMessageProcessor;
+    DiagComponentLogger = /** @class */
+    (function() {
+      function DiagComponentLogger2(props) {
+        this._namespace = props.namespace || "DiagComponentLogger";
+      }
+      __name(DiagComponentLogger2, "DiagComponentLogger");
+      DiagComponentLogger2.prototype.debug = function() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        return logProxy("debug", this._namespace, args);
+      };
+      DiagComponentLogger2.prototype.error = function() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        return logProxy("error", this._namespace, args);
+      };
+      DiagComponentLogger2.prototype.info = function() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        return logProxy("info", this._namespace, args);
+      };
+      DiagComponentLogger2.prototype.warn = function() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        return logProxy("warn", this._namespace, args);
+      };
+      DiagComponentLogger2.prototype.verbose = function() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        return logProxy("verbose", this._namespace, args);
+      };
+      return DiagComponentLogger2;
+    })();
+    __name(logProxy, "logProxy");
   }
 });
 
-// src/framework/telemetry/new-relic/index.ts
-var new_relic_exports = {};
-__export(new_relic_exports, {
-  default: () => new_relic_default
+// node_modules/@opentelemetry/api/build/esm/diag/types.js
+var DiagLogLevel;
+var init_types = __esm({
+  "node_modules/@opentelemetry/api/build/esm/diag/types.js"() {
+    "use strict";
+    (function(DiagLogLevel2) {
+      DiagLogLevel2[DiagLogLevel2["NONE"] = 0] = "NONE";
+      DiagLogLevel2[DiagLogLevel2["ERROR"] = 30] = "ERROR";
+      DiagLogLevel2[DiagLogLevel2["WARN"] = 50] = "WARN";
+      DiagLogLevel2[DiagLogLevel2["INFO"] = 60] = "INFO";
+      DiagLogLevel2[DiagLogLevel2["DEBUG"] = 70] = "DEBUG";
+      DiagLogLevel2[DiagLogLevel2["VERBOSE"] = 80] = "VERBOSE";
+      DiagLogLevel2[DiagLogLevel2["ALL"] = 9999] = "ALL";
+    })(DiagLogLevel || (DiagLogLevel = {}));
+  }
 });
-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"() {
+
+// node_modules/@opentelemetry/api/build/esm/diag/internal/logLevelLogger.js
+function createLogLevelDiagLogger(maxLevel, logger) {
+  if (maxLevel < DiagLogLevel.NONE) {
+    maxLevel = DiagLogLevel.NONE;
+  } else if (maxLevel > DiagLogLevel.ALL) {
+    maxLevel = DiagLogLevel.ALL;
+  }
+  logger = logger || {};
+  function _filterFunc(funcName, theLevel) {
+    var theFunc = logger[funcName];
+    if (typeof theFunc === "function" && maxLevel >= theLevel) {
+      return theFunc.bind(logger);
+    }
+    return function() {
+    };
+  }
+  __name(_filterFunc, "_filterFunc");
+  return {
+    error: _filterFunc("error", DiagLogLevel.ERROR),
+    warn: _filterFunc("warn", DiagLogLevel.WARN),
+    info: _filterFunc("info", DiagLogLevel.INFO),
+    debug: _filterFunc("debug", DiagLogLevel.DEBUG),
+    verbose: _filterFunc("verbose", DiagLogLevel.VERBOSE)
+  };
+}
+var init_logLevelLogger = __esm({
+  "node_modules/@opentelemetry/api/build/esm/diag/internal/logLevelLogger.js"() {
     "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();
+    init_types();
+    __name(createLogLevelDiagLogger, "createLogLevelDiagLogger");
+  }
+});
+
+// node_modules/@opentelemetry/api/build/esm/api/diag.js
+var __read2, __spreadArray2, API_NAME, DiagAPI;
+var init_diag = __esm({
+  "node_modules/@opentelemetry/api/build/esm/api/diag.js"() {
+    "use strict";
+    init_ComponentLogger();
+    init_logLevelLogger();
+    init_types();
+    init_global_utils();
+    __read2 = function(o, n) {
+      var m = typeof Symbol === "function" && o[Symbol.iterator];
+      if (!m) return o;
+      var i = m.call(o), r, ar = [], e;
+      try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+      } catch (error) {
+        e = { error };
+      } finally {
+        try {
+          if (r && !r.done && (m = i["return"])) m.call(i);
+        } finally {
+          if (e) throw e.error;
+        }
       }
-      /**
-       * 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);
+      return ar;
+    };
+    __spreadArray2 = function(to, from, pack) {
+      if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+          ar[i] = from[i];
+        }
       }
-      /**
-       * 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");
+      return to.concat(ar || Array.prototype.slice.call(from));
+    };
+    API_NAME = "diag";
+    DiagAPI = /** @class */
+    (function() {
+      function DiagAPI2() {
+        function _logProxy(funcName) {
+          return function() {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+              args[_i] = arguments[_i];
             }
-            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)
-              }
+            var logger = getGlobal("diag");
+            if (!logger)
+              return;
+            return logger[funcName].apply(logger, __spreadArray2([], __read2(args), false));
+          };
+        }
+        __name(_logProxy, "_logProxy");
+        var self = this;
+        var setLogger = /* @__PURE__ */ __name(function(logger, optionsOrLogLevel) {
+          var _a, _b, _c;
+          if (optionsOrLogLevel === void 0) {
+            optionsOrLogLevel = { logLevel: DiagLogLevel.INFO };
+          }
+          if (logger === self) {
+            var err = new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
+            self.error((_a = err.stack) !== null && _a !== void 0 ? _a : err.message);
+            return false;
+          }
+          if (typeof optionsOrLogLevel === "number") {
+            optionsOrLogLevel = {
+              logLevel: optionsOrLogLevel
             };
-          }),
-          isSuccessful: this.successChecker.execute.bind(this.successChecker)
+          }
+          var oldLogger = getGlobal("diag");
+          var newLogger = createLogLevelDiagLogger((_b = optionsOrLogLevel.logLevel) !== null && _b !== void 0 ? _b : DiagLogLevel.INFO, logger);
+          if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {
+            var stack = (_c = new Error().stack) !== null && _c !== void 0 ? _c : "<failed to generate stacktrace>";
+            oldLogger.warn("Current logger will be overwritten from " + stack);
+            newLogger.warn("Current logger will overwrite one already registered from " + stack);
+          }
+          return registerGlobal("diag", newLogger, self, true);
+        }, "setLogger");
+        self.setLogger = setLogger;
+        self.disable = function() {
+          unregisterGlobal(API_NAME, self);
         };
-      }
-      /**
-       * 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")))
-            )
-          ]
+        self.createComponentLogger = function(options) {
+          return new DiagComponentLogger(options);
         };
+        self.verbose = _logProxy("verbose");
+        self.debug = _logProxy("debug");
+        self.info = _logProxy("info");
+        self.warn = _logProxy("warn");
+        self.error = _logProxy("error");
       }
-      /**
-       * 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;
+      __name(DiagAPI2, "DiagAPI");
+      DiagAPI2.instance = function() {
+        if (!this._instance) {
+          this._instance = new DiagAPI2();
+        }
+        return this._instance;
+      };
+      return DiagAPI2;
+    })();
   }
 });
 
-// src/index.ts
-init_esm_shims();
-
-// src/framework/index.ts
-init_esm_shims();
-
-// src/framework/runtime-action/index.ts
-init_esm_shims();
+// node_modules/@opentelemetry/api/build/esm/diag-api.js
+var diag;
+var init_diag_api = __esm({
+  "node_modules/@opentelemetry/api/build/esm/diag-api.js"() {
+    "use strict";
+    init_diag();
+    diag = DiagAPI.instance();
+  }
+});
 
-// src/framework/runtime-action/response/index.ts
-init_esm_shims();
+// node_modules/@opentelemetry/api/build/esm/index.js
+var init_esm = __esm({
+  "node_modules/@opentelemetry/api/build/esm/index.js"() {
+    "use strict";
+    init_diag_api();
+  }
+});
 
 // 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";
@@ -703,7 +492,6 @@ var RuntimeActionResponse = _RuntimeActionResponse;
 var response_default = RuntimeActionResponse;
 
 // 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.
@@ -769,8 +557,701 @@ var Validator = _Validator;
 var validator_default = Validator;
 
 // src/framework/telemetry/index.ts
-init_esm_shims();
 import { Core } from "@adobe/aio-sdk";
+import { getLogger } from "@adobe/aio-lib-telemetry";
+
+// src/framework/telemetry/new-relic/index.ts
+import {
+  defineTelemetryConfig,
+  getPresetInstrumentations,
+  instrumentEntrypoint
+} from "@adobe/aio-lib-telemetry";
+
+// src/framework/telemetry/helpers/input-error/index.ts
+var _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");
+var TelemetryInputError = _TelemetryInputError;
+
+// src/framework/telemetry/new-relic/validator/index.ts
+var _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");
+var NewRelicTelemetryValidator = _NewRelicTelemetryValidator;
+
+// src/framework/telemetry/helpers/resource-factory/index.ts
+import { getAioRuntimeResource } from "@adobe/aio-lib-telemetry";
+
+// node_modules/@opentelemetry/resources/build/esm/ResourceImpl.js
+init_esm();
+
+// node_modules/@opentelemetry/resources/build/esm/utils.js
+var isPromiseLike = /* @__PURE__ */ __name((val) => {
+  return val !== null && typeof val === "object" && typeof val.then === "function";
+}, "isPromiseLike");
+
+// node_modules/@opentelemetry/resources/build/esm/ResourceImpl.js
+var _ResourceImpl = class _ResourceImpl {
+  constructor(resource, options) {
+    __publicField(this, "_rawAttributes");
+    __publicField(this, "_asyncAttributesPending", false);
+    __publicField(this, "_schemaUrl");
+    __publicField(this, "_memoizedAttributes");
+    const attributes = resource.attributes ?? {};
+    this._rawAttributes = Object.entries(attributes).map(([k, v]) => {
+      if (isPromiseLike(v)) {
+        this._asyncAttributesPending = true;
+      }
+      return [k, v];
+    });
+    this._rawAttributes = guardedRawAttributes(this._rawAttributes);
+    this._schemaUrl = validateSchemaUrl(options?.schemaUrl);
+  }
+  static FromAttributeList(attributes, options) {
+    const res = new _ResourceImpl({}, options);
+    res._rawAttributes = guardedRawAttributes(attributes);
+    res._asyncAttributesPending = attributes.filter(([_, val]) => isPromiseLike(val)).length > 0;
+    return res;
+  }
+  get asyncAttributesPending() {
+    return this._asyncAttributesPending;
+  }
+  async waitForAsyncAttributes() {
+    if (!this.asyncAttributesPending) {
+      return;
+    }
+    for (let i = 0; i < this._rawAttributes.length; i++) {
+      const [k, v] = this._rawAttributes[i];
+      this._rawAttributes[i] = [k, isPromiseLike(v) ? await v : v];
+    }
+    this._asyncAttributesPending = false;
+  }
+  get attributes() {
+    if (this.asyncAttributesPending) {
+      diag.error("Accessing resource attributes before async attributes settled");
+    }
+    if (this._memoizedAttributes) {
+      return this._memoizedAttributes;
+    }
+    const attrs = {};
+    for (const [k, v] of this._rawAttributes) {
+      if (isPromiseLike(v)) {
+        diag.debug(`Unsettled resource attribute ${k} skipped`);
+        continue;
+      }
+      if (v != null) {
+        attrs[k] ?? (attrs[k] = v);
+      }
+    }
+    if (!this._asyncAttributesPending) {
+      this._memoizedAttributes = attrs;
+    }
+    return attrs;
+  }
+  getRawAttributes() {
+    return this._rawAttributes;
+  }
+  get schemaUrl() {
+    return this._schemaUrl;
+  }
+  merge(resource) {
+    if (resource == null)
+      return this;
+    const mergedSchemaUrl = mergeSchemaUrl(this, resource);
+    const mergedOptions = mergedSchemaUrl ? { schemaUrl: mergedSchemaUrl } : void 0;
+    return _ResourceImpl.FromAttributeList([...resource.getRawAttributes(), ...this.getRawAttributes()], mergedOptions);
+  }
+};
+__name(_ResourceImpl, "ResourceImpl");
+var ResourceImpl = _ResourceImpl;
+function resourceFromAttributes(attributes, options) {
+  return ResourceImpl.FromAttributeList(Object.entries(attributes), options);
+}
+__name(resourceFromAttributes, "resourceFromAttributes");
+function guardedRawAttributes(attributes) {
+  return attributes.map(([k, v]) => {
+    if (isPromiseLike(v)) {
+      return [
+        k,
+        v.catch((err) => {
+          diag.debug("promise rejection for resource attribute: %s - %s", k, err);
+          return void 0;
+        })
+      ];
+    }
+    return [k, v];
+  });
+}
+__name(guardedRawAttributes, "guardedRawAttributes");
+function validateSchemaUrl(schemaUrl) {
+  if (typeof schemaUrl === "string" || schemaUrl === void 0) {
+    return schemaUrl;
+  }
+  diag.warn("Schema URL must be string or undefined, got %s. Schema URL will be ignored.", schemaUrl);
+  return void 0;
+}
+__name(validateSchemaUrl, "validateSchemaUrl");
+function mergeSchemaUrl(old, updating) {
+  const oldSchemaUrl = old?.schemaUrl;
+  const updatingSchemaUrl = updating?.schemaUrl;
+  const isOldEmpty = oldSchemaUrl === void 0 || oldSchemaUrl === "";
+  const isUpdatingEmpty = updatingSchemaUrl === void 0 || updatingSchemaUrl === "";
+  if (isOldEmpty) {
+    return updatingSchemaUrl;
+  }
+  if (isUpdatingEmpty) {
+    return oldSchemaUrl;
+  }
+  if (oldSchemaUrl === updatingSchemaUrl) {
+    return oldSchemaUrl;
+  }
+  diag.warn('Schema URL merge conflict: old resource has "%s", updating resource has "%s". Resulting resource will have undefined Schema URL.', oldSchemaUrl, updatingSchemaUrl);
+  return void 0;
+}
+__name(mergeSchemaUrl, "mergeSchemaUrl");
+
+// src/framework/telemetry/helpers/resource-factory/index.ts
+var _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");
+var ResourceFactory = _ResourceFactory;
+
+// src/framework/telemetry/helpers/success-checker/index.ts
+var _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");
+var SuccessChecker = _SuccessChecker;
+
+// src/framework/telemetry/new-relic/index.ts
+import {
+  OTLPLogExporterProto,
+  OTLPMetricExporterProto,
+  OTLPTraceExporterProto,
+  PeriodicExportingMetricReader,
+  SimpleLogRecordProcessor
+} from "@adobe/aio-lib-telemetry/otel";
+
+// src/framework/telemetry/helpers/json-message-processor/index.ts
+var _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");
+var JsonMessageProcessor = _JsonMessageProcessor;
+
+// src/framework/telemetry/new-relic/index.ts
+var _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");
+var NewRelicTelemetry = _NewRelicTelemetry;
+var new_relic_default = NewRelicTelemetry;
+
+// src/framework/telemetry/index.ts
 var _Telemetry = class _Telemetry {
   /**
    * Create a logger with standard configuration and automatic metadata injection.
@@ -780,7 +1261,7 @@ var _Telemetry = class _Telemetry {
    * - `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.
+   * If ENABLE_TELEMETRY is true, uses OpenTelemetry logger; 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.
    *
@@ -817,59 +1298,11 @@ var _Telemetry = class _Telemetry {
    * ```
    */
   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 baseLogger = !params.ENABLE_TELEMETRY ? Core.Logger(name, {
+      level: params.LOG_LEVEL || "info"
+    }) : getLogger(name, {
+      level: params.LOG_LEVEL || "info"
     });
-    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"];
@@ -1017,27 +1450,16 @@ var _Telemetry = class _Telemetry {
    */
   static initialize(action) {
     return async (params) => {
-      if (params.ENABLE_TELEMETRY && params.NEW_RELIC_TELEMETRY) {
+      const newRelicTelemetry = new new_relic_default();
+      if (newRelicTelemetry.canInitialize(params)) {
         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}`
-              );
-            }
-          }
+          const instrumentedAction = newRelicTelemetry.initialize(action);
+          return await instrumentedAction(params);
         } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : "Failed to load telemetry module";
+          const errorMessage = error instanceof Error ? error.message : "Telemetry initialization failed";
           return response_default.error(
             500 /* INTERNAL_ERROR */,
-            `Telemetry module error: ${errorMessage}`
+            `Telemetry configuration error: ${errorMessage}`
           );
         }
       }
@@ -1237,11 +1659,7 @@ _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.
@@ -1264,7 +1682,6 @@ var Parameters = _Parameters;
 var parameters_default = Parameters;
 
 // src/framework/event-consumer-action/index.ts
-init_esm_shims();
 var _EventConsumerAction = class _EventConsumerAction {
   /**
    * Creates an event consumer action handler with telemetry integration
@@ -1351,7 +1768,6 @@ 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 = `
@@ -1429,7 +1845,6 @@ var GraphQlAction = _GraphQlAction;
 var graphql_action_default = GraphQlAction;
 
 // src/framework/openwhisk/index.ts
-init_esm_shims();
 import openwhisk from "openwhisk";
 var _Openwhisk = class _Openwhisk {
   /**
@@ -1457,7 +1872,6 @@ var Openwhisk = _Openwhisk;
 var openwhisk_default = Openwhisk;
 
 // src/framework/openwhisk-action/index.ts
-init_esm_shims();
 var _OpenwhiskAction = class _OpenwhiskAction {
   /**
    * Creates an OpenWhisk webhook action handler with logging and telemetry
@@ -1542,7 +1956,6 @@ 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 {
   /**
@@ -1699,17 +2112,12 @@ __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)
@@ -1844,17 +2252,7 @@ __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";
@@ -1961,10 +2359,10 @@ var _WebhookActionResponse = class _WebhookActionResponse {
    * });
    * ```
    */
-  static add(path2, value, instance) {
+  static add(path, value, instance) {
     const response = {
       op: "add" /* ADD */,
-      path: path2,
+      path,
       value
     };
     if (instance !== void 0) {
@@ -2000,10 +2398,10 @@ var _WebhookActionResponse = class _WebhookActionResponse {
    * });
    * ```
    */
-  static replace(path2, value, instance) {
+  static replace(path, value, instance) {
     const response = {
       op: "replace" /* REPLACE */,
-      path: path2,
+      path,
       value
     };
     if (instance !== void 0) {
@@ -2041,10 +2439,10 @@ var _WebhookActionResponse = class _WebhookActionResponse {
    * };
    * ```
    */
-  static remove(path2) {
+  static remove(path) {
     return {
       op: "remove" /* REMOVE */,
-      path: path2
+      path
     };
   }
 };
@@ -2053,7 +2451,6 @@ 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";
@@ -2141,12 +2538,10 @@ 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
-init_esm_shims();
-import * as aioLibIms from "@adobe/aio-lib-ims";
+import { context, getToken } from "@adobe/aio-lib-ims";
 var _AdobeAuth = class _AdobeAuth {
   /**
    * Retrieves an authentication token from Adobe IMS
@@ -2179,9 +2574,9 @@ var _AdobeAuth = class _AdobeAuth {
       ims_org_id: imsOrgId,
       scopes
     };
-    await aioLibIms.context.setCurrent(currentContext);
-    await aioLibIms.context.set(currentContext, config);
-    return await aioLibIms.getToken();
+    await context.setCurrent(currentContext);
+    await context.set(currentContext, config);
+    return await getToken();
   }
 };
 __name(_AdobeAuth, "AdobeAuth");
@@ -2189,7 +2584,6 @@ 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.
@@ -2546,14 +2940,7 @@ __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 {
   /**
@@ -2912,35 +3299,10 @@ __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
-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: {
@@ -3177,7 +3539,6 @@ 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
@@ -3354,7 +3715,6 @@ 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
@@ -3522,7 +3882,6 @@ 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
@@ -3849,11 +4208,7 @@ __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
@@ -4044,7 +4399,6 @@ __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
@@ -4215,7 +4569,6 @@ __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
@@ -4480,7 +4833,6 @@ 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
@@ -4790,11 +5142,7 @@ __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
@@ -4979,7 +5327,6 @@ 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
@@ -5098,7 +5445,6 @@ 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
@@ -5218,7 +5564,6 @@ 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
@@ -5682,7 +6027,6 @@ 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
@@ -5898,7 +6242,6 @@ 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
@@ -6172,7 +6515,6 @@ 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 = {
@@ -6467,7 +6809,6 @@ var OnboardEvents = _OnboardEvents;
 var onboard_events_default = OnboardEvents;
 
 // src/integration/infinite-loop-breaker/index.ts
-init_esm_shims();
 import { Core as Core3, State as State2 } from "@adobe/aio-sdk";
 import crypto2 from "crypto";
 var _InfiniteLoopBreaker = class _InfiniteLoopBreaker {
@@ -6564,11 +6905,7 @@ _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
@@ -7101,11 +7438,7 @@ __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 {
   /**
@@ -7244,11 +7577,7 @@ __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 {
   /**
@@ -7450,7 +7779,6 @@ 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 {
@@ -7510,7 +7838,6 @@ var Oauth1aConnection = _Oauth1aConnection;
 var oauth1a_connection_default = Oauth1aConnection;
 
 // src/commerce/adobe-commerce-client/ims-connection/index.ts
-init_esm_shims();
 var _ImsConnection = class _ImsConnection {
   /**
    * Creates an instance of ImsConnection
@@ -7553,11 +7880,7 @@ __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: [] };
@@ -7908,7 +8231,6 @@ 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;
@@ -7942,11 +8264,7 @@ __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