@novacraft-engineering/mailbox 0.4.25 → 0.4.27

package/app/mail/writing/live.ts

@@ -0,0 +1,34 @@
+import { Extension, type Editor } from '@tiptap/react'
+import { WRITING_DEFAULTS, type WritingSettings } from './settings'
+import type { MailTemplate, TemplateContext } from './templates'
+
+/** What the writing tools need from the page, written after each render and read on keypress. */
+export type Live = {
+  tools: boolean
+  settings: WritingSettings
+  templates: MailTemplate[]
+  context: TemplateContext
+  words: string[]
+  spellOn: boolean
+  grammarOn: boolean
+  headers: () => HeadersInit
+  submit?: () => void
+  openLink?: () => void
+  openFind?: () => void
+}
+
+export const LiveStore = Extension.create<Record<string, never>, Live>({
+  name: 'writingLive',
+  addStorage: () => ({
+    tools: false,
+    settings: WRITING_DEFAULTS,
+    templates: [],
+    context: {},
+    words: [],
+    spellOn: false,
+    grammarOn: false,
+    headers: () => ({}),
+  }),
+})
+
+export const live = (editor: Editor): Live => (editor.storage as unknown as { writingLive: Live }).writingLive

package/app/mail/writing/paste.test.ts

@@ -0,0 +1,17 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import { cleanPastedHtml } from './paste.ts'
+
+test('Word styling is stripped and meaning is kept', () => {
+  const word = '<!--[if gte mso 9]><xml><o:x/></xml><![endif]--><p class="MsoNormal" style="margin:0;font-family:Calibri;mso-bidi-font-weight:bold"><b>Premium</b> due<o:p></o:p></p>'
+  assert.equal(cleanPastedHtml(word), '<p><b>Premium</b> due</p>')
+})
+
+test('Excel tables survive with their structure', () => {
+  const excel = '<style>td{mso-number-format:General}</style><table class="x"><tr><td class="xl65" style="font-family:Calibri">Vehicle</td><td style="text-align:right;font-size:11pt">N150,000</td></tr></table>'
+  assert.equal(cleanPastedHtml(excel), '<table><tr><td>Vehicle</td><td style="text-align:right">N150,000</td></tr></table>')
+})
+
+test('meaningful inline colour survives, bare font wrappers do not', () => {
+  assert.equal(cleanPastedHtml('<font face="Arial">plain</font> <span style="color:red;font-family:Arial">red</span>'), 'plain <span style="color:red">red</span>')
+})

package/app/mail/writing/paste.ts

@@ -0,0 +1,30 @@
+/**
+ * HTML pasted from Word, Outlook or Excel, without the styling that came with it: Office
+ * namespaces, conditional comments, class names and fonts go; bold, lists, links and tables
+ * stay.
+ */
+export function cleanPastedHtml(html: string): string {
+  let cleaned = html
+    .replace(/<!--\[if[\s\S]*?<!\[endif\]-->/gi, '')
+    .replace(/<!--[\s\S]*?-->/g, '')
+    .replace(/<(style|script|xml|title)\b[^>]*>[\s\S]*?<\/\1>/gi, '')
+    .replace(/<(meta|link)\b[^>]*>/gi, '')
+    .replace(/<\/?o:p[^>]*>/gi, '')
+    .replace(/\s(class|lang|face|size)="[^"]*"/gi, '')
+    .replace(/\sstyle="([^"]*)"/gi, (_whole, css: string) => {
+      const kept = css
+        .split(';')
+        .map(rule => rule.trim())
+        .filter(rule => /^(font-weight|font-style|text-decoration|color|background(-color)?|text-align)\s*:/i.test(rule))
+        .filter(rule => !/mso-|windowtext/i.test(rule))
+        .join(';')
+      return kept ? ` style="${kept}"` : ''
+    })
+  for (let previous = ''; previous !== cleaned; ) {
+    previous = cleaned
+    cleaned = cleaned
+      .replace(/<span>((?:(?!<\/?span\b)[\s\S])*)<\/span>/gi, '$1')
+      .replace(/<font\b[^>]*>((?:(?!<\/?font\b)[\s\S])*)<\/font>/gi, '$1')
+  }
+  return cleaned
+}

package/app/mail/writing/settings.ts

