@llblab/pi-telegram 0.21.0 → 0.22.0

package/lib/logs.ts

@@ -10,13 +10,15 @@ import {
   mkdirSync,
   statSync,
   writeFileSync,
-  appendFile,
+  appendFileSync,
 } from "node:fs";
 import { dirname } from "node:path";
 import {
   resolveAgentDir,
   resolveTelegramProfileTempFilePath,
 } from "./paths.ts";
+import { withTelegramFileTransaction } from "./locks.ts";
+import * as Status from "./status.ts";
 
 export type TelegramLogPathInput = string | (() => string);
 
@@ -32,6 +34,8 @@ export interface TelegramRuntimeJsonlLogOptions {
   previousPath?: TelegramLogPathInput;
   maxBytes?: number;
   getNowMs?: () => number;
+  canReset?: () => boolean;
+  commitReset?: (commit: () => void) => boolean;
 }
 
 export interface TelegramRuntimeJsonlLog {
@@ -89,7 +93,8 @@ export function createTelegramRuntimeJsonlLog(
       ? options.path()
       : (options.path ?? getTelegramRuntimeLogPath());
   const resolvePreviousPath = () => {
-    if (typeof options.previousPath === "function") return options.previousPath();
+    if (typeof options.previousPath === "function")
+      return options.previousPath();
     if (options.previousPath) return options.previousPath;
     return resolvePath().replace(/\.jsonl$/u, "._prev.jsonl");
   };
@@ -108,9 +113,12 @@ export function createTelegramRuntimeJsonlLog(
     copyFileSync(path, previousPath);
   };
 
-  const writeReset = (reason: string, scope?: Record<string, unknown>) => {
-    const path = resolvePath();
-    const previousPath = resolvePreviousPath();
+  const writeResetLocked = (
+    path: string,
+    previousPath: string,
+    reason: string,
+    scope?: Record<string, unknown>,
+  ) => {
     ensureParent(path);
     preserveCurrentLog(path, previousPath);
     writeFileSync(
@@ -126,20 +134,49 @@ export function createTelegramRuntimeJsonlLog(
     );
   };
 
+  const writeReset = (
+    reason: string,
+    scope?: Record<string, unknown>,
+  ): boolean => {
+    if (options.canReset && !options.canReset()) return false;
+    const path = resolvePath();
+    let didReset = false;
+    withTelegramFileTransaction(`${path}.transaction`, () => {
+      const commit = () => {
+        writeResetLocked(path, resolvePreviousPath(), reason, scope);
+        didReset = true;
+      };
+      if (options.commitReset) {
+        options.commitReset(commit);
+      } else {
+        commit();
+      }
+    });
+    return didReset;
+  };
+
   const appendLine = (line: string) => {
+    const path = resolvePath();
+    const previousPath = resolvePreviousPath();
     pending = pending
       .catch(() => undefined)
-      .then(async () => {
-        const path = resolvePath();
+      .then(() => {
         ensureParent(path);
-        if (existsSync(path) && statSync(path).size > maxBytes) {
-          writeReset("max-bytes", { maxBytes });
-        }
-        await new Promise<void>((resolve, reject) => {
-          appendFile(path, line, { mode: 0o600 }, (error) => {
-            if (error) reject(error);
-            else resolve();
-          });
+        withTelegramFileTransaction(`${path}.transaction`, () => {
+          if (
+            existsSync(path) &&
+            statSync(path).size > maxBytes &&
+            (!options.canReset || options.canReset())
+          ) {
+            const rotate = () =>
+              writeResetLocked(path, previousPath, "max-bytes", { maxBytes });
+            if (options.commitReset) {
+              options.commitReset(rotate);
+            } else {
+              rotate();
+            }
+          }
+          appendFileSync(path, line, { mode: 0o600 });
         });
       });
   };
@@ -148,9 +185,10 @@ export function createTelegramRuntimeJsonlLog(
     getPath: resolvePath,
     reset(reason, scope) {
       const path = resolvePath();
-      scopeKeys.set(path, scope ? safeJsonLine(scope) : undefined);
       try {
-        writeReset(reason, scope);
+        if (writeReset(reason, scope)) {
+          scopeKeys.set(path, scope ? safeJsonLine(scope) : undefined);
+        }
       } catch {
         // Diagnostics must never break Telegram runtime behavior.
       }
@@ -158,9 +196,8 @@ export function createTelegramRuntimeJsonlLog(
     resetIfScopeChanged(nextScopeKey, reason, scope) {
       const path = resolvePath();
       if (scopeKeys.get(path) === nextScopeKey) return;
-      scopeKeys.set(path, nextScopeKey);
       try {
-        writeReset(reason, scope);
+        if (writeReset(reason, scope)) scopeKeys.set(path, nextScopeKey);
       } catch {
         // Diagnostics must never break Telegram runtime behavior.
       }
@@ -170,3 +207,125 @@ export function createTelegramRuntimeJsonlLog(
     },
   };
 }
+
+export interface TelegramRuntimeDiagnosticsRuntime<TContext> {
+  events: Status.TelegramRuntimeEventRecorder;
+  recordRuntimeEvent(
+    category: string,
+    error: unknown,
+    details?: Record<string, unknown>,
+  ): void;
+  bindStorage(ports: {
+    getBotToken(): string | undefined;
+    getProfileName(): string | undefined;
+    canReset(): boolean;
+    commitReset(commit: () => void): boolean;
+  }): void;
+  bindStatus(ports: {
+    instanceId: string;
+    updateStatus(ctx: TContext, error?: string): void;
+    getStatusState(): Status.TelegramBridgeStatusLineState;
+    persistSnapshot(
+      snapshot: ReturnType<typeof Status.createTelegramStatusSnapshot>,
+    ): Promise<void>;
+  }): void;
+  updateStatus(ctx: TContext, error?: string): void;
+  getStatusLines(options?: Status.TelegramBridgeStatusLineOptions): string[];
+  scheduleSnapshotPersist(): void;
+}
+
+export function createTelegramRuntimeDiagnosticsRuntime<
+  TContext,
+>(): TelegramRuntimeDiagnosticsRuntime<TContext> {
+  let getBotToken = (): string | undefined => undefined;
+  let getProfileName = (): string | undefined => undefined;
+  let canReset = (): boolean => false;
+  let commitReset = (_commit: () => void): boolean => false;
+  let statusPorts:
+    | {
+        instanceId: string;
+        updateStatus(ctx: TContext, error?: string): void;
+        getStatusState(): Status.TelegramBridgeStatusLineState;
+        persistSnapshot(
+          snapshot: ReturnType<typeof Status.createTelegramStatusSnapshot>,
+        ): Promise<void>;
+      }
+    | undefined;
+  let requestSnapshotPersist = (): void => {};
+  const events = Status.createTelegramRuntimeEventRecorder({
+    getBotToken: () => getBotToken(),
+  });
+  const jsonl = createTelegramRuntimeJsonlLog({
+    path: () => getTelegramRuntimeLogPath(undefined, getProfileName()),
+    previousPath: () =>
+      getTelegramPreviousRuntimeLogPath(undefined, getProfileName()),
+    canReset: () => canReset(),
+    commitReset: (commit) => commitReset(commit),
+  });
+  const recordRuntimeEvent = function (
+    category: string,
+    error: unknown,
+    details?: Record<string, unknown>,
+  ): void {
+    events.record(category, error, details);
+    const latestEvent = events.getEvents().at(-1);
+    if (latestEvent) jsonl.record(latestEvent);
+    requestSnapshotPersist();
+  };
+  const persistCurrentSnapshot = async (): Promise<void> => {
+    if (!statusPorts) return;
+    await statusPorts.persistSnapshot(
+      Status.createTelegramStatusSnapshot(statusPorts.getStatusState()),
+    );
+  };
+  const updateRuntimeLogScope = function (reason: string): void {
+    if (!statusPorts) return;
+    const scope = Status.createTelegramRuntimeLogScope({
+      state: statusPorts.getStatusState(),
+      instanceId: statusPorts.instanceId,
+    });
+    jsonl.resetIfScopeChanged(JSON.stringify(scope), reason, scope);
+  };
+  return {
+    events,
+    recordRuntimeEvent,
+    bindStorage(ports) {
+      getBotToken = ports.getBotToken;
+      getProfileName = ports.getProfileName;
+      canReset = ports.canReset;
+      commitReset = ports.commitReset;
+    },
+    bindStatus(ports) {
+      statusPorts = ports;
+      requestSnapshotPersist =
+        Status.createTelegramRuntimeDiagnosticsSnapshotScheduler({
+          persistSnapshot: persistCurrentSnapshot,
+          recordError(error) {
+            events.record("telegram", error, {
+              phase: "runtime-diagnostics-snapshot-persist",
+            });
+          },
+        });
+    },
+    updateStatus(ctx, error) {
+      if (!statusPorts) return;
+      statusPorts.updateStatus(ctx, error);
+      updateRuntimeLogScope("status-scope-change");
+    },
+    getStatusLines(options) {
+      if (!statusPorts) return [];
+      void persistCurrentSnapshot().catch((error) => {
+        recordRuntimeEvent("telegram", error, {
+          phase: "status-snapshot-persist",
+        });
+      });
+      return Status.buildTelegramBridgeStatusLines(
+        statusPorts.getStatusState(),
+        options,
+      );
+    },
+    scheduleSnapshotPersist() {
+      requestSnapshotPersist();
+    },
+  };
+}

package/lib/media.ts

@@ -100,6 +100,9 @@ export interface TelegramMediaGroupState<TMessage, TContext = unknown> {
   messages: TMessage[];
   context?: TContext;
   flushTimer?: ReturnType<typeof setTimeout>;
+  dispatching?: boolean;
+  suspended?: boolean;
+  reschedule?: () => void;
 }
 
 export interface TelegramMediaGroupController<
@@ -109,9 +112,14 @@ export interface TelegramMediaGroupController<
   queueMessage: (options: {
     message: TMessage;
     context?: TContext;
-    dispatchMessages: (messages: TMessage[], ctx?: TContext) => void;
+    dispatchMessages: (
+      messages: TMessage[],
+      ctx?: TContext,
+    ) => unknown | Promise<unknown>;
   }) => boolean;
   removeMessages: (messageIds: number[]) => number;
+  suspend: () => void;
+  resume: (context: TContext) => void;
   clear: () => void;
 }
 
@@ -140,13 +148,7 @@ export interface TelegramMediaGroupControllerOptions {
 }
 
 export type TelegramAttachmentKind =
-  | "photo"
-  | "document"
-  | "video"
-  | "audio"
-  | "voice"
-  | "animation"
-  | "sticker";
+  "photo" | "document" | "video" | "audio" | "voice" | "animation" | "sticker";
 
 export interface TelegramFileInfo {
   file_id: string;
@@ -306,11 +308,16 @@ function truncateTelegramReplyContextText(text: string): string {
   return `${text.slice(0, TELEGRAM_REPLY_CONTEXT_MAX_LENGTH).trimEnd()}…`;
 }
 
-function formatTelegramUser(user: TelegramMessageUser | undefined): string | undefined {
+function formatTelegramUser(
+  user: TelegramMessageUser | undefined,
+): string | undefined {
   if (!user) return undefined;
   if (user.username) return user.username;
   if (typeof user.id === "number") return String(user.id);
-  const name = [user.first_name, user.last_name].filter(Boolean).join(" ").trim();
+  const name = [user.first_name, user.last_name]
+    .filter(Boolean)
+    .join(" ")
+    .trim();
   return name || undefined;
 }
 
@@ -331,7 +338,8 @@ export function extractTelegramForwardContextText(
   message: TelegramMediaMessage,
   allowedUserId?: number,
 ): string {
-  const originUser = message.forward_origin?.sender_user ?? message.forward_from;
+  const originUser =
+    message.forward_origin?.sender_user ?? message.forward_from;
   const isOwnerOrigin =
     typeof allowedUserId === "number" && originUser?.id === allowedUserId;
   const origin = formatTelegramForwardOriginIdentifier(message);
@@ -497,21 +505,55 @@ export function queueTelegramMediaGroupMessage<
   debounceMs: number;
   setTimer: (callback: () => void, ms: number) => ReturnType<typeof setTimeout>;
   clearTimer: (timer: ReturnType<typeof setTimeout>) => void;
-  dispatchMessages: (messages: TMessage[], ctx?: TContext) => void;
+  dispatchMessages: (
+    messages: TMessage[],
+    ctx?: TContext,
+  ) => unknown | Promise<unknown>;
 }): boolean {
   const key = getTelegramMediaGroupKey(options.message);
   if (!key) return false;
   const existing = options.groups.get(key) ?? { messages: [] };
   existing.messages.push(options.message);
   existing.context = options.context;
+  const scheduleDispatch = (): void => {
+    if (existing.suspended) return;
+    existing.flushTimer = options.setTimer(() => {
+      existing.flushTimer = undefined;
+      const state = options.groups.get(key);
+      if (!state) return;
+      if (state.dispatching) {
+        scheduleDispatch();
+        return;
+      }
+      const dispatchedMessages = [...state.messages];
+      const dispatchedIds = new Set(
+        dispatchedMessages.map((message) => message.message_id),
+      );
+      state.dispatching = true;
+      void Promise.resolve(
+        options.dispatchMessages(dispatchedMessages, state.context),
+      ).then(
+        () => {
+          if (options.groups.get(key) !== state) return;
+          state.messages = state.messages.filter(
+            (message) => !dispatchedIds.has(message.message_id),
+          );
+          state.dispatching = false;
+          if (state.messages.length === 0) options.groups.delete(key);
+          else if (!state.flushTimer) scheduleDispatch();
+        },
+        () => {
+          if (options.groups.get(key) !== state) return;
+          state.dispatching = false;
+          if (!state.flushTimer) scheduleDispatch();
+        },
+      );
+    }, options.debounceMs);
+    existing.flushTimer.unref?.();
+  };
+  existing.reschedule = scheduleDispatch;
   if (existing.flushTimer) options.clearTimer(existing.flushTimer);
-  existing.flushTimer = options.setTimer(() => {
-    const state = options.groups.get(key);
-    options.groups.delete(key);
-    if (!state) return;
-    options.dispatchMessages(state.messages, state.context);
-  }, options.debounceMs);
-  existing.flushTimer.unref?.();
+  scheduleDispatch();
   options.groups.set(key, existing);
   return true;
 }
@@ -542,6 +584,20 @@ export function createTelegramMediaGroupController<
       }),
     removeMessages: (messageIds) =>
       removePendingTelegramMediaGroupMessages(groups, messageIds, clearTimer),
+    suspend: () => {
+      for (const state of groups.values()) {
+        state.suspended = true;
+        if (state.flushTimer) clearTimer(state.flushTimer);
+        state.flushTimer = undefined;
+      }
+    },
+    resume: (context) => {
+      for (const state of groups.values()) {
+        state.context = context;
+        state.suspended = false;
+        if (!state.dispatching && !state.flushTimer) state.reschedule?.();
+      }
+    },
     clear: () => {
       for (const state of groups.values()) {
         if (state.flushTimer) clearTimer(state.flushTimer);
@@ -562,11 +618,10 @@ export function createTelegramMediaGroupDispatchRuntime<
       const queuedMediaGroup = deps.mediaGroups.queueMessage({
         message,
         context: ctx,
-        dispatchMessages: (messages, queuedCtx) => {
-          if (queuedCtx !== undefined) {
-            void deps.dispatchMessages(messages, queuedCtx);
-          }
-        },
+        dispatchMessages: (messages, queuedCtx) =>
+          queuedCtx === undefined
+            ? Promise.resolve()
+            : deps.dispatchMessages(messages, queuedCtx),
       });
       if (queuedMediaGroup) return;
       await deps.dispatchMessages([message], ctx);

package/lib/model.ts

@@ -15,13 +15,7 @@ export interface MenuModel {
 }
 
 export type ThinkingLevel =
-  | "off"
-  | "minimal"
-  | "low"
-  | "medium"
-  | "high"
-  | "xhigh"
-  | "max";
+  "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
 
 export interface ScopedTelegramModel<TModel extends MenuModel = MenuModel> {
   model: TModel;
@@ -443,7 +437,7 @@ export function buildTelegramModelSwitchContinuationText<
 export function buildTelegramModelSwitchContinuationTurn<
   TModel extends MenuModel,
 >(options: {
-  turn: Pick<PendingTelegramTurn, "chatId" | "replyToMessageId">;
+  turn: Pick<PendingTelegramTurn, "chatId" | "replyToMessageId" | "target">;
   selection: ScopedTelegramModel<TModel>;
   telegramPrefix?: string;
   queueOrder: number;
@@ -456,6 +450,7 @@ export function buildTelegramModelSwitchContinuationTurn<
   return {
     kind: "prompt",
     chatId: options.turn.chatId,
+    ...(options.turn.target ? { target: { ...options.turn.target } } : {}),
     replyToMessageId: options.turn.replyToMessageId,
     sourceMessageIds: [],
     queueOrder: options.queueOrder,
@@ -484,7 +479,7 @@ export function createTelegramModelSwitchContinuationTurnBuilder<
   allocateItemOrder: () => number;
   allocateControlOrder: () => number;
 }): (options: {
-  turn: Pick<PendingTelegramTurn, "chatId" | "replyToMessageId">;
+  turn: Pick<PendingTelegramTurn, "chatId" | "replyToMessageId" | "target">;
   selection: ScopedTelegramModel<TModel>;
 }) => PendingTelegramTurn {
   return (options) =>
@@ -501,7 +496,7 @@ export function createTelegramModelSwitchContinuationQueue<
   TSelection extends ScopedTelegramModel,
 >(deps: {
   createContinuationTurn: (options: {
-    turn: Pick<PendingTelegramTurn, "chatId" | "replyToMessageId">;
+    turn: Pick<PendingTelegramTurn, "chatId" | "replyToMessageId" | "target">;
     selection: TSelection;
   }) => PendingTelegramTurn;
   appendQueuedItem: (item: PendingTelegramTurn, ctx: TContext) => void;

package/lib/ownership.ts

@@ -11,6 +11,8 @@ export interface TelegramMessageOwnershipRecord {
   messageId: number;
   target: TelegramTarget;
   instanceId: string;
+  profileKey?: string;
+  ownerGeneration?: string;
   createdAt: number;
   updatedAt: number;
 }
@@ -21,6 +23,8 @@ export interface TelegramMessageOwnershipStore {
     messageId: number;
     target?: TelegramTarget;
     instanceId: string;
+    profileKey?: string;
+    ownerGeneration?: string;
     now?: number;
   }) => TelegramMessageOwnershipRecord;
   get: (
@@ -38,11 +42,110 @@ export interface TelegramMessageOwnershipStore {
   clear: () => void;
 }
 
+export interface TelegramFollowerOwnershipView {
+  instanceId: string;
+  connectedAtMs: number;
+  registrationGeneration?: string;
+}
+
+export interface TelegramBusMessageOwnershipRuntime {
+  store: TelegramMessageOwnershipStore;
+  recordLocal(input: {
+    chatId: number;
+    messageId: number;
+    target?: TelegramTarget;
+  }): TelegramMessageOwnershipRecord;
+  recordRouted(input: {
+    chatId: number;
+    messageId: number;
+    target?: TelegramTarget;
+    instanceId: string;
+  }): TelegramMessageOwnershipRecord;
+  recordFollower(input: {
+    chatId: number;
+    messageId: number;
+    target?: TelegramTarget;
+    follower: TelegramFollowerOwnershipView;
+  }): TelegramMessageOwnershipRecord;
+  isOwnedByFollower(input: {
+    chatId: number;
+    messageId: number;
+    follower: TelegramFollowerOwnershipView;
+  }): boolean;
+}
+
+function getTelegramFollowerOwnershipGeneration(
+  follower: TelegramFollowerOwnershipView,
+): string {
+  return (
+    follower.registrationGeneration ??
+    `${follower.instanceId}:${follower.connectedAtMs}`
+  );
+}
+
+export function createTelegramBusMessageOwnershipRuntime(deps: {
+  instanceId: string;
+  getProfileKey(): string;
+  listFollowers(): readonly TelegramFollowerOwnershipView[];
+}): TelegramBusMessageOwnershipRuntime {
+  const store = createTelegramMessageOwnershipStore({
+    getProfileKey: deps.getProfileKey,
+    isOwnerGenerationLive(record) {
+      if (!record.ownerGeneration) return true;
+      return deps.listFollowers().some((follower) => {
+        return (
+          follower.instanceId === record.instanceId &&
+          getTelegramFollowerOwnershipGeneration(follower) ===
+            record.ownerGeneration
+        );
+      });
+    },
+  });
+  const recordFollower = function (input: {
+    chatId: number;
+    messageId: number;
+    target?: TelegramTarget;
+    follower: TelegramFollowerOwnershipView;
+  }): TelegramMessageOwnershipRecord {
+    return store.record({
+      chatId: input.chatId,
+      messageId: input.messageId,
+      target: input.target,
+      instanceId: input.follower.instanceId,
+      ownerGeneration: getTelegramFollowerOwnershipGeneration(input.follower),
+    });
+  };
+  return {
+    store,
+    recordLocal(input) {
+      return store.record({ ...input, instanceId: deps.instanceId });
+    },
+    recordRouted(input) {
+      const follower = deps
+        .listFollowers()
+        .find((candidate) => candidate.instanceId === input.instanceId);
+      return follower
+        ? recordFollower({ ...input, follower })
+        : store.record(input);
+    },
+    recordFollower,
+    isOwnedByFollower({ chatId, messageId, follower }) {
+      const ownership = store.get(chatId, messageId);
+      return (
+        ownership?.instanceId === follower.instanceId &&
+        ownership.ownerGeneration ===
+          getTelegramFollowerOwnershipGeneration(follower)
+      );
+    },
+  };
+}
+
 function getTelegramMessageOwnershipKey(
   chatId: number,
   messageId: number,
+  profileKey?: string,
 ): string {
-  return `${chatId}:${messageId}`;
+  return `${profileKey ?? ""}:${chatId}:${messageId}`;
 }
 
 function createTelegramMessageOwnershipRecord(input: {
@@ -50,6 +153,8 @@ function createTelegramMessageOwnershipRecord(input: {
   messageId: number;
   target?: TelegramTarget;
   instanceId: string;
+  profileKey?: string;
+  ownerGeneration?: string;
   now: number;
   previous?: TelegramMessageOwnershipRecord;
 }): TelegramMessageOwnershipRecord {
@@ -58,33 +163,72 @@ function createTelegramMessageOwnershipRecord(input: {
     messageId: input.messageId,
     target: input.target ?? { chatId: input.chatId },
     instanceId: input.instanceId,
+    ...(input.profileKey ? { profileKey: input.profileKey } : {}),
+    ...(input.ownerGeneration
+      ? { ownerGeneration: input.ownerGeneration }
+      : {}),
     createdAt: input.previous?.createdAt ?? input.now,
     updatedAt: input.now,
   };
 }
 
-export function createTelegramMessageOwnershipStore(): TelegramMessageOwnershipStore {
+export function createTelegramMessageOwnershipStore(
+  options: {
+    getProfileKey?: () => string | undefined;
+    isOwnerGenerationLive?: (record: TelegramMessageOwnershipRecord) => boolean;
+  } = {},
+): TelegramMessageOwnershipStore {
   const records = new Map<string, TelegramMessageOwnershipRecord>();
   return {
     record: (input) => {
-      const key = getTelegramMessageOwnershipKey(input.chatId, input.messageId);
+      const profileKey = input.profileKey ?? options.getProfileKey?.();
+      const key = getTelegramMessageOwnershipKey(
+        input.chatId,
+        input.messageId,
+        profileKey,
+      );
       const now = input.now ?? Date.now();
       const record = createTelegramMessageOwnershipRecord({
         ...input,
+        profileKey,
         now,
         previous: records.get(key),
       });
       records.set(key, record);
       return record;
     },
-    get: (chatId, messageId) =>
-      records.get(getTelegramMessageOwnershipKey(chatId, messageId)),
+    get: (chatId, messageId) => {
+      const record = records.get(
+        getTelegramMessageOwnershipKey(
+          chatId,
+          messageId,
+          options.getProfileKey?.(),
+        ),
+      );
+      if (!record) return undefined;
+      if (
+        record.ownerGeneration &&
+        options.isOwnerGenerationLive &&
+        !options.isOwnerGenerationLive(record)
+      ) {
+        return undefined;
+      }
+      return record;
+    },
     forget: (chatId, messageId) =>
-      records.delete(getTelegramMessageOwnershipKey(chatId, messageId)),
+      records.delete(
+        getTelegramMessageOwnershipKey(
+          chatId,
+          messageId,
+          options.getProfileKey?.(),
+        ),
+      ),
     forgetTarget: (target) => {
       const targetKey = getTelegramTargetKey(target);
+      const profileKey = options.getProfileKey?.();
       let removed = 0;
       for (const [key, record] of records) {
+        if ((record.profileKey ?? undefined) !== profileKey) continue;
         if (getTelegramTargetKey(record.target) !== targetKey) continue;
         records.delete(key);
         removed += 1;