dsh-bots 0.0.1 → 0.2.10

package/lib/types/shared.d.ts

@@ -0,0 +1,191 @@
+/**
+ * Wire types shared by the host half (gateway bridge) and the client half
+ * (web UI). Keep everything JSON-serializable: these shapes cross the
+ * connection RPC boundary verbatim.
+ * @module dsh-bots/shared
+ */
+/**
+ * Trimmed agent projection the UI renders.
+ *
+ * The projection is deliberately WIDER than the rows it draws: the sidebar
+ * needs unread counts, the hidden-from-sidebar flag, and the authoritative
+ * composing state (never a client-side guess) to reach native parity. Only
+ * genuinely unbounded fields are held back — `avatarDataUrl` is capped by
+ * {@link AVATAR_DATA_URL_MAX} so a list poll can never carry megabytes.
+ */
+export interface AgentInfo {
+    id: string;
+    name: string;
+    description: string;
+    title: string;
+    isGroup: boolean;
+    memberIds: string[];
+    isRunning: boolean;
+    isActive: boolean;
+    lastMessagePreview: string | null;
+    updatedAt: string | null;
+    /** Authoritative "assistant is producing a reply" flag from the gateway. */
+    isComposingMessage: boolean;
+    hasUnread: boolean;
+    unreadCount: number;
+    /** User hid this agent from the sidebar; the nav must not list it. */
+    isHiddenFromSidebar: boolean;
+    /** Non-null when the agent is blocked waiting on the user. */
+    awaitingUserResponse: string | null;
+    lastActivityAt: number | null;
+    /** Inline avatar image, or null when absent/oversized (see hasAvatar). */
+    avatarDataUrl: string | null;
+    avatarShape: string | null;
+    avatarColor: string | null;
+    /** True when the agent has an avatar, even if it was too large to inline. */
+    hasAvatar: boolean;
+}
+/** Largest avatar data URL inlined into a list response (bytes). */
+export declare const AVATAR_DATA_URL_MAX: number;
+/** Workspace row (from the host workspaceRegistry). */
+export interface WorkspaceInfo {
+    id: string;
+    title: string;
+    path: string | null;
+}
+/** Recent dsh session row (from the host sessionQuery + title snapshots). */
+export interface SessionInfo {
+    id: string;
+    title: string;
+    live: boolean;
+}
+/** Gateway health/discovery result. */
+export interface GatewayInfo {
+    ok: boolean;
+    baseUrl?: string;
+    port?: number;
+    pid?: number | null;
+    hasToken?: boolean;
+    reason?: string;
+    /** Effective sdk-bots data directory (from plugin config, not a constant). */
+    dataDir?: string;
+    /**
+     * Box workspace root the engine's exec-daemon guards paths against
+     * (plugin-computed default `<dataDir>/box-workspace`; the engine's
+     * `/health` value wins once the engine exposes it). Per-agent working
+     * directories live at `<root>/agents/<agentId>`.
+     */
+    workspaceRoot?: string;
+    health?: {
+        pid: number | null;
+        isBusy: boolean;
+        activeAgentId: string | null;
+        startedAt: string | null;
+    };
+}
+/**
+ * One transcript entry, normalized to a small display union.
+ *
+ * sdk-bots emits many wire kinds (`message`, `send-message`, `tool-call`,
+ * `tool-result`, `thinking`, …). The host collapses them into `display`, so
+ * the client renders on a closed set instead of sniffing raw shapes — the
+ * previous UI read `entry.content` unconditionally and drew blanks for every
+ * kind that keeps its text somewhere else.
+ */
+export type TranscriptDisplay = 'user' | 'assistant' | 'tool' | 'thinking' | 'event';
+export interface TranscriptEntry {
+    id: string;
+    /** Raw sdk-bots wire kind, kept for diagnostics and future kinds. */
+    kind: string;
+    /** Closed display union the renderer switches on. */
+    display: TranscriptDisplay;
+    timestampMs: number | null;
+    role: string | null;
+    content: string;
+    authorId: string | null;
+    authorName: string | null;
+    /** Streaming tail: the renderer shows a caret and suppresses the timestamp. */
+    isStreaming: boolean;
+    /** Tool name for `display: 'tool'` entries. */
+    toolName: string | null;
+    /** `running` | `ok` | `error` for `display: 'tool'` entries. */
+    toolStatus: 'running' | 'ok' | 'error' | null;
+}
+/**
+ * Every prop the dsh shell's renderer puts on a slot component before the
+ * entry's own `inject` result, and how our `sidebar.workspaces` shadow
+ * reproduces it when it re-renders the shipped entry underneath.
+ *
+ * Taking over a `single` slot means taking over this assembly. The list is the
+ * contract: `tests/delegation.spec.ts` reads the installed renderer and fails
+ * if it grows a key that is not accounted for here, so a dsh upgrade surfaces
+ * as a red test rather than as another silently blank region.
+ */
+export declare const DELEGATED_KIT_KEYS: Record<string, 'synthesized' | 'session-only' | 'guarded'>;
+/** Plugin configuration supplied through cordis.yml. */
+export interface Config {
+    /** sdk-bots data directory holding gateway.json. */
+    dataDir: string;
+}
+/** `bots/<method>` RPC request/response envelope used by the web client. */
+export type RpcEnvelope<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: {
+        message: string;
+    };
+};
+/** One normalized SSE channel event with a local monotonic seq. */
+export interface SseEvent {
+    seq: number;
+    channel: string;
+    data: unknown;
+}
+/** Snapshot of the host SSE ring lifecycle for the UI status line. */
+export interface SseState {
+    running: boolean;
+    ok: boolean;
+    lastError: string | null;
+    connectedAt: string | null;
+    droppedAt: string | null;
+    buffered: number;
+    total: number;
+}
+/** Reply to `bots.eventsSince(seq)`: replay from the ring plus live status. */
+export interface EventsSinceResult {
+    events: SseEvent[];
+    /** Next seq the caller should request next poll. */
+    nextSeq: number;
+    state: SseState;
+    /**
+     * Unread counts per agent id, computed on the host from the same ring
+     * (plugin-owned model — the gateway's own unreadCount is desktop-app
+     * semantics and never accumulates headless). Only non-zero entries appear.
+     */
+    unread?: Record<string, number>;
+}
+/**
+ * One installed MCP server row (gateway `listMcpServers` projection).
+ * `status` is the runtime state reported by the engine — `connected`,
+ * `needsAuth`, `error`, … — the settings page maps it onto StateDot states.
+ */
+export interface McpServerInfo {
+    id: string;
+    serverIdentifier: string;
+    name: string;
+    status: string;
+    accountKey: string;
+    transport: string;
+    toolCount: number;
+    disabledToolCount?: number;
+    statusDetail?: string;
+    customInstructions?: string;
+    [key: string]: unknown;
+}
+/** One routed MCP tool row (gateway `listRoutedMcpTools` projection). */
+export interface McpToolInfo {
+    /** Dynamic registration name the model addresses. */
+    name: string;
+    providerIdentifier: string;
+    /** Underlying tool name on the server. */
+    toolName: string;
+    description?: string;
+    inputSchema?: unknown;
+}

