birdclaw 0.8.2 → 0.8.3

package/src/lib/tweet-repository.ts

@@ -0,0 +1,156 @@
+import type { Database } from "./sqlite";
+import { buildMediaJsonFromIncludes, countTweetMedia } from "./media-includes";
+import { tweetEntitiesFromXurl } from "./tweet-render";
+import type { XurlMentionData, XurlMentionsResponse } from "./types";
+import {
+	type TweetAccountEdgeKind,
+	upsertTweetAccountEdge,
+} from "./tweet-account-edges";
+import { ensureStubProfileForXUser, upsertProfileFromXUser } from "./x-profile";
+
+export type CanonicalTweetKind =
+	| "authored"
+	| "bookmark"
+	| "home"
+	| "like"
+	| "mention"
+	| "search"
+	| "thread"
+	| "thread_context";
+
+export interface IngestTweetPayloadOptions {
+	accountId: string;
+	payload: XurlMentionsResponse;
+	kind: CanonicalTweetKind;
+	source: string;
+	edgeKind?: TweetAccountEdgeKind;
+	collectionKind?: "likes" | "bookmarks";
+	markRepliesAsReplied?: boolean;
+	replaceSecondaryKind?: boolean;
+}
+
+function getReferencedTweetId(tweet: XurlMentionData, type: string) {
+	return (
+		tweet.referenced_tweets?.find((item) => item.type === type)?.id ?? null
+	);
+}
+
+export function replaceTweetFts(db: Database, tweetId: string, text: string) {
+	db.prepare("delete from tweets_fts where tweet_id = ?").run(tweetId);
+	db.prepare("insert into tweets_fts (tweet_id, text) values (?, ?)").run(
+		tweetId,
+		text,
+	);
+}
+
+export function ingestTweetPayload(
+	db: Database,
+	{
+		accountId,
+		payload,
+		kind,
+		source,
+		edgeKind,
+		collectionKind,
+		markRepliesAsReplied = false,
+		replaceSecondaryKind = false,
+	}: IngestTweetPayloadOptions,
+) {
+	const usersById = new Map(
+		(payload.includes?.users ?? []).map((user) => [user.id, user]),
+	);
+	const upsertTweet = db.prepare(`
+    insert into tweets (
+      id, account_id, author_profile_id, kind, text, created_at,
+      is_replied, reply_to_id, like_count, media_count, bookmarked, liked,
+      entities_json, media_json, quoted_tweet_id
+    ) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    on conflict(id) do update set
+      account_id = tweets.account_id,
+      author_profile_id = excluded.author_profile_id,
+      kind = case
+        when ? = 1
+          and tweets.kind not in ('authored', 'home', 'mention')
+          then excluded.kind
+        else tweets.kind
+      end,
+      text = excluded.text,
+      created_at = excluded.created_at,
+      is_replied = max(tweets.is_replied, excluded.is_replied),
+      reply_to_id = coalesce(tweets.reply_to_id, excluded.reply_to_id),
+      like_count = excluded.like_count,
+      media_count = max(tweets.media_count, excluded.media_count),
+      entities_json = excluded.entities_json,
+      media_json = case
+        when excluded.media_json not in ('', '[]', 'null') then excluded.media_json
+        else tweets.media_json
+      end,
+      bookmarked = tweets.bookmarked,
+      liked = tweets.liked,
+      quoted_tweet_id = coalesce(tweets.quoted_tweet_id, excluded.quoted_tweet_id)
+  `);
+	const upsertCollection = collectionKind
+		? db.prepare(`
+        insert into tweet_collections (
+          account_id, tweet_id, kind, collected_at, source, raw_json, updated_at
+        ) values (?, ?, ?, null, ?, ?, ?)
+        on conflict(account_id, tweet_id, kind) do update set
+          source = excluded.source,
+          raw_json = excluded.raw_json,
+          updated_at = excluded.updated_at
+      `)
+		: undefined;
+	const tweetIds: string[] = [];
+
+	db.transaction(() => {
+		const observedAt = new Date().toISOString();
+		for (const tweet of payload.data) {
+			const author = usersById.get(tweet.author_id);
+			const profile = author
+				? upsertProfileFromXUser(db, author)
+				: ensureStubProfileForXUser(db, tweet.author_id);
+			const replyToId = getReferencedTweetId(tweet, "replied_to");
+			const quotedTweetId = getReferencedTweetId(tweet, "quoted");
+			upsertTweet.run(
+				tweet.id,
+				accountId,
+				profile.profile.id,
+				kind,
+				tweet.text,
+				tweet.created_at,
+				markRepliesAsReplied && replyToId ? 1 : 0,
+				replyToId,
+				Number(tweet.public_metrics?.like_count ?? 0),
+				countTweetMedia(tweet),
+				collectionKind === "bookmarks" ? 1 : 0,
+				collectionKind === "likes" ? 1 : 0,
+				JSON.stringify(tweetEntitiesFromXurl(tweet.entities)),
+				buildMediaJsonFromIncludes(tweet, payload.includes?.media),
+				quotedTweetId,
+				replaceSecondaryKind ? 1 : 0,
+			);
+			if (edgeKind) {
+				upsertTweetAccountEdge(db, {
+					accountId,
+					tweetId: tweet.id,
+					kind: edgeKind,
+					source,
+					seenAt: observedAt,
+					rawJson: JSON.stringify(tweet),
+				});
+			}
+			upsertCollection?.run(
+				accountId,
+				tweet.id,
+				collectionKind,
+				source,
+				JSON.stringify(tweet),
+				observedAt,
+			);
+			replaceTweetFts(db, tweet.id, tweet.text);
+			tweetIds.push(tweet.id);
+		}
+	})();
+
+	return tweetIds;
+}

