@dawnlit/outlook-bridge 1.0.0

package/dist/windows/drafts.js

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendAllDrafts = sendAllDrafts;
+exports.listOutlookDrafts = listOutlookDrafts;
+exports.deleteOutlookDrafts = deleteOutlookDrafts;
+// Drafts: which ones belong to an account, and sending, listing or deleting them.
+const run_1 = require("./run");
+const scripts_1 = require("./scripts");
+const json_1 = require("../shared/json");
+/**
+ * Resolve the Drafts folders belonging to one account into `$scan`, and define
+ * `Test-DraftMatches` over them. Emitted into every drafts script so listing,
+ * deleting and sending can never disagree about which drafts are "this account's".
+ * Expects `$target`, `$outlook`, `$ns` and `$account` to already be set.
+ *
+ * Two Drafts folders can hold drafts for one account, so both are scanned:
+ *  - The account's OWN mailbox store Drafts folder (account.DeliveryStore) — where
+ *    a draft composed while that mailbox is selected lands. A draft there with no
+ *    explicit SendUsingAccount still belongs to this account, so null counts.
+ *  - The DEFAULT store's Drafts folder — where the in-app "Create Drafts" flow
+ *    files drafts via $mail.Save() regardless of send-account. Only drafts stamped
+ *    with this account match here; a null SendUsingAccount means the default
+ *    account, not necessarily this one, so it's left alone.
+ * (When those two resolve to the same folder — the account IS the default — it is
+ * scanned once, under the more permissive "own store" rule.)
+ *
+ * Drafts bound to another account never match, so nothing here can reach unrelated
+ * mail. Non-mail items (meeting requests, reports) are ignored.
+ */
+const DRAFTS_SCAN_PS = `
+# Collect the Drafts folders to scan, deduped by id. includeNull marks the account's
+# own store, where a draft with no explicit send-account still belongs to it.
+$scan = @()
+$seen = @{}
+
+$homeDrafts = $null
+try { $homeDrafts = $account.DeliveryStore.GetDefaultFolder(16) } catch {}  # olFolderDrafts
+if ($homeDrafts -ne $null) {
+    $seen["$($homeDrafts.StoreID)|$($homeDrafts.EntryID)"] = $true
+    $scan += [pscustomobject]@{ folder = $homeDrafts; includeNull = $true }
+}
+
+$defDrafts = $null
+try { $defDrafts = $ns.GetDefaultFolder(16) } catch {}
+if ($defDrafts -ne $null) {
+    $k = "$($defDrafts.StoreID)|$($defDrafts.EntryID)"
+    if (-not $seen.ContainsKey($k)) {
+        $seen[$k] = $true
+        $scan += [pscustomobject]@{ folder = $defDrafts; includeNull = $false }
+    }
+}
+
+# SendUsingAccount is null for a draft that never set one, so guard the access.
+function Test-DraftMatches($item, $includeNull) {
+    if ($item.Class -ne 43) { return $false }  # olMail only
+    $acct = $null
+    try { $acct = $item.SendUsingAccount } catch {}
+    if ($acct -eq $null) { return $includeNull }
+    return ($acct.SmtpAddress -ieq $target)
+}
+`;
+/** Session, account and the drafts scan rule — the prelude all three share. */
+function draftsScript(emailAccount) {
+    return (0, scripts_1.accountScript)(emailAccount) + DRAFTS_SCAN_PS;
+}
+/**
+ * Send the mail drafts that belong to `emailAccount`, wherever Outlook filed them.
+ * Which drafts those are is DRAFTS_SCAN_PS's rule, not this function's.
+ *
+ * Item references are snapshotted before any Send() call: sending moves an item out
+ * of Drafts, and mutating the collection mid-enumeration would skip every other one.
+ */
+async function sendAllDrafts(emailAccount) {
+    (0, run_1.requireWindows)();
+    const script = `${draftsScript(emailAccount)}
+# Snapshot the matching mail items first — Send() removes each from Drafts, so
+# sending inside a live enumeration would skip every other item.
+$items = @()
+foreach ($entry in $scan) {
+    foreach ($it in $entry.folder.Items) {
+        if (Test-DraftMatches $it $entry.includeNull) { $items += $it }
+    }
+}
+
+$sent = 0
+$failed = @()
+foreach ($m in $items) {
+    try {
+        $m.Send()
+        $sent++
+    } catch {
+        $subj = ''
+        try { $subj = $m.Subject } catch {}
+        $failed += [pscustomobject]@{ subject = $subj; error = $_.Exception.Message }
+    }
+}
+
+[pscustomobject]@{ sent = $sent; failed = @($failed) } | ConvertTo-Json -Compress -Depth 4
+`;
+    try {
+        const parsed = (0, json_1.parseObject)(await (0, run_1.runPowerShell)(script, 300000));
+        return {
+            sent: (0, json_1.num)(parsed.sent),
+            failed: (0, json_1.toArray)(parsed.failed).map(f => {
+                const e = (0, json_1.record)(f);
+                return { subject: (0, json_1.str)(e.subject), error: (0, json_1.str)(e.error) };
+            }),
+        };
+    }
+    catch (error) {
+        // A malformed report is not worth failing a send that already happened;
+        // a run that never got that far has already rejected above.
+        if (error instanceof SyntaxError)
+            return { sent: 0, failed: [] };
+        throw error;
+    }
+}
+/**
+ * List the mail drafts belonging to `emailAccount`, newest first. Which drafts
+ * those are is DRAFTS_SCAN_PS's rule.
+ *
+ * Deliberately returns no StoreID: deleteOutlookDrafts re-resolves each EntryID
+ * against the same folders, so repeating a ~700-char store id on every row would be
+ * pure payload. Bodies are previewed, never returned whole — a templated reply body
+ * runs to tens of thousands of characters and a folder's worth would blow the cap.
+ */
+async function listOutlookDrafts(emailAccount, limit = 100, previewChars = 300) {
+    (0, run_1.requireWindows)();
+    const script = `${draftsScript(emailAccount)}
+$previewChars = ${previewChars}
+$rows = @()
+$folders = @()
+foreach ($entry in $scan) {
+    $fp = ''
+    try { $fp = $entry.folder.FolderPath } catch {}
+    $folders += $fp
+    foreach ($it in $entry.folder.Items) {
+        if (-not (Test-DraftMatches $it $entry.includeNull)) { continue }
+        $subj = ''; try { $subj = $it.Subject } catch {}
+        $to = ''; try { $to = $it.To } catch {}
+        $addrs = @()
+        try {
+            foreach ($r in $it.Recipients) {
+                $a = ''
+                try { $a = $r.Address } catch {}
+                if ($a -and $a.StartsWith('/')) { try { $a = $r.Name } catch {} }
+                if ($a) { $addrs += $a }
+            }
+        } catch {}
+        $body = ''
+        try { $body = $it.Body } catch {}
+        if ($body -eq $null) { $body = '' }
+        $body = ($body -replace '\\s+', ' ').Trim()
+        if ($body.Length -gt $previewChars) { $body = $body.Substring(0, $previewChars) }
+        $mod = ''
+        try { $mod = $it.LastModificationTime.ToString('yyyy-MM-dd HH:mm') } catch {}
+        $att = $false
+        try { $att = ($it.Attachments.Count -gt 0) } catch {}
+        $rows += [pscustomobject]@{
+            entryId = $it.EntryID
+            subject = $subj
+            to = $to
+            toEmails = @($addrs)
+            bodyPreview = $body
+            hasAttachments = $att
+            lastModified = $mod
+            folderPath = $fp
+        }
+    }
+}
+$sorted = @($rows | Sort-Object -Property lastModified -Descending)
+$total = $sorted.Count
+if ($total -gt ${limit}) { $sorted = @($sorted[0..(${limit} - 1)]) }
+ConvertTo-Json @{ account = $target; foldersScanned = @($folders); count = $total; truncated = ($total -gt ${limit}); drafts = @($sorted) } -Depth 4
+`;
+    const parsed = (0, json_1.parseObject)(await (0, run_1.runPowerShell)(script, 300000));
+    return {
+        account: (0, json_1.str)(parsed.account) || emailAccount,
+        foldersScanned: (0, json_1.toArray)(parsed.foldersScanned).map(json_1.str),
+        count: (0, json_1.num)(parsed.count),
+        truncated: Boolean(parsed.truncated),
+        drafts: (0, json_1.toArray)(parsed.drafts).map(d => {
+            const e = (0, json_1.record)(d);
+            return {
+                entryId: (0, json_1.str)(e.entryId),
+                subject: (0, json_1.str)(e.subject),
+                to: (0, json_1.str)(e.to),
+                toEmails: (0, json_1.strList)(e.toEmails),
+                bodyPreview: (0, json_1.str)(e.bodyPreview),
+                hasAttachments: Boolean(e.hasAttachments),
+                lastModified: (0, json_1.str)(e.lastModified),
+                folderPath: (0, json_1.str)(e.folderPath),
+            };
+        }),
+    };
+}
+/**
+ * Delete mail drafts by EntryID. Outlook's Delete() moves the item to Deleted Items
+ * rather than destroying it, so a mistaken call stays recoverable from there.
+ *
+ * Every id must resolve to a mail item sitting in one of THIS account's Drafts
+ * folders before anything is deleted; an id pointing at ordinary mail, or at another
+ * account's draft, is refused and reported. Without that gate this would be a
+ * general-purpose "delete any email by id" tool, which is not what it is for.
+ */
+async function deleteOutlookDrafts(emailAccount, entryIds) {
+    (0, run_1.requireWindows)();
+    if (entryIds.length === 0)
+        return { deleted: 0, failed: [] };
+    const script = `${draftsScript(emailAccount)}
+# Index this account's Drafts folders by EntryID, so a resolved item can be PROVED
+# to live in one of them before it is deleted.
+$draftFolderIds = @{}
+foreach ($entry in $scan) { $draftFolderIds[$entry.folder.EntryID] = $entry.includeNull }
+
+$deleted = 0
+$failed = @()
+foreach ($id in @(${(0, run_1.psList)(entryIds)})) {
+    try {
+        $it = $null
+        foreach ($entry in $scan) {
+            try {
+                $it = $ns.GetItemFromID($id, $entry.folder.StoreID)
+                if ($it -ne $null) { break }
+            } catch { $it = $null }
+        }
+        if ($it -eq $null) { throw "no such item in this account's Drafts folders" }
+        $parentId = ''
+        try { $parentId = $it.Parent.EntryID } catch {}
+        if (-not $draftFolderIds.ContainsKey($parentId)) {
+            throw "item is not in this account's Drafts folder - refusing to delete"
+        }
+        if (-not (Test-DraftMatches $it $draftFolderIds[$parentId])) {
+            throw "draft is not bound to $target - refusing to delete"
+        }
+        $it.Delete()
+        $deleted++
+    } catch {
+        $failed += [pscustomobject]@{ entryId = $id; error = $_.Exception.Message }
+    }
+}
+ConvertTo-Json @{ deleted = $deleted; failed = @($failed) } -Depth 3
+`;
+    const parsed = (0, json_1.parseObject)(await (0, run_1.runPowerShell)(script, 300000));
+    return {
+        deleted: (0, json_1.num)(parsed.deleted),
+        failed: (0, json_1.toArray)(parsed.failed).map(f => {
+            const e = (0, json_1.record)(f);
+            return { entryId: (0, json_1.str)(e.entryId), error: (0, json_1.str)(e.error) };
+        }),
+    };
+}
+//# sourceMappingURL=drafts.js.map

