@beeuni/sdk 0.1.0

package/dist/browser/cache/idb-sync-cache.d.ts

@@ -0,0 +1,12 @@
+import type { KeyValueStorage } from '../../core/cache/persisted-query-cache.js';
+export declare function indexedDBKeyValueStorage(): KeyValueStorage | null;
+export declare function saveSessionToIDB(_sessionId: string, _messages: any[], _parts: Record<string, any[]>, _beeuniSessionScope?: string): Promise<void>;
+export declare function flushIDBWrites(): Promise<void>;
+export declare function loadSessionFromIDB(_sessionId: string, _beeuniSessionScope?: string): Promise<{
+    messages: any[];
+    parts: Record<string, any[]>;
+} | null>;
+export declare function loadAllSessionIdsFromIDB(): Promise<string[]>;
+export declare function deleteSessionFromIDB(_sessionId: string, beeuniSessionScope?: string): Promise<void>;
+export declare function clearSessionIDBCache(): Promise<void>;
+export declare function pruneIDBCache(): Promise<void>;

package/dist/browser/cache/idb-sync-cache.js

@@ -0,0 +1,88 @@
+import { currentSavedCopyStore } from '../../core/session-sync/saved-copy-store.js';
+import { parseBeeuniSessionScope } from '../session-sync/server-transcript-mirror.js';
+const DB_NAME = 'beeuni-session-cache';
+const DB_VERSION = 4;
+const STORE_NAME = 'saved-copies';
+const RETIRED_STORE_NAME = 'sessions';
+const connections = new WeakMap();
+function factory() {
+    try {
+        return globalThis.indexedDB;
+    }
+    catch {
+        return undefined;
+    }
+}
+function openDB() {
+    const idb = factory();
+    if (!idb)
+        return Promise.reject(new Error('IndexedDB not available'));
+    const open = connections.get(idb);
+    if (open)
+        return open;
+    const pending = new Promise((resolve, reject) => {
+        const request = idb.open(DB_NAME, DB_VERSION);
+        request.onupgradeneeded = () => {
+            const db = request.result;
+            if (db.objectStoreNames.contains(RETIRED_STORE_NAME))
+                db.deleteObjectStore(RETIRED_STORE_NAME);
+            if (!db.objectStoreNames.contains(STORE_NAME))
+                db.createObjectStore(STORE_NAME);
+        };
+        request.onsuccess = () => {
+            const db = request.result;
+            db.onversionchange = () => {
+                db.close();
+                connections.delete(idb);
+            };
+            resolve(db);
+        };
+        request.onerror = () => reject(request.error);
+        request.onblocked = () => reject(new Error('IndexedDB upgrade blocked by another tab'));
+    });
+    connections.set(idb, pending);
+    pending.catch(() => connections.delete(idb));
+    return pending;
+}
+function run(mode, operation) {
+    return openDB().then((db) => new Promise((resolve, reject) => {
+        const tx = db.transaction(STORE_NAME, mode);
+        const request = operation(tx.objectStore(STORE_NAME));
+        tx.oncomplete = () => resolve(request.result);
+        tx.onerror = () => reject(tx.error);
+        tx.onabort = () => reject(tx.error);
+    }));
+}
+export function indexedDBKeyValueStorage() {
+    if (!factory())
+        return null;
+    return {
+        getItem: (key) => run('readonly', (store) => store.get(key)).then((value) => (typeof value === 'string' ? value : null), () => null),
+        setItem: (key, value) => run('readwrite', (store) => store.put(value, key)).then(() => undefined),
+        removeItem: (key) => run('readwrite', (store) => store.delete(key)).then(() => undefined),
+    };
+}
+export async function saveSessionToIDB(_sessionId, _messages, _parts, _beeuniSessionScope) { }
+export function flushIDBWrites() {
+    return Promise.resolve();
+}
+export async function loadSessionFromIDB(_sessionId, _beeuniSessionScope) {
+    return null;
+}
+export async function loadAllSessionIdsFromIDB() {
+    return [];
+}
+export async function deleteSessionFromIDB(_sessionId, beeuniSessionScope) {
+    const scope = parseBeeuniSessionScope(beeuniSessionScope);
+    if (!scope)
+        return;
+    await currentSavedCopyStore()?.remove(scope.projectId, scope.sessionId);
+}
+export async function clearSessionIDBCache() {
+    try {
+        await run('readwrite', (store) => store.clear());
+    }
+    catch {
+    }
+}
+export async function pruneIDBCache() { }