@@ -0,0 +1,98 @@
+export type SpellLanguage = 'en-GB' | 'en-US'
+
+export type WritingSettings = {
+  autoCapitalize: boolean
+  spaceAfterStop: boolean
+  capitalizeI: boolean
+  spellcheck: boolean
+  spellLanguage: SpellLanguage
+  ignoreCapitals: boolean
+  ignoreWithNumbers: boolean
+  repeatedWords: boolean
+  autocorrect: boolean
+  personalWords: string[]
+  grammar: boolean
+  tabIndent: boolean
+  doubleTabMs: number
+  templateShortcuts: boolean
+  cleanPaste: boolean
+  amountFormat: boolean
+  nairaLetter: boolean
+  numberFormat: boolean
+  wordCount: boolean
+  checkAttachment: boolean
+  checkEmptyBody: boolean
+  checkPlaceholders: boolean
+  checkGreeting: boolean
+  checkExternal: boolean
+  externalThreshold: number
+}
+
+export const WRITING_DEFAULTS: WritingSettings = {
+  autoCapitalize: true,
+  spaceAfterStop: true,
+  capitalizeI: true,
+  spellcheck: true,
+  spellLanguage: 'en-GB',
+  ignoreCapitals: true,
+  ignoreWithNumbers: true,
+  repeatedWords: true,
+  autocorrect: true,
+  personalWords: [],
+  grammar: false,
+  tabIndent: true,
+  doubleTabMs: 400,
+  templateShortcuts: true,
+  cleanPaste: true,
+  amountFormat: false,
+  nairaLetter: true,
+  numberFormat: false,
+  wordCount: true,
+  checkAttachment: true,
+  checkEmptyBody: true,
+  checkPlaceholders: true,
+  checkGreeting: true,
+  checkExternal: true,
+  externalThreshold: 5,
+}
+
+const clamp = (value: unknown, low: number, high: number, fallback: number) => {
+  const number = Number(value)
+  return Number.isFinite(number) ? Math.min(high, Math.max(low, Math.round(number))) : fallback
+}
+
+/** Whatever was stored, read back as a complete set: a missing or malformed key takes its default. */
+export function writingSettingsFrom(raw: unknown): WritingSettings {
+  const stored = raw && typeof raw === 'object' ? (raw as Record<string, unknown>) : {}
+  const flag = (key: keyof WritingSettings) =>
+    typeof stored[key] === 'boolean' ? (stored[key] as boolean) : (WRITING_DEFAULTS[key] as boolean)
+  return {
+    autoCapitalize: flag('autoCapitalize'),
+    spaceAfterStop: flag('spaceAfterStop'),
+    capitalizeI: flag('capitalizeI'),
+    spellcheck: flag('spellcheck'),
+    spellLanguage: stored.spellLanguage === 'en-US' ? 'en-US' : 'en-GB',
+    ignoreCapitals: flag('ignoreCapitals'),
+    ignoreWithNumbers: flag('ignoreWithNumbers'),
+    repeatedWords: flag('repeatedWords'),
+    autocorrect: flag('autocorrect'),
+    personalWords: Array.isArray(stored.personalWords)
+      ? [...new Set(stored.personalWords.filter((word): word is string => typeof word === 'string' && word.trim().length > 0).map(word => word.trim()))].slice(0, 5000)
+      : [],
+    grammar: flag('grammar'),
+    tabIndent: flag('tabIndent'),
+    doubleTabMs: clamp(stored.doubleTabMs, 200, 1000, WRITING_DEFAULTS.doubleTabMs),
+    templateShortcuts: flag('templateShortcuts'),
+    cleanPaste: flag('cleanPaste'),
+    amountFormat: typeof stored.amountFormat === 'boolean' ? stored.amountFormat : stored.nairaFormat === true,
+    nairaLetter: flag('nairaLetter'),
+    numberFormat: flag('numberFormat'),
+    wordCount: flag('wordCount'),
+    checkAttachment: flag('checkAttachment'),
+    checkEmptyBody: flag('checkEmptyBody'),
+    checkPlaceholders: flag('checkPlaceholders'),
+    checkGreeting: flag('checkGreeting'),
+    checkExternal: flag('checkExternal'),
+    externalThreshold: clamp(stored.externalThreshold, 1, 100, WRITING_DEFAULTS.externalThreshold),
+  }
+}

package/app/mail/writing/spell.worker.ts