package/dist/windows/drafts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"drafts.js","sourceRoot":"","sources":["../../src/windows/drafts.ts"],"names":[],"mappings":"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"}

package/dist/windows/folders.d.ts

@@ -0,0 +1,16 @@
+import type { InboxFolderInfo, MoveEmailsResult } from '../types';
+/** List the folders under an account's Inbox (the user's filing folders). */
+export declare function listInboxFolders(emailAccount: string, maxDepth?: number): Promise<InboxFolderInfo[]>;
+/**
+ * Move emails (by EntryID) into any folder of the account — a filing folder under
+ * the Inbox, or a well-known folder by name (see WELL_KNOWN_FOLDERS).
+ *
+ * **Moving to "Deleted Items" is how mail gets deleted reversibly**, which is why
+ * this takes well-known roots at all: it means the destructive path and the filing
+ * path are one tool, and the destructive one is undoable from the folder it lands in.
+ *
+ * `createIfMissing` builds the WHOLE missing chain, so a nested destination
+ * ("Clients\\Acme\\2026") is one call rather than a manual mkdir first.
+ * NOTE: moving changes an item's EntryID — the passed ids are dead afterwards.
+ */
+export declare function moveOutlookEmails(emailAccount: string, entryIds: string[], folderName: string, createIfMissing?: boolean): Promise<MoveEmailsResult>;