package/dist/browser/session-sync/mirror-paging.d.ts

@@ -0,0 +1,7 @@
+export declare function chooseOlderSource(input: {
+    runtimeHasOlder: boolean;
+    mirrorCursor: string | null | undefined;
+}): 'runtime' | 'mirror' | null;
+export declare function mirrorCursorAfter(envelope: {
+    next_cursor?: string | null;
+} | null | undefined): string | null;

package/dist/browser/session-sync/mirror-paging.js

@@ -0,0 +1,10 @@
+export function chooseOlderSource(input) {
+    if (input.runtimeHasOlder)
+        return 'runtime';
+    if (input.mirrorCursor)
+        return 'mirror';
+    return null;
+}
+export function mirrorCursorAfter(envelope) {
+    return envelope?.next_cursor ?? null;
+}

package/dist/browser/session-sync/server-transcript-mirror.d.ts

@@ -0,0 +1,33 @@
+import type { Message, Part } from "../../core/runtime/runtime-types.js";
+import { type SessionTranscriptSyncEnvelope } from "../../core/rest/projects-client/sessions.js";
+import type { SavedCopyStore } from "../../core/session-sync/saved-copy-store.js";
+export declare const MIRROR_HYDRATE_LIMIT = 40;
+export interface MirrorHydrateDecision {
+    envelope: SessionTranscriptSyncEnvelope | null;
+    runtimeSessionId: string;
+    hasMessages: boolean;
+}
+export declare function shouldHydrateFromMirror(input: MirrorHydrateDecision): boolean;
+export declare function mirrorMessagesForHydrate(envelope: SessionTranscriptSyncEnvelope): Array<{
+    info: Message;
+    parts: Part[];
+}>;
+export declare function parseBeeuniSessionScope(scope: string | undefined): {
+    projectId: string;
+    sessionId: string;
+} | null;
+export declare function loadSessionTranscriptMirror(input: {
+    beeuniSessionScope: string | undefined;
+    limit?: number;
+    signal?: AbortSignal;
+    child?: string;
+}): Promise<SessionTranscriptSyncEnvelope | null>;
+export declare function loadOlderSessionTranscriptMirror(input: {
+    beeuniSessionScope: string | undefined;
+    before: string;
+    limit?: number;
+    signal?: AbortSignal;
+    child?: string;
+}): Promise<SessionTranscriptSyncEnvelope | null>;
+export declare const SAVED_COPY_REFRESH_DELAY_MS = 3000;
+export declare function refreshSavedCopy(store: SavedCopyStore, projectId: string, sessionId: string): Promise<void>;

package/dist/browser/session-sync/server-transcript-mirror.js

