email-origin-chain 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Flo (yodjii)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,425 @@
+# email-origin-chain
+
+**Uncover the full audit trail of your email threads.** Recursively deep-dives into forwards and replies to reconstruct the entire conversation history. Combines MIME traversal with multi-language text detection for a perfect message chain—giving you instant access to the original sender's details and the true source message.
+
+## Architecture & Refactor
+
+The library recently underwent a major refactor to a plugin-based architecture, improving compatibility and fix recursion bugs.
+
+Detailed documentation can be found in the [docs/architecture/](docs/architecture/README.md) directory:
+- [Phase 1: Cc: Fix](docs/architecture/phase1_cc_fix.md)
+- [Phase 2: Plugin Architecture](docs/architecture/phase2_plugin_foundation.md)
+- [Phase 3: Full Compatibility (100%)](docs/architecture/phase3_fallbacks.md)
+- [Deep Forward Fix Walkthrough](docs/walkthrough_deep_forward_fix.md)
+- [Detector Usage & Priorities](docs/detectors_usage.md)
+
+**✅ Test Coverage:** The library has been validated against **239 fixtures** from the `email-forward-parser-recursive` library with a **100% success rate** (239/239). This includes validating message bodies and ensuring non-message snippets are correctly identified. See [Test Coverage Report](docs/TEST_COVERAGE.md) for details.
+
+## Features
+
+- **Hybrid Strategy**: Combines MIME recursion (`message/rfc822`) and inline text parsing
+- **Reply & Forward Support**: Detects both traditional "Forwarded message" blocks and "On ... wrote:" reply headers in 15+ languages.
+- **Robust Parsing**: Uses `mailparser` and `email-forward-parser` with custom detectors for Outlook Live, French headers, and more.
+- **Type-Safe**: Full TypeScript support
+- **Normalized Output**: Consistent result format with diagnostics
+
+## Installation
+
+```bash
+npm install
+```
+
+### CLI Utilities
+You can test any email file directly using the included extraction tool:
+```bash
+npx tsx bin/extract.ts tests/fixtures/complex-forward.eml
+```
+
+```typescript
+import { extractDeepestHybrid } from 'email-deepest-forward';
+
+// Process a full EML with hybrid strategy
+const result = await extractDeepestHybrid(rawEmailString);
+
+// Process ONLY the text/inline forwards (ignore MIME layer)
+const textOnlyResult = await extractDeepestHybrid(rawText, { skipMimeLayer: true });
+
+console.log(result.text); // The deepest original message
+console.log(result.history); // Full conversation chain
+```
+
+## Options
+
+| Option | Type | Default | Description |
+| :--- | :--- | :--- | :--- |
+| `skipMimeLayer` | `boolean` | `false` | If `true`, ignores MIME parsing (`rfc822`) and processes the input as raw text only. Ideal for inputs that are already stripped of headers. |
+| `maxDepth` | `number` | `5` | Maximum number of recursion levels for MIME parsing. |
+| `timeoutMs` | `number` | `5000` | Timeout for MIME processing to prevent blocking on huge files. |
+
+## Response Format
+
+The library returns a `ResultObject` with the following structure:
+
+| Field | Type | Description |
+| :--- | :--- | :--- |
+| `from` | `object \| null` | `{ name?: string, address?: string }`. |
+| `to` | `array` | List of primary recipients. |
+| `cc` | `array` | List of CC recipients. |
+| `subject` | `string \| null` | The original subject line of the deepest message. |
+| `date_raw` | `string \| null` | The original date string found in the email headers. |
+| `date_iso` | `string \| null` | ISO 8601 UTC representation (normalized via `any-date-parser`). |
+| `text` | `string \| null` | Cleaned body content of the deepest message. |
+| `attachments` | `array` | Metadata for MIME attachments found at the deepest level. |
+| `history` | `array` | **Conversation Chaining**: Full audit trail of the discussion (see below). |
+| `diagnostics` | `object` | Metadata about the parsing process. |
+
+### Diagnostics Detail
+
+- **`method`**: Strategy used to find the deepest message.
+    - `rfc822`: Found via recursive MIME attachments (highest reliability).
+    - `inline`: Found via text pattern detection (forwarded blocks).
+    - `fallback`: No forward found, returning current message info or best-effort extraction.
+- **`depth`**: Number of forward levels traversed (0 for original email).
+- **`parsedOk`**: `true` if at least a sender (`from`) and `subject` were successfully extracted.
+- **`warnings`**: Array of non-fatal issues (e.g., date normalization failure).
+
+### Conversation Chain Reconstruction (Full History)
+
+Rather than just finding the "original" source, the library reconstructs the entire **Conversation Chain** (sometimes called *Email Threading* or *Message Chaining*). This allows you to audit every step of a transfer:
+
+- **`history[0]`**: The **deepest** (oldest) message in the chain. Same as the root object.
+- **`history[1...n-1]`**: Intermediate forwards/messages.
+- **`history[n]`**: The **root** (most recent) message you actually received.
+
+Each history entry contains its own `from`, `to`, `cc`, `subject`, `date_iso`, `text`, and **`flags`** (array of strings). The contact fields (`from`, `to`, `cc`) are structured as objects containing:
+- **`name`**: The display name (e.g., "John Doe").
+- **`address`**: The email address (e.g., "john@example.com").
+
+#### Possible Flags:
+- `level:deepest`: The original source of the thread.
+- `level:root`: The entry representing the received email itself.
+- `trust:high_mime`: Metadata from a real `.eml` attachment (100% reliable).
+- `trust:medium_inline`: Metadata extracted from text patterns (best effort).
+- `method:crisp_engine`: Detected via standard international patterns (Crisp).
+- `method:outlook_fr`: Detected via standard rules (French, Outlook).
+- `method:outlook_reverse_fr`: Detected via reversed rules (Envoyé before De).
+- `method:outlook_empty_header`: Detected via permissive rules (No date/email).
+- `method:new_outlook`: Detected via modern localized headers (handles bolding and `mailto:` tags).
+- `method:reply`: Detected via international reply patterns (`On ... wrote:`).
+- `method:crisp`: Detected via standard international patterns (Crisp/Fallback).
+- `content:silent_forward`: The user forwarded the message without adding any text.
+- `date:unparseable`: A date string was found but could not be normalized to ISO.
+
+### Typical Output Example
+
+```json
+{
+  "from": { "name": "Original Sender Name", "address": "original@source.com" },
+  "subject": "Initial Topic",
+  "text": "The very first message content.",
+  "history": [
+    {
+      "depth": 2,
+      "from": { "name": "Original Sender Name", "address": "original@source.com" },
+      "text": "The very first message content.",
+      "flags": ["method:outlook_fr", "trust:medium_inline", "level:deepest"]
+    },
+    {
+      "depth": 1,
+      "from": { "name": "Intermediate Person", "address": "inter@company.com" },
+      "text": "",
+      "flags": ["method:crisp", "trust:medium_inline", "content:silent_forward"]
+    },
+    {
+      "depth": 0,
+      "from": { "name": "Me", "address": "me@provider.com" },
+      "text": "Check this thread below!",
+      "flags": ["trust:high_mime", "level:root"]
+    }
+  ],
+  "diagnostics": {
+    "method": "inline",
+    "depth": 2,
+    "parsedOk": true,
+    "warnings": []
+  }
+}
+```
+
+## Examples
+
+### 1. Simple Email (No Forward)
+When no forward is detected, the library returns the metadata of the email itself.
+
+```typescript
+const email = `From: alice@example.com
+Subject: Meeting Update
+Date: Mon, 26 Jan 2026 15:00:00 +0100
+
+Hey, the meeting is moved to 4 PM.`;
+
+const result = await extractDeepestHybrid(email);
+console.log(result.diagnostics.depth); // 0
+console.log(result.from.address);      // "alice@example.com"
+```
+
+### 2. Double Inline Forward (Deep Extraction)
+The library recursively follows "Forwarded message" blocks to find the original sender.
+
+```typescript
+const doubleForward = `
+---------- Forwarded message ---------
+From: Flo R. <florian.regalo@gmail.com>
+Date: Mon, 26 Jan 2026 at 15:01
+Subject: Fwd: original topic
+
+---------- Forwarded message ---------
+From: Original Sender <original@source.com>
+Date: Mon, 26 Jan 2026 at 10:00
+Subject: original topic
+
+This is the very first message content.`;
+
+const result = await extractDeepestHybrid(doubleForward);
+console.log(result.diagnostics.depth);  // 2
+console.log(result.from.address);       // "original@source.com"
+console.log(result.text);               // "This is the very first message content."
+```
+
+### 3. Extreme Conversation Chain (5 Levels)
+For complex corporate threads where a message is forwarded multiple times across different regional offices (e.g., mixing English and French headers).
+
+```typescript
+const extremeChain = `From: boss@corp.com
+Date: Tue, 27 Jan 2026 02:35:18 +0100
+Subject: FW: Final Review
+
+Check the bottom of this long thread.
+
+---------- Forwarded message ---------
+From: "Intermediate Manager" <inter-2@corp.com>
+Date: mardi 27 janvier 2026 à 00:30
+Subject: Tr: Final Review
+
+But it is quite normal!
+
+De : "Employee" <real.end@gmail.com>
+Envoyé : mardi 27 janvier 2026 à 00:30
+À : "Recip" <inter-1@provider.com>
+Objet : Fwd: Final Review
+
+Great Yodjii, thank you
+
+---------- Forwarded message ---------
+From: <inter-1@provider.com>
+Date: Tue, 27 Jan 2026 at 00:29
+Subject: Fwd: original request
+
+Ok noted, I am forwarding it back to you.
+
+---------- Forwarded message ---------
+From: <original@source.com>
+Date: mardi 27 janvier 2026 à 00:28
+Subject: original request
+
+Hello, please forward this back to me.`;
+
+const result = await extractDeepestHybrid(extremeChain);
+console.log(result.diagnostics.depth); // 4 (5 messages total)
+```
+
+**JSON Output Example (Extreme Case):**
+
+```json
+{
+  "from": { "address": "original@source.com" },
+  "subject": "original request",
+  "text": "Hello, please forward this back to me.",
+  "history": [
+    {
+      "depth": 4,
+      "from": { "address": "original@source.com" },
+      "text": "Hello, please forward this back to me.",
+      "flags": ["method:crisp", "trust:medium_inline", "level:deepest"]
+    },
+    {
+      "depth": 3,
+      "from": { "address": "inter-1@provider.com" },
+      "text": "Ok noted, I am forwarding it back to you.",
+      "flags": ["method:crisp", "trust:medium_inline"]
+    },
+    {
+      "depth": 2,
+      "from": { "name": "Employee", "address": "real.end@gmail.com" },
+      "text": "Great Yodjii, thank you",
+      "flags": ["method:outlook_empty_header", "trust:medium_inline"]
+    },
+    {
+      "depth": 1,
+      "from": { "name": "Intermediate Manager", "address": "inter-2@corp.com" },
+      "text": "But it is quite normal!",
+      "flags": ["method:crisp", "trust:medium_inline"]
+    },
+    {
+      "depth": 0,
+      "from": { "address": "boss@corp.com" },
+      "text": "Check the bottom of this long thread.",
+      "flags": ["trust:high_mime", "level:root"]
+    }
+  ],
+  "diagnostics": {
+    "method": "inline",
+    "depth": 4,
+    "parsedOk": true,
+    "warnings": []
+  }
+}
+```
+
+### 4. International Support (e.g., French)
+The library automatically handles international headers like "De:", "Objet:", "Message transféré".
+
+```typescript
+const frenchEmail = `
+---------- Message transféré ---------
+De : Expert Auto <expert@assurance.fr>
+Date : lun. 10 févr. 2025 à 11:39
+Objet : Dossier #12345
+
+Hello, here is your expertise report.`;
+
+const result = await extractDeepestHybrid(frenchEmail);
+console.log(result.from.name);       // "Expert Auto"
+console.log(result.date_iso);        // "2025-02-10T10:39:00.000Z"
+```
+
+## Extensions & Plugins (Custom Detectors)
+
+The library allows you to inject **custom forward detectors** to handle specific corporate headers, regional formats, or proprietary email barriers that are not covered by the default detectors.
+
+This system is built on **Dependency Injection**, meaning your custom logic lives in your application code, not deeper in `node_modules`.
+
+### How to create a Plugin
+Implement the `ForwardDetector` interface:
+
+```typescript
+import { extractDeepestHybrid, ForwardDetector, DetectionResult } from 'email-deepest-forward';
+
+class MyCustomDetector implements ForwardDetector {
+    // Unique name for your detector (will appear in 'diagnostics.method')
+    name = 'my-custom-detector';
+    
+    // Priority: Lower number = Higher priority.
+    // -100 = Override Everything (Expert Plugins)
+    // -40 to -20 = Specific Build-in Detectors (Outlook, FR, etc.)
+    // 100 = Crisp (Default International Engine)
+    // 150 = Reply (Fallback)
+    priority = -100;
+
+    detect(text: string): DetectionResult {
+        // Example: Detects '--- START FORWARD ---'
+        const marker = '--- START FORWARD ---';
+        const idx = text.indexOf(marker);
+
+        if (idx !== -1) {
+            // Extracted body (text AFTER the marker)
+            const body = text.substring(idx + marker.length).trim();
+            
+            // Text BEFORE the marker (the message from the forwarder)
+            const message = text.substring(0, idx).trim();
+
+            return {
+                found: true,
+                detector: this.name,
+                confidence: 'high',
+                message: message, // Important for history reconstruction
+                email: {
+                    from: { name: 'Detected Sender', address: 'sender@example.com' },
+                    subject: 'Extracted Subject',
+                    date: new Date().toISOString(),
+                    body: body
+                }
+            };
+        }
+        
+        return { found: false, confidence: 'low' };
+    }
+}
+```
+
+### How to use it
+Pass your detector instance in the `options.customDetectors` array:
+
+```typescript
+const result = await extractDeepestHybrid(emailContent, {
+    customDetectors: [ new MyCustomDetector() ]
+});
+
+console.log(result.diagnostics.method); // "method:my-custom-detector"
+```
+
+---
+
+
+### Malformed Inputs
+If you pass a string that isn't an email (e.g., a simple welcome message), the library returns the text but sets `parsedOk` to `false`.
+
+```typescript
+const result = await extractDeepestHybrid("Welcome to our platform!");
+
+console.log(result.from);               // null
+console.log(result.diagnostics.parsedOk); // false
+console.log(result.text);               // "Welcome to our platform!"
+```
+
+### Missing or Unparseable Dates
+If a date cannot be normalized to ISO format, `date_iso` will be `null` and a warning will be added. You can still access the original string via `date_raw`.
+
+```typescript
+const result = await extractDeepestHybrid(emailWithBadDate);
+
+if (!result.date_iso) {
+  console.warn(result.diagnostics.warnings[0]); // "Could not normalize date: ..."
+  console.log("Raw date was:", result.date_raw);
+}
+```
+
+### Non-String Input
+The library strictly requires a string input and will throw an Error otherwise.
+
+```typescript
+try {
+  await extractDeepestHybrid(null as any);
+} catch (e) {
+  console.error(e.message); // "Input must be a string"
+}
+```
+
+## The Expert Cleaner Utility
+
+All built-in detectors use the `Cleaner` utility to ensure consistent text normalization across recursion levels.
+
+### Key Features:
+- **Normalization**: Unifies line breaks (`\r\n` -> `\n`), removes BOM, handles `&nbsp;`.
+- **Memoization**: Cache layer to prevent re-processing the same text multiple times.
+- **Quote Stripping**: Expertly removes `>` prefixes while preserving body structure.
+- **Boundary Detection**: Uses the "Double Newline" rule found in professional parsers.
+
+```typescript
+import { Cleaner } from 'email-deepest-forward/utils/cleaner';
+
+const normalized = Cleaner.normalize(rawText);
+const bodyOnly = Cleaner.extractBody(lines, lastHeaderIndex);
+const quoteFree = Cleaner.stripQuotes(bodyOnly);
+```
+
+## Strategy
+
+1. **MIME Layer**: Recursively descends through `message/rfc822` attachments using `mailparser`.
+2. **Inline Layer**: Iteratively scans the body for forwarded blocks using `email-forward-parser` patterns (supports multi-language).
+3. **Date Normalization**: Uses `any-date-parser` and `luxon` for resilient international date parsing.
+4. **Fallback**: Manual regex extraction if no structured headers are found.
+
+## License
+
+MIT - See [LICENSE](LICENSE) for details.

