@gscdump/sdk 0.37.7 → 0.38.1

package/dist/v1/index.mjs

@@ -0,0 +1,1375 @@
+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 headers = new Headers(await resolveBaseHeaders(options.headers));
+		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 ${await resolveCredential(options.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.");
+	async function execute(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),
+		queryAnalyticsRows: (input, executeOptions) => execute("analytics.rows.query", input, executeOptions),
+		getRealtimeStreamHead: (input = {}, executeOptions) => execute("realtime.stream.head.get", input, executeOptions),
+		createRealtimeTicket: (input, executeOptions) => execute("realtime.tickets.create", input, executeOptions)
+	};
+}
+const GSCDUMP_REALTIME_V1_SDK_VERSION = "0.37.7";
+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()
+	};
+}
+function utf8Size(value) {
+	return new TextEncoder().encode(value).byteLength;
+}
+async function messageText(raw) {
+	if (typeof raw === "string") return raw;
+	if (raw instanceof ArrayBuffer) return new TextDecoder().decode(raw);
+	if (ArrayBuffer.isView(raw)) return new TextDecoder().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 ?? "0.37.7";
+	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 = [];
+	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);
+		appliedEventOrder.push(key);
+		if (appliedEventOrder.length > 1e4) {
+			const oldest = appliedEventOrder.shift();
+			if (oldest) appliedEventIds.delete(oldest);
+		}
+	}
+	function eventFailureKey(event) {
+		return `${event.cursor?.streamId ?? "ephemeral"}:${event.id}:${event.cursor?.sequence ?? "ephemeral"}`;
+	}
+	function eventForRequiredEffect(event) {
+		return REALTIME_V1_EVENT_NAMES.includes(event.name) && event.eventVersion === 1 ? event : {
+			...event,
+			data: null
+		};
+	}
+	function eventAdvisories(event) {
+		if (!REALTIME_V1_EVENT_NAMES.includes(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_V1_RESOURCE_TYPES.includes(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;
+		}
+		if (utf8Size(text) > 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") {
+			const eventLimit = parsed.data.delivery === "durable" ? GSCDUMP_REALTIME_LIMITS.durableEventMaxBytes : GSCDUMP_REALTIME_LIMITS.ephemeralEventMaxBytes;
+			if (utf8Size(text) > eventLimit) 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
+	};
+}
+export { GSCDUMP_REALTIME_V1_SDK_VERSION, GscdumpRealtimeV1Error, GscdumpV1Error, createGscdumpRealtimeV1Client, createGscdumpV1Client, isGscdumpV1Error };