package/dist/windows/folders.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listInboxFolders = listInboxFolders;
+exports.moveOutlookEmails = moveOutlookEmails;
+// Listing the folders under an Inbox, and filing mail into one.
+const run_1 = require("./run");
+const scripts_1 = require("./scripts");
+const json_1 = require("../shared/json");
+const mail_1 = require("../mail");
+/** List the folders under an account's Inbox (the user's filing folders). */
+async function listInboxFolders(emailAccount, maxDepth = 2) {
+    if (process.platform !== 'win32')
+        return [];
+    const depth = (0, mail_1.clamp)(maxDepth, 1, 4);
+    const script = `${(0, scripts_1.accountScript)(emailAccount)}
+$inbox = $account.DeliveryStore.GetDefaultFolder(6)
+function Walk-Folders($folder, $level) {
+    foreach ($f in $folder.Folders) {
+        [PSCustomObject]@{
+            name       = $f.Name
+            folderPath = $f.FolderPath
+            itemCount  = $f.Items.Count
+            depth      = $level
+        }
+        if ($level -lt ${depth}) { Walk-Folders $f ($level + 1) }
+    }
+}
+$results = @(Walk-Folders $inbox 1)
+ConvertTo-Json $results -Depth 3
+`;
+    return (0, json_1.parseArray)(await (0, run_1.runPowerShell)(script, 60000)).map(item => {
+        const e = (0, json_1.record)(item);
+        return {
+            name: (0, json_1.str)(e.name),
+            folderPath: (0, json_1.str)(e.folderPath),
+            itemCount: (0, json_1.num)(e.itemCount),
+            depth: (0, json_1.num)(e.depth) || 1,
+        };
+    });
+}
+/**
+ * Move emails (by EntryID) into any folder of the account — a filing folder under
+ * the Inbox, or a well-known folder by name (see WELL_KNOWN_FOLDERS).
+ *
+ * **Moving to "Deleted Items" is how mail gets deleted reversibly**, which is why
+ * this takes well-known roots at all: it means the destructive path and the filing
+ * path are one tool, and the destructive one is undoable from the folder it lands in.
+ *
+ * `createIfMissing` builds the WHOLE missing chain, so a nested destination
+ * ("Clients\\Acme\\2026") is one call rather than a manual mkdir first.
+ * NOTE: moving changes an item's EntryID — the passed ids are dead afterwards.
+ */
+async function moveOutlookEmails(emailAccount, entryIds, folderName, createIfMissing = false) {
+    (0, run_1.requireWindows)();
+    if (entryIds.length === 0) {
+        return { folderPath: '', folderCreated: false, moved: 0, failed: [] };
+    }
+    const ref = (0, mail_1.mailFolderRef)(folderName);
+    const script = `${(0, scripts_1.accountScript)(emailAccount)}
+${scripts_1.DELIVERY_STORE_PS}
+${(0, scripts_1.mailScopeScript)(ref, folderName, createIfMissing)}
+$folder = $scope
+$folderCreated = $scopeCreated
+$moved = 0
+$failed = @()
+foreach ($id in @(${(0, run_1.psList)(entryIds)})) {
+    try {
+        $it = $ns.GetItemFromID($id, $store.StoreID)
+        [void]$it.Move($folder)
+        $moved++
+    } catch {
+        $failed += [PSCustomObject]@{ entryId = $id; error = $_.Exception.Message }
+    }
+}
+ConvertTo-Json @{ folderPath = $folder.FolderPath; folderCreated = $folderCreated; moved = $moved; failed = @($failed) } -Depth 3
+`;
+    const parsed = (0, json_1.parseObject)(await (0, run_1.runPowerShell)(script, 300000));
+    return {
+        folderPath: (0, json_1.str)(parsed.folderPath),
+        folderCreated: Boolean(parsed.folderCreated),
+        moved: (0, json_1.num)(parsed.moved),
+        failed: (0, json_1.toArray)(parsed.failed).map(f => {
+            const e = (0, json_1.record)(f);
+            return { entryId: (0, json_1.str)(e.entryId), error: (0, json_1.str)(e.error) };
+        }),
+    };
+}
+//# sourceMappingURL=folders.js.map

