@configdirector/nuxt-sdk 1.9.2 → 1.11.0

package/dist/runtime/nitro/plugin.mjs

@@ -1,34 +1,13 @@
+import { t as admitContext } from "../context-kind-D6YBNij2.mjs";
+import { a as ConfigDirectorValidationError, i as ConfigDirectorInitializationError, n as encodeNativeValue, r as ConfigDirectorConnectionError } from "../native-values-DZJjFBvk.mjs";
 import EventEmitter, { EventEmitter as EventEmitter$1 } from "node:events";
 import { createHash, randomUUID } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
 import * as semver from "semver";
 import { rapidhash } from "rapidhash-js";
 import { defineNitroPlugin, useRuntimeConfig } from "nitropack/runtime";
 import { consola } from "consola";
-//#region ../shared/src/errors.ts
-var ConfigDirectorConnectionError = class ConfigDirectorConnectionError extends Error {
-	name = "ConfigDirectorConnectionError";
-	status;
-	constructor(message, status) {
-		super(message);
-		this.status = status;
-		Object.setPrototypeOf(this, ConfigDirectorConnectionError.prototype);
-	}
-};
-var ConfigDirectorValidationError = class ConfigDirectorValidationError extends Error {
-	name = "ConfigDirectorValidationError";
-	constructor(message) {
-		super(message);
-		Object.setPrototypeOf(this, ConfigDirectorValidationError.prototype);
-	}
-};
-var ConfigDirectorInitializationError = class ConfigDirectorInitializationError extends Error {
-	name = "ConfigDirectorInitializationError";
-	constructor(message) {
-		super(message);
-		Object.setPrototypeOf(this, ConfigDirectorInitializationError.prototype);
-	}
-};
-//#endregion
 //#region ../eventsource/src/errors.ts
 var StreamClosedError = class StreamClosedError extends Error {
 	name = "StreamClosedError";
@@ -635,6 +614,150 @@ var PollingTransport = class extends AbstractPollingTransport {
 	}
 };
 //#endregion