package/src/lib/tweet-search-live.ts

@@ -1,15 +1,15 @@
 import { Effect } from "effect";
-import { searchTweetsViaBirdEffect } from "./bird";
 import type { Database } from "./sqlite";
 import { getNativeDb } from "./db";
 import { runEffectPromise } from "./effect-runtime";
-import { buildMediaJsonFromIncludes, countTweetMedia } from "./media-includes";
-import { readSyncCache, writeSyncCache } from "./sync-cache";
-import { tweetEntitiesFromXurl } from "./tweet-render";
+import { liveTransportGateway } from "./live-transport-gateway";
+import {
+	normalizeCacheTtlMs,
+	resolveLiveSyncAccount,
+	runCachedLiveSyncEffect,
+} from "./live-sync-engine";
 import type { XurlMentionsResponse, XurlTweetsResponse } from "./types";
-import { upsertTweetAccountEdge } from "./tweet-account-edges";
-import { ensureStubProfileForXUser, upsertProfileFromXUser } from "./x-profile";
-import { searchRecentTweetsEffect } from "./xurl";
+import { ingestTweetPayload } from "./tweet-repository";
 
 export type TweetSearchMode = "auto" | "bird" | "xurl" | "local";
 
@@ -85,130 +85,19 @@ function normalizeTime(value: string | undefined, optionName: string) {
 	return date.toISOString();
 }
 