package/dist/windows/folders.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"folders.js","sourceRoot":"","sources":["../../src/windows/folders.ts"],"names":[],"mappings":";;AAQA,4CA+BC;AAcD,8CAuCC;AA5FD,gEAAgE;AAChE,+BAA8D;AAC9D,uCAA8E;AAC9E,yCAAoF;AACpF,kCAA+C;AAG/C,6EAA6E;AACtE,KAAK,UAAU,gBAAgB,CAClC,YAAoB,EACpB,QAAQ,GAAG,CAAC;IAEZ,IAAI,OAAO,CAAC,QAAQ,KAAK,OAAO;QAAE,OAAO,EAAE,CAAC;IAC5C,MAAM,KAAK,GAAG,IAAA,YAAK,EAAC,QAAQ,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IACpC,MAAM,MAAM,GAAG,GAAG,IAAA,uBAAa,EAAC,YAAY,CAAC;;;;;;;;;;yBAUxB,KAAK;;;;;CAK7B,CAAC;IACE,OAAO,IAAA,iBAAU,EAAC,MAAM,IAAA,mBAAa,EAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;QAC7D,MAAM,CAAC,GAAG,IAAA,aAAM,EAAC,IAAI,CAAC,CAAC;QACvB,OAAO;YACH,IAAI,EAAE,IAAA,UAAG,EAAC,CAAC,CAAC,IAAI,CAAC;YACjB,UAAU,EAAE,IAAA,UAAG,EAAC,CAAC,CAAC,UAAU,CAAC;YAC7B,SAAS,EAAE,IAAA,UAAG,EAAC,CAAC,CAAC,SAAS,CAAC;YAC3B,KAAK,EAAE,IAAA,UAAG,EAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC;SAC3B,CAAC;IACN,CAAC,CAAC,CAAC;AACP,CAAC;AAED;;;;;;;;;;;GAWG;AACI,KAAK,UAAU,iBAAiB,CACnC,YAAoB,EACpB,QAAkB,EAClB,UAAkB,EAClB,eAAe,GAAG,KAAK;IAEvB,IAAA,oBAAc,GAAE,CAAC;IACjB,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACxB,OAAO,EAAE,UAAU,EAAE,EAAE,EAAE,aAAa,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;IAC1E,CAAC;IACD,MAAM,GAAG,GAAG,IAAA,oBAAa,EAAC,UAAU,CAAC,CAAC;IACtC,MAAM,MAAM,GAAG,GAAG,IAAA,uBAAa,EAAC,YAAY,CAAC;EAC/C,2BAAiB;EACjB,IAAA,yBAAe,EAAC,GAAG,EAAE,UAAU,EAAE,eAAe,CAAC;;;;;oBAK/B,IAAA,YAAM,EAAC,QAAQ,CAAC;;;;;;;;;;CAUnC,CAAC;IACE,MAAM,MAAM,GAAG,IAAA,kBAAW,EAAC,MAAM,IAAA,mBAAa,EAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAChE,OAAO;QACH,UAAU,EAAE,IAAA,UAAG,EAAC,MAAM,CAAC,UAAU,CAAC;QAClC,aAAa,EAAE,OAAO,CAAC,MAAM,CAAC,aAAa,CAAC;QAC5C,KAAK,EAAE,IAAA,UAAG,EAAC,MAAM,CAAC,KAAK,CAAC;QACxB,MAAM,EAAE,IAAA,cAAO,EAAC,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE;YACnC,MAAM,CAAC,GAAG,IAAA,aAAM,EAAC,CAAC,CAAC,CAAC;YACpB,OAAO,EAAE,OAAO,EAAE,IAAA,UAAG,EAAC,CAAC,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,IAAA,UAAG,EAAC,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC;QAC5D,CAAC,CAAC;KACL,CAAC;AACN,CAAC"}