package/dist/detectors/crisp-detector.d.ts

@@ -0,0 +1,11 @@
+import { ForwardDetector, DetectionResult } from './types';
+/**
+ * Crisp detector - uses the email-forward-parser library
+ * This is the primary detector with highest priority
+ */
+export declare class CrispDetector implements ForwardDetector {
+    readonly name = "crisp";
+    readonly priority = 100;
+    private parser;
+    detect(text: string): DetectionResult;
+}

package/dist/detectors/crisp-detector.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrispDetector = void 0;
+const email_forward_parser_1 = __importDefault(require("email-forward-parser"));
+/**
+ * Crisp detector - uses the email-forward-parser library
+ * This is the primary detector with highest priority
+ */
+class CrispDetector {
+    constructor() {
+        this.name = 'crisp';
+        this.priority = 100; // Fallback - universal library (lower priority than specifics)
+        this.parser = new email_forward_parser_1.default();
+    }
+    detect(text) {
+        const result = this.parser.read(text, undefined);
+        if (!result?.forwarded || !result?.email) {
+            return {
+                found: false,
+                confidence: 'low'
+            };
+        }
+        // Convert Crisp result to our DetectionResult format
+        const from = result.email.from;
+        const fromValue = typeof from === 'string'
+            ? from
+            : from
+                ? { name: from.name || '', address: from.address || '' }
+                : '';
+        return {
+            found: true,
+            email: {
+                from: fromValue,
+                subject: result.email.subject || undefined,
+                date: result.email.date || undefined,
+                body: result.email.body || undefined
+            },
+            message: result.message || undefined,
+            confidence: 'high' // Crisp is very reliable
+        };
+    }
+}
+exports.CrispDetector = CrispDetector;