@@ -0,0 +1,40 @@
+import nspell from 'nspell'
+
+type Request =
+  | { id: number; type: 'check'; language: string; words: string[] }
+  | { id: number; type: 'suggest'; language: string; word: string }
+
+let checker: ReturnType<typeof nspell> | null = null
+let loaded = ''
+let loading: Promise<void> | null = null
+
+async function ready(language: string) {
+  if (checker && loaded === language) return
+  if (!loading || loaded !== language) {
+    loaded = language
+    loading = Promise.all([
+      fetch(`/dictionaries/${language}.aff`).then(response => response.text()),
+      fetch(`/dictionaries/${language}.dic`).then(response => response.text()),
+    ]).then(([aff, dic]) => {
+      checker = nspell(aff, dic)
+    })
+  }
+  await loading
+}
+
+const plain = (word: string) => word.replace(/’/g, "'")
+
+self.onmessage = async (event: MessageEvent<Request>) => {
+  const request = event.data
+  try {
+    await ready(request.language)
+    if (request.type === 'check') {
+      const wrong = request.words.filter(word => !checker!.correct(plain(word)))
+      postMessage({ id: request.id, wrong })
+    } else {
+      postMessage({ id: request.id, suggestions: checker!.suggest(plain(request.word)).slice(0, 6) })
+    }
+  } catch (err) {
+    postMessage({ id: request.id, error: String(err) })
+  }
+}

package/app/mail/writing/spelling.ts

