@openfeature/server-sdk 1.6.2 → 1.7.0

package/dist/cjs/index.js

@@ -1,12 +1,10 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -34,14 +32,7 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
@@ -67,580 +58,20 @@ var __async = (__this, __arguments, generator) => {
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  DefaultLogger: () => DefaultLogger,
-  ErrorCode: () => ErrorCode,
-  FlagNotFoundError: () => FlagNotFoundError,
-  GeneralError: () => GeneralError,
   InMemoryProvider: () => InMemoryProvider,
-  InternalEventEmitter: () => InternalEventEmitter,
-  InvalidContextError: () => InvalidContextError,
-  LOG_LEVELS: () => LOG_LEVELS,
   NOOP_PROVIDER: () => NOOP_PROVIDER,
   NOOP_TRANSACTION_CONTEXT_PROPAGATOR: () => NOOP_TRANSACTION_CONTEXT_PROPAGATOR,
   OpenFeature: () => OpenFeature,
   OpenFeatureAPI: () => OpenFeatureAPI,
-  OpenFeatureClient: () => OpenFeatureClient,
-  OpenFeatureCommonAPI: () => OpenFeatureCommonAPI,
-  OpenFeatureError: () => OpenFeatureError,
-  OpenFeatureEventEmitter: () => OpenFeatureEventEmitter,
-  ParseError: () => ParseError,
-  ProviderEvents: () => ProviderEvents,
-  ProviderStatus: () => ProviderStatus,
-  SafeLogger: () => SafeLogger,
-  StandardResolutionReasons: () => StandardResolutionReasons,
-  TargetingKeyMissingError: () => TargetingKeyMissingError,
-  TypeMismatchError: () => TypeMismatchError,
-  isObject: () => isObject,
-  isString: () => isString,
-  objectOrUndefined: () => objectOrUndefined,
-  statusMatchesEvent: () => statusMatchesEvent,
-  stringOrUndefined: () => stringOrUndefined
+  OpenFeatureClient: () => OpenFeatureClient
 });
 module.exports = __toCommonJS(src_exports);
 
