@spotify-confidence/openfeature-server-provider-local 0.14.2 → 0.15.1

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## [0.15.1](https://github.com/spotify/confidence-resolver/compare/openfeature-provider-js-v0.15.0...openfeature-provider-js-v0.15.1) (2026-06-05)
+
+
+### Bug Fixes
+
+* register telemetry on bundle resolve path ([#431](https://github.com/spotify/confidence-resolver/issues/431)) ([2ce5c9a](https://github.com/spotify/confidence-resolver/commit/2ce5c9a5eb50be27b3aa8d98bfb1be469d23b7c0))
+
+## [0.15.0](https://github.com/spotify/confidence-resolver/compare/openfeature-provider-js-v0.14.2...openfeature-provider-js-v0.15.0) (2026-05-28)
+
+
+### Features
+
+* support skipping apply using context key ([#421](https://github.com/spotify/confidence-resolver/issues/421)) ([0ad63cc](https://github.com/spotify/confidence-resolver/commit/0ad63ccebef53073e57be42a9ab78a03f14e1851))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * rust-guest bumped from 0.2.3 to 0.2.4
+
 ## [0.14.2](https://github.com/spotify/confidence-resolver/compare/openfeature-provider-js-v0.14.1...openfeature-provider-js-v0.14.2) (2026-05-27)
 
 

package/README.md

@@ -339,6 +339,23 @@ yarn add debug
 
 ---
 
+## Advanced: Controlling Exposure Events
+
+By default, every flag evaluation triggers an exposure event (apply). If you need to resolve a flag without recording an exposure, you can pass `_confidence_skip_apply: true` in the evaluation context:
+
+```typescript
+const value = await client.getBooleanValue('my-flag.enabled', false, {
+  targetingKey: 'user-123',
+  _confidence_skip_apply: true,
+});
+```
+
+The key is automatically stripped from the context before it reaches the resolver.
+
+This is an advanced feature intended for specific use cases such as prefetching or background evaluation. If you're considering using it, reach out to the Confidence team to discuss the best approach for your setup.
+
+---
+
 ## License
 
 See the root `LICENSE`.

package/dist/index.fetch.d.ts

@@ -86,6 +86,8 @@ declare enum ResolveReason {
   RESOLVE_REASON_TYPE_MISMATCH = 9,
   /** RESOLVE_REASON_FLAG_NOT_FOUND - The flag was not found in the resolve response */
   RESOLVE_REASON_FLAG_NOT_FOUND = 10,
+  /** RESOLVE_REASON_BUNDLE - A bundle resolve was performed (multiple flags resolved at once) */
+  RESOLVE_REASON_BUNDLE = 11,
   UNRECOGNIZED = -1,
 }
 declare enum SdkId {
@@ -514,6 +516,7 @@ declare class ConfidenceServerProviderLocal implements Provider {
   initialize(context?: EvaluationContext): Promise<void>;
   onClose(): Promise<void>;
   resolve(context: EvaluationContext, flagNames: string[], apply?: boolean): Promise<FlagBundle$1>;
+  private resolveFlags;
   evaluate<T extends JsonValue>(flagKey: string, defaultValue: T, context: EvaluationContext): Promise<ResolutionDetails<T>>;
   private resolveProcess;
   private handleMaterializationWrites;

package/dist/index.fetch.js

@@ -776,6 +776,7 @@ let ResolveReason = /* @__PURE__ */ function(ResolveReason$1) {
 	ResolveReason$1[ResolveReason$1["RESOLVE_REASON_MATERIALIZATION_NOT_SUPPORTED"] = 8] = "RESOLVE_REASON_MATERIALIZATION_NOT_SUPPORTED";
 	ResolveReason$1[ResolveReason$1["RESOLVE_REASON_TYPE_MISMATCH"] = 9] = "RESOLVE_REASON_TYPE_MISMATCH";
 	ResolveReason$1[ResolveReason$1["RESOLVE_REASON_FLAG_NOT_FOUND"] = 10] = "RESOLVE_REASON_FLAG_NOT_FOUND";
+	ResolveReason$1[ResolveReason$1["RESOLVE_REASON_BUNDLE"] = 11] = "RESOLVE_REASON_BUNDLE";
 	ResolveReason$1[ResolveReason$1["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
 	return ResolveReason$1;
 }({});
@@ -803,6 +804,8 @@ function resolveReasonFromJSON(object) {
 		case "RESOLVE_REASON_TYPE_MISMATCH": return ResolveReason.RESOLVE_REASON_TYPE_MISMATCH;
 		case 10:
 		case "RESOLVE_REASON_FLAG_NOT_FOUND": return ResolveReason.RESOLVE_REASON_FLAG_NOT_FOUND;
+		case 11:
+		case "RESOLVE_REASON_BUNDLE": return ResolveReason.RESOLVE_REASON_BUNDLE;
 		case -1:
 		case "UNRECOGNIZED":
 		default: return ResolveReason.UNRECOGNIZED;
@@ -821,6 +824,7 @@ function resolveReasonToJSON(object) {
 		case ResolveReason.RESOLVE_REASON_MATERIALIZATION_NOT_SUPPORTED: return "RESOLVE_REASON_MATERIALIZATION_NOT_SUPPORTED";
 		case ResolveReason.RESOLVE_REASON_TYPE_MISMATCH: return "RESOLVE_REASON_TYPE_MISMATCH";
 		case ResolveReason.RESOLVE_REASON_FLAG_NOT_FOUND: return "RESOLVE_REASON_FLAG_NOT_FOUND";
+		case ResolveReason.RESOLVE_REASON_BUNDLE: return "RESOLVE_REASON_BUNDLE";
 		case ResolveReason.UNRECOGNIZED:
 		default: return "UNRECOGNIZED";
 	}
@@ -1430,7 +1434,7 @@ function isObject(value) {
 function isSet$3(value) {
 	return value !== null && value !== void 0;
 }
-const VERSION = "0.14.2";
+const VERSION = "0.15.1";
 const NOOP_LOG_FN = Object.assign(() => {}, { enabled: false });
 const debugBackend = loadDebug();
 const logger$2 = new class LoggerImpl {
@@ -2896,6 +2900,24 @@ var ConfidenceServerProviderLocal = class ConfidenceServerProviderLocal {
 		this.main.abort();
 	}
 	async resolve(context, flagNames, apply = false) {
+		const startMs = performance.now();
+		let reason = ResolveReason.RESOLVE_REASON_BUNDLE;
+		try {
+			return await this.resolveFlags(context, flagNames, apply);
+		} catch (err) {
+			reason = ResolveReason.RESOLVE_REASON_ERROR;
+			return error(ErrorCode.GENERAL, String(err));
+		} finally {
+			const latencyUs = Math.round((performance.now() - startMs) * 1e3);
+			try {
+				this.resolver.registerResolve({
+					reason,
+					latencyUs
+				});
+			} catch {}
+		}
+	}
+	async resolveFlags(context, flagNames, apply) {
 		const resolveRequest = {
 			flags: flagNames.map((name) => `flags/${name}`),
 			evaluationContext: ConfidenceServerProviderLocal.convertEvaluationContext(context),
@@ -2906,18 +2928,21 @@ var ConfidenceServerProviderLocal = class ConfidenceServerProviderLocal {
 				version: VERSION
 			}
 		};
-		try {
-			const processRequest = this.materializationStore ? { deferredMaterializations: resolveRequest } : { withoutMaterializations: resolveRequest };
-			return create(await this.resolveProcess(processRequest));
-		} catch (err) {
-			return error(ErrorCode.GENERAL, String(err));
-		}
+		const processRequest = this.materializationStore ? { deferredMaterializations: resolveRequest } : { withoutMaterializations: resolveRequest };
+		return create(await this.resolveProcess(processRequest));
 	}
 	async evaluate(flagKey, defaultValue, context) {
 		const startMs = performance.now();
 		try {
 			const [flagName] = flagKey.split(".", 1);
-			const resolution = await this.resolve(context, [flagName], true);
+			const { _confidence_skip_apply,...cleanContext } = context;
+			const skipApply = _confidence_skip_apply === true;
+			let resolution;
+			try {
+				resolution = await this.resolveFlags(cleanContext, [flagName], !skipApply);
+			} catch (err) {
+				resolution = error(ErrorCode.GENERAL, String(err));
+			}
 			const result = resolve(resolution, flagKey, defaultValue, logger$1);
 			const latencyUs = Math.round((performance.now() - startMs) * 1e3);
 			let reason;

package/dist/index.inlined.d.ts

@@ -86,6 +86,8 @@ declare enum ResolveReason {
   RESOLVE_REASON_TYPE_MISMATCH = 9,
   /** RESOLVE_REASON_FLAG_NOT_FOUND - The flag was not found in the resolve response */
   RESOLVE_REASON_FLAG_NOT_FOUND = 10,
+  /** RESOLVE_REASON_BUNDLE - A bundle resolve was performed (multiple flags resolved at once) */
+  RESOLVE_REASON_BUNDLE = 11,
   UNRECOGNIZED = -1,
 }
 declare enum SdkId {
@@ -514,6 +516,7 @@ declare class ConfidenceServerProviderLocal implements Provider {
   initialize(context?: EvaluationContext): Promise<void>;
   onClose(): Promise<void>;
   resolve(context: EvaluationContext, flagNames: string[], apply?: boolean): Promise<FlagBundle$1>;
+  private resolveFlags;
   evaluate<T extends JsonValue>(flagKey: string, defaultValue: T, context: EvaluationContext): Promise<ResolutionDetails<T>>;
   private resolveProcess;
   private handleMaterializationWrites;