@spotify-confidence/openfeature-server-provider-local 0.0.0

package/dist/index.node.js

@@ -0,0 +1,2185 @@
+import { createRequire } from "node:module";
+import fs from "node:fs/promises";
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+let NullValue = /* @__PURE__ */ function(NullValue$1) {
+	NullValue$1[NullValue$1["NULL_VALUE"] = 0] = "NULL_VALUE";
+	NullValue$1[NullValue$1["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+	return NullValue$1;
+}({});
+function nullValueFromJSON(object) {
+	switch (object) {
+		case 0:
+		case "NULL_VALUE": return NullValue.NULL_VALUE;
+		case -1:
+		case "UNRECOGNIZED":
+		default: return NullValue.UNRECOGNIZED;
+	}
+}
+function nullValueToJSON(object) {
+	switch (object) {
+		case NullValue.NULL_VALUE: return "NULL_VALUE";
+		case NullValue.UNRECOGNIZED:
+		default: return "UNRECOGNIZED";
+	}
+}
+function createBaseStruct() {
+	return { fields: {} };
+}
+const Struct = {
+	encode(message, writer = new BinaryWriter()) {
+		Object.entries(message.fields).forEach(([key, value]) => {
+			if (value !== void 0) Struct_FieldsEntry.encode({
+				key,
+				value
+			}, writer.uint32(10).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 = createBaseStruct();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1: {
+					if (tag !== 10) break;
+					const entry1 = Struct_FieldsEntry.decode(reader, reader.uint32());
+					if (entry1.value !== void 0) message.fields[entry1.key] = entry1.value;
+					continue;
+				}
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return { fields: isObject$1(object.fields) ? Object.entries(object.fields).reduce((acc, [key, value]) => {
+			acc[key] = value;
+			return acc;
+		}, {}) : {} };
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.fields) {
+			const entries = Object.entries(message.fields);
+			if (entries.length > 0) {
+				obj.fields = {};
+				entries.forEach(([k, v]) => {
+					obj.fields[k] = v;
+				});
+			}
+		}
+		return obj;
+	},
+	create(base) {
+		return Struct.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseStruct();
+		message.fields = Object.entries(object.fields ?? {}).reduce((acc, [key, value]) => {
+			if (value !== void 0) acc[key] = value;
+			return acc;
+		}, {});
+		return message;
+	},
+	wrap(object) {
+		const struct = createBaseStruct();
+		if (object !== void 0) for (const key of Object.keys(object)) struct.fields[key] = object[key];
+		return struct;
+	},
+	unwrap(message) {
+		const object = {};
+		if (message.fields) for (const key of Object.keys(message.fields)) object[key] = message.fields[key];
+		return object;
+	}
+};
+function createBaseStruct_FieldsEntry() {
+	return {
+		key: "",
+		value: void 0
+	};
+}
+const Struct_FieldsEntry = {
+	encode(message, writer = new BinaryWriter()) {
+		if (message.key !== "") writer.uint32(10).string(message.key);
+		if (message.value !== void 0) Value.encode(Value.wrap(message.value), 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 = createBaseStruct_FieldsEntry();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 10) break;
+					message.key = reader.string();
+					continue;
+				case 2:
+					if (tag !== 18) break;
+					message.value = Value.unwrap(Value.decode(reader, reader.uint32()));
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return {
+			key: isSet$3(object.key) ? globalThis.String(object.key) : "",
+			value: isSet$3(object?.value) ? object.value : void 0
+		};
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.key !== "") obj.key = message.key;
+		if (message.value !== void 0) obj.value = message.value;
+		return obj;
+	},
+	create(base) {
+		return Struct_FieldsEntry.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseStruct_FieldsEntry();
+		message.key = object.key ?? "";
+		message.value = object.value ?? void 0;
+		return message;
+	}
+};
+function createBaseValue() {
+	return {
+		nullValue: void 0,
+		numberValue: void 0,
+		stringValue: void 0,
+		boolValue: void 0,
+		structValue: void 0,
+		listValue: void 0
+	};
+}
+const Value = {
+	encode(message, writer = new BinaryWriter()) {
+		if (message.nullValue !== void 0) writer.uint32(8).int32(message.nullValue);
+		if (message.numberValue !== void 0) writer.uint32(17).double(message.numberValue);
+		if (message.stringValue !== void 0) writer.uint32(26).string(message.stringValue);
+		if (message.boolValue !== void 0) writer.uint32(32).bool(message.boolValue);
+		if (message.structValue !== void 0) Struct.encode(Struct.wrap(message.structValue), writer.uint32(42).fork()).join();
+		if (message.listValue !== void 0) ListValue.encode(ListValue.wrap(message.listValue), writer.uint32(50).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 = createBaseValue();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 8) break;
+					message.nullValue = reader.int32();
+					continue;
+				case 2:
+					if (tag !== 17) break;
+					message.numberValue = reader.double();
+					continue;
+				case 3:
+					if (tag !== 26) break;
+					message.stringValue = reader.string();
+					continue;
+				case 4:
+					if (tag !== 32) break;
+					message.boolValue = reader.bool();
+					continue;
+				case 5:
+					if (tag !== 42) break;
+					message.structValue = Struct.unwrap(Struct.decode(reader, reader.uint32()));
+					continue;
+				case 6:
+					if (tag !== 50) break;
+					message.listValue = ListValue.unwrap(ListValue.decode(reader, reader.uint32()));
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return {
+			nullValue: isSet$3(object.nullValue) ? nullValueFromJSON(object.nullValue) : void 0,
+			numberValue: isSet$3(object.numberValue) ? globalThis.Number(object.numberValue) : void 0,
+			stringValue: isSet$3(object.stringValue) ? globalThis.String(object.stringValue) : void 0,
+			boolValue: isSet$3(object.boolValue) ? globalThis.Boolean(object.boolValue) : void 0,
+			structValue: isObject$1(object.structValue) ? object.structValue : void 0,
+			listValue: globalThis.Array.isArray(object.listValue) ? [...object.listValue] : void 0
+		};
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.nullValue !== void 0) obj.nullValue = nullValueToJSON(message.nullValue);
+		if (message.numberValue !== void 0) obj.numberValue = message.numberValue;
+		if (message.stringValue !== void 0) obj.stringValue = message.stringValue;
+		if (message.boolValue !== void 0) obj.boolValue = message.boolValue;
+		if (message.structValue !== void 0) obj.structValue = message.structValue;
+		if (message.listValue !== void 0) obj.listValue = message.listValue;
+		return obj;
+	},
+	create(base) {
+		return Value.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseValue();
+		message.nullValue = object.nullValue ?? void 0;
+		message.numberValue = object.numberValue ?? void 0;
+		message.stringValue = object.stringValue ?? void 0;
+		message.boolValue = object.boolValue ?? void 0;
+		message.structValue = object.structValue ?? void 0;
+		message.listValue = object.listValue ?? void 0;
+		return message;
+	},
+	wrap(value) {
+		const result = createBaseValue();
+		if (value === null) result.nullValue = NullValue.NULL_VALUE;
+		else if (typeof value === "boolean") result.boolValue = value;
+		else if (typeof value === "number") result.numberValue = value;
+		else if (typeof value === "string") result.stringValue = value;
+		else if (globalThis.Array.isArray(value)) result.listValue = value;
+		else if (typeof value === "object") result.structValue = value;
+		else if (typeof value !== "undefined") throw new globalThis.Error("Unsupported any value type: " + typeof value);
+		return result;
+	},
+	unwrap(message) {
+		if (message.stringValue !== void 0) return message.stringValue;
+		else if (message?.numberValue !== void 0) return message.numberValue;
+		else if (message?.boolValue !== void 0) return message.boolValue;
+		else if (message?.structValue !== void 0) return message.structValue;
+		else if (message?.listValue !== void 0) return message.listValue;
+		else if (message?.nullValue !== void 0) return null;
+	}
+};
+function createBaseListValue() {
+	return { values: [] };
+}
+const ListValue = {
+	encode(message, writer = new BinaryWriter()) {
+		for (const v of message.values) Value.encode(Value.wrap(v), writer.uint32(10).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 = createBaseListValue();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 10) break;
+					message.values.push(Value.unwrap(Value.decode(reader, reader.uint32())));
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return { values: globalThis.Array.isArray(object?.values) ? [...object.values] : [] };
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.values?.length) obj.values = message.values;
+		return obj;
+	},
+	create(base) {
+		return ListValue.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseListValue();
+		message.values = object.values?.map((e) => e) || [];
+		return message;
+	},
+	wrap(array) {
+		const result = createBaseListValue();
+		result.values = array ?? [];
+		return result;
+	},
+	unwrap(message) {
+		if (message?.hasOwnProperty("values") && globalThis.Array.isArray(message.values)) return message.values;
+		else return message;
+	}
+};
+function isObject$1(value) {
+	return typeof value === "object" && value !== null;
+}
+function isSet$3(value) {
+	return value !== null && value !== void 0;
+}
+let ResolveReason = /* @__PURE__ */ function(ResolveReason$1) {
+	ResolveReason$1[ResolveReason$1["RESOLVE_REASON_UNSPECIFIED"] = 0] = "RESOLVE_REASON_UNSPECIFIED";
+	ResolveReason$1[ResolveReason$1["RESOLVE_REASON_MATCH"] = 1] = "RESOLVE_REASON_MATCH";
+	ResolveReason$1[ResolveReason$1["RESOLVE_REASON_NO_SEGMENT_MATCH"] = 2] = "RESOLVE_REASON_NO_SEGMENT_MATCH";
+	ResolveReason$1[ResolveReason$1["RESOLVE_REASON_NO_TREATMENT_MATCH"] = 3] = "RESOLVE_REASON_NO_TREATMENT_MATCH";
+	ResolveReason$1[ResolveReason$1["RESOLVE_REASON_FLAG_ARCHIVED"] = 4] = "RESOLVE_REASON_FLAG_ARCHIVED";
+	ResolveReason$1[ResolveReason$1["RESOLVE_REASON_TARGETING_KEY_ERROR"] = 5] = "RESOLVE_REASON_TARGETING_KEY_ERROR";
+	ResolveReason$1[ResolveReason$1["RESOLVE_REASON_ERROR"] = 6] = "RESOLVE_REASON_ERROR";
+	ResolveReason$1[ResolveReason$1["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+	return ResolveReason$1;
+}({});
+function resolveReasonFromJSON(object) {
+	switch (object) {
+		case 0:
+		case "RESOLVE_REASON_UNSPECIFIED": return ResolveReason.RESOLVE_REASON_UNSPECIFIED;
+		case 1:
+		case "RESOLVE_REASON_MATCH": return ResolveReason.RESOLVE_REASON_MATCH;
+		case 2:
+		case "RESOLVE_REASON_NO_SEGMENT_MATCH": return ResolveReason.RESOLVE_REASON_NO_SEGMENT_MATCH;
+		case 3:
+		case "RESOLVE_REASON_NO_TREATMENT_MATCH": return ResolveReason.RESOLVE_REASON_NO_TREATMENT_MATCH;
+		case 4:
+		case "RESOLVE_REASON_FLAG_ARCHIVED": return ResolveReason.RESOLVE_REASON_FLAG_ARCHIVED;
+		case 5:
+		case "RESOLVE_REASON_TARGETING_KEY_ERROR": return ResolveReason.RESOLVE_REASON_TARGETING_KEY_ERROR;
+		case 6:
+		case "RESOLVE_REASON_ERROR": return ResolveReason.RESOLVE_REASON_ERROR;
+		case -1:
+		case "UNRECOGNIZED":
+		default: return ResolveReason.UNRECOGNIZED;
+	}
+}
+function resolveReasonToJSON(object) {
+	switch (object) {
+		case ResolveReason.RESOLVE_REASON_UNSPECIFIED: return "RESOLVE_REASON_UNSPECIFIED";
+		case ResolveReason.RESOLVE_REASON_MATCH: return "RESOLVE_REASON_MATCH";
+		case ResolveReason.RESOLVE_REASON_NO_SEGMENT_MATCH: return "RESOLVE_REASON_NO_SEGMENT_MATCH";
+		case ResolveReason.RESOLVE_REASON_NO_TREATMENT_MATCH: return "RESOLVE_REASON_NO_TREATMENT_MATCH";
+		case ResolveReason.RESOLVE_REASON_FLAG_ARCHIVED: return "RESOLVE_REASON_FLAG_ARCHIVED";
+		case ResolveReason.RESOLVE_REASON_TARGETING_KEY_ERROR: return "RESOLVE_REASON_TARGETING_KEY_ERROR";
+		case ResolveReason.RESOLVE_REASON_ERROR: return "RESOLVE_REASON_ERROR";
+		case ResolveReason.UNRECOGNIZED:
+		default: return "UNRECOGNIZED";
+	}
+}
+function createBaseResolveFlagsRequest() {
+	return {
+		flags: [],
+		evaluationContext: void 0,
+		clientSecret: "",
+		apply: false
+	};
+}
+const ResolveFlagsRequest = {
+	encode(message, writer = new BinaryWriter()) {
+		for (const v of message.flags) writer.uint32(10).string(v);
+		if (message.evaluationContext !== void 0) Struct.encode(Struct.wrap(message.evaluationContext), writer.uint32(18).fork()).join();
+		if (message.clientSecret !== "") writer.uint32(26).string(message.clientSecret);
+		if (message.apply !== false) writer.uint32(32).bool(message.apply);
+		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 = createBaseResolveFlagsRequest();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 10) break;
+					message.flags.push(reader.string());
+					continue;
+				case 2:
+					if (tag !== 18) break;
+					message.evaluationContext = Struct.unwrap(Struct.decode(reader, reader.uint32()));
+					continue;
+				case 3:
+					if (tag !== 26) break;
+					message.clientSecret = reader.string();
+					continue;
+				case 4:
+					if (tag !== 32) break;
+					message.apply = reader.bool();
+					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) => globalThis.String(e)) : [],
+			evaluationContext: isObject(object.evaluationContext) ? object.evaluationContext : void 0,
+			clientSecret: isSet$2(object.clientSecret) ? globalThis.String(object.clientSecret) : "",
+			apply: isSet$2(object.apply) ? globalThis.Boolean(object.apply) : false
+		};
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.flags?.length) obj.flags = message.flags;
+		if (message.evaluationContext !== void 0) obj.evaluationContext = message.evaluationContext;
+		if (message.clientSecret !== "") obj.clientSecret = message.clientSecret;
+		if (message.apply !== false) obj.apply = message.apply;
+		return obj;
+	},
+	create(base) {
+		return ResolveFlagsRequest.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseResolveFlagsRequest();
+		message.flags = object.flags?.map((e) => e) || [];
+		message.evaluationContext = object.evaluationContext ?? void 0;
+		message.clientSecret = object.clientSecret ?? "";
+		message.apply = object.apply ?? false;
+		return message;
+	}
+};
+function createBaseResolveFlagsResponse() {
+	return {
+		resolvedFlags: [],
+		resolveToken: new Uint8Array(0),
+		resolveId: ""
+	};
+}
+const ResolveFlagsResponse = {
+	encode(message, writer = new BinaryWriter()) {
+		for (const v of message.resolvedFlags) ResolvedFlag.encode(v, writer.uint32(10).fork()).join();
+		if (message.resolveToken.length !== 0) writer.uint32(18).bytes(message.resolveToken);
+		if (message.resolveId !== "") writer.uint32(26).string(message.resolveId);
+		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 = createBaseResolveFlagsResponse();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 10) break;
+					message.resolvedFlags.push(ResolvedFlag.decode(reader, reader.uint32()));
+					continue;
+				case 2:
+					if (tag !== 18) break;
+					message.resolveToken = reader.bytes();
+					continue;
+				case 3:
+					if (tag !== 26) break;
+					message.resolveId = reader.string();
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return {
+			resolvedFlags: globalThis.Array.isArray(object?.resolvedFlags) ? object.resolvedFlags.map((e) => ResolvedFlag.fromJSON(e)) : [],
+			resolveToken: isSet$2(object.resolveToken) ? bytesFromBase64$1(object.resolveToken) : new Uint8Array(0),
+			resolveId: isSet$2(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.resolveId !== "") obj.resolveId = message.resolveId;
+		return obj;
+	},
+	create(base) {
+		return ResolveFlagsResponse.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseResolveFlagsResponse();
+		message.resolvedFlags = object.resolvedFlags?.map((e) => ResolvedFlag.fromPartial(e)) || [];
+		message.resolveToken = object.resolveToken ?? new Uint8Array(0);
+		message.resolveId = object.resolveId ?? "";
+		return message;
+	}
+};
+function createBaseResolvedFlag() {
+	return {
+		flag: "",
+		variant: "",
+		value: void 0,
+		reason: 0
+	};
+}
+const ResolvedFlag = {
+	encode(message, writer = new BinaryWriter()) {
+		if (message.flag !== "") writer.uint32(10).string(message.flag);
+		if (message.variant !== "") writer.uint32(18).string(message.variant);
+		if (message.value !== void 0) Struct.encode(Struct.wrap(message.value), writer.uint32(26).fork()).join();
+		if (message.reason !== 0) writer.uint32(40).int32(message.reason);
+		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 = createBaseResolvedFlag();
+		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.variant = reader.string();
+					continue;
+				case 3:
+					if (tag !== 26) break;
+					message.value = Struct.unwrap(Struct.decode(reader, reader.uint32()));
+					continue;
+				case 5:
+					if (tag !== 40) break;
+					message.reason = reader.int32();
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return {
+			flag: isSet$2(object.flag) ? globalThis.String(object.flag) : "",
+			variant: isSet$2(object.variant) ? globalThis.String(object.variant) : "",
+			value: isObject(object.value) ? object.value : void 0,
+			reason: isSet$2(object.reason) ? resolveReasonFromJSON(object.reason) : 0
+		};
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.flag !== "") obj.flag = message.flag;
+		if (message.variant !== "") obj.variant = message.variant;
+		if (message.value !== void 0) obj.value = message.value;
+		if (message.reason !== 0) obj.reason = resolveReasonToJSON(message.reason);
+		return obj;
+	},
+	create(base) {
+		return ResolvedFlag.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseResolvedFlag();
+		message.flag = object.flag ?? "";
+		message.variant = object.variant ?? "";
+		message.value = object.value ?? void 0;
+		message.reason = object.reason ?? 0;
+		return message;
+	}
+};
+function createBaseSetResolverStateRequest() {
+	return {
+		state: new Uint8Array(0),
+		accountId: ""
+	};
+}
+const SetResolverStateRequest = {
+	encode(message, writer = new BinaryWriter()) {
+		if (message.state.length !== 0) writer.uint32(10).bytes(message.state);
+		if (message.accountId !== "") writer.uint32(18).string(message.accountId);
+		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 = createBaseSetResolverStateRequest();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 10) break;
+					message.state = reader.bytes();
+					continue;
+				case 2:
+					if (tag !== 18) break;
+					message.accountId = reader.string();
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return {
+			state: isSet$2(object.state) ? bytesFromBase64$1(object.state) : new Uint8Array(0),
+			accountId: isSet$2(object.accountId) ? globalThis.String(object.accountId) : ""
+		};
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.state.length !== 0) obj.state = base64FromBytes$1(message.state);
+		if (message.accountId !== "") obj.accountId = message.accountId;
+		return obj;
+	},
+	create(base) {
+		return SetResolverStateRequest.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseSetResolverStateRequest();
+		message.state = object.state ?? new Uint8Array(0);
+		message.accountId = object.accountId ?? "";
+		return message;
+	}
+};
+function createBaseResolveWithStickyRequest() {
+	return {
+		resolveRequest: void 0,
+		materializationsPerUnit: {},
+		failFastOnSticky: false
+	};
+}
+const ResolveWithStickyRequest = {
+	encode(message, writer = new BinaryWriter()) {
+		if (message.resolveRequest !== void 0) ResolveFlagsRequest.encode(message.resolveRequest, writer.uint32(10).fork()).join();
+		Object.entries(message.materializationsPerUnit).forEach(([key, value]) => {
+			ResolveWithStickyRequest_MaterializationsPerUnitEntry.encode({
+				key,
+				value
+			}, writer.uint32(18).fork()).join();
+		});
+		if (message.failFastOnSticky !== false) writer.uint32(24).bool(message.failFastOnSticky);
+		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 = createBaseResolveWithStickyRequest();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 10) break;
+					message.resolveRequest = ResolveFlagsRequest.decode(reader, reader.uint32());
+					continue;
+				case 2: {
+					if (tag !== 18) break;
+					const entry2 = ResolveWithStickyRequest_MaterializationsPerUnitEntry.decode(reader, reader.uint32());
+					if (entry2.value !== void 0) message.materializationsPerUnit[entry2.key] = entry2.value;
+					continue;
+				}
+				case 3:
+					if (tag !== 24) break;
+					message.failFastOnSticky = reader.bool();
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return {
+			resolveRequest: isSet$2(object.resolveRequest) ? ResolveFlagsRequest.fromJSON(object.resolveRequest) : void 0,
+			materializationsPerUnit: isObject(object.materializationsPerUnit) ? Object.entries(object.materializationsPerUnit).reduce((acc, [key, value]) => {
+				acc[key] = MaterializationMap.fromJSON(value);
+				return acc;
+			}, {}) : {},
+			failFastOnSticky: isSet$2(object.failFastOnSticky) ? globalThis.Boolean(object.failFastOnSticky) : false
+		};
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.resolveRequest !== void 0) obj.resolveRequest = ResolveFlagsRequest.toJSON(message.resolveRequest);
+		if (message.materializationsPerUnit) {
+			const entries = Object.entries(message.materializationsPerUnit);
+			if (entries.length > 0) {
+				obj.materializationsPerUnit = {};
+				entries.forEach(([k, v]) => {
+					obj.materializationsPerUnit[k] = MaterializationMap.toJSON(v);
+				});
+			}
+		}
+		if (message.failFastOnSticky !== false) obj.failFastOnSticky = message.failFastOnSticky;
+		return obj;
+	},
+	create(base) {
+		return ResolveWithStickyRequest.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseResolveWithStickyRequest();
+		message.resolveRequest = object.resolveRequest !== void 0 && object.resolveRequest !== null ? ResolveFlagsRequest.fromPartial(object.resolveRequest) : void 0;
+		message.materializationsPerUnit = Object.entries(object.materializationsPerUnit ?? {}).reduce((acc, [key, value]) => {
+			if (value !== void 0) acc[key] = MaterializationMap.fromPartial(value);
+			return acc;
+		}, {});
+		message.failFastOnSticky = object.failFastOnSticky ?? false;
+		return message;
+	}
+};
+function createBaseResolveWithStickyRequest_MaterializationsPerUnitEntry() {
+	return {
+		key: "",
+		value: void 0
+	};
+}
+const ResolveWithStickyRequest_MaterializationsPerUnitEntry = {
+	encode(message, writer = new BinaryWriter()) {
+		if (message.key !== "") writer.uint32(10).string(message.key);
+		if (message.value !== void 0) MaterializationMap.encode(message.value, 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 = createBaseResolveWithStickyRequest_MaterializationsPerUnitEntry();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 10) break;
+					message.key = reader.string();
+					continue;
+				case 2:
+					if (tag !== 18) break;
+					message.value = MaterializationMap.decode(reader, reader.uint32());
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return {
+			key: isSet$2(object.key) ? globalThis.String(object.key) : "",
+			value: isSet$2(object.value) ? MaterializationMap.fromJSON(object.value) : void 0
+		};
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.key !== "") obj.key = message.key;
+		if (message.value !== void 0) obj.value = MaterializationMap.toJSON(message.value);
+		return obj;
+	},
+	create(base) {
+		return ResolveWithStickyRequest_MaterializationsPerUnitEntry.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseResolveWithStickyRequest_MaterializationsPerUnitEntry();
+		message.key = object.key ?? "";
+		message.value = object.value !== void 0 && object.value !== null ? MaterializationMap.fromPartial(object.value) : void 0;
+		return message;
+	}
+};
+function createBaseMaterializationMap() {
+	return { infoMap: {} };
+}
+const MaterializationMap = {
+	encode(message, writer = new BinaryWriter()) {
+		Object.entries(message.infoMap).forEach(([key, value]) => {
+			MaterializationMap_InfoMapEntry.encode({
+				key,
+				value
+			}, writer.uint32(10).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 = createBaseMaterializationMap();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1: {
+					if (tag !== 10) break;
+					const entry1 = MaterializationMap_InfoMapEntry.decode(reader, reader.uint32());
+					if (entry1.value !== void 0) message.infoMap[entry1.key] = entry1.value;
+					continue;
+				}
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return { infoMap: isObject(object.infoMap) ? Object.entries(object.infoMap).reduce((acc, [key, value]) => {
+			acc[key] = MaterializationInfo.fromJSON(value);
+			return acc;
+		}, {}) : {} };
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.infoMap) {
+			const entries = Object.entries(message.infoMap);
+			if (entries.length > 0) {
+				obj.infoMap = {};
+				entries.forEach(([k, v]) => {
+					obj.infoMap[k] = MaterializationInfo.toJSON(v);
+				});
+			}
+		}
+		return obj;
+	},
+	create(base) {
+		return MaterializationMap.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseMaterializationMap();
+		message.infoMap = Object.entries(object.infoMap ?? {}).reduce((acc, [key, value]) => {
+			if (value !== void 0) acc[key] = MaterializationInfo.fromPartial(value);
+			return acc;
+		}, {});
+		return message;
+	}
+};
+function createBaseMaterializationMap_InfoMapEntry() {
+	return {
+		key: "",
+		value: void 0
+	};
+}
+const MaterializationMap_InfoMapEntry = {
+	encode(message, writer = new BinaryWriter()) {
+		if (message.key !== "") writer.uint32(10).string(message.key);
+		if (message.value !== void 0) MaterializationInfo.encode(message.value, 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 = createBaseMaterializationMap_InfoMapEntry();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 10) break;
+					message.key = reader.string();
+					continue;
+				case 2:
+					if (tag !== 18) break;
+					message.value = MaterializationInfo.decode(reader, reader.uint32());
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return {
+			key: isSet$2(object.key) ? globalThis.String(object.key) : "",
+			value: isSet$2(object.value) ? MaterializationInfo.fromJSON(object.value) : void 0
+		};
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.key !== "") obj.key = message.key;
+		if (message.value !== void 0) obj.value = MaterializationInfo.toJSON(message.value);
+		return obj;
+	},
+	create(base) {
+		return MaterializationMap_InfoMapEntry.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseMaterializationMap_InfoMapEntry();
+		message.key = object.key ?? "";
+		message.value = object.value !== void 0 && object.value !== null ? MaterializationInfo.fromPartial(object.value) : void 0;
+		return message;
+	}
+};
+function createBaseMaterializationInfo() {
+	return {
+		unitInInfo: false,
+		ruleToVariant: {}
+	};
+}
+const MaterializationInfo = {
+	encode(message, writer = new BinaryWriter()) {
+		if (message.unitInInfo !== false) writer.uint32(8).bool(message.unitInInfo);
+		Object.entries(message.ruleToVariant).forEach(([key, value]) => {
+			MaterializationInfo_RuleToVariantEntry.encode({
+				key,
+				value
+			}, 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 = createBaseMaterializationInfo();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 8) break;
+					message.unitInInfo = reader.bool();
+					continue;
+				case 2: {
+					if (tag !== 18) break;
+					const entry2 = MaterializationInfo_RuleToVariantEntry.decode(reader, reader.uint32());
+					if (entry2.value !== void 0) message.ruleToVariant[entry2.key] = entry2.value;
+					continue;
+				}
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return {
+			unitInInfo: isSet$2(object.unitInInfo) ? globalThis.Boolean(object.unitInInfo) : false,
+			ruleToVariant: isObject(object.ruleToVariant) ? Object.entries(object.ruleToVariant).reduce((acc, [key, value]) => {
+				acc[key] = String(value);
+				return acc;
+			}, {}) : {}
+		};
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.unitInInfo !== false) obj.unitInInfo = message.unitInInfo;
+		if (message.ruleToVariant) {
+			const entries = Object.entries(message.ruleToVariant);
+			if (entries.length > 0) {
+				obj.ruleToVariant = {};
+				entries.forEach(([k, v]) => {
+					obj.ruleToVariant[k] = v;
+				});
+			}
+		}
+		return obj;
+	},
+	create(base) {
+		return MaterializationInfo.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseMaterializationInfo();
+		message.unitInInfo = object.unitInInfo ?? false;
+		message.ruleToVariant = Object.entries(object.ruleToVariant ?? {}).reduce((acc, [key, value]) => {
+			if (value !== void 0) acc[key] = globalThis.String(value);
+			return acc;
+		}, {});
+		return message;
+	}
+};
+function createBaseMaterializationInfo_RuleToVariantEntry() {
+	return {
+		key: "",
+		value: ""
+	};
+}
+const MaterializationInfo_RuleToVariantEntry = {
+	encode(message, writer = new BinaryWriter()) {
+		if (message.key !== "") writer.uint32(10).string(message.key);
+		if (message.value !== "") writer.uint32(18).string(message.value);
+		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 = createBaseMaterializationInfo_RuleToVariantEntry();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 10) break;
+					message.key = reader.string();
+					continue;
+				case 2:
+					if (tag !== 18) break;
+					message.value = reader.string();
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return {
+			key: isSet$2(object.key) ? globalThis.String(object.key) : "",
+			value: isSet$2(object.value) ? globalThis.String(object.value) : ""
+		};
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.key !== "") obj.key = message.key;
+		if (message.value !== "") obj.value = message.value;
+		return obj;
+	},
+	create(base) {
+		return MaterializationInfo_RuleToVariantEntry.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseMaterializationInfo_RuleToVariantEntry();
+		message.key = object.key ?? "";
+		message.value = object.value ?? "";
+		return message;
+	}
+};
+function createBaseResolveWithStickyResponse() {
+	return {
+		success: void 0,
+		missingMaterializations: void 0
+	};
+}
+const ResolveWithStickyResponse = {
+	encode(message, writer = new BinaryWriter()) {
+		if (message.success !== void 0) ResolveWithStickyResponse_Success.encode(message.success, writer.uint32(10).fork()).join();
+		if (message.missingMaterializations !== void 0) ResolveWithStickyResponse_MissingMaterializations.encode(message.missingMaterializations, 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 = createBaseResolveWithStickyResponse();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 10) break;
+					message.success = ResolveWithStickyResponse_Success.decode(reader, reader.uint32());
+					continue;
+				case 2:
+					if (tag !== 18) break;
+					message.missingMaterializations = ResolveWithStickyResponse_MissingMaterializations.decode(reader, reader.uint32());
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return {
+			success: isSet$2(object.success) ? ResolveWithStickyResponse_Success.fromJSON(object.success) : void 0,
+			missingMaterializations: isSet$2(object.missingMaterializations) ? ResolveWithStickyResponse_MissingMaterializations.fromJSON(object.missingMaterializations) : void 0
+		};
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.success !== void 0) obj.success = ResolveWithStickyResponse_Success.toJSON(message.success);
+		if (message.missingMaterializations !== void 0) obj.missingMaterializations = ResolveWithStickyResponse_MissingMaterializations.toJSON(message.missingMaterializations);
+		return obj;
+	},
+	create(base) {
+		return ResolveWithStickyResponse.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseResolveWithStickyResponse();
+		message.success = object.success !== void 0 && object.success !== null ? ResolveWithStickyResponse_Success.fromPartial(object.success) : void 0;
+		message.missingMaterializations = object.missingMaterializations !== void 0 && object.missingMaterializations !== null ? ResolveWithStickyResponse_MissingMaterializations.fromPartial(object.missingMaterializations) : void 0;
+		return message;
+	}
+};
+function createBaseResolveWithStickyResponse_Success() {
+	return {
+		response: void 0,
+		updates: []
+	};
+}
+const ResolveWithStickyResponse_Success = {
+	encode(message, writer = new BinaryWriter()) {
+		if (message.response !== void 0) ResolveFlagsResponse.encode(message.response, writer.uint32(10).fork()).join();
+		for (const v of message.updates) ResolveWithStickyResponse_MaterializationUpdate.encode(v, 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 = createBaseResolveWithStickyResponse_Success();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 10) break;
+					message.response = ResolveFlagsResponse.decode(reader, reader.uint32());
+					continue;
+				case 2:
+					if (tag !== 18) break;
+					message.updates.push(ResolveWithStickyResponse_MaterializationUpdate.decode(reader, reader.uint32()));
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return {
+			response: isSet$2(object.response) ? ResolveFlagsResponse.fromJSON(object.response) : void 0,
+			updates: globalThis.Array.isArray(object?.updates) ? object.updates.map((e) => ResolveWithStickyResponse_MaterializationUpdate.fromJSON(e)) : []
+		};
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.response !== void 0) obj.response = ResolveFlagsResponse.toJSON(message.response);
+		if (message.updates?.length) obj.updates = message.updates.map((e) => ResolveWithStickyResponse_MaterializationUpdate.toJSON(e));
+		return obj;
+	},
+	create(base) {
+		return ResolveWithStickyResponse_Success.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseResolveWithStickyResponse_Success();
+		message.response = object.response !== void 0 && object.response !== null ? ResolveFlagsResponse.fromPartial(object.response) : void 0;
+		message.updates = object.updates?.map((e) => ResolveWithStickyResponse_MaterializationUpdate.fromPartial(e)) || [];
+		return message;
+	}
+};
+function createBaseResolveWithStickyResponse_MissingMaterializations() {
+	return { items: [] };
+}
+const ResolveWithStickyResponse_MissingMaterializations = {
+	encode(message, writer = new BinaryWriter()) {
+		for (const v of message.items) ResolveWithStickyResponse_MissingMaterializationItem.encode(v, writer.uint32(10).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 = createBaseResolveWithStickyResponse_MissingMaterializations();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 10) break;
+					message.items.push(ResolveWithStickyResponse_MissingMaterializationItem.decode(reader, reader.uint32()));
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return { items: globalThis.Array.isArray(object?.items) ? object.items.map((e) => ResolveWithStickyResponse_MissingMaterializationItem.fromJSON(e)) : [] };
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.items?.length) obj.items = message.items.map((e) => ResolveWithStickyResponse_MissingMaterializationItem.toJSON(e));
+		return obj;
+	},
+	create(base) {
+		return ResolveWithStickyResponse_MissingMaterializations.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseResolveWithStickyResponse_MissingMaterializations();
+		message.items = object.items?.map((e) => ResolveWithStickyResponse_MissingMaterializationItem.fromPartial(e)) || [];
+		return message;
+	}
+};
+function createBaseResolveWithStickyResponse_MissingMaterializationItem() {
+	return {
+		unit: "",
+		rule: "",
+		readMaterialization: ""
+	};
+}
+const ResolveWithStickyResponse_MissingMaterializationItem = {
+	encode(message, writer = new BinaryWriter()) {
+		if (message.unit !== "") writer.uint32(10).string(message.unit);
+		if (message.rule !== "") writer.uint32(18).string(message.rule);
+		if (message.readMaterialization !== "") writer.uint32(26).string(message.readMaterialization);
+		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 = createBaseResolveWithStickyResponse_MissingMaterializationItem();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 10) break;
+					message.unit = reader.string();
+					continue;
+				case 2:
+					if (tag !== 18) break;
+					message.rule = reader.string();
+					continue;
+				case 3:
+					if (tag !== 26) break;
+					message.readMaterialization = reader.string();
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return {
+			unit: isSet$2(object.unit) ? globalThis.String(object.unit) : "",
+			rule: isSet$2(object.rule) ? globalThis.String(object.rule) : "",
+			readMaterialization: isSet$2(object.readMaterialization) ? globalThis.String(object.readMaterialization) : ""
+		};
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.unit !== "") obj.unit = message.unit;
+		if (message.rule !== "") obj.rule = message.rule;
+		if (message.readMaterialization !== "") obj.readMaterialization = message.readMaterialization;
+		return obj;
+	},
+	create(base) {
+		return ResolveWithStickyResponse_MissingMaterializationItem.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseResolveWithStickyResponse_MissingMaterializationItem();
+		message.unit = object.unit ?? "";
+		message.rule = object.rule ?? "";
+		message.readMaterialization = object.readMaterialization ?? "";
+		return message;
+	}
+};
+function createBaseResolveWithStickyResponse_MaterializationUpdate() {
+	return {
+		unit: "",
+		writeMaterialization: "",
+		rule: "",
+		variant: ""
+	};
+}
+const ResolveWithStickyResponse_MaterializationUpdate = {
+	encode(message, writer = new BinaryWriter()) {
+		if (message.unit !== "") writer.uint32(10).string(message.unit);
+		if (message.writeMaterialization !== "") writer.uint32(18).string(message.writeMaterialization);
+		if (message.rule !== "") writer.uint32(26).string(message.rule);
+		if (message.variant !== "") writer.uint32(34).string(message.variant);
+		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 = createBaseResolveWithStickyResponse_MaterializationUpdate();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 10) break;
+					message.unit = reader.string();
+					continue;
+				case 2:
+					if (tag !== 18) break;
+					message.writeMaterialization = reader.string();
+					continue;
+				case 3:
+					if (tag !== 26) break;
+					message.rule = reader.string();
+					continue;
+				case 4:
+					if (tag !== 34) break;
+					message.variant = reader.string();
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return {
+			unit: isSet$2(object.unit) ? globalThis.String(object.unit) : "",
+			writeMaterialization: isSet$2(object.writeMaterialization) ? globalThis.String(object.writeMaterialization) : "",
+			rule: isSet$2(object.rule) ? globalThis.String(object.rule) : "",
+			variant: isSet$2(object.variant) ? globalThis.String(object.variant) : ""
+		};
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.unit !== "") obj.unit = message.unit;
+		if (message.writeMaterialization !== "") obj.writeMaterialization = message.writeMaterialization;
+		if (message.rule !== "") obj.rule = message.rule;
+		if (message.variant !== "") obj.variant = message.variant;
+		return obj;
+	},
+	create(base) {
+		return ResolveWithStickyResponse_MaterializationUpdate.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseResolveWithStickyResponse_MaterializationUpdate();
+		message.unit = object.unit ?? "";
+		message.writeMaterialization = object.writeMaterialization ?? "";
+		message.rule = object.rule ?? "";
+		message.variant = object.variant ?? "";
+		return message;
+	}
+};
+function bytesFromBase64$1(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$1(arr) {
+	if (globalThis.Buffer) return globalThis.Buffer.from(arr).toString("base64");
+	else {
+		const bin = [];
+		arr.forEach((byte) => {
+			bin.push(globalThis.String.fromCharCode(byte));
+		});
+		return globalThis.btoa(bin.join(""));
+	}
+}
+function isObject(value) {
+	return typeof value === "object" && value !== null;
+}
+function isSet$2(value) {
+	return value !== null && value !== void 0;
+}
+const NOOP_LOG_FN = () => {};
+const debugBackend = loadDebug();
+const logger = new class LoggerImpl {
+	childLoggers = /* @__PURE__ */ new Map();
+	debug = NOOP_LOG_FN;
+	info = NOOP_LOG_FN;
+	warn = NOOP_LOG_FN;
+	error = NOOP_LOG_FN;
+	constructor(name) {
+		this.name = name;
+		this.configure();
+	}
+	async configure() {
+		const debug = await debugBackend;
+		if (!debug) return;
+		const debugFn = this.debug = (debug(this.name + ":debug"));
+		const infoFn = this.info = (debug(this.name + ":info"));
+		const warnFn = this.warn = (debug(this.name + ":warn"));
+		const errorFn = this.error = (debug(this.name + ":error"));
+		switch (true) {
+			case debugFn.enabled: infoFn.enabled = true;
+			case infoFn.enabled: warnFn.enabled = true;
+			case warnFn.enabled: errorFn.enabled = true;
+		}
+	}
+	getLogger(name) {
+		let child = (this.childLoggers.get(name));
+		if (!child) {
+			child = new LoggerImpl(this.name + ":" + name);
+			this.childLoggers.set(name, child);
+		}
+		return child;
+	}
+}("cnfd");
+async function loadDebug() {
+	try {
+		const { default: debug } = await import("debug");
+		return debug;
+	} catch (e) {
+		return null;
+	}
+}
+let TimeUnit = /* @__PURE__ */ function(TimeUnit$1) {
+	TimeUnit$1[TimeUnit$1["SECOND"] = 1e3] = "SECOND";
+	TimeUnit$1[TimeUnit$1["MINUTE"] = 6e4] = "MINUTE";
+	TimeUnit$1[TimeUnit$1["HOUR"] = 36e5] = "HOUR";
+	TimeUnit$1[TimeUnit$1["DAY"] = 864e5] = "DAY";
+	return TimeUnit$1;
+}({});
+function scheduleWithFixedInterval(operation, intervalMs, opt = {}) {
+	const maxConcurrent = opt.maxConcurrent ?? 1;
+	const ac = new AbortController();
+	let nextRunTimeoutId = 0;
+	let lastRunTime = 0;
+	let concurrent = 0;
+	const run = async () => {
+		lastRunTime = Date.now();
+		nextRunTimeoutId = portableSetTimeout(run, intervalMs);
+		if (concurrent >= maxConcurrent) return;
+		concurrent++;
+		try {
+			await operation(ac.signal);
+		} catch (e) {
+			logger.warn("scheduleWithFixedInterval failure:", e);
+		}
+		concurrent--;
+		if (Date.now() - lastRunTime > intervalMs && nextRunTimeoutId != 0) {
+			clearTimeout(nextRunTimeoutId);
+			run();
+		}
+	};
+	nextRunTimeoutId = portableSetTimeout(run, intervalMs);
+	const stop = () => {
+		clearTimeout(nextRunTimeoutId);
+		nextRunTimeoutId = 0;
+		ac.abort();
+	};
+	opt.signal?.addEventListener("abort", stop);
+	return stop;
+}
+function timeoutSignal(milliseconds) {
+	const ac = new AbortController();
+	portableSetTimeout(() => {
+		ac.abort(/* @__PURE__ */ new Error("Timeout"));
+	}, milliseconds, { unref: false });
+	return ac.signal;
+}
+function portableSetTimeout(callback, milliseconds, opt = {}) {
+	const timeout = setTimeout(callback, milliseconds);
+	if (opt.unref && typeof timeout === "object" && timeout !== null && "unref" in timeout && typeof timeout.unref === "function") timeout.unref();
+	return Number(timeout);
+}
+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) => {
+		let timeout;
+		const onTimeout = () => {
+			cleanup();
+			resolve();
+		};
+		const onAbort = () => {
+			cleanup();
+			reject(signal?.reason);
+		};
+		const cleanup = () => {
+			clearTimeout(timeout);
+			signal?.removeEventListener("abort", onAbort);
+		};
+		signal?.addEventListener("abort", onAbort);
+		timeout = portableSetTimeout(onTimeout, milliseconds);
+	});
+}
+function promiseSignal(signal) {
+	if (signal.aborted) return Promise.reject(signal.reason);
+	return new Promise((_, reject) => {
+		signal.addEventListener("abort", () => {
+			reject(signal.reason);
+		}, { once: true });
+	});
+}
+function abortablePromise(promise, signal) {
+	return signal ? Promise.race([promise, promiseSignal(signal)]) : promise;
+}
+const logger$1 = logger.getLogger("fetch");
+let Fetch;
+(function(_Fetch) {
+	function create(middleware, sink = fetch) {
+		return middleware.reduceRight((next, middleware$1) => middleware$1(next), sink);
+	}
+	_Fetch.create = create;
+})(Fetch || (Fetch = {}));
+let FetchMiddleware;
+(function(_FetchMiddleware) {
+	function compose(outer, inner) {
+		return (next) => outer(inner(next));
+	}
+	_FetchMiddleware.compose = compose;
+})(FetchMiddleware || (FetchMiddleware = {}));
+function withTimeout(timeoutMs) {
+	return (next) => (url, init = {}) => {
+		const signal = timeoutSignal$1(timeoutMs, init.signal);
+		return next(url, {
+			...init,
+			signal
+		});
+	};
+}
+function withStallTimeout(stallTimeoutMs) {
+	return (next) => async (url, init = {}) => {
+		const ac = new AbortController();
+		const signal = init.signal ? AbortSignal.any([ac.signal, init.signal]) : ac.signal;
+		const abort = () => {
+			ac.abort(/* @__PURE__ */ new Error(`The operation timed out after not receiving data for ${stallTimeoutMs}ms`));
+		};
+		let timeoutId = portableSetTimeout(abort, stallTimeoutMs);
+		const resp = await next(url, {
+			...init,
+			signal
+		});
+		clearTimeout(timeoutId);
+		if (resp.body) {
+			const chunks = [];
+			timeoutId = portableSetTimeout(abort, stallTimeoutMs);
+			for await (const chunk of resp.body) {
+				chunks.push(chunk);
+				clearTimeout(timeoutId);
+				timeoutId = portableSetTimeout(abort, stallTimeoutMs);
+			}
+			return new Response(new Blob(chunks), {
+				status: resp.status,
+				statusText: resp.statusText,
+				headers: resp.headers
+			});
+		}
+		return resp;
+	};
+}
+function withRetry(opts) {
+	const maxAttempts = opts?.maxAttempts ?? 6;
+	const baseInterval = opts?.baseInterval ?? 250;
+	const maxInterval = opts?.maxInterval ?? 3e4;
+	const backoff = opts?.backoff ?? 2;
+	const jitter = opts?.jitter ?? .1;
+	return (next) => async (url, { body, signal,...init } = {}) => {
+		const cloneBody = await bodyRepeater(body);
+		let attempts = 0;
+		let deadline = 0;
+		const calculateDeadline = () => {
+			const delay = (1 + 2 * Math.random() * jitter - jitter) * Math.min(maxInterval, baseInterval * Math.pow(backoff, attempts));
+			return Date.now() + delay;
+		};
+		const onSuccess = async (resp) => {
+			const { status, statusText } = resp;
+			if (status !== 408 && status !== 429 && status < 500 || attempts >= maxAttempts) return resp;
+			logger$1.debug("withRetry %s failed attempt %d with %d %s", url, attempts - 1, status, statusText);
+			const serverDelay = parseRetryAfter(resp.headers.get("Retry-After"), baseInterval, maxInterval);
+			await abortableSleep(serverDelay ?? deadline - Date.now(), signal);
+			return doTry();
+		};
+		const onError = async (error) => {
+			logger$1.debug("withRetry %s failed attempt %d with %s", url, attempts - 1, error);
+			if (signal?.aborted || attempts >= maxAttempts) throw error;
+			await abortableSleep(deadline - Date.now(), signal);
+			return doTry();
+		};
+		const doTry = () => {
+			let attemptSignal = signal;
+			deadline = calculateDeadline();
+			attempts++;
+			if (opts?.abortAtInterval) attemptSignal = timeoutSignal$1(deadline - Date.now(), signal);
+			return next(url, {
+				body: cloneBody(),
+				signal: attemptSignal,
+				...init
+			}).then(onSuccess, onError);
+		};
+		return doTry();
+	};
+}
+function withAuth(tokenProvider, signal) {
+	let renewTimeout = 0;
+	let current = null;
+	signal?.addEventListener("abort", () => {
+		clearTimeout(renewTimeout);
+	});
+	const renewToken = () => {
+		logger$1.debug("withAuth renewing token");
+		clearTimeout(renewTimeout);
+		current = tokenProvider().then(([token, expiry]) => {
+			logger$1.debug("withAuth renew success %s", expiry && expiry.valueOf() - Date.now());
+			if (expiry) {
+				const ttl = expiry.valueOf() - Date.now();
+				renewTimeout = portableSetTimeout(renewToken, .8 * ttl);
+			}
+			return token;
+		}).catch((e) => {
+			current = null;
+			throw e;
+		});
+	};
+	const fetchWithToken = async (fetch$1, url, init) => {
+		const token = await abortablePromise(current, init.signal);
+		const headers = new Headers(init.headers);
+		headers.set("Authorization", `Bearer ${token}`);
+		return fetch$1(url, {
+			...init,
+			headers
+		});
+	};
+	return (next) => async (url, init = {}) => {
+		const bodyClone = await bodyRepeater(init.body);
+		if (!current) renewToken();
+		const currentBeforeFetch = current;
+		let resp = await fetchWithToken(next, url, {
+			...init,
+			body: bodyClone()
+		});
+		if (resp.status === 401) {
+			if (current === currentBeforeFetch) renewToken();
+			resp = await fetchWithToken(next, url, {
+				...init,
+				body: bodyClone()
+			});
+		}
+		return resp;
+	};
+}
+function withRouter(routes) {
+	const hasOnlyOneStar = (s) => s.split("*").length - 1 === 1;
+	const compile = (pattern) => {
+		if (pattern.length >= 2 && pattern[0] === "^" && pattern[pattern.length - 1] === "$") {
+			const rx = new RegExp(pattern);
+			return (url) => rx.test(url);
+		}
+		if (pattern === "*") return (_) => true;
+		if (pattern.includes("|")) {
+			const predicates = pattern.split("|").map(compile);
+			return (url) => predicates.some((pred) => pred(url));
+		}
+		if (pattern.startsWith("*") && hasOnlyOneStar(pattern)) {
+			const suffix = pattern.slice(1);
+			return (url) => url.endsWith(suffix);
+		}
+		if (pattern.endsWith("*") && hasOnlyOneStar(pattern)) {
+			const prefix = pattern.slice(0, -1);
+			return (url) => url.startsWith(prefix);
+		}
+		if (pattern.includes("*")) throw new Error(`withRouter unsupported pattern "${pattern}". Only single leading or trailing * (or * alone) supported.`);
+		return (url) => url === pattern;
+	};
+	const preCompiled = Object.entries(routes).map(([pattern, middlewares]) => {
+		return [compile(pattern), middlewares];
+	});
+	return (next) => {
+		const table = preCompiled.map(([predicate, middlewares]) => {
+			const fetch$1 = Fetch.create(middlewares, next);
+			return [predicate, fetch$1];
+		});
+		return async (url, init = {}) => {
+			const match = table.find(([pred]) => pred(url));
+			if (!match) {
+				logger$1.info("withRouter no route matched %s, falling through", url);
+				return next(url, init);
+			}
+			return match[1](url, init);
+		};
+	};
+}
+function withResponse(factory) {
+	return (_next) => factory;
+}
+const fetchLogger = logger$1;
+function withLogging(logger$2 = fetchLogger) {
+	return (next) => async (url, init) => {
+		const start = Date.now();
+		const resp = await next(url, init);
+		const duration = Date.now() - start;
+		logger$2.info("%s %s (%i) %dms", (init?.method ?? "get").toUpperCase(), url.split("?", 1)[0], resp.status, duration);
+		return resp;
+	};
+}
+async function bodyRepeater(body) {
+	if (body instanceof ReadableStream) {
+		const blob = await new Response(body).blob();
+		return () => blob.stream();
+	}
+	return () => body;
+}
+function parseRetryAfter(retryAfterValue, min = 0, max = Number.MAX_SAFE_INTEGER) {
+	if (retryAfterValue) {
+		let delay = Number(retryAfterValue) * 1e3;
+		if (Number.isNaN(delay)) delay = Date.parse(retryAfterValue) - Date.now();
+		if (Number.isFinite(delay) && delay > 0) return Math.max(min, Math.min(delay, max));
+	}
+}
+function timeoutSignal$1(delay, signal) {
+	const ac = new AbortController();
+	portableSetTimeout(() => ac.abort(/* @__PURE__ */ new Error(`Operation timed out after ${delay}ms`)), delay);
+	return signal ? AbortSignal.any([signal, ac.signal]) : ac.signal;
+}
+const DEFAULT_STATE_INTERVAL = 3e4;
+const DEFAULT_FLUSH_INTERVAL = 1e4;
+var ConfidenceServerProviderLocal = class ConfidenceServerProviderLocal {
+	metadata = { name: "ConfidenceServerProviderLocal" };
+	status = "NOT_READY";
+	main = new AbortController();
+	fetch;
+	flushInterval;
+	stateEtag = null;
+	constructor(resolver$1, options) {
+		this.resolver = resolver$1;
+		this.options = options;
+		this.flushInterval = options.flushInterval ?? DEFAULT_FLUSH_INTERVAL;
+		const withConfidenceAuth = withAuth(async () => {
+			const { accessToken, expiresIn } = await this.fetchToken();
+			return [accessToken, new Date(Date.now() + 1e3 * expiresIn)];
+		}, this.main.signal);
+		const withFastRetry = FetchMiddleware.compose(withRetry({
+			maxAttempts: Infinity,
+			baseInterval: 300,
+			maxInterval: 5 * TimeUnit.SECOND
+		}), withTimeout(5 * TimeUnit.SECOND));
+		this.fetch = Fetch.create([withRouter({
+			"https://iam.confidence.dev/v1/oauth/token": [withFastRetry],
+			"https://storage.googleapis.com/*": [withRetry({
+				maxAttempts: Infinity,
+				baseInterval: 500,
+				maxInterval: DEFAULT_STATE_INTERVAL
+			}), withStallTimeout(500)],
+			"https://flags.confidence.dev/*|https://resolver.confidence.dev/*": [withConfidenceAuth, withRouter({
+				"*/v1/resolverState:resolverStateUri": [withFastRetry],
+				"*/v1/flags:resolve": [withRetry({
+					maxAttempts: 3,
+					baseInterval: 100
+				}), withTimeout(3 * TimeUnit.SECOND)],
+				"*/v1/flagLogs:write": [withRetry({
+					maxAttempts: 3,
+					baseInterval: 500
+				}), withTimeout(5 * TimeUnit.SECOND)]
+			})],
+			"*": [withResponse((url) => {
+				throw new Error(`Unknown route ${url}`);
+			})]
+		}), withLogging()], options.fetch ?? fetch);
+	}
+	async initialize(context) {
+		const signal = this.main.signal;
+		const initialUpdateSignal = AbortSignal.any([signal, timeoutSignal(this.options.initializeTimeout ?? DEFAULT_STATE_INTERVAL)]);
+		try {
+			await this.updateState(initialUpdateSignal);
+			scheduleWithFixedInterval((signal$1) => this.flush(signal$1), this.flushInterval, {
+				maxConcurrent: 3,
+				signal
+			});
+			scheduleWithFixedInterval((signal$1) => this.updateState(signal$1), DEFAULT_STATE_INTERVAL, { signal });
+			this.status = "READY";
+		} catch (e) {
+			this.status = "ERROR";
+			throw e;
+		}
+	}
+	async onClose() {
+		await this.flush(timeoutSignal(3e3));
+		this.main.abort();
+	}
+	async evaluate(flagKey, defaultValue, context) {
+		const [flagName, ...path] = flagKey.split(".");
+		const stickyRequest = {
+			resolveRequest: {
+				flags: [`flags/${flagName}`],
+				evaluationContext: ConfidenceServerProviderLocal.convertEvaluationContext(context),
+				apply: true,
+				clientSecret: this.options.flagClientSecret
+			},
+			materializationsPerUnit: {},
+			failFastOnSticky: true
+		};
+		const response = await this.resolveWithStickyInternal(stickyRequest);
+		return this.extractValue(response.resolvedFlags[0], flagName, path, defaultValue);
+	}
+	async resolveWithStickyInternal(request) {
+		const response = this.resolver.resolveWithSticky(request);
+		if (response.success && response.success.response) {
+			const { response: flagsResponse } = response.success;
+			return flagsResponse;
+		}
+		if (response.missingMaterializations) return await this.remoteResolve(request.resolveRequest);
+		throw new Error("Invalid response: resolve result not set");
+	}
+	async remoteResolve(request) {
+		const resp = await this.fetch("https://resolver.confidence.dev/v1/flags:resolve", {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(ResolveFlagsRequest.toJSON(request))
+		});
+		if (!resp.ok) throw new Error(`Remote resolve failed: ${resp.status} ${resp.statusText}`);
+		const json = await resp.json();
+		return ResolveFlagsResponse.fromJSON(json);
+	}
+	extractValue(flag, flagName, path, defaultValue) {
+		if (!flag) return {
+			value: defaultValue,
+			reason: "ERROR",
+			errorCode: "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: "TYPE_MISMATCH"
+			};
+			value = value[step];
+		}
+		if (!isAssignableTo(value, defaultValue)) return {
+			value: defaultValue,
+			reason: "ERROR",
+			errorCode: "TYPE_MISMATCH"
+		};
+		return {
+			value,
+			reason: "MATCH",
+			variant: flag.variant
+		};
+	}
+	async updateState(signal) {
+		const { signedUri, account } = await this.fetchResolveStateUri(signal);
+		const headers = new Headers();
+		if (this.stateEtag) headers.set("If-None-Match", this.stateEtag);
+		const resp = await this.fetch(signedUri, {
+			headers,
+			signal
+		});
+		if (resp.status === 304) return;
+		if (!resp.ok) throw new Error(`Failed to fetch state: ${resp.status} ${resp.statusText}`);
+		this.stateEtag = resp.headers.get("etag");
+		const state = new Uint8Array(await resp.arrayBuffer());
+		this.resolver.setResolverState({
+			accountId: account,
+			state
+		});
+	}
+	async flush(signal) {
+		const writeFlagLogRequest = this.resolver.flushLogs();
+		if (writeFlagLogRequest.length == 0) return;
+		await this.fetch("https://resolver.confidence.dev/v1/flagLogs:write", {
+			method: "post",
+			signal,
+			headers: { "Content-Type": "application/x-protobuf" },
+			body: writeFlagLogRequest
+		});
+	}
+	async fetchResolveStateUri(signal) {
+		const resp = await this.fetch("https://flags.confidence.dev/v1/resolverState:resolverStateUri", { signal });
+		if (!resp.ok) throw new Error("Failed to get resolve state url");
+		return resp.json();
+	}
+	async fetchToken() {
+		const resp = await this.fetch("https://iam.confidence.dev/v1/oauth/token", {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({
+				clientId: this.options.apiClientId,
+				clientSecret: this.options.apiClientSecret,
+				grantType: "client_credentials"
+			})
+		});
+		if (!resp.ok) throw new Error("Failed to fetch access token");
+		return resp.json();
+	}
+	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,
+			...rest
+		};
+	}
+	resolveBooleanEvaluation(flagKey, defaultValue, context) {
+		return Promise.resolve(this.evaluate(flagKey, defaultValue, context));
+	}
+	resolveNumberEvaluation(flagKey, defaultValue, context) {
+		return Promise.resolve(this.evaluate(flagKey, defaultValue, context));
+	}
+	resolveObjectEvaluation(flagKey, defaultValue, context) {
+		return Promise.resolve(this.evaluate(flagKey, defaultValue, context));
+	}
+	resolveStringEvaluation(flagKey, defaultValue, context) {
+		return Promise.resolve(this.evaluate(flagKey, defaultValue, context));
+	}
+};
+function hasKey(obj, key) {
+	return key in obj;
+}
+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;
+		}
+	}
+	return true;
+}
+function createBaseVoid() {
+	return {};
+}
+const Void = {
+	encode(_, writer = new BinaryWriter()) {
+		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 = createBaseVoid();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(_) {
+		return {};
+	},
+	toJSON(_) {
+		return {};
+	},
+	create(base) {
+		return Void.fromPartial(base ?? {});
+	},
+	fromPartial(_) {
+		return createBaseVoid();
+	}
+};
+function createBaseRequest() {
+	return { data: new Uint8Array(0) };
+}
+const Request = {
+	encode(message, writer = new BinaryWriter()) {
+		if (message.data.length !== 0) writer.uint32(10).bytes(message.data);
+		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 = createBaseRequest();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 10) break;
+					message.data = reader.bytes();
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return { data: isSet$1(object.data) ? bytesFromBase64(object.data) : new Uint8Array(0) };
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.data.length !== 0) obj.data = base64FromBytes(message.data);
+		return obj;
+	},
+	create(base) {
+		return Request.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseRequest();
+		message.data = object.data ?? new Uint8Array(0);
+		return message;
+	}
+};
+function createBaseResponse() {
+	return {
+		data: void 0,
+		error: void 0
+	};
+}
+const Response$1 = {
+	encode(message, writer = new BinaryWriter()) {
+		if (message.data !== void 0) writer.uint32(10).bytes(message.data);
+		if (message.error !== void 0) writer.uint32(18).string(message.error);
+		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 = createBaseResponse();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 10) break;
+					message.data = reader.bytes();
+					continue;
+				case 2:
+					if (tag !== 18) break;
+					message.error = reader.string();
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return {
+			data: isSet$1(object.data) ? bytesFromBase64(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.error !== void 0) obj.error = message.error;
+		return obj;
+	},
+	create(base) {
+		return Response$1.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseResponse();
+		message.data = object.data ?? void 0;
+		message.error = object.error ?? void 0;
+		return message;
+	}
+};
+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(globalThis.String.fromCharCode(byte));
+		});
+		return globalThis.btoa(bin.join(""));
+	}
+}
+function isSet$1(value) {
+	return value !== null && value !== void 0;
+}
+function createBaseTimestamp() {
+	return {
+		seconds: 0,
+		nanos: 0
+	};
+}
+const Timestamp = {
+	encode(message, writer = new BinaryWriter()) {
+		if (message.seconds !== 0) writer.uint32(8).int64(message.seconds);
+		if (message.nanos !== 0) writer.uint32(16).int32(message.nanos);
+		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 = createBaseTimestamp();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 8) break;
+					message.seconds = longToNumber(reader.int64());
+					continue;
+				case 2:
+					if (tag !== 16) break;
+					message.nanos = reader.int32();
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return {
+			seconds: isSet(object.seconds) ? globalThis.Number(object.seconds) : 0,
+			nanos: isSet(object.nanos) ? globalThis.Number(object.nanos) : 0
+		};
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.seconds !== 0) obj.seconds = Math.round(message.seconds);
+		if (message.nanos !== 0) obj.nanos = Math.round(message.nanos);
+		return obj;
+	},
+	create(base) {
+		return Timestamp.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseTimestamp();
+		message.seconds = object.seconds ?? 0;
+		message.nanos = object.nanos ?? 0;
+		return message;
+	}
+};
+function longToNumber(int64) {
+	const num = globalThis.Number(int64.toString());
+	if (num > globalThis.Number.MAX_SAFE_INTEGER) throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
+	if (num < globalThis.Number.MIN_SAFE_INTEGER) throw new globalThis.Error("Value is smaller than Number.MIN_SAFE_INTEGER");
+	return num;
+}
+function isSet(value) {
+	return value !== null && value !== void 0;
+}
+var WasmResolver = class WasmResolver {
+	exports;
+	imports;
+	constructor() {
+		this.imports = { wasm_msg: { wasm_msg_host_current_time: () => {
+			const epochMillisecond = Date.now();
+			const seconds = Math.floor(epochMillisecond / 1e3);
+			const nanos = (epochMillisecond - 1e3 * seconds) * 1e6;
+			return this.transferRequest({
+				seconds,
+				nanos
+			}, Timestamp);
+		} } };
+	}
+	resolveWithSticky(request) {
+		const reqPtr = this.transferRequest(request, ResolveWithStickyRequest);
+		const resPtr = this.exports.wasm_msg_guest_resolve_with_sticky(reqPtr);
+		return this.consumeResponse(resPtr, ResolveWithStickyResponse);
+	}
+	setResolverState(request) {
+		const reqPtr = this.transferRequest(request, SetResolverStateRequest);
+		const resPtr = this.exports.wasm_msg_guest_set_resolver_state(reqPtr);
+		this.consumeResponse(resPtr, Void);
+	}
+	flushLogs() {
+		const resPtr = this.exports.wasm_msg_guest_flush_logs(0);
+		const { data, error } = this.consume(resPtr, Response$1);
+		if (error) throw new Error(error);
+		return data;
+	}
+	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);
+		return codec.decode(data);
+	}
+	transfer(data, codec) {
+		const encoded = codec.encode(data).finish();
+		const ptr = this.exports.wasm_msg_alloc(encoded.length);
+		this.viewBuffer(ptr).set(encoded);
+		return ptr;
+	}
+	consume(ptr, codec) {
+		const data = this.viewBuffer(ptr);
+		const res = codec.decode(data.slice());
+		this.free(ptr);
+		return res;
+	}
+	viewBuffer(ptr) {
+		const size = new DataView(this.exports.memory.buffer).getUint32(ptr - 4, true);
+		return new Uint8Array(this.exports.memory.buffer, ptr, size - 4);
+	}
+	free(ptr) {
+		this.exports.wasm_msg_free(ptr);
+	}
+	static async load(module$1) {
+		const wasmResolver = new WasmResolver();
+		wasmResolver.exports = (await WebAssembly.instantiate(module$1, wasmResolver.imports)).exports;
+		return wasmResolver;
+	}
+};
+const wasmPath = __require.resolve("./confidence_resolver.wasm");
+const buffer = await fs.readFile(wasmPath);
+const module = await WebAssembly.compile(buffer);
+const resolver = await WasmResolver.load(module);
+function createConfidenceServerProvider(options) {
+	return new ConfidenceServerProviderLocal(resolver, options);
+}
+export { createConfidenceServerProvider };