@spotify-confidence/openfeature-server-provider-local 0.6.0 → 0.8.0

package/dist/index.node.js

@@ -1112,14 +1112,14 @@ const ResolveFlagsResponse = {
 	fromJSON(object) {
 		return {
 			resolvedFlags: globalThis.Array.isArray(object?.resolvedFlags) ? object.resolvedFlags.map((e) => ResolvedFlag.fromJSON(e)) : [],
-			resolveToken: isSet$3(object.resolveToken) ? bytesFromBase64$1(object.resolveToken) : new Uint8Array(0),
+			resolveToken: isSet$3(object.resolveToken) ? bytesFromBase64$2(object.resolveToken) : new Uint8Array(0),
 			resolveId: isSet$3(object.resolveId) ? globalThis.String(object.resolveId) : ""
 		};
 	},
 	toJSON(message) {
 		const obj = {};
 		if (message.resolvedFlags?.length) obj.resolvedFlags = message.resolvedFlags.map((e) => ResolvedFlag.toJSON(e));
-		if (message.resolveToken.length !== 0) obj.resolveToken = base64FromBytes$1(message.resolveToken);
+		if (message.resolveToken.length !== 0) obj.resolveToken = base64FromBytes$2(message.resolveToken);
 		if (message.resolveId !== "") obj.resolveId = message.resolveId;
 		return obj;
 	},
@@ -1134,13 +1134,151 @@ const ResolveFlagsResponse = {
 		return message;
 	}
 };
