@configdirector/nuxt-sdk 1.7.0 → 1.8.0

package/dist/testing.mjs

@@ -0,0 +1,1645 @@
+//#region ../js-client-core/src/Emitter.ts
+var Emitter = class {
+	handlerMap = /* @__PURE__ */ new Map();
+	on(name, handler) {
+		const handlers = this.handlerMap.get(name);
+		if (handlers) handlers.push(handler);
+		else this.handlerMap.set(name, [handler]);
+	}
+	once(name, handler) {
+		const self = this;
+		function onceHandler(payload) {
+			self.off(name, onceHandler);
+			handler.apply(self, payload);
+		}
+		this.on(name, onceHandler);
+	}
+	off(name, handler) {
+		const handlers = this.handlerMap.get(name);
+		if (!handlers) return;
+		if (handler) {
+			const listenerIndex = handlers.indexOf(handler);
+			if (listenerIndex >= 0) handlers.splice(listenerIndex, 1);
+		} else this.handlerMap.set(name, []);
+	}
+	clear() {
+		this.handlerMap.clear();
+	}
+	emit(name, payload) {
+		const handlers = this.handlerMap.get(name);
+		if (!handlers) return;
+		handlers.slice().map((h) => h(payload));
+	}
+};
+//#endregion
+//#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);
+	}
+};
+//#endregion
+//#region ../eventsource/src/errors.ts
+var StreamClosedError = class StreamClosedError extends Error {
+	name = "StreamClosedError";
+	constructor(message) {
+		super(message);
+		Object.setPrototypeOf(this, StreamClosedError.prototype);
+	}
+};
+var MissingResponseBodyError = class MissingResponseBodyError extends Error {
+	name = "MissingResponseBodyError";
+	constructor(message) {
+		super(message);
+		Object.setPrototypeOf(this, MissingResponseBodyError.prototype);
+	}
+};
+var InvalidOptionError = class InvalidOptionError extends Error {
+	name = "InvalidOptionError";
+	constructor(message) {
+		super(message);
+		Object.setPrototypeOf(this, InvalidOptionError.prototype);
+	}
+};
+var ValueOutOfRangeError = class ValueOutOfRangeError extends Error {
+	name = "ValueOutOfRangeError";
+	constructor(message) {
+		super(message);
+		Object.setPrototypeOf(this, ValueOutOfRangeError.prototype);
+	}
+};
+//#endregion
+//#region ../eventsource/src/types.ts
+let ReadyState = /* @__PURE__ */ function(ReadyState) {
+	ReadyState["OPEN"] = "open";
+	ReadyState["CLOSED"] = "closed";
+	ReadyState["CONNECTING"] = "connecting";
+	return ReadyState;
+}({});
+//#endregion
+//#region ../eventsource/src/EventSourceParser.ts
+var EventSourceParser = class {
+	isFirstChunk = true;
+	bufferedInput = "";
+	currentEvent = { data: "" };
+	lastEventId;
+	onEvent;
+	onRetry;
+	onComment;
+	constructor(options) {
+		this.currentEvent = { data: "" };
+		this.onEvent = options.onEvent ?? (() => {});
+		this.onRetry = options.onRetry;
+		this.onComment = options.onComment;
+	}
+	parse(chunk) {
+		let input = chunk;
+		if (this.isFirstChunk) {
+			this.isFirstChunk = false;
+			if (input.startsWith("")) input = input.slice(1);
+			else if (input.startsWith("")) input = input.slice(3);
+		}
+		const lines = this.scanLines(this.bufferedInput + input);
+		for (const line of lines) this.dispatchLine(line);
+	}
+	finish() {
+		this.bufferedInput = "";
+	}
+	/**
+	* Scans `text` character by character to extract complete lines, recognizing
+	* CR, LF, and CRLF as line terminators per the SSE spec. Any unterminated
+	* trailing text is buffered and prepended to the next chunk.
+	*/
+	scanLines(text) {
+		const lines = [];
+		let lineStart = 0;
+		let i = 0;
+		while (i < text.length) {
+			const ch = text[i];
+			if (ch === "\r" || ch === "\n") {
+				lines.push(text.slice(lineStart, i));
+				if (ch === "\r" && text[i + 1] === "\n") i++;
+				i++;
+				lineStart = i;
+			} else i++;
+		}
+		this.bufferedInput = text.slice(lineStart);
+		return lines;
+	}
+	dispatchLine(line) {
+		if (line.startsWith(":")) {
+			this.onComment?.(this.extractValue(line, 1));
+			return;
+		}
+		if (line === "") {
+			this.emitEvent();
+			return;
+		}
+		this.applyField(this.parseField(line));
+	}
+	emitEvent() {
+		const data = this.currentEvent.data.endsWith("\n") ? this.currentEvent.data.slice(0, -1) : this.currentEvent.data;
+		if (data !== "") this.onEvent({
+			...this.currentEvent,
+			id: this.lastEventId,
+			data
+		});
+		this.currentEvent = { data: "" };
+	}
+	applyField(parsed) {
+		switch (parsed.field) {
+			case "event":
+				this.currentEvent.type = parsed.value;
+				break;
+			case "data":
+				this.currentEvent.data += parsed.value + "\n";
+				break;
+			case "id":
+				if (!parsed.value.includes("\0")) this.lastEventId = parsed.value;
+				break;
+			case "retry":
+				if (/^\d+$/.test(parsed.value)) this.onRetry?.(Number.parseInt(parsed.value, 10));
+				break;
+			default: break;
+		}
+	}
+	parseField(line) {
+		const colon = line.indexOf(":");
+		if (colon === -1) return {
+			field: line,
+			value: ""
+		};
+		return {
+			field: line.slice(0, colon),
+			value: this.extractValue(line, colon + 1)
+		};
+	}
+	/** Returns the value portion of a line, stripping a single leading space per spec. */
+	extractValue(line, from) {
+		return line[from] === " " ? line.slice(from + 1) : line.slice(from);
+	}
+};
+//#endregion
+//#region ../eventsource/src/EventSourceClient.ts
+var EventSourceClient = class {
+	DEFAULT_SHOULD_RECONNECT = () => true;
+	DEFAULT_CALCULATE_RECONNECT_DELAY = () => this.serverReconnectionTime;
+	url;
+	headers;
+	body;
+	requestOptions;
+	lastEventId;
+	reconnectAttempt = 0;
+	abortController = new AbortController();
+	reconnectTimeout;
+	_readyState = ReadyState.CLOSED;
+	serverReconnectionTime = 2e3;
+	_fetch;
+	_onError;
+	_onMessage;
+	_onComment;
+	_onConnect;
+	_onDisconnect;
+	_shouldReconnect;
+	_calculateReconnectDelay;
+	constructor(options) {
+		this.url = options.url.toString();
+		this.lastEventId = options.lastEventId;
+		this.headers = {
+			Accept: "text/event-stream",
+			...options.headers
+		};
+		const body = options.body;
+		this.body = typeof body === "function" ? body : () => body;
+		this.requestOptions = {
+			method: options.method ?? "GET",
+			mode: options.mode,
+			credentials: options.credentials,
+			redirect: options.redirect,
+			referrer: options.referrer,
+			referrerPolicy: options.referrerPolicy
+		};
+		this._fetch = options.fetch ?? ((url, init) => fetch(url, init));
+		this._onError = this.resolveCallback(options.onError, () => {}, "onError");
+		this._onConnect = this.resolveCallback(options.onConnect, () => {}, "onConnect");
+		this._onDisconnect = this.resolveCallback(options.onDisconnect, () => {}, "onDisconnect");
+		this._onMessage = this.resolveCallback(options.onMessage, () => {}, "onMessage");
+		this._onComment = this.resolveCallback(options.onComment, () => {}, "onComment");
+		this._shouldReconnect = this.resolveCallback(options.shouldReconnect, this.DEFAULT_SHOULD_RECONNECT, "shouldReconnect");
+		this._calculateReconnectDelay = this.resolveCallback(options.calculateReconnectDelay, this.DEFAULT_CALCULATE_RECONNECT_DELAY, "calculateReconnectDelay");
+	}
+	set onError(value) {
+		this._onError = this.resolveCallback(value, () => {}, "onError");
+	}
+	set onMessage(value) {
+		this._onMessage = this.resolveCallback(value, () => {}, "onMessage");
+	}
+	set onComment(value) {
+		this._onComment = this.resolveCallback(value, () => {}, "onComment");
+	}
+	set onConnect(value) {
+		this._onConnect = this.resolveCallback(value, () => {}, "onConnect");
+	}
+	set onDisconnect(value) {
+		this._onDisconnect = this.resolveCallback(value, () => {}, "onDisconnect");
+	}
+	set shouldReconnect(value) {
+		this._shouldReconnect = this.resolveCallback(value, this.DEFAULT_SHOULD_RECONNECT, "shouldReconnect");
+	}
+	set calculateReconnectDelay(value) {
+		this._calculateReconnectDelay = this.resolveCallback(value, this.DEFAULT_CALCULATE_RECONNECT_DELAY, "shouldReconnect");
+	}
+	get readyState() {
+		return this._readyState;
+	}
+	connect() {
+		if (this._readyState !== ReadyState.CLOSED) return;
+		this.reconnectAttempt = 0;
+		this.initiateConnection();
+	}
+	close() {
+		clearTimeout(this.reconnectTimeout);
+		this._readyState = ReadyState.CLOSED;
+		this.abortController.abort();
+	}
+	initiateConnection() {
+		this.abortController = new AbortController();
+		this._readyState = ReadyState.CONNECTING;
+		this._fetch(this.url, {
+			...this.requestOptions,
+			body: this.body(),
+			headers: this.buildRequestHeaders(),
+			signal: this.abortController.signal,
+			cache: "no-store"
+		}).then((response) => this.handleFetchResponse(response)).catch((error) => {
+			if (error.name === "AbortError" || this.abortController.signal.aborted) {
+				this.close();
+				return;
+			}
+			this._onError(error);
+			this.scheduleReconnect({ error });
+		});
+	}
+	async handleFetchResponse(response) {
+		const { body, status } = response;
+		if (status === 204) {
+			this.disconnected();
+			return;
+		}
+		if (status >= 400) {
+			this.scheduleReconnect({ status });
+			return;
+		}
+		if (!body) throw new MissingResponseBodyError("The server response did not have a body");
+		this._readyState = ReadyState.OPEN;
+		this._onConnect();
+		this.reconnectAttempt = 0;
+		const parser = new EventSourceParser({
+			onEvent: (event) => {
+				if (typeof event.id === "string") this.lastEventId = event.id;
+				this._onMessage(event);
+			},
+			onComment: (comment) => this._onComment(comment),
+			onRetry: (retryDelay) => this.serverReconnectionTime = retryDelay
+		});
+		await this.readResponseStream(body, parser);
+		this.scheduleReconnect({
+			status,
+			error: new StreamClosedError("The server response stream was closed")
+		});
+	}
+	async readResponseStream(body, parser) {
+		const reader = body.getReader();
+		const decoder = new TextDecoder();
+		let done = false;
+		while (!done) {
+			const result = await reader.read();
+			if (result.value) parser.parse(decoder.decode(result.value, { stream: true }));
+			done = result.done;
+		}
+		parser.finish();
+	}
+	disconnected() {
+		clearTimeout(this.reconnectTimeout);
+		this._readyState = ReadyState.CLOSED;
+		this._onDisconnect();
+	}
+	buildRequestHeaders() {
+		const lastEventIdHeader = this.lastEventId ? { "Last-Event-ID": this.lastEventId } : void 0;
+		return {
+			...this.headers,
+			...lastEventIdHeader
+		};
+	}
+	scheduleReconnect(state) {
+		if (this.abortController.signal.aborted) return;
+		clearTimeout(this.reconnectTimeout);
+		this.reconnectAttempt += 1;
+		const reconnectionState = {
+			attempt: this.reconnectAttempt,
+			status: state.status,
+			error: state.error,
+			serverReconnectionTime: this.serverReconnectionTime
+		};
+		if (!this._shouldReconnect(reconnectionState)) {
+			this.disconnected();
+			return;
+		}
+		this._readyState = ReadyState.CONNECTING;
+		let delay = this._calculateReconnectDelay(reconnectionState);
+		if (!Number.isFinite(delay) || delay < 1 || delay > 1e3 * 60 * 60) {
+			this._onError(new ValueOutOfRangeError(`The calculated reconnect delay is out of range: ${delay}. Defaulting to ${this.serverReconnectionTime}`));
+			delay = this.serverReconnectionTime;
+		}
+		this.reconnectTimeout = setTimeout(() => this.initiateConnection(), delay);
+	}
+	resolveCallback(provided, fallback, optionName) {
+		if (provided == null) return fallback;
+		if (typeof provided !== "function") throw new InvalidOptionError(`${optionName} must be a function`);
+		return provided;
+	}
+};
+//#endregion
+//#region ../eventsource/src/index.ts
+const createEventSourceClient = (options) => {
+	return new EventSourceClient(options);
+};
+//#endregion
+//#region ../js-client-core/src/StreamingTransport.ts
+var StreamingTransport = class {
+	logger;
+	eventSource;
+	eventEmitter = new Emitter();
+	url;
+	timeoutTimer;
+	constructor(options) {
+		this.options = options;
+		this.options = options;
+		this.logger = options.logger;
+		this.url = options.resolveUrl("client/sse/v1", options.baseUrl);
+	}
+	async connect(context, timeout) {
+		if (this.eventSource) this.close();
+		const eventSourcePromise = new Promise((resolve, reject) => {
+			this.eventSource = createEventSourceClient({
+				url: this.url,
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				fetch: this.options.fetch,
+				body: JSON.stringify({
+					givenContext: context,
+					metaContext: this.options.metaContext,
+					clientSdkKey: this.options.clientSdkKey,
+					instanceId: this.options.instanceId
+				}),
+				onMessage: ({ data }) => {
+					this.dispatchMessage(data);
+				},
+				onConnect: () => {
+					this.logger.debug("[StreamingTransport] Connected");
+					resolve(this);
+				},
+				shouldReconnect: (state) => {
+					const reconnect = !this.isStatusFatal(state.status);
+					if (!reconnect) {
+						const error = this.prepareFatalError(state.status, state.error);
+						this.eventEmitter.emit("connectionError", error);
+						reject(error);
+					}
+					return reconnect;
+				},
+				calculateReconnectDelay: (state) => {
+					const delay = this.options.connectionRetryDelay(state.attempt);
+					const logMessage = `[StreamingTransport] Scheduling reconnect attempt #${state.attempt} in ${delay}ms.`;
+					if (state.attempt <= 5) this.logger.info(logMessage);
+					else this.logger.warn(logMessage);
+					return delay;
+				},
+				onError: (error) => {
+					this.logger.debug("[StreamingTransport] Error: ", error);
+				},
+				onDisconnect: () => {
+					this.logger.debug("[StreamingTransport] Disconnected");
+				}
+			});
+			this.eventSource.connect();
+		});
+		clearTimeout(this.timeoutTimer);
+		this.timeoutTimer = void 0;
+		return Promise.race([eventSourcePromise, new Promise((resolve) => {
+			this.timeoutTimer = setTimeout(() => resolve(this), timeout);
+		})]).finally(() => clearTimeout(this.timeoutTimer));
+	}
+	dispatchMessage(data) {
+		try {
+			const json = JSON.parse(data);
+			this.eventEmitter.emit("configSetReceived", json);
+		} catch (error) {
+			this.logger.error("[StreamingTransport] Error parsing and dispatching config data update: ", error);
+		}
+	}
+	prepareFatalError(responseStatus, error) {
+		const status = responseStatus ?? 0;
+		return new ConfigDirectorConnectionError(`${`Connection failed with status: ${responseStatus ?? "unknown"}.`}${error ? ` Error: ${error}` : ""}. This is an unrecoverable error, will not attempt to reconnect.`, status);
+	}
+	isStatusFatal(status) {
+		return !!status && status >= 400 && status < 500 && status != 429;
+	}
+	on(name, handler) {
+		this.eventEmitter.on(name, handler);
+	}
+	off(name, handler) {
+		this.eventEmitter.off(name, handler);
+	}
+	clear() {
+		this.eventEmitter.clear();
+	}
+	close() {
+		this.eventSource?.close();
+		clearTimeout(this.timeoutTimer);
+	}
+	dispose() {
+		this.close();
+		this.clear();
+	}
+};
+//#endregion
+//#region ../shared/src/value-parser.ts
+const getRequestedType = (defaultValue) => {
+	const baseType = typeof defaultValue;
+	if (baseType === "object") try {
+		return defaultValue.constructor?.name ?? baseType;
+	} catch {
+		return baseType;
+	}
+	else if (baseType === "function") try {
+		const functionName = defaultValue.name;
+		return functionName ? `function: ${functionName}` : baseType;
+	} catch {
+		return baseType;
+	}
+	return baseType;
+};
+const isNumericNativeType = (requestedType) => {
+	return requestedType === "number" || requestedType === "bigint";
+};
+const configTypesNotReadableAsString = new Set([
+	"boolean",
+	"integer",
+	"float"
+]);
+const parseConfigValue = (configState, defaultValue) => {
+	const value = configState.value;
+	const requestedType = getRequestedType(defaultValue);
+	if (value == null || value === "") return {
+		parsedValue: defaultValue,
+		parsedValueId: void 0,
+		requestedType,
+		usedDefault: true,
+		reason: "value-missing"
+	};
+	if (configState.type === "json") return parseJson(value, defaultValue, requestedType, configState.valueId);
+	if (typeof defaultValue === "string") {
+		if (configTypesNotReadableAsString.has(configState.type)) return {
+			parsedValue: defaultValue,
+			parsedValueId: void 0,
+			requestedType,
+			usedDefault: true,
+			reason: "type-mismatch"
+		};
+		return {
+			parsedValue: value,
+			parsedValueId: configState.valueId,
+			requestedType,
+			usedDefault: false,
+			reason: "found-match"
+		};
+	}
+	if (typeof defaultValue === "boolean" && (configState.type === "boolean" || configState.type === "string" || configState.type === "enum")) {
+		const boolValue = parseConfigBoolean(value);
+		const hasBoolean = typeof boolValue === "boolean";
+		return {
+			parsedValue: hasBoolean ? boolValue : defaultValue,
+			parsedValueId: hasBoolean ? configState.valueId : void 0,
+			requestedType,
+			usedDefault: !hasBoolean,
+			reason: hasBoolean ? "found-match" : "invalid-boolean"
+		};
+	}
+	if (isNumericNativeType(typeof defaultValue) && configState.type === "integer") {
+		const numValue = parseConfigInteger(value);
+		const hasNumber = typeof numValue === "number";
+		return {
+			parsedValue: hasNumber ? numValue : defaultValue,
+			parsedValueId: hasNumber ? configState.valueId : void 0,
+			requestedType,
+			usedDefault: !hasNumber,
+			reason: hasNumber ? "found-match" : "invalid-number"
+		};
+	}
+	if (isNumericNativeType(typeof defaultValue) && (configState.type === "float" || configState.type === "enum" || configState.type === "string")) {
+		const numValue = parseConfigFloat(value);
+		const hasNumber = typeof numValue === "number";
+		return {
+			parsedValue: hasNumber ? numValue : defaultValue,
+			parsedValueId: hasNumber ? configState.valueId : void 0,
+			requestedType,
+			usedDefault: !hasNumber,
+			reason: hasNumber ? "found-match" : "invalid-number"
+		};
+	}
+	return {
+		parsedValue: defaultValue,
+		parsedValueId: void 0,
+		requestedType,
+		usedDefault: true,
+		reason: "type-mismatch"
+	};
+};
+const parseConfigBoolean = (value) => {
+	if (!value) return;
+	const lowerValue = value.toLowerCase();
+	if (lowerValue != "true" && lowerValue != "false") return;
+	return lowerValue === "true";
+};
+const parseConfigInteger = (value) => {
+	const num = parseStrictNumber(value);
+	return num == null ? void 0 : Math.trunc(num);
+};
+const parseConfigFloat = (value) => {
+	return parseStrictNumber(value);
+};
+const parseStrictNumber = (value) => {
+	if (!value || !isDecimalCharacters(value)) return;
+	const num = Number(value);
+	if (isNaN(num) || !isFinite(num)) return;
+	return num;
+};
+const isDecimalCharacters = (value) => {
+	for (const character of value) if (!(character >= "0" && character <= "9") && !"+-.eE".includes(character)) return false;
+	return true;
+};
+const parseJson = (jsonString, defaultValue, requestedType, valueId) => {
+	if (typeof defaultValue === "string") return {
+		parsedValue: jsonString,
+		parsedValueId: valueId,
+		requestedType,
+		usedDefault: false,
+		reason: "found-match"
+	};
+	try {
+		const parsed = JSON.parse(jsonString);
+		if (!isJsonTypeCompatible(parsed, defaultValue)) return {
+			parsedValue: defaultValue,
+			parsedValueId: void 0,
+			requestedType,
+			usedDefault: true,
+			reason: "type-mismatch"
+		};
+		return {
+			parsedValue: parsed,
+			parsedValueId: valueId,
+			requestedType,
+			usedDefault: false,
+			reason: "found-match"
+		};
+	} catch {
+		return {
+			parsedValue: defaultValue,
+			parsedValueId: void 0,
+			requestedType,
+			usedDefault: true,
+			reason: "invalid-json"
+		};
+	}
+};
+const isJsonTypeCompatible = (parsed, defaultValue) => {
+	if (parsed === null) return false;
+	const defaultType = typeof defaultValue;
+	if (defaultType === "bigint") return typeof parsed === "number";
+	return typeof parsed === defaultType;
+};
+//#endregion
+//#region ../shared/src/logger.ts
+const LEVELS = {
+	off: -1,
+	error: 0,
+	warn: 1,
+	info: 2,
+	debug: 3
+};
+const buildDateFormatter = () => {
+	const baseOptions = {
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit",
+		hour: "2-digit",
+		minute: "2-digit",
+		second: "2-digit",
+		timeZoneName: "short"
+	};
+	try {
+		return new Intl.DateTimeFormat(void 0, {
+			...baseOptions,
+			fractionalSecondDigits: 3
+		});
+	} catch {
+		return new Intl.DateTimeFormat(void 0, baseOptions);
+	}
+};
+var DefaultConsoleLogger = class {
+	dateFormatter;
+	constructor(level, decorator) {
+		this.level = level;
+		this.decorator = decorator;
+		this.level = level;
+		this.decorator = decorator;
+		this.dateFormatter = buildDateFormatter();
+	}
+	debug(message, ...args) {
+		this.log(console.debug, "debug", message, ...args);
+	}
+	info(message, ...args) {
+		this.log(console.info, "info", message, ...args);
+	}
+	warn(message, ...args) {
+		this.log(console.warn, "warn", message, ...args);
+	}
+	error(message, ...args) {
+		this.log(console.error, "error", message, ...args);
+	}
+	log(loggerFunction, level, message, ...args) {
+		if (LEVELS[this.level] >= LEVELS[level]) loggerFunction(`[${this.dateFormatter.format(/* @__PURE__ */ new Date())}] ${this.decorator?.decorateMessage(message)}`, ...args);
+	}
+};
+//#endregion
+//#region ../js-client-core/src/logger.ts
+var LogMessageDecorator = class {
+	decorateMessage(message) {
+		return `[ConfigDirector:js-client-sdk] ${message}`;
+	}
+};
+const createDefaultLogger = (level, messageDecorator) => {
+	return new DefaultConsoleLogger(level ?? "warn", messageDecorator ?? new LogMessageDecorator());
+};
+//#endregion
+//#region ../shared/src/url.ts
+const defaultUrlFactory = (input, base) => new URL(input, base?.toString());
+//#endregion
+//#region ../shared/src/transport/pollingInterval.ts
+const resolvePollingInterval = (configuredSeconds, defaults) => {
+	if (configuredSeconds === void 0) return {
+		seconds: defaults.defaultSeconds,
+		warning: void 0
+	};
+	if (configuredSeconds >= defaults.minimumSeconds) return {
+		seconds: configuredSeconds,
+		warning: void 0
+	};
+	return {
+		seconds: defaults.minimumSeconds,
+		warning: `pollingInterval of ${configuredSeconds} seconds is below the minimum of ${defaults.minimumSeconds} seconds. Using ${defaults.minimumSeconds} seconds.`
+	};
+};
+//#endregion
+//#region ../shared/src/instance-id.ts
+const generateInstanceId = () => {
+	if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") return crypto.randomUUID();
+	return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (placeholder) => {
+		const random = Math.random() * 16 | 0;
+		return (placeholder === "x" ? random : random & 3 | 8).toString(16);
+	});
+};
+//#endregion
+//#region ../js-client-core/src/instance-id.ts
+const STORAGE_KEY = "configdirector-sdk:instance-id";
+const RECORD_VERSION = 1;
+const MAX_AGE_MS = 360 * 60 * 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}$/;
+const fnv1a = (input, offsetBasis) => {
+	let hash = offsetBasis;
+	for (let i = 0; i < input.length; i++) {
+		hash ^= input.charCodeAt(i);
+		hash = Math.imul(hash, 16777619);
+	}
+	return hash >>> 0;
+};
+const checksumFor = (id, createdAt) => {
+	const payload = `${CHECKSUM_SALT}|${id}|${createdAt}`;
+	const low = fnv1a(payload, 2166136261);
+	return fnv1a(`${low}|${payload}`, 16777619).toString(16).padStart(8, "0") + low.toString(16).padStart(8, "0");
+};
+const getLocalStorage = () => {
+	try {
+		return globalThis.localStorage ?? void 0;
+	} catch {
+		return;
+	}
+};
+const isUsableRecord = (record) => {
+	if (!record || typeof record !== "object") return false;
+	const { v, id, createdAt, checksum } = record;
+	if (v !== RECORD_VERSION || typeof id !== "string" || typeof checksum !== "string") return false;
+	if (typeof createdAt !== "number" || !Number.isInteger(createdAt) || createdAt <= 0) return false;
+	if (!UUID_V4_PATTERN.test(id)) return false;
+	return checksum === checksumFor(id, createdAt);
+};
+const readStoredInstanceId = (storage, logger) => {
+	let raw;
+	try {
+		raw = storage.getItem(STORAGE_KEY);
+	} catch (error) {
+		logger?.debug("[ConfigDirectorClient] Could not read the stored instance id, generating a new one", error);
+		return;
+	}
+	if (!raw) return;
+	let record;
+	try {
+		record = JSON.parse(raw);
+	} catch {
+		logger?.debug("[ConfigDirectorClient] The stored instance id is not valid JSON, generating a new one");
+		return;
+	}
+	if (!isUsableRecord(record)) {
+		logger?.debug("[ConfigDirectorClient] The stored instance id failed validation, generating a new one");
+		return;
+	}
+	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;
+	}
+	return record.id;
+};
+const storeInstanceId = (storage, id, logger) => {
+	const createdAt = Date.now();
+	const record = {
+		v: RECORD_VERSION,
+		id,
+		createdAt,
+		checksum: checksumFor(id, createdAt)
+	};
+	try {
+		storage.setItem(STORAGE_KEY, JSON.stringify(record));
+	} catch (error) {
+		logger?.debug("[ConfigDirectorClient] Could not persist the instance id", error);
+	}
+};
+const resolveInstanceId = (logger) => {
+	const storage = getLocalStorage();
+	if (!storage) return generateInstanceId();
+	const storedInstanceId = readStoredInstanceId(storage, logger);
+	if (storedInstanceId) return storedInstanceId;
+	const instanceId = generateInstanceId();
+	storeInstanceId(storage, instanceId, logger);
+	return instanceId;
+};
+//#endregion
+//#region ../shared/src/transport/AbstractPollingTransport.ts
+var AbstractPollingTransport = class {
+	fatalError = false;
+	pollingInterval;
+	clearPollingInterval() {
+		clearInterval(this.pollingInterval);
+	}
+	schedulePollingInterval(callback) {
+		clearInterval(this.pollingInterval);
+		if (this.pollingIntervalSeconds <= 0) return;
+		this.pollingInterval = setInterval(callback, this.pollingIntervalSeconds * 1e3);
+	}
+	async handleNonOkResponse(response) {
+		if (!response.ok) if (this.isStatusFatal(response.status)) {
+			this.fatalError = true;
+			this.close();
+			throw this.prepareFatalResponseStatusError(response.status, await response.text());
+		} else throw new ConfigDirectorConnectionError(`Connection failed with status: ${response.status}`, response.status);
+	}
+	handleFetchError(fetchError) {
+		if (this.isFetchErrorFatal(fetchError)) {
+			this.fatalError = true;
+			this.close();
+			throw new ConfigDirectorConnectionError(`Connection failed with fatal error: ${fetchError}. This is an unrecoverable error, retry attempts will be ignored.`);
+		} else if (fetchError instanceof SyntaxError) throw new ConfigDirectorConnectionError(`Failed to parse the response from the server: ${fetchError}`);
+		else throw new ConfigDirectorConnectionError(`Connection failed with error: ${fetchError}.`);
+	}
+	prepareFatalResponseStatusError(responseStatus, errorBody) {
+		const status = responseStatus ?? 0;
+		return new ConfigDirectorConnectionError(`${`Connection failed with status: ${responseStatus ?? "unknown"}`}${(errorBody?.trim()?.length ?? 0) > 0 ? ` (${errorBody})` : ""}. This is an unrecoverable error, retry attempts will be ignored.`, status);
+	}
+	isStatusFatal(status) {
+		return !!status && status >= 400 && status < 500 && status != 429;
+	}
+	isFetchErrorFatal(fetchError) {
+		return fetchError?.name === "NotAllowedError";
+	}
+	get isConnected() {
+		return this.pollingInterval !== void 0;
+	}
+	close() {
+		clearInterval(this.pollingInterval);
+		this.pollingInterval = void 0;
+	}
+	dispose() {
+		this.close();
+		this.clear();
+	}
+};
+//#endregion
+//#region ../shared/src/fetchWithTimeout.ts
+const fetchWithTimeout = async (timeout, resource, options, logger) => {
+	const abortController = new AbortController();
+	const abortTimeoutId = setTimeout(() => {
+		logger.debug("[fetchWithTimeout] Reached timeout, aborting request");
+		abortController.abort();
+	}, timeout);
+	try {
+		const response = await fetch(typeof resource === "string" || resource instanceof Request ? resource : resource.toString(), {
+			...options,
+			signal: abortController.signal
+		});
+		clearTimeout(abortTimeoutId);
+		return response;
+	} catch (error) {
+		logger.warn("[fetchWithTimeout] Fetch error: ", error);
+		clearTimeout(abortTimeoutId);
+		throw error;
+	}
+};
+//#endregion
+//#region ../js-client-core/src/PollingTransport.ts
+var PollingTransport = class extends AbstractPollingTransport {
+	pollingIntervalSeconds;
+	logger;
+	eventEmitter = new Emitter();
+	url;
+	lastUpdateTimestamp;
+	constructor(options) {
+		super();
+		this.options = options;
+		this.options = options;
+		this.logger = options.logger;
+		this.url = options.resolveUrl("client/polling/v1", options.baseUrl);
+		this.pollingIntervalSeconds = options.pollingInterval ?? 60;
+	}
+	async connect(context, timeout) {
+		this.clearPollingInterval();
+		try {
+			await this.fetchConfigs(context, timeout);
+		} finally {
+			if (!this.fatalError) this.schedulePollingInterval(() => {
+				this.fetchConfigs(context, timeout).catch((error) => {
+					this.logger.error("[PollingTransport] Error during polling:", error);
+				});
+			});
+		}
+		return this;
+	}
+	async fetchConfigs(context, timeout) {
+		if (this.fatalError) {
+			this.logger.warn("[PollingTransport] There was a prior unrecoverable error. Ignoring attempt to reconnect.");
+			return;
+		}
+		try {
+			const response = await fetchWithTimeout(timeout, this.url, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					givenContext: context,
+					metaContext: this.options.metaContext,
+					clientSdkKey: this.options.clientSdkKey,
+					instanceId: this.options.instanceId,
+					lastUpdateTimestamp: this.lastUpdateTimestamp
+				})
+			}, this.logger);
+			await this.handleNonOkResponse(response);
+			if (response.status == 200) {
+				const json = JSON.parse(await response.text());
+				this.lastUpdateTimestamp = json.timestamp;
+				this.eventEmitter.emit("configSetReceived", json);
+			}
+		} catch (fetchError) {
+			try {
+				this.handleFetchError(fetchError);
+			} catch (handledError) {
+				if (this.fatalError) this.eventEmitter.emit("connectionError", handledError);
+				throw handledError;
+			}
+		}
+	}
+	on(name, handler) {
+		this.eventEmitter.on(name, handler);
+	}
+	off(name, handler) {
+		this.eventEmitter.off(name, handler);
+	}
+	clear() {
+		this.eventEmitter.clear();
+	}
+};
+//#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 ../js-client-core/src/DefaultConfigDirectorClient.ts
+const MAX_EXPONENTIAL_DELAY = 9;
+var DefaultConfigDirectorClient = class {
+	logger;
+	telemetryClient;
+	configSet;
+	handlersMap = /* @__PURE__ */ new Map();
+	transport;
+	eventEmitter = new Emitter();
+	timeout;
+	timeoutTimer;
+	ready = false;
+	initializing = false;
+	hasReceivedConfigSet = false;
+	readyPromise;
+	readyResolve;
+	currentContext;
+	connectionMode;
+	instanceId;
+	constructor(telemetryClient, clientSdkKey, sdkOptions, clientOptions, internalClientOptions) {
+		this.logger = clientOptions?.logger ?? createDefaultLogger();
+		this.instanceId = resolveInstanceId(this.logger);
+		this.timeout = clientOptions?.connection?.timeout ?? 3e3;
+		this.validateSdkKeyPresence(clientSdkKey);
+		const urlFactory = internalClientOptions?.urlFactory ?? defaultUrlFactory;
+		const baseUrl = this.parseUrl(clientOptions?.connection?.url, urlFactory) ?? "https://client-sdk-api.configdirector.com";
+		this.connectionMode = clientOptions?.connection?.mode ?? "streaming";
+		this.telemetryClient = telemetryClient;
+		this.transport = internalClientOptions?.transport ?? this.buildTransport(clientSdkKey, sdkOptions, baseUrl, urlFactory, clientOptions, internalClientOptions);
+		this.transport.on("configSetReceived", (configSet) => {
+			this.hasReceivedConfigSet = true;
+			this.readyResolve?.();
+			const removedKeys = this.findKeysRemovedBy(configSet);
+			if (!this.configSet || configSet.kind == "full") this.configSet = configSet;
+			else this.configSet.configs = {
+				...this.configSet.configs,
+				...configSet.configs
+			};
+			const keys = Object.keys(configSet.configs);
+			this.emit("configsUpdated", {
+				keys,
+				removedKeys
+			});
+			this.updateWatchers([...keys, ...removedKeys]);
+			this.logger.debug("[ConfigDirectorClient] ConfigSet updated from server:", {
+				keys,
+				removedKeys
+			});
+		});
+		this.transport.on("connectionError", (error) => {
+			this.initializing = false;
+			this.logger.error("[ConfigDirectorClient] The connection encountered an unrecoverable error and will not be retried. Configs will no longer receive updates.", error);
+			this.emit("connectionError", { error });
+		});
+		this.registerHandler("clientReady", clientOptions?.hooks?.clientReady);
+		this.registerHandler("configEvaluated", clientOptions?.hooks?.configEvaluated);
+		this.registerHandler("configsUpdated", clientOptions?.hooks?.configsUpdated);
+		this.registerHandler("contextUpdated", clientOptions?.hooks?.contextUpdated);
+		this.registerHandler("connectionError", clientOptions?.hooks?.connectionError);
+	}
+	registerHandler(event, handler) {
+		if (!handler) return;
+		const handlers = Array.isArray(handler) ? handler : [handler];
+		for (const h of handlers) if (typeof h === "function") this.on(event, h);
+	}
+	resolvePollingIntervalForMode(configuredSeconds) {
+		if (this.connectionMode !== "polling") return;
+		const resolved = resolvePollingInterval(configuredSeconds, {
+			defaultSeconds: 60,
+			minimumSeconds: 30
+		});
+		if (resolved.warning) this.logger.warn(`[ConfigDirectorClient] ${resolved.warning}`);
+		return resolved.seconds;
+	}
+	buildTransport(clientSdkKey, sdkOptions, baseUrl, urlFactory, clientOptions, internalClientOptions) {
+		return new (this.getTransportConstructor(this.connectionMode))({
+			instanceId: this.instanceId,
+			clientSdkKey,
+			baseUrl,
+			resolveUrl: urlFactory,
+			metaContext: {
+				...clientOptions?.metadata,
+				sdkName: sdkOptions.sdkName,
+				sdkVersion: sdkOptions.sdkVersion,
+				userAgent: readUserAgent(),
+				host: readHost()
+			},
+			logger: this.logger,
+			fetch: internalClientOptions?.fetch,
+			connectionRetryDelay: internalClientOptions?.connectionRetryDelay ?? ((attempt) => {
+				return Math.pow(2, Math.min(attempt, MAX_EXPONENTIAL_DELAY)) * 1e3;
+			}),
+			pollingInterval: this.resolvePollingIntervalForMode(clientOptions?.connection?.pollingInterval)
+		});
+	}
+	getTransportConstructor(connectionMode) {
+		switch (connectionMode) {
+			case "polling": return PollingTransport;
+			default: return StreamingTransport;
+		}
+	}
+	async initialize(context) {
+		if (!this.hasReceivedConfigSet) this.initializing = true;
+		await this.connectToTransport(context, "initialization");
+	}
+	async updateContext(context) {
+		await this.connectToTransport(context, "context update");
+	}
+	get context() {
+		return this.currentContext;
+	}
+	async connectToTransport(context, caller) {
+		try {
+			this.ready = false;
+			this.readyPromise = new Promise((resolve) => {
+				this.readyResolve = resolve;
+			}).then((cancelled) => {
+				if (cancelled) return;
+				this.ready = true;
+				this.initializing = false;
+				this.emit("clientReady", { action: caller });
+				this.logger.debug("[ConfigDirectorClient] Received initial payload from the server, client is ready");
+			});
+			const startTime = (/* @__PURE__ */ new Date()).getTime();
+			await this.transport.connect(context ?? {}, this.timeout, caller);
+			this.currentContext = context;
+			this.telemetryClient.updateContext(context);
+			this.emit("contextUpdated", { context });
+			const elapsedTime = (/* @__PURE__ */ new Date()).getTime() - startTime;
+			const remainingTimeout = this.timeout - elapsedTime;
+			clearTimeout(this.timeoutTimer);
+			this.timeoutTimer = void 0;
+			if (remainingTimeout > 0) await Promise.race([this.readyPromise, new Promise((resolve) => {
+				this.timeoutTimer = setTimeout(() => resolve(), remainingTimeout);
+			})]).finally(() => clearTimeout(this.timeoutTimer));
+			if (!this.ready) this.logger.warn(`[ConfigDirectorClient] Timed out waiting for ${caller} after ${this.timeout}ms. The client will continue to retry since there were no fatal errors detected. Configs will return the default value until the connection succeeds.`);
+		} catch (error) {
+			this.logger.error(`[ConfigDirectorClient] An error occurred during ${caller}: `, error);
+		}
+	}
+	findKeysRemovedBy(configSet) {
+		if (!this.configSet || configSet.kind != "full") return [];
+		return Object.keys(this.configSet.configs).filter((key) => !Object.prototype.hasOwnProperty.call(configSet.configs, key));
+	}
+	updateWatchers(configKeys) {
+		configKeys.forEach((configKey) => this.updateWatchersForConfig(configKey));
+	}
+	updateWatchersForConfig(configKey) {
+		const configState = this.configSet?.configs[configKey];
+		this.handlersMap.get(configKey)?.forEach((h) => {
+			const value = this.getValueFromConfigState(configKey, configState, h.defaultValue);
+			h.handler(value);
+		});
+	}
+	watch(configKey, defaultValue, callback) {
+		this.validateDefaultValue(defaultValue);
+		const handlers = this.handlersMap.get(configKey);
+		const handlerWithOptions = {
+			handler: callback,
+			defaultValue,
+			requestedType: typeof defaultValue
+		};
+		if (handlers) handlers.push(handlerWithOptions);
+		else this.handlersMap.set(configKey, [handlerWithOptions]);
+		return () => this.unwatch(configKey, callback);
+	}
+	unwatch(configKey, callback) {
+		const handlers = this.handlersMap.get(configKey);
+		if (!handlers) return;
+		if (callback) {
+			const index = handlers.findIndex((h) => h.handler == callback);
+			if (index >= 0) handlers?.splice(index, 1);
+		} else handlers.splice(0);
+	}
+	getValue(configKey, defaultValue) {
+		this.validateDefaultValue(defaultValue);
+		const configState = this.configSet?.configs[configKey];
+		return this.getValueFromConfigState(configKey, configState, defaultValue);
+	}
+	getValueFromConfigState(configKey, configState, defaultValue) {
+		if (!configState) {
+			this.logger.debug(`[ConfigDirectorClient] No config state found for '${configKey}', returning default value '${defaultValue}'`);
+			const reason = this.isReady ? "config-state-missing" : "client-not-ready";
+			this.telemetryClient.evaluatedConfig({
+				contextId: this.currentContext?.id,
+				key: configKey,
+				defaultValue,
+				requestedType: getRequestedType(defaultValue),
+				evaluatedValue: defaultValue,
+				usedDefault: true,
+				evaluationReason: reason
+			});
+			this.dispatchEvaluationEvent({
+				key: configKey,
+				value: defaultValue,
+				isDefaultValue: true,
+				reason,
+				context: this.context
+			});
+			return defaultValue;
+		}
+		const parseResult = parseConfigValue(configState, defaultValue);
+		this.telemetryClient.evaluatedConfig({
+			contextId: this.currentContext?.id,
+			type: configState.type,
+			key: configKey,
+			defaultValue,
+			requestedType: parseResult.requestedType,
+			evaluatedValue: parseResult.parsedValue,
+			evaluatedValueId: parseResult.parsedValueId,
+			usedDefault: parseResult.usedDefault,
+			evaluationReason: parseResult.reason
+		});
+		this.dispatchEvaluationEvent({
+			key: configKey,
+			value: parseResult.parsedValue,
+			valueId: parseResult.parsedValueId ?? void 0,
+			isDefaultValue: parseResult.usedDefault,
+			reason: parseResult.reason,
+			context: this.context
+		});
+		this.logger.debug(`[ConfigDirectorClient] Evaluated '${configKey}' to '${parseResult.parsedValue}'`);
+		return parseResult.parsedValue;
+	}
+	dispatchEvaluationEvent(event) {
+		setTimeout(() => this.emit("configEvaluated", { evaluation: event }), 0);
+	}
+	emit(name, payload) {
+		try {
+			this.eventEmitter.emit(name, payload);
+		} catch (error) {
+			this.logger.error(`[ConfigDirectorClient] Error executing event handlers for '${name}'`, error);
+		}
+	}
+	parseUrl(url, urlFactory) {
+		if (!url) return;
+		try {
+			return urlFactory(url);
+		} catch (error) {
+			throw new ConfigDirectorValidationError(`Invalid base URL '${url}'. Parsing failed: ${error}`);
+		}
+	}
+	validateSdkKeyPresence(sdkKey) {
+		if (!sdkKey || sdkKey.trim().length == 0) throw new ConfigDirectorValidationError("No client SDK key was provided, the client cannot be instantiated without a valid client SDK key");
+	}
+	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.");
+		if (typeof defaultValue === "function") throw new ConfigDirectorValidationError("Invalid default value. The default value for a config cannot be a function.");
+	}
+	get isReady() {
+		return this.ready;
+	}
+	get isInitializing() {
+		return this.initializing;
+	}
+	on(eventName, handler) {
+		this.eventEmitter.on(eventName, handler);
+	}
+	off(eventName, handler) {
+		this.eventEmitter.off(eventName, handler);
+	}
+	clear() {
+		this.logger.debug("[ConfigDirectorClient] clear() has been called, removing all observers");
+		this.eventEmitter.clear();
+		this.handlersMap.clear();
+	}
+	unwatchAll() {
+		this.handlersMap.clear();
+	}
+	pauseNetwork() {
+		this.logger.debug("[ConfigDirectorClient] pauseNetwork() called, pausing transport connection");
+		clearTimeout(this.timeoutTimer);
+		this.timeoutTimer = void 0;
+		this.transport.close();
+		this.ready = false;
+	}
+	async resumeNetwork() {
+		await this.connectToTransport(this.currentContext, "network resume");
+	}
+	async close() {
+		this.logger.debug("[ConfigDirectorClient] close() has been called, closing connection to server");
+		clearTimeout(this.timeoutTimer);
+		this.readyResolve?.(true);
+		this.telemetryClient.close();
+		this.transport.close();
+		this.ready = false;
+		this.initializing = false;
+	}
+	dispose() {
+		this.clear();
+		this.close();
+	}
+};
+//#endregion
+//#region ../shared/src/testing/values.ts
+const encodeTestValue$1 = (key, value) => {
+	if (key.trim().length == 0) throw new ConfigDirectorValidationError("Invalid config key. The key of a test value cannot be empty.");
+	return encode(key, value);
+};
+const encode = (key, value) => {
+	switch (typeof value) {
+		case "boolean": return {
+			type: "boolean",
+			value: value ? "true" : "false"
+		};
+		case "number": return encodeNumber(key, value);
+		case "string": return {
+			type: "string",
+			value
+		};
+		case "object": if (value !== null) {
+			assertJsonContents(key, value, "");
+			return {
+				type: "json",
+				value: JSON.stringify(value)
+			};
+		}
+	}
+	throw new ConfigDirectorValidationError(`Invalid test value for '${key}': ${describe(value)}. Use a boolean, a number, a string, a plain object, or an array.`);
+};
+const encodeNumber = (key, value) => {
+	if (!Number.isFinite(value)) throw new ConfigDirectorValidationError(`Invalid test value for '${key}': ${describe(value)} is not a finite number.`);
+	if (Number.isInteger(value)) {
+		if (!Number.isSafeInteger(value)) throw new ConfigDirectorValidationError(`Invalid test value for '${key}': ${value} is not a safe integer, so the SDK could not read it back exactly.`);
+		return {
+			type: "integer",
+			value: String(value)
+		};
+	}
+	return {
+		type: "float",
+		value: toPlainDecimal(value)
+	};
+};
+const toPlainDecimal = (value) => {
+	const text = String(value);
+	const exponentIndex = text.indexOf("e-");
+	if (exponentIndex < 0) return text;
+	const sign = text.startsWith("-") ? "-" : "";
+	const [integerDigits = "", fractionDigits = ""] = text.slice(sign.length, exponentIndex).split(".");
+	const leadingZeros = Number(text.slice(exponentIndex + 2)) - integerDigits.length;
+	return `${sign}0.${"0".repeat(leadingZeros)}${integerDigits}${fractionDigits}`;
+};
+const assertJsonContents = (key, value, path) => {
+	if (value === null || typeof value === "boolean" || typeof value === "string") return;
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) throw invalidJsonContents(key, path, `${describe(value)} is not a finite number`);
+		return;
+	}
+	if (Array.isArray(value)) {
+		value.forEach((item, index) => assertJsonContents(key, item, `${path}[${index}]`));
+		return;
+	}
+	if (isPlainObject(value)) {
+		for (const [property, item] of Object.entries(value)) assertJsonContents(key, item, path ? `${path}.${property}` : property);
+		return;
+	}
+	throw invalidJsonContents(key, path, `${describe(value)} cannot be encoded as JSON`);
+};
+const invalidJsonContents = (key, path, problem) => new ConfigDirectorValidationError(`Invalid test value for '${key}'${path ? ` at '${path}'` : ""}: ${problem}. JSON contents can hold booleans, finite numbers, strings, null, arrays, and plain objects.`);
+const isPlainObject = (value) => {
+	if (typeof value !== "object" || value === null) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+};
+const describe = (value) => {
+	if (value === null) return "null";
+	if (typeof value === "function") return "a function";
+	if (typeof value === "object") return `a ${value.constructor?.name ?? "object"} instance`;
+	if (typeof value === "symbol") return "a symbol";
+	return String(value);
+};
+//#endregion
+//#region ../js-client-core/src/testing/values.ts
+const encodeTestValue = (key, value, revision) => {
+	const encoded = encodeTestValue$1(key, value);
+	return {
+		id: `test-config:${key}`,
+		key,
+		type: encoded.type,
+		value: encoded.value,
+		valueId: `test-value:${key}:${revision}`
+	};
+};
+//#endregion
+//#region ../js-client-core/src/testing/InMemoryConnection.ts
+const TEST_ENVIRONMENT = {
+	environmentId: "test-environment",
+	projectId: "test-project"
+};
+const controlledAttemptFor = (reason) => {
+	switch (reason) {
+		case "initialization": return "initialize";
+		case "context update": return "updateContext";
+		default: return;
+	}
+};
+var InMemoryConnection = class {
+	emitter = new Emitter();
+	configs = /* @__PURE__ */ new Map();
+	recordedContexts = [];
+	pendingDeliveries = [];
+	armed = {
+		initialize: "nothing",
+		updateContext: "nothing"
+	};
+	pendingHold;
+	connected = false;
+	delivering = false;
+	revision = 0;
+	attemptGeneration = 0;
+	constructor(logger, values) {
+		this.logger = logger;
+		this.store(values);
+	}
+	get contextUpdates() {
+		return [...this.recordedContexts];
+	}
+	setValue(key, value) {
+		const configState = encodeTestValue(key, value, ++this.revision);
+		this.configs.set(key, configState);
+		this.deliverIfConnected({
+			...TEST_ENVIRONMENT,
+			kind: "delta",
+			configs: { [key]: configState }
+		});
+	}
+	removeValue(key) {
+		this.configs.delete(key);
+		this.deliverIfConnected(this.fullUpdate());
+	}
+	replaceValues(values) {
+		const encoded = this.encodeAll(values);
+		this.configs.clear();
+		encoded.forEach((configState, key) => this.configs.set(key, configState));
+		this.armed.initialize = "nothing";
+		this.armed.updateContext = "nothing";
+		this.deliverIfConnected(this.fullUpdate());
+	}
+	hold(attempt) {
+		this.armed[attempt] = "hold";
+	}
+	complete(attempt) {
+		if (this.pendingHold?.attempt === attempt) this.pendingHold.complete();
+		else if (this.armed[attempt] === "hold") this.armed[attempt] = "nothing";
+	}
+	fail(attempt) {
+		if (this.pendingHold?.attempt === attempt) this.pendingHold.fail();
+		else this.armed[attempt] = "failure";
+	}
+	connect(context, timeout, reason) {
+		this.endAttempt();
+		const attempt = controlledAttemptFor(reason);
+		if (!attempt) return this.connectNow();
+		this.recordedContexts.push(context);
+		const armed = this.armed[attempt];
+		this.armed[attempt] = "nothing";
+		switch (armed) {
+			case "failure": return this.failNow(reason);
+			case "hold": return this.holdNow(attempt, reason, timeout);
+			default: return this.connectNow();
+		}
+	}
+	on = (name, handler) => this.emitter.on(name, handler);
+	off = (name, handler) => this.emitter.off(name, handler);
+	clear() {
+		this.emitter.clear();
+	}
+	close() {
+		this.endAttempt();
+	}
+	dispose() {
+		this.close();
+		this.clear();
+	}
+	endAttempt() {
+		this.attemptGeneration++;
+		this.connected = false;
+		this.pendingHold?.end();
+	}
+	connectNow() {
+		const connected = Promise.resolve(this);
+		this.scheduleFirstDelivery();
+		return connected;
+	}
+	holdNow(attempt, reason, timeout) {
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => this.pendingHold?.end(), timeout);
+			const release = () => {
+				clearTimeout(timer);
+				this.pendingHold = void 0;
+			};
+			this.pendingHold = {
+				attempt,
+				end: () => {
+					release();
+					resolve(this);
+				},
+				complete: () => {
+					release();
+					resolve(this);
+					this.scheduleFirstDelivery();
+				},
+				fail: () => {
+					release();
+					const error = this.fatalError(reason);
+					this.emitter.emit("connectionError", error);
+					reject(error);
+				}
+			};
+		});
+	}
+	failNow(reason) {
+		const error = this.fatalError(reason);
+		this.emitter.emit("connectionError", error);
+		return Promise.reject(error);
+	}
+	fatalError(reason) {
+		return new ConfigDirectorConnectionError(`Connection failed with status: 401. Error: the test client failed this ${reason}. This is an unrecoverable error, will not attempt to reconnect.`, 401);
+	}
+	scheduleFirstDelivery() {
+		const generation = this.attemptGeneration;
+		Promise.resolve().then(() => {}).then(() => {
+			if (generation !== this.attemptGeneration) return;
+			this.connected = true;
+			this.deliver(this.fullUpdate());
+		});
+	}
+	deliverIfConnected(configSet) {
+		if (this.connected) this.deliver(configSet);
+	}
+	deliver(configSet) {
+		this.pendingDeliveries.push(configSet);
+		if (this.delivering) return;
+		this.delivering = true;
+		try {
+			let next = this.pendingDeliveries.shift();
+			while (next) {
+				this.emitCaught(next);
+				next = this.pendingDeliveries.shift();
+			}
+		} finally {
+			this.delivering = false;
+		}
+	}
+	emitCaught(configSet) {
+		try {
+			this.emitter.emit("configSetReceived", configSet);
+		} catch (error) {
+			this.logger.error("[InMemoryConnection] Error dispatching a config update from the test client: ", error);
+		}
+	}
+	fullUpdate() {
+		return {
+			...TEST_ENVIRONMENT,
+			kind: "full",
+			configs: Object.fromEntries(this.configs)
+		};
+	}
+	store(values) {
+		this.encodeAll(values).forEach((configState, key) => this.configs.set(key, configState));
+	}
+	encodeAll(values) {
+		const encoded = /* @__PURE__ */ new Map();
+		for (const [key, value] of Object.entries(values)) encoded.set(key, encodeTestValue(key, value, ++this.revision));
+		return encoded;
+	}
+};
+//#endregion
+//#region ../js-client-core/src/testing/TestClient.ts
+const TEST_CLIENT_SDK_KEY = "test-client";
+const noopTelemetryClient = {
+	updateContext: async () => {},
+	evaluatedConfig: () => {},
+	close: async () => {}
+};
+var InMemoryTestClient = class {
+	constructor(client, connection) {
+		this.client = client;
+		this.connection = connection;
+	}
+	setValue(key, value) {
+		this.connection.setValue(key, value);
+	}
+	removeValue(key) {
+		this.connection.removeValue(key);
+	}
+	replaceValues(values) {
+		this.connection.replaceValues(values);
+	}
+	holdInitialization() {
+		this.connection.hold("initialize");
+	}
+	completeInitialization() {
+		this.connection.complete("initialize");
+	}
+	failInitialization() {
+		this.connection.fail("initialize");
+	}
+	holdContextUpdate() {
+		this.connection.hold("updateContext");
+	}
+	completeContextUpdate() {
+		this.connection.complete("updateContext");
+	}
+	failContextUpdate() {
+		this.connection.fail("updateContext");
+	}
+	get contextUpdates() {
+		return this.connection.contextUpdates;
+	}
+};
+const createTestClient$1 = (sdkOptions, options) => {
+	const logger = options?.logger ?? createDefaultLogger();
+	const connection = new InMemoryConnection(logger, options?.values ?? {});
+	return new InMemoryTestClient(new DefaultConfigDirectorClient(noopTelemetryClient, TEST_CLIENT_SDK_KEY, sdkOptions, {
+		logger,
+		connection: { timeout: options?.timeout }
+	}, { transport: connection }), connection);
+};
+//#endregion
+//#region ../js-client-core/src/installedTestClient.ts
+const INSTALLED_TEST_CLIENT_SLOT = Symbol.for("@configdirector/installed-test-client");
+//#endregion
+//#region ../js-client-core/src/testing/installTestClient.ts
+/**
+* Makes every `ConfigDirectorProvider` mounted without a `client` prop, and every client
+* `withProvider` would build, use `testClient.client` instead of building a client, until the
+* returned function uninstalls it. Construction props such as `sdkKey` are ignored while installed;
+* `context` and `hooks` apply to the installed client as they do for a `client` prop. A provider
+* reads the installed client when it is constructed, so install before rendering.
+*
+* Installing again replaces the installed test client. Each uninstall function restores the test
+* client that was installed when it was created, so nested installs are uninstalled in reverse order.
+*
+* @param testClient The test client whose `client` providers should use
+* @returns A function that uninstalls it
+*
+* @example
+* let uninstallTestClient: () => void;
+* beforeEach(() => {
+*   testClient = createTestClient({ values: { "new-checkout": true } });
+*   uninstallTestClient = installTestClient(testClient);
+* });
+* afterEach(() => uninstallTestClient());
+*/
+const installTestClient = (testClient) => {
+	const slot = globalThis;
+	const previous = slot[INSTALLED_TEST_CLIENT_SLOT];
+	slot[INSTALLED_TEST_CLIENT_SLOT] = testClient.client;
+	return () => {
+		slot[INSTALLED_TEST_CLIENT_SLOT] = previous;
+	};
+};
+//#endregion
+//#region src/testing.ts
+/**
+* Creates a {@link TestClient}: a real `ConfigDirectorClient` connected to an in-memory server
+* that the test controls. No network connection is opened and no telemetry is sent. Hand it to the
+* ConfigDirector Nuxt plugin with `installTestClient` before the Nuxt app is created.
+*
+* @param options {@link TestClientOptions}: the initial values, the client's timeout, and its logger
+* @returns A {@link TestClient} whose `client` the plugin provides to the app
+*
+* @example
+* import { createTestClient, installTestClient } from "@configdirector/nuxt-sdk/testing";
+*
+* const testClient = createTestClient({ values: { "new-checkout": true } });
+* installTestClient(testClient);
+*
+* test("shows the new checkout when the flag is on", async () => {
+*   const component = await mountSuspended(Checkout);
+*   expect(component.text()).toContain("New checkout");
+* });
+*/
+const createTestClient = (options) => {
+	return createTestClient$1({
+		sdkName: "nuxt-sdk",
+		sdkVersion: "1.8.0"
+	}, options);
+};
+//#endregion
+export { ConfigDirectorConnectionError, ConfigDirectorValidationError, createTestClient, installTestClient };