@replanejs/test-suite 0.8.19

package/dist/index.cjs

@@ -0,0 +1,937 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const vitest = __toESM(require("vitest"));
+const __replanejs_admin = __toESM(require("@replanejs/admin"));
+const __replanejs_sdk = __toESM(require("@replanejs/sdk"));
+
+//#region src/utils.ts
+/**
+* Creates a deferred promise that can be resolved/rejected externally
+*/
+function createDeferred() {
+	let resolve;
+	let reject;
+	const promise = new Promise((res, rej) => {
+		resolve = res;
+		reject = rej;
+	});
+	return {
+		promise,
+		resolve,
+		reject
+	};
+}
+/**
+* Waits for a condition to be met or times out.
+* Returns immediately when condition is satisfied.
+*
+* @example
+* ```ts
+* let value: string | null = null;
+* client.subscribe("config", (v) => { value = v; });
+*
+* await waitFor(() => value !== null, { timeout: 2000 });
+* expect(value).toBe("expected");
+* ```
+*/
+async function waitFor(condition, options = {}) {
+	const { timeout = 5e3, timeoutMessage = "waitFor timed out" } = options;
+	const startTime = Date.now();
+	while (true) {
+		const result = await condition();
+		if (result) return;
+		if (Date.now() - startTime >= timeout) throw new Error(timeoutMessage);
+		await new Promise((resolve) => setTimeout(resolve, 10));
+	}
+}
+function createSignal() {
+	let deferred = createDeferred();
+	let triggered = false;
+	let value;
+	return {
+		wait(options = {}) {
+			const { timeout = 5e3, timeoutMessage = "Signal wait timed out" } = options;
+			return Promise.race([deferred.promise, new Promise((_, reject) => setTimeout(() => reject(new Error(timeoutMessage)), timeout))]);
+		},
+		trigger(v) {
+			if (!triggered) {
+				triggered = true;
+				value = v;
+				deferred.resolve(v);
+			}
+		},
+		isTriggered() {
+			return triggered;
+		},
+		reset() {
+			triggered = false;
+			value = void 0;
+			deferred = createDeferred();
+		},
+		getValue() {
+			return value;
+		}
+	};
+}
+function createCollector() {
+	const values = [];
+	const listeners = [];
+	const notify = () => {
+		for (const listener of listeners) listener();
+	};
+	return {
+		push(value) {
+			values.push(value);
+			notify();
+		},
+		getValues() {
+			return [...values];
+		},
+		count() {
+			return values.length;
+		},
+		async waitForCount(count, options = {}) {
+			const { timeout = 5e3, timeoutMessage = `Collector timed out waiting for ${count} values` } = options;
+			if (values.length >= count) return [...values];
+			return new Promise((resolve, reject) => {
+				const timeoutId = setTimeout(() => {
+					const idx = listeners.indexOf(listener);
+					if (idx !== -1) listeners.splice(idx, 1);
+					reject(new Error(timeoutMessage));
+				}, timeout);
+				const listener = () => {
+					if (values.length >= count) {
+						clearTimeout(timeoutId);
+						const idx = listeners.indexOf(listener);
+						if (idx !== -1) listeners.splice(idx, 1);
+						resolve([...values]);
+					}
+				};
+				listeners.push(listener);
+			});
+		},
+		async waitFor(predicate, options = {}) {
+			const { timeout = 5e3, timeoutMessage = "Collector timed out waiting for matching value" } = options;
+			for (const v of values) if (predicate(v)) return v;
+			return new Promise((resolve, reject) => {
+				const timeoutId = setTimeout(() => {
+					const idx = listeners.indexOf(listener);
+					if (idx !== -1) listeners.splice(idx, 1);
+					reject(new Error(timeoutMessage));
+				}, timeout);
+				const listener = () => {
+					const latest = values[values.length - 1];
+					if (latest !== void 0 && predicate(latest)) {
+						clearTimeout(timeoutId);
+						const idx = listeners.indexOf(listener);
+						if (idx !== -1) listeners.splice(idx, 1);
+						resolve(latest);
+					}
+				};
+				listeners.push(listener);
+			});
+		},
+		clear() {
+			values.length = 0;
+		}
+	};
+}
+/**
+* Delay for a specified time (use sparingly in tests)
+*/
+function delay(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+* Generate a unique test identifier
+*/
+function uniqueId(prefix = "test") {
+	return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+/**
+* Sync the edge replica with the database.
+* Requires TESTING_MODE=true on the server.
+*
+* This is useful in tests to ensure the edge replica has
+* received all config changes before making assertions.
+*
+* @param request - The request object containing the edge API base URL and admin API key
+* @param request.edgeApiBaseUrl - The base URL of the edge API (e.g., "http://localhost:8080")
+* @param request.adminApiKey - The admin API key
+*/
+async function syncReplica(request) {
+	const { edgeApiBaseUrl, sdkKey } = request;
+	const response = await fetch(`${edgeApiBaseUrl}/api/sdk/v1/testing/sync`, {
+		method: "POST",
+		headers: { Authorization: `Bearer ${sdkKey}` }
+	});
+	if (!response.ok) {
+		const body = await response.text();
+		throw new Error(`Failed to sync replica: ${response.status} ${body}`);
+	}
+}
+
+//#endregion
+//#region src/test-suite.ts
+/**
+* Helper to create a literal value for conditions.
+*/
+function literal(value) {
+	return {
+		type: "literal",
+		value
+	};
+}
+const silentLogger = {
+	debug: () => {},
+	info: () => {},
+	warn: () => {},
+	error: () => {}
+};
+/**
+* Creates a test context with helper methods
+*/
+function createTestContext(admin, workspaceId, projectId, environmentId, sdkKey, options) {
+	const defaultTimeout = options.defaultTimeout ?? 1e4;
+	function sync() {
+		return syncReplica({
+			edgeApiBaseUrl: options.edgeApiBaseUrl,
+			sdkKey
+		});
+	}
+	return {
+		admin,
+		workspaceId,
+		projectId,
+		environmentId,
+		sdkKey,
+		edgeApiBaseUrl: options.edgeApiBaseUrl,
+		adminApiBaseUrl: options.adminApiBaseUrl,
+		defaultTimeout,
+		sync,
+		async createClient(clientOptions) {
+			await sync();
+			return (0, __replanejs_sdk.createReplaneClient)({
+				sdkKey,
+				baseUrl: options.edgeApiBaseUrl,
+				logger: silentLogger,
+				initializationTimeoutMs: defaultTimeout,
+				context: clientOptions?.context,
+				defaults: clientOptions?.defaults,
+				required: clientOptions?.required
+			});
+		},
+		async createConfig(name, value, configOptions) {
+			await admin.configs.create({
+				projectId,
+				name,
+				description: configOptions?.description ?? "",
+				editors: [],
+				maintainers: [],
+				base: {
+					value,
+					schema: null,
+					overrides: configOptions?.overrides ?? []
+				},
+				variants: []
+			});
+			await sync();
+		},
+		async updateConfig(name, value, configOptions) {
+			await admin.configs.update({
+				projectId,
+				configName: name,
+				description: configOptions?.description ?? "",
+				editors: [],
+				base: {
+					value,
+					schema: null,
+					overrides: configOptions?.overrides ?? []
+				},
+				variants: []
+			});
+			await sync();
+		},
+		async deleteConfig(name) {
+			await admin.configs.delete({
+				projectId,
+				configName: name
+			});
+			await sync();
+		}
+	};
+}
+/**
+* Main test suite function
+*
+* @example
+* ```ts
+* import { testSuite } from "@replanejs/test-suite";
+*
+* testSuite({
+*   superadminKey: process.env.SUPERADMIN_KEY!,
+*   adminApiBaseUrl: "http://localhost:8080",
+*   edgeApiBaseUrl: "http://localhost:8080",
+* });
+* ```
+*/
+function testSuite(options) {
+	const { superadminKey, adminApiBaseUrl, edgeApiBaseUrl } = options;
+	const defaultTimeout = options.defaultTimeout ?? 1e4;
+	(0, vitest.describe)("Replane E2E Test Suite", () => {
+		let admin;
+		let workspaceId;
+		let projectId;
+		let environmentId;
+		let sdkKey;
+		let ctx;
+		const activeClients = [];
+		(0, vitest.beforeAll)(async () => {
+			admin = new __replanejs_admin.ReplaneAdmin({
+				apiKey: superadminKey,
+				baseUrl: adminApiBaseUrl
+			});
+			const workspaceName = uniqueId("e2e-workspace");
+			const workspaceRes = await admin.workspaces.create({ name: workspaceName });
+			workspaceId = workspaceRes.id;
+			const projectName = uniqueId("e2e-project");
+			const projectRes = await admin.projects.create({
+				workspaceId,
+				name: projectName,
+				description: "E2E test project"
+			});
+			projectId = projectRes.id;
+			const envRes = await admin.environments.list({ projectId });
+			const prodEnv = envRes.environments.find((e) => e.name === "Production") ?? envRes.environments[0];
+			if (!prodEnv) throw new Error("No environments found");
+			environmentId = prodEnv.id;
+			const sdkKeyRes = await admin.sdkKeys.create({
+				projectId,
+				name: uniqueId("e2e-sdk-key"),
+				environmentId
+			});
+			sdkKey = sdkKeyRes.key;
+			await syncReplica({
+				edgeApiBaseUrl,
+				sdkKey
+			});
+			ctx = createTestContext(admin, workspaceId, projectId, environmentId, sdkKey, options);
+		});
+		(0, vitest.afterAll)(async () => {
+			for (const client of activeClients) try {
+				client.close();
+			} catch {}
+			activeClients.length = 0;
+			if (workspaceId) await admin.workspaces.delete({ workspaceId });
+		});
+		const trackClient = (client) => {
+			activeClients.push(client);
+			return client;
+		};
+		(0, vitest.afterEach)(async () => {
+			const configs = await admin.configs.list({ projectId });
+			for (const config of configs.configs) await admin.configs.delete({
+				projectId,
+				configName: config.name
+			});
+			await syncReplica({
+				edgeApiBaseUrl,
+				sdkKey
+			});
+		});
+		(0, vitest.describe)("SDK Connection", () => {
+			(0, vitest.it)("should connect and receive initial configs", async () => {
+				await ctx.createConfig("test-config", "initial-value");
+				const client = trackClient(await ctx.createClient({ required: ["test-config"] }));
+				const value = client.get("test-config");
+				(0, vitest.expect)(value).toBe("initial-value");
+				client.close();
+			});
+			(0, vitest.it)("should handle empty project (no configs)", async () => {
+				const emptyProjectRes = await admin.projects.create({
+					workspaceId,
+					name: uniqueId("empty-project"),
+					description: "Empty project for testing"
+				});
+				const emptyEnvRes = await admin.environments.list({ projectId: emptyProjectRes.id });
+				const emptyEnv = emptyEnvRes.environments[0];
+				const emptySdkKeyRes = await admin.sdkKeys.create({
+					projectId: emptyProjectRes.id,
+					name: uniqueId("empty-sdk-key"),
+					environmentId: emptyEnv.id
+				});
+				await syncReplica({
+					edgeApiBaseUrl,
+					sdkKey
+				});
+				const client = trackClient(await (0, __replanejs_sdk.createReplaneClient)({
+					sdkKey: emptySdkKeyRes.key,
+					baseUrl: edgeApiBaseUrl,
+					logger: silentLogger,
+					initializationTimeoutMs: defaultTimeout
+				}));
+				(0, vitest.expect)(() => client.get("nonexistent")).toThrow();
+				client.close();
+				await admin.projects.delete({ projectId: emptyProjectRes.id });
+			});
+			(0, vitest.it)("should use default values when config not found", async () => {
+				const client = trackClient(await ctx.createClient({ defaults: { "missing-config": "default-value" } }));
+				const value = client.get("missing-config");
+				(0, vitest.expect)(value).toBe("default-value");
+				client.close();
+			});
+			(0, vitest.it)("should throw when required config is missing", { timeout: 15e3 }, async () => {
+				await (0, vitest.expect)(ctx.createClient({ required: ["definitely-missing-config"] })).rejects.toThrow();
+			});
+		});
+		(0, vitest.describe)("Get Config", () => {
+			(0, vitest.it)("should get string config", async () => {
+				await ctx.createConfig("string-config", "hello");
+				const client = trackClient(await ctx.createClient({ required: ["string-config"] }));
+				(0, vitest.expect)(client.get("string-config")).toBe("hello");
+				client.close();
+			});
+			(0, vitest.it)("should get number config", async () => {
+				await ctx.createConfig("number-config", 42);
+				const client = trackClient(await ctx.createClient({ required: ["number-config"] }));
+				(0, vitest.expect)(client.get("number-config")).toBe(42);
+				client.close();
+			});
+			(0, vitest.it)("should get boolean config", async () => {
+				await ctx.createConfig("boolean-config", true);
+				const client = trackClient(await ctx.createClient({ required: ["boolean-config"] }));
+				(0, vitest.expect)(client.get("boolean-config")).toBe(true);
+				client.close();
+			});
+			(0, vitest.it)("should get object config", async () => {
+				const objValue = { nested: { value: "deep" } };
+				await ctx.createConfig("object-config", objValue);
+				const client = trackClient(await ctx.createClient({ required: ["object-config"] }));
+				(0, vitest.expect)(client.get("object-config")).toEqual(objValue);
+				client.close();
+			});
+			(0, vitest.it)("should get array config", async () => {
+				const arrValue = [
+					1,
+					2,
+					3
+				];
+				await ctx.createConfig("array-config", arrValue);
+				const client = trackClient(await ctx.createClient({ required: ["array-config"] }));
+				(0, vitest.expect)(client.get("array-config")).toEqual(arrValue);
+				client.close();
+			});
+			(0, vitest.it)("should get null config", async () => {
+				await ctx.createConfig("null-config", null);
+				const client = trackClient(await ctx.createClient({ required: ["null-config"] }));
+				(0, vitest.expect)(client.get("null-config")).toBe(null);
+				client.close();
+			});
+			(0, vitest.it)("should return default value when config not found", async () => {
+				const client = trackClient(await ctx.createClient());
+				const value = client.get("nonexistent", { default: "fallback" });
+				(0, vitest.expect)(value).toBe("fallback");
+				client.close();
+			});
+			(0, vitest.it)("should throw ReplaneError when config not found and no default", async () => {
+				const client = trackClient(await ctx.createClient());
+				try {
+					client.get("nonexistent");
+					vitest.expect.fail("Should have thrown");
+				} catch (error) {
+					(0, vitest.expect)(error).toBeInstanceOf(__replanejs_sdk.ReplaneError);
+					(0, vitest.expect)(error.code).toBe(__replanejs_sdk.ReplaneErrorCode.NotFound);
+				}
+				client.close();
+			});
+		});
+		(0, vitest.describe)("Real-time Updates", () => {
+			(0, vitest.it)("should receive config updates via subscription", async () => {
+				await ctx.createConfig("live-config", "initial");
+				const client = trackClient(await ctx.createClient({ required: ["live-config"] }));
+				(0, vitest.expect)(client.get("live-config")).toBe("initial");
+				const updateSignal = createSignal();
+				client.subscribe("live-config", (config) => {
+					if (config.value !== "initial") updateSignal.trigger(config.value);
+				});
+				await ctx.updateConfig("live-config", "updated");
+				const newValue = await updateSignal.wait({ timeout: defaultTimeout });
+				(0, vitest.expect)(newValue).toBe("updated");
+				(0, vitest.expect)(client.get("live-config")).toBe("updated");
+				client.close();
+			});
+			(0, vitest.it)("should receive multiple updates in order", async () => {
+				await ctx.createConfig("multi-update-config", 0);
+				const client = trackClient(await ctx.createClient({ required: ["multi-update-config"] }));
+				(0, vitest.expect)(client.get("multi-update-config")).toBe(0);
+				const collector = createCollector();
+				client.subscribe("multi-update-config", (config) => {
+					const val = config.value;
+					if (val > 0) collector.push(val);
+				});
+				await ctx.updateConfig("multi-update-config", 1);
+				await delay(100);
+				await ctx.updateConfig("multi-update-config", 2);
+				await delay(100);
+				await ctx.updateConfig("multi-update-config", 3);
+				const values = await collector.waitForCount(3, { timeout: defaultTimeout });
+				(0, vitest.expect)(values).toEqual([
+					1,
+					2,
+					3
+				]);
+				client.close();
+			});
+			(0, vitest.it)("should handle rapid updates", async () => {
+				await ctx.createConfig("rapid-config", 0);
+				const client = trackClient(await ctx.createClient({ required: ["rapid-config"] }));
+				(0, vitest.expect)(client.get("rapid-config")).toBe(0);
+				const collector = createCollector();
+				client.subscribe("rapid-config", (config) => {
+					collector.push(config.value);
+				});
+				const updateCount = 10;
+				for (let i = 1; i <= updateCount; i++) await ctx.updateConfig("rapid-config", i);
+				await collector.waitFor((v) => v === updateCount, { timeout: defaultTimeout });
+				(0, vitest.expect)(client.get("rapid-config")).toBe(updateCount);
+				client.close();
+			});
+			(0, vitest.it)("should call global subscription for any config change", async () => {
+				await ctx.createConfig("config-a", "a");
+				await ctx.createConfig("config-b", "b");
+				const client = trackClient(await ctx.createClient({ required: ["config-a", "config-b"] }));
+				(0, vitest.expect)(client.get("config-a")).toBe("a");
+				(0, vitest.expect)(client.get("config-b")).toBe("b");
+				const collector = createCollector();
+				client.subscribe((config) => {
+					if (config.value === "a-updated" || config.value === "b-updated") collector.push({
+						name: config.name,
+						value: config.value
+					});
+				});
+				await ctx.updateConfig("config-a", "a-updated");
+				await ctx.updateConfig("config-b", "b-updated");
+				await collector.waitForCount(2, { timeout: defaultTimeout });
+				const values = collector.getValues();
+				const aUpdate = values.find((v) => v.name === "config-a");
+				const bUpdate = values.find((v) => v.name === "config-b");
+				(0, vitest.expect)(aUpdate?.value).toBe("a-updated");
+				(0, vitest.expect)(bUpdate?.value).toBe("b-updated");
+				client.close();
+			});
+			(0, vitest.it)("should allow unsubscribing", async () => {
+				await ctx.createConfig("unsub-config", "initial");
+				const client = trackClient(await ctx.createClient({ required: ["unsub-config"] }));
+				(0, vitest.expect)(client.get("unsub-config")).toBe("initial");
+				const collector = createCollector();
+				const unsubscribe = client.subscribe("unsub-config", (config) => {
+					if (config.value !== "initial") collector.push(config.value);
+				});
+				await ctx.updateConfig("unsub-config", "update-1");
+				await collector.waitForCount(1, { timeout: defaultTimeout });
+				unsubscribe();
+				await ctx.updateConfig("unsub-config", "update-2");
+				await delay(2e3);
+				(0, vitest.expect)(collector.count()).toBe(1);
+				client.close();
+			});
+		});
+		(0, vitest.describe)("Override Evaluation", () => {
+			(0, vitest.it)("should evaluate equals condition", async () => {
+				await ctx.createConfig("env-config", "default", { overrides: [{
+					name: "prod-override",
+					conditions: [{
+						operator: "equals",
+						property: "env",
+						value: literal("production")
+					}],
+					value: "production-value"
+				}] });
+				const client1 = trackClient(await ctx.createClient({ required: ["env-config"] }));
+				(0, vitest.expect)(client1.get("env-config")).toBe("default");
+				client1.close();
+				const client2 = trackClient(await ctx.createClient({
+					context: { env: "production" },
+					required: ["env-config"]
+				}));
+				(0, vitest.expect)(client2.get("env-config")).toBe("production-value");
+				client2.close();
+				const client3 = trackClient(await ctx.createClient({
+					context: { env: "staging" },
+					required: ["env-config"]
+				}));
+				(0, vitest.expect)(client3.get("env-config")).toBe("default");
+				client3.close();
+			});
+			(0, vitest.it)("should evaluate in condition", async () => {
+				await ctx.createConfig("region-config", "default", { overrides: [{
+					name: "western-override",
+					conditions: [{
+						operator: "in",
+						property: "region",
+						value: literal(["us", "eu"])
+					}],
+					value: "western"
+				}] });
+				const client1 = trackClient(await ctx.createClient({
+					context: { region: "us" },
+					required: ["region-config"]
+				}));
+				(0, vitest.expect)(client1.get("region-config")).toBe("western");
+				client1.close();
+				const client2 = trackClient(await ctx.createClient({
+					context: { region: "eu" },
+					required: ["region-config"]
+				}));
+				(0, vitest.expect)(client2.get("region-config")).toBe("western");
+				client2.close();
+				const client3 = trackClient(await ctx.createClient({
+					context: { region: "asia" },
+					required: ["region-config"]
+				}));
+				(0, vitest.expect)(client3.get("region-config")).toBe("default");
+				client3.close();
+			});
+			(0, vitest.it)("should evaluate not_in condition", async () => {
+				await ctx.createConfig("allow-config", "allowed", { overrides: [{
+					name: "not-blocked-override",
+					conditions: [{
+						operator: "not_in",
+						property: "country",
+						value: literal(["blocked1", "blocked2"])
+					}],
+					value: "not-blocked"
+				}] });
+				const client1 = trackClient(await ctx.createClient({
+					context: { country: "blocked1" },
+					required: ["allow-config"]
+				}));
+				(0, vitest.expect)(client1.get("allow-config")).toBe("allowed");
+				client1.close();
+				const client2 = trackClient(await ctx.createClient({
+					context: { country: "normal" },
+					required: ["allow-config"]
+				}));
+				(0, vitest.expect)(client2.get("allow-config")).toBe("not-blocked");
+				client2.close();
+			});
+			(0, vitest.it)("should evaluate numeric comparison conditions", async () => {
+				await ctx.createConfig("tier-config", "free", { overrides: [{
+					name: "premium-override",
+					conditions: [{
+						operator: "greater_than_or_equal",
+						property: "level",
+						value: literal(10)
+					}],
+					value: "premium"
+				}] });
+				const client1 = trackClient(await ctx.createClient({
+					context: { level: 5 },
+					required: ["tier-config"]
+				}));
+				(0, vitest.expect)(client1.get("tier-config")).toBe("free");
+				client1.close();
+				const client2 = trackClient(await ctx.createClient({
+					context: { level: 10 },
+					required: ["tier-config"]
+				}));
+				(0, vitest.expect)(client2.get("tier-config")).toBe("premium");
+				client2.close();
+				const client3 = trackClient(await ctx.createClient({
+					context: { level: 15 },
+					required: ["tier-config"]
+				}));
+				(0, vitest.expect)(client3.get("tier-config")).toBe("premium");
+				client3.close();
+			});
+			(0, vitest.it)("should evaluate and condition", async () => {
+				await ctx.createConfig("combo-config", "default", { overrides: [{
+					name: "combo-override",
+					conditions: [{
+						operator: "and",
+						conditions: [{
+							operator: "equals",
+							property: "plan",
+							value: literal("enterprise")
+						}, {
+							operator: "equals",
+							property: "verified",
+							value: literal(true)
+						}]
+					}],
+					value: "enterprise-verified"
+				}] });
+				const client1 = trackClient(await ctx.createClient({
+					context: {
+						plan: "enterprise",
+						verified: true
+					},
+					required: ["combo-config"]
+				}));
+				(0, vitest.expect)(client1.get("combo-config")).toBe("enterprise-verified");
+				client1.close();
+				const client2 = trackClient(await ctx.createClient({
+					context: {
+						plan: "enterprise",
+						verified: false
+					},
+					required: ["combo-config"]
+				}));
+				(0, vitest.expect)(client2.get("combo-config")).toBe("default");
+				client2.close();
+			});
+			(0, vitest.it)("should evaluate or condition", async () => {
+				await ctx.createConfig("either-config", "default", { overrides: [{
+					name: "privileged-override",
+					conditions: [{
+						operator: "or",
+						conditions: [{
+							operator: "equals",
+							property: "role",
+							value: literal("admin")
+						}, {
+							operator: "equals",
+							property: "role",
+							value: literal("superadmin")
+						}]
+					}],
+					value: "privileged"
+				}] });
+				const client1 = trackClient(await ctx.createClient({
+					context: { role: "admin" },
+					required: ["either-config"]
+				}));
+				(0, vitest.expect)(client1.get("either-config")).toBe("privileged");
+				client1.close();
+				const client2 = trackClient(await ctx.createClient({
+					context: { role: "superadmin" },
+					required: ["either-config"]
+				}));
+				(0, vitest.expect)(client2.get("either-config")).toBe("privileged");
+				client2.close();
+				const client3 = trackClient(await ctx.createClient({
+					context: { role: "user" },
+					required: ["either-config"]
+				}));
+				(0, vitest.expect)(client3.get("either-config")).toBe("default");
+				client3.close();
+			});
+			(0, vitest.it)("should allow per-request context override", async () => {
+				await ctx.createConfig("dynamic-config", "default", { overrides: [{
+					name: "feature-override",
+					conditions: [{
+						operator: "equals",
+						property: "feature",
+						value: literal("enabled")
+					}],
+					value: "feature-on"
+				}] });
+				const client = trackClient(await ctx.createClient({ required: ["dynamic-config"] }));
+				(0, vitest.expect)(client.get("dynamic-config")).toBe("default");
+				(0, vitest.expect)(client.get("dynamic-config", { context: { feature: "enabled" } })).toBe("feature-on");
+				(0, vitest.expect)(client.get("dynamic-config")).toBe("default");
+				client.close();
+			});
+			(0, vitest.it)("should apply first matching override", async () => {
+				await ctx.createConfig("priority-config", "default", { overrides: [
+					{
+						name: "gold-override",
+						conditions: [{
+							operator: "equals",
+							property: "tier",
+							value: literal("gold")
+						}],
+						value: "gold-value"
+					},
+					{
+						name: "silver-override",
+						conditions: [{
+							operator: "equals",
+							property: "tier",
+							value: literal("silver")
+						}],
+						value: "silver-value"
+					},
+					{
+						name: "score-override",
+						conditions: [{
+							operator: "greater_than",
+							property: "score",
+							value: literal(0)
+						}],
+						value: "has-score"
+					}
+				] });
+				const client = trackClient(await ctx.createClient({
+					context: {
+						tier: "gold",
+						score: 100
+					},
+					required: ["priority-config"]
+				}));
+				(0, vitest.expect)(client.get("priority-config")).toBe("gold-value");
+				client.close();
+			});
+		});
+		(0, vitest.describe)("Snapshot", () => {
+			(0, vitest.it)("should create snapshot with current configs", async () => {
+				await ctx.createConfig("snap-config-1", "value-1");
+				await ctx.createConfig("snap-config-2", "value-2");
+				const client = trackClient(await ctx.createClient({ required: ["snap-config-1", "snap-config-2"] }));
+				const snapshot = client.getSnapshot();
+				(0, vitest.expect)(snapshot.configs).toMatchInlineSnapshot(`
+          [
+            {
+              "name": "snap-config-1",
+              "overrides": [],
+              "value": "value-1",
+            },
+            {
+              "name": "snap-config-2",
+              "overrides": [],
+              "value": "value-2",
+            },
+          ]
+        `);
+				(0, vitest.expect)(snapshot.configs.map((c) => c.name).sort()).toEqual(["snap-config-1", "snap-config-2"]);
+				client.close();
+			});
+			(0, vitest.it)("should include context in snapshot", async () => {
+				await ctx.createConfig("ctx-config", "value");
+				const client = trackClient(await ctx.createClient({
+					context: { userId: "123" },
+					required: ["ctx-config"]
+				}));
+				const snapshot = client.getSnapshot();
+				(0, vitest.expect)(snapshot.context).toEqual({ userId: "123" });
+				client.close();
+			});
+		});
+		(0, vitest.describe)("Error Handling", () => {
+			(0, vitest.it)("should throw on invalid SDK key", async () => {
+				await (0, vitest.expect)((0, __replanejs_sdk.createReplaneClient)({
+					sdkKey: "invalid-key",
+					baseUrl: edgeApiBaseUrl,
+					logger: silentLogger,
+					initializationTimeoutMs: 2e3
+				})).rejects.toThrow();
+			});
+			(0, vitest.it)("should handle closed client gracefully", async () => {
+				await ctx.createConfig("close-test", "value");
+				const client = trackClient(await ctx.createClient({ required: ["close-test"] }));
+				(0, vitest.expect)(client.get("close-test")).toBe("value");
+				client.close();
+				const cachedValue = client.get("close-test");
+				(0, vitest.expect)(cachedValue).toBe("value");
+			});
+			(0, vitest.it)("should timeout on unreachable server", async () => {
+				await (0, vitest.expect)((0, __replanejs_sdk.createReplaneClient)({
+					sdkKey: "rp_test",
+					baseUrl: "http://localhost:59999",
+					logger: silentLogger,
+					initializationTimeoutMs: 1e3
+				})).rejects.toThrow();
+			});
+		});
+		(0, vitest.describe)("Config Lifecycle", () => {
+			(0, vitest.it)("should handle config creation after client connects", async () => {
+				const client = trackClient(await ctx.createClient({ defaults: { "late-config": "waiting" } }));
+				const configSignal = createSignal();
+				client.subscribe("late-config", (config) => {
+					configSignal.trigger(config.value);
+				});
+				await ctx.createConfig("late-config", "late-value");
+				const value = await configSignal.wait({ timeout: defaultTimeout });
+				(0, vitest.expect)(value).toBe("late-value");
+				(0, vitest.expect)(client.get("late-config")).toBe("late-value");
+				client.close();
+			});
+			(0, vitest.it)("should ignore config deletion on client", async () => {
+				await ctx.createConfig("delete-me", "exists");
+				const client = trackClient(await ctx.createClient({ required: ["delete-me"] }));
+				(0, vitest.expect)(client.get("delete-me")).toBe("exists");
+				await ctx.deleteConfig("delete-me");
+				await delay(1e3);
+				(0, vitest.expect)(client.get("delete-me")).toBe("exists");
+				client.close();
+			});
+		});
+		(0, vitest.describe)("Concurrent Clients", () => {
+			(0, vitest.it)("should handle multiple clients with same SDK key", async () => {
+				await ctx.createConfig("shared-config", "initial");
+				const client1 = trackClient(await ctx.createClient({ required: ["shared-config"] }));
+				const client2 = trackClient(await ctx.createClient({ required: ["shared-config"] }));
+				(0, vitest.expect)(client1.get("shared-config")).toBe("initial");
+				(0, vitest.expect)(client2.get("shared-config")).toBe("initial");
+				const signal1 = createSignal();
+				const signal2 = createSignal();
+				client1.subscribe("shared-config", (c) => {
+					if (c.value === "updated") signal1.trigger(c.value);
+				});
+				client2.subscribe("shared-config", (c) => {
+					if (c.value === "updated") signal2.trigger(c.value);
+				});
+				await ctx.updateConfig("shared-config", "updated");
+				const [v1, v2] = await Promise.all([signal1.wait({ timeout: defaultTimeout }), signal2.wait({ timeout: defaultTimeout })]);
+				(0, vitest.expect)(v1).toBe("updated");
+				(0, vitest.expect)(v2).toBe("updated");
+				client1.close();
+				client2.close();
+			});
+			(0, vitest.it)("should isolate context between clients", async () => {
+				await ctx.createConfig("context-config", "default", { overrides: [{
+					name: "prod-override",
+					conditions: [{
+						operator: "equals",
+						property: "env",
+						value: literal("prod")
+					}],
+					value: "prod-value"
+				}] });
+				const client1 = trackClient(await ctx.createClient({
+					context: { env: "prod" },
+					required: ["context-config"]
+				}));
+				const client2 = trackClient(await ctx.createClient({
+					context: { env: "dev" },
+					required: ["context-config"]
+				}));
+				(0, vitest.expect)(client1.get("context-config")).toBe("prod-value");
+				(0, vitest.expect)(client2.get("context-config")).toBe("default");
+				client1.close();
+				client2.close();
+			});
+		});
+	});
+}
+
+//#endregion
+exports.createCollector = createCollector;
+exports.createDeferred = createDeferred;
+exports.createSignal = createSignal;
+exports.delay = delay;
+exports.syncReplica = syncReplica;
+exports.testSuite = testSuite;
+exports.uniqueId = uniqueId;
+exports.waitFor = waitFor;