@bobfrankston/mailx-types 0.1.71 → 0.1.76

package/index.d.ts

@@ -5,6 +5,7 @@
  */
 export { CONTACT_RULES } from "./contact-rules.js";
 export { assessMessageTrust, spamScoreOf } from "./trust.js";
+export { logIfChanged, clearLogState } from "./log-changes.js";
 export type { TrustFinding, TrustInput, SpamScore } from "./trust.js";
 export type { MailxApi } from "./mailx-api.js";
 export { addContactsDenylistEntry, addContactsPreferredEntry, type PreferredContactEntry, type CloudReadFn, type CloudWriteFn, } from "./contacts-config.js";

package/index.js

@@ -8,6 +8,7 @@
 // junk-contact filtering on every platform.
 export { CONTACT_RULES } from "./contact-rules.js";
 export { assessMessageTrust, spamScoreOf } from "./trust.js";
+export { logIfChanged, clearLogState } from "./log-changes.js";
 // Shared contacts.jsonc mutations — one implementation for desktop + Android.
 export { addContactsDenylistEntry, addContactsPreferredEntry, } from "./contacts-config.js";
 // Group-name expansion for recipient fields. Lets users type a group name

package/log-changes.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Log a line only when it says something new.
+ *
+ * Sync walks ~90 folders every cycle, and a folder in a bad state produces the
+ * SAME line every time — "reconcile refused — would delete 250/250 (100%)"
+ * once per folder per cycle, forever. On Android each of those is an HTTP
+ * request to the log server, and in the file the real news is buried under
+ * hundreds of identical repeats (Bob 2026-08-29: "are we overlogging").
+ *
+ * Deleting the lines is the wrong fix — a refused reconcile is a genuine
+ * anomaly and the log is where it surfaces. What is worth reading is the
+ * CHANGE: the first time a folder enters that state, and every time the
+ * numbers move. So the same key + same text is dropped, a changed text is
+ * printed, and a state that persists is re-stated once an hour so a standing
+ * problem cannot become invisible.
+ *
+ * Keyed by caller-supplied string (account + folder + which check), because
+ * two folders in the same state are two facts, not one.
+ */
+/**
+ * @param key    identifies the thing being described — "acct/folder:reconcile"
+ * @param line   the message; identical text for the same key is suppressed
+ * @param emit   where to write (defaults to console.log; pass a logger in libraries)
+ * @returns whether the line was emitted, so callers can count what they skipped
+ */
+export declare function logIfChanged(key: string, line: string, emit?: (msg: string) => void): boolean;
+/** Forget a key — call when the condition clears, so its return is news again. */
+export declare function clearLogState(key: string): void;
+//# sourceMappingURL=log-changes.d.ts.map

package/log-changes.js

@@ -0,0 +1,42 @@
+/**
+ * Log a line only when it says something new.
+ *
+ * Sync walks ~90 folders every cycle, and a folder in a bad state produces the
+ * SAME line every time — "reconcile refused — would delete 250/250 (100%)"
+ * once per folder per cycle, forever. On Android each of those is an HTTP
+ * request to the log server, and in the file the real news is buried under
+ * hundreds of identical repeats (Bob 2026-08-29: "are we overlogging").
+ *
+ * Deleting the lines is the wrong fix — a refused reconcile is a genuine
+ * anomaly and the log is where it surfaces. What is worth reading is the
+ * CHANGE: the first time a folder enters that state, and every time the
+ * numbers move. So the same key + same text is dropped, a changed text is
+ * printed, and a state that persists is re-stated once an hour so a standing
+ * problem cannot become invisible.
+ *
+ * Keyed by caller-supplied string (account + folder + which check), because
+ * two folders in the same state are two facts, not one.
+ */
+/** How long an unchanged line stays suppressed before being restated. */
+const RESTATE_AFTER_MS = 60 * 60 * 1000;
+const lastSeen = new Map();
+/**
+ * @param key    identifies the thing being described — "acct/folder:reconcile"
+ * @param line   the message; identical text for the same key is suppressed
+ * @param emit   where to write (defaults to console.log; pass a logger in libraries)
+ * @returns whether the line was emitted, so callers can count what they skipped
+ */
+export function logIfChanged(key, line, emit = console.log) {
+    const now = Date.now();
+    const prev = lastSeen.get(key);
+    if (prev && prev.line === line && now - prev.at < RESTATE_AFTER_MS)
+        return false;
+    lastSeen.set(key, { line, at: now });
+    emit(prev && prev.line === line ? `${line} (unchanged for an hour)` : line);
+    return true;
+}
+/** Forget a key — call when the condition clears, so its return is news again. */
+export function clearLogState(key) {
+    lastSeen.delete(key);
+}
+//# sourceMappingURL=log-changes.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx-types",
-  "version": "0.1.71",
+  "version": "0.1.76",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",