package/dist/windows/index.d.ts

@@ -0,0 +1,27 @@
+import type { CapabilityMap, OutlookBridge } from '../types';
+/**
+ * The whole contract in one object — and the compile-time proof that this
+ * module answers all of it.
+ *
+ * Typed as `OutlookBridge` rather than inferred: without that a signature could
+ * drift from the macOS one and only surface as a union in the published .d.ts,
+ * which is exactly how it drifted before.
+ */
+declare const bridge: OutlookBridge;
+export { bridge };
+export * from './accounts';
+export * from './send';
+export * from './drafts';
+export * from './read';
+export * from './folders';
+export * from './cleanup';
+export * from './bounces';
+export * from './attachments';
+export * from './signatures';
+export * from './templates';
+export { mailScopeScript } from './scripts';
+/**
+ * Windows drives the full COM object model, so every operation is available —
+ * this is the reference the macOS map is measured against.
+ */
+export declare const capabilities: CapabilityMap;

package/dist/windows/index.js

@@ -0,0 +1,100 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.capabilities = exports.mailScopeScript = exports.bridge = void 0;
+// The Windows implementation: Outlook driven through PowerShell + COM.
+//
+// Split by feature rather than kept as one file — every operation here is
+// "generate a script, run it, coerce the result", and the interesting part of
+// each is the script, which is only readable next to the rules it encodes.
+// `scripts.ts` holds the fragments more than one feature emits; `run.ts` owns
+// the run itself and the escaping.
+//
+// This is the reference implementation: everything in the platform contract
+// works here, which is what the macOS capability map is measured against.
+const accounts_1 = require("./accounts");
+const send_1 = require("./send");
+const drafts_1 = require("./drafts");
+const read_1 = require("./read");
+const folders_1 = require("./folders");
+const cleanup_1 = require("./cleanup");
+const bounces_1 = require("./bounces");
+const attachments_1 = require("./attachments");
+const signatures_1 = require("./signatures");
+const templates_1 = require("./templates");
+const capabilities_1 = require("../shared/capabilities");
+/**
+ * The whole contract in one object — and the compile-time proof that this
+ * module answers all of it.
+ *
+ * Typed as `OutlookBridge` rather than inferred: without that a signature could
+ * drift from the macOS one and only surface as a union in the published .d.ts,
+ * which is exactly how it drifted before.
+ */
+const bridge = {
+    getOutlookAccounts: accounts_1.getOutlookAccounts,
+    sendOutlookEmail: send_1.sendOutlookEmail,
+    replyOutlookEmail: send_1.replyOutlookEmail,
+    sendAllDrafts: drafts_1.sendAllDrafts,
+    readInboxEmails: read_1.readInboxEmails,
+    searchInboxByFilter: read_1.searchInboxByFilter,
+    readSelectedEmail: read_1.readSelectedEmail,
+    readEmailBody: read_1.readEmailBody,
+    openOutlookEmail: read_1.openOutlookEmail,
+    listInboxFolders: folders_1.listInboxFolders,
+    moveOutlookEmails: folders_1.moveOutlookEmails,
+    listOutlookDrafts: drafts_1.listOutlookDrafts,
+    deleteOutlookDrafts: drafts_1.deleteOutlookDrafts,
+    deleteOutlookEmails: cleanup_1.deleteOutlookEmails,
+    purgeDeletedItems: cleanup_1.purgeDeletedItems,
+    saveEmailAttachment: attachments_1.saveEmailAttachment,
+    saveEmailAttachmentDetailed: attachments_1.saveEmailAttachmentDetailed,
+    saveEmailAttachments: attachments_1.saveEmailAttachments,
+    cleanUndeliverableEmails: bounces_1.cleanUndeliverableEmails,
+    collectBouncedRecipients: bounces_1.collectBouncedRecipients,
+    readSentRecipientGroups: bounces_1.readSentRecipientGroups,
+    listOutlookSignatures: signatures_1.listOutlookSignatures,
+    readOutlookSignatureHtml: signatures_1.readOutlookSignatureHtml,
+    readTemplateEmails: templates_1.readTemplateEmails,
+    saveTemplateEmail: templates_1.saveTemplateEmail,
+    editEmailTemplate: templates_1.editEmailTemplate,
+};
+exports.bridge = bridge;
+// Re-exported one module at a time rather than by name: every feature module
+// here exports exactly its bridge functions and nothing else, so the name list
+// this replaces was a copy of the `bridge` literal above with no way to drift
+// from it usefully.
+__exportStar(require("./accounts"), exports);
+__exportStar(require("./send"), exports);
+__exportStar(require("./drafts"), exports);
+__exportStar(require("./read"), exports);
+__exportStar(require("./folders"), exports);
+__exportStar(require("./cleanup"), exports);
+__exportStar(require("./bounces"), exports);
+__exportStar(require("./attachments"), exports);
+__exportStar(require("./signatures"), exports);
+__exportStar(require("./templates"), exports);
+// The folder-scope emitter, exported so the generated script can be checked
+// without an Outlook session — a syntax error in it would otherwise only ever
+// surface as a failed live run.
+var scripts_1 = require("./scripts");
+Object.defineProperty(exports, "mailScopeScript", { enumerable: true, get: function () { return scripts_1.mailScopeScript; } });
+/**
+ * Windows drives the full COM object model, so every operation is available —
+ * this is the reference the macOS map is measured against.
+ */
+exports.capabilities = (0, capabilities_1.capabilityMap)(bridge);
+//# sourceMappingURL=index.js.map