@@ -0,0 +1,112 @@
+import { getSessionTranscriptSync, } from "../../core/rest/projects-client/sessions.js";
+import { claimOpenBundle, takeOpenBundleTranscript, takeOpenBundleTranscriptAbsence, } from "../../core/session/open-bundle.js";
+export const MIRROR_HYDRATE_LIMIT = 40;
+export function shouldHydrateFromMirror(input) {
+    const { envelope, runtimeSessionId, hasMessages } = input;
+    if (!envelope)
+        return false;
+    if (hasMessages)
+        return false;
+    if (!runtimeSessionId)
+        return false;
+    if (!envelope.available)
+        return false;
+    if (envelope.source !== "mirror")
+        return false;
+    if (envelope.messages.length === 0)
+        return false;
+    if ((envelope.runtime_session_id ?? envelope.opencode_session_id) !== runtimeSessionId)
+        return false;
+    return true;
+}
+export function mirrorMessagesForHydrate(envelope) {
+    const out = [];
+    for (const row of envelope.messages) {
+        const info = row?.info;
+        if (!info || typeof info !== "object")
+            continue;
+        const id = typeof info.id === "string" ? info.id.trim() : "";
+        if (!id)
+            continue;
+        const parts = (Array.isArray(row.parts) ? row.parts : [])
+            .filter((p) => !!p && typeof p === "object")
+            .slice()
+            .sort((a, b) => String(a.id ?? "").localeCompare(String(b.id ?? "")));
+        out.push({ info: info, parts: parts });
+    }
+    return out;
+}
+export function parseBeeuniSessionScope(scope) {
+    if (!scope)
+        return null;
+    const slash = scope.indexOf("/");
+    if (slash <= 0 || slash === scope.length - 1)
+        return null;
+    const projectId = scope.slice(0, slash);
+    const sessionId = scope.slice(slash + 1);
+    if (!projectId || !sessionId || sessionId.includes("/"))
+        return null;
+    return { projectId, sessionId };
+}
+export async function loadSessionTranscriptMirror(input) {
+    const scope = parseBeeuniSessionScope(input.beeuniSessionScope);
+    if (!scope)
+        return null;
+    if (input.child) {
+        try {
+            return await getSessionTranscriptSync(scope.projectId, scope.sessionId, {
+                limit: input.limit ?? MIRROR_HYDRATE_LIMIT,
+                signal: input.signal,
+                child: input.child,
+            });
+        }
+        catch {
+            return null;
+        }
+    }
+    const claimed = claimOpenBundle(scope.projectId, scope.sessionId);
+    if (claimed)
+        await claimed;
+    const stashed = takeOpenBundleTranscript(scope.projectId, scope.sessionId);
+    if (stashed)
+        return stashed;
+    if (takeOpenBundleTranscriptAbsence(scope.projectId, scope.sessionId))
+        return null;
+    try {
+        return await getSessionTranscriptSync(scope.projectId, scope.sessionId, {
+            limit: input.limit ?? MIRROR_HYDRATE_LIMIT,
+            signal: input.signal,
+        });
+    }
+    catch {
+        return null;
+    }
+}
+export async function loadOlderSessionTranscriptMirror(input) {
+    const scope = parseBeeuniSessionScope(input.beeuniSessionScope);
+    if (!scope)
+        return null;
+    try {
+        return await getSessionTranscriptSync(scope.projectId, scope.sessionId, {
+            limit: input.limit ?? MIRROR_HYDRATE_LIMIT,
+            before: input.before,
+            signal: input.signal,
+            child: input.child,
+        });
+    }
+    catch {
+        return null;
+    }
+}
+export const SAVED_COPY_REFRESH_DELAY_MS = 3_000;
+export async function refreshSavedCopy(store, projectId, sessionId) {
+    try {
+        const envelope = await getSessionTranscriptSync(projectId, sessionId, {
+            limit: MIRROR_HYDRATE_LIMIT,
+        });
+        if (envelope)
+            await store.write(projectId, sessionId, envelope);
+    }
+    catch {
+    }
+}

package/dist/browser/session-sync/session-cache-ownership.d.ts

@@ -0,0 +1,8 @@
+export declare function resolveSessionCacheOwnerScope(runtimeScope: string, beeuniSessionScope?: string): string | null;
+export declare function sessionCacheOwnerScopesConflict(a: string | null, b: string | null): boolean;
+export declare function getSessionCacheOwnership(sessionId: string): string | null;
+export declare function claimSessionCacheOwnership(sessionId: string, ownerScope: string): {
+    changed: boolean;
+    previousOwnerScope: string | null;
+};
+export declare function resetSessionCacheOwnership(): void;