@@ -0,0 +1,164 @@
+import { Extension } from '@tiptap/react'
+import { Plugin, PluginKey, type EditorState } from '@tiptap/pm/state'
+import { Decoration, DecorationSet, type EditorView } from '@tiptap/pm/view'
+import type { Node as ProseMirrorNode } from '@tiptap/pm/model'
+import type { WritingSettings } from './settings'
+import { live } from './live'
+import { checkableWord, wordsOf } from './text'
+
+let worker: Worker | null = null
+let nextId = 1
+const waiting = new Map<number, (reply: { wrong?: string[]; suggestions?: string[] }) => void>()
+
+function ask<T>(message: Record<string, unknown>): Promise<T> {
+  if (!worker) {
+    worker = new Worker(new URL('./spell.worker.ts', import.meta.url), { type: 'module' })
+    worker.onmessage = event => {
+      const resolve = waiting.get(event.data.id)
+      waiting.delete(event.data.id)
+      resolve?.(event.data)
+    }
+  }
+  const id = nextId++
+  return new Promise(resolve => {
+    waiting.set(id, resolve as (reply: { wrong?: string[]; suggestions?: string[] }) => void)
+    worker!.postMessage({ id, ...message })
+  })
+}
+
+export const suggestSpelling = (word: string, language: string) =>
+  ask<{ suggestions?: string[] }>({ type: 'suggest', language, word }).then(reply => reply.suggestions ?? [])
+
+type SpellState = { set: DecorationSet; version: number }
+
+export const spellingKey = new PluginKey<SpellState>('spelling')
+
+type Found = { from: number; to: number; word: string; kind: 'spelling' | 'repeat' }
+
+function collect(doc: ProseMirrorNode, settings: WritingSettings): Found[] {
+  const found: Found[] = []
+  doc.descendants((node, pos) => {
+    if (node.type.name === 'codeBlock') return false
+    if (!node.isText || !node.text) return true
+    if (node.marks.some(mark => mark.type.name === 'code' || mark.type.name === 'link')) return false
+    const words = wordsOf(node.text)
+    words.forEach((entry, index) => {
+      const previous = words[index - 1]
+      if (
+        settings.repeatedWords &&
+        previous &&
+        previous.word.toLowerCase() === entry.word.toLowerCase() &&
+        /^\s+$/.test(node.text!.slice(previous.end, entry.start)) &&
+        !/^\d+$/.test(entry.word)
+      ) {
+        found.push({ from: pos + entry.start, to: pos + entry.end, word: entry.word, kind: 'repeat' })
+      }
+      found.push({ from: pos + entry.start, to: pos + entry.end, word: entry.word, kind: 'spelling' })
+    })
+    return false
+  })
+  return found
+}
+
+/**
+ * Red underlines under words the dictionary does not know, and a softer one under a word
+ * repeated by accident. Drawn as decorations, so nothing is added to the message itself.
+ */
+export const Spelling = Extension.create<Record<string, never>, { verdicts: Map<string, boolean>; ignored: Set<string> }>({
+  name: 'spelling',
+  addStorage() {
+    return { verdicts: new Map(), ignored: new Set() }
+  },
+  addProseMirrorPlugins() {
+    const storage = this.storage
+    const editor = this.editor
+    let timer: ReturnType<typeof setTimeout> | null = null
+    let language = ''
+
+    const build = (state: EditorState): DecorationSet => {
+      const current = live(editor)
+      if (!current.tools || !current.spellOn) return DecorationSet.empty
+      const settings = current.settings
+      const known = new Set(current.words.map(word => word.toLowerCase()))
+      const head = state.selection.empty ? state.selection.head : -1
+      const decorations: Decoration[] = []
+      for (const entry of collect(state.doc, settings)) {
+        if (entry.kind === 'repeat') {
+          decorations.push(Decoration.inline(entry.from, entry.to, { class: 'rteRepeat', 'data-word': entry.word, 'data-kind': 'repeat' }))
+          continue
+        }
+        if (entry.to === head) continue
+        if (!checkableWord(entry.word, settings)) continue
+        const key = entry.word.toLowerCase()
+        if (known.has(key) || storage.ignored.has(key)) continue
+        if (storage.verdicts.get(entry.word) === false) {
+          decorations.push(Decoration.inline(entry.from, entry.to, { class: 'rteMisspelt', 'data-word': entry.word, 'data-kind': 'spelling' }))
+        }
+      }
+      return DecorationSet.create(state.doc, decorations)
+    }
+
+    const refresh = (view: EditorView) => {
+      const { settings, tools, spellOn } = live(editor)
+      if (!tools || !spellOn) {
+        view.dispatch(view.state.tr.setMeta(spellingKey, DecorationSet.empty))
+        return
+      }
+      if (language !== settings.spellLanguage) {
+        storage.verdicts.clear()
+        language = settings.spellLanguage
+      }
+      const unknown = [
+        ...new Set(
+          collect(view.state.doc, settings)
+            .filter(entry => entry.kind === 'spelling' && checkableWord(entry.word, settings) && !storage.verdicts.has(entry.word))
+            .map(entry => entry.word),
+        ),
+      ]
+      const draw = () => {
+        if (!view.isDestroyed) view.dispatch(view.state.tr.setMeta(spellingKey, build(view.state)))
+      }
+      if (!unknown.length) return draw()
+      void ask<{ wrong?: string[] }>({ type: 'check', language, words: unknown }).then(reply => {
+        const wrong = new Set(reply.wrong ?? [])
+        for (const word of unknown) storage.verdicts.set(word, !wrong.has(word))
+        draw()
+      })
+    }
+
+    const schedule = (view: EditorView, delay: number) => {
+      if (timer) clearTimeout(timer)
+      timer = setTimeout(() => refresh(view), delay)
+    }
+
+    return [
+      new Plugin<SpellState>({
+        key: spellingKey,
+        state: {
+          init: () => ({ set: DecorationSet.empty, version: 0 }),
+          apply(tr, value) {
+            const meta = tr.getMeta(spellingKey) as DecorationSet | 'refresh' | undefined
+            if (meta instanceof DecorationSet) return { set: meta, version: value.version }
+            if (meta === 'refresh') return { set: value.set, version: value.version + 1 }
+            return { set: value.set.map(tr.mapping, tr.doc), version: value.version }
+          },
+        },
+        props: {
+          decorations: state => spellingKey.getState(state)?.set,
+        },
+        view: view => {
+          schedule(view, 50)
+          return {
+            update: (next, previous) => {
+              const refreshed = spellingKey.getState(next.state)?.version !== spellingKey.getState(previous)?.version
+              if (refreshed || !next.state.doc.eq(previous.doc)) schedule(next, refreshed ? 0 : 450)
+            },
+            destroy: () => {
+              if (timer) clearTimeout(timer)
+            },
+          }
+        },
+      }),
+    ]
+  },
+})

package/app/mail/writing/templates.ts

