@mikitasazan/notify 1.26.0 → 1.26.1

package/dist/send.d.ts

@@ -5,6 +5,21 @@ export declare const dedupe: (e: NotifyEvent, now?: number) => {
     action: "send" | "suppress";
     stillRed?: number;
 };
+/**
+ * One slot per OFFENDER — project, type and the card's own instance key —
+ * not per type (15.09.2026). Keyed by type, the red about a broken weekly
+ * script went green the moment ANY other script of that type sent a clean
+ * card, the reactor deleted the red and closed its issue, and next week the
+ * same red counted as a first day again: an issue never filed. The slot is
+ * both the watchdog card's key and the entry in the red memory below.
+ */
+export declare const brokenSlot: (e: NotifyEvent) => string;
+/** Exported for tests: remember that this offender's red is in the feed. */
+export declare const rememberBroken: (slot: string, now?: number) => void;
+/** Exported for tests: true once — the slot was red and is forgotten now. */
+export declare const forgetBroken: (slot: string) => boolean;
+/** Exported for tests: the green that pairs with brokenCardEvent's red — same key, same project. */
+export declare const healedCardEvent: (e: NotifyEvent) => NotifyEvent;
 /** Exported for tests: the watchdog's own card must provably pass the lint. */
 export declare const brokenCardEvent: (e: NotifyEvent, faults: string[], offenderHtml: string) => NotifyEvent;
 export declare const notify: (e: NotifyEvent) => Promise<SendResult>;

package/dist/send.js

@@ -412,6 +412,62 @@ const journal = (line) => {
         // the journal is best-effort: a card must never be lost to bookkeeping
     }
 };
+/**
+ * One slot per OFFENDER — project, type and the card's own instance key —
+ * not per type (15.09.2026). Keyed by type, the red about a broken weekly
+ * script went green the moment ANY other script of that type sent a clean
+ * card, the reactor deleted the red and closed its issue, and next week the
+ * same red counted as a first day again: an issue never filed. The slot is
+ * both the watchdog card's key and the entry in the red memory below.
+ */
+export const brokenSlot = (e) => `notify-broken-${String(e.type)}-${String(e.project)}-${eventKey(e)}`;
+const brokenStatePath = () => join(dirname(statePath()), 'notify-broken.red.json');
+const readBroken = () => {
+    try {
+        const parsed = JSON.parse(readFileSync(brokenStatePath(), 'utf8'));
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+};
+const writeBroken = (state) => {
+    try {
+        const file = brokenStatePath();
+        mkdirSync(dirname(file), { recursive: true });
+        const tmp = `${file}.tmp${process.pid}`;
+        writeFileSync(tmp, JSON.stringify(state, null, 1));
+        renameSync(tmp, file);
+    }
+    catch {
+        // memory is best-effort: a lost entry costs one green, never a card
+    }
+};
+/** Exported for tests: remember that this offender's red is in the feed. */
+export const rememberBroken = (slot, now = Date.now()) => {
+    const state = readBroken();
+    state[slot] = new Date(now).toISOString().slice(0, 10);
+    writeBroken(state);
+};
+/** Exported for tests: true once — the slot was red and is forgotten now. */
+export const forgetBroken = (slot) => {
+    const state = readBroken();
+    if (!Object.hasOwn(state, slot)) {
+        return false;
+    }
+    delete state[slot];
+    writeBroken(state);
+    return true;
+};
+/** Exported for tests: the green that pairs with brokenCardEvent's red — same key, same project. */
+export const healedCardEvent = (e) => ({
+    type: 'job',
+    project: 'mac-config',
+    job: 'notify: a card broke the standard',
+    status: 'ok',
+    note: `the ${String(e.type)} card for ${String(e.project)} passes the standard again`,
+    key: brokenSlot(e)
+});
 /** Exported for tests: the watchdog's own card must provably pass the lint. */
 export const brokenCardEvent = (e, faults, offenderHtml) => {
     const offender = offenderHtml
@@ -436,7 +492,7 @@ export const brokenCardEvent = (e, faults, offenderHtml) => {
         detail: offender || undefined,
         detailLabel: 'Offender',
         check: 'config jobs --log notify-broken',
-        key: `notify-broken-${String(e.type)}`
+        key: brokenSlot(e)
     };
 };
 const reportBrokenCard = async (e, faults, offenderHtml) => {
@@ -455,6 +511,19 @@ const reportBrokenCard = async (e, faults, offenderHtml) => {
         journal(`notify-watchdog: own card failed lint: ${ownFaults.join('; ')}`);
     }
     await deliver(targets(broken), html).catch(() => undefined);
+    rememberBroken(brokenSlot(e));
+};
+/**
+ * The green half of the watchdog: the offender's next clean card heals its
+ * own red, and only its own. Sent through `deliver` directly, not `notify`,
+ * so a green can never be swallowed by the 20h window a red just used.
+ */
+const reportHealedCard = async (e) => {
+    if (!forgetBroken(brokenSlot(e))) {
+        return;
+    }
+    const healed = healedCardEvent(e);
+    await deliver(targets(healed), render(healed)).catch(() => undefined);
 };
 export const notify = async (e) => {
     // Object.hasOwn, not `in`: `in` walks the prototype chain, and
@@ -486,5 +555,8 @@ export const notify = async (e) => {
     if (faults.length > 0) {
         await reportBrokenCard(e, faults, html);
     }
+    else {
+        await reportHealedCard(e);
+    }
     return result;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikitasazan/notify",
-  "version": "1.26.0",
+  "version": "1.26.1",
   "description": "Единая типизированная отправка Telegram-уведомлений (форум-темы, маршрутизация, ретраи) для всех проектов",
   "type": "module",
   "license": "MIT",