@configdirector/nuxt-sdk 1.11.0 → 1.12.0

package/dist/runtime/plugin.server.mjs

@@ -58,6 +58,37 @@ const admitContext = (context) => {
 	};
 };
 //#endregion
+//#region ../shared/src/deepEqual.ts
+const deepEqual = (left, right) => {
+	if (Object.is(left, right)) return true;
+	if (typeof left !== "object" || typeof right !== "object" || left === null || right === null) return false;
+	if (Object.getPrototypeOf(left) !== Object.getPrototypeOf(right)) return false;
+	if (left instanceof Date && right instanceof Date) return left.getTime() === right.getTime();
+	if (Array.isArray(left) && Array.isArray(right)) return left.length === right.length && left.every((item, index) => deepEqual(item, right[index]));
+	if (!isPlainObject(left) || !isPlainObject(right)) return false;
+	const leftKeys = Object.keys(left);
+	const rightKeys = Object.keys(right);
+	return leftKeys.length === rightKeys.length && leftKeys.every((key) => Object.prototype.hasOwnProperty.call(right, key) && deepEqual(left[key], right[key]));
+};
+const isPlainObject = (value) => {
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+};
+//#endregion
+//#region ../js-client-core/src/mountAction.ts
+const decideMountAction = (client, context) => {
+	if (client.isInitializing) return "none";
+	if (!client.isReady) return "initialize";
+	if (context !== void 0 && !deepEqual(context, client.context)) return "updateContext";
+	return "none";
+};
+//#endregion
+//#region src/runtime/client-startup.ts
+const decideContextUpdateAction = (client, context, waitsForFirstContext) => {
+	if (waitsForFirstContext && decideMountAction(client, context) === "initialize") return "startClient";
+	return "updateContext";
+};
+//#endregion
 //#region src/runtime/app/composables/useConfigDirectorContext.ts
 const DEFAULT_TIMEOUT = 3e3;
 const getEffectiveTimeout = (option) => {
@@ -66,6 +97,14 @@ const getEffectiveTimeout = (option) => {
 const useConfigDirectorContext = () => {
 	const state = useState("configdirector-context");
 	const { client } = useConfigDirectorClient();
+	const { $configDirectorClientStartup } = useNuxtApp();
+	const startup = $configDirectorClientStartup;
+	const handContextToClient = (rawContext) => {
+		switch (decideContextUpdateAction(client, rawContext, startup.waitsForFirstContext)) {
+			case "startClient": return startup.start(rawContext);
+			case "updateContext": return client.updateContext(rawContext);
+		}
+	};
 	const updateContext = async (context, options) => {
 		const rawContext = toRaw(context);
 		const oldContext = JSON.stringify(state.value);
@@ -75,7 +114,7 @@ const useConfigDirectorContext = () => {
 			const timeout = getEffectiveTimeout(options?.timeoutMilliseconds);
 			let timer;
 			try {
-				await Promise.race([client.updateContext(rawContext), new Promise((resolve) => {
+				await Promise.race([handContextToClient(rawContext), new Promise((resolve) => {
 					timer = setTimeout(() => resolve(), timeout);
 				})]);
 			} finally {
@@ -98,6 +137,10 @@ var plugin_server_default = defineNuxtPlugin((nuxtApp) => {
 	if (!serverSdkClient) throw "The nitro ConfigDirector plugin was not initialized";
 	const client = createSsrClient(serverSdkClient);
 	const readyStatus = shallowRef(serverSdkClient.isReady ? "ready" : "default");
+	const startup = {
+		waitsForFirstContext: false,
+		start: (context) => client.initialize(context)
+	};
 	nuxtApp.hooks.hook("app:created", async () => {
 		logger.debug("Updating ConfigDirector context for SSR evaluation");
 		const { context } = useConfigDirectorContext();
@@ -105,7 +148,8 @@ var plugin_server_default = defineNuxtPlugin((nuxtApp) => {
 	});
 	return { provide: {
 		configDirectorClient: client,
-		configDirectorClientReadyStatus: readonly(readyStatus)
+		configDirectorClientReadyStatus: readonly(readyStatus),
+		configDirectorClientStartup: startup
 	} };
 });
 var SsrClient = class {

package/dist/runtime/server/composables/useConfigDirectorServerClient.d.mts

@@ -1,4 +1,4 @@
-import { n as ConfigDirectorClient } from "../../types-CS7AMNWe.mjs";
+import { n as ConfigDirectorClient } from "../../types-BoDJiQsr.mjs";
 
 //#region src/runtime/server/composables/useConfigDirectorServerClient.d.ts
 declare const useConfigDirectorServerClient: () => ConfigDirectorClient;

package/dist/runtime/server/composables/useConfigDirectorServerClient.d.ts

@@ -1,4 +1,4 @@
-import { n as ConfigDirectorClient } from "../../types-CS7AMNWe.mjs";
+import { n as ConfigDirectorClient } from "../../types-BoDJiQsr.mjs";
 
 //#region src/runtime/server/composables/useConfigDirectorServerClient.d.ts
 declare const useConfigDirectorServerClient: () => ConfigDirectorClient;

package/dist/runtime/server/composables/useConfigDirectorServerClient.mjs

@@ -2,7 +2,7 @@ import { useNitroApp } from "nitropack/runtime";
 //#region src/runtime/server/composables/useConfigDirectorServerClient.ts
 const useConfigDirectorServerClient = () => {
 	const serverSdkClient = useNitroApp().configDirectorClient;
-	if (!serverSdkClient) throw "The nitro ConfigDirector plugin was not initialized";
+	if (!serverSdkClient) throw new Error("The ConfigDirector Nitro plugin was not initialized");
 	return serverSdkClient;
 };
 //#endregion

package/dist/runtime/server/composables/useConfigDirectorServerHooks.d.mts

@@ -1,4 +1,4 @@
-import { t as ClientHooks } from "../../types-CS7AMNWe.mjs";
+import { t as ClientHooks } from "../../types-BoDJiQsr.mjs";
 
 //#region src/runtime/server/composables/useConfigDirectorServerHooks.d.ts
 declare const useConfigDirectorServerHooks: (hooks: ClientHooks) => void;

package/dist/runtime/server/composables/useConfigDirectorServerHooks.d.ts

@@ -1,4 +1,4 @@
-import { t as ClientHooks } from "../../types-CS7AMNWe.mjs";
+import { t as ClientHooks } from "../../types-BoDJiQsr.mjs";
 
 //#region src/runtime/server/composables/useConfigDirectorServerHooks.d.ts
 declare const useConfigDirectorServerHooks: (hooks: ClientHooks) => void;

package/dist/runtime/server/composables/useConfigDirectorServerHooks.mjs

@@ -1,8 +1,7 @@
-import { useNitroApp } from "nitropack/runtime";
+import { useConfigDirectorServerClient } from "./useConfigDirectorServerClient.mjs";
 //#region src/runtime/server/composables/useConfigDirectorServerHooks.ts
 const useConfigDirectorServerHooks = (hooks) => {
-	const client = useNitroApp().configDirectorClient;
-	if (!client) throw new Error("The ConfigDirector Nitro plugin was not initialized");
+	const client = useConfigDirectorServerClient();
 	const entries = Object.entries(hooks);
 	for (const [event, handler] of entries) {
 		if (!handler) continue;

package/dist/runtime/{types-CS7AMNWe.d.mts → types-BoDJiQsr.d.mts}

@@ -1,4 +1,4 @@
-import { a as ConfigValueType, i as ConfigState, n as ConfigDirectorContext, r as ConfigEvaluation } from "./native-values-BV2k_xR2.mjs";
+import { a as ConfigValueType, i as ConfigState, n as ConfigDirectorContext, r as ConfigEvaluation } from "./native-values-ChQdi7c7.mjs";
 
 //#region ../js-server-sdk/src/types.d.ts
 type ClientEvents = {

package/dist/runtime/{types-Dt3bENKf.d.mts → types-CuzrFq9I.d.mts}

@@ -1,4 +1,4 @@
-import { a as ConfigValueType, n as ConfigDirectorContext, r as ConfigEvaluation } from "./native-values-BV2k_xR2.mjs";
+import { a as ConfigValueType, n as ConfigDirectorContext, r as ConfigEvaluation } from "./native-values-ChQdi7c7.mjs";
 
 //#region ../js-client-core/src/Emitter.d.ts
 type EventType = string | symbol;
@@ -17,6 +17,7 @@ type ClientHooks = {
   contextUpdated?: HookHandler<"contextUpdated"> | HookHandler<"contextUpdated">[];
   configEvaluated?: HookHandler<"configEvaluated"> | HookHandler<"configEvaluated">[];
   connectionError?: HookHandler<"connectionError"> | HookHandler<"connectionError">[];
+  cachedValuesLoaded?: HookHandler<"cachedValuesLoaded"> | HookHandler<"cachedValuesLoaded">[];
 };
 type ClientConnectAction = "initialization" | "context update" | "network resume";
 type HookHandler<TEvent extends keyof ClientEvents> = (payload: ClientEvents[TEvent]) => void;
@@ -37,6 +38,7 @@ type ClientEvents = {
   connectionError: {
     error: Error;
   };
+  cachedValuesLoaded: Record<string, never>;
 };
 type WatchHandler<T extends ConfigValueType> = (message: T) => void;
 /**

package/dist/testing.d.mts

@@ -19,7 +19,7 @@ interface ConfigDirectorLogger {
   warn(message: string, ...args: any): void;
   error(message: string, ...args: any): void;
 }
-type EvaluationReason = "found-match" | "config-state-missing" | "client-not-ready" | "type-mismatch" | "value-missing" | "invalid-number" | "invalid-json" | "invalid-boolean";
+type EvaluationReason = "found-match" | "config-state-missing" | "client-not-ready" | "type-mismatch" | "value-missing" | "invalid-number" | "invalid-json" | "invalid-boolean" | "cached";
 type ConfigEvaluation = {
   key: string;
   value: ConfigValueType;
@@ -38,9 +38,11 @@ type ConfigDirectorContext = {
    * The context's identifier. This should be a value that uniquely identifies the user or other
    * entity among contexts of the same {@link kind}.
    * In the case of anonymous users, you could generate a UUID or alternatively not provide
-   * the {@link id} and the SDK will generate a random UUID. However, keep in mind that this
-   * value is used for segmenting contexts in percentage rollouts, and changes to the {@link id}
-   * could result in the context being assigned to a different percentile.
+   * the {@link id}. In a client SDK, ConfigDirector then derives an identifier from an ID the SDK
+   * stores for the app install or the website, so it stays the same until the app is uninstalled
+   * or the site's data is cleared. However, keep in mind that this value is used for segmenting
+   * contexts in percentage rollouts, and changes to the {@link id} could result in the context
+   * being assigned to a different percentile.
    */
   id?: string;
   /**
@@ -105,6 +107,7 @@ type ClientEvents = {
   connectionError: {
     error: Error;
   };
+  cachedValuesLoaded: Record<string, never>;
 };
 type WatchHandler<T extends ConfigValueType> = (message: T) => void;
 /**

package/dist/testing.mjs

@@ -920,10 +920,27 @@ const generateInstanceId = () => {
 	});
 };
 //#endregion
+//#region ../js-client-core/src/browser-globals.ts
+const read = (readValue) => {
+	try {
+		return readValue(globalThis);
+	} catch {
+		return;
+	}
+};
+const readUserAgent = () => read((globals) => globals.navigator?.userAgent);
+const readHost = () => read((globals) => globals.location?.host);
+const localStorageIfAvailable = () => {
+	try {
+		return globalThis.localStorage ?? void 0;
+	} catch {
+		return;
+	}
+};
+//#endregion
 //#region ../js-client-core/src/client-session.ts
 const STORAGE_KEY = "configdirector-sdk:instance-id";
 const RECORD_VERSION = 1;
-const MAX_AGE_MS = 360 * 60 * 1e3;
 const STORAGE_DEADLINE_MS = 1e3;
 const CHECKSUM_SALT = "configdirector.instanceId.v1";
 const UUID_V4_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
@@ -940,13 +957,6 @@ const checksumFor = (id, createdAt) => {
 	const low = fnv1a(payload, 2166136261);
 	return fnv1a(`${low}|${payload}`, 16777619).toString(16).padStart(8, "0") + low.toString(16).padStart(8, "0");
 };
-const localStorageIfAvailable = () => {
-	try {
-		return globalThis.localStorage ?? void 0;
-	} catch {
-		return;
-	}
-};
 const isUsableRecord = (record) => {
 	if (!record || typeof record !== "object") return false;
 	const { v, id, createdAt, checksum } = record;
@@ -975,11 +985,6 @@ const readStoredInstanceId = async (storage, logger) => {
 		logger.debug("[ConfigDirectorClient] The stored instance id failed validation, generating a new one");
 		return { outcome: "nothing usable" };
 	}
-	const age = Date.now() - record.createdAt;
-	if (age < 0 || age >= MAX_AGE_MS) {
-		logger.debug("[ConfigDirectorClient] The stored instance id has expired, generating a new one");
-		return { outcome: "nothing usable" };
-	}
 	return {
 		outcome: "stored",
 		instanceId: record.id
@@ -1195,17 +1200,6 @@ var PollingTransport = class extends AbstractPollingTransport {
 	}
 };
 //#endregion
-//#region ../js-client-core/src/browser-globals.ts
-const read = (readValue) => {
-	try {
-		return readValue(globalThis);
-	} catch {
-		return;
-	}
-};
-const readUserAgent = () => read((globals) => globals.navigator?.userAgent);
-const readHost = () => read((globals) => globals.location?.host);
-//#endregion
 //#region ../shared/src/context-kind.ts
 const CONTEXT_KIND_MAXIMUM_LENGTH = 64;
 const KIND_SAMPLE_MAXIMUM_CHARACTERS = 128;
@@ -1246,6 +1240,176 @@ const admitContext = (context) => {
 	};
 };
 //#endregion
+//#region ../shared/src/utf8-byte-length.ts
+const isHighSurrogate = (codeUnit) => codeUnit >= 55296 && codeUnit <= 56319;
+const isLowSurrogate = (codeUnit) => codeUnit >= 56320 && codeUnit <= 57343;
+const utf8ByteLength = (text) => {
+	let bytes = 0;
+	for (let i = 0; i < text.length; i++) {
+		const codeUnit = text.charCodeAt(i);
+		if (codeUnit <= 127) bytes += 1;
+		else if (codeUnit <= 2047) bytes += 2;
+		else if (isHighSurrogate(codeUnit) && i + 1 < text.length && isLowSurrogate(text.charCodeAt(i + 1))) {
+			bytes += 4;
+			i++;
+		} else bytes += 3;
+	}
+	return bytes;
+};
+//#endregion
+//#region ../js-client-core/src/cached-values.ts
+const ENTRY_FORMAT_VERSION = 1;
+const DEFAULT_CONTEXT_KIND = "user";
+const planCaching = (connectionPlan, caching, platformProvider) => {
+	if (connectionPlan.kind === "stay-offline") return {
+		kind: "no cache",
+		reason: "offline mode"
+	};
+	if (caching?.enabled === false) return {
+		kind: "no cache",
+		reason: "turned off"
+	};
+	const provider = caching?.provider ?? platformProvider?.(connectionPlan.clientSdkKey);
+	if (!provider) return {
+		kind: "no cache",
+		reason: "no provider available"
+	};
+	return {
+		kind: "cache",
+		provider,
+		clientSdkKey: connectionPlan.clientSdkKey
+	};
+};
+const contextTagFor = (context, instanceId) => {
+	const contextKind = context?.kind ?? DEFAULT_CONTEXT_KIND;
+	if (context?.id != null) return {
+		contextKind,
+		contextId: context.id
+	};
+	return {
+		contextKind,
+		anonymousInstanceId: instanceId
+	};
+};
+const sameContextTag = (stored, launch) => {
+	if (stored.contextKind !== launch.contextKind) return false;
+	if ("contextId" in stored && "contextId" in launch) return stored.contextId === launch.contextId;
+	if ("anonymousInstanceId" in stored && "anonymousInstanceId" in launch) return stored.anonymousInstanceId === launch.anonymousInstanceId;
+	return false;
+};
+const decideCachedValuesAdoption = (cachedValues, launchContextTag, hasReceivedLiveValues) => {
+	if (hasReceivedLiveValues) return "live values already arrived";
+	if (!sameContextTag(cachedValues.contextTag, launchContextTag)) return "context mismatch";
+	return "adopt";
+};
+const isContextTag = (candidate) => {
+	if (!candidate || typeof candidate !== "object") return false;
+	const { contextKind, contextId, anonymousInstanceId } = candidate;
+	if (typeof contextKind !== "string") return false;
+	return typeof contextId === "string" || typeof anonymousInstanceId === "string";
+};
+const isConfigStateMap = (candidate) => {
+	if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) return false;
+	return Object.values(candidate).every((config) => config && typeof config === "object" && typeof config.id === "string" && typeof config.key === "string");
+};
+const isEntryFor = (clientSdkKey, candidate) => {
+	if (!candidate || typeof candidate !== "object") return false;
+	const entry = candidate;
+	return entry.formatVersion === ENTRY_FORMAT_VERSION && entry.clientSdkKey === clientSdkKey && isContextTag(entry.contextTag) && typeof entry.environmentId === "string" && typeof entry.projectId === "string" && isConfigStateMap(entry.configs) && typeof entry.receivedAt === "number";
+};
+var CachedValuesStore = class {
+	warned = /* @__PURE__ */ new Set();
+	pendingRead;
+	queuedCachedValues;
+	writing = false;
+	constructor(provider, clientSdkKey, logger) {
+		this.provider = provider;
+		this.clientSdkKey = clientSdkKey;
+		this.logger = logger;
+	}
+	read() {
+		this.pendingRead ??= this.readEntry();
+		return this.pendingRead;
+	}
+	replace(cachedValues) {
+		this.queuedCachedValues = cachedValues;
+		this.writeQueued();
+	}
+	async readEntry() {
+		let raw;
+		try {
+			raw = await this.provider.read();
+		} catch (error) {
+			this.warnOnce("read failed", "Could not read the values kept on the device, starting without them:", error);
+			return { outcome: "failed" };
+		}
+		if (raw == null || raw === "") return { outcome: "nothing stored" };
+		const entry = this.parseEntry(raw);
+		if (!entry) {
+			this.warnOnce("unreadable", "The values kept on the device could not be read and were removed, starting without them");
+			await this.removeEntry();
+			return { outcome: "unreadable" };
+		}
+		return {
+			outcome: "stored",
+			cachedValues: entry
+		};
+	}
+	parseEntry(raw) {
+		try {
+			const candidate = JSON.parse(raw);
+			return isEntryFor(this.clientSdkKey, candidate) ? candidate : void 0;
+		} catch {
+			return;
+		}
+	}
+	async writeQueued() {
+		if (this.writing) return;
+		this.writing = true;
+		try {
+			while (this.queuedCachedValues) {
+				const cachedValues = this.queuedCachedValues;
+				this.queuedCachedValues = void 0;
+				await this.writeEntry(cachedValues);
+			}
+		} finally {
+			this.writing = false;
+		}
+	}
+	async writeEntry(cachedValues) {
+		const entry = {
+			formatVersion: ENTRY_FORMAT_VERSION,
+			clientSdkKey: this.clientSdkKey,
+			...cachedValues
+		};
+		const serialized = JSON.stringify(entry);
+		const size = utf8ByteLength(serialized);
+		const limit = this.provider.sizeLimit();
+		if (size > limit) {
+			this.warnOnce("over the size limit", `The values received (${size} bytes) exceed the caching provider's limit of ${limit} bytes, so no values are kept on the device`);
+			await this.removeEntry();
+			return;
+		}
+		try {
+			await this.provider.write(serialized);
+		} catch (error) {
+			this.warnOnce("write failed", "Could not keep the values on the device:", error);
+		}
+	}
+	async removeEntry() {
+		try {
+			await this.provider.remove();
+		} catch (error) {
+			this.warnOnce("remove failed", "Could not remove the values kept on the device:", error);
+		}
+	}
+	warnOnce(warning, message, ...details) {
+		if (this.warned.has(warning)) return;
+		this.warned.add(warning);
+		this.logger.warn(`[ConfigDirectorClient] ${message}`, ...details);
+	}
+};
+//#endregion
 //#region ../js-client-core/src/DefaultConfigDirectorClient.ts
 const MAX_EXPONENTIAL_DELAY = 9;
 var DefaultConfigDirectorClient = class DefaultConfigDirectorClient {
@@ -1263,11 +1427,15 @@ var DefaultConfigDirectorClient = class DefaultConfigDirectorClient {
 	readyPromise;
 	readyResolve;
 	currentContext;
+	submittedContext;
 	connectionPlan;
 	clientSession;
-	static from(liveTelemetryClient, clientSdkKeyOrOptions, sdkOptions, clientOptions) {
-		if (typeof clientSdkKeyOrOptions === "object") return new DefaultConfigDirectorClient(liveTelemetryClient, void 0, sdkOptions, clientSdkKeyOrOptions);
-		return new DefaultConfigDirectorClient(liveTelemetryClient, clientSdkKeyOrOptions, sdkOptions, clientOptions);
+	cachedValuesStore;
+	servingCachedValues = false;
+	cachedValuesAdoptionStarted = false;
+	static from(liveTelemetryClient, clientSdkKeyOrOptions, sdkOptions, clientOptions, internalClientOptions) {
+		if (typeof clientSdkKeyOrOptions === "object") return new DefaultConfigDirectorClient(liveTelemetryClient, void 0, sdkOptions, clientSdkKeyOrOptions, internalClientOptions);
+		return new DefaultConfigDirectorClient(liveTelemetryClient, clientSdkKeyOrOptions, sdkOptions, clientOptions, internalClientOptions);
 	}
 	constructor(liveTelemetryClient, clientSdkKey, sdkOptions, clientOptions, internalClientOptions) {
 		this.logger = clientOptions?.logger ?? createDefaultLogger();
@@ -1275,10 +1443,12 @@ var DefaultConfigDirectorClient = class DefaultConfigDirectorClient {
 		this.timeout = clientOptions?.connection?.timeout ?? 3e3;
 		const urlFactory = internalClientOptions?.urlFactory ?? defaultUrlFactory;
 		this.connectionPlan = planConnection(clientSdkKey, clientOptions?.connection, urlFactory);
+		this.cachedValuesStore = this.buildCachedValuesStore(planCaching(this.connectionPlan, clientOptions?.caching, internalClientOptions?.platformCachingProvider));
 		this.telemetryClient = this.buildTelemetryClient(liveTelemetryClient, clientOptions);
 		this.transport = internalClientOptions?.transport ?? this.buildTransport(sdkOptions, clientOptions, urlFactory, internalClientOptions);
 		this.transport.on("configSetReceived", (configSet) => {
 			this.hasReceivedConfigSet = true;
+			this.servingCachedValues = false;
 			this.readyResolve?.();
 			const removedKeys = this.findKeysRemovedBy(configSet);
 			if (!this.configSet || configSet.kind == "full") this.configSet = configSet;
@@ -1286,6 +1456,7 @@ var DefaultConfigDirectorClient = class DefaultConfigDirectorClient {
 				...this.configSet.configs,
 				...configSet.configs
 			};
+			this.keepValuesOnTheDevice(this.configSet);
 			const keys = Object.keys(configSet.configs);
 			this.emit("configsUpdated", {
 				keys,
@@ -1307,6 +1478,80 @@ var DefaultConfigDirectorClient = class DefaultConfigDirectorClient {
 		this.registerHandler("configsUpdated", clientOptions?.hooks?.configsUpdated);
 		this.registerHandler("contextUpdated", clientOptions?.hooks?.contextUpdated);
 		this.registerHandler("connectionError", clientOptions?.hooks?.connectionError);
+		this.registerHandler("cachedValuesLoaded", clientOptions?.hooks?.cachedValuesLoaded);
+	}
+	buildCachedValuesStore(cachingPlan) {
+		switch (cachingPlan.kind) {
+			case "no cache":
+				this.logger.debug(`[ConfigDirectorClient] No values are kept on the device: ${cachingPlan.reason}`);
+				return;
+			case "cache": {
+				const store = new CachedValuesStore(cachingPlan.provider, cachingPlan.clientSdkKey, this.logger);
+				store.read();
+				return store;
+			}
+		}
+	}
+	startCachedValuesAdoption() {
+		const store = this.cachedValuesStore;
+		if (!store || this.cachedValuesAdoptionStarted) return;
+		this.cachedValuesAdoptionStarted = true;
+		this.adoptCachedValues(store);
+	}
+	async adoptCachedValues(store) {
+		const read = await store.read();
+		switch (read.outcome) {
+			case "nothing stored":
+			case "unreadable":
+			case "failed": return;
+			case "stored": break;
+		}
+		const { instanceId } = await this.clientSession;
+		const launchContextTag = contextTagFor(this.submittedContext, instanceId);
+		const adoption = decideCachedValuesAdoption(read.cachedValues, launchContextTag, this.hasReceivedConfigSet);
+		switch (adoption) {
+			case "adopt":
+				this.serveCachedValues(read.cachedValues);
+				return;
+			case "live values already arrived":
+			case "context mismatch":
+				this.logger.debug(`[ConfigDirectorClient] The values kept on the device were not adopted: ${adoption}`);
+				return;
+		}
+	}
+	serveCachedValues(cachedValues) {
+		const { environmentId, projectId, configs } = cachedValues;
+		this.configSet = {
+			environmentId,
+			projectId,
+			configs,
+			kind: "full"
+		};
+		this.servingCachedValues = true;
+		const keys = Object.keys(configs);
+		this.emit("cachedValuesLoaded", {});
+		this.emit("configsUpdated", {
+			keys,
+			removedKeys: []
+		});
+		this.updateWatchers(keys);
+		this.logger.debug("[ConfigDirectorClient] Serving the values kept on the device until live values arrive:", { keys });
+	}
+	keepValuesOnTheDevice(configSet) {
+		const store = this.cachedValuesStore;
+		if (!store) return;
+		const context = this.submittedContext;
+		const receivedAt = Date.now();
+		this.clientSession.then(({ instanceId }) => store.replace({
+			contextTag: contextTagFor(context, instanceId),
+			environmentId: configSet.environmentId,
+			projectId: configSet.projectId,
+			configs: configSet.configs,
+			receivedAt
+		}));
+	}
+	servedReason(reason) {
+		return this.servingCachedValues && reason === "found-match" ? "cached" : reason;
 	}
 	registerHandler(event, handler) {
 		if (!handler) return;
@@ -1400,6 +1645,8 @@ var DefaultConfigDirectorClient = class DefaultConfigDirectorClient {
 		return this.currentContext;
 	}
 	async connectToTransport(context, caller) {
+		this.submittedContext = context;
+		if (caller === "initialization") this.startCachedValuesAdoption();
 		try {
 			this.ready = false;
 			this.readyPromise = new Promise((resolve) => {
@@ -1500,6 +1747,7 @@ var DefaultConfigDirectorClient = class DefaultConfigDirectorClient {
 			return defaultValue;
 		}
 		const parseResult = parseConfigValue(configState, defaultValue);
+		const reason = this.servedReason(parseResult.reason);
 		this.telemetryClient.evaluatedConfig({
 			contextId: this.currentContext?.id,
 			type: configState.type,
@@ -1509,14 +1757,14 @@ var DefaultConfigDirectorClient = class DefaultConfigDirectorClient {
 			evaluatedValue: parseResult.parsedValue,
 			evaluatedValueId: parseResult.parsedValueId,
 			usedDefault: parseResult.usedDefault,
-			evaluationReason: parseResult.reason
+			evaluationReason: reason
 		});
 		this.dispatchEvaluationEvent({
 			key: configKey,
 			value: parseResult.parsedValue,
 			valueId: parseResult.parsedValueId ?? void 0,
 			isDefaultValue: parseResult.usedDefault,
-			reason: parseResult.reason,
+			reason,
 			context: this.context
 		});
 		this.logger.debug(`[ConfigDirectorClient] Evaluated '${configKey}' to '${parseResult.parsedValue}'`);
@@ -1882,7 +2130,7 @@ const installTestClient = (testClient) => {
 const createTestClient = (options) => {
 	return createTestClient$1({
 		sdkName: "nuxt-sdk",
-		sdkVersion: "1.11.0"
+		sdkVersion: "1.12.0"
 	}, options);
 };
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@configdirector/nuxt-sdk",
-  "version": "1.11.0",
+  "version": "1.12.0",
   "description": "Nuxt SDK for ConfigDirector. ConfigDirector is a remote configuration and feature flag service.",
   "license": "MIT",
   "author": "ConfigDirector",