@@ -0,0 +1,40 @@
+export type MailTemplate = { id: string; name: string; shortcut: string; html: string }
+export type TemplateContext = { firstName?: string; name?: string; email?: string; senderName?: string }
+
+export const TEMPLATE_FIELD = /\{[A-Za-z][A-Za-z_ ]{0,29}\}/g
+
+/** A shortcut as the sender types it: ";renewal". Letters, digits, dashes only. */
+export const normaliseShortcut = (raw: string) => raw.trim().toLowerCase().replace(/^;+/, '').replace(/[^a-z0-9-]/g, '')
+
+/** Fills the fields a template can know about; the rest stay as {field} for the sender to Tab through. */
+export function fillTemplate(html: string, context: TemplateContext, today = new Date()): string {
+  const known: Record<string, string | undefined> = {
+    first_name: context.firstName,
+    firstname: context.firstName,
+    name: context.name ?? context.firstName,
+    email: context.email,
+    sender_name: context.senderName,
+    my_name: context.senderName,
+    date: today.toLocaleDateString('en-GB', { day: 'numeric', month: 'long', year: 'numeric' }),
+    today: today.toLocaleDateString('en-GB', { day: 'numeric', month: 'long', year: 'numeric' }),
+  }
+  return html.replace(TEMPLATE_FIELD, field => {
+    const value = known[field.slice(1, -1).trim().toLowerCase().replace(/\s+/g, '_')]
+    return value ? value.replace(/&/g, '&amp;').replace(/</g, '&lt;') : field
+  })
+}
+
+const SHARED_MAILBOXES = new Set([
+  'info', 'admin', 'support', 'claims', 'accounts', 'account', 'underwriting', 'sales', 'hello', 'contact', 'enquiries',
+  'enquiry', 'noreply', 'no-reply', 'mail', 'office', 'team', 'service', 'services', 'customerservice', 'customercare',
+  'care', 'help', 'hr', 'finance', 'billing', 'operations', 'ops', 'reception', 'marketing', 'news', 'notifications',
+])
+
+/** A first name from an address like eric.samuel@…; nothing for a shared mailbox like info@. */
+export function firstNameFromAddress(address: string | undefined): string | undefined {
+  const local = (address ?? '').split('@')[0]?.toLowerCase() ?? ''
+  if (!local || SHARED_MAILBOXES.has(local)) return undefined
+  const first = local.split(/[._-]/)[0]
+  if (!/^[a-z]{2,20}$/.test(first) || SHARED_MAILBOXES.has(first)) return undefined
+  return first[0].toUpperCase() + first.slice(1)
+}

package/app/mail/writing/text.test.ts