package/dist/browser/session-sync/session-cache-ownership.js

@@ -0,0 +1,36 @@
+const owners = new Map();
+const AUTHORITATIVE_PREFIX = 'beeuni:';
+function isAuthoritative(ownerScope) {
+    return ownerScope.startsWith(AUTHORITATIVE_PREFIX);
+}
+export function resolveSessionCacheOwnerScope(runtimeScope, beeuniSessionScope) {
+    if (beeuniSessionScope)
+        return `${AUTHORITATIVE_PREFIX}${beeuniSessionScope}`;
+    if (!runtimeScope || runtimeScope === 'none')
+        return null;
+    return `runtime:${runtimeScope}`;
+}
+export function sessionCacheOwnerScopesConflict(a, b) {
+    if (!a || !b || a === b)
+        return false;
+    return isAuthoritative(a) === isAuthoritative(b);
+}
+export function getSessionCacheOwnership(sessionId) {
+    return owners.get(sessionId) ?? null;
+}
+export function claimSessionCacheOwnership(sessionId, ownerScope) {
+    const previousOwnerScope = getSessionCacheOwnership(sessionId);
+    if (previousOwnerScope === ownerScope) {
+        return { changed: false, previousOwnerScope };
+    }
+    if (previousOwnerScope !== null &&
+        !isAuthoritative(ownerScope) &&
+        isAuthoritative(previousOwnerScope)) {
+        return { changed: false, previousOwnerScope };
+    }
+    owners.set(sessionId, ownerScope);
+    return { changed: true, previousOwnerScope };
+}
+export function resetSessionCacheOwnership() {
+    owners.clear();
+}

package/dist/browser/session-sync/session-sync-registry.d.ts

@@ -0,0 +1,44 @@
+import type { Message, Part, SessionStatus } from '../../core/runtime/runtime-types.js';
+import { SessionSyncController, type SessionSyncPage, type SessionSyncReason } from '../../core/session-sync/session-sync-controller.js';
+interface MessagesResponse {
+    data?: Array<{
+        info: Message;
+        parts: Part[];
+    }>;
+    error?: unknown;
+    response?: Response;
+}
+interface SessionMessageClient {
+    session: {
+        messages: (request: {
+            sessionID: string;
+            limit: number;
+            before?: string;
+        }, options?: {
+            signal?: AbortSignal;
+        }) => Promise<MessagesResponse>;
+        status?: () => Promise<{
+            data?: Record<string, SessionStatus>;
+        }>;
+    };
+}
+export declare const ACTIVE_SESSION_PREFETCH_SOURCE: unique symbol;
+type SessionPrefetchSource = string | typeof ACTIVE_SESSION_PREFETCH_SOURCE;
+export declare function readSessionMessagePage(client: SessionMessageClient, sessionId: string, request: {
+    limit: number;
+    before?: string;
+}, signal?: AbortSignal): Promise<SessionSyncPage>;
+export declare function getSessionSyncController(sessionId: string, client?: SessionMessageClient, runtimeScope?: string): SessionSyncController;
+export declare function prefetchSessionSyncOnce(sessionId: string, source: SessionPrefetchSource, client?: SessionMessageClient): Promise<boolean>;
+export declare function clearActiveSessionPrefetches(): void;
+export declare function retainSessionSyncController(sessionId: string, runtimeScope?: string): () => void;
+export declare function reconcileSessionTail(sessionId: string, reason: SessionSyncReason, runtimeScope?: string): Promise<void>;
+export declare function loadSessionRuntimeStatus(sessionId: string, client?: SessionMessageClient): Promise<SessionStatus | null>;
+export declare function loadSessionTranscriptMessages(sessionId: string): Promise<SessionSyncPage['messages']>;
+export declare function noteSessionSyncEvent(event: {
+    type?: string;
+    properties?: unknown;
+}): void;
+export declare function resetSessionSyncControllers(): void;
+export declare function resetSessionSyncControllersForSession(sessionId: string, keepRuntimeScope?: string): void;
+export {};