package/trust.d.ts

@@ -56,6 +56,14 @@ export interface TrustInput {
     ownAddresses: string[];
     /** Sanitized HTML body, for the link-construct checks. */
     bodyHtml: string;
+    /** The reader has approved this sender or its domain in allowlist.jsonc —
+     *  "Always: *@icecer.com" in the remote-content banner, or "Trust all
+     *  senders at ‹domain›" in the address menu. It answers the only question
+     *  a spam score cannot: is this mail WANTED. It never silences forgery
+     *  evidence, and it counts only on a message whose sender was actually
+     *  proved — otherwise the list would be a switch a forger could flip by
+     *  typing a trusted address into From. */
+    senderTrusted?: boolean;
     /** Plain-text body, for the character-level checks. Separate from the HTML
      *  because markup legitimately contains things prose does not, and the
      *  zero-width test would trip over an entity or an attribute value. */
@@ -105,6 +113,9 @@ export interface SpamScore {
      *  listed in the Spamhaus SBL blocklist)". A number alone is unactionable;
      *  this can be judged in a second. */
     reasons: string[];
+    /** The reader approved this sender AND the sender is proved: the score is
+     *  still true, and no longer worth showing. The viewer hides the chip. */
+    trusted: boolean;
 }
 export declare function spamScoreOf(input: TrustInput): SpamScore;
 //# sourceMappingURL=trust.d.ts.map

package/trust.js

@@ -354,6 +354,16 @@ function serverSpamVerdict(input) {
     const a = analyzeServerSpam(input);
     if (!a || !a.flagged)
         return null;
+    // Mail from a sender the reader has approved, whose identity is proved,
+    // and which nothing accuses of forgery: say nothing at all. The server's
+    // score answers "is this bulk", the reader has already answered "is it
+    // wanted", and repeating the first after the second is how a banner turns
+    // into furniture. (Bob 2026-08-28, having just clicked "Always:
+    // *@icecer.com" on a conference announcement: "I accepted the server so
+    // shouldn't this be considered safe?")
+    const trustedAndProved = input.senderTrusted && a.proved;
+    if (trustedAndProved && a.kind !== "forgery" && !a.authFailures.length)
+        return null;
     const numbers = Number.isFinite(a.score) && Number.isFinite(a.threshold)
         ? `SpamAssassin score ${a.score} of ${a.threshold}`
         : "flagged by SpamAssassin";
@@ -385,6 +395,13 @@ function serverSpamVerdict(input) {
             detail: `${numbers}${why}${bayes}`,
         };
     const proof = a.proved ? `${provedNote(a)} ` : "";
+    if (input.senderTrusted && !a.proved)
+        return {
+            id: "server-spam-verdict",
+            severity: "caution",
+            text: "This claims to be a sender you trust, but nothing proves it is.",
+            detail: `No DMARC pass, no valid signature from the sending domain, and it passed through hosts your server does not trust. ${numbers}${why}`,
+        };
     return {
         id: "server-spam-verdict",
         severity: "caution",
@@ -658,6 +675,7 @@ export function spamScoreOf(input) {
         kind: a.kind,
         proved: a.proved,
         provedBy: a.provedBy,
+        trusted: !!input.senderTrusted && a.proved && a.kind !== "forgery" && !a.authFailures.length,
         reasons: a.reasons,
     };
 }