+//#region ../js-server-sdk/src/native-values.ts
+const unconditionalConfig = (id, key, value) => {
+	const encoded = encodeNativeValue(key, value);
+	return {
+		id,
+		key,
+		type: encoded.type,
+		variations: [{
+			name: null,
+			value: encoded.value
+		}],
+		target: {
+			defaultValue: encoded.value,
+			rules: []
+		}
+	};
+};
+//#endregion
+//#region ../js-server-sdk/src/OfflineTransport.ts
+const OFFLINE_ENVIRONMENT = {
+	environmentId: "offline",
+	projectId: "offline"
+};
+var OfflineTransport = class {
+	emitter = new EventEmitter();
+	connected = false;
+	constructor(source) {
+		this.source = source;
+	}
+	async connect() {
+		const configs = await loadOfflineConfigs(this.source);
+		this.connected = true;
+		this.emitter.emit("configBundleReceived", {
+			...OFFLINE_ENVIRONMENT,
+			kind: "full",
+			configs
+		});
+		return this;
+	}
+	get isConnected() {
+		return this.connected;
+	}
+	on(name, handler) {
+		this.emitter.on(name, handler);
+	}
+	off(name, handler) {
+		if (handler) this.emitter.off(name, handler);
+		else this.emitter.removeAllListeners(name);
+	}
+	close() {
+		this.connected = false;
+	}
+	dispose() {
+		this.close();
+		this.emitter.removeAllListeners();
+	}
+};
+const loadOfflineConfigs = async (source) => {
+	switch (source.kind) {
+		case "in-code-defaults": return {};
+		case "values": return encodeOfflineValues(source.values, "The offline values");
+		case "file": return encodeOfflineValues(await readOfflineValuesFile(source.path), `The offline values file '${source.path}'`);
+		case "rejected": throw new ConfigDirectorInitializationError(source.message);
+	}
+};
+const readOfflineValuesFile = async (path) => {
+	let text;
+	try {
+		text = await readFile(resolve(path), "utf8");
+	} catch (error) {
+		throw new ConfigDirectorInitializationError(`The offline values file '${path}' could not be read: ${messageOf(error)}`);
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch (error) {
+		throw new ConfigDirectorInitializationError(`The offline values file '${path}' is not valid JSON: ${messageOf(error)}`);
+	}
+	if (!isJsonObject(parsed)) throw new ConfigDirectorInitializationError(`The offline values file '${path}' must hold a JSON object with one value per config key, but holds ${describeJson(parsed)}.`);
+	return parsed;
+};
+const encodeOfflineValues = (values, subject) => {
+	try {
+		return Object.fromEntries(Object.entries(values).map(([key, value]) => [key, unconditionalConfig(`offline:${key}`, key, value)]));
+	} catch (error) {
+		if (error instanceof ConfigDirectorValidationError) throw new ConfigDirectorInitializationError(`${subject} could not be loaded. ${error.message}`);
+		throw error;
+	}
+};
+const isJsonObject = (parsed) => typeof parsed === "object" && parsed !== null && !Array.isArray(parsed);
+const describeJson = (parsed) => {
+	if (parsed === null) return "null";
+	if (Array.isArray(parsed)) return "an array";
+	return `a ${typeof parsed}`;
+};
+const messageOf = (error) => error instanceof Error ? error.message : String(error);
+//#endregion
+//#region ../js-server-sdk/src/connection-plan.ts
+const defaultBaseUrl = new URL("https://server-sdk-api.configdirector.com");
+const planConnection = (serverSdkKey, connection) => {
+	if (connection?.mode === "offline") return {
+		kind: "stay-offline",
+		source: offlineSourceOf(connection)
+	};
+	const mode = connection?.mode ?? "streaming";
+	if (!serverSdkKey || serverSdkKey.trim().length == 0) throw new ConfigDirectorValidationError("No server SDK key was provided, the client cannot be instantiated without a valid server SDK key");
+	if (connection?.file !== void 0 || connection?.values !== void 0) return {
+		kind: "stay-offline",
+		source: {
+			kind: "rejected",
+			message: `The connection options 'file' and 'values' apply only when the connection mode is 'offline', but the mode is '${mode}'.`
+		}
+	};
+	return {
+		kind: "connect",
+		mode,
+		serverSdkKey,
+		baseUrl: baseUrlOf(connection?.url)
+	};
+};
+const baseUrlOf = (url) => {
+	if (!url) return defaultBaseUrl;
+	try {
+		return new URL(url);
+	} catch (error) {
+		throw new ConfigDirectorValidationError(`Invalid base URL '${url}'. Parsing failed: ${error}`);
+	}
+};
+const offlineSourceOf = (connection) => {
+	if (connection.file !== void 0 && connection.values !== void 0) return {
+		kind: "rejected",
+		message: "An offline connection takes either 'file' or 'values', not both."
+	};
+	if (connection.file !== void 0) return {
+		kind: "file",
+		path: connection.file
+	};
+	if (connection.values !== void 0) return {
+		kind: "values",
+		values: connection.values
+	};
+	return { kind: "in-code-defaults" };
+};
+//#endregion
 //#region ../config-evaluator/src/json-pointer.ts
 const ARRAY_INDEX_PATTERN = /^(?:0|[1-9][0-9]*)$/;
 const INVALID_ESCAPE_PATTERN = /~(?![01])/;
@@ -7017,6 +7140,7 @@ const compareArray = (givenValue, operator, targetValues) => {
 		default: return false;
 	}
 };