package/dist/detectors/index.d.ts

@@ -0,0 +1,5 @@
+export { DetectorRegistry } from './registry';
+export { CrispDetector } from './crisp-detector';
+export { OutlookFRDetector } from './outlook-fr-detector';
+export { NewOutlookDetector } from './new-outlook-detector';
+export type { ForwardDetector, DetectionResult } from './types';

package/dist/detectors/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NewOutlookDetector = exports.OutlookFRDetector = exports.CrispDetector = exports.DetectorRegistry = void 0;
+var registry_1 = require("./registry");
+Object.defineProperty(exports, "DetectorRegistry", { enumerable: true, get: function () { return registry_1.DetectorRegistry; } });
+var crisp_detector_1 = require("./crisp-detector");
+Object.defineProperty(exports, "CrispDetector", { enumerable: true, get: function () { return crisp_detector_1.CrispDetector; } });
+var outlook_fr_detector_1 = require("./outlook-fr-detector");
+Object.defineProperty(exports, "OutlookFRDetector", { enumerable: true, get: function () { return outlook_fr_detector_1.OutlookFRDetector; } });
+var new_outlook_detector_1 = require("./new-outlook-detector");
+Object.defineProperty(exports, "NewOutlookDetector", { enumerable: true, get: function () { return new_outlook_detector_1.NewOutlookDetector; } });