package/dist/windows/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/windows/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,uEAAuE;AACvE,EAAE;AACF,0EAA0E;AAC1E,8EAA8E;AAC9E,2EAA2E;AAC3E,8EAA8E;AAC9E,mCAAmC;AACnC,EAAE;AACF,4EAA4E;AAC5E,0EAA0E;AAC1E,yCAAgD;AAChD,iCAA6D;AAC7D,qCAAiF;AACjF,iCAAmH;AACnH,uCAAgE;AAChE,uCAAmE;AACnE,uCAAyG;AACzG,+CAAwG;AACxG,6CAA+E;AAC/E,2CAAuF;AACvF,yDAAuD;AAGvD;;;;;;;GAOG;AACH,MAAM,MAAM,GAAkB;IAC1B,kBAAkB,EAAlB,6BAAkB;IAClB,gBAAgB,EAAhB,uBAAgB;IAChB,iBAAiB,EAAjB,wBAAiB;IACjB,aAAa,EAAb,sBAAa;IACb,eAAe,EAAf,sBAAe;IACf,mBAAmB,EAAnB,0BAAmB;IACnB,iBAAiB,EAAjB,wBAAiB;IACjB,aAAa,EAAb,oBAAa;IACb,gBAAgB,EAAhB,uBAAgB;IAChB,gBAAgB,EAAhB,0BAAgB;IAChB,iBAAiB,EAAjB,2BAAiB;IACjB,iBAAiB,EAAjB,0BAAiB;IACjB,mBAAmB,EAAnB,4BAAmB;IACnB,mBAAmB,EAAnB,6BAAmB;IACnB,iBAAiB,EAAjB,2BAAiB;IACjB,mBAAmB,EAAnB,iCAAmB;IACnB,2BAA2B,EAA3B,yCAA2B;IAC3B,oBAAoB,EAApB,kCAAoB;IACpB,wBAAwB,EAAxB,kCAAwB;IACxB,wBAAwB,EAAxB,kCAAwB;IACxB,uBAAuB,EAAvB,iCAAuB;IACvB,qBAAqB,EAArB,kCAAqB;IACrB,wBAAwB,EAAxB,qCAAwB;IACxB,kBAAkB,EAAlB,8BAAkB;IAClB,iBAAiB,EAAjB,6BAAiB;IACjB,iBAAiB,EAAjB,6BAAiB;CACpB,CAAC;AAEO,wBAAM;AAEf,6EAA6E;AAC7E,+EAA+E;AAC/E,8EAA8E;AAC9E,oBAAoB;AACpB,6CAA2B;AAC3B,yCAAuB;AACvB,2CAAyB;AACzB,yCAAuB;AACvB,4CAA0B;AAC1B,4CAA0B;AAC1B,4CAA0B;AAC1B,gDAA8B;AAC9B,+CAA6B;AAC7B,8CAA4B;AAE5B,4EAA4E;AAC5E,8EAA8E;AAC9E,gCAAgC;AAChC,qCAA4C;AAAnC,0GAAA,eAAe,OAAA;AAExB;;;GAGG;AACU,QAAA,YAAY,GAAkB,IAAA,4BAAa,EAAC,MAAM,CAAC,CAAC"}