+function createBaseApplyFlagsRequest() {
+	return {
+		flags: [],
+		clientSecret: "",
+		resolveToken: new Uint8Array(0),
+		sendTime: void 0,
+		sdk: void 0
+	};
+}
+const ApplyFlagsRequest = {
+	encode(message, writer = new BinaryWriter()) {
+		for (const v of message.flags) AppliedFlag.encode(v, writer.uint32(10).fork()).join();
+		if (message.clientSecret !== "") writer.uint32(18).string(message.clientSecret);
+		if (message.resolveToken.length !== 0) writer.uint32(26).bytes(message.resolveToken);
+		if (message.sendTime !== void 0) Timestamp.encode(toTimestamp(message.sendTime), writer.uint32(34).fork()).join();
+		if (message.sdk !== void 0) Sdk.encode(message.sdk, writer.uint32(42).fork()).join();
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+		const end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseApplyFlagsRequest();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 10) break;
+					message.flags.push(AppliedFlag.decode(reader, reader.uint32()));
+					continue;
+				case 2:
+					if (tag !== 18) break;
+					message.clientSecret = reader.string();
+					continue;
+				case 3:
+					if (tag !== 26) break;
+					message.resolveToken = reader.bytes();
+					continue;
+				case 4:
+					if (tag !== 34) break;
+					message.sendTime = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+					continue;
+				case 5:
+					if (tag !== 42) break;
+					message.sdk = Sdk.decode(reader, reader.uint32());
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return {
+			flags: globalThis.Array.isArray(object?.flags) ? object.flags.map((e) => AppliedFlag.fromJSON(e)) : [],
+			clientSecret: isSet$3(object.clientSecret) ? globalThis.String(object.clientSecret) : "",
+			resolveToken: isSet$3(object.resolveToken) ? bytesFromBase64$2(object.resolveToken) : new Uint8Array(0),
+			sendTime: isSet$3(object.sendTime) ? fromJsonTimestamp(object.sendTime) : void 0,
+			sdk: isSet$3(object.sdk) ? Sdk.fromJSON(object.sdk) : void 0
+		};
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.flags?.length) obj.flags = message.flags.map((e) => AppliedFlag.toJSON(e));
+		if (message.clientSecret !== "") obj.clientSecret = message.clientSecret;
+		if (message.resolveToken.length !== 0) obj.resolveToken = base64FromBytes$2(message.resolveToken);
+		if (message.sendTime !== void 0) obj.sendTime = message.sendTime.toISOString();
+		if (message.sdk !== void 0) obj.sdk = Sdk.toJSON(message.sdk);
+		return obj;
+	},
+	create(base) {
+		return ApplyFlagsRequest.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseApplyFlagsRequest();
+		message.flags = object.flags?.map((e) => AppliedFlag.fromPartial(e)) || [];
+		message.clientSecret = object.clientSecret ?? "";
+		message.resolveToken = object.resolveToken ?? new Uint8Array(0);
+		message.sendTime = object.sendTime ?? void 0;
+		message.sdk = object.sdk !== void 0 && object.sdk !== null ? Sdk.fromPartial(object.sdk) : void 0;
+		return message;
+	}
+};
+function createBaseAppliedFlag() {
+	return {
+		flag: "",
+		applyTime: void 0
+	};
+}
+const AppliedFlag = {
+	encode(message, writer = new BinaryWriter()) {
+		if (message.flag !== "") writer.uint32(10).string(message.flag);
+		if (message.applyTime !== void 0) Timestamp.encode(toTimestamp(message.applyTime), writer.uint32(18).fork()).join();
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+		const end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseAppliedFlag();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 10) break;
+					message.flag = reader.string();
+					continue;
+				case 2:
+					if (tag !== 18) break;
+					message.applyTime = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return {
+			flag: isSet$3(object.flag) ? globalThis.String(object.flag) : "",
+			applyTime: isSet$3(object.applyTime) ? fromJsonTimestamp(object.applyTime) : void 0
+		};
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.flag !== "") obj.flag = message.flag;
+		if (message.applyTime !== void 0) obj.applyTime = message.applyTime.toISOString();
+		return obj;
+	},
+	create(base) {
+		return AppliedFlag.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseAppliedFlag();
+		message.flag = object.flag ?? "";
+		message.applyTime = object.applyTime ?? void 0;
+		return message;
+	}
+};
 function createBaseResolvedFlag() {
 	return {
 		flag: "",
 		variant: "",
 		value: void 0,
 		flagSchema: void 0,
-		reason: 0
+		reason: 0,
+		shouldApply: false
 	};
 }
 const ResolvedFlag = {
@@ -1150,6 +1288,7 @@ const ResolvedFlag = {
 		if (message.value !== void 0) Struct.encode(Struct.wrap(message.value), writer.uint32(26).fork()).join();
 		if (message.flagSchema !== void 0) FlagSchema_StructFlagSchema.encode(message.flagSchema, writer.uint32(34).fork()).join();
 		if (message.reason !== 0) writer.uint32(40).int32(message.reason);
+		if (message.shouldApply !== false) writer.uint32(48).bool(message.shouldApply);
 		return writer;
 	},
 	decode(input, length) {
@@ -1179,6 +1318,10 @@ const ResolvedFlag = {
 					if (tag !== 40) break;
 					message.reason = reader.int32();
 					continue;
+				case 6:
+					if (tag !== 48) break;
+					message.shouldApply = reader.bool();
+					continue;
 			}
 			if ((tag & 7) === 4 || tag === 0) break;
 			reader.skip(tag & 7);
@@ -1191,7 +1334,8 @@ const ResolvedFlag = {
 			variant: isSet$3(object.variant) ? globalThis.String(object.variant) : "",
 			value: isObject(object.value) ? object.value : void 0,
 			flagSchema: isSet$3(object.flagSchema) ? FlagSchema_StructFlagSchema.fromJSON(object.flagSchema) : void 0,
-			reason: isSet$3(object.reason) ? resolveReasonFromJSON(object.reason) : 0
+			reason: isSet$3(object.reason) ? resolveReasonFromJSON(object.reason) : 0,
+			shouldApply: isSet$3(object.shouldApply) ? globalThis.Boolean(object.shouldApply) : false
 		};
 	},
 	toJSON(message) {
@@ -1201,6 +1345,7 @@ const ResolvedFlag = {
 		if (message.value !== void 0) obj.value = message.value;
 		if (message.flagSchema !== void 0) obj.flagSchema = FlagSchema_StructFlagSchema.toJSON(message.flagSchema);
 		if (message.reason !== 0) obj.reason = resolveReasonToJSON(message.reason);
+		if (message.shouldApply !== false) obj.shouldApply = message.shouldApply;
 		return obj;
 	},
 	create(base) {
@@ -1213,10 +1358,11 @@ const ResolvedFlag = {
 		message.value = object.value ?? void 0;
 		message.flagSchema = object.flagSchema !== void 0 && object.flagSchema !== null ? FlagSchema_StructFlagSchema.fromPartial(object.flagSchema) : void 0;
 		message.reason = object.reason ?? 0;
+		message.shouldApply = object.shouldApply ?? false;
 		return message;
 	}
 };
-function bytesFromBase64$1(b64) {
+function bytesFromBase64$2(b64) {
 	if (globalThis.Buffer) return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
 	else {
 		const bin = globalThis.atob(b64);
@@ -1225,7 +1371,7 @@ function bytesFromBase64$1(b64) {
 		return arr;
 	}
 }
-function base64FromBytes$1(arr) {
+function base64FromBytes$2(arr) {
 	if (globalThis.Buffer) return globalThis.Buffer.from(arr).toString("base64");
 	else {
 		const bin = [];
@@ -1235,13 +1381,31 @@ function base64FromBytes$1(arr) {
 		return globalThis.btoa(bin.join(""));
 	}
 }
+function toTimestamp(date) {
+	const seconds = Math.trunc(date.getTime() / 1e3);
+	const nanos = date.getTime() % 1e3 * 1e6;
+	return {
+		seconds,
+		nanos
+	};
+}
+function fromTimestamp(t) {
+	let millis = (t.seconds || 0) * 1e3;
+	millis += (t.nanos || 0) / 1e6;
+	return new globalThis.Date(millis);
+}
+function fromJsonTimestamp(o) {
+	if (o instanceof globalThis.Date) return o;
+	else if (typeof o === "string") return new globalThis.Date(o);
+	else return fromTimestamp(Timestamp.fromJSON(o));
+}
 function isObject(value) {
 	return typeof value === "object" && value !== null;
 }
 function isSet$3(value) {
 	return value !== null && value !== void 0;
 }
-const VERSION = "0.6.0";
+const VERSION = "0.8.0";
 const NOOP_LOG_FN = Object.assign(() => {}, { enabled: false });
 const debugBackend = loadDebug();
 const logger$2 = new class LoggerImpl {
@@ -1341,11 +1505,11 @@ function abortableSleep(milliseconds, signal) {
 	if (signal?.aborted) return Promise.reject(signal.reason);
 	if (milliseconds <= 0) return Promise.resolve();
 	if (milliseconds === Infinity) return signal ? promiseSignal(signal) : new Promise(() => {});
-	return new Promise((resolve, reject) => {
+	return new Promise((resolve$1, reject) => {
 		let timeout;
 		const onTimeout = () => {
 			cleanup();
-			resolve();
+			resolve$1();
 		};
 		const onAbort = () => {
 			cleanup();
@@ -1373,13 +1537,32 @@ function hasKey(obj, key) {
 function castStringToEnum(value) {
 	return value;
 }
+function bytesFromBase64(b64) {
+	if (globalThis.Buffer) return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
+	else {
+		const bin = globalThis.atob(b64);
+		const arr = new Uint8Array(bin.length);
+		for (let i = 0; i < bin.length; ++i) arr[i] = bin.charCodeAt(i);
+		return arr;
+	}
+}
+function base64FromBytes(arr) {
+	if (globalThis.Buffer) return globalThis.Buffer.from(arr).toString("base64");
+	else {
+		const bin = [];
+		arr.forEach((byte) => {
+			bin.push(String.fromCharCode(byte));
+		});
+		return globalThis.btoa(bin.join(""));
+	}
+}
 const logger$3 = logger$2.getLogger("fetch");
 let Fetch;
 (function(_Fetch) {
-	function create(middleware, sink = fetch) {
+	function create$1(middleware, sink = fetch) {
 		return middleware.reduceRight((next, middleware$1) => middleware$1(next), sink);
 	}
-	_Fetch.create = create;
+	_Fetch.create = create$1;
 })(Fetch || (Fetch = {}));
 let FetchMiddleware;
 (function(_FetchMiddleware) {
@@ -1449,9 +1632,9 @@ function withRetry(opts) {
 			await abortableSleep(serverDelay ?? deadline - Date.now(), signal);
 			return doTry();
 		};
-		const onError = async (error) => {
-			logger$3.debug("withRetry %s failed attempt %d with %s", url, attempts - 1, error);
-			if (signal?.aborted || attempts >= maxAttempts) throw error;
+		const onError = async (error$1) => {
+			logger$3.debug("withRetry %s failed attempt %d with %s", url, attempts - 1, error$1);
+			if (signal?.aborted || attempts >= maxAttempts) throw error$1;
 			await abortableSleep(deadline - Date.now(), signal);
 			return doTry();
 		};
@@ -2233,13 +2416,13 @@ const SetResolverStateRequest = {
 	},
 	fromJSON(object) {
 		return {
-			state: isSet$1(object.state) ? bytesFromBase64(object.state) : new Uint8Array(0),
+			state: isSet$1(object.state) ? bytesFromBase64$1(object.state) : new Uint8Array(0),
 			accountId: isSet$1(object.accountId) ? globalThis.String(object.accountId) : ""
 		};
 	},
 	toJSON(message) {
 		const obj = {};
-		if (message.state.length !== 0) obj.state = base64FromBytes(message.state);
+		if (message.state.length !== 0) obj.state = base64FromBytes$1(message.state);
 		if (message.accountId !== "") obj.accountId = message.accountId;
 		return obj;
 	},
@@ -2279,11 +2462,11 @@ const Request = {
 		return message;
 	},
 	fromJSON(object) {
-		return { data: isSet$1(object.data) ? bytesFromBase64(object.data) : new Uint8Array(0) };
+		return { data: isSet$1(object.data) ? bytesFromBase64$1(object.data) : new Uint8Array(0) };
 	},
 	toJSON(message) {
 		const obj = {};
-		if (message.data.length !== 0) obj.data = base64FromBytes(message.data);
+		if (message.data.length !== 0) obj.data = base64FromBytes$1(message.data);
 		return obj;
 	},
 	create(base) {
@@ -2330,13 +2513,13 @@ const Response$1 = {
 	},
 	fromJSON(object) {
 		return {
-			data: isSet$1(object.data) ? bytesFromBase64(object.data) : void 0,
+			data: isSet$1(object.data) ? bytesFromBase64$1(object.data) : void 0,
 			error: isSet$1(object.error) ? globalThis.String(object.error) : void 0
 		};
 	},
 	toJSON(message) {
 		const obj = {};
-		if (message.data !== void 0) obj.data = base64FromBytes(message.data);
+		if (message.data !== void 0) obj.data = base64FromBytes$1(message.data);
 		if (message.error !== void 0) obj.error = message.error;
 		return obj;
 	},
@@ -2350,7 +2533,7 @@ const Response$1 = {
 		return message;
 	}
 };
-function bytesFromBase64(b64) {
+function bytesFromBase64$1(b64) {
 	if (globalThis.Buffer) return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
 	else {
 		const bin = globalThis.atob(b64);
@@ -2359,7 +2542,7 @@ function bytesFromBase64(b64) {
 		return arr;
 	}
 }
-function base64FromBytes(arr) {
+function base64FromBytes$1(arr) {
 	if (globalThis.Buffer) return globalThis.Buffer.from(arr).toString("base64");
 	else {
 		const bin = [];
@@ -2372,21 +2555,137 @@ function base64FromBytes(arr) {
 function isSet$1(value) {
 	return value !== null && value !== void 0;
 }
+let ErrorCode = /* @__PURE__ */ function(ErrorCode$1) {
+	ErrorCode$1["PROVIDER_NOT_READY"] = "PROVIDER_NOT_READY";
+	ErrorCode$1["PROVIDER_FATAL"] = "PROVIDER_FATAL";
+	ErrorCode$1["FLAG_NOT_FOUND"] = "FLAG_NOT_FOUND";
+	ErrorCode$1["TYPE_MISMATCH"] = "TYPE_MISMATCH";
+	ErrorCode$1["GENERAL"] = "GENERAL";
+	return ErrorCode$1;
+}({});
+const encodeToken = base64FromBytes;
+const decodeToken = bytesFromBase64;
+function create({ resolveId, resolveToken, resolvedFlags }) {
+	return {
+		flags: Object.fromEntries(resolvedFlags.map(({ flag, reason, variant, value, shouldApply }) => {
+			const name = flag.slice(6);
+			const details = {
+				reason: convertReason(reason),
+				variant,
+				value: value ?? null,
+				shouldApply
+			};
+			return [name, details];
+		})),
+		resolveId,
+		resolveToken: encodeToken(resolveToken)
+	};
+}
+function error(errorCode, errorMessage) {
+	return {
+		flags: {},
+		resolveId: "",
+		resolveToken: "",
+		errorCode,
+		errorMessage
+	};
+}
+function resolve(bundle, flagKey, defaultValue, logger$4) {
+	const [flagName, ...path] = flagKey.split(".");
+	const flag = bundle?.flags[flagName];
+	if (bundle?.errorCode) {
+		logger$4?.warn(`Flag evaluation for "%s" failed. %s %s`, flagKey, bundle.errorCode, bundle?.errorMessage);
+		return {
+			reason: "ERROR",
+			errorCode: bundle.errorCode,
+			errorMessage: bundle.errorMessage,
+			value: defaultValue,
+			shouldApply: false
+		};
+	}
+	if (!flag) {
+		logger$4?.warn(`Flag evaluation for '${flagKey}' failed: flag not found`);
+		return {
+			reason: "ERROR",
+			errorCode: ErrorCode.FLAG_NOT_FOUND,
+			value: defaultValue,
+			shouldApply: false
+		};
+	}
+	let value = flag.value;
+	for (let i = 0; i < path.length; i++) {
+		if (value === null || typeof value !== "object" || Array.isArray(value)) return {
+			reason: "ERROR",
+			value: defaultValue,
+			errorCode: ErrorCode.TYPE_MISMATCH,
+			errorMessage: `resolved value is not an object at ${[flagName, ...path.slice(0, i)].join(".")}`,
+			shouldApply: false
+		};
+		value = value[path[i]];
+	}
+	try {
+		const validated = evaluateAssignment(value, defaultValue, [flagName, ...path]);
+		return {
+			...flag,
+			value: validated
+		};
+	} catch (e) {
+		return {
+			reason: "ERROR",
+			value: defaultValue,
+			errorCode: ErrorCode.TYPE_MISMATCH,
+			errorMessage: String(e),
+			shouldApply: false
+		};
+	}
+}
+function evaluateAssignment(resolvedValue, defaultValue, path) {
+	const resolvedType = typeof resolvedValue;
+	const defaultType = typeof defaultValue;
+	if (Array.isArray(defaultValue)) throw `arrays are not supported as flag values at ${path.join(".")}`;
+	if (defaultValue === null) return resolvedValue;
+	if (resolvedValue === null) return defaultValue;
+	if (resolvedType !== defaultType) throw `resolved value (${resolvedType}) isn't assignable to default type (${defaultType}) at ${path.join(".")}`;
+	if (typeof resolvedValue === "object") {
+		const result = { ...resolvedValue };
+		for (const [key, value] of Object.entries(defaultValue)) {
+			if (!hasKey(resolvedValue, key)) throw `resolved value is missing field "${key}" at ${path.join(".")}`;
+			result[key] = evaluateAssignment(resolvedValue[key], value, [...path, key]);
+		}
+		return result;
+	}
+	return resolvedValue;
+}
+function convertReason(reason) {
+	switch (reason) {
+		case ResolveReason.RESOLVE_REASON_ERROR: return "ERROR";
+		case ResolveReason.RESOLVE_REASON_FLAG_ARCHIVED: return "FLAG_ARCHIVED";
+		case ResolveReason.RESOLVE_REASON_MATCH: return "MATCH";
+		case ResolveReason.RESOLVE_REASON_NO_SEGMENT_MATCH: return "NO_SEGMENT_MATCH";
+		case ResolveReason.RESOLVE_REASON_TARGETING_KEY_ERROR: return "TARGETING_KEY_ERROR";
+		case ResolveReason.RESOLVE_REASON_NO_TREATMENT_MATCH: return "NO_TREATMENT_MATCH";
+		default: return "UNSPECIFIED";
+	}
+}
 const logger$1 = getLogger("provider");
 const DEFAULT_INITIALIZE_TIMEOUT = 3e4;
 const DEFAULT_STATE_INTERVAL = 3e4;
 const DEFAULT_FLUSH_INTERVAL = 1e4;
 var ConfidenceServerProviderLocal = class ConfidenceServerProviderLocal {
 	metadata = { name: "ConfidenceServerProviderLocal" };
-	status = "NOT_READY";
+	status = castStringToEnum("NOT_READY");
 	main = new AbortController();
 	fetch;
 	stateUpdateInterval;
 	flushInterval;
 	materializationStore;
 	stateEtag = null;
-	constructor(resolver$1, options) {
-		this.resolver = resolver$1;
+	get resolver() {
+		if (this.resolverOrPromise instanceof Promise) throw new Error("Resolver not ready");
+		return this.resolverOrPromise;
+	}
+	constructor(resolverOrPromise, options) {
+		this.resolverOrPromise = resolverOrPromise;
 		this.options = options;
 		this.stateUpdateInterval = options.stateUpdateInterval ?? DEFAULT_STATE_INTERVAL;
 		if (!Number.isInteger(this.stateUpdateInterval) || this.stateUpdateInterval < 1e3) throw new Error(`stateUpdateInterval must be an integer >= 1000 (1s), currently: ${this.stateUpdateInterval}`);
@@ -2424,15 +2723,16 @@ var ConfidenceServerProviderLocal = class ConfidenceServerProviderLocal {
 		const signal = this.main.signal;
 		const initialUpdateSignal = AbortSignal.any([signal, timeoutSignal(this.options.initializeTimeout ?? DEFAULT_INITIALIZE_TIMEOUT)]);
 		try {
+			this.resolverOrPromise = await this.resolverOrPromise;
 			await this.updateState(initialUpdateSignal);
 			scheduleWithFixedInterval((signal$1) => this.flush(signal$1), this.flushInterval, {
 				maxConcurrent: 3,
 				signal
 			});
 			scheduleWithFixedInterval((signal$1) => this.updateState(signal$1), this.stateUpdateInterval, { signal });
-			this.status = "READY";
+			this.status = castStringToEnum("READY");
 		} catch (e) {
-			this.status = "ERROR";
+			this.status = castStringToEnum("ERROR");
 			throw e;
 		}
 	}
@@ -2440,34 +2740,33 @@ var ConfidenceServerProviderLocal = class ConfidenceServerProviderLocal {
 		await this.flush(timeoutSignal(3e3));
 		this.main.abort();
 	}
+	async resolve(context, flagNames, apply = false) {
+		const stickyRequest = {
+			resolveRequest: {
+				flags: flagNames.map((name) => `flags/${name}`),
+				evaluationContext: ConfidenceServerProviderLocal.convertEvaluationContext(context),
+				apply,
+				clientSecret: this.options.flagClientSecret,
+				sdk: {
+					id: SdkId.SDK_ID_JS_LOCAL_SERVER_PROVIDER,
+					version: VERSION
+				}
+			},
+			materializations: [],
+			failFastOnSticky: false,
+			notProcessSticky: false
+		};
+		try {
+			return create(await this.resolveWithSticky(stickyRequest));
+		} catch (err) {
+			return error(ErrorCode.GENERAL, String(err));
+		}
+	}
 	async evaluate(flagKey, defaultValue, context) {
 		try {
-			const [flagName, ...path] = flagKey.split(".");
-			const stickyRequest = {
-				resolveRequest: {
-					flags: [`flags/${flagName}`],
-					evaluationContext: ConfidenceServerProviderLocal.convertEvaluationContext(context),
-					apply: true,
-					clientSecret: this.options.flagClientSecret,
-					sdk: {
-						id: SdkId.SDK_ID_JS_LOCAL_SERVER_PROVIDER,
-						version: VERSION
-					}
-				},
-				materializations: [],
-				failFastOnSticky: false,
-				notProcessSticky: false
-			};
-			const response = await this.resolveWithSticky(stickyRequest);
-			return this.extractValue(response.resolvedFlags[0], flagName, path, defaultValue);
-		} catch (e) {
-			logger$1.warn(`Flag evaluation for '${flagKey}' failed`, e);
-			return {
-				value: defaultValue,
-				reason: "ERROR",
-				errorCode: castStringToEnum("GENERAL"),
-				errorMessage: String(e)
-			};
+			const [flagName] = flagKey.split(".", 1);
+			const resolution = await this.resolve(context, [flagName], true);
+			return resolve(resolution, flagKey, defaultValue, logger$1);
 		} finally {
 			this.flushAssigned();
 		}
@@ -2486,36 +2785,6 @@ var ConfidenceServerProviderLocal = class ConfidenceServerProviderLocal {
 		if (storeVariantOp.length) this.writeMaterializations({ storeVariantOp });
 		return ResolveFlagsResponse.create(resolveResponse);
 	}
-	extractValue(flag, flagName, path, defaultValue) {
-		if (!flag) return {
-			value: defaultValue,
-			reason: "ERROR",
-			errorCode: castStringToEnum("FLAG_NOT_FOUND")
-		};
-		if (flag.reason !== ResolveReason.RESOLVE_REASON_MATCH) return {
-			value: defaultValue,
-			reason: ConfidenceServerProviderLocal.convertReason(flag.reason)
-		};
-		let value = flag.value;
-		for (const step of path) {
-			if (typeof value !== "object" || value === null || !hasKey(value, step)) return {
-				value: defaultValue,
-				reason: "ERROR",
-				errorCode: castStringToEnum("TYPE_MISMATCH")
-			};
-			value = value[step];
-		}
-		if (!isAssignableTo(value, defaultValue)) return {
-			value: defaultValue,
-			reason: "ERROR",
-			errorCode: castStringToEnum("TYPE_MISMATCH")
-		};
-		return {
-			value,
-			reason: "MATCH",
-			variant: flag.variant
-		};
-	}
 	async updateState(signal) {
 		const cdnUrl = `https://confidence-resolver-state-cdn.spotifycdn.com/${await sha256Hex(this.options.flagClientSecret)}`;
 		const headers = new Headers();
@@ -2573,17 +2842,6 @@ var ConfidenceServerProviderLocal = class ConfidenceServerProviderLocal {
 		}
 		throw new Error("Write materialization not supported");
 	}
-	static convertReason(reason) {
-		switch (reason) {
-			case ResolveReason.RESOLVE_REASON_ERROR: return "ERROR";
-			case ResolveReason.RESOLVE_REASON_FLAG_ARCHIVED: return "FLAG_ARCHIVED";
-			case ResolveReason.RESOLVE_REASON_MATCH: return "MATCH";
-			case ResolveReason.RESOLVE_REASON_NO_SEGMENT_MATCH: return "NO_SEGMENT_MATCH";
-			case ResolveReason.RESOLVE_REASON_TARGETING_KEY_ERROR: return "TARGETING_KEY_ERROR";
-			case ResolveReason.RESOLVE_REASON_NO_TREATMENT_MATCH: return "NO_TREATMENT_MATCH";
-			default: return "UNSPECIFIED";
-		}
-	}
 	static convertEvaluationContext({ targetingKey: targeting_key,...rest }) {
 		return {
 			targeting_key,
@@ -2602,23 +2860,23 @@ var ConfidenceServerProviderLocal = class ConfidenceServerProviderLocal {
 	resolveStringEvaluation(flagKey, defaultValue, context) {
 		return Promise.resolve(this.evaluate(flagKey, defaultValue, context));
 	}
-};
-function isAssignableTo(value, schema) {
-	if (typeof schema !== typeof value) return false;
-	if (typeof value === "object" && typeof schema === "object") {
-		if (schema === null) return value === null;
-		if (Array.isArray(schema)) {
-			if (!Array.isArray(value)) return false;
-			if (schema.length == 0) return true;
-			return value.every((item) => isAssignableTo(item, schema[0]));
-		}
-		for (const [key, schemaValue] of Object.entries(schema)) {
-			if (!hasKey(value, key)) return false;
-			if (!isAssignableTo(value[key], schemaValue)) return false;
-		}
+	applyFlag(resolveToken, flagName) {
+		const request = {
+			flags: [{
+				flag: `flags/${flagName}`,
+				applyTime: /* @__PURE__ */ new Date()
+			}],
+			clientSecret: this.options.flagClientSecret,
+			resolveToken: decodeToken(resolveToken),
+			sendTime: /* @__PURE__ */ new Date(),
+			sdk: {
+				id: SdkId.SDK_ID_JS_LOCAL_SERVER_PROVIDER,
+				version: VERSION
+			}
+		};
+		this.resolver.applyFlags(request);
 	}
-	return true;
-}
+};
 function createBaseResolveWithStickyRequest() {
 	return {
 		resolveRequest: void 0,
@@ -2812,7 +3070,8 @@ const EXPORT_FN_NAMES = [
 	"wasm_msg_guest_resolve_with_sticky",
 	"wasm_msg_guest_set_resolver_state",
 	"wasm_msg_guest_bounded_flush_logs",
-	"wasm_msg_guest_bounded_flush_assign"
+	"wasm_msg_guest_bounded_flush_assign",
+	"wasm_msg_guest_apply_flags"
 ];
 function verifyExports(exports) {
 	for (const fnName of EXPORT_FN_NAMES) if (typeof exports[fnName] !== "function") throw new Error(`Expected Function export "${fnName}" found ${exports[fnName]}`);
@@ -2821,8 +3080,8 @@ function verifyExports(exports) {
 var UnsafeWasmResolver = class {
 	exports;
 	flushCount = 0;
-	constructor(module$1) {
-		const { exports } = new WebAssembly.Instance(module$1, { wasm_msg: { wasm_msg_host_current_time: () => {
+	constructor(module) {
+		const { exports } = new WebAssembly.Instance(module, { wasm_msg: { wasm_msg_host_current_time: () => {
 			const epochMillisecond = Date.now();
 			const seconds = Math.floor(epochMillisecond / 1e3);
 			const nanos = (epochMillisecond - 1e3 * seconds) * 1e6;
@@ -2846,23 +3105,28 @@ var UnsafeWasmResolver = class {
 	}
 	flushLogs() {
 		const resPtr = this.exports.wasm_msg_guest_bounded_flush_logs(0);
-		const { data, error } = this.consume(resPtr, Response$1);
-		if (error) throw new Error(error);
+		const { data, error: error$1 } = this.consume(resPtr, Response$1);
+		if (error$1) throw new Error(error$1);
 		return data;
 	}
 	flushAssigned() {
 		const resPtr = this.exports.wasm_msg_guest_bounded_flush_assign(0);
-		const { data, error } = this.consume(resPtr, Response$1);
-		if (error) throw new Error(error);
+		const { data, error: error$1 } = this.consume(resPtr, Response$1);
+		if (error$1) throw new Error(error$1);
 		return data;
 	}
+	applyFlags(request) {
+		const reqPtr = this.transferRequest(request, ApplyFlagsRequest);
+		const resPtr = this.exports.wasm_msg_guest_apply_flags(reqPtr);
+		this.consumeResponse(resPtr, Void);
+	}
 	transferRequest(value, codec) {
 		const data = codec.encode(value).finish();
 		return this.transfer({ data }, Request);
 	}
 	consumeResponse(ptr, codec) {
-		const { data, error } = this.consume(ptr, Response$1);
-		if (error) throw new Error(error);
+		const { data, error: error$1 } = this.consume(ptr, Response$1);
+		if (error$1) throw new Error(error$1);
 		return codec.decode(data);
 	}
 	transfer(data, codec) {
@@ -2885,18 +3149,18 @@ var UnsafeWasmResolver = class {
 		this.exports.wasm_msg_free(ptr);
 	}
 };
-const DEFAULT_DELEGATE_FACTORY = (module$1) => new UnsafeWasmResolver(module$1);
+const DEFAULT_DELEGATE_FACTORY = (module) => new UnsafeWasmResolver(module);
 var WasmResolver = class {
 	delegate;
 	currentState;
 	bufferedLogs = [];
-	constructor(module$1, delegateFactory = DEFAULT_DELEGATE_FACTORY) {
-		this.module = module$1;
+	constructor(module, delegateFactory = DEFAULT_DELEGATE_FACTORY) {
+		this.module = module;
 		this.delegateFactory = delegateFactory;
-		this.delegate = delegateFactory(module$1);
+		this.delegate = delegateFactory(module);
 	}
-	reloadInstance(error) {
-		logger.error("Failure calling into wasm:", error);
+	reloadInstance(error$1) {
+		logger.error("Failure calling into wasm:", error$1);
 		try {
 			this.bufferedLogs.push(this.delegate.flushLogs());
 		} catch (_) {
@@ -2908,46 +3172,57 @@ var WasmResolver = class {
 	resolveWithSticky(request) {
 		try {
 			return this.delegate.resolveWithSticky(request);
-		} catch (error) {
-			if (error instanceof WebAssembly.RuntimeError) this.reloadInstance(error);
-			throw error;
+		} catch (error$1) {
+			if (error$1 instanceof WebAssembly.RuntimeError) this.reloadInstance(error$1);
+			throw error$1;
 		}
 	}
 	setResolverState(request) {
 		this.currentState = request;
 		try {
 			this.delegate.setResolverState(request);
-		} catch (error) {
-			if (error instanceof WebAssembly.RuntimeError) this.reloadInstance(error);
-			throw error;
+		} catch (error$1) {
+			if (error$1 instanceof WebAssembly.RuntimeError) this.reloadInstance(error$1);
+			throw error$1;
 		}
 	}
 	flushLogs() {
 		try {
 			this.bufferedLogs.push(this.delegate.flushLogs());
 			const len = this.bufferedLogs.reduce((sum, chunk) => sum + chunk.length, 0);
-			const buffer$1 = new Uint8Array(len);
+			const buffer = new Uint8Array(len);
 			let offset = 0;
 			for (const chunk of this.bufferedLogs) {
-				buffer$1.set(chunk, offset);
+				buffer.set(chunk, offset);
 				offset += chunk.length;
 			}
 			this.bufferedLogs.length = 0;
-			return buffer$1;
-		} catch (error) {
-			if (error instanceof WebAssembly.RuntimeError) this.reloadInstance(error);
-			throw error;
+			return buffer;
+		} catch (error$1) {
+			if (error$1 instanceof WebAssembly.RuntimeError) this.reloadInstance(error$1);
+			throw error$1;
 		}
 	}
 	flushAssigned() {
 		return this.delegate.flushAssigned();
 	}
+	applyFlags(request) {
+		try {
+			this.delegate.applyFlags(request);
+		} catch (error$1) {
+			if (error$1 instanceof WebAssembly.RuntimeError) this.reloadInstance(error$1);
+			throw error$1;
+		}
+	}
 };
-const wasmPath = __require.resolve("./confidence_resolver.wasm");
-const buffer = await fs.readFile(wasmPath);
-const module = await WebAssembly.compile(buffer);
-const resolver = new WasmResolver(module);
-function createConfidenceServerProvider(options) {
+let resolver = null;
+function createConfidenceServerProvider({ wasmPath,...options }) {
+	if (!resolver) resolver = createResolver(wasmPath ?? __require.resolve("./confidence_resolver.wasm"));
 	return new ConfidenceServerProviderLocal(resolver, options);
 }
+async function createResolver(wasmPath) {
+	const buffer = await fs.readFile(wasmPath);
+	const module = await WebAssembly.compile(buffer);
+	return new WasmResolver(module);
+}
 export { createConfidenceServerProvider };