package/dist/detectors/new-outlook-detector.d.ts

@@ -0,0 +1,10 @@
+import { ForwardDetector, DetectionResult } from './types';
+/**
+ * Detector for "Plain Header" format (common in New Outlook, Outlook 2013, Mobile clients)
+ * Pattern: Localized headers like From/De/Von, To/À/An, Date/Sent/Envoyé
+ */
+export declare class NewOutlookDetector implements ForwardDetector {
+    readonly name = "new_outlook";
+    readonly priority = -40;
+    detect(text: string): DetectionResult;
+}

package/dist/detectors/new-outlook-detector.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NewOutlookDetector = void 0;
+const cleaner_1 = require("../utils/cleaner");
+/**
+ * Detector for "Plain Header" format (common in New Outlook, Outlook 2013, Mobile clients)
+ * Pattern: Localized headers like From/De/Von, To/À/An, Date/Sent/Envoyé
+ */
+class NewOutlookDetector {
+    constructor() {
+        this.name = 'new_outlook';
+        this.priority = -40; // Specific detector - High Priority (Override)
+    }
+    detect(text) {
+        // 1. Expert Normalization
+        const normalized = cleaner_1.Cleaner.normalize(text);
+        // Define multi-lingual header maps
+        const labels = {
+            from: ['From', 'De', 'Von', 'Da', 'Od', 'Fra', 'Kimden', 'Van', 'Från', 'De ', 'Lähettäjä', 'Feladó', 'От'],
+            date: ['Date', 'Sent', 'Envoyé', 'Gesendet', 'Inviato', 'Enviado', 'Data', 'Sendt', 'Lähetetty', 'Skickat', 'Datum', 'Dátum', 'Päivämäärä', 'Tarih', 'Дата'],
+            subject: ['Subject', 'Objet', 'Betreff', 'Oggetto', 'Assunto', 'Asunto', 'Emne', 'Aihe', 'Ämne', 'Předmět', 'Predmet', 'Tárgy', 'Temat', 'Тема', 'Konu', 'Onderwerp'],
+            to: ['To', 'À', 'A', 'An', 'Para', 'Til', 'Vastaanottaja', 'Till', 'Pro', 'Za', 'Címzett', 'Do', 'Кому', 'Kime', 'Aan']
+        };
+        const lines = normalized.split('\n').map(l => l.trimRight());
+        // Helper to find a header in a set of lines
+        const findHeader = (searchLines, keys) => {
+            for (let i = 0; i < searchLines.length; i++) {
+                const line = searchLines[i];
+                for (const key of keys) {
+                    const regex = new RegExp(`^\\s*[\\*_]*${key}[\\*_]*\\s*:`, 'i');
+                    if (line.match(regex)) {
+                        const colonIndex = line.indexOf(':');
+                        return { index: i, line, key, value: line.substring(colonIndex + 1).trim() };
+                    }
+                }
+            }
+            return null;
+        };
+        // 2. Identification
+        const fromMatch = findHeader(lines, labels.from);
+        if (!fromMatch)
+            return { found: false, confidence: 'low' };
+        const fromIndex = fromMatch.index;
+        // CRITICAL: The window must stop if we hit an empty line (end of headers)
+        let searchWindow = [];
+        const windowLimit = 15;
+        const searchStart = Math.max(0, fromIndex - 2);
+        for (let i = searchStart; i < Math.min(lines.length, fromIndex + windowLimit); i++) {
+            if (i > fromIndex && lines[i].trim() === '')
+                break;
+            searchWindow.push(lines[i]);
+        }
+        const findHeaderInWindow = (keys) => {
+            for (let j = 0; j < searchWindow.length; j++) {
+                const line = searchWindow[j];
+                for (const key of keys) {
+                    const regex = new RegExp(`^\\s*[\\*_]*${key}[\\*_]*\\s*:`, 'i');
+                    if (line.match(regex)) {
+                        const colonIndex = line.indexOf(':');
+                        return { index: searchStart + j, line, key, value: line.substring(colonIndex + 1).trim() };
+                    }
+                }
+            }
+            return null;
+        };
+        const subject = findHeaderInWindow(labels.subject);
+        if (!subject)
+            return { found: false, confidence: 'low' };
+        const date = findHeaderInWindow(labels.date);
+        const to = findHeaderInWindow(labels.to);
+        const fromValue = fromMatch.value;
+        const emailMatch = fromValue.match(/[<\[](?:mailto:)?(.*?)[>\]]/i);
+        const address = emailMatch ? emailMatch[1].trim() : (fromValue.includes('@') ? fromValue : '');
+        const name = fromValue.replace(/[<\[].*?[>\]]/g, '').trim() || address;
+        const subjectIndex = subject.index;
+        const dateIndex = date ? date.index : -1;
+        const toIndex = to ? to.index : -1;
+        const lastHeaderIndex = Math.max(fromIndex, subjectIndex, dateIndex, toIndex);
+        // 3. Expert Body Extraction
+        const bodyContent = cleaner_1.Cleaner.extractBody(lines, lastHeaderIndex);
+        const finalBody = fromMatch.line.startsWith('>') ? cleaner_1.Cleaner.stripQuotes(bodyContent) : bodyContent;
+        // 4. Message (preceding text)
+        let messageEndIndex = fromIndex;
+        if (messageEndIndex > 0) {
+            for (let k = 1; k <= 5; k++) {
+                if (messageEndIndex - k < 0)
+                    break;
+                const prevLine = lines[messageEndIndex - k].trim();
+                if (prevLine.match(/^-{2,}.*-{2,}$/) || prevLine.match(/^_{3,}$/)) {
+                    messageEndIndex = messageEndIndex - k;
+                    break;
+                }
+                if (prevLine === '')
+                    continue;
+                break;
+            }
+        }
+        const message = messageEndIndex > 0 ? lines.slice(0, messageEndIndex).join('\n').trim() : undefined;
+        return {
+            found: true,
+            email: {
+                from: address ? { name: name.replace(/["']/g, ''), address: address } : name,
+                subject: subject.value,
+                date: date ? date.value : undefined,
+                body: finalBody
+            },
+            message: message,
+            confidence: 'medium'
+        };
+    }
+}
+exports.NewOutlookDetector = NewOutlookDetector;

package/dist/detectors/outlook-empty-header-detector.d.ts

@@ -0,0 +1,16 @@
+import { ForwardDetector, DetectionResult } from './types';
+/**
+ * Detector for Outlook forwards where the "Envoyé:" (Sent) header is present but empty.
+ * Example of failing block:
+ * ________________________________
+ * De: Florian M.
+ * Envoyé:
+ * À: Flo M.
+ * Objet: RE: ...
+ */
+export declare class OutlookEmptyHeaderDetector implements ForwardDetector {
+    readonly name = "outlook_empty_header";
+    readonly priority = 50;
+    private readonly HEADER_PATTERN;
+    detect(text: string): DetectionResult;
+}