package/dist/windows/read.d.ts

@@ -0,0 +1,54 @@
+import type { EmailBodyResult, InboxEmail, InboxSearchFilter, InboxSearchMatch, SelectedEmail } from '../types';
+/**
+ * Read recent emails from the Outlook inbox for the given account.
+ * No subject filtering — returns everything within the date window, up to the limit.
+ * Does NOT download attachments; returns attachment names only.
+ *
+ * `folder` scopes the read to one folder under the Inbox instead of the Inbox
+ * root. Without it, mail already filed away (Inbox\\Invoices) is unreachable —
+ * which is the normal state of any mailbox its owner keeps tidy. Segments are
+ * matched as direct children; a bare name that isn't a direct child falls back to
+ * the same recursive by-name search moveOutlookEmails uses, so one folder string
+ * works in both. Only the named folder is read — its own subfolders are not.
+ */
+export declare function readInboxEmails(emailAccount: string, daysBack?: number, limit?: number, folder?: string): Promise<InboxEmail[]>;
+/**
+ * Read one email's full plain-text body by EntryID.
+ *
+ * Uses `MailItem.Body`, not `HTMLBody`: Outlook's own plain-text rendering is
+ * what every other reader here consumes, and the markup costs an order of
+ * magnitude more for the same sentences. The tradeoff is that HTML tables
+ * flatten, so figures broken out in a table lose their row/column pairing — read
+ * those from the attachment where there is one.
+ *
+ * Exists because `readInboxEmails` caps its preview at 600 chars, and a reply
+ * whose first 600 chars read as complete can still carry a material detail below
+ * the cut. Nothing detects that from the preview alone.
+ *
+ * `includeQuoted` is off by default — see splitQuotedOriginal for why the
+ * quoted thread is a hazard to a caller reading figures out of a reply.
+ * `quotedLength` is reported either way so a caller can tell it exists and ask again.
+ */
+export declare function readEmailBody(entryId: string, storeId?: string, maxChars?: number, includeQuoted?: boolean): Promise<EmailBodyResult>;
+/**
+ * Walk every folder under the Inbox (recursively) for one account and return
+ * the emails matching `filter` — full body included, attachments listed by
+ * name but not saved.
+ *
+ * Built for a scan that doesn't know in advance which subfolder holds what
+ * it's after; `readInboxEmails` covers the cheaper "one known folder" case.
+ *
+ * `daysBack` bounds the scan to items received within that many days — what a
+ * daily batch run wants, since a subject filter alone walks the whole Inbox
+ * tree and returns every match ever received. 0 keeps that unbounded
+ * behavior, and is only sane paired with `filter.subjectLike` so Restrict can
+ * narrow the set server-side before anything crosses COM.
+ */
+export declare function searchInboxByFilter(emailAccount: string, filter?: InboxSearchFilter, daysBack?: number): Promise<InboxSearchMatch[]>;
+/**
+ * Read the email currently selected (or open) in Outlook — full body,
+ * attachments listed by name but not saved.
+ */
+export declare function readSelectedEmail(): Promise<SelectedEmail>;
+/** Open an email in Outlook by its EntryID. */
+export declare function openOutlookEmail(entryId: string): Promise<void>;