@mikitasazan/notify 1.11.0 → 1.12.0

package/dist/render.js

@@ -20,7 +20,6 @@
  * after every line.
  */
 import { ICON, iconFor } from "./events.js";
-/** First letter capitalized, the rest left as is (ga4/GitHub stay themselves). */
 /**
  * A label gets a capital letter — but NOT a name that is deliberately
  * written lowercase: `iOS` was turning into `IOS`. The signal is a capital
@@ -52,7 +51,7 @@ export const esc = (v) => String(v ?? '')
  *    Telegram replies `400 can't parse entities`, and we treat a 4xx as a
  *    permanent error and do not retry — the message disappeared for good.
  */
-export const clampMessage = (text, limit = 4000) => {
+export const clampMessage = (text, limit = 4000, marker = '…') => {
     if (text.length <= limit) {
         return text;
     }
@@ -61,8 +60,14 @@ export const clampMessage = (text, limit = 4000) => {
     // Cut on a line boundary — only if that keeps most of the content.
     let end = lastBreak > limit * 0.6 ? lastBreak : limit;
     // Never cut inside `<...>` or inside `&...;` — otherwise the markup breaks.
+    // The closing `>` must be searched for only up to `end`, not across all of
+    // `cut`: a `>` that belongs to a LATER, already-doomed part of the message
+    // (still inside `cut` because `cut` runs to `limit`, past `end`) used to
+    // read as "this tag is closed" and let a tag get cut mid-attribute anyway —
+    // found by GLM review, reproduces with a long `href` that straddles the
+    // line-boundary cut point.
     const openTag = cut.lastIndexOf('<', end - 1);
-    if (openTag !== -1 && cut.indexOf('>', openTag) === -1) {
+    if (openTag !== -1 && cut.slice(openTag, end).indexOf('>') === -1) {
         end = openTag;
     }
     const amp = cut.lastIndexOf('&', end - 1);
@@ -103,7 +108,12 @@ export const clampMessage = (text, limit = 4000) => {
         .reverse()
         .map((t) => `</${t}>`)
         .join('');
-    return `${body}${tail}\n…`;
+    // The marker ANNOUNCES the cut instead of hiding it (v2.1): the caller
+    // reserves the marker's length out of `limit` before calling, so the
+    // marker itself can never be the thing that pushes the message over
+    // Telegram's hard cap — a free addition on top of 4000/4096 plus a long
+    // path was measured to earn a 400, and a 4xx is never retried.
+    return `${body}${tail}\n${marker}`;
 };
 // Only the first line: a field is single-line by contract (commit, branch,
 // author, a stat), not a place for a paragraph. A live case (18.08): a CI card
@@ -124,6 +134,21 @@ const firstLine = (value) => {
  * value serializes as `null`, not as a missing key.
  */
 const field = (label, value) => value === undefined || value === null || value === '' ? null : `<b>${esc(cap(label))}:</b> ${esc(firstLine(value))}`;
+/**
+ * A Reason-shaped field: one line stays an ordinary field, several lines
+ * become a captioned quote — NOTHING is cut to the first line any more.
+ * `field`'s silent `firstLine` on a multi-line reason was the v1 contract,
+ * and it gutted every card whose failure did not fit one line (scp retries,
+ * a three-line diagnosis): the owner saw `Connection timed…` and nothing
+ * else. Confirmed live on four cards in the 14-day sweep, fixed in v2.1.
+ */
+const reason = (label, value) => {
+    if (value === undefined || value === null || value === '') {
+        return null;
+    }
+    const text = String(value);
+    return text.includes('\n') ? quoted(label, text) : field(label, text);
+};
 /**
  * An identifier field (`commit:`/`pr:`/`issue:`): the value is a link if
  * one exists, otherwise the plain text of the same field — an identifier
@@ -140,19 +165,43 @@ const fieldLink = (label, url, text) => {
         ? `<b>${esc(cap(label))}:</b> <a href="${esc(url)}">${esc(firstLine(text))}</a>`
         : field(label, text);
 };
-/**
- * An action field (`workflow:`): unlike `fieldLink`, without a URL this is
- * NOT a field — the run simply has nowhere to lead, and showing the bare
- * word "run" with no link is more meaningless than not showing the row at
- * all.
- */
-// The link text is the name of where it leads (the workflow's name, the run's
-// name). The fallback word used to be "run": a noun that names nothing — the
-// owner read "Workflow: run" and did not understand what it was. "open" is a
-// verb, and it is at least honest about being a link, not a name.
-const fieldAction = (label, url, text) => url ? `<b>${esc(cap(label))}:</b> <a href="${esc(url)}">${esc(text ?? 'open')}</a>` : null;
 /** A monospace field — a path/command to copy, not a link. */
 const fieldCode = (label, value) => value ? `<b>${esc(cap(label))}:</b> <code>${esc(value)}</code>` : null;
+/**
+ * A person field — Author, Assignee, Reviewer. Every one of them is a
+ * GitHub login (`github-cards.py` reads it off `.user.login`/`.assignee.login`
+ * on the GitHub API object), and every GitHub login is a profile at one fixed
+ * address: `github.com/<login>`. The owner: "автор должен вести на страницу
+ * автора" — a name is an identifier like a commit hash or a PR number, and
+ * every other identifier on the card is a link.
+ */
+// `firstLine`, same as `fieldLink`: a login with an embedded `\n` (found by
+// Codex/GLM review) would otherwise land a raw newline inside the `href`
+// itself, not just the link text — every other field guards against a
+// multi-line value, this one didn't.
+const fieldPerson = (label, login) => {
+    if (!login) {
+        return null;
+    }
+    const oneLine = firstLine(login);
+    return `<b>${esc(cap(label))}:</b> <a href="https://github.com/${esc(oneLine)}">${esc(oneLine)}</a>`;
+};
+/**
+ * `Actor` on a CI card is a Telegram handle, not a GitHub login
+ * (`nightly.yml`, step "Кто чинит" — "по «@chelsnebes» приходит уведомление
+ * тому, кто чинит, по «mikitasazan» — нет"), so it links to Telegram, not
+ * GitHub: `github.com/@chelsnebes` would open a page that does not exist.
+ * Telegram DOES auto-link a bare `@handle` on its own, but the owner asked
+ * for an explicit link like every other identifier on the card, not an
+ * implicit one riding on a client behavior he cannot see from here.
+ */
+const fieldTelegram = (label, handle) => {
+    if (!handle) {
+        return null;
+    }
+    const oneLine = firstLine(handle);
+    return `<b>${esc(cap(label))}:</b> <a href="https://t.me/${esc(oneLine.replace(/^@/, ''))}">${esc(oneLine)}</a>`;
+};
 /**
  * A row that asks something FROM THE OWNER, rather than reports a fact. It
  * already stood last, set off by a blank line, and still read as an
@@ -178,13 +227,25 @@ const fieldRun = (value, why) => {
 };
 /** A group heading: italic + underline, no bold, no colon. */
 const group = (name) => `<i><u>${esc(cap(name))}</u></i>`;
-/** An item inside a group: `<b>label:</b> <a>text</a>` — or a plain bulleted/numbered row with no label. */
+/**
+ * An item inside a group: `<b>label:</b> <a>text</a>` — or a plain
+ * bulleted/numbered row with no label. `facts`, when the item carries them,
+ * print as indented `label: value` rows underneath — a nested list, one
+ * item with several facts of its own, the way a search query has both a
+ * click count and a position.
+ */
 const groupItem = (it, index, numbered) => {
     const linked = it.url ? `<a href="${esc(it.url)}">${esc(it.text)}</a>` : esc(it.text);
-    if (it.label) {
-        return `<b>${esc(it.label)}:</b> ${linked}`;
+    const head = it.label
+        ? `<b>${esc(cap(it.label))}:</b> ${linked}`
+        : numbered
+            ? `${index + 1}. ${linked}`
+            : `• ${linked}`;
+    if (!it.facts || it.facts.length === 0) {
+        return head;
     }
-    return numbered ? `${index + 1}. ${linked}` : `• ${linked}`;
+    const sub = it.facts.map(([label, value]) => `   <b>${esc(cap(label))}:</b> ${esc(String(value))}`);
+    return [head, ...sub].join('\n');
 };
 // A long explanation (a note, incident details) — as a quote: in Telegram
 // that is a bar on the left and a light indent, reading as "details," not as
@@ -206,15 +267,16 @@ const note = (text) => {
  * the card says it nowhere. The caption stands on its own line, because
  * the text itself does not fit in a field: a field holds one line and cuts
  * it.
+ *
+ * The caption is a bold field label with nothing after the colon, not the
+ * group() heading (italic-underline). It was the group heading first, and
+ * the owner read that and said it did not look like a category — correctly:
+ * a group is a heading over a LIST, and this caption sits over one quote,
+ * never more than one. A bold label with no value on the line is the same
+ * shape `Title:` already has right before a PR's body — the reader has
+ * already seen this exact pattern mean "what follows is quoted text."
  */
-/**
- * A quote that needs saying what it is. The heading is a GROUP heading — the
- * same italic-underline every other card uses over a block — not a bold field
- * label: a bold label means `label: value` on one line, and using it here made
- * the session card the only one whose block was titled a third way. The owner
- * read the card and asked where its group was.
- */
-const quoted = (label, text) => text ? `${group(label)}\n${note(text)}` : null;
+const quoted = (label, text) => text ? `<b>${esc(cap(label))}:</b>\n${note(text)}` : null;
 /**
  * Assembles the card. A blank line here marks a block change, not
  * indentation: two in a row mean an empty block, a leading one means a
@@ -421,14 +483,12 @@ const typeLine = (icon, type, action, url, aside) => {
 /**
  * What to call the thing that ran. The workflow's own name first — it is the
  * only text here that identifies THIS run. Then the caller's own word for the
- * mechanism (`manual, from the Mac`). Last resort `the run`, and only when a
- * link exists: losing the link to the logs on a red card is the one loss this
- * format cannot afford, and a row that says nothing is still better than a
- * card with nowhere to click. No live sender reaches that last resort — the
- * GitHub Action always fills the workflow name, and the hand-run scripts send
- * no run link at all.
+ * mechanism (`manual, from the Mac`). No third fallback: a row that says
+ * nothing distinctive is worse than not printing a name at all, and
+ * `typeLine` already handles the case with no name — a bare `<b>Deploy</b>`,
+ * still linked when a run URL exists.
  */
-const mechanism = (workflowName, via, runUrl) => workflowName ?? via;
+const mechanism = (workflowName, via) => workflowName ?? via;
 // The name of what ran sits WITH the type line, not eight lines below it.
 // `Deploy: fail` and `by what means it ran` answer one question, and the owner
 // read the two rows as unrelated things. It used to be one fact split in two:
@@ -443,14 +503,19 @@ const mechanism = (workflowName, via, runUrl) => workflowName ?? via;
 // unlinked, because a hand deploy has no run to open.
 const renderDeploy = (e) => {
     const icon = iconFor(e);
-    const runUrl = e.workflowUrl ?? e.url;
     return join([
-        // The name of what shipped the deploy sits on the type line. The outcome
-        // is already said by the icon and the third tag; there is nothing to
-        // repeat in words, and it is the same law a job and a report follow. The
-        // `Via` row is gone: it used to carry this same name one floor below.
-        typeLine(icon, 'Deploy', mechanism(e.workflowName, e.via, runUrl), runUrl),
-        ...twoBlocks([field('Target', e.target), field('Reason', e.note)], [commitRow(e.commit, e.commitUrl, e.commitTitle), bodyQuote(e.commitBody)])
+        // The name of what shipped the deploy sits on the type line, the outcome
+        // in parens beside it — icon and tag alone were judged, live, not to be
+        // enough: a plain 🔴 next to a workflow name still read as "something
+        // happened," not "it failed," on a screen small enough to lose the color.
+        // The `Via` row is gone: it used to carry this same name one floor below.
+        // The run URL is gone from this line too — it is the `Source:` row now.
+        typeLine(icon, 'Deploy', mechanism(e.workflowName, e.via), undefined, e.status === 'fail' ? 'Fail' : 'OK'),
+        ...twoBlocks([field('Target', e.target), reason('Reason', e.note), field('Still red', e.stillRed ? `day ${e.stillRed}` : null)], [
+            commitRow(e.commit, e.commitUrl, e.commitTitle),
+            fieldPerson('Author', e.commitAuthor),
+            bodyQuote(e.commitBody)
+        ])
     ]);
 };
 const schedule = (expected, lastSeen, lastLabel) => {
@@ -472,27 +537,30 @@ const renderJob = (e) => {
     // icon says and what the third tag now says too. The icon table on the
     // catalogue page defines both marks.
     return join([
-        typeLine(icon, 'Job', e.job, e.workflowUrl ?? e.url, e.aside),
-        field('Reason', e.note),
+        // The URL moved off the type line into the `Source:` row of the pointer
+        // block (v2.1, rule S): the owner asked for a pointer he can SEE, and a
+        // link riding invisibly on the name is not one.
+        typeLine(icon, 'Job', e.job, undefined, e.aside),
+        reason('Reason', e.note),
+        field('Still red', e.stillRed ? `day ${e.stillRed}` : null),
         // The timetable is a different subject from this event: how often the task
         // owes a sign of life and when it last gave one. It stood in a bare run
         // under `Reason:` and read as more of the same. `Last run` when the task
         // is alive, `Last seen` when it is not — one timestamp, two questions.
         ...schedule(e.expected, e.lastSeen, e.status === 'silent' ? 'Last seen' : 'Last run'),
         ...labelled(e.stats),
+        e.detail ? '' : null,
+        quoted(e.detailLabel ?? 'Detail', e.detail),
         hasItems ? '' : null,
         // Heading ONLY for `disabled`. It used to print for any job carrying a
         // list, so playhub's daily card of newly published games was headed
         // "Disabled workflows".
         disabledList ? group('Disabled workflows') : null,
         ...(hasItems ? bullets(e.items, disabledList) : []),
-        e.command || e.logs ? '' : null,
-        fieldCode('Log', e.logs),
+        e.command ? '' : null,
         ...fieldRun(e.command, e.commandNote)
-        // No trailing `Workflow:` row. It pointed at `workflowUrl ?? url` — the
-        // exact address line 2 already carries — so it was one destination
-        // written twice, and it stood BELOW the `To do:` command, which is the
-        // last thing the card is supposed to say.
+        // `Log:` left this body for the pointer block that `render` appends to
+        // every card — the block a cut can never take.
     ]);
 };
 const renderReport = (e) => {
@@ -503,7 +571,7 @@ const renderReport = (e) => {
         // without a word.
         const numbers = labelled(e.lines);
         return join([
-            typeLine(iconFor(e), 'Report', e.title, e.url, e.aside),
+            typeLine(iconFor(e), 'Report', e.title, undefined, e.aside),
             // Rows with no group of their own sit flush against the header instead of
             // forming a separate slab under a blank line. `labelled` puts the blank
             // line before the first group itself, so there is none here.
@@ -514,25 +582,37 @@ const renderReport = (e) => {
     }
     const items = bullets(e.items, false);
     return join([
-        // Both analytics jobs send a link to the day's snapshot in docs/. It used to
-        // hang off a trailing `Details: open` row; now it is the report's own name.
-        typeLine(iconFor(e), 'Report', e.title, e.url, e.aside),
+        // The day's snapshot link is the `Source:` row now, same as every URL.
+        typeLine(iconFor(e), 'Report', e.title, undefined, e.aside),
         // Flush against the header — see the branch above.
         ...labelled(e.lines),
         items.length > 0 ? '' : null,
         ...items
     ]);
 };
-// Same law as the deploy card, one row up: what ran is named beside the type
-// line and carries the link to its run. The label is `Check` and not `Via`
-// because here the name answers WHICH gate spoke — `nightly`, `Quality` —
-// while on a deploy it answers by what means the code was shipped.
+// Same law as the deploy card: what ran joins the type line itself and
+// carries the link to its run — `CI: nightly`, not a separate `Check:`/`Via:`
+// row. There is no separate label here at all: on deploy the mechanism
+// answers by what means the code was shipped, on CI it answers WHICH gate
+// spoke (`nightly`, `Quality`) — but both are the name on the type line.
 const renderCi = (e) => {
     const icon = iconFor(e);
-    const runUrl = e.workflowUrl ?? e.url;
     return join([
-        typeLine(icon, 'CI', mechanism(e.workflowName, undefined, runUrl), runUrl),
-        ...twoBlocks([field('Actor', e.actor), field('Reason', e.note)], [commitRow(e.commit, e.commitUrl, e.commitTitle), bodyQuote(e.commitBody)])
+        // The run URL is the `Source:` row now, not an invisible link on the name.
+        typeLine(icon, 'CI', mechanism(e.workflowName, undefined), undefined, e.status === 'fail' ? 'Fail' : 'OK'),
+        // `Actor` used to be read as "who wrote the commit," and on most runs it
+        // is — `github.actor` for a push IS the person who pushed. It stops being
+        // that on a scheduled run: arvent's nightly rewrites it to whoever is on
+        // duty to fix a red run, which can be someone other than the commit's
+        // author. So Actor answers "who is responsible for this run," `Author`
+        // below the commit answers "who wrote this code" — two different people
+        // on a nightly card, the same person everywhere else.
+        ...twoBlocks([reason('Reason', e.note), field('Still red', e.stillRed ? `day ${e.stillRed}` : null)], [
+            fieldTelegram('Actor', e.actor),
+            commitRow(e.commit, e.commitUrl, e.commitTitle),
+            fieldPerson('Author', e.commitAuthor),
+            bodyQuote(e.commitBody)
+        ])
     ]);
 };
 // A pull request and an issue are identified the way GitHub itself identifies
@@ -548,22 +628,42 @@ const named = (number, title) => title ? `#${number} ${title}` : `#${number}`;
 // about someone taking issue #312 and asked who, because he never got that far.
 //
 // The description is the news exactly once, when the thing is opened. On
-// assigned, closed, merged or a review verdict it is text he has already read,
-// and it buries the one line he came for.
-const opening = (action, body) => action === 'opened' ? bodyQuote(body) : null;
+// assigned, closed or merged it is text he has already read, and it buries
+// the one line he came for.
+//
+// A review verdict is the one exception: on `approved`/`changes_requested`
+// `body` is not the PR's description any more — the sender puts the
+// REVIEWER'S OWN comment there, which is new text he has not seen. "Verdict:
+// changes_requested, then nothing" was the owner's complaint: a verdict with
+// no comment attached said less than the review itself did.
+const VERDICT = new Set(['approved', 'changes_requested']);
+const opening = (action, body) => action === 'opened' || VERDICT.has(action) ? bodyQuote(body) : null;
+// The body is what the title stands for — it sits directly under the name,
+// with nothing between them. The people come after, consolidated in one
+// place, never splitting the title from what it names: the owner on the
+// old order, title then Author then Assignee then finally the body — "why
+// does the assignee cut apart what should be inseparable?"
 const renderPr = (e) => join([
-    typeLine(iconFor(e), 'PR', named(e.number, e.title), e.url),
-    field('Author', e.author),
-    field('Reviewer', e.reviewer),
-    e.action === 'opened' && e.body ? '' : null,
-    opening(e.action, e.body)
+    typeLine(iconFor(e), 'PR', named(e.number, e.title)),
+    opening(e.action, e.body),
+    (e.action === 'opened' || VERDICT.has(e.action)) && e.body ? '' : null,
+    fieldPerson('Author', e.author),
+    fieldPerson('Reviewer', e.reviewer)
 ]);
+// The issue's body prints ONLY on `opened` — the same law the PR card
+// follows. History of this line: hidden → shown everywhere (the owner's call
+// of 26.08.2026, "inconsistent with the same card showing it moments
+// earlier") → hidden again on 31.08.2026, when the owner, shown the live
+// duplicate ("the full body arrives a second time in one day"), delegated
+// the call ("сделай как лучше по оптимизации и простоте") and approved the
+// short assigned card in the v2.1 mockups. On assigned/closed the card is
+// the one new fact plus the `Source:` link to the full text.
 const renderIssue = (e) => join([
-    typeLine(iconFor(e), 'Issue', named(e.number, e.title), e.url),
-    field('Author', e.author),
-    field('Assignee', e.assignee),
+    typeLine(iconFor(e), 'Issue', named(e.number, e.title)),
+    e.action === 'opened' ? bodyQuote(e.body) : null,
     e.action === 'opened' && e.body ? '' : null,
-    opening(e.action, e.body)
+    fieldPerson('Author', e.author),
+    fieldPerson('Assignee', e.assignee)
 ]);
 // The incident's own title IS line 2, exactly as an issue's is. It used to say
 // the word `open` there — which the 🚨 already says, and no other card repeats
@@ -573,12 +673,17 @@ const renderIssue = (e) => join([
 // log path). It used to go through `field`, which keeps only the first line, so
 // every alarm this package ever sent arrived gutted. It is quoted now, the same
 // shape a commit body takes.
-const renderIncident = (e) => join([
-    typeLine(iconFor(e), 'Incident', e.title, e.url),
-    e.detail && e.detail !== e.title ? note(e.detail) : null,
-    e.logs ? '' : null,
-    fieldCode('Log', e.logs)
-]);
+const renderIncident = (e) => {
+    const findings = bullets(e.items, false);
+    return join([
+        typeLine(iconFor(e), 'Incident', e.title),
+        e.detail && e.detail !== e.title ? note(e.detail) : null,
+        field('Still red', e.stillRed ? `day ${e.stillRed}` : null),
+        findings.length > 0 ? '' : null,
+        ...findings
+        // `Log:` moved to the pointer block `render` appends — see renderJob.
+    ]);
+};
 // A session in trouble. Same law as every other card: identifier first, then
 // the facts as fields, then his own words as a quote — never as a field, which
 // keeps one line and clipped the name of the very session the card is about.
@@ -593,7 +698,8 @@ const renderSession = (e) => join([
     // opened a block that had no heading. Facts about the session touch the
     // line that names it, the way they do on every job card.
     field('Project', e.workdir),
-    field('Reason', e.reason),
+    reason('Reason', e.reason),
+    field('Still red', e.stillRed ? `day ${e.stillRed}` : null),
     e.opened ? '' : null,
     quoted('Opened with', e.opened),
     e.command ? '' : null,
@@ -718,12 +824,62 @@ export const OUTCOME_TAG = {
 };
 export const outcomeTag = (e) => OUTCOME_TAG[iconFor(e)];
 const tagsLine = (e) => `#${TYPE_TAG[e.type]} #${esc(eventKey(e))} #${outcomeTag(e)}`;
+/**
+ * Rule S (v2.1): the card's last block says where to verify it. `Source:` is
+ * a hyperlink when the event has a canonical URL; `Check:` is a local
+ * command; `Log:` is a path and only ever an ADDITION — a path cannot be
+ * tapped, only copied. The link text is a short English noun naming what
+ * opens, never the click.
+ */
+const SOURCE_NAME = {
+    deploy: 'workflow run',
+    ci: 'workflow run',
+    job: 'workflow run',
+    report: 'report',
+    pr: 'pull request',
+    issue: 'issue',
+    incident: 'details',
+    session: 'details',
+    heartbeat_miss: 'details'
+};
+const sourceUrl = (e) => {
+    const wf = 'workflowUrl' in e ? e.workflowUrl : undefined;
+    const url = 'url' in e ? e.url : undefined;
+    return wf ?? url;
+};
+const pointerBlock = (e) => {
+    const url = sourceUrl(e);
+    const logs = 'logs' in e ? e.logs : undefined;
+    const rows = [
+        fieldCode('Log', logs),
+        fieldCode('Check', e.check),
+        url ? `<b>Source:</b> <a href="${esc(url)}">${esc(SOURCE_NAME[e.type] ?? 'source')}</a>` : null
+    ].filter((r) => r !== null);
+    return rows.length > 0 ? `\n\n${rows.join('\n')}` : '';
+};
+/**
+ * The line that stands in for what the cut removed. It rides INSIDE the
+ * budget (the caller subtracts its length before clamping), so announcing
+ * the cut can never itself overflow the limit — with an attachment the
+ * limit is 1024, and the old flat 40-character margin did not fit a marker
+ * plus a path.
+ */
+const cutMarker = (e) => {
+    if (e.path) {
+        return '⋯ cut, full text attached';
+    }
+    const logs = 'logs' in e ? e.logs : undefined;
+    return logs ? `⋯ cut, full: <code>${esc(logs)}</code>` : '⋯ cut';
+};
 /**
  * Renders an event into finished HTML text, cut to Telegram's limit.
- * Tags are the FIRST line, added before the cut (not after, as before):
- * they carry both the human filter and the parser's machine key — a card
- * cut without them would be not only unclickable but invisible to the
- * parser on exactly the longest, meaning the most important, messages.
+ *
+ * Assembly is TAIL-FIRST (v2.1): the parts that must survive any cut — the
+ * tag line (the human filter and the parser's machine key), the pointer
+ * block (`Log`/`Check`/`Source`) and the cut marker — are measured before
+ * the body is clamped, and the body gets what is left. Under the old order
+ * the pointer was part of the body, so the longest cards lost exactly the
+ * line saying where to look.
  */
 export const render = (e) => {
     const renderer = RENDERERS[e.type];
@@ -734,11 +890,14 @@ export const render = (e) => {
         throw new Error(`unknown event type: ${String(e.type)}`);
     }
     const tags = tagsLine(e);
-    // clampMessage can go past the passed limit for the tail of closing tags
-    // and the ellipsis — minus 40 leaves it that margin. Messages already have
-    // their own margin (4000 against Telegram's 4096); for a caption the 1024
-    // limit is the real one. A card with an attachment is a caption, so the
-    // budget is chosen by `path`.
-    const budget = Math.max(64, e.path ? 1024 - tags.length - 40 : 4000 - tags.length - 1);
-    return `${tags}\n${clampMessage(renderer(e), budget)}`;
+    const pointer = pointerBlock(e);
+    const marker = cutMarker(e);
+    // clampMessage can go past the passed limit for the tail of closing tags —
+    // minus 40 leaves it that margin. Messages already have their own margin
+    // (4000 against Telegram's 4096); for a caption the 1024 limit is the real
+    // one. A card with an attachment is a caption, so the budget is chosen by
+    // `path`.
+    const limit = e.path ? 1024 : 4000;
+    const budget = Math.max(64, limit - tags.length - pointer.length - marker.length - 42);
+    return `${tags}\n${clampMessage(renderer(e), budget, marker)}${pointer}`;
 };

package/dist/send.d.ts

@@ -1,3 +1,10 @@
 import type { NotifyEvent } from './events.ts';
 export type SendResult = 'sent' | 'skipped' | 'failed';
+/** Exported for tests only — the time is injectable so day counting is provable. */
+export declare const dedupe: (e: NotifyEvent, now?: number) => {
+    action: "send" | "suppress";
+    stillRed?: number;
+};
+/** 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>;