@hexclave/shared 1.0.0

package/dist/interface/client-interface.test.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/interface/client-interface.test.js

@@ -0,0 +1,559 @@
+const require_chunk = require('../chunk-BE-pF4vm.js');
+let vitest = require("vitest");
+let ___utils_results_js = require("../utils/results.js");
+let ___known_errors_js = require("../known-errors.js");
+let ___sessions_js = require("../sessions.js");
+let __client_interface_js = require("./client-interface.js");
+
+//#region src/interface/client-interface.test.ts
+function createClientInterface(options) {
+	const apiUrls = options?.apiUrls ?? [options?.baseUrl ?? "https://api.example.com"];
+	return new __client_interface_js.HexclaveClientInterface({
+		clientVersion: "test",
+		getBaseUrl: () => apiUrls[0],
+		getApiUrls: () => apiUrls,
+		probeRate: options?.probeRate,
+		extraRequestHeaders: {},
+		projectId: "project-id",
+		publishableClientKey: "publishable-client-key"
+	});
+}
+function createSession() {
+	return new ___sessions_js.InternalSession({
+		refreshAccessTokenCallback: async () => null,
+		refreshToken: null,
+		accessToken: null
+	});
+}
+function createJsonResponse(body) {
+	return new Response(JSON.stringify(body), {
+		status: 200,
+		headers: { "Content-Type": "application/json" }
+	});
+}
+function createKnownErrorResponse(error) {
+	return new Response(JSON.stringify({
+		code: error.errorCode,
+		message: error.message,
+		details: error.details
+	}), {
+		status: error.statusCode,
+		headers: {
+			"Content-Type": "application/json",
+			"x-stack-known-error": error.errorCode
+		}
+	});
+}
+function createTextResponse(body, options) {
+	return new Response(body, options);
+}
+function getRequestBody(fetchMock) {
+	const requestInit = fetchMock.mock.calls[0]?.[1];
+	if (requestInit == null || typeof requestInit !== "object" || !("body" in requestInit)) throw new Error("Expected request init to include a body");
+	const requestBody = requestInit.body;
+	if (requestBody == null || typeof requestBody !== "string") throw new Error("Expected request body to be a JSON string");
+	const parsed = JSON.parse(requestBody);
+	if (parsed == null || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("Expected parsed request body to be an object");
+	return parsed;
+}
+(0, vitest.afterEach)(() => {
+	vitest.vi.unstubAllGlobals();
+	vitest.vi.restoreAllMocks();
+});
+(0, vitest.describe)("HexclaveClientInterface bot challenge compatibility", () => {
+	(0, vitest.it)("omits bot challenge from magic link requests when no token is provided", async () => {
+		const fetchMock = vitest.vi.fn(async () => createJsonResponse({ nonce: "nonce" }));
+		vitest.vi.stubGlobal("fetch", fetchMock);
+		await createClientInterface().sendMagicLinkEmail("user@example.com", "https://app.example.com/callback");
+		(0, vitest.expect)(getRequestBody(fetchMock)).toStrictEqual({
+			email: "user@example.com",
+			callback_url: "https://app.example.com/callback"
+		});
+	});
+	(0, vitest.it)("serializes visible bot challenge retry fields for magic link requests", async () => {
+		const fetchMock = vitest.vi.fn(async () => createJsonResponse({ nonce: "nonce" }));
+		vitest.vi.stubGlobal("fetch", fetchMock);
+		await createClientInterface().sendMagicLinkEmail("user@example.com", "https://app.example.com/callback", {
+			token: " visible-token ",
+			phase: "visible"
+		});
+		(0, vitest.expect)(getRequestBody(fetchMock)).toStrictEqual({
+			email: "user@example.com",
+			callback_url: "https://app.example.com/callback",
+			bot_challenge_token: "visible-token",
+			bot_challenge_phase: "visible"
+		});
+	});
+	(0, vitest.it)("serializes bot challenge unavailability for magic link requests", async () => {
+		const fetchMock = vitest.vi.fn(async () => createJsonResponse({ nonce: "nonce" }));
+		vitest.vi.stubGlobal("fetch", fetchMock);
+		await createClientInterface().sendMagicLinkEmail("user@example.com", "https://app.example.com/callback", { phase: "visible" });
+		(0, vitest.expect)(getRequestBody(fetchMock)).toStrictEqual({
+			email: "user@example.com",
+			callback_url: "https://app.example.com/callback",
+			bot_challenge_unavailable: "true"
+		});
+	});
+	(0, vitest.it)("serializes explicit bot challenge unavailability for magic link requests", async () => {
+		const fetchMock = vitest.vi.fn(async () => createJsonResponse({ nonce: "nonce" }));
+		vitest.vi.stubGlobal("fetch", fetchMock);
+		await createClientInterface().sendMagicLinkEmail("user@example.com", "https://app.example.com/callback", { unavailable: true });
+		(0, vitest.expect)(getRequestBody(fetchMock)).toStrictEqual({
+			email: "user@example.com",
+			callback_url: "https://app.example.com/callback",
+			bot_challenge_unavailable: "true"
+		});
+	});
+	(0, vitest.it)("returns BotChallengeFailed as a Result error for magic link requests", async () => {
+		const fetchMock = vitest.vi.fn(async () => createKnownErrorResponse(new ___known_errors_js.KnownErrors.BotChallengeFailed("Visible bot challenge verification failed")));
+		vitest.vi.stubGlobal("fetch", fetchMock);
+		const result = await createClientInterface().sendMagicLinkEmail("user@example.com", "https://app.example.com/callback", { phase: "visible" });
+		(0, vitest.expect)(result.status).toBe("error");
+		if (result.status !== "error") throw new Error("Expected magic link request to fail with BotChallengeFailed");
+		(0, vitest.expect)(result.error).toBeInstanceOf(___known_errors_js.KnownErrors.BotChallengeFailed);
+	});
+	(0, vitest.it)("omits bot challenge from credential signup requests when no token is provided", async () => {
+		const fetchMock = vitest.vi.fn(async () => createJsonResponse({
+			access_token: "access-token",
+			refresh_token: "refresh-token"
+		}));
+		vitest.vi.stubGlobal("fetch", fetchMock);
+		await createClientInterface().signUpWithCredential("user@example.com", "password", void 0, createSession(), void 0);
+		(0, vitest.expect)(getRequestBody(fetchMock)).toStrictEqual({
+			email: "user@example.com",
+			password: "password"
+		});
+	});
+	(0, vitest.it)("returns BotChallengeFailed as a Result error for credential signup requests", async () => {
+		const fetchMock = vitest.vi.fn(async () => createKnownErrorResponse(new ___known_errors_js.KnownErrors.BotChallengeFailed("Visible bot challenge verification failed")));
+		vitest.vi.stubGlobal("fetch", fetchMock);
+		const result = await createClientInterface().signUpWithCredential("user@example.com", "password", void 0, createSession(), { phase: "visible" });
+		(0, vitest.expect)(result.status).toBe("error");
+		if (result.status !== "error") throw new Error("Expected credential signup to fail with BotChallengeFailed");
+		(0, vitest.expect)(result.error).toBeInstanceOf(___known_errors_js.KnownErrors.BotChallengeFailed);
+	});
+	(0, vitest.it)("omits bot challenge from OAuth URLs when no token is provided", async () => {
+		const oauthUrl = await createClientInterface().getOAuthUrl({
+			provider: "github",
+			redirectUrl: "https://app.example.com/oauth/callback",
+			errorRedirectUrl: "https://app.example.com/error",
+			codeChallenge: "code-challenge",
+			state: "state",
+			type: "authenticate",
+			session: createSession()
+		});
+		(0, vitest.expect)(new URL(oauthUrl).searchParams.has("bot_challenge_token")).toBe(false);
+	});
+	(0, vitest.it)("serializes visible bot challenge retry fields in OAuth URLs", async () => {
+		const oauthUrl = await createClientInterface().getOAuthUrl({
+			provider: "github",
+			redirectUrl: "https://app.example.com/oauth/callback",
+			errorRedirectUrl: "https://app.example.com/error",
+			codeChallenge: "code-challenge",
+			state: "state",
+			type: "authenticate",
+			botChallenge: {
+				token: "visible-token",
+				phase: "visible"
+			},
+			session: createSession()
+		});
+		(0, vitest.expect)(Object.fromEntries(new URL(oauthUrl).searchParams.entries())).toMatchObject({
+			bot_challenge_token: "visible-token",
+			bot_challenge_phase: "visible"
+		});
+	});
+	(0, vitest.it)("serializes bot challenge unavailability in OAuth URLs", async () => {
+		const oauthUrl = await createClientInterface().getOAuthUrl({
+			provider: "github",
+			redirectUrl: "https://app.example.com/oauth/callback",
+			errorRedirectUrl: "https://app.example.com/error",
+			codeChallenge: "code-challenge",
+			state: "state",
+			type: "authenticate",
+			botChallenge: { phase: "visible" },
+			session: createSession()
+		});
+		(0, vitest.expect)(Object.fromEntries(new URL(oauthUrl).searchParams.entries())).toMatchObject({ bot_challenge_unavailable: "true" });
+	});
+	(0, vitest.it)("authorizes OAuth via a JSON response instead of relying on manual redirects", async () => {
+		const fetchCalls = [];
+		const fetchMock = vitest.vi.fn(async (input, init) => {
+			fetchCalls.push([input, init]);
+			return createJsonResponse({ location: "https://accounts.example.com/oauth/authorize" });
+		});
+		vitest.vi.stubGlobal("fetch", fetchMock);
+		vitest.vi.stubGlobal("window", {});
+		const result = await createClientInterface().authorizeOAuth({
+			provider: "github",
+			redirectUrl: "https://app.example.com/oauth/callback",
+			errorRedirectUrl: "https://app.example.com/error",
+			codeChallenge: "code-challenge",
+			state: "state",
+			type: "authenticate",
+			session: createSession()
+		});
+		(0, vitest.expect)(___utils_results_js.Result.orThrow(result)).toBe("https://accounts.example.com/oauth/authorize");
+		(0, vitest.expect)(fetchMock).toHaveBeenCalledTimes(1);
+		const [requestUrl, requestInit] = fetchCalls[0] ?? [];
+		if (!(typeof requestUrl === "string" || requestUrl instanceof URL)) throw new Error("Expected authorizeOAuth to call fetch with a URL");
+		(0, vitest.expect)(new URL(requestUrl.toString()).searchParams.get("stack_response_mode")).toBe("json");
+		(0, vitest.expect)(requestInit).toMatchObject({ method: "GET" });
+		(0, vitest.expect)(requestInit).not.toHaveProperty("credentials");
+	});
+	(0, vitest.it)("returns BotChallengeFailed as a Result error for OAuth authorization", async () => {
+		const fetchMock = vitest.vi.fn(async () => createKnownErrorResponse(new ___known_errors_js.KnownErrors.BotChallengeFailed("Visible bot challenge verification failed")));
+		vitest.vi.stubGlobal("fetch", fetchMock);
+		vitest.vi.stubGlobal("window", {});
+		const result = await createClientInterface().authorizeOAuth({
+			provider: "github",
+			redirectUrl: "https://app.example.com/oauth/callback",
+			errorRedirectUrl: "https://app.example.com/error",
+			codeChallenge: "code-challenge",
+			state: "state",
+			type: "authenticate",
+			session: createSession()
+		});
+		(0, vitest.expect)(result.status).toBe("error");
+		if (result.status !== "error") throw new Error("Expected OAuth authorization to fail with BotChallengeFailed");
+		(0, vitest.expect)(result.error).toBeInstanceOf(___known_errors_js.KnownErrors.BotChallengeFailed);
+	});
+	(0, vitest.it)("serializes bot challenge unavailability for credential signup requests", async () => {
+		const fetchMock = vitest.vi.fn(async () => createJsonResponse({
+			access_token: "access-token",
+			refresh_token: "refresh-token"
+		}));
+		vitest.vi.stubGlobal("fetch", fetchMock);
+		await createClientInterface().signUpWithCredential("user@example.com", "password", void 0, createSession(), { phase: "visible" });
+		(0, vitest.expect)(getRequestBody(fetchMock)).toStrictEqual({
+			email: "user@example.com",
+			password: "password",
+			bot_challenge_unavailable: "true"
+		});
+	});
+});
+(0, vitest.describe)("_withFallback", () => {
+	/** Builds a list of N URL bases: ["https://url-0.test", "https://url-1.test", ...] */
+	function urlList(n) {
+		return Array.from({ length: n }, (_, i) => `https://url-${i}.test`);
+	}
+	/** Returns the index of the URL base that `fullUrl` starts with, or -1. */
+	function urlIndex(urls, fullUrl) {
+		return urls.findIndex((base) => fullUrl.startsWith(base));
+	}
+	/** Records every fetch URL and calls `handler` to decide the outcome. */
+	function mockFetch(handler) {
+		const log = [];
+		vitest.vi.stubGlobal("fetch", vitest.vi.fn(async (input) => {
+			const url = input.toString();
+			log.push(url);
+			if (handler(url) === "fail") throw new TypeError("Failed to fetch");
+			return createJsonResponse({ display_name: "test" });
+		}));
+		return log;
+	}
+	function sendRequest(iface) {
+		const session = iface.createSession({
+			refreshToken: null,
+			accessToken: null
+		});
+		return iface.sendClientRequest("/users/me", { method: "GET" }, session);
+	}
+	(0, vitest.it)("single URL uses standard 5-retry behavior", async () => {
+		let attempts = 0;
+		vitest.vi.stubGlobal("fetch", vitest.vi.fn(async () => {
+			attempts++;
+			if (attempts < 3) throw new TypeError("Failed to fetch");
+			return createJsonResponse({ display_name: "test" });
+		}));
+		await sendRequest(createClientInterface({ apiUrls: urlList(1) }));
+		(0, vitest.expect)(attempts).toBe(3);
+	});
+	(0, vitest.it)("uses primary when it is healthy", async () => {
+		const urls = urlList(3);
+		const log = mockFetch(() => "ok");
+		await sendRequest(createClientInterface({ apiUrls: urls }));
+		(0, vitest.expect)(log.every((u) => urlIndex(urls, u) === 0)).toBe(true);
+	});
+	(0, vitest.it)("tries URLs in order and succeeds on first working one", async () => {
+		const urls = urlList(4);
+		const log = mockFetch((u) => urlIndex(urls, u) < 2 ? "fail" : "ok");
+		await sendRequest(createClientInterface({ apiUrls: urls }));
+		(0, vitest.expect)(urlIndex(urls, log[0])).toBe(0);
+		(0, vitest.expect)(urlIndex(urls, log[1])).toBe(1);
+		(0, vitest.expect)(urlIndex(urls, log[2])).toBe(2);
+		(0, vitest.expect)(log.length).toBe(3);
+	});
+	(0, vitest.it)("does not fall back on KnownError", async () => {
+		const urls = urlList(3);
+		const log = [];
+		vitest.vi.stubGlobal("fetch", vitest.vi.fn(async (input) => {
+			log.push(input.toString());
+			return createKnownErrorResponse(new ___known_errors_js.KnownErrors.UserNotFound());
+		}));
+		await (0, vitest.expect)(sendRequest(createClientInterface({ apiUrls: urls }))).rejects.toThrow();
+		(0, vitest.expect)(log.every((u) => urlIndex(urls, u) === 0)).toBe(true);
+	});
+	(0, vitest.it)("does not retry or fall back on non-KnownError 4xx responses", async () => {
+		const urls = urlList(3);
+		const log = [];
+		vitest.vi.stubGlobal("fetch", vitest.vi.fn(async (input) => {
+			log.push(input.toString());
+			return createTextResponse("Payments are not set up", { status: 402 });
+		}));
+		await (0, vitest.expect)(sendRequest(createClientInterface({ apiUrls: urls }))).rejects.toMatchObject({ name: "Error" });
+		(0, vitest.expect)(log.length).toBe(1);
+		(0, vitest.expect)(urlIndex(urls, log[0])).toBe(0);
+	});
+	(0, vitest.it)("wraps non-KnownError 4xx responses as normal errors", async () => {
+		const response = createTextResponse("Payments are not set up", { status: 402 });
+		vitest.vi.stubGlobal("fetch", vitest.vi.fn(async () => response));
+		await (0, vitest.expect)(sendRequest(createClientInterface({ apiUrls: urlList(1) }))).rejects.toMatchObject({
+			name: "Error",
+			message: vitest.expect.stringContaining("402 Payments are not set up"),
+			cause: response
+		});
+	});
+	(0, vitest.it)("does not retry non-KnownError 5xx responses on a single URL", async () => {
+		let attempts = 0;
+		vitest.vi.stubGlobal("fetch", vitest.vi.fn(async () => {
+			attempts++;
+			return createTextResponse("Server unavailable", { status: 503 });
+		}));
+		await (0, vitest.expect)(sendRequest(createClientInterface({ apiUrls: urlList(1) }))).rejects.toThrow("503 Server unavailable");
+		(0, vitest.expect)(attempts).toBe(1);
+	});
+	(0, vitest.it)("falls back on non-KnownError 5xx responses", async () => {
+		const urls = urlList(3);
+		const log = [];
+		vitest.vi.stubGlobal("fetch", vitest.vi.fn(async (input) => {
+			const url = input.toString();
+			log.push(url);
+			if (urlIndex(urls, url) === 0) return createTextResponse("Server unavailable", { status: 503 });
+			return createJsonResponse({ display_name: "test" });
+		}));
+		await sendRequest(createClientInterface({ apiUrls: urls }));
+		(0, vitest.expect)(log.length).toBe(2);
+		(0, vitest.expect)(urlIndex(urls, log[0])).toBe(0);
+		(0, vitest.expect)(urlIndex(urls, log[1])).toBe(1);
+	});
+	(0, vitest.it)("does not fall back on wrapped non-KnownError 4xx refresh token responses", async () => {
+		const urls = urlList(3);
+		const log = [];
+		vitest.vi.stubGlobal("fetch", vitest.vi.fn(async (input) => {
+			const url = input instanceof Request ? input.url : input.toString();
+			log.push(url);
+			return createTextResponse("Payments are not set up", { status: 402 });
+		}));
+		await (0, vitest.expect)(createClientInterface({ apiUrls: urls }).fetchNewAccessToken(new ___sessions_js.RefreshToken("refresh-token"))).rejects.toThrow("Payments are not set up");
+		(0, vitest.expect)(log.length).toBe(1);
+		(0, vitest.expect)(urlIndex(urls, log[0])).toBe(0);
+	});
+	(0, vitest.it)("makes 2 passes × N URLs attempts before throwing", async () => {
+		for (const n of [
+			2,
+			3,
+			5
+		]) {
+			const urls = urlList(n);
+			const log = mockFetch(() => "fail");
+			await (0, vitest.expect)(sendRequest(createClientInterface({ apiUrls: urls }))).rejects.toThrow();
+			(0, vitest.expect)(log.length).toBe(2 * n);
+			for (let i = 0; i < n; i++) (0, vitest.expect)(log.filter((u) => urlIndex(urls, u) === i).length).toBe(2);
+		}
+	});
+	(0, vitest.it)("bypasses fallback when apiUrlOverride is provided", async () => {
+		const log = [];
+		vitest.vi.stubGlobal("fetch", vitest.vi.fn(async (input) => {
+			log.push(input.toString());
+			return createJsonResponse({ display_name: "test" });
+		}));
+		const iface = createClientInterface({ apiUrls: urlList(3) });
+		const session = iface.createSession({
+			refreshToken: null,
+			accessToken: null
+		});
+		await iface.sendClientRequest("/users/me", { method: "GET" }, session, "client", "https://override.test/api/v1");
+		(0, vitest.expect)(log.every((u) => u.startsWith("https://override.test"))).toBe(true);
+	});
+	(0, vitest.it)("enters sticky mode: subsequent requests skip straight to the working fallback", async () => {
+		const urls = urlList(4);
+		const iface = createClientInterface({
+			apiUrls: urls,
+			probeRate: 0
+		});
+		mockFetch((u) => urlIndex(urls, u) === 3 ? "ok" : "fail");
+		await sendRequest(iface);
+		const log = mockFetch(() => "ok");
+		await sendRequest(iface);
+		(0, vitest.expect)(log.length).toBe(1);
+		(0, vitest.expect)(urlIndex(urls, log[0])).toBe(3);
+	});
+	(0, vitest.it)("probes primary and exits sticky mode when probe succeeds", async () => {
+		const urls = urlList(3);
+		const iface = createClientInterface({
+			apiUrls: urls,
+			probeRate: 1
+		});
+		mockFetch((u) => urlIndex(urls, u) === 0 ? "fail" : "ok");
+		await sendRequest(iface);
+		const log = mockFetch(() => "ok");
+		await sendRequest(iface);
+		(0, vitest.expect)(urlIndex(urls, log[0])).toBe(0);
+		const log2 = mockFetch(() => "ok");
+		await sendRequest(iface);
+		(0, vitest.expect)(log2.length).toBe(1);
+		(0, vitest.expect)(urlIndex(urls, log2[0])).toBe(0);
+	});
+	(0, vitest.it)("halves probe rate on each failed probe", async () => {
+		const urls = urlList(2);
+		const iface = createClientInterface({
+			apiUrls: urls,
+			probeRate: 1
+		});
+		mockFetch((u) => urlIndex(urls, u) === 0 ? "fail" : "ok");
+		await sendRequest(iface);
+		mockFetch((u) => urlIndex(urls, u) === 0 ? "fail" : "ok");
+		await sendRequest(iface);
+		const randomMock = vitest.vi.spyOn(Math, "random").mockReturnValue(.4);
+		mockFetch((u) => urlIndex(urls, u) === 0 ? "fail" : "ok");
+		await sendRequest(iface);
+		randomMock.mockReturnValue(.3);
+		const log = mockFetch(() => "ok");
+		await sendRequest(iface);
+		(0, vitest.expect)(log.length).toBe(1);
+		(0, vitest.expect)(urlIndex(urls, log[0])).toBe(1);
+		randomMock.mockRestore();
+	});
+	(0, vitest.it)("falls through to full iteration when sticky URL also goes down", async () => {
+		const urls = urlList(3);
+		const iface = createClientInterface({
+			apiUrls: urls,
+			probeRate: 0
+		});
+		mockFetch((u) => urlIndex(urls, u) === 2 ? "ok" : "fail");
+		await sendRequest(iface);
+		const log = mockFetch((u) => urlIndex(urls, u) === 1 ? "ok" : "fail");
+		await sendRequest(iface);
+		(0, vitest.expect)(log.some((u) => urlIndex(urls, u) === 2)).toBe(true);
+		(0, vitest.expect)(log.some((u) => urlIndex(urls, u) === 1)).toBe(true);
+	});
+	(0, vitest.it)("re-enters sticky on the new working URL after fallthrough", async () => {
+		const urls = urlList(4);
+		const iface = createClientInterface({
+			apiUrls: urls,
+			probeRate: 0
+		});
+		mockFetch((u) => urlIndex(urls, u) === 3 ? "ok" : "fail");
+		await sendRequest(iface);
+		mockFetch((u) => urlIndex(urls, u) === 2 ? "ok" : "fail");
+		await sendRequest(iface);
+		const log = mockFetch(() => "ok");
+		await sendRequest(iface);
+		(0, vitest.expect)(log.length).toBe(1);
+		(0, vitest.expect)(urlIndex(urls, log[0])).toBe(2);
+	});
+	(0, vitest.it)("throws when sticky URL fails and all URLs fail in iteration", async () => {
+		const urls = urlList(3);
+		const iface = createClientInterface({
+			apiUrls: urls,
+			probeRate: 0
+		});
+		mockFetch((u) => urlIndex(urls, u) === 1 ? "ok" : "fail");
+		await sendRequest(iface);
+		const log = mockFetch(() => "fail");
+		await (0, vitest.expect)(sendRequest(iface)).rejects.toThrow();
+		(0, vitest.expect)(log.length).toBe(7);
+	});
+	(0, vitest.it)("does not probe primary when sticky URL fails (probe only before sticky attempt)", async () => {
+		const urls = urlList(3);
+		const iface = createClientInterface({
+			apiUrls: urls,
+			probeRate: 1
+		});
+		mockFetch((u) => urlIndex(urls, u) === 2 ? "ok" : "fail");
+		await sendRequest(iface);
+		const log = mockFetch((u) => urlIndex(urls, u) === 1 ? "ok" : "fail");
+		await sendRequest(iface);
+		const hitOrder = log.map((u) => urlIndex(urls, u));
+		(0, vitest.expect)(hitOrder[0]).toBe(0);
+		(0, vitest.expect)(hitOrder[1]).toBe(2);
+		(0, vitest.expect)(hitOrder).toContain(1);
+	});
+});
+(0, vitest.describe)("sendAnalyticsEventBatch encoding", () => {
+	function captureFetch() {
+		const fetchMock = vitest.vi.fn(async () => createJsonResponse({ inserted: 0 }));
+		vitest.vi.stubGlobal("fetch", fetchMock);
+		return fetchMock;
+	}
+	function getRequestInit(fetchMock) {
+		const init = fetchMock.mock.calls[0]?.[1];
+		if (init == null || typeof init !== "object") throw new Error("expected RequestInit");
+		return init;
+	}
+	async function gunzipToText(body) {
+		if (!(body instanceof Uint8Array)) throw new Error("expected Uint8Array body");
+		const stream = new Blob([body]).stream().pipeThrough(new DecompressionStream("gzip"));
+		return await new Response(stream).text();
+	}
+	(0, vitest.it)("gzips body and sends application/octet-stream when keepalive is false", async () => {
+		const fetchMock = captureFetch();
+		const iface = createClientInterface();
+		const payload = JSON.stringify({
+			batch_id: "abc",
+			events: [{ event_type: "$click" }]
+		});
+		await iface.sendAnalyticsEventBatch(payload, null, { keepalive: false });
+		const init = getRequestInit(fetchMock);
+		(0, vitest.expect)(new Headers(init.headers).get("Content-Type")).toBe("application/octet-stream");
+		(0, vitest.expect)(init.body).toBeInstanceOf(Uint8Array);
+		await (0, vitest.expect)(gunzipToText(init.body)).resolves.toBe(payload);
+	});
+	(0, vitest.it)("falls back to plain JSON when keepalive is true (avoids racing pagehide tear-down)", async () => {
+		const fetchMock = captureFetch();
+		const iface = createClientInterface();
+		const payload = JSON.stringify({
+			batch_id: "abc",
+			events: []
+		});
+		await iface.sendAnalyticsEventBatch(payload, null, { keepalive: true });
+		const init = getRequestInit(fetchMock);
+		(0, vitest.expect)(new Headers(init.headers).get("Content-Type")).toBe("application/json");
+		(0, vitest.expect)(init.body).toBe(payload);
+	});
+	(0, vitest.it)("falls back to plain JSON when CompressionStream is unavailable", async () => {
+		vitest.vi.stubGlobal("CompressionStream", void 0);
+		const fetchMock = captureFetch();
+		const iface = createClientInterface();
+		const payload = JSON.stringify({
+			batch_id: "abc",
+			events: []
+		});
+		await iface.sendAnalyticsEventBatch(payload, null, { keepalive: false });
+		const init = getRequestInit(fetchMock);
+		(0, vitest.expect)(new Headers(init.headers).get("Content-Type")).toBe("application/json");
+		(0, vitest.expect)(init.body).toBe(payload);
+	});
+	(0, vitest.it)("falls back to plain JSON when CompressionStream throws at runtime", async () => {
+		class ThrowingCompressionStream {
+			constructor() {
+				throw new Error("compression unsupported");
+			}
+		}
+		vitest.vi.stubGlobal("CompressionStream", ThrowingCompressionStream);
+		const fetchMock = captureFetch();
+		const iface = createClientInterface();
+		const payload = JSON.stringify({
+			batch_id: "abc",
+			events: []
+		});
+		await iface.sendAnalyticsEventBatch(payload, null, { keepalive: false });
+		const init = getRequestInit(fetchMock);
+		(0, vitest.expect)(new Headers(init.headers).get("Content-Type")).toBe("application/json");
+		(0, vitest.expect)(init.body).toBe(payload);
+	});
+});
+
+//#endregion
+//# sourceMappingURL=client-interface.test.js.map