package/lib/types/sse.d.ts

@@ -0,0 +1,79 @@
+/**
+ * SSE plumbing for the host half — pure ring + parser (unit-tested) and a
+ * native `fetch` listener that keeps the ring fed from the sdk-bots gateway
+ * `/events` endpoint. The web client has no network, so this is the only live
+ * event path; it replays through `bots.eventsSince(seq)`.
+ *
+ * The wire uses `Accept-Encoding: identity` to sidestep gzip/deflate handling
+ * in the host fetch layer (the gateway also supports `?token=` for the old
+ * browser path, but we always send the `authorization` header).
+ * @module dsh-bots/sse
+ */
+import type { EventsSinceResult, SseEvent, SseState } from './shared.js';
+export type { EventsSinceResult, SseEvent, SseState };
+/** Incremental SSE wire parser: feed string chunks, receive frames. */
+export declare class SseParser {
+    private readonly onEvent;
+    private buffer;
+    private event;
+    private dataLines;
+    constructor(onEvent: (event: string, data: string) => void);
+    push(chunk: string): void;
+    private feedLine;
+}
+/** Bounded, monotonic ring of normalized events with O(log n) `eventsSince`. */
+export declare class SseRingBuffer {
+    /** Optional side-channel observer (unread tracking); must never throw. */
+    private readonly onPush?;
+    private readonly capacity;
+    private entries;
+    private nextSeq;
+    constructor(capacity?: number, 
+    /** Optional side-channel observer (unread tracking); must never throw. */
+    onPush?: ((channel: string, data: unknown) => void) | undefined);
+    /** Append one event; returns its assigned seq. */
+    push(channel: string, data: unknown): number;
+    /** Replay events strictly after `seq`, or everything when the seq fell off. */
+    eventsSince(seq: number): SseEvent[];
+    get size(): number;
+    get total(): number;
+}
+/**
+ * Long-lived `/events` listener. Re-resolves discovery on every connect so a
+ * restarted sdk-bots host is picked up automatically; reconnects are silent
+ * and bounded. Deliberately never throws — errors surface via `state()`.
+ */
+export declare class GatewaySseClient {
+    private readonly ring;
+    private readonly resolveBase;
+    private readonly reconnectBaseMs;
+    private readonly channels?;
+    private readonly onConnected?;
+    private ac;
+    private timer;
+    private stopped;
+    private ok;
+    private lastError;
+    private connectedAt;
+    private droppedAt;
+    private attempt;
+    constructor(opts: {
+        ring?: SseRingBuffer;
+        resolveBase: () => {
+            url: string;
+            token: string | null;
+        } | null;
+        reconnectBaseMs?: number;
+        /** Optional `channels` subscription subset, e.g. `transcript,agents`. */
+        channels?: string[];
+        /** Fired after every successful (re)connect — unread rebase hook. */
+        onConnected?: () => void;
+    });
+    get buffer(): SseRingBuffer;
+    start(): void;
+    stop(): void;
+    state(): SseState;
+    eventsSince(seq: number): EventsSinceResult;
+    private connect;
+    private schedule;
+}

