@loro-dev/streams-crdt 0.11.1 → 0.12.0

package/dist/{stream-id-fOF9ZqCH.js → stream-id-DVVP3k7V.js}

@@ -135,6 +135,8 @@ const DEFAULT_RECONNECT_CONFIG = {
 	jitterFraction: .2,
 	maxAttempts: Infinity,
 	connectTimeoutMs: 1e4,
+	initialSyncSlowAfterMs: 3e4,
+	initialSyncHardTimeoutMs: 12e4,
 	pollTimeoutMs: 3e4,
 	liveInactivityTimeoutMs: 45e3
 };
@@ -503,6 +505,17 @@ var TimeoutError = class extends Error {
 		this.timeoutMs = timeoutMs;
 	}
 };
+var InitialSyncTimeoutError = class extends Error {
+	operation;
+	timeoutMs;
+	elapsedMs;
+	constructor(operation, timeoutMs, elapsedMs) {
+		super(`initial ${operation} did not complete within ${timeoutMs}ms; the in-flight bootstrap/catch-up request was aborted at the hard timeout`);
+		this.operation = operation;
+		this.timeoutMs = timeoutMs;
+		this.elapsedMs = elapsedMs;
+	}
+};
 var ProtocolError = class extends Error {
 	status;
 	constructor(message, status) {
@@ -673,6 +686,12 @@ function classifyFetchError(err) {
 		retriable: true,
 		atMs: Date.now()
 	};
+	if (err instanceof InitialSyncTimeoutError) return {
+		code: "initial_sync_timeout",
+		message,
+		retriable: true,
+		atMs: Date.now()
+	};
 	if (err instanceof TypeError) return {
 		code: "network",
 		message,
@@ -748,6 +767,14 @@ function toTransportError(error) {
 		phase: error.timeoutType,
 		message: error.message
 	};
+	if (error instanceof InitialSyncTimeoutError) return {
+		code: "initial_sync_timeout",
+		retryable: true,
+		operation: error.operation,
+		timeoutMs: error.timeoutMs,
+		elapsedMs: error.elapsedMs,
+		message: error.message
+	};
 	if (error instanceof HttpError && error.status === 410) return {
 		code: "gone",
 		retryable: true,
@@ -903,9 +930,10 @@ function normalizeShardUrlsOptions(options) {
 		bootstrap: normalizeShardOrigins(options.bootstrap, "shardUrls.bootstrap"),
 		catchup: normalizeShardOrigins(options.catchup, "shardUrls.catchup"),
 		largePost: normalizeShardOrigins(options.largePost, "shardUrls.largePost"),
+		other: normalizeShardOrigins(options.other, "shardUrls.other"),
 		largePostMinBytes
 	};
-	if (normalized.bootstrap == null && normalized.catchup == null && normalized.largePost == null) return;
+	if (normalized.bootstrap == null && normalized.catchup == null && normalized.largePost == null && normalized.other == null) return;
 	return normalized;
 }
 function requestBodyByteLength(body) {
@@ -940,7 +968,9 @@ function normalizedStreamPath(streamUrl) {
 var StreamsTransportClient = class {
 	streamUrl;
 	adapter;
+	streamTtlSeconds;
 	client;
+	initialSyncClient;
 	fetchImpl;
 	authProvider;
 	reconnectConfig;
@@ -950,6 +980,7 @@ var StreamsTransportClient = class {
 	constructor(options) {
 		this.streamUrl = options.streamUrl;
 		this.adapter = options.adapter;
+		this.streamTtlSeconds = normalizeStreamTtlSeconds(options.streamTtlSeconds);
 		this.fetchImpl = options.fetchImpl;
 		this.shardUrls = normalizeShardUrlsOptions(options.shardUrls);
 		this.client = new StreamsClient({
@@ -962,6 +993,16 @@ var StreamsTransportClient = class {
 				pollTimeoutMs: options.reconnectConfig.pollTimeoutMs
 			}
 		});
+		this.initialSyncClient = new StreamsClient({
+			url: options.streamUrl,
+			auth: options.authProvider,
+			fetch: this.fetchRouted.bind(this),
+			retry: { maxAttempts: 0 },
+			timeout: {
+				connectTimeoutMs: 0,
+				pollTimeoutMs: options.reconnectConfig.pollTimeoutMs
+			}
+		});
 		this.authProvider = options.authProvider;
 		this.reconnectConfig = options.reconnectConfig;
 	}
@@ -972,17 +1013,20 @@ var StreamsTransportClient = class {
 		const shardUrls = this.shardUrls;
 		if (shardUrls == null) return input;
 		const operation = this.classifyShardOperation(input, init, shardUrls);
-		if (operation == null) return input;
-		const origins = operation === "bootstrap" ? shardUrls.bootstrap : operation === "catchup" ? shardUrls.catchup : shardUrls.largePost;
+		const origins = this.originsForShardOperation(operation, shardUrls);
 		if (origins == null || origins.length === 0) return input;
 		const target = new URL(input);
-		const shardOrigin = new URL(this.nextShardOrigin(operation, origins));
+		const shardOrigin = new URL(this.nextShardOrigin(operation ?? "other", origins));
 		target.protocol = shardOrigin.protocol;
 		target.host = shardOrigin.host;
 		target.username = "";
 		target.password = "";
 		return target.toString();
 	}
+	originsForShardOperation(operation, shardUrls) {
+		if (operation == null) return shardUrls.other;
+		return (operation === "bootstrap" ? shardUrls.bootstrap : operation === "catchup" ? shardUrls.catchup : shardUrls.largePost) ?? shardUrls.other;
+	}
 	nextShardOrigin(operation, origins) {
 		const currentIndex = this.shardCursorIndexes[operation] ?? createRandomShardStart(origins.length);
 		this.shardCursorIndexes[operation] = (currentIndex + 1) % origins.length;
@@ -1002,7 +1046,10 @@ var StreamsTransportClient = class {
 	}
 	async createStreamRequest() {
 		const adapterHeaders = this.adapter.getCreateStreamHeaders ? await this.adapter.getCreateStreamHeaders() : void 0;
-		const result = await this.client.create({ headers: adapterHeaders });
+		const result = await this.client.create({
+			headers: adapterHeaders,
+			ttlSeconds: this.streamTtlSeconds
+		});
 		if (result.ok) return result.result.created;
 		throw this.toTransportFailure(result.result);
 	}
@@ -1014,8 +1061,8 @@ var StreamsTransportClient = class {
 	async readFromOffsetSseItems(offset, cursor, onControl, onOpen, signal, onActivity) {
 		return this.readItemsSse(offset, cursor, onControl, onOpen, signal, onActivity);
 	}
-	async readFromOffset(offset, cursor, live, signal) {
-		const result = await this.client.readOnce({
+	async readFromOffset(offset, cursor, live, signal, timeoutMode = "default") {
+		const result = await (live == null && timeoutMode === "initial" ? this.initialSyncClient : this.client).readOnce({
 			offset,
 			cursor,
 			live,
@@ -1036,8 +1083,8 @@ var StreamsTransportClient = class {
 			}
 		};
 	}
-	async bootstrap() {
-		const result = await this.client.bootstrap();
+	async bootstrap(signal, timeoutMode = "default") {
+		const result = await (timeoutMode === "initial" ? this.initialSyncClient : this.client).bootstrap({ signal });
 		if (!result.ok) throw this.toTransportFailure(result.result);
 		const snapshot = result.result.snapshotOffset === "-1" ? new Uint8Array() : result.result.snapshot?.body ?? new Uint8Array();
 		return {
@@ -1178,15 +1225,16 @@ var StreamsTransportClient = class {
 		}
 	}
 	async fetchAuthorized(input, init, timeoutMs, phase) {
+		const requestUrl = this.routeRequestUrl(input, init);
 		const firstToken = await this.resolveToken({ reason: "request" });
-		const firstResponse = await this.fetchWithTimeout(input, {
+		const firstResponse = await this.fetchWithTimeout(requestUrl, {
 			...init,
 			headers: this.attachAuthorization(init.headers, firstToken)
 		}, timeoutMs, phase);
 		if (this.authProvider == null || firstResponse.status !== 401 && firstResponse.status !== 403) return firstResponse;
 		await firstResponse.body?.cancel().catch(() => {});
 		const refreshedToken = await this.refreshTokenAfterFailure(firstResponse.status, firstToken);
-		return this.fetchWithTimeout(input, {
+		return this.fetchWithTimeout(requestUrl, {
 			...init,
 			headers: this.attachAuthorization(init.headers, refreshedToken)
 		}, timeoutMs, phase);
@@ -1375,6 +1423,11 @@ var StreamsTransportClient = class {
 		};
 	}
 };
+function normalizeStreamTtlSeconds(value) {
+	if (value == null) return;
+	if (!Number.isSafeInteger(value) || value < 0) throw new Error("streamTtlSeconds must be a non-negative safe integer");
+	return value;
+}
 const REQUEST_ID_HEADER_NAMES = [
 	"x-request-id",
 	"x-amzn-trace-id",
@@ -1466,7 +1519,8 @@ var EphemeralStreamCrdt = class {
 			adapter: createNoopAdapter(),
 			authProvider: normalizeAuthProvider(options.auth),
 			fetchImpl: options.fetch ?? globalThis.fetch.bind(globalThis),
-			reconnectConfig: this.reconnectConfig
+			reconnectConfig: this.reconnectConfig,
+			shardUrls: options.shardUrls
 		});
 	}
 	async join(params) {
@@ -2295,6 +2349,7 @@ var StreamsCrdt = class StreamsCrdt {
 		this.client = new StreamsTransportClient({
 			streamUrl: this.streamUrl,
 			adapter: this.adapter,
+			streamTtlSeconds: options.streamTtlSeconds,
 			authProvider,
 			fetchImpl,
 			reconnectConfig: this.reconnectConfig,
@@ -2417,7 +2472,7 @@ var StreamsCrdt = class StreamsCrdt {
 	async uploadSnapshotForTesting() {
 		try {
 			await this.adapter.flushLocalExports?.();
-			const cursor = await this.syncOnce();
+			const cursor = await this.syncOnce("sync");
 			const rawSnapshot = this.adapter.exportSnapshot();
 			const snapshot = this.encodeSnapshot == null ? rawSnapshot : await this.encodeSnapshot(rawSnapshot);
 			await this.client.putSnapshotAt(cursor.nextOffset, snapshot);
@@ -2485,7 +2540,7 @@ var StreamsCrdt = class StreamsCrdt {
 			this.disableWriteOnlyMode("appendWriteOnly cannot be used after sync() on the same transport");
 			return {
 				ok: true,
-				value: { cursor: await this.syncOnce() }
+				value: { cursor: await this.syncOnce("sync") }
 			};
 		} catch (error) {
 			return {
@@ -2509,11 +2564,11 @@ var StreamsCrdt = class StreamsCrdt {
 			const state = this.joinState;
 			if (state != null && !state.closed) return {
 				ok: true,
-				value: { cursor: await this.catchupJoinState(state, params) }
+				value: { cursor: await this.catchupJoinState(state, params, state.requestController?.signal) }
 			};
 			return {
 				ok: true,
-				value: { cursor: (await this.resolvePullOnlyRemoteState()).cursor }
+				value: { cursor: (await this.resolvePullOnlyRemoteState("catchup")).cursor }
 			};
 		} catch (error) {
 			return {
@@ -2692,10 +2747,46 @@ var StreamsCrdt = class StreamsCrdt {
 			}
 		});
 	}
+	async runInitialSyncWithDeadline(operation, task, parentSignal) {
+		const startedAtMs = Date.now();
+		const hardController = new AbortController();
+		const signal = mergeAbortSignals(parentSignal, hardController.signal);
+		const slowAfterMs = this.reconnectConfig.initialSyncSlowAfterMs;
+		const hardTimeoutMs = this.reconnectConfig.initialSyncHardTimeoutMs;
+		let slowTimer;
+		let hardTimer;
+		let hardTimeoutError;
+		let hardTimeoutPromise;
+		if (typeof slowAfterMs === "number" && Number.isFinite(slowAfterMs) && slowAfterMs > 0) slowTimer = setTimeout(() => {
+			this.logDebug("initial sync still pending", {
+				streamUrl: this.streamUrl,
+				operation,
+				elapsedMs: Date.now() - startedAtMs,
+				slowAfterMs
+			});
+		}, slowAfterMs);
+		if (typeof hardTimeoutMs === "number" && Number.isFinite(hardTimeoutMs) && hardTimeoutMs > 0) hardTimeoutPromise = new Promise((_, reject) => {
+			hardTimer = setTimeout(() => {
+				hardTimeoutError = new InitialSyncTimeoutError(operation, hardTimeoutMs, Date.now() - startedAtMs);
+				hardController.abort(hardTimeoutError);
+				reject(hardTimeoutError);
+			}, hardTimeoutMs);
+		});
+		try {
+			const taskPromise = task(signal);
+			return hardTimeoutPromise == null ? await taskPromise : await Promise.race([taskPromise, hardTimeoutPromise]);
+		} catch (error) {
+			if (hardTimeoutError != null) throw hardTimeoutError;
+			throw error;
+		} finally {
+			if (slowTimer != null) clearTimeout(slowTimer);
+			if (hardTimer != null) clearTimeout(hardTimer);
+		}
+	}
 	async startJoin(state) {
 		try {
 			state.requestController ??= new AbortController();
-			const joined = await this.performInitialJoinSync(state.liveMode);
+			const joined = await this.performInitialJoinSync(state.liveMode, state.requestController?.signal);
 			state.cursor = joined.cursor;
 			state.streamCursor = joined.streamCursor;
 			state.liveMode = joined.liveMode;
@@ -2727,14 +2818,14 @@ var StreamsCrdt = class StreamsCrdt {
 			throw error;
 		}
 	}
-	async syncOnce() {
-		let cursor = (await this.finalizeDirectLocalAppendIfNeeded(await this.resolveInitialRemoteState())).cursor;
+	async syncOnce(operation, parentSignal) {
+		let cursor = (await this.finalizeDirectLocalAppendIfNeeded(await this.resolveInitialRemoteState(operation, parentSignal))).cursor;
 		const localBatch = this.exportUpdates(cursor.serverLowerBoundVersion);
 		if (localBatch.batch != null) cursor = (await this.appendLocalBatchDurably(cursor, localBatch.batch)).cursor;
 		return cursor;
 	}
-	async performInitialJoinSync(preferredLiveMode) {
-		const initial = await this.finalizeDirectLocalAppendIfNeeded(await this.resolveInitialRemoteState());
+	async performInitialJoinSync(preferredLiveMode, parentSignal) {
+		const initial = await this.finalizeDirectLocalAppendIfNeeded(await this.resolveInitialRemoteState("join", parentSignal));
 		let cursor = initial.cursor;
 		let localExportRefVersion = cursor.serverLowerBoundVersion;
 		let streamCursor = initial.streamCursor;
@@ -2761,33 +2852,51 @@ var StreamsCrdt = class StreamsCrdt {
 			serverLowerBoundVersion: this.adapter.emptyVersion()
 		});
 	}
-	async resolveInitialRemoteState() {
+	async resolveInitialRemoteState(operation, parentSignal) {
 		const loaded = await this.remoteCursorStore.load(this.streamUrl);
 		const cursor = loaded ?? this.createInitialCursor();
+		const runInitial = (task) => this.runInitialSyncWithDeadline(operation, task, parentSignal);
 		try {
-			if (loaded == null) return await this.bootstrapState(cursor);
-			const caughtUp = await this.catchupOrGone(cursor, { goneStrategy: "return-gone" });
-			if ("kind" in caughtUp) return await this.recoverFromGoneWithLocalBootstrap(cursor);
+			if (loaded == null) return await runInitial((signal) => this.bootstrapState(cursor, {
+				signal,
+				timeoutMode: "initial"
+			}));
+			const caughtUp = await runInitial((signal) => this.catchupOrGone(cursor, {
+				goneStrategy: "return-gone",
+				signal,
+				timeoutMode: "initial"
+			}));
+			if ("kind" in caughtUp) return await this.recoverFromGoneWithLocalBootstrap(cursor, operation, parentSignal);
 			return caughtUp;
 		} catch (error) {
 			if (!isStreamNotFoundError(error) || !this.createStreamIfMissing) throw error;
 			await this.ensureStreamExists();
-			return await this.bootstrapState(this.createInitialCursor());
+			return await runInitial((signal) => this.bootstrapState(this.createInitialCursor(), {
+				signal,
+				timeoutMode: "initial"
+			}));
 		}
 	}
-	async resolvePullOnlyRemoteState() {
+	async resolvePullOnlyRemoteState(operation, parentSignal) {
 		const loaded = await this.remoteCursorStore.load(this.streamUrl);
 		const cursor = loaded ?? this.createInitialCursor();
+		const runInitial = (task) => this.runInitialSyncWithDeadline(operation, task, parentSignal);
 		try {
-			if (loaded == null) return await this.bootstrapState(cursor);
-			return await this.catchupFromCursor(cursor);
+			if (loaded == null) return await runInitial((signal) => this.bootstrapState(cursor, {
+				signal,
+				timeoutMode: "initial"
+			}));
+			return await runInitial((signal) => this.catchupFromCursor(cursor, void 0, void 0, void 0, signal, "initial"));
 		} catch (error) {
 			if (!isStreamNotFoundError(error) || !this.createStreamIfMissing) throw error;
 			await this.ensureStreamExists();
-			return await this.bootstrapState(this.createInitialCursor());
+			return await runInitial((signal) => this.bootstrapState(this.createInitialCursor(), {
+				signal,
+				timeoutMode: "initial"
+			}));
 		}
 	}
-	async catchupJoinState(state, params) {
+	async catchupJoinState(state, params, parentSignal) {
 		if (state.readSubStatus === "connecting") {
 			await state.started;
 			return state.cursor;
@@ -2795,9 +2904,9 @@ var StreamsCrdt = class StreamsCrdt {
 		if (state.readSubStatus === "ok" && params.force !== true) return state.cursor;
 		const cursor = await this.enqueueExclusive(async () => {
 			if (state.closed) throw new Error("subscription closed");
-			const caughtUp = await this.catchupFromCursor(state.cursor, void 0, state.streamCursor, (previousVersion, nextVersion) => {
+			const caughtUp = await this.runInitialSyncWithDeadline("catchup", (signal) => this.catchupFromCursor(state.cursor, void 0, state.streamCursor, (previousVersion, nextVersion) => {
 				this.snapshotManager.observeRemoteVersion(state, previousVersion, nextVersion);
-			});
+			}, signal, "initial"), parentSignal);
 			state.cursor = caughtUp.cursor;
 			state.streamCursor = caughtUp.streamCursor;
 			return state.cursor;
@@ -2811,13 +2920,15 @@ var StreamsCrdt = class StreamsCrdt {
 	}
 	async bootstrapState(cursor, options = {}) {
 		const cursorManager = options.cursorManager ?? this.cursorManager;
-		const result = await this.client.bootstrap();
+		const result = await this.client.bootstrap(options.signal, options.timeoutMode);
 		let saved = await cursorManager.applyBootstrapPayload(cursor, result.snapshot, result.updates, result.nextOffset, result.upToDate);
 		let bootstrapCursor = result.streamCursor;
 		if (!result.upToDate) {
 			const caughtUp = await this.catchupOrGone(saved, {
 				streamCursor: bootstrapCursor,
-				cursorManager
+				cursorManager,
+				signal: options.signal,
+				timeoutMode: options.timeoutMode
 			});
 			if ("kind" in caughtUp) throw new Error("bootstrap catch-up unexpectedly returned gone");
 			saved = caughtUp.cursor;
@@ -2828,11 +2939,13 @@ var StreamsCrdt = class StreamsCrdt {
 			streamCursor: bootstrapCursor
 		};
 	}
-	async catchupFromCursor(cursor, live, streamCursor, onRemoteVersionApplied) {
+	async catchupFromCursor(cursor, live, streamCursor, onRemoteVersionApplied, signal, timeoutMode) {
 		const result = await this.catchupOrGone(cursor, {
 			live,
 			streamCursor,
-			onRemoteVersionApplied
+			onRemoteVersionApplied,
+			signal,
+			timeoutMode
 		});
 		if ("kind" in result) throw new Error("catchup unexpectedly returned gone");
 		return result;
@@ -2844,14 +2957,18 @@ var StreamsCrdt = class StreamsCrdt {
 		const cursorManager = options.cursorManager ?? this.cursorManager;
 		while (true) {
 			const requestOffset = current.nextOffset;
-			const response = await this.client.readFromOffset(requestOffset, currentStreamCursor, options.live);
+			const response = await this.client.readFromOffset(requestOffset, currentStreamCursor, options.live, options.signal, options.timeoutMode);
 			if (response.kind === "gone") {
 				if (goneStrategy === "return-gone") return StreamsCrdt.GONE_CATCHUP;
 				return await this.bootstrapState({
 					...current,
 					nextOffset: "-1",
 					serverLowerBoundVersion: this.adapter.emptyVersion()
-				}, { cursorManager });
+				}, {
+					cursorManager,
+					signal: options.signal,
+					timeoutMode: options.timeoutMode
+				});
 			}
 			const result = response.value;
 			if (isReadNoProgress(requestOffset, result)) throw new Error(`catch-up made no progress at offset ${requestOffset}; server returned empty updates and unchanged next offset with up_to_date=false`);
@@ -2862,7 +2979,11 @@ var StreamsCrdt = class StreamsCrdt {
 					...current,
 					nextOffset: "-1",
 					serverLowerBoundVersion: this.adapter.emptyVersion()
-				}, { cursorManager });
+				}, {
+					cursorManager,
+					signal: options.signal,
+					timeoutMode: options.timeoutMode
+				});
 				throw error;
 			}
 			currentStreamCursor = result.streamCursor;
@@ -2878,7 +2999,7 @@ var StreamsCrdt = class StreamsCrdt {
 				...state.cursor,
 				nextOffset: "-1",
 				serverLowerBoundVersion: this.adapter.emptyVersion()
-			});
+			}, { signal: state.requestController?.signal });
 			state.cursor = bootstrapped.cursor;
 			state.streamCursor = bootstrapped.streamCursor;
 			state.retryAttempt = 0;
@@ -3080,8 +3201,12 @@ var StreamsCrdt = class StreamsCrdt {
 	* exports and appends any local delta, then re-bootstraps to converge
 	* persisted cursor and local CRDT state on server truth.
 	*/
-	async inferRemoteAndAppendLocal(bootstrapCursor, cursorManager) {
-		const inferredRemote = await this.bootstrapState(bootstrapCursor, { cursorManager });
+	async inferRemoteAndAppendLocal(bootstrapCursor, cursorManager, operation, parentSignal) {
+		const inferredRemote = await this.runInitialSyncWithDeadline(operation, (signal) => this.bootstrapState(bootstrapCursor, {
+			cursorManager,
+			signal,
+			timeoutMode: "initial"
+		}), parentSignal);
 		let pendingAppend;
 		if (this.frozenLocalAppend != null) {
 			if (this.frozenLocalAppend.pendingCount != null) throw new Error("pending local append must be finalized by pending flush");
@@ -3090,22 +3215,29 @@ var StreamsCrdt = class StreamsCrdt {
 			const localBatch = this.exportUpdates(inferredRemote.cursor.serverLowerBoundVersion);
 			if (localBatch.batch != null) pendingAppend = await this.appendLocalBatchRemote(inferredRemote.cursor, localBatch.batch);
 		}
-		const result = await this.bootstrapState(bootstrapCursor);
+		const result = await this.runInitialSyncWithDeadline(operation, (signal) => this.bootstrapState(bootstrapCursor, {
+			signal,
+			timeoutMode: "initial"
+		}), parentSignal);
 		if (pendingAppend != null) this.commitProducerAck(pendingAppend.producerAck);
 		return result;
 	}
-	async recoverFromGoneWithLocalBootstrap(cursor) {
+	async recoverFromGoneWithLocalBootstrap(cursor, operation, parentSignal) {
 		const isolatedCursorManager = await this.createIsolatedCursorManager();
 		const bootstrapCursor = {
 			...cursor,
 			nextOffset: "-1",
 			serverLowerBoundVersion: this.adapter.emptyVersion()
 		};
-		if (isolatedCursorManager != null) return await this.inferRemoteAndAppendLocal(bootstrapCursor, isolatedCursorManager);
+		if (isolatedCursorManager != null) return await this.inferRemoteAndAppendLocal(bootstrapCursor, isolatedCursorManager, operation, parentSignal);
 		const preservedLocalSnapshot = this.adapter.exportSnapshot();
 		let restoredLocalSnapshot = false;
 		try {
-			const inferredRemote = await this.bootstrapState(bootstrapCursor, { cursorManager: this.volatileCursorManager });
+			const inferredRemote = await this.runInitialSyncWithDeadline(operation, (signal) => this.bootstrapState(bootstrapCursor, {
+				cursorManager: this.volatileCursorManager,
+				signal,
+				timeoutMode: "initial"
+			}), parentSignal);
 			await this.adapter.applySnapshot(preservedLocalSnapshot);
 			restoredLocalSnapshot = true;
 			let pendingAppend;
@@ -3116,7 +3248,10 @@ var StreamsCrdt = class StreamsCrdt {
 				const localBatch = this.exportUpdates(inferredRemote.cursor.serverLowerBoundVersion);
 				if (localBatch.batch != null) pendingAppend = await this.appendLocalBatchRemote(inferredRemote.cursor, localBatch.batch);
 			}
-			const result = await this.bootstrapState(bootstrapCursor);
+			const result = await this.runInitialSyncWithDeadline(operation, (signal) => this.bootstrapState(bootstrapCursor, {
+				signal,
+				timeoutMode: "initial"
+			}), parentSignal);
 			if (pendingAppend != null) this.commitProducerAck(pendingAppend.producerAck);
 			return result;
 		} catch (error) {
@@ -3153,7 +3288,7 @@ var StreamsCrdt = class StreamsCrdt {
 							...state.cursor,
 							nextOffset: "-1",
 							serverLowerBoundVersion: this.adapter.emptyVersion()
-						});
+						}, { signal: capturedController?.signal });
 						state.cursor = bootstrapped.cursor;
 						state.streamCursor = bootstrapped.streamCursor;
 						state.retryAttempt = 0;
@@ -3246,7 +3381,7 @@ var StreamsCrdt = class StreamsCrdt {
 					...state.cursor,
 					nextOffset: "-1",
 					serverLowerBoundVersion: this.adapter.emptyVersion()
-				});
+				}, { signal: capturedController?.signal });
 				state.cursor = bootstrapped.cursor;
 				state.streamCursor = bootstrapped.streamCursor;
 				state.retryAttempt = 0;
@@ -3544,4 +3679,4 @@ function createStreamUrl(input) {
 //#endregion
 export { InMemoryRemoteCursorStore as a, EphemeralStreamCrdt as c, StreamsCrdt as i, PayloadProtectionError as l, isValidBucketId as n, IndexedDbRemoteCursorStore as o, isValidRillId as r, createInitialRemoteCursor as s, createStreamUrl as t };
 
-//# sourceMappingURL=stream-id-fOF9ZqCH.js.map
+//# sourceMappingURL=stream-id-DVVP3k7V.js.map