@bobfrankston/rmfmail 1.2.286 → 1.2.287

package/.commitmsg

@@ -1,43 +1,33 @@
-Spam banner: classify the rules instead of reusing the delivery score
+Grammar squiggles: stop inventing words, stop underlining white space
 
-The trust banner asked "is this forged" and answered it with SpamAssassin's
-bottom line, a number tuned to answer "should this be delivered". Four
-newsletters Bob subscribed to (Constant Contact, Adobe MAX, Mokin, ActBlue)
-scored 2.2 to 10.9 and two of them raised "This message is not what it says
-it is" — on mail that passes DMARC aligned on a published reject policy,
-where that headline is factually false. What scored them was bulk-mail rules
-and third-party blocklist entries about hosts they merely link to: Mokin's
-6.0 URIBL_SBL is the Spamhaus listing of the IP of the nameserver of a linked
-domain, fourth-order guilt by association, more than the whole 4.5 threshold
-on its own.
+Three complaints from one compose session (Bob 2026-08-27, forwarding a
+message), all of them the checker arguing with prose that was fine:
 
-trust.ts now reads the `tests=` list that was sitting in the same header and
-sorts the rules into what they are evidence OF — forgery, third-party
-association, bulk mail, or unclassified — and reads the topmost
-Authentication-Results for a DMARC-aligned pass. Severity follows the rules,
-never the number:
+1. "keypoint". Harper's CompoundNouns rule fires on any noun+noun pair whose
+   joined form is in its dictionary, so "One key point in my recent efforts"
+   came back as an error suggesting a word he did not write. Disabled in the
+   daemon next to AvoidCurses — same objection as that one: the tool
+   proofreads, it does not get a vote on word choice. Its siblings (MergeWords,
+   MakeupCompoundNoun, OvertimeCompoundNoun, ThereAfterCompound,
+   EasyGoingCompoundAdjective) are named in a comment there, one line each to
+   turn off if they start nagging.
 
-  - a forgery rule fired, or the server itself recorded an SPF/DKIM/DMARC
-    failure -> danger, unchanged. Phishing and malware URL listings count as
-    identity evidence, so a lookalike domain with its own valid DKIM cannot
-    buy silence.
-  - sender DMARC-proved and every rule that scored is one this file can name,
-    or the whole score is bulk rules -> info: a new neutral severity with no
-    headline and no "do not open anything" footer.
-  - anything else -> caution, including a proved sender whose score came from
-    rules with no class. Unknown is never a reason to go quiet.
+2. A blue dotted line across two blank lines. blockText concatenated a block's
+   text nodes with no separator, so the last word of a paragraph was glued to
+   the first word of the next: "…of the network" + "To: x@y.com" reached Harper
+   as "networkTo", and it reported — correctly, for the string it was given —
+   that the word should be split. The span then covered a junction that on
+   screen is two empty lines, and getClientRects painted a full-width underline
+   over the whitespace. Verified both halves against the real engine: gluing
+   produces `networkTo` and `FrankstonSubject` lints that vanish once the
+   breaks are there. blockText now emits "\n" at every line-breaking element,
+   and spanToRange refuses any span whose ends sit in different line boxes, so
+   no squiggle can ever be drawn across a paragraph boundary again.
 
-Findings and the score chip now come from one analysis, so they cannot
-disagree; the chip goes grey rather than red when the sender is proved or the
-score is all bulk, and both name their evidence ("8.0 SH_DBL_HEADERS (A domain
-found in headers is listed in DBL)") instead of showing a bare number. The
-`threshold/2` chip floor is untouched — see docs/spam-false-positives.md on
-why tuning it is not the fix.
+3. Lints on the sentence being typed. The unfinished sentence under the caret
+   is now exempt — a thought that is not out yet is not an error.
 
-Over 20,291 messages in the store, 1,131 were flagged spam and every one of
-them used to get the red banner: now 294 do, 672 are caution, 165 are quiet
-notes. Tests cover all four sample messages verbatim, plus the two ways the
-proof could be gamed (a forged Authentication-Results below the server's own,
-and one naming a different From).
-
-TODO C165 first cut. Sender trust via allowlist.jsonc still open.
+The pure helpers (collectBlocks, blockText, lineBox, caretOffset,
+sentenceStart, spanToRange) moved to module scope and are exported, because
+they hold the decisions worth testing; tests/dom/harper-lint.test.ts covers all
+three rules in jsdom, using the forward markup client/app.ts actually builds.

package/client/compose/compose.bundle.js

