@gscdump/sdk 1.4.0 → 1.4.1

package/dist/v1/index.mjs

@@ -1,1440 +1,3 @@
-import { GSCDUMP_REALTIME_ACK_POLICY, GSCDUMP_REALTIME_CLOSE_CODES, GSCDUMP_REALTIME_CONNECTION_POLICY, GSCDUMP_REALTIME_LIMITS, GSCDUMP_REALTIME_PING, GSCDUMP_REALTIME_PONG, GSCDUMP_REALTIME_SUBPROTOCOL, REALTIME_V1_EVENT_NAMES, REALTIME_V1_RESOURCE_TYPES, buildHttpOperationPath, createGscdumpV1Protocol } from "@gscdump/contracts/v1";
-var GscdumpV1Error = class extends Error {
-	tag = "GscdumpV1Error";
-	code;
-	status;
-	requestId;
-	retryable;
-	details;
-	cause;
-	constructor(options) {
-		super(options.message);
-		this.name = "GscdumpV1Error";
-		this.code = options.code;
-		this.status = options.status;
-		this.requestId = options.requestId;
-		this.retryable = options.retryable;
-		this.details = options.details;
-		this.cause = options.cause;
-	}
-};
-function isGscdumpV1Error(error) {
-	return error instanceof GscdumpV1Error;
-}
-const DEFAULT_API_ROOT = "https://gscdump.com/api";
-const API_PREFIX_RE = /^\/api(?=\/)/;
-const TRAILING_SLASH_RE = /\/+$/;
-const LEADING_SLASH_RE = /^\/+/;
-function validationDetails(cause) {
-	if (typeof cause === "object" && cause !== null && "issues" in cause) return { issues: cause.issues };
-	return {};
-}
-function requestValidationError(operationId, location, cause) {
-	return new GscdumpV1Error({
-		code: "request_validation",
-		message: `${operationId}: invalid request ${location}`,
-		retryable: false,
-		details: {
-			location,
-			...validationDetails(cause)
-		},
-		cause
-	});
-}
-function responseValidationError(operationId, status, requestId, cause) {
-	return new GscdumpV1Error({
-		code: "response_validation",
-		message: `${operationId}: response ${status} did not match the v1 contract`,
-		status,
-		requestId,
-		retryable: false,
-		details: validationDetails(cause),
-		cause
-	});
-}
-function clampInteger(value, fallback, min, max) {
-	if (value === void 0) return fallback;
-	if (!Number.isFinite(value)) throw new TypeError("Retry configuration values must be finite numbers.");
-	return Math.min(max, Math.max(min, Math.trunc(value)));
-}
-function resolveRetryOptions(options) {
-	const baseDelayMs = clampInteger(options?.baseDelayMs, 250, 0, 6e4);
-	const maxDelayMs = clampInteger(options?.maxDelayMs, 2e3, baseDelayMs, 3e5);
-	return {
-		maxAttempts: clampInteger(options?.maxAttempts, 3, 1, 5),
-		baseDelayMs,
-		maxDelayMs
-	};
-}
-function resolveApiUrl(apiRoot, contractPath) {
-	const relative = contractPath.replace(API_PREFIX_RE, "").replace(LEADING_SLASH_RE, "");
-	return `${apiRoot.replace(TRAILING_SLASH_RE, "")}/${relative}`;
-}
-function appendQueryValue(search, key, value) {
-	if (value === void 0) return;
-	if (Array.isArray(value)) {
-		for (const item of value) appendQueryValue(search, key, item);
-		return;
-	}
-	if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-		search.append(key, value === null ? "null" : String(value));
-		return;
-	}
-	search.append(key, JSON.stringify(value));
-}
-function appendQuery(url, query) {
-	if (query === void 0 || query === null) return url;
-	if (typeof query !== "object" || Array.isArray(query)) throw new TypeError("A query schema must produce an object.");
-	const search = new URLSearchParams();
-	for (const key of Object.keys(query).sort()) appendQueryValue(search, key, query[key]);
-	const serialized = search.toString();
-	return serialized ? `${url}?${serialized}` : url;
-}
-function assertAbsentLocation(operationId, location, value) {
-	if (value !== void 0) throw requestValidationError(operationId, location, /* @__PURE__ */ new TypeError(`${location} is not accepted by this operation.`));
-}
-function parseLocation(operation, location, value) {
-	const schema = operation.request[location];
-	if (schema === null) {
-		assertAbsentLocation(operation.id, location, value);
-		return;
-	}
-	try {
-		return schema.parse(location === "headers" && value === void 0 ? {} : value);
-	} catch (cause) {
-		throw requestValidationError(operation.id, location, cause);
-	}
-}
-function prepareRequest(surface, operation, input, options) {
-	let path;
-	if (operation.request.params === null) {
-		assertAbsentLocation(operation.id, "params", input.params);
-		path = buildHttpOperationPath(surface, operation);
-	} else try {
-		path = buildHttpOperationPath(surface, operation, input.params);
-	} catch (cause) {
-		throw requestValidationError(operation.id, "params", cause);
-	}
-	const inputHeaders = input.headers;
-	const headerRequestId = inputHeaders?.["x-request-id"];
-	if (options.requestId && headerRequestId && options.requestId !== headerRequestId) throw requestValidationError(operation.id, "headers", /* @__PURE__ */ new TypeError("requestId conflicts with headers.x-request-id."));
-	const requestHeaders = options.requestId ? {
-		...inputHeaders ?? {},
-		"x-request-id": options.requestId
-	} : input.headers;
-	return {
-		path,
-		query: parseLocation(operation, "query", input.query),
-		headers: parseLocation(operation, "headers", requestHeaders),
-		body: parseLocation(operation, "body", input.body)
-	};
-}
-async function resolveCredential(resolver) {
-	let credential;
-	try {
-		credential = typeof resolver === "function" ? await resolver() : resolver;
-	} catch (cause) {
-		throw new GscdumpV1Error({
-			code: "credential_resolution",
-			message: "Could not resolve the v1 Bearer credential.",
-			retryable: false,
-			details: {},
-			cause
-		});
-	}
-	if (typeof credential !== "string" || !credential.trim()) throw new GscdumpV1Error({
-		code: "credential_resolution",
-		message: "The v1 Bearer credential cannot be empty.",
-		retryable: false,
-		details: {}
-	});
-	return credential;
-}
-async function resolveBaseHeaders(resolver) {
-	return typeof resolver === "function" ? await resolver() : resolver;
-}
-async function buildRequestHeaders(options, operation, prepared, executeOptions) {
-	try {
-		const [baseHeaders, credential] = await Promise.all([resolveBaseHeaders(options.headers), resolveCredential(options.credential)]);
-		const headers = new Headers(baseHeaders);
-		for (const [key, value] of Object.entries(prepared.headers)) if (value !== void 0) headers.set(key, String(value));
-		headers.delete("x-api-key");
-		headers.set("accept", "application/json");
-		headers.set("authorization", `Bearer ${credential}`);
-		if (executeOptions.idempotencyKey) headers.set("idempotency-key", executeOptions.idempotencyKey);
-		if (prepared.body !== void 0) headers.set("content-type", "application/json");
-		return headers;
-	} catch (cause) {
-		if (cause instanceof GscdumpV1Error) throw cause;
-		throw requestValidationError(operation.id, "headers", cause);
-	}
-}
-function isAbortError(error, signal) {
-	return signal?.aborted === true || typeof error === "object" && error !== null && "name" in error && error.name === "AbortError";
-}
-function abortedRequestError(operation, executeOptions, cause = executeOptions.signal?.reason) {
-	return new GscdumpV1Error({
-		code: "aborted",
-		message: `${operation.id}: request aborted`,
-		requestId: executeOptions.requestId,
-		retryable: false,
-		details: {},
-		cause
-	});
-}
-async function waitForRetry(ms, operation, executeOptions) {
-	try {
-		await sleep(ms, executeOptions.signal);
-	} catch (cause) {
-		if (isAbortError(cause, executeOptions.signal)) throw abortedRequestError(operation, executeOptions, cause);
-		throw cause;
-	}
-}
-function awaitWithAbort(promise, operation, executeOptions) {
-	const signal = executeOptions.signal;
-	if (!signal) return promise;
-	if (signal.aborted) return Promise.reject(abortedRequestError(operation, executeOptions));
-	return new Promise((resolve, reject) => {
-		function onAbort() {
-			reject(abortedRequestError(operation, executeOptions));
-		}
-		signal.addEventListener("abort", onAbort, { once: true });
-		promise.then((value) => {
-			signal.removeEventListener("abort", onAbort);
-			resolve(value);
-		}, (cause) => {
-			signal.removeEventListener("abort", onAbort);
-			reject(cause);
-		});
-	});
-}
-function parseRetryAfter(value, now) {
-	if (value === null) return void 0;
-	const seconds = Number(value);
-	if (Number.isFinite(seconds) && seconds >= 0) return Math.ceil(seconds * 1e3);
-	const date = Date.parse(value);
-	if (Number.isNaN(date)) return void 0;
-	return Math.max(0, date - now);
-}
-function retryDelay(attempt, retryAfter, options) {
-	const exponential = Math.min(options.maxDelayMs, options.baseDelayMs * 2 ** Math.max(0, attempt - 1));
-	return Math.max(exponential, parseRetryAfter(retryAfter, Date.now()) ?? 0);
-}
-function sleep(ms, signal) {
-	if (signal?.aborted) return Promise.reject(signal.reason ?? new DOMException("The operation was aborted.", "AbortError"));
-	return new Promise((resolve, reject) => {
-		const handle = setTimeout(() => {
-			signal?.removeEventListener("abort", onAbort);
-			resolve();
-		}, ms);
-		function onAbort() {
-			clearTimeout(handle);
-			reject(signal?.reason ?? new DOMException("The operation was aborted.", "AbortError"));
-		}
-		signal?.addEventListener("abort", onAbort, { once: true });
-	});
-}
-async function readJson(response) {
-	const text = await response.text();
-	if (!text) return null;
-	return JSON.parse(text);
-}
-function requestIdFrom(response) {
-	return response.headers.get("x-request-id") ?? void 0;
-}
-function operationLookup(protocol) {
-	const operations = /* @__PURE__ */ new Map();
-	for (const surface of Object.values(protocol.surfaces)) for (const operation of Object.values(surface.operations)) operations.set(operation.id, {
-		operation,
-		surface
-	});
-	return operations;
-}
-function createGscdumpV1Client(options) {
-	const protocol = createGscdumpV1Protocol();
-	const operations = operationLookup(protocol);
-	const retryOptions = resolveRetryOptions(options.retry);
-	const apiRoot = options.apiRoot ?? DEFAULT_API_ROOT;
-	const fetchImpl = options.fetch ?? globalThis.fetch;
-	if (typeof fetchImpl !== "function") throw new TypeError("createGscdumpV1Client requires a fetch implementation in this runtime.");
-	const execute = executeUntyped;
-	async function executeUntyped(operationId, input, executeOptions = {}) {
-		const entry = operations.get(operationId);
-		if (!entry) throw new GscdumpV1Error({
-			code: "request_validation",
-			message: `Unknown gscdump v1 operation: ${operationId}`,
-			retryable: false,
-			details: { operationId }
-		});
-		const { operation, surface } = entry;
-		if (typeof input !== "object" || input === null || Array.isArray(input)) throw requestValidationError(operation.id, "input", /* @__PURE__ */ new TypeError("input must be an object."));
-		const prepared = prepareRequest(surface, operation, input, executeOptions);
-		let url;
-		try {
-			url = appendQuery(resolveApiUrl(apiRoot, prepared.path), prepared.query);
-		} catch (cause) {
-			throw requestValidationError(operation.id, "query", cause);
-		}
-		const canRetry = operation.semantics.retry === "idempotent";
-		for (let attempt = 1; attempt <= retryOptions.maxAttempts; attempt++) {
-			if (executeOptions.signal?.aborted) throw abortedRequestError(operation, executeOptions);
-			const headers = await awaitWithAbort(buildRequestHeaders(options, operation, prepared, executeOptions), operation, executeOptions);
-			if (executeOptions.signal?.aborted) throw abortedRequestError(operation, executeOptions);
-			let response;
-			try {
-				response = await fetchImpl(url, {
-					method: operation.method,
-					headers,
-					body: prepared.body === void 0 ? void 0 : JSON.stringify(prepared.body),
-					signal: executeOptions.signal
-				});
-			} catch (cause) {
-				if (isAbortError(cause, executeOptions.signal)) throw abortedRequestError(operation, executeOptions, cause);
-				if (canRetry && attempt < retryOptions.maxAttempts) {
-					await waitForRetry(retryDelay(attempt, null, retryOptions), operation, executeOptions);
-					continue;
-				}
-				throw new GscdumpV1Error({
-					code: "network_error",
-					message: `${operation.id}: network request failed`,
-					requestId: executeOptions.requestId,
-					retryable: canRetry,
-					details: { attempts: attempt },
-					cause
-				});
-			}
-			const requestId = requestIdFrom(response) ?? executeOptions.requestId;
-			let payload;
-			try {
-				payload = await readJson(response);
-			} catch (cause) {
-				if (isAbortError(cause, executeOptions.signal)) throw abortedRequestError(operation, executeOptions, cause);
-				throw responseValidationError(operation.id, response.status, requestId, cause);
-			}
-			if (executeOptions.signal?.aborted) throw abortedRequestError(operation, executeOptions);
-			const responseContract = operation.responses[response.status];
-			if (responseContract) try {
-				return responseContract.client.parse(payload);
-			} catch (cause) {
-				throw responseValidationError(operation.id, response.status, requestId, cause);
-			}
-			if (response.ok) throw new GscdumpV1Error({
-				code: "protocol_error",
-				message: `${operation.id}: undeclared success status ${response.status}`,
-				status: response.status,
-				requestId,
-				retryable: false,
-				details: { status: response.status }
-			});
-			let envelope;
-			try {
-				envelope = protocol.schemas.errorEnvelope.client.parse(payload);
-			} catch (cause) {
-				throw responseValidationError(operation.id, response.status, requestId, cause);
-			}
-			if (!operation.errors.includes(envelope.error.code)) throw new GscdumpV1Error({
-				code: "protocol_error",
-				message: `${operation.id}: undeclared error code ${envelope.error.code}`,
-				status: response.status,
-				requestId: envelope.error.requestId,
-				retryable: false,
-				details: { code: envelope.error.code }
-			});
-			const apiError = new GscdumpV1Error({
-				code: envelope.error.code,
-				message: envelope.error.message,
-				status: response.status,
-				requestId: envelope.error.requestId,
-				retryable: envelope.error.retryable,
-				details: envelope.error.details ?? {}
-			});
-			if (canRetry && apiError.retryable && attempt < retryOptions.maxAttempts) {
-				await waitForRetry(retryDelay(attempt, response.headers.get("retry-after"), retryOptions), operation, executeOptions);
-				continue;
-			}
-			throw apiError;
-		}
-		throw new GscdumpV1Error({
-			code: "network_error",
-			message: `${operationId}: retry budget exhausted`,
-			retryable: false,
-			details: {}
-		});
-	}
-	return {
-		execute,
-		getUserLifecycle: (input, executeOptions) => execute("partner.users.lifecycle.get", input, executeOptions),
-		listAvailableSites: (input, executeOptions) => execute("partner.users.sites.available.list", input, executeOptions),
-		createSite: (input, executeOptions) => execute("partner.users.sites.create", input, executeOptions),
-		createUser: (input, executeOptions) => execute("partner.users.create", input, executeOptions),
-		updateUserTokens: (input, executeOptions) => execute("partner.users.tokens.update", input, executeOptions),
-		getSiteIndexing: (input, executeOptions) => execute("partner.sites.indexing.get", input, executeOptions),
-		listSiteIndexingUrls: (input, executeOptions) => execute("partner.sites.indexing.urls.list", input, executeOptions),
-		getSiteIndexingDiagnostics: (input, executeOptions) => execute("partner.sites.indexing.diagnostics.get", input, executeOptions),
-		getSiteSitemaps: (input, executeOptions) => execute("partner.sites.sitemaps.get", input, executeOptions),
-		getSiteSitemapChanges: (input, executeOptions) => execute("partner.sites.sitemaps.changes.get", input, executeOptions),
-		getSiteAnalysis: (input, executeOptions) => execute("partner.sites.analysis.get", input, executeOptions),
-		getSiteAnalysisBundle: (input, executeOptions) => execute("partner.sites.analysis.bundle.get", input, executeOptions),
-		deleteSite: (input, executeOptions) => execute("partner.sites.delete", input, executeOptions),
-		getCanonicalMismatches: (input, executeOptions) => execute("partner.sites.canonical.mismatches.get", input, executeOptions),
-		inspectSiteUrls: (input, executeOptions) => execute("partner.sites.indexing.inspect.create", input, executeOptions),
-		recoverSitePermission: (input, executeOptions) => execute("partner.sites.permission.recover", input, executeOptions),
-		queryKeywordSparklines: (input, executeOptions) => execute("partner.sites.keyword.sparklines.query", input, executeOptions),
-		getQueryTrend: (input, executeOptions) => execute("partner.sites.query.trend.get", input, executeOptions),
-		getPageTrend: (input, executeOptions) => execute("partner.sites.page.trend.get", input, executeOptions),
-		getContentVelocity: (input, executeOptions) => execute("partner.sites.content.velocity.get", input, executeOptions),
-		getCtrCurve: (input, executeOptions) => execute("partner.sites.ctr.curve.get", input, executeOptions),
-		getDarkTraffic: (input, executeOptions) => execute("partner.sites.dark.traffic.get", input, executeOptions),
-		getDeviceGap: (input, executeOptions) => execute("partner.sites.device.gap.get", input, executeOptions),
-		getKeywordBreadth: (input, executeOptions) => execute("partner.sites.keyword.breadth.get", input, executeOptions),
-		getPositionDistribution: (input, executeOptions) => execute("partner.sites.position.distribution.get", input, executeOptions),
-		getTopAssociation: (input, executeOptions) => execute("partner.sites.top.association.get", input, executeOptions),
-		getIndexPercent: (input, executeOptions) => execute("partner.sites.index.percent.get", input, executeOptions),
-		createSitemapAction: (input, executeOptions) => execute("partner.sites.sitemaps.action.create", input, executeOptions),
-		querySitemapMembership: (input, executeOptions) => execute("partner.sites.sitemaps.membership.query", input, executeOptions),
-		createTeam: (input, executeOptions) => execute("partner.teams.create", input, executeOptions),
-		renameTeam: (input, executeOptions) => execute("partner.teams.rename", input, executeOptions),
-		deleteTeam: (input, executeOptions) => execute("partner.teams.delete", input, executeOptions),
-		listTeamMembers: (input, executeOptions) => execute("partner.teams.members.list", input, executeOptions),
-		addTeamMember: (input, executeOptions) => execute("partner.teams.members.add", input, executeOptions),
-		updateTeamMemberRole: (input, executeOptions) => execute("partner.teams.members.role.update", input, executeOptions),
-		removeTeamMember: (input, executeOptions) => execute("partner.teams.members.remove", input, executeOptions),
-		updateSiteTeam: (input, executeOptions) => execute("partner.sites.team.update", input, executeOptions),
-		getTeamCatalog: (input, executeOptions) => execute("partner.teams.catalog.get", input, executeOptions),
-		bindTeamCatalog: (input, executeOptions) => execute("partner.teams.catalog.bind", input, executeOptions),
-		getSiteIntIdCrosswalk: (input, executeOptions) => execute("partner.users.sites.crosswalk.get", input, executeOptions),
-		deleteUser: (input, executeOptions) => execute("partner.users.delete", input, executeOptions),
-		createVerificationToken: (input, executeOptions) => execute("partner.users.verification.token.create", input, executeOptions),
-		addAndVerifySite: (input, executeOptions) => execute("partner.users.sites.verify.create", input, executeOptions),
-		queryCrossSource: (input, executeOptions) => execute("partner.sites.cross.source.query", input, executeOptions),
-		enrichKeywords: (input, executeOptions) => execute("partner.keywords.enrich.query", input, executeOptions),
-		queryAnalyticsRows: (input, executeOptions) => execute("analytics.rows.query", input, executeOptions),
-		queryAnalyticsReport: (input, executeOptions) => execute("analytics.reports.query", input, executeOptions),
-		queryAnalyticsReportDetail: (input, executeOptions) => execute("analytics.reports.detail.query", input, executeOptions),
-		getRealtimeStreamHead: (input = {}, executeOptions) => execute("realtime.stream.head.get", input, executeOptions),
-		createRealtimeTicket: (input, executeOptions) => execute("realtime.tickets.create", input, executeOptions)
-	};
-}
-function utf8Size(value) {
-	let bytes = 0;
-	for (let index = 0; index < value.length; index++) {
-		const code = value.charCodeAt(index);
-		if (code <= 127) bytes++;
-		else if (code <= 2047) bytes += 2;
-		else if (code >= 55296 && code <= 56319 && index + 1 < value.length && value.charCodeAt(index + 1) >= 56320 && value.charCodeAt(index + 1) <= 57343) {
-			bytes += 4;
-			index++;
-		} else bytes += 3;
-	}
-	return bytes;
-}
-const GSCDUMP_REALTIME_V1_SDK_VERSION = "1.4.0";
-var GscdumpRealtimeV1Error = class extends Error {
-	tag = "GscdumpRealtimeV1Error";
-	code;
-	retryable;
-	terminal;
-	details;
-	cause;
-	constructor(options) {
-		super(options.message);
-		this.name = "GscdumpRealtimeV1Error";
-		this.code = options.code;
-		this.retryable = options.retryable;
-		this.terminal = options.terminal;
-		this.details = options.details ?? {};
-		this.cause = options.cause;
-	}
-};
-var StaleEpochError = class extends Error {
-	constructor() {
-		super("The realtime connection epoch is no longer active.");
-		this.name = "StaleEpochError";
-	}
-};
-function createMemoryCursorStore() {
-	let value = null;
-	return {
-		load: () => value,
-		save: (cursor) => {
-			value = { ...cursor };
-		}
-	};
-}
-function defaultRuntime() {
-	return {
-		createSocket(url, protocols) {
-			if (typeof globalThis.WebSocket !== "function") throw new GscdumpRealtimeV1Error({
-				code: "runtime_unavailable",
-				message: "This runtime does not provide WebSocket; inject a realtime runtime port.",
-				retryable: false,
-				terminal: true
-			});
-			return new globalThis.WebSocket(url, [...protocols]);
-		},
-		setTimeout: (handler, ms) => globalThis.setTimeout(handler, ms),
-		clearTimeout: (handle) => globalThis.clearTimeout(handle),
-		random: () => Math.random(),
-		now: () => Date.now()
-	};
-}
-const UTF8_DECODER = new TextDecoder();
-const REALTIME_EVENT_NAMES = new Set(REALTIME_V1_EVENT_NAMES);
-const REALTIME_RESOURCE_TYPES = new Set(REALTIME_V1_RESOURCE_TYPES);
-const APPLIED_EVENT_CACHE_MAX = 1e4;
-async function messageText(raw) {
-	if (typeof raw === "string") return raw;
-	if (raw instanceof ArrayBuffer) return UTF8_DECODER.decode(raw);
-	if (ArrayBuffer.isView(raw)) return UTF8_DECODER.decode(new Uint8Array(raw.buffer, raw.byteOffset, raw.byteLength));
-	if (typeof Blob !== "undefined" && raw instanceof Blob) return raw.text();
-	throw new TypeError("Realtime frames must be text or UTF-8 binary data.");
-}
-function compareSequence(left, right) {
-	const a = BigInt(left);
-	const b = BigInt(right);
-	return a < b ? -1 : a > b ? 1 : 0;
-}
-function nextSequence(sequence) {
-	return (BigInt(sequence) + 1n).toString();
-}
-function laterCursor(left, right) {
-	return compareSequence(left.sequence, right.sequence) >= 0 ? left : right;
-}
-function sameCursor(left, right) {
-	return left?.streamId === right?.streamId && left?.sequence === right?.sequence;
-}
-function parseErrorDetails(cause) {
-	if (typeof cause === "object" && cause !== null && "issues" in cause) return { issues: cause.issues };
-	return {};
-}
-function safeRandom(random) {
-	const value = random();
-	return Number.isFinite(value) ? Math.min(1, Math.max(0, value)) : .5;
-}
-function createGscdumpRealtimeV1Client(options) {
-	const protocol = createGscdumpV1Protocol();
-	const runtime = options.runtime ?? defaultRuntime();
-	const cursorStore = options.cursorStore ?? createMemoryCursorStore();
-	const sdkVersion = options.sdkVersion ?? "1.4.0";
-	if (!sdkVersion) throw new TypeError("sdkVersion cannot be empty.");
-	let running = false;
-	let epoch = 0;
-	let reconnectTimer;
-	let heartbeatTimer;
-	let rotationTimer;
-	let current = null;
-	let immediateExpiredTicketRetry = true;
-	let cursor = null;
-	let streamId = null;
-	let head = null;
-	let attempt = 0;
-	let transport = "idle";
-	let freshness = "unknown";
-	let lastError = null;
-	const eventFailures = /* @__PURE__ */ new Map();
-	const appliedEventIds = /* @__PURE__ */ new Set();
-	const appliedEventOrder = [];
-	let appliedEventCursor = 0;
-	function getSnapshot() {
-		return {
-			transport,
-			freshness,
-			attempt,
-			streamId,
-			cursor: cursor ? { ...cursor } : null,
-			head: head ? { ...head } : null,
-			error: lastError
-		};
-	}
-	function observe(observation) {
-		if (!options.onObservation) return;
-		try {
-			Promise.resolve(options.onObservation(observation)).catch(() => {});
-		} catch {}
-	}
-	function emitState() {
-		observe({
-			type: "state",
-			state: getSnapshot()
-		});
-	}
-	function setState(nextTransport, nextFreshness = freshness) {
-		transport = nextTransport;
-		freshness = nextFreshness;
-		emitState();
-	}
-	function reportError(error) {
-		lastError = error;
-		observe({
-			type: "error",
-			error,
-			state: getSnapshot()
-		});
-		emitState();
-	}
-	function clearTimer(handle) {
-		if (handle !== void 0) runtime.clearTimeout(handle);
-	}
-	function clearConnectionTimers() {
-		clearTimer(heartbeatTimer);
-		clearTimer(rotationTimer);
-		heartbeatTimer = void 0;
-		rotationTimer = void 0;
-	}
-	function ensureEpoch(context) {
-		if (!running || current !== context || context.closed || context.epoch !== epoch) throw new StaleEpochError();
-	}
-	function closeSocket(context, code, reason) {
-		if (context.closed) return;
-		context.closed = true;
-		if (current === context) {
-			current = null;
-			epoch++;
-		}
-		clearConnectionTimers();
-		try {
-			context.socket.close(code, reason);
-		} catch {}
-	}
-	function reconnectBackoff() {
-		const exponent = Math.max(0, attempt - 1);
-		const cap = Math.min(GSCDUMP_REALTIME_CONNECTION_POLICY.reconnectMaxDelayMs, GSCDUMP_REALTIME_CONNECTION_POLICY.reconnectBaseDelayMs * 2 ** exponent);
-		return cap / 2 + safeRandom(runtime.random) * cap / 2;
-	}
-	function scheduleReconnect(context, reason, minimumDelayMs = 0, immediate = false) {
-		if (!running) return;
-		if (context) closeSocket(context, GSCDUMP_REALTIME_CLOSE_CODES.internalError, reason);
-		clearTimer(reconnectTimer);
-		attempt++;
-		const delay = immediate ? minimumDelayMs : Math.max(minimumDelayMs, reconnectBackoff());
-		setState("waiting", freshness === "unknown" || freshness === "degraded" ? freshness : "stale");
-		reconnectTimer = runtime.setTimeout(() => {
-			reconnectTimer = void 0;
-			beginAttempt();
-		}, delay);
-	}
-	function terminal(error, context = current) {
-		running = false;
-		clearTimer(reconnectTimer);
-		reconnectTimer = void 0;
-		if (context) closeSocket(context, GSCDUMP_REALTIME_CLOSE_CODES.normal, "terminal");
-		freshness = "degraded";
-		transport = "terminal";
-		reportError(error);
-	}
-	function assertStream(value, context, label) {
-		if (value.streamId !== context.ticket.head.streamId) throw new GscdumpRealtimeV1Error({
-			code: "protocol_error",
-			message: `${label} did not match the ticket's exact stream.`,
-			retryable: false,
-			terminal: true,
-			details: {
-				expected: context.ticket.head.streamId,
-				received: value.streamId
-			}
-		});
-	}
-	function sendJson(context, value) {
-		ensureEpoch(context);
-		const serialized = JSON.stringify(value);
-		if (utf8Size(serialized) > GSCDUMP_REALTIME_LIMITS.clientFrameMaxBytes) throw new GscdumpRealtimeV1Error({
-			code: "protocol_error",
-			message: "The generated client frame exceeded the v1 size limit.",
-			retryable: false,
-			terminal: true
-		});
-		try {
-			context.socket.send(serialized);
-		} catch (cause) {
-			throw new GscdumpRealtimeV1Error({
-				code: "socket_error",
-				message: "Could not send a realtime client frame.",
-				retryable: true,
-				terminal: false,
-				cause
-			});
-		}
-	}
-	function sendAck(context, appliedCursor) {
-		sendJson(context, protocol.schemas.ackFrame.parse({
-			type: "ack",
-			cursor: appliedCursor
-		}));
-	}
-	function eventDedupeKey(stream, id) {
-		return `${stream}:${id}`;
-	}
-	function rememberEvent(stream, id) {
-		const key = eventDedupeKey(stream, id);
-		if (appliedEventIds.has(key)) return;
-		appliedEventIds.add(key);
-		if (appliedEventOrder.length < APPLIED_EVENT_CACHE_MAX) appliedEventOrder.push(key);
-		else {
-			const oldest = appliedEventOrder[appliedEventCursor];
-			if (oldest) appliedEventIds.delete(oldest);
-			appliedEventOrder[appliedEventCursor] = key;
-			appliedEventCursor = (appliedEventCursor + 1) % APPLIED_EVENT_CACHE_MAX;
-		}
-	}
-	function eventFailureKey(event) {
-		return `${event.cursor?.streamId ?? "ephemeral"}:${event.id}:${event.cursor?.sequence ?? "ephemeral"}`;
-	}
-	function eventForRequiredEffect(event) {
-		return REALTIME_EVENT_NAMES.has(event.name) && event.eventVersion === 1 ? event : {
-			...event,
-			data: null
-		};
-	}
-	function eventAdvisories(event) {
-		if (!REALTIME_EVENT_NAMES.has(event.name)) observe({
-			type: "advisory",
-			code: "unknown_event",
-			event
-		});
-		else if (event.eventVersion !== 1) observe({
-			type: "advisory",
-			code: "unsupported_event_version",
-			event
-		});
-		if (event.changes.some((change) => !REALTIME_RESOURCE_TYPES.has(change.type))) observe({
-			type: "advisory",
-			code: "unknown_resource",
-			event
-		});
-	}
-	async function saveCursor(context, nextCursor) {
-		ensureEpoch(context);
-		await cursorStore.save(nextCursor);
-		ensureEpoch(context);
-	}
-	async function performResync(context, request) {
-		ensureEpoch(context);
-		setState("handshaking", "resyncing");
-		try {
-			await options.resync(request);
-			ensureEpoch(context);
-		} catch (cause) {
-			if (cause instanceof StaleEpochError || !running || current !== context || context.closed) return;
-			terminal(new GscdumpRealtimeV1Error({
-				code: "resync_failed",
-				message: `Realtime resync failed (${request.reason}).`,
-				retryable: false,
-				terminal: true,
-				details: {
-					reason: request.reason,
-					resumeAfter: request.resumeAfter
-				},
-				cause
-			}), context);
-			return;
-		}
-		try {
-			await saveCursor(context, request.resumeAfter);
-		} catch (cause) {
-			if (cause instanceof StaleEpochError || !running || current !== context || context.closed) return;
-			terminal(new GscdumpRealtimeV1Error({
-				code: "cursor_store_failed",
-				message: "Realtime resync completed, but its resume cursor could not be persisted.",
-				retryable: false,
-				terminal: true,
-				details: { resumeAfter: request.resumeAfter },
-				cause
-			}), context);
-			return;
-		}
-		cursor = { ...request.resumeAfter };
-		eventFailures.clear();
-		emitState();
-		scheduleReconnect(context, "resync-complete", 0, true);
-	}
-	async function handleEventFailure(context, event, code, cause) {
-		if (cause instanceof StaleEpochError) return;
-		ensureEpoch(context);
-		const key = eventFailureKey(event);
-		const failures = (eventFailures.get(key) ?? 0) + 1;
-		eventFailures.set(key, failures);
-		const error = new GscdumpRealtimeV1Error({
-			code,
-			message: code === "effect_failed" ? `The required effect rejected for durable event ${event.id}.` : `The cursor store rejected durable event ${event.id}.`,
-			retryable: failures < GSCDUMP_REALTIME_ACK_POLICY.effectRetryBeforeUnsafeResync,
-			terminal: false,
-			details: {
-				eventId: event.id,
-				sequence: event.cursor?.sequence,
-				failures
-			},
-			cause
-		});
-		freshness = "degraded";
-		reportError(error);
-		if (failures < GSCDUMP_REALTIME_ACK_POLICY.effectRetryBeforeUnsafeResync) {
-			scheduleReconnect(context, code);
-			return;
-		}
-		const eventCursor = event.cursor;
-		if (!eventCursor) return;
-		const resumeAfter = context.head ? laterCursor(context.head, eventCursor) : eventCursor;
-		await performResync(context, {
-			reason: "effect_application_failed",
-			source: "client",
-			streamId: eventCursor.streamId,
-			previousCursor: cursor,
-			resumeAfter,
-			failedEvent: event,
-			cause
-		});
-	}
-	async function applyDurableEvent(context, event) {
-		ensureEpoch(context);
-		assertStream(event.cursor, context, "event cursor");
-		if (context.replayThrough && compareSequence(event.cursor.sequence, context.replayThrough.sequence) > 0) throw new GscdumpRealtimeV1Error({
-			code: "protocol_error",
-			message: "A live event arrived before the declared replay completed.",
-			retryable: false,
-			terminal: true
-		});
-		if (!context.replaying && (!context.head || compareSequence(event.cursor.sequence, context.head.sequence) > 0)) {
-			context.head = { ...event.cursor };
-			head = { ...event.cursor };
-		}
-		if (!cursor) {
-			await performResync(context, {
-				reason: "initial_cursor_missing",
-				source: "client",
-				streamId: event.cursor.streamId,
-				previousCursor: null,
-				resumeAfter: context.head ? laterCursor(context.head, event.cursor) : event.cursor
-			});
-			return;
-		}
-		assertStream(cursor, context, "stored cursor");
-		if (compareSequence(event.cursor.sequence, cursor.sequence) <= 0) {
-			sendAck(context, cursor);
-			return;
-		}
-		if (event.cursor.sequence !== nextSequence(cursor.sequence)) {
-			const resumeAfter = context.head ? laterCursor(context.head, event.cursor) : event.cursor;
-			await performResync(context, {
-				reason: "sequence_gap",
-				source: "client",
-				streamId: event.cursor.streamId,
-				previousCursor: cursor,
-				resumeAfter
-			});
-			return;
-		}
-		setState(context.replaying ? "replaying" : "live", "applying");
-		const effectEvent = eventForRequiredEffect(event);
-		if (!appliedEventIds.has(eventDedupeKey(event.cursor.streamId, event.id))) try {
-			await options.applyEvent(effectEvent);
-			ensureEpoch(context);
-		} catch (cause) {
-			await handleEventFailure(context, event, "effect_failed", cause);
-			return;
-		}
-		try {
-			await saveCursor(context, event.cursor);
-		} catch (cause) {
-			await handleEventFailure(context, event, "cursor_store_failed", cause);
-			return;
-		}
-		cursor = { ...event.cursor };
-		rememberEvent(event.cursor.streamId, event.id);
-		eventFailures.delete(eventFailureKey(event));
-		sendAck(context, cursor);
-		freshness = context.replaying ? "stale" : "fresh";
-		transport = context.replaying ? "replaying" : "live";
-		emitState();
-		eventAdvisories(effectEvent);
-		observe({
-			type: "event",
-			event: effectEvent,
-			cursor: { ...cursor }
-		});
-	}
-	function scheduleHeartbeat(context) {
-		clearTimer(heartbeatTimer);
-		heartbeatTimer = runtime.setTimeout(() => {
-			heartbeatTimer = void 0;
-			if (!running || current !== context || context.closed) return;
-			const staleFor = runtime.now() - context.lastPongAt;
-			if (staleFor >= GSCDUMP_REALTIME_CONNECTION_POLICY.staleAfterMs) {
-				const error = new GscdumpRealtimeV1Error({
-					code: "heartbeat_stale",
-					message: "Realtime heartbeat became stale.",
-					retryable: true,
-					terminal: false,
-					details: { staleFor }
-				});
-				freshness = "stale";
-				reportError(error);
-				scheduleReconnect(context, "heartbeat-stale");
-				return;
-			}
-			try {
-				context.socket.send(GSCDUMP_REALTIME_PING);
-			} catch (cause) {
-				reportError(new GscdumpRealtimeV1Error({
-					code: "socket_error",
-					message: "Could not send the realtime heartbeat.",
-					retryable: true,
-					terminal: false,
-					cause
-				}));
-				scheduleReconnect(context, "heartbeat-send");
-				return;
-			}
-			scheduleHeartbeat(context);
-		}, GSCDUMP_REALTIME_CONNECTION_POLICY.heartbeatIntervalMs);
-	}
-	function scheduleRotation(context, expiresAt) {
-		clearTimer(rotationTimer);
-		const delay = Math.max(0, Date.parse(expiresAt) - runtime.now() - GSCDUMP_REALTIME_CONNECTION_POLICY.connectionRefreshBeforeExpiryMs);
-		rotationTimer = runtime.setTimeout(() => {
-			rotationTimer = void 0;
-			if (running && current === context && !context.closed) scheduleReconnect(context, "connection-expiry-rotation", 0, true);
-		}, delay);
-	}
-	async function handleReady(context, frame) {
-		ensureEpoch(context);
-		if (context.ready) throw new GscdumpRealtimeV1Error({
-			code: "protocol_error",
-			message: "The server sent more than one ready frame.",
-			retryable: false,
-			terminal: true
-		});
-		assertStream(frame, context, "ready frame");
-		assertStream(frame.head, context, "ready head");
-		assertStream(frame.replayFloor, context, "ready replay floor");
-		if (compareSequence(frame.head.sequence, context.ticket.head.sequence) < 0) throw new GscdumpRealtimeV1Error({
-			code: "protocol_error",
-			message: "The ready head regressed behind the ticket head.",
-			retryable: false,
-			terminal: true,
-			details: {
-				ticketHead: context.ticket.head,
-				readyHead: frame.head
-			}
-		});
-		const expiresAt = Date.parse(frame.expiresAt);
-		if (!Number.isFinite(expiresAt) || expiresAt <= runtime.now() || expiresAt - runtime.now() > context.ticket.maxConnectionSeconds * 1e3) throw new GscdumpRealtimeV1Error({
-			code: "protocol_error",
-			message: "The ready frame carried an invalid signed connection expiry.",
-			retryable: false,
-			terminal: true,
-			details: { expiresAt: frame.expiresAt }
-		});
-		context.ready = true;
-		context.head = { ...frame.head };
-		context.lastPongAt = runtime.now();
-		head = { ...frame.head };
-		streamId = frame.streamId;
-		attempt = 0;
-		lastError = null;
-		scheduleHeartbeat(context);
-		scheduleRotation(context, frame.expiresAt);
-		if (!cursor) {
-			await performResync(context, {
-				reason: "initial_cursor_missing",
-				source: "client",
-				streamId: frame.streamId,
-				previousCursor: null,
-				resumeAfter: frame.head
-			});
-			return;
-		}
-		if (cursor.streamId !== frame.streamId) {
-			await performResync(context, {
-				reason: "stream_mismatch",
-				source: "client",
-				streamId: frame.streamId,
-				previousCursor: cursor,
-				resumeAfter: frame.head
-			});
-			return;
-		}
-		if (compareSequence(cursor.sequence, frame.head.sequence) > 0) {
-			await performResync(context, {
-				reason: "sequence_gap",
-				source: "client",
-				streamId: frame.streamId,
-				previousCursor: cursor,
-				resumeAfter: frame.head
-			});
-			return;
-		}
-		if (compareSequence(cursor.sequence, frame.replayFloor.sequence) < 0) {
-			await performResync(context, {
-				reason: "cursor_expired",
-				source: "client",
-				streamId: frame.streamId,
-				previousCursor: cursor,
-				resumeAfter: frame.head
-			});
-			return;
-		}
-		if (sameCursor(cursor, frame.head)) {
-			context.replaying = false;
-			setState("live", "fresh");
-		} else {
-			context.replaying = true;
-			setState("replaying", "stale");
-		}
-	}
-	async function processFrame(context, frame) {
-		ensureEpoch(context);
-		if (frame.type === "ready") {
-			await handleReady(context, frame);
-			return;
-		}
-		if (frame.type === "error") {
-			const retryable = !(frame.error.code === "invalid_frame" || frame.error.code === "protocol_mismatch" || frame.error.code === "policy_violation") && frame.error.retryable;
-			const error = new GscdumpRealtimeV1Error({
-				code: frame.error.code === "internal_error" || frame.error.code === "overloaded" ? "socket_error" : "protocol_error",
-				message: frame.error.message,
-				retryable,
-				terminal: !retryable,
-				details: {
-					serverCode: frame.error.code,
-					retryAfter: frame.error.retryAfter
-				}
-			});
-			reportError(error);
-			if (retryable) {
-				context.retryAfterMs = frame.error.retryAfter === void 0 ? void 0 : frame.error.retryAfter * 1e3;
-				scheduleReconnect(context, "server-error", context.retryAfterMs);
-			} else terminal(error, context);
-			return;
-		}
-		if (!context.ready) throw new GscdumpRealtimeV1Error({
-			code: "protocol_error",
-			message: `The server sent ${frame.type} before ready.`,
-			retryable: false,
-			terminal: true
-		});
-		if (frame.type === "replay.begin") {
-			assertStream(frame.through, context, "replay through cursor");
-			if (frame.after) assertStream(frame.after, context, "replay after cursor");
-			if (context.replayThrough) throw new GscdumpRealtimeV1Error({
-				code: "protocol_error",
-				message: "The server sent a nested replay.begin frame.",
-				retryable: false,
-				terminal: true
-			});
-			if (!sameCursor(frame.after, cursor)) {
-				await performResync(context, {
-					reason: "sequence_gap",
-					source: "client",
-					streamId: context.ticket.head.streamId,
-					previousCursor: cursor,
-					resumeAfter: frame.through
-				});
-				return;
-			}
-			if (!context.head || !sameCursor(frame.through, context.head)) throw new GscdumpRealtimeV1Error({
-				code: "protocol_error",
-				message: "The replay boundary did not match the ready head.",
-				retryable: false,
-				terminal: true
-			});
-			context.replaying = true;
-			context.replayThrough = { ...frame.through };
-			setState("replaying", "stale");
-			return;
-		}
-		if (frame.type === "replay.end") {
-			assertStream(frame.through, context, "replay end cursor");
-			if (!context.replaying || !context.replayThrough || !sameCursor(context.replayThrough, frame.through) || !sameCursor(cursor, frame.through)) {
-				await performResync(context, {
-					reason: "sequence_gap",
-					source: "client",
-					streamId: frame.through.streamId,
-					previousCursor: cursor,
-					resumeAfter: context.head ? laterCursor(context.head, frame.through) : frame.through
-				});
-				return;
-			}
-			context.replaying = false;
-			context.replayThrough = null;
-			setState("live", "fresh");
-			return;
-		}
-		if (frame.type === "resync.required") {
-			assertStream(frame.scope, context, "resync scope");
-			assertStream(frame.resumeAfter, context, "resync cursor");
-			const minimumSequence = context.head && cursor ? laterCursor(context.head, cursor).sequence : context.head?.sequence ?? cursor?.sequence;
-			if (minimumSequence !== void 0 && compareSequence(frame.resumeAfter.sequence, minimumSequence) < 0) throw new GscdumpRealtimeV1Error({
-				code: "protocol_error",
-				message: "The resync cursor regressed behind observed stream state.",
-				retryable: false,
-				terminal: true,
-				details: {
-					minimumSequence,
-					resumeAfter: frame.resumeAfter
-				}
-			});
-			await performResync(context, {
-				reason: frame.reason,
-				source: "server",
-				streamId: frame.scope.streamId,
-				previousCursor: cursor,
-				resumeAfter: frame.resumeAfter
-			});
-			return;
-		}
-		if (frame.type === "batch") {
-			if (context.replaying && !context.replayThrough) throw new GscdumpRealtimeV1Error({
-				code: "protocol_error",
-				message: "A replay batch arrived before replay.begin.",
-				retryable: false,
-				terminal: true
-			});
-			for (const event of frame.events) {
-				ensureEpoch(context);
-				await applyDurableEvent(context, event);
-			}
-			return;
-		}
-		if (frame.type === "event") {
-			if (frame.delivery === "ephemeral") {
-				const observedEvent = eventForRequiredEffect(frame);
-				eventAdvisories(observedEvent);
-				observe({
-					type: "event",
-					event: observedEvent,
-					cursor: cursor ? { ...cursor } : null
-				});
-				return;
-			}
-			if (context.replaying && !context.replayThrough) throw new GscdumpRealtimeV1Error({
-				code: "protocol_error",
-				message: "A durable replay event arrived before replay.begin.",
-				retryable: false,
-				terminal: true
-			});
-			await applyDurableEvent(context, frame);
-		}
-	}
-	async function processRawMessage(context, raw) {
-		ensureEpoch(context);
-		const text = await messageText(raw);
-		ensureEpoch(context);
-		if (text === GSCDUMP_REALTIME_PONG) {
-			context.lastPongAt = runtime.now();
-			return;
-		}
-		const textBytes = utf8Size(text);
-		if (textBytes > GSCDUMP_REALTIME_LIMITS.outboundFrameMaxBytes) throw new GscdumpRealtimeV1Error({
-			code: "protocol_error",
-			message: "A server frame exceeded the v1 outbound frame limit.",
-			retryable: false,
-			terminal: true
-		});
-		let rawFrame;
-		try {
-			rawFrame = JSON.parse(text);
-		} catch (cause) {
-			throw new GscdumpRealtimeV1Error({
-				code: "protocol_error",
-				message: "The server sent malformed realtime JSON.",
-				retryable: false,
-				terminal: true,
-				cause
-			});
-		}
-		const parsed = protocol.schemas.serverFrame.safeParse(rawFrame);
-		if (!parsed.success) throw new GscdumpRealtimeV1Error({
-			code: "protocol_error",
-			message: "The server frame did not match the v1 protocol.",
-			retryable: false,
-			terminal: true,
-			details: parseErrorDetails(parsed.error),
-			cause: parsed.error
-		});
-		if (parsed.data.type === "event") {
-			if (textBytes > (parsed.data.delivery === "durable" ? GSCDUMP_REALTIME_LIMITS.durableEventMaxBytes : GSCDUMP_REALTIME_LIMITS.ephemeralEventMaxBytes)) throw new GscdumpRealtimeV1Error({
-				code: "protocol_error",
-				message: `A ${parsed.data.delivery} event exceeded its v1 size limit.`,
-				retryable: false,
-				terminal: true
-			});
-		}
-		if (parsed.data.type === "batch") {
-			for (const event of parsed.data.events) if (utf8Size(JSON.stringify(event)) > GSCDUMP_REALTIME_LIMITS.durableEventMaxBytes) throw new GscdumpRealtimeV1Error({
-				code: "protocol_error",
-				message: "A durable event inside a batch exceeded its v1 size limit.",
-				retryable: false,
-				terminal: true
-			});
-		}
-		await processFrame(context, parsed.data);
-	}
-	function handleFrameQueueError(context, cause) {
-		if (cause instanceof StaleEpochError || !running || current !== context) return;
-		const error = cause instanceof GscdumpRealtimeV1Error ? cause : new GscdumpRealtimeV1Error({
-			code: "protocol_error",
-			message: "Realtime frame processing failed.",
-			retryable: false,
-			terminal: true,
-			cause
-		});
-		if (error.terminal) {
-			terminal(error, context);
-			return;
-		}
-		reportError(error);
-		scheduleReconnect(context, error.code);
-	}
-	async function loadCursor(ticket) {
-		let stored;
-		try {
-			stored = await cursorStore.load();
-		} catch (cause) {
-			throw new GscdumpRealtimeV1Error({
-				code: "cursor_store_failed",
-				message: "Could not load the realtime cursor.",
-				retryable: false,
-				terminal: true,
-				cause
-			});
-		}
-		if (stored === null) return null;
-		const parsed = protocol.schemas.cursor.safeParse(stored);
-		if (!parsed.success) {
-			reportError(new GscdumpRealtimeV1Error({
-				code: "cursor_store_failed",
-				message: "The stored realtime cursor was invalid; a full resync is required.",
-				retryable: true,
-				terminal: false,
-				details: parseErrorDetails(parsed.error),
-				cause: parsed.error
-			}));
-			return null;
-		}
-		if (parsed.data.streamId !== ticket.head.streamId) return null;
-		return parsed.data;
-	}
-	async function provideFreshTicket() {
-		let raw;
-		try {
-			raw = await options.ticketProvider();
-		} catch (cause) {
-			throw new GscdumpRealtimeV1Error({
-				code: "ticket_provider_failed",
-				message: "The realtime ticket provider rejected.",
-				retryable: true,
-				terminal: false,
-				cause
-			});
-		}
-		const parsed = protocol.schemas.ticketResponse.client.safeParse(raw);
-		if (!parsed.success) throw new GscdumpRealtimeV1Error({
-			code: "ticket_invalid",
-			message: "The realtime ticket response did not match the v1 contract.",
-			retryable: false,
-			terminal: true,
-			details: parseErrorDetails(parsed.error),
-			cause: parsed.error
-		});
-		if (Date.parse(parsed.data.data.expiresAt) <= runtime.now()) throw new GscdumpRealtimeV1Error({
-			code: "ticket_invalid",
-			message: "The realtime ticket had already expired locally.",
-			retryable: true,
-			terminal: false,
-			details: { localExpiry: true }
-		});
-		return parsed.data.data;
-	}
-	async function beginAttempt() {
-		if (!running) return;
-		const attemptEpoch = ++epoch;
-		setState("ticketing", freshness === "fresh" ? "stale" : freshness);
-		let ticket;
-		try {
-			ticket = await provideFreshTicket();
-		} catch (cause) {
-			if (!running || epoch !== attemptEpoch) return;
-			const error = cause instanceof GscdumpRealtimeV1Error ? cause : new GscdumpRealtimeV1Error({
-				code: "ticket_provider_failed",
-				message: "Could not obtain a realtime ticket.",
-				retryable: true,
-				terminal: false,
-				cause
-			});
-			if (error.code === "ticket_invalid" && error.details.localExpiry === true && immediateExpiredTicketRetry) {
-				immediateExpiredTicketRetry = false;
-				beginAttempt();
-				return;
-			}
-			reportError(error);
-			if (error.terminal) terminal(error, null);
-			else scheduleReconnect(null, error.code);
-			return;
-		}
-		immediateExpiredTicketRetry = true;
-		if (!running || epoch !== attemptEpoch) return;
-		try {
-			cursor = await loadCursor(ticket);
-		} catch (cause) {
-			if (!running || epoch !== attemptEpoch) return;
-			terminal(cause, null);
-			return;
-		}
-		if (!running || epoch !== attemptEpoch) return;
-		streamId = ticket.head.streamId;
-		head = { ...ticket.head };
-		emitState();
-		let socket;
-		try {
-			socket = runtime.createSocket(ticket.socketUrl, [ticket.protocol, ticket.ticket]);
-		} catch (cause) {
-			terminal(cause instanceof GscdumpRealtimeV1Error ? cause : new GscdumpRealtimeV1Error({
-				code: "runtime_unavailable",
-				message: "Could not create the realtime WebSocket.",
-				retryable: false,
-				terminal: true,
-				cause
-			}), null);
-			return;
-		}
-		const context = {
-			epoch: attemptEpoch,
-			socket,
-			ticket,
-			accepted: false,
-			ready: false,
-			closed: false,
-			replaying: false,
-			replayThrough: null,
-			lastPongAt: runtime.now(),
-			head: null,
-			retryAfterMs: void 0,
-			frameQueue: Promise.resolve()
-		};
-		current = context;
-		setState("connecting", freshness);
-		socket.onopen = () => {
-			if (!running || current !== context || context.closed) return;
-			context.accepted = true;
-			if (socket.protocol !== GSCDUMP_REALTIME_SUBPROTOCOL) {
-				terminal(new GscdumpRealtimeV1Error({
-					code: "protocol_error",
-					message: "The WebSocket did not select gscdump.v1.",
-					retryable: false,
-					terminal: true,
-					details: { selectedProtocol: socket.protocol }
-				}), context);
-				return;
-			}
-			setState("handshaking", cursor ? "stale" : "unknown");
-			try {
-				const hello = protocol.schemas.helloFrame.parse({
-					type: "hello",
-					protocolVersion: protocol.constants.realtimeProtocolVersion,
-					sdkVersion,
-					resume: cursor
-				});
-				sendJson(context, hello);
-			} catch (cause) {
-				handleFrameQueueError(context, cause);
-			}
-		};
-		socket.onmessage = (event) => {
-			if (!running || current !== context || context.closed) return;
-			const work = context.frameQueue.then(() => processRawMessage(context, event.data));
-			context.frameQueue = work.catch((cause) => {
-				handleFrameQueueError(context, cause);
-			});
-		};
-		socket.onerror = (cause) => {
-			if (!running || current !== context || context.closed) return;
-			const error = new GscdumpRealtimeV1Error({
-				code: context.accepted ? "socket_error" : "upgrade_rejected",
-				message: context.accepted ? "The accepted realtime socket emitted an opaque error." : "The realtime WebSocket upgrade was rejected or failed opaquely.",
-				retryable: true,
-				terminal: false,
-				cause
-			});
-			reportError(error);
-			scheduleReconnect(context, error.code);
-		};
-		socket.onclose = (event) => {
-			if (context.closed || current !== context) return;
-			current = null;
-			epoch++;
-			clearConnectionTimers();
-			const code = event.code ?? 1006;
-			if (!running) return;
-			if (!context.accepted) {
-				reportError(new GscdumpRealtimeV1Error({
-					code: "upgrade_rejected",
-					message: "The realtime WebSocket upgrade failed opaquely.",
-					retryable: true,
-					terminal: false,
-					details: { closeCode: code }
-				}));
-				scheduleReconnect(null, "upgrade-rejected");
-				return;
-			}
-			if (code === GSCDUMP_REALTIME_CLOSE_CODES.normal) {
-				running = false;
-				setState("stopped", "unknown");
-				return;
-			}
-			if (code === GSCDUMP_REALTIME_CLOSE_CODES.protocolError || code === GSCDUMP_REALTIME_CLOSE_CODES.policyViolation) {
-				terminal(new GscdumpRealtimeV1Error({
-					code: "protocol_error",
-					message: `The realtime server closed with terminal code ${code}.`,
-					retryable: false,
-					terminal: true,
-					details: {
-						closeCode: code,
-						reason: event.reason
-					}
-				}), null);
-				return;
-			}
-			if (code === GSCDUMP_REALTIME_CLOSE_CODES.maximumLifetime) {
-				scheduleReconnect(null, "maximum-lifetime", 0, true);
-				return;
-			}
-			if (code === 1006 || code === GSCDUMP_REALTIME_CLOSE_CODES.internalError || code === GSCDUMP_REALTIME_CLOSE_CODES.serviceRestart || code === GSCDUMP_REALTIME_CLOSE_CODES.overloadedOrAckLag) {
-				scheduleReconnect(null, `close-${code}`, context.retryAfterMs);
-				return;
-			}
-			terminal(new GscdumpRealtimeV1Error({
-				code: "protocol_error",
-				message: `The realtime server used an unsupported close code ${code}.`,
-				retryable: false,
-				terminal: true,
-				details: {
-					closeCode: code,
-					reason: event.reason
-				}
-			}), null);
-		};
-	}
-	async function start() {
-		if (running) return;
-		running = true;
-		attempt = 0;
-		lastError = null;
-		immediateExpiredTicketRetry = true;
-		freshness = cursor ? "stale" : "unknown";
-		await beginAttempt();
-	}
-	function stop() {
-		running = false;
-		clearTimer(reconnectTimer);
-		reconnectTimer = void 0;
-		if (current) closeSocket(current, GSCDUMP_REALTIME_CLOSE_CODES.normal, "manual");
-		else epoch++;
-		setState("stopped", "unknown");
-	}
-	return {
-		start,
-		stop,
-		getSnapshot
-	};
-}
+import { GscdumpV1Error, createGscdumpV1Client, isGscdumpV1Error } from "./http.mjs";
+import { GSCDUMP_REALTIME_V1_SDK_VERSION, GscdumpRealtimeV1Error, createGscdumpRealtimeV1Client } from "./realtime.mjs";
 export { GSCDUMP_REALTIME_V1_SDK_VERSION, GscdumpRealtimeV1Error, GscdumpV1Error, createGscdumpRealtimeV1Client, createGscdumpV1Client, isGscdumpV1Error };