+const effectiveContextKind = (context) => context?.context?.kind ?? "user";
 //#endregion
 //#region ../config-evaluator/src/ConditionEvaluator.ts
 var ConditionEvaluator = class {
@@ -7065,6 +7189,7 @@ var ConditionEvaluator = class {
 		switch (condition.attribute) {
 			case "identifier": return orAbsent(context?.context?.id);
 			case "name": return orAbsent(context?.context?.name);
+			case "kind": return effectiveContextKind(context);
 			case "appName": return orAbsent(context?.metadata?.appName);
 			case "appVersion": return orAbsent(context?.metadata?.appVersion);
 			case "traits":
@@ -7112,9 +7237,9 @@ const holdsAttributeConditionsOnly = (segment) => (segment.groups ?? []).every((
 //#endregion
 //#region ../config-evaluator/src/percent-hashing.ts
 const SEED = 15426857351n;
-const assignPercentage = (data) => {
-	const value = `${data.contextIdentifier}-${data.configId}`;
-	return Number(rapidhash(value, { seed: SEED }) % 1000n) / 10;
+const assignPercentage = ({ configId, contextIdentifier, contextKind }) => {
+	const hashInput = contextKind === "user" ? `${contextIdentifier}-${configId}` : `${contextIdentifier}-${configId}:${contextKind}`;
+	return Number(rapidhash(hashInput, { seed: SEED }) % 1000n) / 10;
 };
 //#endregion
 //#region ../config-evaluator/src/ConfigEvaluator.ts
@@ -7208,7 +7333,8 @@ var ConfigEvaluator = class {
 		const identifier = context?.context?.id ?? void 0;
 		const assignedPercentage = identifier === void 0 ? 0 : assignPercentage({
 			configId: config.id,
-			contextIdentifier: identifier
+			contextIdentifier: identifier,
+			contextKind: effectiveContextKind(context)
 		});
 		const shares = [];
 		let sum = 0;
@@ -7511,6 +7637,59 @@ const resolvePollingInterval = (configuredSeconds, defaults) => {
 		warning: `pollingInterval of ${configuredSeconds} seconds is below the minimum of ${defaults.minimumSeconds} seconds. Using ${defaults.minimumSeconds} seconds.`
 	};
 };
+var InvalidContextSubmissions = class {
+	countsByKindSample = /* @__PURE__ */ new Map();
+	countBeyondSampleLimit = 0;
+	startTime;
+	record(kindSample) {
+		this.startTime ??= /* @__PURE__ */ new Date();
+		return this.add(kindSample, 1);
+	}
+	absorb(entries) {
+		for (const entry of entries) {
+			if (this.startTime === void 0 || entry.startTime < this.startTime) this.startTime = entry.startTime;
+			this.add(entry.event.kindSample, entry.count);
+		}
+	}
+	add(kindSample, count) {
+		if (kindSample !== void 0) {
+			const knownCount = this.countsByKindSample.get(kindSample);
+			if (knownCount !== void 0) {
+				this.countsByKindSample.set(kindSample, knownCount + count);
+				return "known-kind-sample";
+			}
+			if (this.countsByKindSample.size < 20) {
+				this.countsByKindSample.set(kindSample, count);
+				return "new-kind-sample";
+			}
+		}
+		const firstBeyondSampleLimit = this.countBeyondSampleLimit === 0;
+		this.countBeyondSampleLimit += count;
+		return firstBeyondSampleLimit ? "first-beyond-sample-limit" : "beyond-sample-limit";
+	}
+	takeSnapshot() {
+		const endTime = /* @__PURE__ */ new Date();
+		const startTime = this.startTime ?? endTime;
+		const entryOf = (count, kindSample) => ({
+			startTime,
+			endTime,
+			count,
+			event: {
+				reason: "invalid-context-kind",
+				kindSample
+			}
+		});
+		const sampledEntries = Array.from(this.countsByKindSample, ([kindSample, count]) => entryOf(count, kindSample));
+		const entries = this.countBeyondSampleLimit > 0 ? [...sampledEntries, entryOf(this.countBeyondSampleLimit)] : sampledEntries;
+		this.clear();
+		return entries;
+	}
+	clear() {
+		this.countsByKindSample.clear();
+		this.countBeyondSampleLimit = 0;
+		this.startTime = void 0;
+	}
+};
 //#endregion
 //#region ../shared/src/telemetry/utils.ts
 const CONFIG_VALUE_MAX_LENGTH = 500;
@@ -7821,6 +8000,7 @@ var ServerTelemetryEventCollector = class extends TelemetryEventCollector {
 	reporter;
 	_context;
 	contexts;
+	invalidContextSubmissions = new InvalidContextSubmissions();
 	constructor(options) {
 		super(options);
 		this.reporter = new ServerEventReporter(options);
@@ -7829,13 +8009,23 @@ var ServerTelemetryEventCollector = class extends TelemetryEventCollector {
 	}
 	evaluatedConfig(payload) {
 		if (!this.collectEvents) return;
-		if (payload.context?.id && !payload.context.anonymous) this.contexts.set(payload.context.id, payload.context);
+		const context = payload.context ?? void 0;
+		const contextKind = effectiveContextKind({ context });
+		const contextId = context?.anonymous ? void 0 : context?.id;
+		if (contextId) this.contexts.set(`${contextKind}:${contextId}`, {
+			...context,
+			kind: contextKind
+		});
 		const event = {
 			...payload.evaluation,
-			contextId: payload.context?.anonymous ? void 0 : payload.context?.id
+			contextId,
+			contextKind: contextId === void 0 ? void 0 : contextKind
 		};
 		this.evaluationEventQueue.push(this.sanitizeEvaluatedConfigEvent(event));
 	}
+	recordInvalidContext(kindSample) {
+		return this.invalidContextSubmissions.record(kindSample);
+	}
 	sanitizeEvaluatedConfigEvent(event) {
 		return {
 			...event,
@@ -7869,7 +8059,10 @@ var ServerTelemetryEventCollector = class extends TelemetryEventCollector {
 		return await this.reporter?.report({
 			context: this._context,
 			discreteEvents: { capturedContexts: contextsSnapshot.contexts },
-			aggregatedEvents: { evaluatedConfig: this.aggregator.aggregate(evaluationSnapshot) },
+			aggregatedEvents: {
+				evaluatedConfig: this.aggregator.aggregate(evaluationSnapshot),
+				invalidContext: this.invalidContextSubmissions.takeSnapshot()
+			},
 			droppedEvents: {
 				evaluatedConfig: evaluationSnapshot.droppedCount,
 				capturedContexts: contextsSnapshot.droppedCount
@@ -7878,6 +8071,14 @@ var ServerTelemetryEventCollector = class extends TelemetryEventCollector {
 	}
 };
 //#endregion
+//#region ../js-server-sdk/src/telemetry/discarding.ts
+const discardingTelemetryClient = {
+	start: () => {},
+	evaluatedConfig: () => {},
+	recordInvalidContext: () => "new-kind-sample",
+	close: async () => {}
+};
+//#endregion
 //#region ../shared/src/base62-encoder.ts
 const BASE62 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 const toBase62 = (buf, length) => {
@@ -7900,11 +8101,20 @@ const generateValueId = async (v) => {
 };
 //#endregion
 //#region ../js-server-sdk/src/DefaultConfigDirectorClient.ts
-const defaultBaseUrl = new URL("https://server-sdk-api.configdirector.com");
 const DEFAULT_FLUSH_INTERVAL = 3e4;
 const DEFAULT_EVENT_QUEUE_LIMIT = 5e3;
+const liveTimeoutWarningDetails = {
+	streaming: "The client will continue to retry since there were no fatal errors detected. Configs will return the default value until the connection succeeds.",
+	polling: "Since the client was configured without streaming, configs may not update and always return the default value."
+};
+const logInvalidContext = {
+	"new-kind-sample": (logger, kindSample) => logger.error(`[ConfigDirectorClient] Ignored a context with the invalid kind '${kindSample}' and evaluated as if no context was supplied. A context kind has 1 to 64 characters, using only lowercase letters, digits, '-' and '_'.`),
+	"known-kind-sample": () => {},
+	"first-beyond-sample-limit": (logger) => logger.error(`[ConfigDirectorClient] Ignored a context with another invalid kind and evaluated as if no context was supplied. 20 different invalid kinds were logged recently, so further invalid kinds are not logged individually.`),
+	"beyond-sample-limit": () => {}
+};
 const usesAnySegment = (definition, segmentIds) => (definition.target?.rules ?? []).some((rule) => rule.type === "conditional" && (rule.conditions ?? []).some((condition) => condition.kind === "segment" && segmentIds.has(condition.segmentId)));
-var DefaultConfigDirectorClient = class {
+var DefaultConfigDirectorClient = class DefaultConfigDirectorClient {
 	logger;
 	usageEventCollector;
 	configSet;
@@ -7916,19 +8126,21 @@ var DefaultConfigDirectorClient = class {
 	readyPromise;
 	readyResolve;
 	readyTimer;
-	connectionMode;
+	connectionPlan;
 	configEvaluator;
 	metaContext;
+	static from(serverSdkKeyOrOptions, sdkOptions, clientOptions) {
+		if (typeof serverSdkKeyOrOptions === "object") return new DefaultConfigDirectorClient(void 0, sdkOptions, serverSdkKeyOrOptions);
+		return new DefaultConfigDirectorClient(serverSdkKeyOrOptions, sdkOptions, clientOptions);
+	}
 	constructor(serverSdkKey, sdkOptions, clientOptions, internalClientOptions) {
 		this.logger = clientOptions?.logger ?? createDefaultLogger$1();
 		this.timeout = clientOptions?.connection?.timeout ?? 3e3;
 		this.metaContext = clientOptions?.metadata ?? {};
-		this.validateSdkKeyPresence(serverSdkKey);
+		this.connectionPlan = planConnection(serverSdkKey, clientOptions?.connection);
 		this.configEvaluator = new ConfigEvaluator(this.logger);
-		const baseUrl = this.parseUrl(clientOptions?.connection?.url) ?? defaultBaseUrl;
-		this.connectionMode = clientOptions?.connection?.mode ?? "streaming";
-		this.usageEventCollector = internalClientOptions?.telemetry ?? this.buildTelemetryCollector(serverSdkKey, sdkOptions, baseUrl, clientOptions);
-		this.transport = internalClientOptions?.transport ?? this.buildTransport(serverSdkKey, sdkOptions, baseUrl, clientOptions);
+		this.usageEventCollector = internalClientOptions?.telemetry ?? this.buildTelemetryClient(sdkOptions, clientOptions);
+		this.transport = internalClientOptions?.transport ?? this.buildTransport(sdkOptions, clientOptions);
 		this.transport.on("configBundleReceived", (configBundle) => {
 			this.readyResolve?.(false);
 			const removedKeys = this.findKeysRemovedBy(configBundle);
@@ -7990,16 +8202,20 @@ var DefaultConfigDirectorClient = class {
 				})]);
 				this.clearReadyTimer();
 			}
-			if (!this.ready) {
-				const warningDetails = this.connectionMode === "streaming" ? "The client will continue to retry since there were no fatal errors detected. Configs will return the default value until the connection succeeds." : "Since the client was configured without streaming, configs may not update and always return the default value.";
-				this.logger.warn(`[ConfigDirectorClient] Timed out waiting for initialization after ${this.timeout}ms. ${warningDetails}`);
-			}
+			if (!this.ready) this.logger.warn(`[ConfigDirectorClient] Timed out waiting for initialization after ${this.timeout}ms. ${this.timeoutWarningDetails()}`);
 		} catch (error) {
+			if (error instanceof ConfigDirectorInitializationError) throw error;
 			this.logger.error("[ConfigDirectorClient] An error occurred during initialization: ", error);
 		}
 	}
-	resolvePollingIntervalForMode(configuredSeconds) {
-		if (this.connectionMode !== "polling") return;
+	timeoutWarningDetails() {
+		switch (this.connectionPlan.kind) {
+			case "connect": return liveTimeoutWarningDetails[this.connectionPlan.mode];
+			case "stay-offline": return "The offline values were not delivered, so configs return the default value.";
+		}
+	}
+	pollingIntervalFor(mode, configuredSeconds) {
+		if (mode !== "polling") return;
 		const resolved = resolvePollingInterval(configuredSeconds, {
 			defaultSeconds: 300,
 			minimumSeconds: 60
@@ -8007,38 +8223,48 @@ var DefaultConfigDirectorClient = class {
 		if (resolved.warning) this.logger.warn(`[ConfigDirectorClient] ${resolved.warning}`);
 		return resolved.seconds;
 	}
-	buildTelemetryCollector(serverSdkKey, sdkOptions, baseUrl, clientOptions) {
-		const queueLimit = clientOptions?.telemetry?.eventQueueLimit ?? DEFAULT_EVENT_QUEUE_LIMIT;
-		return new ServerTelemetryEventCollector({
-			sdkKey: serverSdkKey,
-			sdkIdentity: sdkOptions,
-			metaContext: clientOptions?.metadata ?? {},
-			logger: this.logger,
-			baseUrl,
-			flushIntervalDelay: clientOptions?.telemetry?.flushInterval ?? DEFAULT_FLUSH_INTERVAL,
-			evaluationQueueLimit: Math.ceil(queueLimit * .7),
-			contextLimit: Math.floor(queueLimit * .3),
-			urlFactory: defaultUrlFactory,
-			valueIdGenerator: generateValueId
-		});
+	buildTelemetryClient(sdkOptions, clientOptions) {
+		const plan = this.connectionPlan;
+		switch (plan.kind) {
+			case "stay-offline": return discardingTelemetryClient;
+			case "connect": {
+				const queueLimit = clientOptions?.telemetry?.eventQueueLimit ?? DEFAULT_EVENT_QUEUE_LIMIT;
+				return new ServerTelemetryEventCollector({
+					sdkKey: plan.serverSdkKey,
+					sdkIdentity: sdkOptions,
+					metaContext: clientOptions?.metadata ?? {},
+					logger: this.logger,
+					baseUrl: plan.baseUrl,
+					flushIntervalDelay: clientOptions?.telemetry?.flushInterval ?? DEFAULT_FLUSH_INTERVAL,
+					evaluationQueueLimit: Math.ceil(queueLimit * .7),
+					contextLimit: Math.floor(queueLimit * .3),
+					urlFactory: defaultUrlFactory,
+					valueIdGenerator: generateValueId
+				});
+			}
+		}
 	}
-	buildTransport(serverSdkKey, sdkOptions, baseUrl, clientOptions) {
-		return new (this.getTransportConstructor(this.connectionMode))({
-			serverSdkKey,
-			baseUrl,
-			metaContext: {
-				...clientOptions?.metadata,
-				sdkName: sdkOptions.sdkName,
-				sdkVersion: sdkOptions.sdkVersion
-			},
-			logger: this.logger,
-			pollingInterval: this.resolvePollingIntervalForMode(clientOptions?.connection?.pollingInterval)
-		});
+	buildTransport(sdkOptions, clientOptions) {
+		const plan = this.connectionPlan;
+		switch (plan.kind) {
+			case "stay-offline": return new OfflineTransport(plan.source);
+			case "connect": return new (this.getTransportConstructor(plan.mode))({
+				serverSdkKey: plan.serverSdkKey,
+				baseUrl: plan.baseUrl,
+				metaContext: {
+					...clientOptions?.metadata,
+					sdkName: sdkOptions.sdkName,
+					sdkVersion: sdkOptions.sdkVersion
+				},
+				logger: this.logger,
+				pollingInterval: this.pollingIntervalFor(plan.mode, clientOptions?.connection?.pollingInterval)
+			});
+		}
 	}
 	getTransportConstructor(mode) {
 		switch (mode) {
 			case "polling": return PollingTransport;
-			default: return StreamingTransport;
+			case "streaming": return StreamingTransport;
 		}
 	}
 	findKeysRemovedBy(configBundle) {
@@ -8086,7 +8312,8 @@ var DefaultConfigDirectorClient = class {
 		const configDefinition = this.configSet?.configs[configKey];
 		return this.getValueFromConfigDefinition(configKey, configDefinition, defaultValue, context);
 	}
-	getValueFromConfigDefinition(configKey, configDefinition, defaultValue, context) {
+	getValueFromConfigDefinition(configKey, configDefinition, defaultValue, suppliedContext) {
+		const context = this.contextToEvaluate(suppliedContext);
 		if (configDefinition) {
 			const configState = this.configEvaluator.evaluate(configDefinition, {
 				context,
@@ -8140,19 +8367,17 @@ var DefaultConfigDirectorClient = class {
 			return defaultValue;
 		}
 	}
-	dispatchEvaluationEvent(event) {
-		setTimeout(() => this.eventEmitter.emit("configEvaluated", { evaluation: event }), 0);
-	}
-	parseUrl(url) {
-		if (!url) return;
-		try {
-			return new URL(url);
-		} catch (error) {
-			throw new ConfigDirectorValidationError(`Invalid base URL '${url}'. Parsing failed: ${error}`);
+	contextToEvaluate(suppliedContext) {
+		const admission = admitContext(suppliedContext);
+		switch (admission.outcome) {
+			case "admitted": return admission.context;
+			case "ignored":
+				logInvalidContext[this.usageEventCollector.recordInvalidContext(admission.kindSample)](this.logger, admission.kindSample);
+				return;
 		}
 	}
-	validateSdkKeyPresence(sdkKey) {
-		if (!sdkKey || sdkKey.trim().length == 0) throw new ConfigDirectorValidationError("No server SDK key was provided, the client cannot be instantiated without a valid server SDK key");
+	dispatchEvaluationEvent(event) {
+		setTimeout(() => this.eventEmitter.emit("configEvaluated", { evaluation: event }), 0);
 	}
 	validateDefaultValue(defaultValue) {
 		if (defaultValue === void 0 || defaultValue === null) throw new ConfigDirectorValidationError("Invalid default value. The default value for a config must be defined and non-null.");
@@ -8177,11 +8402,12 @@ var DefaultConfigDirectorClient = class {
 		this.handlersMap.clear();
 	}
 	getAllConfigs(options) {
+		const context = this.contextToEvaluate(options?.context);
 		if (!this.configSet) return {};
 		const entries = Object.entries(this.configSet.configs);
 		const filtered = options?.configKeys ? entries.filter(([key]) => options.configKeys?.includes(key)) : entries;
 		return Object.fromEntries(filtered.map(([key, config]) => [key, this.configEvaluator.evaluate(config, {
-			context: options?.context,
+			context,
 			metadata: this.metaContext
 		}, this.configSet?.segments)]));
 	}
@@ -8216,27 +8442,38 @@ const createDefaultLogger = (level) => {
 var plugin_default = defineNitroPlugin((nitroApp) => {
 	const runtimeConfig = useRuntimeConfig();
 	const logger = createDefaultLogger(runtimeConfig.configdirector?.logLevel);
-	if (!runtimeConfig.configdirector.serverSdkKey) {
+	const { serverSdkKey, baseUrl, connection } = runtimeConfig.configdirector;
+	const connectionMode = connection?.mode || "streaming";
+	if (connectionMode !== "offline" && !serverSdkKey) {
 		const message = "The ConfigDirector serverSdkKey must be configured for the plugin to initialize. You can provide it in nuxt.config.ts under 'runtimeConfig.configdirector.serverSdkKey' or as a runtime environment variable named NUXT_CONFIGDIRECTOR_SERVER_SDK_KEY";
 		logger.error(message);
 		throw new ConfigDirectorInitializationError(message);
 	}
 	logger.debug("Initializing ConfigDirector Nitro plugin");
-	const { serverSdkKey, baseUrl, connection } = runtimeConfig.configdirector;
-	const client = new DefaultConfigDirectorClient(serverSdkKey, {
+	const client = new DefaultConfigDirectorClient(serverSdkKey || void 0, {
 		sdkName: "nuxt-sdk",
-		sdkVersion: "1.9.2"
+		sdkVersion: "1.11.0"
 	}, {
 		logger,
 		connection: {
 			url: baseUrl || void 0,
-			mode: connection?.mode || void 0,
+			mode: connectionMode,
+			file: connection?.file || void 0,
+			values: connection?.values,
 			pollingInterval: connection?.pollingInterval || void 0,
 			timeout: connection?.timeout || void 0
 		}
 	});
+	const initialization = client.initialize();
+	initialization.catch((error) => {
+		logger.error("The ConfigDirector server client could not initialize, so every request fails:", error);
+	});
 	nitroApp.configDirectorClient = client;
-	nitroApp.configDirectorInitialization = client.initialize();
+	nitroApp.configDirectorConnectionMode = connectionMode;
+	nitroApp.configDirectorInitialization = initialization;
+	nitroApp.hooks.hook("request", (event) => {
+		useRuntimeConfig(event).public.configdirector.serverConnectionMode = connectionMode;
+	});
 });
 //#endregion
 export { plugin_default as default };