package/lib/types/unread.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Per-agent unread tracking for the sidebar badge.
+ *
+ * Why not the gateway's `unreadCount`? The sdk-bots host models unread state
+ * for the Grok desktop app: arrivals only count on the single `activeSession`,
+ * a focused window marks everything read instantly, and any transcript READ
+ * (`openAgentBounded` → `markAgentViewed`) clears the marker — which our own
+ * tail polling trips constantly. On a headless local gateway that model never
+ * accumulates (every agent observed at `unreadCount: 0` despite activity).
+ *
+ * So the plugin owns the model instead, at the one layer that is always
+ * watching: the host half's SSE ring. Rules:
+ *
+ *   - A "message" is a human-visible transcript kind (user prompt, bot reply,
+ *     attachment) — never tool calls, thinking, or system events.
+ *   - Each agent has a persisted marker `lastReadAtMs` ("读到哪了") in
+ *     `<dataDir>/dsh-bots-unread.json`; opening the conversation advances it.
+ *   - Live arrivals with `timestampMs > marker` bump the count; anything at or
+ *     before the marker is already-read history and is ignored (this is what
+ *     makes snapshot replays on SSE reconnect idempotent).
+ *   - After a restart the in-memory counts are gone but the markers survive,
+ *     so a rebase from transcript tails reconstructs the counts exactly.
+ *   - First run (no marker file yet) treats all existing history as read —
+ *     an upgrade must not light up 30 badges of backlog.
+ * @module dsh-bots/unread
+ */
+/** True when a transcript entry kind should raise the unread badge. */
+export declare function isMessageEntryKind(kind: unknown): boolean;
+/** Seconds/milliseconds/ISO → epoch ms; null when unreadable. */
+export declare function entryEpochMs(raw: unknown): number | null;
+/** Minimal shape the store needs from a wire transcript entry. */
+export interface UnreadEntry {
+    kind?: unknown;
+    timestampMs?: unknown;
+}
+/**
+ * Unread counts + persisted read markers, one instance per plugin host.
+ * All mutations are crash-safe: markers flush to disk synchronously (a few
+ * hundred bytes), counts are reconstructible so they stay in memory.
+ */
+export declare class UnreadStore {
+    private readonly filePath;
+    private readonly now;
+    private markers;
+    private countBy;
+    private loaded;
+    /** True when no marker file existed at first load (seed-legacy mode). */
+    private freshInstall;
+    constructor(filePath: string, now?: () => number);
+    private ensureLoaded;
+    private persist;
+    /** Snapshot of all live counts, keyed by agent id. */
+    counts(): Record<string, number>;
+    /** Current unread count for one agent (0 when none). */
+    unreadFor(agentId: string): number;
+    /**
+     * One live transcript arrival. Entries at or before the read marker are
+     * already-read history (snapshot replays) and are ignored.
+     */
+    bump(agentId: string, entry: UnreadEntry | null | undefined): void;
+    /**
+     * The user read the conversation: zero the count and advance the marker
+     * ("上次读到哪" = now, or the explicit position when given).
+     */
+    markRead(agentId: string, atMs?: number): void;
+    /**
+     * Recompute one agent's count from a transcript tail (reconnect/boot heal).
+     * An agent never seen before on a fresh install is seeded as read-up-to-now;
+     * an agent without a marker on a normal boot is genuinely never-read.
+     */
+    rebase(agentId: string, entries: ReadonlyArray<UnreadEntry | null | undefined>): void;
+    /** Drop state for agents that no longer exist; returns the removed ids. */
+    prune(knownIds: ReadonlySet<string>): string[];
+}

