@adobe-commerce/aio-toolkit 1.0.9 → 1.0.10

package/dist/index.mjs

@@ -1,435 +1,646 @@
 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 __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
-// 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"() {
+// 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";
-    _globalThis = typeof globalThis === "object" ? globalThis : global;
   }
 });
 
-// node_modules/@opentelemetry/api/build/esm/platform/node/index.js
-var init_node = __esm({
-  "node_modules/@opentelemetry/api/build/esm/platform/node/index.js"() {
+// 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_globalThis();
+    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;
   }
 });
 
-// node_modules/@opentelemetry/api/build/esm/platform/index.js
-var init_platform = __esm({
-  "node_modules/@opentelemetry/api/build/esm/platform/index.js"() {
+// 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_node();
+    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;
   }
 });
 
-// node_modules/@opentelemetry/api/build/esm/version.js
-var VERSION;
-var init_version = __esm({
-  "node_modules/@opentelemetry/api/build/esm/version.js"() {
+// 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";
-    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;
-    };
-  }
-  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);
+    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);
       }
-      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);
+    };
+    __name(_ResourceFactory, "ResourceFactory");
+    ResourceFactory = _ResourceFactory;
   }
 });
 
-// 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"() {
+// 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_platform();
-    init_version();
-    init_semver();
-    major = VERSION.split(".")[0];
-    GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for("opentelemetry.js.api." + major);
-    _global = _globalThis;
-    __name(registerGlobal, "registerGlobal");
-    __name(getGlobal, "getGlobal");
-    __name(unregisterGlobal, "unregisterGlobal");
+    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;
   }
 });
 
-// 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"() {
+// 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_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 (r && !r.done && (m = i["return"])) m.call(i);
-        } finally {
-          if (e) throw e.error;
+    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;
       }
-      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];
+      /**
+       * 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);
       }
-      return to.concat(ar || Array.prototype.slice.call(from));
-    };
-    DiagComponentLogger = /** @class */
-    (function() {
-      function DiagComponentLogger2(props) {
-        this._namespace = props.namespace || "DiagComponentLogger";
+      /**
+       * 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(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");
-  }
-});
-
-// 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 = {}));
-  }
-});
-
-// 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_types();
-    __name(createLogLevelDiagLogger, "createLogLevelDiagLogger");
+    __name(_JsonMessageProcessor, "JsonMessageProcessor");
+    JsonMessageProcessor = _JsonMessageProcessor;
   }
 });
 
-// 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"() {
+// 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_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;
-        }
+    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();
       }
-      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];
-        }
+      /**
+       * 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 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];
+      /**
+       * 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");
             }
-            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
+            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 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);
+          }),
+          isSuccessful: this.successChecker.execute.bind(this.successChecker)
         };
-        self.createComponentLogger = function(options) {
-          return new DiagComponentLogger(options);
+      }
+      /**
+       * 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.verbose = _logProxy("verbose");
-        self.debug = _logProxy("debug");
-        self.info = _logProxy("info");
-        self.warn = _logProxy("warn");
-        self.error = _logProxy("error");
       }
-      __name(DiagAPI2, "DiagAPI");
-      DiagAPI2.instance = function() {
-        if (!this._instance) {
-          this._instance = new DiagAPI2();
-        }
-        return this._instance;
-      };
-      return DiagAPI2;
-    })();
+      /**
+       * 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;
   }
 });
 
-// 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/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/index.ts
+init_esm_shims();
+
+// src/framework/runtime-action/index.ts
+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";
@@ -492,6 +703,7 @@ 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.
@@ -557,701 +769,8 @@ 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.
@@ -1261,7 +780,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; otherwise uses Core.Logger.
+   * 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.
    *
@@ -1298,11 +817,59 @@ var _Telemetry = class _Telemetry {
    * ```
    */
   static createLogger(name, params) {
-    const baseLogger = !params.ENABLE_TELEMETRY ? Core.Logger(name, {
-      level: params.LOG_LEVEL || "info"
-    }) : getLogger(name, {
-      level: params.LOG_LEVEL || "info"
+    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"];
@@ -1450,16 +1017,27 @@ var _Telemetry = class _Telemetry {
    */
   static initialize(action) {
     return async (params) => {
-      const newRelicTelemetry = new new_relic_default();
-      if (newRelicTelemetry.canInitialize(params)) {
+      if (params.ENABLE_TELEMETRY && params.NEW_RELIC_TELEMETRY) {
         try {
-          const instrumentedAction = newRelicTelemetry.initialize(action);
-          return await instrumentedAction(params);
+          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 : "Telemetry initialization failed";
+          const errorMessage = error instanceof Error ? error.message : "Failed to load telemetry module";
           return response_default.error(
             500 /* INTERNAL_ERROR */,
-            `Telemetry configuration error: ${errorMessage}`
+            `Telemetry module error: ${errorMessage}`
           );
         }
       }
@@ -1659,7 +1237,11 @@ _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.
@@ -1682,6 +1264,7 @@ 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
@@ -1768,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 = `
@@ -1845,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 {
   /**
@@ -1872,6 +1457,7 @@ 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
@@ -1956,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 {
   /**
@@ -2112,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)
@@ -2252,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";
@@ -2359,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) {
@@ -2398,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) {
@@ -2439,10 +2041,10 @@ var _WebhookActionResponse = class _WebhookActionResponse {
    * };
    * ```
    */
-  static remove(path) {
+  static remove(path2) {
     return {
       op: "remove" /* REMOVE */,
-      path
+      path: path2
     };
   }
 };
@@ -2451,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";
@@ -2538,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
@@ -2574,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");
@@ -2584,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.
@@ -2940,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 {
   /**
@@ -3299,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
+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: {
@@ -3539,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
@@ -3715,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
@@ -3882,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
@@ -4208,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
@@ -4399,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
@@ -4569,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
@@ -4833,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
@@ -5142,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
@@ -5327,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
@@ -5445,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
@@ -5564,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
@@ -6027,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
@@ -6242,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
@@ -6515,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 = {
@@ -6809,6 +6467,7 @@ 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 {
@@ -6905,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
@@ -7438,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 {
   /**
@@ -7577,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 {
   /**
@@ -7779,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 {
@@ -7838,6 +7510,7 @@ 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
@@ -7880,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: [] };
@@ -8231,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;
@@ -8264,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