@@ -0,0 +1,88 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import { checkableWord, correctWord, formatAmount, startsSentence, wordsOf } from './text.ts'
+
+test('a sentence starts after a full stop, question or exclamation, and at a paragraph start', () => {
+  assert.equal(startsSentence(''), true)
+  assert.equal(startsSentence('   '), true)
+  assert.equal(startsSentence('Thank you. '), true)
+  assert.equal(startsSentence('Is it ready? '), true)
+  assert.equal(startsSentence('Done! '), true)
+  assert.equal(startsSentence('He said "yes." '), true)
+  assert.equal(startsSentence('Thank you.'), false, 'no space yet')
+  assert.equal(startsSentence('Thank you '), false)
+})
+
+test('abbreviations, initials and ellipses do not start a sentence', () => {
+  assert.equal(startsSentence('for e.g. '), false)
+  assert.equal(startsSentence('i.e. '), false)
+  assert.equal(startsSentence('Metroperil Ltd. '), false)
+  assert.equal(startsSentence('Policy No. '), false)
+  assert.equal(startsSentence('Dear Mr. '), false)
+  assert.equal(startsSentence('from J. '), false)
+  assert.equal(startsSentence('Well... '), false)
+  assert.equal(startsSentence('see info@x.com. '), false)
+  assert.equal(startsSentence('visit www. '), false, 'www. is an address, not a sentence end')
+})
+
+test('typos are corrected keeping their capitals', () => {
+  assert.equal(correctWord('teh'), 'the')
+  assert.equal(correctWord('Teh'), 'The')
+  assert.equal(correctWord('TEH'), 'THE')
+  assert.equal(correctWord('dont'), "don't")
+  assert.equal(correctWord('recieved'), 'received')
+  assert.equal(correctWord('the'), null)
+})
+
+test('amounts in any currency are grouped', () => {
+  const on = { nairaLetter: true, plainNumbers: false }
+  assert.equal(formatAmount('N1500000', on), '\u20a61,500,000')
+  assert.equal(formatAmount('NGN2500.50', on), 'NGN2,500.50')
+  assert.equal(formatAmount('$2500', on), '$2,500')
+  assert.equal(formatAmount('\u00a31250000', on), '\u00a31,250,000')
+  assert.equal(formatAmount('USD150000', on), 'USD150,000')
+  assert.equal(formatAmount('2500', on, 'USD'), '2,500', 'a code written apart still makes it money')
+  assert.equal(formatAmount('N1500000', { ...on, nairaLetter: false }), null)
+  assert.equal(formatAmount('N123', on), null, 'too short to be an amount')
+  assert.equal(formatAmount('NIGERIA', on), null)
+})
+
+test('plain numbers are grouped only when asked, and never years, phones or account numbers', () => {
+  const plain = { nairaLetter: true, plainNumbers: true }
+  assert.equal(formatAmount('1500000', plain), '1,500,000')
+  assert.equal(formatAmount('15000.75', plain), '15,000.75')
+  assert.equal(formatAmount('1500000', { ...plain, plainNumbers: false }), null)
+  assert.equal(formatAmount('2026', plain), null, 'a year')
+  assert.equal(formatAmount('08061397800', plain), null, 'a phone number')
+  assert.equal(formatAmount('2034567890', plain), null, 'a ten-digit account number')
+})
+
+test('only real words are checked', () => {
+  const options = { ignoreCapitals: true, ignoreWithNumbers: true }
+  assert.equal(checkableWord('insurance', options), true)
+  assert.equal(checkableWord('LASACO', options), false)
+  assert.equal(checkableWord('LASACO', { ...options, ignoreCapitals: false }), true)
+  assert.equal(checkableWord('AKD792', options), false)
+  assert.equal(checkableWord('a', options), false)
+})
+
+test('addresses are not split into words', () => {
+  assert.deepEqual(wordsOf('Mail info@metroperil.com today').map(entry => entry.word), ['Mail', 'today'])
+  assert.deepEqual(wordsOf("don't stop").map(entry => entry.word), ["don't", 'stop'])
+})
+
+test('templates fill what they can and leave the rest to Tab through', async () => {
+  const { fillTemplate, normaliseShortcut } = await import('./templates.ts')
+  const html = fillTemplate('<p>Dear {first_name}, as at {date} policy {policy_no} is due. {sender_name}</p>', { firstName: 'Eric', senderName: 'Richard' }, new Date('2026-09-23T10:00:00Z'))
+  assert.equal(html, '<p>Dear Eric, as at 23 September 2026 policy {policy_no} is due. Richard</p>')
+  assert.equal(normaliseShortcut(';Renewal Notice'), 'renewalnotice')
+})
+
+test('a first name is read from a personal address, never from a shared one', async () => {
+  const { firstNameFromAddress } = await import('./templates.ts')
+  assert.equal(firstNameFromAddress('eric.samuel@coronation.ng'), 'Eric')
+  assert.equal(firstNameFromAddress('sijuatobatele@lasaco.com'), 'Sijuatobatele')
+  assert.equal(firstNameFromAddress('info@metroperil.com'), undefined)
+  assert.equal(firstNameFromAddress('claims@insurer.com'), undefined)
+  assert.equal(firstNameFromAddress('a2b@x.com'), undefined)
+})

package/app/mail/writing/text.ts