@@ -3710,7 +3710,13 @@ var init_spellcheck = __esm({
 // client/compose/harper-lint.js
 var harper_lint_exports = {};
 __export(harper_lint_exports, {
-  initHarperLint: () => initHarperLint
+  blockText: () => blockText,
+  caretOffset: () => caretOffset,
+  collectBlocks: () => collectBlocks,
+  initHarperLint: () => initHarperLint,
+  lineBox: () => lineBox,
+  sentenceStart: () => sentenceStart,
+  spanToRange: () => spanToRange
 });
 function initHarperLint(ed) {
   let disposed = false;
@@ -3735,42 +3741,6 @@ function initHarperLint(ed) {
     doc.getElementById(OVERLAY_ID2)?.remove();
     doc.getElementById(POPUP_ID)?.remove();
   };
-  const collectBlocks = (root) => {
-    const kids = Array.from(root.children).filter((c) => c instanceof HTMLElement);
-    const blocks = (kids.length ? kids : [root]).filter((b) => b.tagName !== "BLOCKQUOTE" && !b.closest("blockquote") && !b.querySelector("blockquote"));
-    return blocks;
-  };
-  const blockText = (block, doc) => {
-    const walker = doc.createTreeWalker(block, NodeFilter.SHOW_TEXT);
-    const nodes = [];
-    let text = "";
-    for (let n = walker.nextNode(); n; n = walker.nextNode()) {
-      nodes.push({ node: n, from: text.length });
-      text += n.data;
-    }
-    return { text, nodes };
-  };
-  const spanToRange = (doc, nodes, start, end) => {
-    let a = null;
-    let b = null;
-    for (const e of nodes) {
-      const len = e.node.data.length;
-      if (!a && start >= e.from && start <= e.from + len)
-        a = { node: e.node, off: start - e.from };
-      if (end >= e.from && end <= e.from + len)
-        b = { node: e.node, off: end - e.from };
-    }
-    if (!a || !b)
-      return null;
-    try {
-      const r = doc.createRange();
-      r.setStart(a.node, a.off);
-      r.setEnd(b.node, b.off);
-      return r;
-    } catch {
-      return null;
-    }
-  };
   const paint = () => {
     if (disposed)
       return;
@@ -3834,9 +3804,13 @@ function initHarperLint(ed) {
       const tx = texts[i];
       if (!tx)
         return;
+      const caret = caretOffset(t.doc, tx.nodes);
+      const writingFrom = caret < 0 ? -1 : sentenceStart(tx.text, caret);
       for (const l of lints || []) {
         if (SKIP_KINDS.has(l.kind))
           continue;
+        if (writingFrom >= 0 && l.end > writingFrom && l.start <= caret)
+          continue;
         const range = spanToRange(t.doc, tx.nodes, l.start, l.end);
         if (range)
           next.push({ lint: l, range });
@@ -3966,7 +3940,7 @@ function initHarperLint(ed) {
     }
   };
 }
-var DEBOUNCE_MS, OVERLAY_ID2, POPUP_ID, SKIP_KINDS;
+var DEBOUNCE_MS, OVERLAY_ID2, POPUP_ID, SKIP_KINDS, collectBlocks, LINE_BREAKING, blockText, lineBox, caretOffset, sentenceStart, spanToRange;
 var init_harper_lint = __esm({
   "client/compose/harper-lint.js"() {
     "use strict";
@@ -3975,6 +3949,100 @@ var init_harper_lint = __esm({
     OVERLAY_ID2 = "harper-overlay";
     POPUP_ID = "harper-popup";
     SKIP_KINDS = /* @__PURE__ */ new Set(["Spelling"]);
+    collectBlocks = (root) => {
+      const kids = Array.from(root.children).filter((c) => c instanceof HTMLElement);
+      const blocks = (kids.length ? kids : [root]).filter((b) => b.tagName !== "BLOCKQUOTE" && !b.closest("blockquote") && !b.querySelector("blockquote"));
+      return blocks;
+    };
+    LINE_BREAKING = /* @__PURE__ */ new Set([
+      "BR",
+      "P",
+      "DIV",
+      "LI",
+      "UL",
+      "OL",
+      "TR",
+      "TD",
+      "TH",
+      "TABLE",
+      "PRE",
+      "HR",
+      "BLOCKQUOTE",
+      "H1",
+      "H2",
+      "H3",
+      "H4",
+      "H5",
+      "H6",
+      "SECTION",
+      "ARTICLE",
+      "FIGURE"
+    ]);
+    blockText = (block, doc) => {
+      const walker = doc.createTreeWalker(block, NodeFilter.SHOW_TEXT | NodeFilter.SHOW_ELEMENT);
+      const nodes = [];
+      let text = "";
+      let pendingBreak = false;
+      for (let n = walker.nextNode(); n; n = walker.nextNode()) {
+        if (n.nodeType === Node.ELEMENT_NODE) {
+          if (LINE_BREAKING.has(n.tagName))
+            pendingBreak = true;
+          continue;
+        }
+        const data = n.data;
+        if (!data)
+          continue;
+        if (pendingBreak && text)
+          text += "\n";
+        pendingBreak = false;
+        nodes.push({ node: n, from: text.length });
+        text += data;
+      }
+      return { text, nodes };
+    };
+    lineBox = (node) => {
+      for (let e = node; e; e = e.parentNode)
+        if (e.nodeType === Node.ELEMENT_NODE && LINE_BREAKING.has(e.tagName))
+          return e;
+      return null;
+    };
+    caretOffset = (doc, nodes) => {
+      const sel = doc.getSelection?.();
+      if (!sel || !sel.focusNode)
+        return -1;
+      for (const e of nodes)
+        if (e.node === sel.focusNode)
+          return e.from + sel.focusOffset;
+      return -1;
+    };
+    sentenceStart = (text, caret) => {
+      const before = text.slice(0, caret);
+      const m = before.match(/[.!?…\n][^.!?…\n]*$/);
+      return m ? caret - (m[0].length - 1) : 0;
+    };
+    spanToRange = (doc, nodes, start, end) => {
+      let a = null;
+      let b = null;
+      for (const e of nodes) {
+        const len = e.node.data.length;
+        if (!a && start >= e.from && start <= e.from + len)
+          a = { node: e.node, off: start - e.from };
+        if (end >= e.from && end <= e.from + len)
+          b = { node: e.node, off: end - e.from };
+      }
+      if (!a || !b)
+        return null;
+      if (lineBox(a.node) !== lineBox(b.node))
+        return null;
+      try {
+        const r = doc.createRange();
+        r.setStart(a.node, a.off);
+        r.setEnd(b.node, b.off);
+        return r;
+      } catch {
+        return null;
+      }
+    };
   }
 });