-function normalizeCacheTtlMs(value: number | undefined) {
-	if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
-		return DEFAULT_CACHE_TTL_MS;
-	}
-	return Math.floor(value);
-}
-
-function resolveAccount(db: Database, accountId?: string) {
-	const row = accountId
-		? (db
-				.prepare("select id, handle from accounts where id = ?")
-				.get(accountId) as { id: string; handle: string } | undefined)
-		: (db
-				.prepare(
-					`
-          select id, handle
-          from accounts
-          order by is_default desc, created_at asc
-          limit 1
-          `,
-				)
-				.get() as { id: string; handle: string } | undefined);
-
-	if (!row) {
-		throw new Error(`Unknown account: ${accountId ?? "default"}`);
-	}
-
-	return {
-		accountId: row.id,
-		username: row.handle.replace(/^@/, ""),
-	};
-}
-
-function replaceTweetFts(db: Database, tweetId: string, text: string) {
-	db.prepare("delete from tweets_fts where tweet_id = ?").run(tweetId);
-	db.prepare("insert into tweets_fts (tweet_id, text) values (?, ?)").run(
-		tweetId,
-		text,
-	);
-}
-
 function mergeTweetSearchIntoLocalStore(
 	db: Database,
 	accountId: string,
 	payload: XurlMentionsResponse,
 	source: "bird" | "xurl" | "cache",
 ) {
-	const usersById = new Map(
-		(payload.includes?.users ?? []).map((user) => [user.id, user]),
-	);
-	const upsertTweet = db.prepare(
-		`
-    insert into tweets (
-      id, account_id, author_profile_id, kind, text, created_at,
-      is_replied, reply_to_id, like_count, media_count, bookmarked, liked,
-      entities_json, media_json, quoted_tweet_id
-    ) values (?, ?, ?, 'search', ?, ?, 0, ?, ?, ?, 0, 0, ?, ?, ?)
-    on conflict(id) do update set
-      account_id = tweets.account_id,
-      author_profile_id = excluded.author_profile_id,
-      kind = tweets.kind,
-      text = excluded.text,
-      created_at = excluded.created_at,
-      reply_to_id = coalesce(tweets.reply_to_id, excluded.reply_to_id),
-      like_count = excluded.like_count,
-      media_count = max(tweets.media_count, excluded.media_count),
-      entities_json = excluded.entities_json,
-      media_json = case
-        when excluded.media_json not in ('', '[]', 'null') then excluded.media_json
-        else tweets.media_json
-      end,
-      quoted_tweet_id = coalesce(tweets.quoted_tweet_id, excluded.quoted_tweet_id),
-      bookmarked = tweets.bookmarked,
-      liked = tweets.liked
-    `,
-	);
-	const tweetIds: string[] = [];
-
-	db.transaction(() => {
-		const seenAt = new Date().toISOString();
-		for (const tweet of payload.data) {
-			const author =
-				usersById.get(tweet.author_id) ??
-				({
-					id: tweet.author_id,
-					username: `user_${tweet.author_id}`,
-					name: `user_${tweet.author_id}`,
-				} as const);
-			const profile = usersById.has(tweet.author_id)
-				? upsertProfileFromXUser(db, author)
-				: ensureStubProfileForXUser(db, tweet.author_id);
-			const replyToId =
-				tweet.referenced_tweets?.find((item) => item.type === "replied_to")
-					?.id ?? null;
-			const quotedTweetId =
-				tweet.referenced_tweets?.find((item) => item.type === "quoted")?.id ??
-				null;
-			upsertTweet.run(
-				tweet.id,
-				accountId,
-				profile.profile.id,
-				tweet.text,
-				tweet.created_at,
-				replyToId,
-				Number(tweet.public_metrics?.like_count ?? 0),
-				countTweetMedia(tweet),
-				JSON.stringify(tweetEntitiesFromXurl(tweet.entities)),
-				buildMediaJsonFromIncludes(tweet, payload.includes?.media),
-				quotedTweetId,
-			);
-			upsertTweetAccountEdge(db, {
-				accountId,
-				tweetId: tweet.id,
-				kind: "search",
-				source,
-				seenAt,
-				rawJson: JSON.stringify(tweet),
-			});
-			replaceTweetFts(db, tweet.id, tweet.text);
-			tweetIds.push(tweet.id);
-		}
-	})();
-
-	return tweetIds;
+	return ingestTweetPayload(db, {
+		accountId,
+		payload,
+		kind: "search",
+		edgeKind: "search",
+		source,
+	});
 }
 
 function toMentionsResponse(payload: XurlTweetsResponse): XurlMentionsResponse {
@@ -302,7 +191,7 @@ function fetchBirdSearchEffect({
 	limit: number;
 	maxPages: number;
 }) {
-	return searchTweetsViaBirdEffect(query, {
+	return liveTransportGateway.bird.searchTweets(query, {
 		maxResults: Math.min(limit, XURL_PAGE_SIZE),
 		all: maxPages > 1 || limit > XURL_PAGE_SIZE,
 		maxPages,
@@ -332,13 +221,16 @@ function fetchXurlSearchEffect({
 				limit -
 				responses.reduce((total, response) => total + response.data.length, 0);
 			if (remaining <= 0) break;
-			const response = yield* searchRecentTweetsEffect(query, {
-				maxResults: Math.max(10, Math.min(XURL_PAGE_SIZE, remaining)),
-				paginationToken: nextToken,
-				startTime: since,
-				endTime: until,
-				timeoutMs,
-			});
+			const response = yield* liveTransportGateway.xurl.searchRecentTweets(
+				query,
+				{
+					maxResults: Math.max(10, Math.min(XURL_PAGE_SIZE, remaining)),
+					paginationToken: nextToken,
+					startTime: since,
+					endTime: until,
+					timeoutMs,
+				},
+			);
 			responses.push(toMentionsResponse(response));
 			nextToken =
 				typeof response.meta?.next_token === "string"
@@ -368,42 +260,44 @@ function runModeEffect(
 	return Effect.gen(function* () {
 		const db = getNativeDb();
 		const key = cacheKey({ ...options, mode });
-		const cached = yield* trySync(() =>
-			readSyncCache<XurlMentionsResponse>(key, db),
-		);
-		const ageMs = cached
-			? Date.now() - new Date(cached.updatedAt).getTime()
-			: Number.POSITIVE_INFINITY;
-		const payload =
-			!options.refresh && cached && ageMs <= options.cacheTtlMs
-				? cached.value
-				: yield* (
-						mode === "bird"
-							? fetchBirdSearchEffect(options).pipe(Effect.mapError(toError))
-							: fetchXurlSearchEffect(options)
-					).pipe(
+		const fetch =
+			mode === "bird"
+				? fetchBirdSearchEffect(options).pipe(Effect.mapError(toError))
+				: fetchXurlSearchEffect(options);
+		const syncResult = yield* runCachedLiveSyncEffect({
+			db,
+			cacheKey: key,
+			refresh: options.refresh,
+			cacheTtlMs: options.cacheTtlMs,
+			transports: [
+				{
+					source: mode,
+					fetch: fetch.pipe(
 						Effect.map((response) => limitResponse(response, options.limit)),
-					);
-		if (!cached || options.refresh || ageMs > options.cacheTtlMs) {
-			yield* trySync(() => writeSyncCache(key, payload, db));
-		}
-		const tweetIds = yield* trySync(() =>
-			mergeTweetSearchIntoLocalStore(
-				db,
-				options.accountId,
-				payload,
-				!options.refresh && cached && ageMs <= options.cacheTtlMs
-					? "cache"
-					: mode,
-			),
-		);
+					),
+				},
+			],
+			persistLive: (writeDb, payload, source) =>
+				mergeTweetSearchIntoLocalStore(
+					writeDb,
+					options.accountId,
+					payload,
+					source,
+				),
+			persistCached: (writeDb, payload) =>
+				mergeTweetSearchIntoLocalStore(
+					writeDb,
+					options.accountId,
+					payload,
+					"cache",
+				),
+		});
+		const { payload, source } = syncResult;
+		const tweetIds = syncResult.persisted ?? [];
 
 		return {
 			ok: true,
-			source:
-				!options.refresh && cached && ageMs <= options.cacheTtlMs
-					? "cache"
-					: mode,
+			source,
 			accountId: options.accountId,
 			query: options.query,
 			count: tweetIds.length,
@@ -479,9 +373,11 @@ export function syncTweetSearchEffect({
 		const normalizedUntil = yield* trySync(() =>
 			normalizeTime(until, "--until"),
 		);
-		const ttlMs = normalizeCacheTtlMs(cacheTtlMs);
+		const ttlMs = normalizeCacheTtlMs(cacheTtlMs, DEFAULT_CACHE_TTL_MS);
 		const db = getNativeDb();
-		const resolvedAccount = yield* trySync(() => resolveAccount(db, account));
+		const resolvedAccount = yield* trySync(() =>
+			resolveLiveSyncAccount(db, account),
+		);
 		const accountId = resolvedAccount.accountId;
 		if (mode === "local") {
 			return {

package/src/lib/web-sync.ts

@@ -1,11 +1,14 @@
 import { existsSync } from "node:fs";
 import { Effect } from "effect";
 import { maybeAutoSyncBackupEffect } from "./backup";
-import { getBirdclawPaths } from "./config";
 import { syncDirectMessagesViaCachedBirdEffect } from "./dms-live";
 import { runEffectBackground, runEffectPromise } from "./effect-runtime";
 import { syncMentionThreadsEffect } from "./mention-threads-live";
 import { syncMentionsEffect } from "./mentions-live";
+import {
+	defaultServerRuntimeServices,
+	type ServerRuntimeServices,
+} from "./server-runtime-services";
 import NativeSqliteDatabase from "./sqlite";
 import { syncTimelineCollectionEffect } from "./timeline-collections-live";
 import { syncHomeTimelineEffect } from "./timeline-live";
@@ -69,6 +72,7 @@ interface WebSyncPlan {
 	run: (
 		accountId: string | undefined,
 		options: WebSyncOptions,
+		runtime: ServerRuntimeServices,
 	) => Effect.Effect<WebSyncStep[], unknown>;
 }
 
@@ -132,12 +136,12 @@ const WEB_SYNC_PLANS: Record<WebSyncKind, WebSyncPlan> = {
 	timeline: {
 		label: "Home timeline",
 		accountAware: true,
-		run: (account) =>
+		run: (account, _options, runtime) =>
 			Effect.gen(function* () {
 				const result = yield* syncHomeTimelineEffect({
 					account,
 					mode:
-						!account || account === resolveDefaultSyncAccountId()
+						!account || account === resolveDefaultSyncAccountId(runtime)
 							? "auto"
 							: "xurl",
 					limit: 100,
@@ -201,12 +205,14 @@ const WEB_SYNC_PLANS: Record<WebSyncKind, WebSyncPlan> = {
 	likes: {
 		label: "Likes",
 		accountAware: true,
-		run: (account) => syncSavedCollection("likes", account),
+		run: (account, _options, runtime) =>
+			syncSavedCollection("likes", account, runtime),
 	},
 	bookmarks: {
 		label: "Bookmarks",
 		accountAware: true,
-		run: (account) => syncSavedCollection("bookmarks", account),
+		run: (account, _options, runtime) =>
+			syncSavedCollection("bookmarks", account, runtime),
 	},
 	dms: {
 		label: "Direct messages",
@@ -242,10 +248,11 @@ const WEB_SYNC_PLANS: Record<WebSyncKind, WebSyncPlan> = {
 function syncSavedCollection(
 	kind: "likes" | "bookmarks",
 	account: string | undefined,
+	runtime: ServerRuntimeServices,
 ): Effect.Effect<WebSyncStep[], unknown> {
 	return Effect.gen(function* () {
 		const isNonDefaultAccount =
-			account !== undefined && account !== resolveDefaultSyncAccountId();
+			account !== undefined && account !== resolveDefaultSyncAccountId(runtime);
 		const result = yield* syncTimelineCollectionEffect({
 			kind,
 			account,
@@ -270,13 +277,14 @@ export function performWebSyncEffect(
 	kind: WebSyncKind,
 	accountId?: string,
 	options: WebSyncOptions = {},
+	runtime: ServerRuntimeServices = defaultServerRuntimeServices,
 ) {
 	return Effect.gen(function* () {
-		const startedAt = new Date().toISOString();
-		const steps = yield* WEB_SYNC_PLANS[kind].run(accountId, options);
+		const startedAt = runtime.now().toISOString();
+		const steps = yield* WEB_SYNC_PLANS[kind].run(accountId, options, runtime);
 
 		const backup = yield* maybeAutoSyncBackupEffect();
-		const finishedAt = new Date().toISOString();
+		const finishedAt = runtime.now().toISOString();
 		return {
 			ok: true,
 			kind,
@@ -290,12 +298,12 @@ export function performWebSyncEffect(
 	});
 }
 
-function createWebSyncJobId(kind: WebSyncKind) {
-	return `sync_${kind}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+function createWebSyncJobId(kind: WebSyncKind, runtime: ServerRuntimeServices) {
+	return `sync_${kind}_${runtime.now().getTime().toString(36)}_${runtime.random().toString(36).slice(2, 8)}`;
 }
 
-function resolveDefaultSyncAccountId() {
-	const dbPath = getBirdclawPaths().dbPath;
+function resolveDefaultSyncAccountId(runtime: ServerRuntimeServices) {
+	const dbPath = runtime.getPaths().dbPath;
 	if (!existsSync(dbPath)) {
 		return "acct_primary";
 	}
@@ -336,12 +344,13 @@ function getRunningSyncKey(
 	kind: WebSyncKind,
 	accountId: string | undefined,
 	options: WebSyncOptions = {},
+	runtime: ServerRuntimeServices = defaultServerRuntimeServices,
 ) {
 	if (!WEB_SYNC_PLANS[kind].accountAware) {
 		const optionKey = serializeSyncOptions(kind, options);
 		return optionKey ? `${kind}:${optionKey}` : kind;
 	}
-	return `${kind}:${accountId ?? resolveDefaultSyncAccountId()}`;
+	return `${kind}:${accountId ?? resolveDefaultSyncAccountId(runtime)}`;
 }
 
 function getEffectiveAccountId(
@@ -380,8 +389,9 @@ function toFailedResponse(
 	startedAt: string,
 	error: unknown,
 	accountId?: string,
+	runtime: ServerRuntimeServices = defaultServerRuntimeServices,
 ): WebSyncResponse {
-	const finishedAt = new Date().toISOString();
+	const finishedAt = runtime.now().toISOString();
 	const message = messageFromError(error);
 	return {
 		ok: false,
@@ -399,17 +409,18 @@ export function startWebSync(
 	kind: WebSyncKind,
 	accountId?: string,
 	options: WebSyncOptions = {},
+	runtime: ServerRuntimeServices = defaultServerRuntimeServices,
 ): WebSyncJobSnapshot {
 	const effectiveAccountId = getEffectiveAccountId(kind, accountId);
-	const syncKey = getRunningSyncKey(kind, effectiveAccountId, options);
+	const syncKey = getRunningSyncKey(kind, effectiveAccountId, options, runtime);
 	const current = runningSyncs.get(syncKey);
 	if (current) {
 		return current;
 	}
 
-	const startedAt = new Date().toISOString();
+	const startedAt = runtime.now().toISOString();
 	const job: WebSyncJobSnapshot = {
-		id: createWebSyncJobId(kind),
+		id: createWebSyncJobId(kind, runtime),
 		kind,
 		...(effectiveAccountId ? { accountId: effectiveAccountId } : {}),
 		status: "running",
@@ -420,35 +431,39 @@ export function startWebSync(
 	webSyncJobKeys.set(job.id, syncKey);
 	setJobSnapshot(job);
 
-	runEffectBackground(performWebSyncEffect(kind, effectiveAccountId, options), {
-		onSuccess: (result) => {
-			setJobSnapshot({
-				...job,
-				status: "succeeded",
-				finishedAt: result.finishedAt,
-				summary: result.summary,
-				inProgress: false,
-				result,
-			});
-		},
-		onFailure: (error) => {
-			const result = toFailedResponse(
-				kind,
-				startedAt,
-				error,
-				effectiveAccountId,
-			);
-			setJobSnapshot({
-				...job,
-				status: "failed",
-				finishedAt: result.finishedAt,
-				summary: result.summary,
-				inProgress: false,
-				result,
-				error: result.error,
-			});
+	runEffectBackground(
+		performWebSyncEffect(kind, effectiveAccountId, options, runtime),
+		{
+			onSuccess: (result) => {
+				setJobSnapshot({
+					...job,
+					status: "succeeded",
+					finishedAt: result.finishedAt,
+					summary: result.summary,
+					inProgress: false,
+					result,
+				});
+			},
+			onFailure: (error) => {
+				const result = toFailedResponse(
+					kind,
+					startedAt,
+					error,
+					effectiveAccountId,
+					runtime,
+				);
+				setJobSnapshot({
+					...job,
+					status: "failed",
+					finishedAt: result.finishedAt,
+					summary: result.summary,
+					inProgress: false,
+					result,
+					error: result.error,
+				});
+			},
 		},
-	});
+	);
 
 	return job;
 }
@@ -461,13 +476,14 @@ export function runWebSyncEffect(
 	kind: WebSyncKind,
 	accountId?: string,
 	options: WebSyncOptions = {},
+	runtime: ServerRuntimeServices = defaultServerRuntimeServices,
 ): Effect.Effect<WebSyncResponse, Error> {
 	return Effect.gen(function* () {
 		const effectiveAccountId = getEffectiveAccountId(kind, accountId);
 		const current = runningSyncs.get(
-			getRunningSyncKey(kind, effectiveAccountId, options),
+			getRunningSyncKey(kind, effectiveAccountId, options, runtime),
 		);
-		const startedAt = new Date().toISOString();
+		const startedAt = runtime.now().toISOString();
 		if (current) {
 			return {
 				ok: false,
@@ -480,7 +496,7 @@ export function runWebSyncEffect(
 			} satisfies WebSyncResponse;
 		}
 
-		const job = startWebSync(kind, effectiveAccountId, options);
+		const job = startWebSync(kind, effectiveAccountId, options, runtime);
 		while (job.inProgress) {
 			yield* Effect.sleep(25);
 			const latest = getWebSyncJob(job.id);
@@ -501,8 +517,9 @@ export function runWebSync(
 	kind: WebSyncKind,
 	accountId?: string,
 	options: WebSyncOptions = {},
+	runtime: ServerRuntimeServices = defaultServerRuntimeServices,
 ): Promise<WebSyncResponse> {
-	return runEffectPromise(runWebSyncEffect(kind, accountId, options));
+	return runEffectPromise(runWebSyncEffect(kind, accountId, options, runtime));
 }
 
 export function clearWebSyncLocksForTests() {