switchroom 0.19.26 → 0.19.27

package/telegram-plugin/tests/status-pin-retarget.test.ts

@@ -1,6 +1,9 @@
 import { describe, it, expect } from "vitest";
-import { runStatusPinReconcile } from "../gateway/status-pin-retarget.js";
-import type { DesiredPin, PinState } from "../status-pin.js";
+import {
+  runStatusPinReconcile,
+  type StatusPinClaim,
+} from "../gateway/status-pin-retarget.js";
+import type { PinLegAction, PinState } from "../status-pin.js";
 
 /**
  * The orchestrator the gateway's `reconcileStatusPinInner` delegates to.
@@ -14,16 +17,19 @@ import type { DesiredPin, PinState } from "../status-pin.js";
  * turn AND deleted the durable row, putting it out of reach of both the
  * mid-session reaper and the next boot's sweep.
  *
- * These tests drive the module with a fake leg runner and assert the LEG
- * SEQUENCE — the thing that was wrong — plus the registry bookkeeping.
+ * #3831: the expansion ALSO existed inside `status-pin-driver.ts`, decided from
+ * the driver's own `decidePinAction` call and lacking the per-leg persistence.
+ * That copy is gone — the driver now takes a `PinLegAction`, which cannot
+ * express a repin — so this module is the only decider. These tests assert the
+ * LEG SEQUENCE the driver now receives, plus the claim bookkeeping.
  */
 
 /** Records every leg and returns a scripted outcome for it. */
 function legRecorder(outcomes: Array<PinState | null>) {
-  const legs: Array<{ from: PinState | null; want: DesiredPin }> = [];
+  const legs: Array<{ from: PinState | null; action: PinLegAction }> = [];
   let i = 0;
-  const runPin = async (from: PinState | null, want: DesiredPin) => {
-    legs.push({ from, want });
+  const runPin = async (action: PinLegAction, from: PinState | null) => {
+    legs.push({ from, action });
     const out = outcomes[i];
     i += 1;
     return out ?? null;
@@ -31,18 +37,10 @@ function legRecorder(outcomes: Array<PinState | null>) {
   return { legs, runPin };
 }
 
-function registries(seed?: { key: string; state: PinState; chatId: string; at: number }) {
-  const r = {
-    state: new Map<string, PinState>(),
-    chatIds: new Map<string, string>(),
-    pinnedAt: new Map<string, number>(),
-  };
-  if (seed) {
-    r.state.set(seed.key, seed.state);
-    r.chatIds.set(seed.key, seed.chatId);
-    r.pinnedAt.set(seed.key, seed.at);
-  }
-  return r;
+function claimsOf(seed?: { key: string; claim: StatusPinClaim }) {
+  const claims = new Map<string, StatusPinClaim>();
+  if (seed) claims.set(seed.key, seed.claim);
+  return claims;
 }
 
 const KEY = "fg:c:7";
@@ -51,7 +49,10 @@ const CHAT = "-100123";
 describe("runStatusPinReconcile — RETARGET", () => {
   it("runs BOTH legs: unpins the stale claim, then pins the new message", async () => {
     const { legs, runPin } = legRecorder([null, { messageId: 901 }]);
-    const reg = registries({ key: KEY, state: { messageId: 900 }, chatId: CHAT, at: 1000 });
+    const claims = claimsOf({
+      key: KEY,
+      claim: { messageId: 900, chatId: CHAT, pinnedAt: 1000 },
+    });
 
     await runStatusPinReconcile({
       pinKey: KEY,
@@ -60,19 +61,19 @@ describe("runStatusPinReconcile — RETARGET", () => {
       desired: { pinned: true, messageId: 901 },
       persist: null,
       runPin,
-      registries: reg,
+      claims,
     });
 
     // The pre-fix behaviour was legs === [unpin] and nothing pinned.
     expect(legs).toEqual([
-      { from: { messageId: 900 }, want: { pinned: false } },
-      { from: null, want: { pinned: true, messageId: 901 } },
+      { from: { messageId: 900 }, action: { kind: "unpin", messageId: 900 } },
+      { from: null, action: { kind: "pin", messageId: 901 } },
     ]);
-    expect(reg.state.get(KEY)).toEqual({ messageId: 901 });
-    expect(reg.chatIds.get(KEY)).toBe(CHAT);
+    expect(claims.get(KEY)?.messageId).toBe(901);
+    expect(claims.get(KEY)?.chatId).toBe(CHAT);
   });
 
-  it("leg 2 starts from a NULL claim, so it decides a real `pin` (not a noop)", async () => {
+  it("leg 2 starts from a NULL claim, so the driver pins rather than no-opping", async () => {
     const { legs, runPin } = legRecorder([null, { messageId: 901 }]);
     await runStatusPinReconcile({
       pinKey: KEY,
@@ -81,14 +82,18 @@ describe("runStatusPinReconcile — RETARGET", () => {
       desired: { pinned: true, messageId: 901 },
       persist: null,
       runPin,
-      registries: registries(),
+      claims: claimsOf(),
     });
     expect(legs[1].from).toBeNull();
+    expect(legs[1].action).toEqual({ kind: "pin", messageId: 901 });
   });
 
   it("re-stamps pinnedAt for the NEW card, so the reaper ages the live message", async () => {
     const { runPin } = legRecorder([null, { messageId: 901 }]);
-    const reg = registries({ key: KEY, state: { messageId: 900 }, chatId: CHAT, at: 1000 });
+    const claims = claimsOf({
+      key: KEY,
+      claim: { messageId: 900, chatId: CHAT, pinnedAt: 1000 },
+    });
     await runStatusPinReconcile({
       pinKey: KEY,
       chatId: CHAT,
@@ -96,18 +101,22 @@ describe("runStatusPinReconcile — RETARGET", () => {
       desired: { pinned: true, messageId: 901 },
       persist: null,
       runPin,
-      registries: reg,
+      claims,
+      now: () => 5000,
     });
     // Leg 1 cleared the claim (dropping the old stamp), leg 2 took a fresh one.
-    expect(reg.pinnedAt.get(KEY)).toBeGreaterThan(1000);
+    expect(claims.get(KEY)?.pinnedAt).toBe(5000);
   });
 
   it("NEVER-CONFIRMED unpin (#3664 Defect B): SKIPS the pin leg and retains the OLD claim", async () => {
-    // A non-null leg-1 result means reconcilePin deliberately kept the claim —
+    // A non-null leg-1 result means executePinLeg deliberately kept the claim —
     // the old message is provably still pinned. Pinning the new one now would
     // leave TWO pins in the chat with a durable record of one.
     const { legs, runPin } = legRecorder([{ messageId: 900 }]);
-    const reg = registries({ key: KEY, state: { messageId: 900 }, chatId: CHAT, at: 1000 });
+    const claims = claimsOf({
+      key: KEY,
+      claim: { messageId: 900, chatId: CHAT, pinnedAt: 1000 },
+    });
 
     await runStatusPinReconcile({
       pinKey: KEY,
@@ -116,19 +125,24 @@ describe("runStatusPinReconcile — RETARGET", () => {
       desired: { pinned: true, messageId: 901 },
       persist: null,
       runPin,
-      registries: reg,
+      claims,
     });
 
     expect(legs).toHaveLength(1);
-    expect(reg.state.get(KEY)).toEqual({ messageId: 900 });
-    expect(reg.chatIds.get(KEY)).toBe(CHAT);
-    expect(reg.pinnedAt.get(KEY)).toBe(1000); // original age preserved for the TTL gate
+    expect(claims.get(KEY)).toEqual({
+      messageId: 900,
+      chatId: CHAT,
+      pinnedAt: 1000, // original age preserved for the TTL gate
+    });
   });
 
   it("a FAILED pin leg drops the claim entirely (nothing is pinned, nothing is tracked)", async () => {
-    // reconcilePin returns its `from` on a failed pin — here `null`.
+    // executePinLeg returns its `from` on a failed pin — here `null`.
     const { runPin } = legRecorder([null, null]);
-    const reg = registries({ key: KEY, state: { messageId: 900 }, chatId: CHAT, at: 1000 });
+    const claims = claimsOf({
+      key: KEY,
+      claim: { messageId: 900, chatId: CHAT, pinnedAt: 1000 },
+    });
     await runStatusPinReconcile({
       pinKey: KEY,
       chatId: CHAT,
@@ -136,18 +150,16 @@ describe("runStatusPinReconcile — RETARGET", () => {
       desired: { pinned: true, messageId: 901 },
       persist: null,
       runPin,
-      registries: reg,
+      claims,
     });
-    expect(reg.state.has(KEY)).toBe(false);
-    expect(reg.chatIds.has(KEY)).toBe(false);
-    expect(reg.pinnedAt.has(KEY)).toBe(false);
+    expect(claims.has(KEY)).toBe(false);
   });
 });
 
 describe("runStatusPinReconcile — single-leg actions are unchanged", () => {
-  it("first pin: one leg, claim + chat + age recorded", async () => {
+  it("first pin: one leg, claim + chat + age recorded together", async () => {
     const { legs, runPin } = legRecorder([{ messageId: 900 }]);
-    const reg = registries();
+    const claims = claimsOf();
     await runStatusPinReconcile({
       pinKey: KEY,
       chatId: CHAT,
@@ -155,16 +167,26 @@ describe("runStatusPinReconcile — single-leg actions are unchanged", () => {
       desired: { pinned: true, messageId: 900 },
       persist: null,
       runPin,
-      registries: reg,
+      claims,
+      now: () => 4242,
+    });
+    expect(legs).toEqual([
+      { from: null, action: { kind: "pin", messageId: 900 } },
+    ]);
+    // #3809: the claim is ONE record — a chat-less claim cannot be represented.
+    expect(claims.get(KEY)).toEqual({
+      messageId: 900,
+      chatId: CHAT,
+      pinnedAt: 4242,
     });
-    expect(legs).toEqual([{ from: null, want: { pinned: true, messageId: 900 } }]);
-    expect(reg.state.get(KEY)).toEqual({ messageId: 900 });
-    expect(reg.pinnedAt.has(KEY)).toBe(true);
   });
 
-  it("turn-end unpin: one leg, all three registries cleared", async () => {
+  it("turn-end unpin: one leg, the whole claim is cleared", async () => {
     const { legs, runPin } = legRecorder([null]);
-    const reg = registries({ key: KEY, state: { messageId: 900 }, chatId: CHAT, at: 1000 });
+    const claims = claimsOf({
+      key: KEY,
+      claim: { messageId: 900, chatId: CHAT, pinnedAt: 1000 },
+    });
     await runStatusPinReconcile({
       pinKey: KEY,
       chatId: CHAT,
@@ -172,19 +194,22 @@ describe("runStatusPinReconcile — single-leg actions are unchanged", () => {
       desired: { pinned: false },
       persist: null,
       runPin,
-      registries: reg,
+      claims,
     });
-    expect(legs).toEqual([{ from: { messageId: 900 }, want: { pinned: false } }]);
-    expect(reg.state.has(KEY)).toBe(false);
-    expect(reg.chatIds.has(KEY)).toBe(false);
-    expect(reg.pinnedAt.has(KEY)).toBe(false);
+    expect(legs).toEqual([
+      { from: { messageId: 900 }, action: { kind: "unpin", messageId: 900 } },
+    ]);
+    expect(claims.has(KEY)).toBe(false);
   });
 
   it("steady-state re-pin of the SAME id: still one leg, and the ORIGINAL age is kept", async () => {
     // 20 edits/turn each re-drive this; the reaper's TTL must measure from the
     // first pin, not be reset by every edit.
     const { legs, runPin } = legRecorder([{ messageId: 900 }]);
-    const reg = registries({ key: KEY, state: { messageId: 900 }, chatId: CHAT, at: 1000 });
+    const claims = claimsOf({
+      key: KEY,
+      claim: { messageId: 900, chatId: CHAT, pinnedAt: 1000 },
+    });
     await runStatusPinReconcile({
       pinKey: KEY,
       chatId: CHAT,
@@ -192,15 +217,17 @@ describe("runStatusPinReconcile — single-leg actions are unchanged", () => {
       desired: { pinned: true, messageId: 900 },
       persist: null,
       runPin,
-      registries: reg,
+      claims,
+      now: () => 9_999_999,
     });
     expect(legs).toHaveLength(1);
-    expect(reg.pinnedAt.get(KEY)).toBe(1000);
+    expect(legs[0].action.kind).toBe("noop");
+    expect(claims.get(KEY)?.pinnedAt).toBe(1000);
   });
 
-  it("unpin with no claim: one no-op leg, registries stay empty", async () => {
+  it("unpin with no claim: one no-op leg, the registry stays empty", async () => {
     const { legs, runPin } = legRecorder([null]);
-    const reg = registries();
+    const claims = claimsOf();
     await runStatusPinReconcile({
       pinKey: KEY,
       chatId: CHAT,
@@ -208,9 +235,10 @@ describe("runStatusPinReconcile — single-leg actions are unchanged", () => {
       desired: { pinned: false },
       persist: null,
       runPin,
-      registries: reg,
+      claims,
     });
     expect(legs).toHaveLength(1);
-    expect(reg.state.size).toBe(0);
+    expect(legs[0].action.kind).toBe("noop");
+    expect(claims.size).toBe(0);
   });
 });

package/telegram-plugin/tests/status-pin-service-message-suppression.test.ts

@@ -43,13 +43,17 @@ describe('status-pin service-message suppression', () => {
     // message (which would nuke manual/operator pins too) — AND it must be
     // chat-scoped (pinnedMessageIsOurs requires chatId + messageId), never a
     // messageId-only match.
-    expect(MODULE_SRC).toContain('deps.statusPinState')
+    expect(MODULE_SRC).toContain('deps.statusPinClaims')
     expect(MODULE_SRC).toMatch(/pinned_message\?\.message_id/)
     expect(MODULE_SRC).toContain('pinnedMessageIsOurs(')
     // The chatId computed from the update must be fed to the guard.
     expect(MODULE_SRC).toMatch(/pinnedMessageIsOurs\(trackedPins\(\), chatId, pinnedId\)/)
-    // And the tracked entries must carry their chat association.
-    expect(MODULE_SRC).toContain('deps.statusPinChatIds.get(pinKey)')
+    // And the tracked entries must carry their chat association. Since #3809
+    // that association is STRUCTURAL — one claim record per key carrying both
+    // messageId and chatId — so the guard reads it off the claim itself and a
+    // chat-less tracked pin can no longer be constructed.
+    expect(MODULE_SRC).toMatch(/chatId: c\.chatId/)
+    expect(MODULE_SRC).toMatch(/messageId: c\.messageId/)
   })
 
   it('bails out when the pinned message is not one of ours', () => {