-// ../shared/src/errors/open-feature-error-abstract.ts
-var OpenFeatureError = class extends Error {
-  constructor(message) {
-    super(message);
-    Object.setPrototypeOf(this, OpenFeatureError.prototype);
-    this.name = "OpenFeatureError";
-  }
-};
-
-// ../shared/src/evaluation/evaluation.ts
-var StandardResolutionReasons = {
-  /**
-   * The resolved value was the result of a dynamic evaluation, such as a rule or specific user-targeting.
-   */
-  TARGETING_MATCH: "TARGETING_MATCH",
-  /**
-   * The resolved value was the result of pseudorandom assignment.
-   */
-  SPLIT: "SPLIT",
-  /**
-   * The resolved value was the result of the flag being disabled in the management system.
-   */
-  DISABLED: "DISABLED",
-  /**
-   *  The resolved value was configured statically, or otherwise fell back to a pre-configured value.
-   */
-  DEFAULT: "DEFAULT",
-  /**
-   * The reason for the resolved value could not be determined.
-   */
-  UNKNOWN: "UNKNOWN",
-  /**
-   * The resolved value is static (no dynamic evaluation).
-   */
-  STATIC: "STATIC",
-  /**
-   * The resolved value was retrieved from cache.
-   */
-  CACHED: "CACHED",
-  /**
-   * The resolved value was the result of an error.
-   *
-   * Note: The `errorCode` and `errorMessage` fields may contain additional details of this error.
-   */
-  ERROR: "ERROR"
-};
-var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
-  ErrorCode2["PROVIDER_NOT_READY"] = "PROVIDER_NOT_READY";
-  ErrorCode2["FLAG_NOT_FOUND"] = "FLAG_NOT_FOUND";
-  ErrorCode2["PARSE_ERROR"] = "PARSE_ERROR";
-  ErrorCode2["TYPE_MISMATCH"] = "TYPE_MISMATCH";
-  ErrorCode2["TARGETING_KEY_MISSING"] = "TARGETING_KEY_MISSING";
-  ErrorCode2["INVALID_CONTEXT"] = "INVALID_CONTEXT";
-  ErrorCode2["GENERAL"] = "GENERAL";
-  return ErrorCode2;
-})(ErrorCode || {});
-
-// ../shared/src/errors/general-error.ts
-var GeneralError = class extends OpenFeatureError {
-  constructor(message) {
-    super(message);
-    Object.setPrototypeOf(this, GeneralError.prototype);
-    this.name = "GeneralError";
-    this.code = "GENERAL" /* GENERAL */;
-  }
-};
-
-// ../shared/src/errors/flag-not-found-error.ts
-var FlagNotFoundError = class extends OpenFeatureError {
-  constructor(message) {
-    super(message);
-    Object.setPrototypeOf(this, FlagNotFoundError.prototype);
-    this.name = "FlagNotFoundError";
-    this.code = "FLAG_NOT_FOUND" /* FLAG_NOT_FOUND */;
-  }
-};
-
-// ../shared/src/errors/parse-error.ts
-var ParseError = class extends OpenFeatureError {
-  constructor(message) {
-    super(message);
-    Object.setPrototypeOf(this, ParseError.prototype);
-    this.name = "ParseError";
-    this.code = "PARSE_ERROR" /* PARSE_ERROR */;
-  }
-};
-
-// ../shared/src/errors/type-mismatch-error.ts
-var TypeMismatchError = class extends OpenFeatureError {
-  constructor(message) {
-    super(message);
-    Object.setPrototypeOf(this, TypeMismatchError.prototype);
-    this.name = "TypeMismatchError";
-    this.code = "TYPE_MISMATCH" /* TYPE_MISMATCH */;
-  }
-};
-
-// ../shared/src/errors/targeting-key-missing-error.ts
-var TargetingKeyMissingError = class extends OpenFeatureError {
-  constructor(message) {
-    super(message);
-    Object.setPrototypeOf(this, TargetingKeyMissingError.prototype);
-    this.name = "TargetingKeyMissingError";
-    this.code = "TARGETING_KEY_MISSING" /* TARGETING_KEY_MISSING */;
-  }
-};
-
-// ../shared/src/errors/invalid-context-error.ts
-var InvalidContextError = class extends OpenFeatureError {
-  constructor(message) {
-    super(message);
-    Object.setPrototypeOf(this, InvalidContextError.prototype);
-    this.name = "InvalidContextError";
-    this.code = "INVALID_CONTEXT" /* INVALID_CONTEXT */;
-  }
-};
-
-// ../shared/src/provider/provider.ts
-var ProviderStatus = /* @__PURE__ */ ((ProviderStatus2) => {
-  ProviderStatus2["NOT_READY"] = "NOT_READY";
-  ProviderStatus2["READY"] = "READY";
-  ProviderStatus2["ERROR"] = "ERROR";
-  ProviderStatus2["STALE"] = "STALE";
-  return ProviderStatus2;
-})(ProviderStatus || {});
-
-// ../shared/src/events/events.ts
-var ProviderEvents = /* @__PURE__ */ ((ProviderEvents3) => {
-  ProviderEvents3["Ready"] = "PROVIDER_READY";
-  ProviderEvents3["Error"] = "PROVIDER_ERROR";
-  ProviderEvents3["ConfigurationChanged"] = "PROVIDER_CONFIGURATION_CHANGED";
-  ProviderEvents3["Stale"] = "PROVIDER_STALE";
-  return ProviderEvents3;
-})(ProviderEvents || {});
-
-// ../shared/src/events/event-utils.ts
-var eventStatusMap = {
-  ["READY" /* READY */]: "PROVIDER_READY" /* Ready */,
-  ["ERROR" /* ERROR */]: "PROVIDER_ERROR" /* Error */,
-  ["STALE" /* STALE */]: "PROVIDER_STALE" /* Stale */,
-  ["NOT_READY" /* NOT_READY */]: void 0
-};
-var statusMatchesEvent = (event, status) => {
-  return !status && event === "PROVIDER_READY" /* Ready */ || eventStatusMap[status] === event;
-};
-
-// ../shared/src/events/open-feature-event-emitter.ts
-var import_events2 = __toESM(require("events"));
-
-// ../shared/src/logger/default-logger.ts
-var DefaultLogger = class {
-  error(...args) {
-    console.error(...args);
-  }
-  warn(...args) {
-    console.warn(...args);
-  }
-  info() {
-  }
-  debug() {
-  }
-};
-
-// ../shared/src/logger/safe-logger.ts
-var LOG_LEVELS = ["error", "warn", "info", "debug"];
-var SafeLogger = class {
-  constructor(logger) {
-    this.fallbackLogger = new DefaultLogger();
-    try {
-      for (const level of LOG_LEVELS) {
-        if (!logger[level] || typeof logger[level] !== "function") {
-          throw new Error(`The provided logger is missing the ${level} method.`);
-        }
-      }
-      this.logger = logger;
-    } catch (err) {
-      console.error(err);
-      console.error("Falling back to the default logger.");
-      this.logger = this.fallbackLogger;
-    }
-  }
-  error(...args) {
-    this.log("error", ...args);
-  }
-  warn(...args) {
-    this.log("warn", ...args);
-  }
-  info(...args) {
-    this.log("info", ...args);
-  }
-  debug(...args) {
-    this.log("debug", ...args);
-  }
-  log(level, ...args) {
-    try {
-      this.logger[level](...args);
-    } catch (error) {
-      this.fallbackLogger[level](...args);
-    }
-  }
-};
-
-// ../shared/src/events/open-feature-event-emitter.ts
-var GenericEventEmitter = class {
-  constructor(globalLogger) {
-    this.globalLogger = globalLogger;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    this._handlers = /* @__PURE__ */ new WeakMap();
-    this.eventEmitter = new import_events2.default({ captureRejections: true });
-    this.eventEmitter.on("error", (err) => {
-      var _a;
-      (_a = this._logger) == null ? void 0 : _a.error("Error running event handler:", err);
-    });
-  }
-  emit(eventType, context) {
-    this.eventEmitter.emit(eventType, context);
-  }
-  addHandler(eventType, handler) {
-    const asyncHandler = (details) => __async(this, null, function* () {
-      yield handler(details);
-    });
-    this._handlers.set(handler, asyncHandler);
-    this.eventEmitter.on(eventType, asyncHandler);
-  }
-  removeHandler(eventType, handler) {
-    const asyncHandler = this._handlers.get(handler);
-    if (!asyncHandler) {
-      return;
-    }
-    this.eventEmitter.removeListener(eventType, asyncHandler);
-  }
-  removeAllHandlers(eventType) {
-    if (eventType) {
-      this.eventEmitter.removeAllListeners(eventType);
-    } else {
-      this.eventEmitter.removeAllListeners();
-    }
-  }
-  getHandlers(eventType) {
-    return this.eventEmitter.listeners(eventType);
-  }
-  setLogger(logger) {
-    this._eventLogger = new SafeLogger(logger);
-    return this;
-  }
-  get _logger() {
-    var _a, _b;
-    return (_b = this._eventLogger) != null ? _b : (_a = this.globalLogger) == null ? void 0 : _a.call(this);
-  }
-};
-var OpenFeatureEventEmitter = class extends GenericEventEmitter {
-};
-var InternalEventEmitter = class extends GenericEventEmitter {
-};
-
-// ../shared/src/transaction-context/no-op-transaction-context-propagator.ts
-var NoopTransactionContextPropagator = class {
-  getTransactionContext() {
-    return {};
-  }
-  setTransactionContext(_, callback) {
-    callback();
-  }
-};
-var NOOP_TRANSACTION_CONTEXT_PROPAGATOR = new NoopTransactionContextPropagator();
-
-// ../shared/src/type-guards.ts
-function isString(value) {
-  return typeof value === "string";
-}
-function stringOrUndefined(value) {
-  return isString(value) ? value : void 0;
-}
-function isObject(value) {
-  return typeof value === "object";
-}
-function objectOrUndefined(value) {
-  return isObject(value) ? value : void 0;
-}
-
-// ../shared/src/filter.ts
-function isDefined(input) {
-  return typeof input !== "undefined" && input !== null;
-}
-
-// ../shared/src/open-feature.ts
-var OpenFeatureCommonAPI = class {
-  constructor(category) {
-    this._hooks = [];
-    this._transactionContextPropagator = NOOP_TRANSACTION_CONTEXT_PROPAGATOR;
-    this._context = {};
-    this._logger = new DefaultLogger();
-    this._events = new InternalEventEmitter(() => this._logger);
-    this._clientEventHandlers = /* @__PURE__ */ new Map();
-    this._clientProviders = /* @__PURE__ */ new Map();
-    this._clientEvents = /* @__PURE__ */ new Map();
-    this._runsOn = category;
-  }
-  addHooks(...hooks) {
-    this._hooks = [...this._hooks, ...hooks];
-    return this;
-  }
-  getHooks() {
-    return this._hooks;
-  }
-  clearHooks() {
-    this._hooks = [];
-    return this;
-  }
-  setLogger(logger) {
-    this._logger = new SafeLogger(logger);
-    return this;
-  }
-  /**
-   * Get metadata about registered provider.
-   * @returns {ProviderMetadata} Provider Metadata
-   */
-  get providerMetadata() {
-    return this._defaultProvider.metadata;
-  }
-  /**
-   * Adds a handler for the given provider event type.
-   * The handlers are called in the order they have been added.
-   * API (global) events run for all providers.
-   * @param {ProviderEvents} eventType The provider event type to listen to
-   * @param {EventHandler} handler The handler to run on occurrence of the event type
-   */
-  addHandler(eventType, handler) {
-    [.../* @__PURE__ */ new Map([[void 0, this._defaultProvider]]), ...this._clientProviders].forEach((keyProviderTuple) => {
-      var _a;
-      const clientName = keyProviderTuple[0];
-      const provider = keyProviderTuple[1];
-      const shouldRunNow = statusMatchesEvent(eventType, keyProviderTuple[1].status);
-      if (shouldRunNow) {
-        try {
-          handler({ clientName, providerName: provider.metadata.name });
-        } catch (err) {
-          (_a = this._logger) == null ? void 0 : _a.error("Error running event handler:", err);
-        }
-      }
-    });
-    this._events.addHandler(eventType, handler);
-  }
-  /**
-   * Removes a handler for the given provider event type.
-   * @param {ProviderEvents} eventType The provider event type to remove the listener for
-   * @param {EventHandler} handler The handler to remove for the provider event type
-   */
-  removeHandler(eventType, handler) {
-    this._events.removeHandler(eventType, handler);
-  }
-  /**
-   * Gets the current handlers for the given provider event type.
-   * @param {ProviderEvents} eventType The provider event type to get the current handlers for
-   * @returns {EventHandler[]} The handlers currently attached to the given provider event type
-   */
-  getHandlers(eventType) {
-    return this._events.getHandlers(eventType);
-  }
-  setProviderAndWait(clientOrProvider, providerOrUndefined) {
-    return __async(this, null, function* () {
-      yield this.setAwaitableProvider(clientOrProvider, providerOrUndefined);
-    });
-  }
-  setProvider(clientOrProvider, providerOrUndefined) {
-    const maybePromise = this.setAwaitableProvider(clientOrProvider, providerOrUndefined);
-    if (maybePromise) {
-      maybePromise.catch(() => {
-      });
-    }
-    return this;
-  }
-  setAwaitableProvider(clientOrProvider, providerOrUndefined) {
-    var _a, _b, _c, _d, _e, _f;
-    const clientName = stringOrUndefined(clientOrProvider);
-    const provider = (_a = objectOrUndefined(clientOrProvider)) != null ? _a : objectOrUndefined(providerOrUndefined);
-    if (!provider) {
-      this._logger.debug("No provider defined, ignoring setProvider call");
-      return;
-    }
-    const oldProvider = this.getProviderForClient(clientName);
-    const providerName = provider.metadata.name;
-    if (oldProvider === provider) {
-      this._logger.debug("Provider is already set, ignoring setProvider call");
-      return;
-    }
-    if (!provider.runsOn) {
-      this._logger.debug(`Provider '${provider.metadata.name}' has not defined its intended use.`);
-    } else if (provider.runsOn !== this._runsOn) {
-      throw new GeneralError(`Provider '${provider.metadata.name}' is intended for use on the ${provider.runsOn}.`);
-    }
-    const emitters = this.getAssociatedEventEmitters(clientName);
-    if (typeof provider.initialize === "function" && provider.status === void 0) {
-      const activeLogger = this._logger || console;
-      activeLogger.warn(
-        `Provider ${providerName} implements 'initialize' but not 'status'. Please implement 'status'.`
-      );
-    }
-    let initializationPromise = void 0;
-    if ((provider == null ? void 0 : provider.status) === "NOT_READY" /* NOT_READY */ && typeof provider.initialize === "function") {
-      initializationPromise = (_d = (_c = (_b = provider.initialize) == null ? void 0 : _b.call(provider, this._context)) == null ? void 0 : _c.then(() => {
-        var _a2;
-        this.getAssociatedEventEmitters(clientName).forEach((emitter) => {
-          emitter == null ? void 0 : emitter.emit("PROVIDER_READY" /* Ready */, { clientName, providerName });
-        });
-        (_a2 = this._events) == null ? void 0 : _a2.emit("PROVIDER_READY" /* Ready */, { clientName, providerName });
-      })) == null ? void 0 : _d.catch((error) => {
-        var _a2;
-        this.getAssociatedEventEmitters(clientName).forEach((emitter) => {
-          emitter == null ? void 0 : emitter.emit("PROVIDER_ERROR" /* Error */, { clientName, providerName, message: error.message });
-        });
-        (_a2 = this._events) == null ? void 0 : _a2.emit("PROVIDER_ERROR" /* Error */, { clientName, providerName, message: error.message });
-        throw error;
-      });
-    } else {
-      emitters.forEach((emitter) => {
-        emitter == null ? void 0 : emitter.emit("PROVIDER_READY" /* Ready */, { clientName, providerName });
-      });
-      (_e = this._events) == null ? void 0 : _e.emit("PROVIDER_READY" /* Ready */, { clientName, providerName });
-    }
-    if (clientName) {
-      this._clientProviders.set(clientName, provider);
-    } else {
-      this._defaultProvider = provider;
-    }
-    this.transferListeners(oldProvider, provider, clientName, emitters);
-    if (![...this._clientProviders.values(), this._defaultProvider].includes(oldProvider)) {
-      (_f = oldProvider == null ? void 0 : oldProvider.onClose) == null ? void 0 : _f.call(oldProvider);
-    }
-    return initializationPromise;
-  }
-  getProviderForClient(name) {
-    var _a;
-    if (!name) {
-      return this._defaultProvider;
-    }
-    return (_a = this._clientProviders.get(name)) != null ? _a : this._defaultProvider;
-  }
-  buildAndCacheEventEmitterForClient(name) {
-    const emitter = this._clientEvents.get(name);
-    if (emitter) {
-      return emitter;
-    }
-    const newEmitter = new InternalEventEmitter(() => this._logger);
-    this._clientEvents.set(name, newEmitter);
-    const clientProvider = this.getProviderForClient(name);
-    Object.values(ProviderEvents).forEach(
-      (eventType) => {
-        var _a;
-        return (_a = clientProvider.events) == null ? void 0 : _a.addHandler(eventType, (details) => __async(this, null, function* () {
-          newEmitter.emit(eventType, __spreadProps(__spreadValues({}, details), { clientName: name, providerName: clientProvider.metadata.name }));
-        }));
-      }
-    );
-    return newEmitter;
-  }
-  getUnboundEmitters() {
-    const namedProviders = [...this._clientProviders.keys()];
-    const eventEmitterNames = [...this._clientEvents.keys()].filter(isDefined);
-    const unboundEmitterNames = eventEmitterNames.filter((name) => !namedProviders.includes(name));
-    return [
-      // all unbound, named emitters
-      ...unboundEmitterNames.map((name) => this._clientEvents.get(name)),
-      // the default emitter
-      this._clientEvents.get(void 0)
-    ].filter(isDefined);
-  }
-  getAssociatedEventEmitters(clientName) {
-    return clientName ? [this.buildAndCacheEventEmitterForClient(clientName)] : this.getUnboundEmitters();
-  }
-  transferListeners(oldProvider, newProvider, clientName, emitters) {
-    var _a;
-    (_a = this._clientEventHandlers.get(clientName)) == null ? void 0 : _a.forEach((eventHandler) => {
-      var _a2;
-      return (_a2 = oldProvider.events) == null ? void 0 : _a2.removeHandler(...eventHandler);
-    });
-    const newClientHandlers = Object.values(ProviderEvents).map((eventType) => {
-      const handler = (details) => __async(this, null, function* () {
-        emitters.forEach((emitter) => {
-          emitter == null ? void 0 : emitter.emit(eventType, __spreadProps(__spreadValues({}, details), { clientName, providerName: newProvider.metadata.name }));
-        });
-        this._events.emit(eventType, __spreadProps(__spreadValues({}, details), { clientName, providerName: newProvider.metadata.name }));
-      });
-      return [eventType, handler];
-    });
-    this._clientEventHandlers.set(clientName, newClientHandlers);
-    newClientHandlers.forEach((eventHandler) => {
-      var _a2;
-      return (_a2 = newProvider.events) == null ? void 0 : _a2.addHandler(...eventHandler);
-    });
-  }
-  close() {
-    return __async(this, null, function* () {
-      var _a, _b;
-      try {
-        yield (_b = (_a = this == null ? void 0 : this._defaultProvider) == null ? void 0 : _a.onClose) == null ? void 0 : _b.call(_a);
-      } catch (err) {
-        this.handleShutdownError(this._defaultProvider, err);
-      }
-      const providers = Array.from(this._clientProviders);
-      yield Promise.all(
-        providers.map((_0) => __async(this, [_0], function* ([, provider]) {
-          var _a2;
-          try {
-            yield (_a2 = provider.onClose) == null ? void 0 : _a2.call(provider);
-          } catch (err) {
-            this.handleShutdownError(this._defaultProvider, err);
-          }
-        }))
-      );
-    });
-  }
-  handleShutdownError(provider, err) {
-    this._logger.error(`Error during shutdown of provider ${provider.metadata.name}: ${err}`);
-    this._logger.error(err == null ? void 0 : err.stack);
-  }
-  setTransactionContextPropagator(transactionContextPropagator) {
-    const baseMessage = "Invalid TransactionContextPropagator, will not be set: ";
-    if (typeof (transactionContextPropagator == null ? void 0 : transactionContextPropagator.getTransactionContext) !== "function") {
-      this._logger.error(`${baseMessage}: getTransactionContext is not a function.`);
-    } else if (typeof (transactionContextPropagator == null ? void 0 : transactionContextPropagator.setTransactionContext) !== "function") {
-      this._logger.error(`${baseMessage}: setTransactionContext is not a function.`);
-    } else {
-      this._transactionContextPropagator = transactionContextPropagator;
-    }
-    return this;
-  }
-  setTransactionContext(transactionContext, callback, ...args) {
-    this._transactionContextPropagator.setTransactionContext(transactionContext, callback, ...args);
-  }
-  getTransactionContext() {
-    try {
-      return this._transactionContextPropagator.getTransactionContext();
-    } catch (err) {
-      const error = err;
-      this._logger.error(`Error getting transaction context: ${error == null ? void 0 : error.message}, returning empty context.`);
-      this._logger.error(error == null ? void 0 : error.stack);
-      return {};
-    }
-  }
-};
+// src/client/open-feature-client.ts
+var import_core5 = require("@openfeature/core");
 
 // src/provider/no-op-provider.ts