package/lib/types/version.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Minimal semver caret-range matching for the prerelease patterns this plugin
+ * actually uses (e.g. `^4.0.1`, `^0.1.1-rc.2`).
+ *
+ * Ported from the community dsh-plugin-template (MIT) and kept
+ * dependency-free: it implements the subset of node-semver semantics needed to
+ * turn a silent peer mismatch into a loud, actionable error.
+ * See tests/version.spec.ts for the behavior matrix.
+ * @module dsh-plugin-bots/version
+ */
+export interface ParsedVersion {
+    major: number;
+    minor: number;
+    patch: number;
+    /** Prerelease identifiers (e.g. ["rc", "2"]), or null for a stable version. */
+    prerelease: string[] | null;
+}
+/** Parse `X.Y.Z` or `X.Y.Z-pre` into a comparable structure, or null. */
+export declare function parseVersion(input: string): ParsedVersion | null;
+/** Compare two prerelease identifier lists; a stable version (null) is higher. */
+export declare function comparePrerelease(a: string[] | null, b: string[] | null): number;
+/** Upper exclusive bound of a caret range: ^0.1.0 → 0.2.0, ^1.2.3 → 2.0.0. */
+export declare function caretUpperBound(version: ParsedVersion): [number, number, number];
+/**
+ * Whether `version` satisfies the caret range `^X.Y.Z` or `^X.Y.Z-pre`.
+ * Mirrors node-semver for the subset this plugin declares.
+ */
+export declare function satisfiesCaret(version: string, range: string): boolean;

package/lib/types/workspace.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Per-agent workspace jail configuration bridge (plugin side).
+ *
+ * The ENGINE owns the isolation mechanism (`sdk-bots src/host/runner/
+ * agent-workspace-jail.ts`): when an agent's settings.json declares
+ * `workspaceRoot`, every shell that agent runs is wrapped in a generated
+ * macOS Seatbelt profile that denies file WRITES outside the agent's own
+ * workspace directory (+ allowPaths + OS temp). Reads stay unrestricted so
+ * shared blackboards remain readable. The jail resolves lazily per turn —
+ * editing settings.json takes effect on the agent's next turn, no restart.
+ *
+ * This module only mirrors the engine's config contract so the plugin can
+ * read and write it safely:
+ *   `<dataDir>/agents/<agentId>/settings.json` →
+ *     { workspaceRoot?: "/workspace/<slug>", workspaceAllowPaths?: string[] }
+ *
+ * Validation mirrors the engine exactly (SLUG_PATTERN, agentId pattern,
+ * virtual-prefix form) because the engine FAILS CLOSED on malformed config —
+ * a bad write would break the agent's turns, not silently run unjailed.
+ * @module dsh-bots/workspace
+ */
+/** Bot-facing virtual root prefix; the daemon maps it under the box root. */
+export declare const WORKSPACE_VIRTUAL_PREFIX = "/workspace/";
+/** One agent's jail config as stored on disk. */
+export interface AgentWorkspaceConfig {
+    agentId: string;
+    /** `/workspace/<slug>` when jailed, null otherwise. */
+    workspaceRoot: string | null;
+    /** Extra host paths the jailed agent may write. */
+    allowPaths: string[];
+}
+/** Validate the `/workspace/<slug>` virtual form exactly like the engine. */
+export declare function validateVirtualRoot(requested: string): string;
+/** Read one agent's jail config; null when the agent dir does not exist. */
+export declare function readAgentWorkspace(dataDir: string, agentId: string): AgentWorkspaceConfig | null;
+/** Scan every agent directory for its jail config (missing settings → unjailed). */
+export declare function listAgentWorkspaces(dataDir: string): AgentWorkspaceConfig[];
+export interface SetAgentWorkspaceRequest {
+    /** `/workspace/<slug>` to jail; null/undefined removes the jail. */
+    workspaceRoot?: string | null;
+    /** Extra writable host paths; replaces the previous list. */
+    allowPaths?: string[];
+}
+/**
+ * Write one agent's jail keys into its settings.json, preserving every other
+ * field. Creates the agent dir when missing (a freshly created bot may not
+ * have its settings.json yet).
+ */
+export declare function setAgentWorkspace(dataDir: string, agentId: string, request: SetAgentWorkspaceRequest): AgentWorkspaceConfig;

