@spotify-confidence/openfeature-server-provider-local 0.9.1 → 0.10.0

package/dist/index.node.js

@@ -776,6 +776,7 @@ let ResolveReason = /* @__PURE__ */ function(ResolveReason$1) {
 	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["RESOLVE_REASON_UNRECOGNIZED_TARGETING_RULE"] = 7] = "RESOLVE_REASON_UNRECOGNIZED_TARGETING_RULE";
+	ResolveReason$1[ResolveReason$1["RESOLVE_REASON_MATERIALIZATION_NOT_SUPPORTED"] = 8] = "RESOLVE_REASON_MATERIALIZATION_NOT_SUPPORTED";
 	ResolveReason$1[ResolveReason$1["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
 	return ResolveReason$1;
 }({});
@@ -797,6 +798,8 @@ function resolveReasonFromJSON(object) {
 		case "RESOLVE_REASON_ERROR": return ResolveReason.RESOLVE_REASON_ERROR;
 		case 7:
 		case "RESOLVE_REASON_UNRECOGNIZED_TARGETING_RULE": return ResolveReason.RESOLVE_REASON_UNRECOGNIZED_TARGETING_RULE;
+		case 8:
+		case "RESOLVE_REASON_MATERIALIZATION_NOT_SUPPORTED": return ResolveReason.RESOLVE_REASON_MATERIALIZATION_NOT_SUPPORTED;
 		case -1:
 		case "UNRECOGNIZED":
 		default: return ResolveReason.UNRECOGNIZED;
@@ -812,6 +815,7 @@ function resolveReasonToJSON(object) {
 		case ResolveReason.RESOLVE_REASON_TARGETING_KEY_ERROR: return "RESOLVE_REASON_TARGETING_KEY_ERROR";
 		case ResolveReason.RESOLVE_REASON_ERROR: return "RESOLVE_REASON_ERROR";
 		case ResolveReason.RESOLVE_REASON_UNRECOGNIZED_TARGETING_RULE: return "RESOLVE_REASON_UNRECOGNIZED_TARGETING_RULE";
+		case ResolveReason.RESOLVE_REASON_MATERIALIZATION_NOT_SUPPORTED: return "RESOLVE_REASON_MATERIALIZATION_NOT_SUPPORTED";
 		case ResolveReason.UNRECOGNIZED:
 		default: return "UNRECOGNIZED";
 	}
@@ -1116,14 +1120,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$2(object.resolveToken) : new Uint8Array(0),
+			resolveToken: isSet$3(object.resolveToken) ? bytesFromBase64$3(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$2(message.resolveToken);
+		if (message.resolveToken.length !== 0) obj.resolveToken = base64FromBytes$3(message.resolveToken);
 		if (message.resolveId !== "") obj.resolveId = message.resolveId;
 		return obj;
 	},
@@ -1193,7 +1197,7 @@ const ApplyFlagsRequest = {
 		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),
+			resolveToken: isSet$3(object.resolveToken) ? bytesFromBase64$3(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
 		};
@@ -1202,7 +1206,7 @@ const ApplyFlagsRequest = {
 		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.resolveToken.length !== 0) obj.resolveToken = base64FromBytes$3(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;
@@ -1366,7 +1370,7 @@ const ResolvedFlag = {
 		return message;
 	}
 };
-function bytesFromBase64$2(b64) {
+function bytesFromBase64$3(b64) {
 	if (globalThis.Buffer) return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
 	else {
 		const bin = globalThis.atob(b64);
@@ -1375,7 +1379,7 @@ function bytesFromBase64$2(b64) {
 		return arr;
 	}
 }
-function base64FromBytes$2(arr) {
+function base64FromBytes$3(arr) {
 	if (globalThis.Buffer) return globalThis.Buffer.from(arr).toString("base64");
 	else {
 		const bin = [];
@@ -1409,7 +1413,7 @@ function isObject(value) {
 function isSet$3(value) {
 	return value !== null && value !== void 0;
 }
-const VERSION = "0.9.1";
+const VERSION = "0.10.0";
 const NOOP_LOG_FN = Object.assign(() => {}, { enabled: false });
 const debugBackend = loadDebug();
 const logger$2 = new class LoggerImpl {
@@ -1542,7 +1546,7 @@ function hasKey(obj, key) {
 function castStringToEnum(value) {
 	return value;
 }
-function bytesFromBase64(b64) {
+function bytesFromBase64$1(b64) {
 	if (globalThis.Buffer) return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
 	else {
 		const bin = globalThis.atob(b64);
@@ -1551,7 +1555,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 = [];
@@ -2262,6 +2266,53 @@ var ConfidenceRemoteMaterializationStore = class {
 		if (!response.ok) throw new Error(`Failed to write materializations: ${response.status} ${response.statusText}`);
 	}
 };
+function materializationRecordsToReadOps(records) {
+	return records.map((record) => {
+		if (record.rule) return {
+			op: "variant",
+			unit: record.unit,
+			materialization: record.materialization,
+			rule: record.rule
+		};
+		return {
+			op: "inclusion",
+			unit: record.unit,
+			materialization: record.materialization
+		};
+	});
+}
+function readResultsToMaterializationRecords(results) {
+	return results.flatMap((result) => {
+		switch (result.op) {
+			case "variant":
+				if (result.variant) return [{
+					unit: result.unit,
+					materialization: result.materialization,
+					rule: result.rule,
+					variant: result.variant
+				}];
+				return [];
+			case "inclusion":
+				if (result.included) return [{
+					unit: result.unit,
+					materialization: result.materialization,
+					rule: "",
+					variant: ""
+				}];
+				return [];
+		}
+		return [];
+	});
+}
+function materializationRecordsToWriteOps(records) {
+	return records.map((record) => ({
+		op: "variant",
+		unit: record.unit,
+		materialization: record.materialization,
+		rule: record.rule,
+		variant: record.variant
+	}));
+}
 function readOpsToProto(readOps) {
 	return { ops: readOps.flatMap((readOp) => {
 		switch (readOp.op) {
@@ -2278,22 +2329,6 @@ function readOpsToProto(readOps) {
 		return [];
 	}) };
 }
-function readOpsFromProto(readOpReq) {
-	return readOpReq.ops.flatMap(({ variantReadOp, inclusionReadOp }) => {
-		if (variantReadOp) return [{
-			op: "variant",
-			unit: variantReadOp.unit,
-			materialization: variantReadOp.materialization,
-			rule: variantReadOp.rule
-		}];
-		if (inclusionReadOp) return [{
-			op: "inclusion",
-			unit: inclusionReadOp.unit,
-			materialization: inclusionReadOp.materialization
-		}];
-		return [];
-	});
-}
 function readResultFromProto(result) {
 	return result.results.flatMap(({ inclusionResult, variantResult }) => {
 		if (inclusionResult) return [{
@@ -2312,24 +2347,6 @@ function readResultFromProto(result) {
 		return [];
 	});
 }
-function readResultToProto(readResults) {
-	return { results: readResults.flatMap((readResult) => {
-		switch (readResult.op) {
-			case "inclusion": return [{ inclusionResult: {
-				unit: readResult.unit,
-				materialization: readResult.materialization,
-				isIncluded: readResult.included
-			} }];
-			case "variant": return [{ variantResult: {
-				unit: readResult.unit,
-				materialization: readResult.materialization,
-				rule: readResult.rule,
-				variant: readResult.variant ?? ""
-			} }];
-		}
-		return [];
-	}) };
-}
 function writeOpsToProto(writeOps) {
 	return { storeVariantOp: writeOps.flatMap((writeOp) => {
 		switch (writeOp.op) {
@@ -2343,17 +2360,6 @@ function writeOpsToProto(writeOps) {
 		return [];
 	}) };
 }
-function writeOpsFromProto(writeOpsReq) {
-	return writeOpsReq.storeVariantOp.map((variantData) => {
-		return {
-			op: "variant",
-			unit: variantData.unit,
-			materialization: variantData.materialization,
-			rule: variantData.rule,
-			variant: variantData.variant
-		};
-	});
-}
 function createBaseVoid() {
 	return {};
 }
@@ -2421,13 +2427,13 @@ const SetResolverStateRequest = {
 	},
 	fromJSON(object) {
 		return {
-			state: isSet$1(object.state) ? bytesFromBase64$1(object.state) : new Uint8Array(0),
+			state: isSet$1(object.state) ? bytesFromBase64$2(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$1(message.state);
+		if (message.state.length !== 0) obj.state = base64FromBytes$2(message.state);
 		if (message.accountId !== "") obj.accountId = message.accountId;
 		return obj;
 	},
@@ -2467,11 +2473,11 @@ const Request = {
 		return message;
 	},
 	fromJSON(object) {
-		return { data: isSet$1(object.data) ? bytesFromBase64$1(object.data) : new Uint8Array(0) };
+		return { data: isSet$1(object.data) ? bytesFromBase64$2(object.data) : new Uint8Array(0) };
 	},
 	toJSON(message) {
 		const obj = {};
-		if (message.data.length !== 0) obj.data = base64FromBytes$1(message.data);
+		if (message.data.length !== 0) obj.data = base64FromBytes$2(message.data);
 		return obj;
 	},
 	create(base) {
@@ -2518,13 +2524,13 @@ const Response$1 = {
 	},
 	fromJSON(object) {
 		return {
-			data: isSet$1(object.data) ? bytesFromBase64$1(object.data) : void 0,
+			data: isSet$1(object.data) ? bytesFromBase64$2(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$1(message.data);
+		if (message.data !== void 0) obj.data = base64FromBytes$2(message.data);
 		if (message.error !== void 0) obj.error = message.error;
 		return obj;
 	},
@@ -2538,7 +2544,7 @@ const Response$1 = {
 		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);
@@ -2547,7 +2553,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 = [];
@@ -2568,8 +2574,8 @@ let ErrorCode = /* @__PURE__ */ function(ErrorCode$1) {
 	ErrorCode$1["GENERAL"] = "GENERAL";
 	return ErrorCode$1;
 }({});
-const encodeToken = base64FromBytes;
-const decodeToken = bytesFromBase64;
+const encodeToken = base64FromBytes$1;
+const decodeToken = bytesFromBase64$1;
 function create({ resolveId, resolveToken, resolvedFlags }) {
 	return {
 		flags: Object.fromEntries(resolvedFlags.map(({ flag, reason, variant, value, shouldApply }) => {
@@ -2676,7 +2682,7 @@ function convertReason(reason) {
 const logger$1 = getLogger("provider");
 const DEFAULT_INITIALIZE_TIMEOUT = 3e4;
 const DEFAULT_STATE_INTERVAL = 3e4;
-const DEFAULT_FLUSH_INTERVAL = 1e4;
+const DEFAULT_FLUSH_INTERVAL = 15e3;
 var ConfidenceServerProviderLocal = class ConfidenceServerProviderLocal {
 	metadata = { name: "ConfidenceServerProviderLocal" };
 	status = castStringToEnum("NOT_READY");
@@ -2702,7 +2708,7 @@ var ConfidenceServerProviderLocal = class ConfidenceServerProviderLocal {
 				maxAttempts: Infinity,
 				baseInterval: 500,
 				maxInterval: this.stateUpdateInterval
-			}), withStallTimeout(500)],
+			}), withStallTimeout(1 * TimeUnit.SECOND)],
 			"https://resolver.confidence.dev/*": [withRouter({
 				"*/v1/materialization:readMaterializedOperations": [withRetry({
 					maxAttempts: 3,
@@ -2747,23 +2753,19 @@ var ConfidenceServerProviderLocal = class ConfidenceServerProviderLocal {
 		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
+		const 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
+			}
 		};
 		try {
-			return create(await this.resolveWithSticky(stickyRequest));
+			const processRequest = this.materializationStore ? { deferredMaterializations: resolveRequest } : { withoutMaterializations: resolveRequest };
+			return create(await this.resolveProcess(processRequest));
 		} catch (err) {
 			return error(ErrorCode.GENERAL, String(err));
 		}
@@ -2777,19 +2779,30 @@ var ConfidenceServerProviderLocal = class ConfidenceServerProviderLocal {
 			this.flushAssigned();
 		}
 	}
-	async resolveWithSticky(stickyRequest) {
-		let stickyResponse = this.resolver.resolveWithSticky(stickyRequest);
-		if (stickyResponse.readOpsRequest) {
-			const { results: materializations } = await this.readMaterializations(stickyResponse.readOpsRequest);
-			stickyResponse = this.resolver.resolveWithSticky({
-				...stickyRequest,
-				materializations
-			});
+	async resolveProcess(request) {
+		const response = this.resolver.resolveProcess(request);
+		if (response.suspended) {
+			const { materializationsToRead, state } = response.suspended;
+			const readOps = materializationRecordsToReadOps(materializationsToRead);
+			const readResults = await this.readMaterializations(readOps);
+			const materializations = readResultsToMaterializationRecords(readResults);
+			const resumeResponse = this.resolver.resolveProcess({ resume: {
+				materializations,
+				state
+			} });
+			if (!resumeResponse.resolved) throw new Error("Resolve still suspended after providing materializations");
+			this.handleMaterializationWrites(resumeResponse.resolved.materializationsToWrite);
+			return ResolveFlagsResponse.create(resumeResponse.resolved.response);
+		}
+		if (!response.resolved) throw new Error("Unexpected empty resolve response");
+		this.handleMaterializationWrites(response.resolved.materializationsToWrite);
+		return ResolveFlagsResponse.create(response.resolved.response);
+	}
+	handleMaterializationWrites(records) {
+		if (records.length > 0) {
+			const writeOps = materializationRecordsToWriteOps(records);
+			this.writeMaterializations(writeOps);
 		}
-		if (!stickyResponse.success) throw new Error("Missing materializations");
-		const { materializationUpdates: storeVariantOp, response: resolveResponse } = stickyResponse.success;
-		if (storeVariantOp.length) this.writeMaterializations({ storeVariantOp });
-		return ResolveFlagsResponse.create(resolveResponse);
 	}
 	async updateState(signal) {
 		const cdnUrl = `https://confidence-resolver-state-cdn.spotifycdn.com/${await sha256Hex(this.options.flagClientSecret)}`;
@@ -2830,18 +2843,15 @@ var ConfidenceServerProviderLocal = class ConfidenceServerProviderLocal {
 			throw err;
 		}
 	}
-	async readMaterializations(readOpsReq) {
+	async readMaterializations(readOps) {
 		const materializationStore = this.materializationStore;
-		if (materializationStore && typeof materializationStore.readMaterializations === "function") {
-			const result = await materializationStore.readMaterializations(readOpsFromProto(readOpsReq));
-			return readResultToProto(result);
-		}
+		if (materializationStore && typeof materializationStore.readMaterializations === "function") return materializationStore.readMaterializations(readOps);
 		throw new Error("Read materialization not supported");
 	}
-	writeMaterializations(writeOpsRequest) {
+	writeMaterializations(writeOps) {
 		const materializationStore = this.materializationStore;
 		if (materializationStore && typeof materializationStore.writeMaterializations === "function") {
-			materializationStore.writeMaterializations(writeOpsFromProto(writeOpsRequest)).catch((e) => {
+			materializationStore.writeMaterializations(writeOps).catch((e) => {
 				logger$1.warn("Failed to write materialization", e);
 			});
 			return;
@@ -2883,44 +2893,105 @@ var ConfidenceServerProviderLocal = class ConfidenceServerProviderLocal {
 		this.resolver.applyFlags(request);
 	}
 };
-function createBaseResolveWithStickyRequest() {
+function createBaseResolveProcessRequest() {
 	return {
-		resolveRequest: void 0,
-		failFastOnSticky: false,
-		notProcessSticky: false,
-		materializations: []
+		deferredMaterializations: void 0,
+		staticMaterializations: void 0,
+		withoutMaterializations: void 0,
+		resume: void 0
 	};
 }
-const ResolveWithStickyRequest = {
+const ResolveProcessRequest = {
 	encode(message, writer = new BinaryWriter()) {
-		if (message.resolveRequest !== void 0) ResolveFlagsRequest.encode(message.resolveRequest, writer.uint32(10).fork()).join();
-		if (message.failFastOnSticky !== false) writer.uint32(24).bool(message.failFastOnSticky);
-		if (message.notProcessSticky !== false) writer.uint32(32).bool(message.notProcessSticky);
-		for (const v of message.materializations) ReadResult.encode(v, writer.uint32(42).fork()).join();
+		if (message.deferredMaterializations !== void 0) ResolveFlagsRequest.encode(message.deferredMaterializations, writer.uint32(10).fork()).join();
+		if (message.staticMaterializations !== void 0) ResolveProcessRequest_StaticMaterializations.encode(message.staticMaterializations, writer.uint32(18).fork()).join();
+		if (message.withoutMaterializations !== void 0) ResolveFlagsRequest.encode(message.withoutMaterializations, writer.uint32(26).fork()).join();
+		if (message.resume !== void 0) ResolveProcessRequest_Resume.encode(message.resume, writer.uint32(34).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();
+		const message = createBaseResolveProcessRequest();
 		while (reader.pos < end) {
 			const tag = reader.uint32();
 			switch (tag >>> 3) {
 				case 1:
 					if (tag !== 10) break;
-					message.resolveRequest = ResolveFlagsRequest.decode(reader, reader.uint32());
+					message.deferredMaterializations = ResolveFlagsRequest.decode(reader, reader.uint32());
+					continue;
+				case 2:
+					if (tag !== 18) break;
+					message.staticMaterializations = ResolveProcessRequest_StaticMaterializations.decode(reader, reader.uint32());
 					continue;
 				case 3:
-					if (tag !== 24) break;
-					message.failFastOnSticky = reader.bool();
+					if (tag !== 26) break;
+					message.withoutMaterializations = ResolveFlagsRequest.decode(reader, reader.uint32());
 					continue;
 				case 4:
-					if (tag !== 32) break;
-					message.notProcessSticky = reader.bool();
+					if (tag !== 34) break;
+					message.resume = ResolveProcessRequest_Resume.decode(reader, reader.uint32());
 					continue;
-				case 5:
-					if (tag !== 42) break;
-					message.materializations.push(ReadResult.decode(reader, reader.uint32()));
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return {
+			deferredMaterializations: isSet(object.deferredMaterializations) ? ResolveFlagsRequest.fromJSON(object.deferredMaterializations) : void 0,
+			staticMaterializations: isSet(object.staticMaterializations) ? ResolveProcessRequest_StaticMaterializations.fromJSON(object.staticMaterializations) : void 0,
+			withoutMaterializations: isSet(object.withoutMaterializations) ? ResolveFlagsRequest.fromJSON(object.withoutMaterializations) : void 0,
+			resume: isSet(object.resume) ? ResolveProcessRequest_Resume.fromJSON(object.resume) : void 0
+		};
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.deferredMaterializations !== void 0) obj.deferredMaterializations = ResolveFlagsRequest.toJSON(message.deferredMaterializations);
+		if (message.staticMaterializations !== void 0) obj.staticMaterializations = ResolveProcessRequest_StaticMaterializations.toJSON(message.staticMaterializations);
+		if (message.withoutMaterializations !== void 0) obj.withoutMaterializations = ResolveFlagsRequest.toJSON(message.withoutMaterializations);
+		if (message.resume !== void 0) obj.resume = ResolveProcessRequest_Resume.toJSON(message.resume);
+		return obj;
+	},
+	create(base) {
+		return ResolveProcessRequest.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseResolveProcessRequest();
+		message.deferredMaterializations = object.deferredMaterializations !== void 0 && object.deferredMaterializations !== null ? ResolveFlagsRequest.fromPartial(object.deferredMaterializations) : void 0;
+		message.staticMaterializations = object.staticMaterializations !== void 0 && object.staticMaterializations !== null ? ResolveProcessRequest_StaticMaterializations.fromPartial(object.staticMaterializations) : void 0;
+		message.withoutMaterializations = object.withoutMaterializations !== void 0 && object.withoutMaterializations !== null ? ResolveFlagsRequest.fromPartial(object.withoutMaterializations) : void 0;
+		message.resume = object.resume !== void 0 && object.resume !== null ? ResolveProcessRequest_Resume.fromPartial(object.resume) : void 0;
+		return message;
+	}
+};
+function createBaseResolveProcessRequest_StaticMaterializations() {
+	return {
+		resolveRequest: void 0,
+		materializations: []
+	};
+}
+const ResolveProcessRequest_StaticMaterializations = {
+	encode(message, writer = new BinaryWriter()) {
+		if (message.resolveRequest !== void 0) ResolveFlagsRequest.encode(message.resolveRequest, writer.uint32(10).fork()).join();
+		for (const v of message.materializations) MaterializationRecord.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 = createBaseResolveProcessRequest_StaticMaterializations();
+		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;
+					message.materializations.push(MaterializationRecord.decode(reader, reader.uint32()));
 					continue;
 			}
 			if ((tag & 7) === 4 || tag === 0) break;
@@ -2931,57 +3002,51 @@ const ResolveWithStickyRequest = {
 	fromJSON(object) {
 		return {
 			resolveRequest: isSet(object.resolveRequest) ? ResolveFlagsRequest.fromJSON(object.resolveRequest) : void 0,
-			failFastOnSticky: isSet(object.failFastOnSticky) ? globalThis.Boolean(object.failFastOnSticky) : false,
-			notProcessSticky: isSet(object.notProcessSticky) ? globalThis.Boolean(object.notProcessSticky) : false,
-			materializations: globalThis.Array.isArray(object?.materializations) ? object.materializations.map((e) => ReadResult.fromJSON(e)) : []
+			materializations: globalThis.Array.isArray(object?.materializations) ? object.materializations.map((e) => MaterializationRecord.fromJSON(e)) : []
 		};
 	},
 	toJSON(message) {
 		const obj = {};
 		if (message.resolveRequest !== void 0) obj.resolveRequest = ResolveFlagsRequest.toJSON(message.resolveRequest);
-		if (message.failFastOnSticky !== false) obj.failFastOnSticky = message.failFastOnSticky;
-		if (message.notProcessSticky !== false) obj.notProcessSticky = message.notProcessSticky;
-		if (message.materializations?.length) obj.materializations = message.materializations.map((e) => ReadResult.toJSON(e));
+		if (message.materializations?.length) obj.materializations = message.materializations.map((e) => MaterializationRecord.toJSON(e));
 		return obj;
 	},
 	create(base) {
-		return ResolveWithStickyRequest.fromPartial(base ?? {});
+		return ResolveProcessRequest_StaticMaterializations.fromPartial(base ?? {});
 	},
 	fromPartial(object) {
-		const message = createBaseResolveWithStickyRequest();
+		const message = createBaseResolveProcessRequest_StaticMaterializations();
 		message.resolveRequest = object.resolveRequest !== void 0 && object.resolveRequest !== null ? ResolveFlagsRequest.fromPartial(object.resolveRequest) : void 0;
-		message.failFastOnSticky = object.failFastOnSticky ?? false;
-		message.notProcessSticky = object.notProcessSticky ?? false;
-		message.materializations = object.materializations?.map((e) => ReadResult.fromPartial(e)) || [];
+		message.materializations = object.materializations?.map((e) => MaterializationRecord.fromPartial(e)) || [];
 		return message;
 	}
 };
-function createBaseResolveWithStickyResponse() {
+function createBaseResolveProcessRequest_Resume() {
 	return {
-		success: void 0,
-		readOpsRequest: void 0
+		materializations: [],
+		state: new Uint8Array(0)
 	};
 }
-const ResolveWithStickyResponse = {
+const ResolveProcessRequest_Resume = {
 	encode(message, writer = new BinaryWriter()) {
-		if (message.success !== void 0) ResolveWithStickyResponse_Success.encode(message.success, writer.uint32(10).fork()).join();
-		if (message.readOpsRequest !== void 0) ReadOperationsRequest.encode(message.readOpsRequest, writer.uint32(26).fork()).join();
+		for (const v of message.materializations) MaterializationRecord.encode(v, writer.uint32(10).fork()).join();
+		if (message.state.length !== 0) writer.uint32(18).bytes(message.state);
 		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();
+		const message = createBaseResolveProcessRequest_Resume();
 		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());
+					message.materializations.push(MaterializationRecord.decode(reader, reader.uint32()));
 					continue;
-				case 3:
-					if (tag !== 26) break;
-					message.readOpsRequest = ReadOperationsRequest.decode(reader, reader.uint32());
+				case 2:
+					if (tag !== 18) break;
+					message.state = reader.bytes();
 					continue;
 			}
 			if ((tag & 7) === 4 || tag === 0) break;
@@ -2991,42 +3056,97 @@ const ResolveWithStickyResponse = {
 	},
 	fromJSON(object) {
 		return {
-			success: isSet(object.success) ? ResolveWithStickyResponse_Success.fromJSON(object.success) : void 0,
-			readOpsRequest: isSet(object.readOpsRequest) ? ReadOperationsRequest.fromJSON(object.readOpsRequest) : void 0
+			materializations: globalThis.Array.isArray(object?.materializations) ? object.materializations.map((e) => MaterializationRecord.fromJSON(e)) : [],
+			state: isSet(object.state) ? bytesFromBase64(object.state) : new Uint8Array(0)
 		};
 	},
 	toJSON(message) {
 		const obj = {};
-		if (message.success !== void 0) obj.success = ResolveWithStickyResponse_Success.toJSON(message.success);
-		if (message.readOpsRequest !== void 0) obj.readOpsRequest = ReadOperationsRequest.toJSON(message.readOpsRequest);
+		if (message.materializations?.length) obj.materializations = message.materializations.map((e) => MaterializationRecord.toJSON(e));
+		if (message.state.length !== 0) obj.state = base64FromBytes(message.state);
 		return obj;
 	},
 	create(base) {
-		return ResolveWithStickyResponse.fromPartial(base ?? {});
+		return ResolveProcessRequest_Resume.fromPartial(base ?? {});
 	},
 	fromPartial(object) {
-		const message = createBaseResolveWithStickyResponse();
-		message.success = object.success !== void 0 && object.success !== null ? ResolveWithStickyResponse_Success.fromPartial(object.success) : void 0;
-		message.readOpsRequest = object.readOpsRequest !== void 0 && object.readOpsRequest !== null ? ReadOperationsRequest.fromPartial(object.readOpsRequest) : void 0;
+		const message = createBaseResolveProcessRequest_Resume();
+		message.materializations = object.materializations?.map((e) => MaterializationRecord.fromPartial(e)) || [];
+		message.state = object.state ?? new Uint8Array(0);
 		return message;
 	}
 };
-function createBaseResolveWithStickyResponse_Success() {
+function createBaseResolveProcessResponse() {
+	return {
+		resolved: void 0,
+		suspended: void 0
+	};
+}
+const ResolveProcessResponse = {
+	encode(message, writer = new BinaryWriter()) {
+		if (message.resolved !== void 0) ResolveProcessResponse_Resolved.encode(message.resolved, writer.uint32(10).fork()).join();
+		if (message.suspended !== void 0) ResolveProcessResponse_Suspended.encode(message.suspended, 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 = createBaseResolveProcessResponse();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 10) break;
+					message.resolved = ResolveProcessResponse_Resolved.decode(reader, reader.uint32());
+					continue;
+				case 2:
+					if (tag !== 18) break;
+					message.suspended = ResolveProcessResponse_Suspended.decode(reader, reader.uint32());
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return {
+			resolved: isSet(object.resolved) ? ResolveProcessResponse_Resolved.fromJSON(object.resolved) : void 0,
+			suspended: isSet(object.suspended) ? ResolveProcessResponse_Suspended.fromJSON(object.suspended) : void 0
+		};
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.resolved !== void 0) obj.resolved = ResolveProcessResponse_Resolved.toJSON(message.resolved);
+		if (message.suspended !== void 0) obj.suspended = ResolveProcessResponse_Suspended.toJSON(message.suspended);
+		return obj;
+	},
+	create(base) {
+		return ResolveProcessResponse.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseResolveProcessResponse();
+		message.resolved = object.resolved !== void 0 && object.resolved !== null ? ResolveProcessResponse_Resolved.fromPartial(object.resolved) : void 0;
+		message.suspended = object.suspended !== void 0 && object.suspended !== null ? ResolveProcessResponse_Suspended.fromPartial(object.suspended) : void 0;
+		return message;
+	}
+};
+function createBaseResolveProcessResponse_Resolved() {
 	return {
 		response: void 0,
-		materializationUpdates: []
+		materializationsToWrite: []
 	};
 }
-const ResolveWithStickyResponse_Success = {
+const ResolveProcessResponse_Resolved = {
 	encode(message, writer = new BinaryWriter()) {
 		if (message.response !== void 0) ResolveFlagsResponse.encode(message.response, writer.uint32(10).fork()).join();
-		for (const v of message.materializationUpdates) VariantData.encode(v, writer.uint32(26).fork()).join();
+		for (const v of message.materializationsToWrite) MaterializationRecord.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();
+		const message = createBaseResolveProcessResponse_Resolved();
 		while (reader.pos < end) {
 			const tag = reader.uint32();
 			switch (tag >>> 3) {
@@ -3034,9 +3154,9 @@ const ResolveWithStickyResponse_Success = {
 					if (tag !== 10) break;
 					message.response = ResolveFlagsResponse.decode(reader, reader.uint32());
 					continue;
-				case 3:
-					if (tag !== 26) break;
-					message.materializationUpdates.push(VariantData.decode(reader, reader.uint32()));
+				case 2:
+					if (tag !== 18) break;
+					message.materializationsToWrite.push(MaterializationRecord.decode(reader, reader.uint32()));
 					continue;
 			}
 			if ((tag & 7) === 4 || tag === 0) break;
@@ -3047,25 +3167,172 @@ const ResolveWithStickyResponse_Success = {
 	fromJSON(object) {
 		return {
 			response: isSet(object.response) ? ResolveFlagsResponse.fromJSON(object.response) : void 0,
-			materializationUpdates: globalThis.Array.isArray(object?.materializationUpdates) ? object.materializationUpdates.map((e) => VariantData.fromJSON(e)) : []
+			materializationsToWrite: globalThis.Array.isArray(object?.materializationsToWrite) ? object.materializationsToWrite.map((e) => MaterializationRecord.fromJSON(e)) : []
 		};
 	},
 	toJSON(message) {
 		const obj = {};
 		if (message.response !== void 0) obj.response = ResolveFlagsResponse.toJSON(message.response);
-		if (message.materializationUpdates?.length) obj.materializationUpdates = message.materializationUpdates.map((e) => VariantData.toJSON(e));
+		if (message.materializationsToWrite?.length) obj.materializationsToWrite = message.materializationsToWrite.map((e) => MaterializationRecord.toJSON(e));
 		return obj;
 	},
 	create(base) {
-		return ResolveWithStickyResponse_Success.fromPartial(base ?? {});
+		return ResolveProcessResponse_Resolved.fromPartial(base ?? {});
 	},
 	fromPartial(object) {
-		const message = createBaseResolveWithStickyResponse_Success();
+		const message = createBaseResolveProcessResponse_Resolved();
 		message.response = object.response !== void 0 && object.response !== null ? ResolveFlagsResponse.fromPartial(object.response) : void 0;
-		message.materializationUpdates = object.materializationUpdates?.map((e) => VariantData.fromPartial(e)) || [];
+		message.materializationsToWrite = object.materializationsToWrite?.map((e) => MaterializationRecord.fromPartial(e)) || [];
 		return message;
 	}
 };
+function createBaseResolveProcessResponse_Suspended() {
+	return {
+		materializationsToRead: [],
+		state: new Uint8Array(0)
+	};
+}
+const ResolveProcessResponse_Suspended = {
+	encode(message, writer = new BinaryWriter()) {
+		for (const v of message.materializationsToRead) MaterializationRecord.encode(v, writer.uint32(10).fork()).join();
+		if (message.state.length !== 0) writer.uint32(18).bytes(message.state);
+		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 = createBaseResolveProcessResponse_Suspended();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 10) break;
+					message.materializationsToRead.push(MaterializationRecord.decode(reader, reader.uint32()));
+					continue;
+				case 2:
+					if (tag !== 18) break;
+					message.state = reader.bytes();
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return {
+			materializationsToRead: globalThis.Array.isArray(object?.materializationsToRead) ? object.materializationsToRead.map((e) => MaterializationRecord.fromJSON(e)) : [],
+			state: isSet(object.state) ? bytesFromBase64(object.state) : new Uint8Array(0)
+		};
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.materializationsToRead?.length) obj.materializationsToRead = message.materializationsToRead.map((e) => MaterializationRecord.toJSON(e));
+		if (message.state.length !== 0) obj.state = base64FromBytes(message.state);
+		return obj;
+	},
+	create(base) {
+		return ResolveProcessResponse_Suspended.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseResolveProcessResponse_Suspended();
+		message.materializationsToRead = object.materializationsToRead?.map((e) => MaterializationRecord.fromPartial(e)) || [];
+		message.state = object.state ?? new Uint8Array(0);
+		return message;
+	}
+};
+function createBaseMaterializationRecord() {
+	return {
+		unit: "",
+		materialization: "",
+		rule: "",
+		variant: ""
+	};
+}
+const MaterializationRecord = {
+	encode(message, writer = new BinaryWriter()) {
+		if (message.unit !== "") writer.uint32(10).string(message.unit);
+		if (message.materialization !== "") writer.uint32(18).string(message.materialization);
+		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 = createBaseMaterializationRecord();
+		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.materialization = 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(object.unit) ? globalThis.String(object.unit) : "",
+			materialization: isSet(object.materialization) ? globalThis.String(object.materialization) : "",
+			rule: isSet(object.rule) ? globalThis.String(object.rule) : "",
+			variant: isSet(object.variant) ? globalThis.String(object.variant) : ""
+		};
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.unit !== "") obj.unit = message.unit;
+		if (message.materialization !== "") obj.materialization = message.materialization;
+		if (message.rule !== "") obj.rule = message.rule;
+		if (message.variant !== "") obj.variant = message.variant;
+		return obj;
+	},
+	create(base) {
+		return MaterializationRecord.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseMaterializationRecord();
+		message.unit = object.unit ?? "";
+		message.materialization = object.materialization ?? "";
+		message.rule = object.rule ?? "";
+		message.variant = object.variant ?? "";
+		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(value) {
 	return value !== null && value !== void 0;
 }
@@ -3073,7 +3340,7 @@ const logger = getLogger("wasm-resolver");
 const EXPORT_FN_NAMES = [
 	"wasm_msg_alloc",
 	"wasm_msg_free",
-	"wasm_msg_guest_resolve_with_sticky",
+	"wasm_msg_guest_resolve_flags",
 	"wasm_msg_guest_set_resolver_state",
 	"wasm_msg_guest_bounded_flush_logs",
 	"wasm_msg_guest_bounded_flush_assign",
@@ -3088,9 +3355,9 @@ var UnsafeWasmResolver = class {
 	flushCount = 0;
 	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;
+			const epochMs = performance.timeOrigin + performance.now();
+			const seconds = Math.floor(epochMs / 1e3);
+			const nanos = Math.round((epochMs - seconds * 1e3) * 1e6);
 			return this.transferRequest({
 				seconds,
 				nanos
@@ -3099,10 +3366,10 @@ var UnsafeWasmResolver = class {
 		verifyExports(exports);
 		this.exports = exports;
 	}
-	resolveWithSticky(request) {
-		const reqPtr = this.transferRequest(request, ResolveWithStickyRequest);
-		const resPtr = this.exports.wasm_msg_guest_resolve_with_sticky(reqPtr);
-		return this.consumeResponse(resPtr, ResolveWithStickyResponse);
+	resolveProcess(request) {
+		const reqPtr = this.transferRequest(request, ResolveProcessRequest);
+		const resPtr = this.exports.wasm_msg_guest_resolve_flags(reqPtr);
+		return this.consumeResponse(resPtr, ResolveProcessResponse);
 	}
 	setResolverState(request) {
 		const reqPtr = this.transferRequest(request, SetResolverStateRequest);
@@ -3175,9 +3442,9 @@ var WasmResolver = class {
 		this.delegate = this.delegateFactory(this.module);
 		if (this.currentState) this.delegate.setResolverState(this.currentState);
 	}
-	resolveWithSticky(request) {
+	resolveProcess(request) {
 		try {
-			return this.delegate.resolveWithSticky(request);
+			return this.delegate.resolveProcess(request);
 		} catch (error$1) {
 			if (error$1 instanceof WebAssembly.RuntimeError) this.reloadInstance(error$1);
 			throw error$1;