Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
import { useEffect, useMemo, useRef, useSyncExternalStore } from 'react';
import { getStickySessionDeviceId } from '@/features/device-link/stickySessionOrigin';
import { createLogger } from '@/lib/logger';
import {
isRemoteSessionSticky,
orcaWorkflowsFor,
orcaWorkflowsForDevice,
subscribeOrcaWorkerChanged,
} from '@/lib/makerTransport';
import { isActiveWorkerStatus, type OrcaWorkerStatus } from '../../../../shared/orca-worker-status';
const log = createLogger('workerProjectionStore');
export interface WorkerInfo {
workerId: string;
sessionId: string;
role: string;
agent: 'claude-code' | 'codex' | 'pi';
model: string;
effort: string | null;
label: string | null;
status: OrcaWorkerStatus;
focused: boolean;
idleSince: string | null;
/** Worker 的 Agent 在另一台电脑或分享上运行(远程供应商);Agent 在任务所在电脑时无此字段。 */
agentDeviceId?: string;
/** 在同账号另一台电脑运行的 Worker;本机 Worker 无此字段。 */
executionDevice?: WorkerExecutionDevice;
}
export interface WorkerExecutionDevice {
deviceId: string;
/** 运行设备上的真实任务 id;sessionId 是本机不跑 Agent 的代理任务。 */
remoteSessionId: string;
deviceName: string | null;
/** false = 暂时无法获取状态;null = 尚未探测。 */
reachable: boolean | null;
workingDir: string | null;
}
function mapExecutionDevice(raw: unknown): WorkerExecutionDevice | undefined {
if (!raw || typeof raw !== 'object') return undefined;
const value = raw as Record<string, unknown>;
if (typeof value.deviceId !== 'string' || typeof value.remoteSessionId !== 'string') {
return undefined;
}
return {
deviceId: value.deviceId,
remoteSessionId: value.remoteSessionId,
deviceName: typeof value.deviceName === 'string' && value.deviceName ? value.deviceName : null,
reachable: typeof value.reachable === 'boolean' ? value.reachable : null,
workingDir: typeof value.workingDir === 'string' && value.workingDir ? value.workingDir : null,
};
}
export interface WorkersSnapshot {
workers: WorkerInfo[];
softLimit: number;
hardLimit: number;
workerStatus: 'idle' | 'applied' | 'failed';
requestId: number;
updatedAt: number;
}
export interface WorkersRefreshResult {
leadSessionId: string;
requestId: number;
status: 'applied' | 'failed';
workers: WorkerInfo[];
}
export interface WorkerCreationRefreshResult {
status: 'applied' | 'failed';
workers: WorkerInfo[];
hardLimit: number | null;
}
const DEFAULT_SOFT_LIMIT = 5;
const DEFAULT_HARD_LIMIT = 8;
const DEFAULT_SNAPSHOT: WorkersSnapshot = {
workers: [],
softLimit: DEFAULT_SOFT_LIMIT,
hardLimit: DEFAULT_HARD_LIMIT,
workerStatus: 'idle',
requestId: 0,
updatedAt: 0,
};
const DEFAULT_COALESCE_MS = 100;
const ACTIVE_REVALIDATE_FRESH_MS = 1_000;
const LOCAL_BATCH_CHUNK_SIZE = 200;
interface LeadEntry {
snapshot: WorkersSnapshot;
listeners: Set<() => void>;
ownerCount: number;
unsubscribe: (() => void) | null;
requestSeq: number;
settingsSeq: number;
inFlight: Promise<WorkersRefreshResult> | null;
queuedRefresh: QueuedRefresh | null;
authoritativeWaiters: Set<(value: WorkersRefreshResult) => void>;
settingsInFlight: Promise<WorkerSettingsRefreshResult> | null;
settingsUpdatedAt: number;
}
interface QueuedRefresh {
promise: Promise<WorkersRefreshResult>;
resolve: (value: WorkersRefreshResult) => void;
timer: number | null;
ready: boolean;
}
interface WorkerSettingsRefreshResult {
status: 'applied' | 'failed';
hardLimit: number | null;
}
interface LocalBatchItem {
leadSessionId: string;
requestId: number;
entry: LeadEntry;
resolve: (value: WorkersRefreshResult) => void;
}
let coalesceMs = DEFAULT_COALESCE_MS;
const entries = new Map<string, LeadEntry>();
let globalVersion = 0;
const globalListeners = new Set<() => void>();
let localBatchTimer: number | null = null;
const localBatchQueue = new Map<string, LocalBatchItem>();
function nowMs(): number {
return Date.now();
}
function scheduleTimer(cb: () => void, delayMs: number): number {
return window.setTimeout(cb, delayMs);
}
function clearTimer(timer: number): void {
window.clearTimeout(timer);
}
function stableLeadSessionIds(leadSessionIds: readonly string[]): string[] {
return [...new Set(leadSessionIds)].sort();
}
function stableLeadSessionIdsKey(leadSessionIds: readonly string[]): string {
return stableLeadSessionIds(leadSessionIds).join('\0');
}
function emitGlobal(): void {
globalVersion += 1;
for (const listener of globalListeners) listener();
}
function emitEntry(entry: LeadEntry): void {
for (const listener of entry.listeners) listener();
emitGlobal();
}
function getEntry(leadSessionId: string): LeadEntry {
let entry = entries.get(leadSessionId);
if (!entry) {
entry = {
snapshot: DEFAULT_SNAPSHOT,
listeners: new Set(),
ownerCount: 0,
unsubscribe: null,
requestSeq: 0,
settingsSeq: 0,
inFlight: null,
queuedRefresh: null,
authoritativeWaiters: new Set(),
settingsInFlight: null,
settingsUpdatedAt: 0,
};
entries.set(leadSessionId, entry);
}
return entry;
}
function mapWorkerRecord(raw: Record<string, unknown>): WorkerInfo {
const session = raw.session as Record<string, unknown> | undefined;
return {
workerId: raw.id as string,
sessionId: raw.sessionId as string,
role: (raw.role as string) ?? 'developer',
agent:
session?.agentKind === 'codex' ? 'codex' : session?.agentKind === 'pi' ? 'pi' : 'claude-code',
model: (session?.model as string) ?? 'claude-sonnet-4-6',
effort: (session?.effort as string | null) ?? null,
label: (raw.label as string | null) ?? null,
status: (raw.status as WorkerInfo['status']) ?? 'idle',
focused: (raw.focused as boolean) ?? false,
idleSince: (raw.idleSince as string | null) ?? null,
...(typeof session?.agentDeviceId === 'string' && session.agentDeviceId
? { agentDeviceId: session.agentDeviceId }
: {}),
...(mapExecutionDevice(raw.executionDevice)
? { executionDevice: mapExecutionDevice(raw.executionDevice) }
: {}),
};
}
function writeWorkersSnapshot(
leadSessionId: string,
entry: LeadEntry,
requestId: number,
status: WorkersSnapshot['workerStatus'],
workers: WorkerInfo[],
): WorkersRefreshResult {
entry.snapshot = {
...entry.snapshot,
workers,
workerStatus: status,
requestId,
updatedAt: nowMs(),
};
emitEntry(entry);
return { leadSessionId, requestId, status: status === 'applied' ? 'applied' : 'failed', workers };
}
function failedWorkersResult(leadSessionId: string, entry: LeadEntry): WorkersRefreshResult {
return {
leadSessionId,
requestId: entry.requestSeq,
status: 'failed',
workers: entry.snapshot.workers,
};
}
function resolveAuthoritativeWaiters(entry: LeadEntry, result: WorkersRefreshResult): void {
if (entry.inFlight || entry.queuedRefresh || entry.authoritativeWaiters.size === 0) return;
const waiters = [...entry.authoritativeWaiters];
entry.authoritativeWaiters.clear();
for (const resolve of waiters) resolve(result);
}
function maybeStartQueuedRefresh(leadSessionId: string, entry: LeadEntry): void {
const queued = entry.queuedRefresh;
if (!queued?.ready || entry.inFlight) return;
entry.queuedRefresh = null;
if (queued.timer !== null) clearTimer(queued.timer);
const request = startLeadRequest(leadSessionId, entry);
void request.then(queued.resolve);
}
function finishLeadRequest(
leadSessionId: string,
entry: LeadEntry,
request: Promise<WorkersRefreshResult>,
): void {
void request.then((result) => {
if (entry.inFlight !== request) return;
entry.inFlight = null;
maybeStartQueuedRefresh(leadSessionId, entry);
resolveAuthoritativeWaiters(entry, result);
});
}
function normalizeBatchResponse(
response: unknown,
): Record<string, Array<Record<string, unknown>>> {
if (!response || typeof response !== 'object') return {};
return response as Record<string, Array<Record<string, unknown>>>;
}
function hasOwnKey(value: object, key: string): boolean {
return Object.prototype.hasOwnProperty.call(value, key);
}
function projectionWorkflowsFor(leadSessionId: string) {
const deviceId = getStickySessionDeviceId(leadSessionId);
return deviceId ? orcaWorkflowsForDevice(deviceId) : orcaWorkflowsFor(leadSessionId);
}
async function listLocalWorkersByLeads(
leadSessionIds: readonly string[],
): Promise<Record<string, Array<Record<string, unknown>>>> {
const batchApi = window.electronAPI.localDb.orcaWorkflows.listWorkersByLeads;
if (!batchApi) {
const rows = await Promise.all(
leadSessionIds.map(async (leadSessionId) => {
const workers = await window.electronAPI.localDb.orcaWorkflows.listWorkersByLead(
leadSessionId,
);
return [
leadSessionId,
workers as unknown as Array<Record<string, unknown>>,
] as const;
}),
);
return Object.fromEntries(rows);
}
const chunks: string[][] = [];
for (let index = 0; index < leadSessionIds.length; index += LOCAL_BATCH_CHUNK_SIZE) {
chunks.push(leadSessionIds.slice(index, index + LOCAL_BATCH_CHUNK_SIZE));
}
const responses = await Promise.all(chunks.map((chunk) => batchApi(chunk)));
return Object.assign({}, ...responses.map(normalizeBatchResponse));
}
function flushLocalBatch(): void {
localBatchTimer = null;
const batch = [...localBatchQueue.values()];
localBatchQueue.clear();
if (batch.length === 0) return;
const leadSessionIds = batch.map((item) => item.leadSessionId);
const request = listLocalWorkersByLeads(leadSessionIds);
void request
.then((raw) => {
const grouped = normalizeBatchResponse(raw);
for (const item of batch) {
if (item.entry.requestSeq !== item.requestId) {
item.resolve({
leadSessionId: item.leadSessionId,
requestId: item.entry.requestSeq,
status: 'failed',
workers: item.entry.snapshot.workers,
});
} else {
const records = grouped[item.leadSessionId];
if (!hasOwnKey(grouped, item.leadSessionId) || !Array.isArray(records)) {
log.warn('listWorkersByLeads returned invalid lead entry', {
leadSessionId: item.leadSessionId,
});
item.resolve(writeWorkersSnapshot(
item.leadSessionId,
item.entry,
item.requestId,
'failed',
item.entry.snapshot.workers,
));
continue;
}
const workers = records.map(mapWorkerRecord);
item.resolve(writeWorkersSnapshot(
item.leadSessionId,
item.entry,
item.requestId,
'applied',
workers,
));
}
}
})
.catch((err) => {
log.warn('listWorkersByLeads failed', err instanceof Error ? err.message : String(err));
for (const item of batch) {
item.resolve(
item.entry.requestSeq === item.requestId
? writeWorkersSnapshot(
item.leadSessionId,
item.entry,
item.requestId,
'failed',
item.entry.snapshot.workers,
)
: failedWorkersResult(item.leadSessionId, item.entry),
);
}
});
}
function enqueueLocalBatch(
leadSessionId: string,
entry: LeadEntry,
requestId: number,
): Promise<WorkersRefreshResult> {
const request = new Promise<WorkersRefreshResult>((resolve) => {
localBatchQueue.set(leadSessionId, { leadSessionId, requestId, entry, resolve });
if (localBatchTimer === null) {
localBatchTimer = scheduleTimer(flushLocalBatch, 0);
}
});
entry.inFlight = request;
finishLeadRequest(leadSessionId, entry, request);
return request;
}
function startRemoteLeadRequest(
leadSessionId: string,
entry: LeadEntry,
requestId: number,
): Promise<WorkersRefreshResult> {
const request = projectionWorkflowsFor(leadSessionId)
.listWorkersByLead(leadSessionId)
.then((records) => {
if (entry.requestSeq !== requestId) {
return {
leadSessionId,
requestId: entry.requestSeq,
status: 'failed' as const,
workers: entry.snapshot.workers,
};
}
const workers = (records as unknown as Array<Record<string, unknown>>).map(mapWorkerRecord);
return writeWorkersSnapshot(leadSessionId, entry, requestId, 'applied', workers);
})
.catch((err) => {
if (entry.requestSeq === requestId) {
log.warn('listWorkersByLead failed', err instanceof Error ? err.message : String(err));
return writeWorkersSnapshot(
leadSessionId,
entry,
requestId,
'failed',
entry.snapshot.workers,
);
}
return {
leadSessionId,
requestId: entry.requestSeq,
status: 'failed' as const,
workers: entry.snapshot.workers,
};
});
entry.inFlight = request;
finishLeadRequest(leadSessionId, entry, request);
return request;
}
function requestWorkersProjection(
leadSessionId: string,
options: {
mode?: 'join' | 'active' | 'authoritative' | 'event';
minFreshMs?: number;
} = {},
): Promise<WorkersRefreshResult> {
const entry = getEntry(leadSessionId);
const mode = options.mode ?? 'join';
const minFreshMs = options.minFreshMs ?? 0;
if (
mode === 'active' &&
minFreshMs > 0 &&
entry.snapshot.workerStatus === 'applied' &&
nowMs() - entry.snapshot.updatedAt <= minFreshMs
) {
return Promise.resolve({
leadSessionId,
requestId: entry.snapshot.requestId,
status: 'applied',
workers: entry.snapshot.workers,
});
}
if (mode === 'event') {
return queueWorkersRefresh(leadSessionId, entry, coalesceMs);
}
if (mode === 'authoritative') {
const settled = new Promise<WorkersRefreshResult>((resolve) => {
entry.authoritativeWaiters.add(resolve);
});
if (entry.inFlight || entry.queuedRefresh) {
void queueWorkersRefresh(leadSessionId, entry, 0);
} else {
startLeadRequest(leadSessionId, entry);
}
return settled;
}
if (entry.inFlight) return entry.inFlight;
if (entry.queuedRefresh) return entry.queuedRefresh.promise;
return startLeadRequest(leadSessionId, entry);
}
function queueWorkersRefresh(
leadSessionId: string,
entry: LeadEntry,
delayMs: number,
): Promise<WorkersRefreshResult> {
const existing = entry.queuedRefresh;
if (existing) {
if (delayMs === 0 && !existing.ready) {
if (existing.timer !== null) clearTimer(existing.timer);
existing.timer = null;
existing.ready = true;
maybeStartQueuedRefresh(leadSessionId, entry);
} else if (delayMs > 0 && !existing.ready) {
if (existing.timer !== null) clearTimer(existing.timer);
existing.timer = scheduleTimer(() => {
existing.timer = null;
existing.ready = true;
maybeStartQueuedRefresh(leadSessionId, entry);
}, delayMs);
}
return existing.promise;
}
let resolveQueued!: (value: WorkersRefreshResult) => void;
const queued: QueuedRefresh = {
promise: new Promise<WorkersRefreshResult>((resolve) => {
resolveQueued = resolve;
}),
resolve: (value) => resolveQueued(value),
timer: null,
ready: delayMs === 0,
};
entry.queuedRefresh = queued;
if (delayMs > 0) {
queued.timer = scheduleTimer(() => {
queued.timer = null;
queued.ready = true;
maybeStartQueuedRefresh(leadSessionId, entry);
}, delayMs);
}
maybeStartQueuedRefresh(leadSessionId, entry);
return queued.promise;
}
function startLeadRequest(
leadSessionId: string,
entry: LeadEntry,
): Promise<WorkersRefreshResult> {
const requestId = entry.requestSeq + 1;
entry.requestSeq = requestId;
if (isRemoteSessionSticky(leadSessionId)) {
return startRemoteLeadRequest(leadSessionId, entry, requestId);
}
return enqueueLocalBatch(leadSessionId, entry, requestId);
}
function invalidateLead(leadSessionId: string): void {
const entry = getEntry(leadSessionId);
if (entry.ownerCount <= 0) return;
void requestWorkersProjection(leadSessionId, { mode: 'event' });
}
export function retainWorkerProjection(leadSessionId: string | undefined): () => void {
if (!leadSessionId) return () => undefined;
const entry = getEntry(leadSessionId);
entry.ownerCount += 1;
if (entry.ownerCount === 1) {
entry.unsubscribe = subscribeOrcaWorkerChanged(leadSessionId, () => invalidateLead(leadSessionId));
void requestWorkersProjection(leadSessionId);
}
return () => {
entry.ownerCount = Math.max(0, entry.ownerCount - 1);
if (entry.ownerCount !== 0) return;
entry.unsubscribe?.();
entry.unsubscribe = null;
if (entry.queuedRefresh && entry.authoritativeWaiters.size === 0) {
if (entry.queuedRefresh.timer !== null) clearTimer(entry.queuedRefresh.timer);
entry.queuedRefresh.resolve(failedWorkersResult(leadSessionId, entry));
entry.queuedRefresh = null;
}
// 无人持有后快照不再刷新;按持有范围派生的整表视图(listRetainedWorkerProjections)要随之收敛。
emitGlobal();
};
}
export function useWorkerProjectionOwner(leadSessionId: string | undefined): void {
useEffect(() => retainWorkerProjection(leadSessionId), [leadSessionId]);
}
export function useWorkerProjectionOwners(leadSessionIds: readonly string[]): void {
const key = stableLeadSessionIdsKey(leadSessionIds);
const retainedRef = useRef<Map<string, () => void>>(new Map());
const stableIds = useMemo(() => (key.length > 0 ? key.split('\0') : []), [key]);
useEffect(() => {
const retained = retainedRef.current;
const next = new Set(stableIds);
for (const [leadSessionId, release] of retained) {
if (!next.has(leadSessionId)) {
release();
retained.delete(leadSessionId);
}
}
for (const leadSessionId of stableIds) {
if (!retained.has(leadSessionId)) {
retained.set(leadSessionId, retainWorkerProjection(leadSessionId));
}
}
}, [stableIds]);
useEffect(() => {
return () => {
const retained = retainedRef.current;
for (const release of retained.values()) release();
retained.clear();
};
}, []);
}
export function getWorkerProjectionSnapshot(
leadSessionId: string | undefined,
): WorkersSnapshot {
if (!leadSessionId) return DEFAULT_SNAPSHOT;
return entries.get(leadSessionId)?.snapshot ?? DEFAULT_SNAPSHOT;
}
export function subscribeWorkerProjection(
leadSessionId: string | undefined,
listener: () => void,
): () => void {
if (!leadSessionId) return () => undefined;
const entry = getEntry(leadSessionId);
entry.listeners.add(listener);
return () => {
entry.listeners.delete(listener);
};
}
export function useWorkerProjection(leadSessionId: string | undefined): WorkersSnapshot {
return useSyncExternalStore(
(listener) => subscribeWorkerProjection(leadSessionId, listener),
() => getWorkerProjectionSnapshot(leadSessionId),
() => getWorkerProjectionSnapshot(leadSessionId),
);
}
export function subscribeAllWorkerProjections(listener: () => void): () => void {
globalListeners.add(listener);
return () => {
globalListeners.delete(listener);
};
}
export function getAllWorkerProjectionVersion(): number {
return globalVersion;
}
/**
* 当前有人持有的 Lead 投影。无人持有的条目不再订阅 Worker 变化(如协同已结束、Lead 已
* 不在任何列表里),快照可能过期,不能作为跨 Lead 派生的依据。变化随
* subscribeAllWorkerProjections / getAllWorkerProjectionVersion 广播。
*/
export function listRetainedWorkerProjections(): Array<readonly [string, WorkersSnapshot]> {
const result: Array<readonly [string, WorkersSnapshot]> = [];
for (const [leadSessionId, entry] of entries) {
if (entry.ownerCount > 0) result.push([leadSessionId, entry.snapshot]);
}
return result;
}
export function useWorkerProjectionVersion(): number {
return useSyncExternalStore(
subscribeAllWorkerProjections,
getAllWorkerProjectionVersion,
getAllWorkerProjectionVersion,
);
}
export function revalidateWorkersProjection(
leadSessionId: string,
): Promise<WorkersRefreshResult> {
return requestWorkersProjection(leadSessionId, { mode: 'authoritative' });
}
export function revalidateActiveWorkersProjection(leadSessionId: string): Promise<WorkersRefreshResult> {
return requestWorkersProjection(leadSessionId, {
mode: 'active',
minFreshMs: ACTIVE_REVALIDATE_FRESH_MS,
});
}
function requestWorkerSettings(
leadSessionId: string,
minFreshMs = 0,
): Promise<WorkerSettingsRefreshResult> {
const entry = getEntry(leadSessionId);
if (minFreshMs > 0 && nowMs() - entry.settingsUpdatedAt <= minFreshMs) {
return Promise.resolve({ status: 'applied', hardLimit: entry.snapshot.hardLimit });
}
if (entry.settingsInFlight) return entry.settingsInFlight;
const requestId = entry.settingsSeq + 1;
entry.settingsSeq = requestId;
const request = projectionWorkflowsFor(leadSessionId)
.getCollaborationSettings()
.then((settings) => {
if (entry.settingsSeq !== requestId) return { status: 'failed' as const, hardLimit: null };
const raw = settings as Record<string, unknown> | null;
const rawHardLimit = raw?.workerHardLimit;
const rawSoftLimit = raw?.workerSoftLimit;
const hardLimit =
typeof rawHardLimit === 'number' && Number.isFinite(rawHardLimit) && rawHardLimit >= 0
? rawHardLimit
: null;
const softLimit =
typeof rawSoftLimit === 'number' && Number.isFinite(rawSoftLimit) && rawSoftLimit >= 0
? rawSoftLimit
: null;
if (hardLimit === null) return { status: 'failed' as const, hardLimit: null };
entry.snapshot = {
...entry.snapshot,
hardLimit,
...(softLimit !== null ? { softLimit } : {}),
};
entry.settingsUpdatedAt = nowMs();
emitEntry(entry);
return { status: 'applied' as const, hardLimit };
})
.catch(() => ({ status: 'failed' as const, hardLimit: null }));
entry.settingsInFlight = request;
void request.finally(() => {
if (entry.settingsInFlight === request) entry.settingsInFlight = null;
});
return request;
}
export function revalidateActiveWorkerSettings(
leadSessionId: string,
): Promise<WorkerSettingsRefreshResult> {
return requestWorkerSettings(leadSessionId, ACTIVE_REVALIDATE_FRESH_MS);
}
export async function refreshWorkerCreationState(
leadSessionId: string,
): Promise<WorkerCreationRefreshResult> {
const [workersResult, settingsResult] = await Promise.all([
requestWorkersProjection(leadSessionId, { mode: 'authoritative' }),
requestWorkerSettings(leadSessionId),
]);
if (workersResult.status !== 'applied' || settingsResult.status !== 'applied') {
return {
status: 'failed',
workers: workersResult.workers,
hardLimit: settingsResult.hardLimit,
};
}
return {
status: 'applied',
workers: workersResult.workers,
hardLimit: settingsResult.hardLimit,
};
}
export function getActiveWorkerCount(workers: readonly WorkerInfo[]): number {
return workers.filter((w) => isActiveWorkerStatus(w.status)).length;
}
export function clearWorkerProjectionStore(leadSessionId?: string): void {
const clearEntry = (id: string, entry: LeadEntry) => {
entry.requestSeq += 1;
entry.settingsSeq += 1;
entry.inFlight = null;
entry.settingsInFlight = null;
const failed = failedWorkersResult(id, entry);
const queuedBatchItem = localBatchQueue.get(id);
if (queuedBatchItem?.entry === entry) {
localBatchQueue.delete(id);
queuedBatchItem.resolve(failed);
}
if (entry.queuedRefresh) {
if (entry.queuedRefresh.timer !== null) clearTimer(entry.queuedRefresh.timer);
entry.queuedRefresh.resolve(failed);
entry.queuedRefresh = null;
}
for (const resolve of entry.authoritativeWaiters) resolve(failed);
entry.authoritativeWaiters.clear();
entry.unsubscribe?.();
entry.unsubscribe = null;
entry.snapshot = { ...DEFAULT_SNAPSHOT };
entry.settingsUpdatedAt = 0;
emitEntry(entry);
if (entry.ownerCount > 0) {
entry.unsubscribe = subscribeOrcaWorkerChanged(id, () => invalidateLead(id));
void requestWorkersProjection(id);
} else if (entry.listeners.size === 0) {
entries.delete(id);
}
};
if (leadSessionId) {
const entry = entries.get(leadSessionId);
if (entry) clearEntry(leadSessionId, entry);
} else {
for (const [id, entry] of entries) clearEntry(id, entry);
}
if (localBatchQueue.size === 0 && localBatchTimer !== null) {
clearTimer(localBatchTimer);
localBatchTimer = null;
}
emitGlobal();
}
export function __setWorkerProjectionCoalesceMsForTest(value: number): void {
coalesceMs = value;
}
export function __getWorkerProjectionOwnerCountForTest(leadSessionId: string): number {
return entries.get(leadSessionId)?.ownerCount ?? 0;
}