package/lib/unread.js

@@ -0,0 +1,196 @@
+/**
+ * Per-agent unread tracking for the sidebar badge.
+ *
+ * Why not the gateway's `unreadCount`? The sdk-bots host models unread state
+ * for the Grok desktop app: arrivals only count on the single `activeSession`,
+ * a focused window marks everything read instantly, and any transcript READ
+ * (`openAgentBounded` → `markAgentViewed`) clears the marker — which our own
+ * tail polling trips constantly. On a headless local gateway that model never
+ * accumulates (every agent observed at `unreadCount: 0` despite activity).
+ *
+ * So the plugin owns the model instead, at the one layer that is always
+ * watching: the host half's SSE ring. Rules:
+ *
+ *   - A "message" is a human-visible transcript kind (user prompt, bot reply,
+ *     attachment) — never tool calls, thinking, or system events.
+ *   - Each agent has a persisted marker `lastReadAtMs` ("读到哪了") in
+ *     `<dataDir>/dsh-bots-unread.json`; opening the conversation advances it.
+ *   - Live arrivals with `timestampMs > marker` bump the count; anything at or
+ *     before the marker is already-read history and is ignored (this is what
+ *     makes snapshot replays on SSE reconnect idempotent).
+ *   - After a restart the in-memory counts are gone but the markers survive,
+ *     so a rebase from transcript tails reconstructs the counts exactly.
+ *   - First run (no marker file yet) treats all existing history as read —
+ *     an upgrade must not light up 30 badges of backlog.
+ * @module dsh-bots/unread
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+/** Wire `kind`s that represent a message a human would want to see. */
+const MESSAGE_KINDS = new Set([
+    'message',
+    'user-message',
+    'send-message',
+    'agent-message',
+    'assistant-text',
+    'user-attachment',
+]);
+/** True when a transcript entry kind should raise the unread badge. */
+export function isMessageEntryKind(kind) {
+    return typeof kind === 'string' && MESSAGE_KINDS.has(kind);
+}
+/** Seconds/milliseconds/ISO → epoch ms; null when unreadable. */
+export function entryEpochMs(raw) {
+    if (typeof raw === 'number') {
+        if (!Number.isFinite(raw) || raw <= 0)
+            return null;
+        return Math.round(raw < 1e11 ? raw * 1000 : raw);
+    }
+    if (typeof raw !== 'string' || raw === '')
+        return null;
+    if (/^\d+$/.test(raw))
+        return entryEpochMs(Number(raw));
+    const parsed = Date.parse(raw);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+/**
+ * Unread counts + persisted read markers, one instance per plugin host.
+ * All mutations are crash-safe: markers flush to disk synchronously (a few
+ * hundred bytes), counts are reconstructible so they stay in memory.
+ */
+export class UnreadStore {
+    filePath;
+    now;
+    markers = new Map();
+    countBy = new Map();
+    loaded = false;
+    /** True when no marker file existed at first load (seed-legacy mode). */
+    freshInstall = false;
+    constructor(filePath, now = Date.now) {
+        this.filePath = filePath;
+        this.now = now;
+    }
+    ensureLoaded() {
+        if (this.loaded)
+            return;
+        this.loaded = true;
+        try {
+            if (existsSync(this.filePath)) {
+                const raw = JSON.parse(readFileSync(this.filePath, 'utf8'));
+                if (raw !== null && typeof raw === 'object' && raw.version === 1 && raw.markers !== null && typeof raw.markers === 'object') {
+                    for (const [id, at] of Object.entries(raw.markers)) {
+                        if (typeof at === 'number' && Number.isFinite(at) && at > 0)
+                            this.markers.set(id, at);
+                    }
+                }
+            }
+            else {
+                // First run after the feature (or after manually clearing state):
+                // existing history counts as read, only new traffic raises badges.
+                this.freshInstall = true;
+            }
+        }
+        catch {
+            // A corrupt file must not brick the badge; treat as fresh.
+            this.freshInstall = true;
+        }
+    }
+    persist() {
+        try {
+            const markers = {};
+            for (const [id, at] of this.markers)
+                markers[id] = at;
+            const body = { version: 1, markers };
+            mkdirSync(dirname(this.filePath), { recursive: true });
+            writeFileSync(this.filePath, JSON.stringify(body));
+        }
+        catch {
+            // Best effort: counts still work in memory; markers rebuild lazily.
+        }
+    }
+    /** Snapshot of all live counts, keyed by agent id. */
+    counts() {
+        this.ensureLoaded();
+        const out = {};
+        for (const [id, n] of this.countBy) {
+            if (n > 0)
+                out[id] = n;
+        }
+        return out;
+    }
+    /** Current unread count for one agent (0 when none). */
+    unreadFor(agentId) {
+        this.ensureLoaded();
+        return this.countBy.get(agentId) ?? 0;
+    }
+    /**
+     * One live transcript arrival. Entries at or before the read marker are
+     * already-read history (snapshot replays) and are ignored.
+     */
+    bump(agentId, entry) {
+        if (typeof agentId !== 'string' || agentId === '' || !isMessageEntryKind(entry?.kind))
+            return;
+        this.ensureLoaded();
+        const ts = entryEpochMs(entry?.timestampMs) ?? this.now();
+        if (ts <= (this.markers.get(agentId) ?? 0))
+            return;
+        this.countBy.set(agentId, (this.countBy.get(agentId) ?? 0) + 1);
+    }
+    /**
+     * The user read the conversation: zero the count and advance the marker
+     * ("上次读到哪" = now, or the explicit position when given).
+     */
+    markRead(agentId, atMs) {
+        if (typeof agentId !== 'string' || agentId === '')
+            return;
+        this.ensureLoaded();
+        const at = Math.max(atMs ?? this.now(), this.markers.get(agentId) ?? 0);
+        this.markers.set(agentId, at);
+        this.countBy.set(agentId, 0);
+        this.persist();
+    }
+    /**
+     * Recompute one agent's count from a transcript tail (reconnect/boot heal).
+     * An agent never seen before on a fresh install is seeded as read-up-to-now;
+     * an agent without a marker on a normal boot is genuinely never-read.
+     */
+    rebase(agentId, entries) {
+        if (typeof agentId !== 'string' || agentId === '')
+            return;
+        this.ensureLoaded();
+        if (this.freshInstall && !this.markers.has(agentId)) {
+            this.markers.set(agentId, this.now());
+            this.countBy.set(agentId, 0);
+            this.persist();
+            return;
+        }
+        const marker = this.markers.get(agentId) ?? 0;
+        let n = 0;
+        for (const entry of entries) {
+            if (!isMessageEntryKind(entry?.kind))
+                continue;
+            const ts = entryEpochMs(entry?.timestampMs);
+            if (ts !== null && ts > marker)
+                n += 1;
+        }
+        this.countBy.set(agentId, n);
+    }
+    /** Drop state for agents that no longer exist; returns the removed ids. */
+    prune(knownIds) {
+        this.ensureLoaded();
+        const removed = [];
+        for (const id of [...this.markers.keys()]) {
+            if (!knownIds.has(id)) {
+                this.markers.delete(id);
+                removed.push(id);
+            }
+        }
+        for (const id of [...this.countBy.keys()]) {
+            if (!knownIds.has(id))
+                this.countBy.delete(id);
+        }
+        if (removed.length > 0)
+            this.persist();
+        return removed;
+    }
+}