package/dist/browser/session-sync/session-sync-registry.js

@@ -0,0 +1,253 @@
+import { getClient, getClientForUrl, RuntimeNotReadyError } from '../../core/runtime/client.js';
+import { SandboxNotReadyError, isSandboxNotReadyError } from '../../core/http/runtime-errors.js';
+import { ApiError } from '../../core/http/api/errors.js';
+import { SessionSyncController, loadCompleteSessionHistory, } from '../../core/session-sync/session-sync-controller.js';
+import { getCurrentRuntimeSandboxId, getCurrentRuntimeUrl } from '../../core/session/current-runtime.js';
+import { useSyncStore } from '../stores/sync-store.js';
+export const ACTIVE_SESSION_PREFETCH_SOURCE = Symbol('active-session-prefetch');
+const MAX_CONTROLLERS = 20;
+const controllers = new Map();
+function runtimeScopeKey(runtimeScope) {
+    return runtimeScope ?? getCurrentRuntimeSandboxId() ?? 'none';
+}
+function controllerKey(sessionId, runtimeScope) {
+    return `${runtimeScopeKey(runtimeScope)}\n${sessionId}`;
+}
+function findExistingSessionEntry(sessionId, runtimeScope) {
+    const exact = controllers.get(controllerKey(sessionId, runtimeScope));
+    if (exact)
+        return exact;
+    if (runtimeScopeKey(runtimeScope) !== 'none')
+        return undefined;
+    let match;
+    for (const entry of controllers.values()) {
+        if (entry.sessionId !== sessionId)
+            continue;
+        if (match)
+            return undefined;
+        match = entry;
+    }
+    return match;
+}
+function cmp(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+function messageKey(info) {
+    return `${info.time?.created ?? 0}${info.id}`;
+}
+function messagePageErrorText(result, status) {
+    const err = result.error;
+    if (typeof err === 'string' && err)
+        return err;
+    if (err && typeof err === 'object') {
+        const rec = err;
+        const data = rec.data && typeof rec.data === 'object' ? rec.data : undefined;
+        const message = data?.message ?? rec.message ?? rec.error;
+        if (typeof message === 'string' && message)
+            return message;
+        try {
+            return JSON.stringify(err);
+        }
+        catch {
+        }
+    }
+    return status ? `Session message read failed: ${status}` : 'Session message read failed';
+}
+export async function readSessionMessagePage(client, sessionId, request, signal) {
+    const result = await client.session.messages({
+        sessionID: sessionId,
+        limit: request.limit,
+        ...(request.before ? { before: request.before } : {}),
+    }, signal ? { signal } : undefined);
+    const status = result.response?.status;
+    const failed = result.error !== undefined || (typeof status === 'number' && status >= 400);
+    if (failed) {
+        const message = messagePageErrorText(result, status);
+        if (status === 503 ||
+            isSandboxNotReadyError(result.error) ||
+            isSandboxNotReadyError(message)) {
+            throw new SandboxNotReadyError(message);
+        }
+        throw new ApiError(message, { status });
+    }
+    const items = (Array.isArray(result.data) ? result.data : []).filter((item) => !!item && typeof item === 'object' && !!item.info?.id);
+    return {
+        messages: items
+            .map((item) => ({
+            info: item.info,
+            parts: (Array.isArray(item.parts) ? item.parts : [])
+                .filter((part) => !!part?.id)
+                .sort((a, b) => cmp(a.id, b.id)),
+        }))
+            .sort((a, b) => cmp(messageKey(a.info), messageKey(b.info))),
+        nextCursor: result.response?.headers.get('x-next-cursor') || undefined,
+    };
+}
+function reportTelemetry(sessionId, event) {
+    console.debug('[session-sync]', { sessionId, ...event });
+}
+function resolveClient(key) {
+    const entry = controllers.get(key);
+    if (!entry)
+        throw new RuntimeNotReadyError('Session synchronization controller was retired');
+    if (entry.client)
+        return entry.client;
+    if (!entry.runtimeUrl && entry.runtimeScope === runtimeScopeKey()) {
+        entry.runtimeUrl = getCurrentRuntimeUrl() ?? undefined;
+    }
+    if (!entry.runtimeUrl)
+        throw new RuntimeNotReadyError();
+    entry.client = getClientForUrl(entry.runtimeUrl);
+    return entry.client;
+}
+function createController(sessionId, key) {
+    return new SessionSyncController({
+        sessionId,
+        loadPage: (request, signal) => readSessionMessagePage(resolveClient(key), sessionId, request, signal),
+        hydrate: (messages) => {
+            useSyncStore.getState().hydrate(sessionId, messages);
+        },
+        markLoaded: () => {
+            const state = useSyncStore.getState();
+            if (!(sessionId in state.messages))
+                state.hydrate(sessionId, []);
+        },
+        onTelemetry: (event) => reportTelemetry(sessionId, event),
+    });
+}
+function evictInactiveControllers(protectedKey) {
+    if (controllers.size <= MAX_CONTROLLERS)
+        return;
+    const inactive = [...controllers.entries()]
+        .filter(([key, entry]) => entry.consumers === 0 && key !== protectedKey)
+        .sort((a, b) => a[1].lastUsedAt - b[1].lastUsedAt);
+    for (const [key, entry] of inactive) {
+        entry.controller.destroy();
+        controllers.delete(key);
+        if (controllers.size <= MAX_CONTROLLERS)
+            return;
+    }
+}
+function getOrCreateRegistryEntry(sessionId, client, initialConsumers = 0, runtimeScope) {
+    const key = controllerKey(sessionId, runtimeScope);
+    const existing = controllers.get(key);
+    if (existing) {
+        if (client)
+            existing.client = client;
+        existing.lastUsedAt = Date.now();
+        return existing;
+    }
+    const entry = {
+        sessionId,
+        runtimeScope: runtimeScopeKey(runtimeScope),
+        controller: createController(sessionId, key),
+        client,
+        runtimeUrl: runtimeScopeKey(runtimeScope) === runtimeScopeKey()
+            ? getCurrentRuntimeUrl() ?? undefined
+            : undefined,
+        consumers: initialConsumers,
+        lastUsedAt: Date.now(),
+    };
+    controllers.set(key, entry);
+    return entry;
+}
+export function getSessionSyncController(sessionId, client, runtimeScope) {
+    const key = controllerKey(sessionId, runtimeScope);
+    const entry = getOrCreateRegistryEntry(sessionId, client, 0, runtimeScope);
+    evictInactiveControllers(key);
+    return entry.controller;
+}
+export async function prefetchSessionSyncOnce(sessionId, source, client) {
+    const runtimeScope = source === ACTIVE_SESSION_PREFETCH_SOURCE ? runtimeScopeKey() : source;
+    const key = controllerKey(sessionId, runtimeScope);
+    const existing = controllers.get(key);
+    const entry = getOrCreateRegistryEntry(sessionId, existing?.consumers ? undefined : client, 0, runtimeScope);
+    evictInactiveControllers(key);
+    if (entry.prefetchedSource === source)
+        return true;
+    await entry.controller.reconcile('manual');
+    const succeeded = entry.controller.getSnapshot().freshness === 'fresh';
+    const current = controllers.get(key);
+    if (succeeded && current === entry)
+        current.prefetchedSource = source;
+    return succeeded;
+}
+export function clearActiveSessionPrefetches() {
+    for (const entry of controllers.values()) {
+        if (entry.prefetchedSource === ACTIVE_SESSION_PREFETCH_SOURCE) {
+            entry.prefetchedSource = undefined;
+        }
+    }
+}
+export function retainSessionSyncController(sessionId, runtimeScope) {
+    const key = controllerKey(sessionId, runtimeScope);
+    let entry = controllers.get(key);
+    if (entry) {
+        entry.consumers += 1;
+        entry.lastUsedAt = Date.now();
+    }
+    else {
+        entry = getOrCreateRegistryEntry(sessionId, undefined, 1, runtimeScope);
+    }
+    evictInactiveControllers();
+    const controller = entry.controller;
+    return () => {
+        const current = controllers.get(key);
+        if (!current || current.controller !== controller)
+            return;
+        current.consumers = Math.max(0, current.consumers - 1);
+        current.lastUsedAt = Date.now();
+        if (current.consumers === 0)
+            controller.setBusy(false);
+        evictInactiveControllers();
+    };
+}
+export function reconcileSessionTail(sessionId, reason, runtimeScope) {
+    return getSessionSyncController(sessionId, undefined, runtimeScope).reconcile(reason);
+}
+export async function loadSessionRuntimeStatus(sessionId, client = getClient()) {
+    if (!client.session.status)
+        return null;
+    const result = (await client.session.status());
+    if (result.error !== undefined || result.data === undefined) {
+        throw new Error(`session status read failed: ${JSON.stringify(result.error ?? 'no data')}`);
+    }
+    return result.data[sessionId] ?? { type: 'idle' };
+}
+export function loadSessionTranscriptMessages(sessionId) {
+    return loadCompleteSessionHistory((request) => readSessionMessagePage(getClient(), sessionId, request));
+}
+const TRANSCRIPT_EVENT_TYPES = new Set([
+    'message.updated',
+    'message.part.updated',
+    'message.removed',
+    'message.part.removed',
+]);
+export function noteSessionSyncEvent(event) {
+    if (!event.properties || typeof event.properties !== 'object')
+        return;
+    const properties = event.properties;
+    const info = properties.info;
+    const part = properties.part;
+    const sessionId = (typeof properties.sessionID === 'string' && properties.sessionID) ||
+        info?.sessionID ||
+        part?.sessionID;
+    if (!sessionId)
+        return;
+    if (!TRANSCRIPT_EVENT_TYPES.has(event.type ?? ''))
+        return;
+    findExistingSessionEntry(sessionId)?.controller.noteActivity();
+}
+export function resetSessionSyncControllers() {
+    for (const entry of controllers.values())
+        entry.controller.destroy();
+    controllers.clear();
+}
+export function resetSessionSyncControllersForSession(sessionId, keepRuntimeScope) {
+    for (const [key, entry] of controllers) {
+        if (entry.sessionId !== sessionId || entry.runtimeScope === keepRuntimeScope)
+            continue;
+        entry.controller.destroy();
+        controllers.delete(key);
+    }
+}

package/dist/browser/session-sync/visibility.d.ts

@@ -0,0 +1,6 @@
+export interface VisibilityTarget {
+    visibilityState: string;
+    addEventListener: (type: 'visibilitychange', handler: () => void) => void;
+    removeEventListener: (type: 'visibilitychange', handler: () => void) => void;
+}
+export declare function onTabVisible(run: () => void, target?: VisibilityTarget | undefined): () => void;

package/dist/browser/session-sync/visibility.js

@@ -0,0 +1,21 @@
+import { onHostSignal } from '../../core/session/host-signals.js';
+export function onTabVisible(run, target = typeof document === 'undefined'
+    ? undefined
+    : document) {
+    const stopHost = onHostSignal((signal) => {
+        if (signal === 'visible')
+            run();
+    });
+    if (!target)
+        return stopHost;
+    const handler = () => {
+        if (target.visibilityState !== 'visible')
+            return;
+        run();
+    };
+    target.addEventListener('visibilitychange', handler);
+    return () => {
+        stopHost();
+        target.removeEventListener('visibilitychange', handler);
+    };
+}