@@ -0,0 +1,106 @@
+const ABBREVIATIONS = new Set([
+  'e.g', 'i.e', 'etc', 'eg', 'ie', 'vs', 'viz', 'cf', 'al', 'approx', 'ref', 'no', 'nos', 'tel', 'fig', 'p', 'pp', 'pg',
+  'mr', 'mrs', 'ms', 'dr', 'prof', 'sr', 'jr', 'st', 'hon', 'rev', 'engr', 'arc', 'barr', 'chief', 'alh', 'gen', 'capt',
+  'ltd', 'plc', 'inc', 'co', 'corp', 'dept', 'est', 'attn', 'encl', 'pls', 'www',
+  'jan', 'feb', 'mar', 'apr', 'jun', 'jul', 'aug', 'sep', 'sept', 'oct', 'nov', 'dec',
+])
+
+/**
+ * Whether a letter typed after `before` begins a sentence. `before` is the paragraph's text
+ * up to the caret. "e.g. the" and "Ltd. has" do not; "1.5" and "metroperil.com" never
+ * reach here because nothing but a space follows a full stop that ends a sentence.
+ */
+export function startsSentence(before: string): boolean {
+  if (!before.trim()) return true
+  const match = before.match(/(\S*?)([.!?])["'”’)\]]*\s+$/)
+  if (!match) return false
+  if (match[2] !== '.') return true
+  if (/\.\.$/.test(before.trimEnd().replace(/["'”’)\]]+$/, ''))) return false
+  const word = match[1].replace(/^["'“‘(\[]+/, '').toLowerCase()
+  if (ABBREVIATIONS.has(word)) return false
+  if (/^[a-z]$/.test(word)) return false
+  return !/@|\//.test(word)
+}
+
+const TYPOS: Record<string, string> = {
+  teh: 'the', hte: 'the', adn: 'and', nad: 'and', taht: 'that', thta: 'that', wiht: 'with', whit: 'with',
+  recieve: 'receive', recieved: 'received', reciept: 'receipt', beleive: 'believe', acheive: 'achieve',
+  seperate: 'separate', seperately: 'separately', definately: 'definitely', occured: 'occurred',
+  occurence: 'occurrence', untill: 'until', wich: 'which', becuase: 'because', becasue: 'because',
+  thier: 'their', freind: 'friend', calender: 'calendar', accomodate: 'accommodate', acommodate: 'accommodate',
+  adress: 'address', buisness: 'business', comittee: 'committee', commited: 'committed', enviroment: 'environment',
+  existance: 'existence', foward: 'forward', goverment: 'government', gaurantee: 'guarantee', garantee: 'guarantee',
+  immediatly: 'immediately', independant: 'independent', neccessary: 'necessary', necesary: 'necessary',
+  noticable: 'noticeable', occassion: 'occasion', persue: 'pursue', posession: 'possession', prefered: 'preferred',
+  premuim: 'premium', premiun: 'premium', polcy: 'policy', ploicy: 'policy', insurace: 'insurance', insurnace: 'insurance',
+  renewel: 'renewal', reneval: 'renewal', recomend: 'recommend', refered: 'referred', responsability: 'responsibility',
+  sincerly: 'sincerely', succesful: 'successful', sucessful: 'successful', tommorow: 'tomorrow', tomorow: 'tomorrow',
+  truely: 'truly', wierd: 'weird', writting: 'writing', thanx: 'thanks', pls: 'please', plz: 'please',
+  dont: "don't", doesnt: "doesn't", didnt: "didn't", cant: "can't", couldnt: "couldn't", wouldnt: "wouldn't",
+  shouldnt: "shouldn't", isnt: "isn't", wasnt: "wasn't", arent: "aren't", werent: "weren't", havent: "haven't",
+  hasnt: "hasn't", wont: "won't", im: "I'm", ive: "I've", youre: "you're", theyre: "they're", thats: "that's",
+}
+
+/** The correction for a mistyped word, keeping its capitals; null when the word is fine. */
+export function correctWord(word: string): string | null {
+  const fixed = TYPOS[word.toLowerCase()]
+  if (!fixed) return null
+  if (word === word.toUpperCase() && word.length > 1) return fixed.toUpperCase()
+  if (word[0] === word[0].toUpperCase()) return fixed[0].toUpperCase() + fixed.slice(1)
+  return fixed
+}
+
+const CURRENCY_CODES = 'NGN|USD|GBP|EUR|GHS|KES|ZAR|XOF|XAF|CAD|AUD|JPY|CNY|INR|AED|CHF|EGP|RWF|UGX|TZS'
+const CURRENCY_SYMBOLS = '\u20a6$\u00a3\u20ac\u00a5\u20b9\u20b5'
+const MONEY = new RegExp(`^(${CURRENCY_CODES}|[${CURRENCY_SYMBOLS}]|N)(\\d{4,})(\\.\\d{1,2})?$`)
+const CURRENCY_ALONE = new RegExp(`^(?:${CURRENCY_CODES}|[${CURRENCY_SYMBOLS}]|N)$`)
+
+const group = (digits: string) => digits.replace(/\B(?=(\d{3})+(?!\d))/g, ',')
+
+export type AmountOptions = { nairaLetter: boolean; plainNumbers: boolean }
+
+/**
+ * An amount with its thousands grouped: "$2500" → "$2,500", "USD 1500000" → "USD 1,500,000",
+ * and, when asked for, "N1500000" → "₦1,500,000" and a bare "150000" → "150,000".
+ *
+ * A bare number is only grouped at five to nine digits and never with a leading zero, so a
+ * year, a phone number and a ten-digit account number are left as typed. `previous` is the
+ * word before, so "USD 2500" is money even though the amount stands alone.
+ */
+export function formatAmount(token: string, options: AmountOptions, previous = ''): string | null {
+  const money = token.match(MONEY)
+  if (money) {
+    if (money[1] === 'N' && !options.nairaLetter) return null
+    return `${money[1] === 'N' ? '\u20a6' : money[1]}${group(money[2])}${money[3] ?? ''}`
+  }
+  const bare = token.match(/^(\d{4,})(\.\d{1,2})?$/)
+  if (!bare) return null
+  if (CURRENCY_ALONE.test(previous) && !(previous === 'N' && !options.nairaLetter)) return `${group(bare[1])}${bare[2] ?? ''}`
+  if (options.plainNumbers && /^[1-9]\d{4,8}$/.test(bare[1])) return `${group(bare[1])}${bare[2] ?? ''}`
+  return null
+}
+
+/** Whether a word should be put to the dictionary at all. */
+export function checkableWord(word: string, options: { ignoreCapitals: boolean; ignoreWithNumbers: boolean }): boolean {
+  if (word.length < 2) return false
+  if (/\d/.test(word)) return !options.ignoreWithNumbers
+  if (!/^[A-Za-zÀ-ɏ'’-]+$/.test(word)) return false
+  if (options.ignoreCapitals && word === word.toUpperCase()) return false
+  return true
+}
+
+/** The words of a passage with their offsets, ignoring web and email addresses. */
+export function wordsOf(text: string): Array<{ word: string; start: number; end: number }> {
+  const out: Array<{ word: string; start: number; end: number }> = []
+  const skip: Array<[number, number]> = []
+  for (const match of text.matchAll(/\S+@\S+|https?:\/\/\S+|www\.\S+|\b\S+\.(?:com|ng|org|net|io|africa|co|uk)\b\S*/gi)) {
+    skip.push([match.index ?? 0, (match.index ?? 0) + match[0].length])
+  }
+  for (const match of text.matchAll(/[A-Za-zÀ-ɏ0-9]+(?:['’-][A-Za-zÀ-ɏ0-9]+)*/g)) {
+    const start = match.index ?? 0
+    const end = start + match[0].length
+    if (skip.some(([from, to]) => start >= from && end <= to)) continue
+    out.push({ word: match[0], start, end })
+  }
+  return out
+}

package/lib/mail-provider.ts

@@ -174,7 +174,7 @@ async function sendViaSes(payload: SendPayload): Promise<SendResult> {
  * A mailbox this deployment owns that keeps a copy of everything the app sends on its own
  * behalf. Product mail is invisible otherwise: it leaves for the recipient and no account
  * here ever sees it. Skipped when the archive is already a recipient, so a message never
- * arrives twice.
+ * arrives twice, and skipped for anything a person wrote — their Sent folder already has it.
  */
 function withArchive(payload: SendPayload): SendPayload {
   const archive = (process.env.MAIL_ARCHIVE_BCC ?? '').trim().toLowerCase()

package/lib/scheduled.ts

@@ -145,9 +145,10 @@ async function dispatchRow(row: Record<string, unknown>): Promise<'sent' | 'fail
   try {
     // scheduledAt is deliberately dropped: the wait already happened here.
     const { scheduledAt: _ignored, ...payload } = send.payload
-    const result = await sendMail(
-      payload.html ? { ...payload, html: absoluteUrls(payload.html, BRAND.publicUrl) } : payload,
-    )
+    const result = await sendMail({
+      ...(payload.html ? { ...payload, html: absoluteUrls(payload.html, BRAND.publicUrl) } : payload),
+      skipArchive: true,
+    })
     await recordSend(send, result?.id ?? null)
     await sql`
       UPDATE mail_scheduled SET status = 'sent', sent_id = ${result?.id ?? null}, last_error = NULL WHERE id = ${id}`