+var import_core = require("@openfeature/core");
 var REASON_NO_OP = "No-op";
 var NoopFeatureProvider = class {
   constructor() {
@@ -649,7 +80,7 @@ var NoopFeatureProvider = class {
     };
   }
   get status() {
-    return "NOT_READY" /* NOT_READY */;
+    return import_core.ProviderStatus.NOT_READY;
   }
   resolveBooleanEvaluation(_, defaultValue) {
     return this.noOp(defaultValue);
@@ -672,20 +103,24 @@ var NoopFeatureProvider = class {
 };
 var NOOP_PROVIDER = new NoopFeatureProvider();
 
+// src/provider/in-memory-provider/in-memory-provider.ts
+var import_core3 = require("@openfeature/core");
+
 // src/provider/in-memory-provider/variant-not-found-error.ts
-var VariantFoundError = class extends OpenFeatureError {
+var import_core2 = require("@openfeature/core");
+var VariantFoundError = class extends import_core2.OpenFeatureError {
   constructor(message) {
     super(message);
     Object.setPrototypeOf(this, VariantFoundError.prototype);
     this.name = "VariantFoundError";
-    this.code = "GENERAL" /* GENERAL */;
+    this.code = import_core2.ErrorCode.GENERAL;
   }
 };
 
 // src/provider/in-memory-provider/in-memory-provider.ts
 var InMemoryProvider = class {
   constructor(flagConfiguration = {}) {
-    this.events = new OpenFeatureEventEmitter();
+    this.events = new import_core3.OpenFeatureEventEmitter();
     this.runsOn = "server";
     this.metadata = {
       name: "in-memory"
@@ -699,7 +134,7 @@ var InMemoryProvider = class {
   putConfiguration(flagConfiguration) {
     const flagsChanged = Object.entries(flagConfiguration).filter(([key, value]) => this._flagConfiguration[key] !== value).map(([key]) => key);
     this._flagConfiguration = __spreadValues({}, flagConfiguration);
-    this.events.emit("PROVIDER_CONFIGURATION_CHANGED" /* ConfigurationChanged */, { flagsChanged });
+    this.events.emit(import_core3.ProviderEvents.ConfigurationChanged, { flagsChanged });
   }
   resolveBooleanEvaluation(flagKey, defaultValue, context, logger) {
     return this.resolveFlagWithReason(flagKey, defaultValue, context, logger);
@@ -722,12 +157,12 @@ var InMemoryProvider = class {
       try {
         const resolutionResult = this.lookupFlagValue(flagKey, defaultValue, ctx, logger);
         if (typeof (resolutionResult == null ? void 0 : resolutionResult.value) != typeof defaultValue) {
-          throw new TypeMismatchError();
+          throw new import_core3.TypeMismatchError();
         }
         return resolutionResult;
       } catch (error) {
-        if (!(error instanceof OpenFeatureError)) {
-          throw new GeneralError((error == null ? void 0 : error.message) || "unknown error");
+        if (!(error instanceof import_core3.OpenFeatureError)) {
+          throw new import_core3.GeneralError((error == null ? void 0 : error.message) || "unknown error");
         }
         throw error;
       }
@@ -738,11 +173,11 @@ var InMemoryProvider = class {
     if (!(flagKey in this._flagConfiguration)) {
       const message = `no flag found with key ${flagKey}`;
       logger == null ? void 0 : logger.debug(message);
-      throw new FlagNotFoundError(message);
+      throw new import_core3.FlagNotFoundError(message);
     }
     const flagSpec = this._flagConfiguration[flagKey];
     if (flagSpec.disabled) {
-      return { value: defaultValue, reason: StandardResolutionReasons.DISABLED };
+      return { value: defaultValue, reason: import_core3.StandardResolutionReasons.DISABLED };
     }
     const isContextEval = ctx && (flagSpec == null ? void 0 : flagSpec.contextEvaluator);
     const variant = isContextEval ? (_a = flagSpec.contextEvaluator) == null ? void 0 : _a.call(flagSpec, ctx) : flagSpec.defaultVariant;
@@ -755,18 +190,32 @@ var InMemoryProvider = class {
     return __spreadProps(__spreadValues({
       value
     }, variant && { variant }), {
-      reason: isContextEval ? StandardResolutionReasons.TARGETING_MATCH : StandardResolutionReasons.STATIC
+      reason: isContextEval ? import_core3.StandardResolutionReasons.TARGETING_MATCH : import_core3.StandardResolutionReasons.STATIC
     });
   }
 };
 
+// src/open-feature.ts
+var import_core4 = require("@openfeature/core");
+
+// src/transaction-context/no-op-transaction-context-propagator.ts
+var NoopTransactionContextPropagator = class {
+  getTransactionContext() {
+    return {};
+  }
+  setTransactionContext(_, callback) {
+    callback();
+  }
+};
+var NOOP_TRANSACTION_CONTEXT_PROPAGATOR = new NoopTransactionContextPropagator();
+
 // src/open-feature.ts
 var GLOBAL_OPENFEATURE_API_KEY = Symbol.for("@openfeature/js-sdk/api");
 var _globalThis = globalThis;
-var OpenFeatureAPI = class extends OpenFeatureCommonAPI {
-  // eslint-disable-next-line @typescript-eslint/no-empty-function
+var OpenFeatureAPI = class extends import_core4.OpenFeatureCommonAPI {
   constructor() {
     super("server");
+    this._transactionContextPropagator = NOOP_TRANSACTION_CONTEXT_PROPAGATOR;
     this._defaultProvider = NOOP_PROVIDER;
   }
   /**
@@ -792,9 +241,9 @@ var OpenFeatureAPI = class extends OpenFeatureCommonAPI {
   }
   getClient(nameOrContext, versionOrContext, contextOrUndefined) {
     var _a, _b;
-    const name = stringOrUndefined(nameOrContext);
-    const version = stringOrUndefined(versionOrContext);
-    const context = (_b = (_a = objectOrUndefined(nameOrContext)) != null ? _a : objectOrUndefined(versionOrContext)) != null ? _b : objectOrUndefined(contextOrUndefined);
+    const name = (0, import_core4.stringOrUndefined)(nameOrContext);
+    const version = (0, import_core4.stringOrUndefined)(versionOrContext);
+    const context = (_b = (_a = (0, import_core4.objectOrUndefined)(nameOrContext)) != null ? _a : (0, import_core4.objectOrUndefined)(versionOrContext)) != null ? _b : (0, import_core4.objectOrUndefined)(contextOrUndefined);
     return new OpenFeatureClient(
       () => this.getProviderForClient(name),
       () => this.buildAndCacheEventEmitterForClient(name),
@@ -803,6 +252,37 @@ var OpenFeatureAPI = class extends OpenFeatureCommonAPI {
       context
     );
   }
+  /**
+   * Clears all registered providers and resets the default provider.
+   * @returns {Promise<void>}
+   */
+  clearProviders() {
+    return super.clearProvidersAndSetDefault(NOOP_PROVIDER);
+  }
+  setTransactionContextPropagator(transactionContextPropagator) {
+    const baseMessage = "Invalid TransactionContextPropagator, will not be set: ";
+    if (typeof (transactionContextPropagator == null ? void 0 : transactionContextPropagator.getTransactionContext) !== "function") {
+      this._logger.error(`${baseMessage}: getTransactionContext is not a function.`);
+    } else if (typeof (transactionContextPropagator == null ? void 0 : transactionContextPropagator.setTransactionContext) !== "function") {
+      this._logger.error(`${baseMessage}: setTransactionContext is not a function.`);
+    } else {
+      this._transactionContextPropagator = transactionContextPropagator;
+    }
+    return this;
+  }
+  setTransactionContext(transactionContext, callback, ...args) {
+    this._transactionContextPropagator.setTransactionContext(transactionContext, callback, ...args);
+  }
+  getTransactionContext() {
+    try {
+      return this._transactionContextPropagator.getTransactionContext();
+    } catch (err) {
+      const error = err;
+      this._logger.error(`Error getting transaction context: ${error == null ? void 0 : error.message}, returning empty context.`);
+      this._logger.error(error == null ? void 0 : error.stack);
+      return {};
+    }
+  }
 };
 var OpenFeature = OpenFeatureAPI.getInstance();
 
@@ -826,7 +306,7 @@ var OpenFeatureClient = class {
   addHandler(eventType, handler) {
     var _a;
     this.emitterAccessor().addHandler(eventType, handler);
-    const shouldRunNow = statusMatchesEvent(eventType, this._provider.status);
+    const shouldRunNow = (0, import_core5.statusMatchesEvent)(eventType, this._provider.status);
     if (shouldRunNow) {
       try {
         handler({ clientName: this.metadata.name, providerName: this._provider.metadata.name });
@@ -842,7 +322,7 @@ var OpenFeatureClient = class {
     return this.emitterAccessor().getHandlers(eventType);
   }
   setLogger(logger) {
-    this._clientLogger = new SafeLogger(logger);
+    this._clientLogger = new import_core5.SafeLogger(logger);
     return this;
   }
   setContext(context) {
@@ -949,13 +429,13 @@ var OpenFeatureClient = class {
         return evaluationDetails;
       } catch (err) {
         const errorMessage = err == null ? void 0 : err.message;
-        const errorCode = (err == null ? void 0 : err.code) || "GENERAL" /* GENERAL */;
+        const errorCode = (err == null ? void 0 : err.code) || import_core5.ErrorCode.GENERAL;
         yield this.errorHooks(allHooksReversed, hookContext, err, options);
         return {
           errorCode,
           errorMessage,
           value: defaultValue,
-          reason: StandardResolutionReasons.ERROR,
+          reason: import_core5.StandardResolutionReasons.ERROR,
           flagMetadata: Object.freeze({}),
           flagKey
         };
@@ -1021,35 +501,16 @@ var OpenFeatureClient = class {
     return this._clientLogger || this.globalLogger();
   }
 };
+
+// src/index.ts
+__reExport(src_exports, require("@openfeature/core"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  DefaultLogger,
-  ErrorCode,
-  FlagNotFoundError,
-  GeneralError,
   InMemoryProvider,
-  InternalEventEmitter,
-  InvalidContextError,
-  LOG_LEVELS,
   NOOP_PROVIDER,
   NOOP_TRANSACTION_CONTEXT_PROPAGATOR,
   OpenFeature,
   OpenFeatureAPI,
-  OpenFeatureClient,
-  OpenFeatureCommonAPI,
-  OpenFeatureError,
-  OpenFeatureEventEmitter,
-  ParseError,
-  ProviderEvents,
-  ProviderStatus,
-  SafeLogger,
-  StandardResolutionReasons,
-  TargetingKeyMissingError,
-  TypeMismatchError,
-  isObject,
-  isString,
-  objectOrUndefined,
-  statusMatchesEvent,
-  stringOrUndefined
+  OpenFeatureClient
 });
 //# sourceMappingURL=index.js.map