@dawnlit/outlook-bridge 1.1.1 → 2.1.0

package/dist/windows/read.js

@@ -13,291 +13,270 @@ const json_1 = require("../shared/json");
 const mail_1 = require("../mail");
 const errors_1 = require("../errors");
 /**
- * An arbitrary email body crosses the PowerShell boundary base64'd: it carries
- * quotes, control characters and non-ASCII that would otherwise have to survive
- * both the console codepage and JSON string escaping intact.
+ * The COM property carrying each kind of folder's timestamp. Sent Items and
+ * Drafts have no ReceivedTime, and filtering them on it returns an empty set
+ * that looks exactly like an empty folder.
  */
-function decodeBody(value) {
-    return Buffer.from((0, json_1.str)(value), 'base64').toString('utf8');
+function dateProperty(rootId) {
+    if (rootId === mail_1.FolderId.Drafts)
+        return 'LastModificationTime';
+    return (0, mail_1.isOutgoingRoot)(rootId) ? 'SentOn' : 'ReceivedTime';
 }
-// Outgoing roots keep their timestamp under a different COM property; anything
-// else carries ReceivedTime.
-const OUTGOING_DATE_PROPS = {
-    [mail_1.WELL_KNOWN_FOLDERS['sent items']]: 'SentOn',
-    [mail_1.WELL_KNOWN_FOLDERS.outbox]: 'SentOn',
-    [mail_1.WELL_KNOWN_FOLDERS.drafts]: 'LastModificationTime',
-};
 /**
- * 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.
+ * Bodies cross the PowerShell boundary base64-encoded: they carry quotes,
+ * control characters and non-ASCII that would otherwise have to survive JSON
+ * escaping in two languages intact.
  */
-async function readInboxEmails(emailAccount, daysBack = 60, limit = 50, folder) {
-    if (process.platform !== 'win32')
-        return [];
-    const ref = folder ? (0, mail_1.mailFolderRef)(folder) : { rootId: 6, rootLabel: 'Inbox', segments: [] };
-    // A folder argument that trims away to nothing ("\\", "  ") would otherwise
-    // read the Inbox root and look like it had scoped — the exact silent
-    // mis-scoping this parameter exists to prevent. A bare well-known name
-    // ("Sent Items") legitimately has no segments, so it is not that case.
-    if (folder && folder.trim() && ref.segments.length === 0 && ref.rootId === 6
-        && !Object.prototype.hasOwnProperty.call(mail_1.WELL_KNOWN_FOLDERS, folder.trim().toLowerCase())) {
-        throw new errors_1.NotFoundError('folder', `Folder '${folder}' does not name a folder under the Inbox.`);
-    }
-    // Which timestamp the folder's items actually carry (see the note in the script).
-    const dateProp = OUTGOING_DATE_PROPS[ref.rootId] ?? 'ReceivedTime';
-    const isOutgoing = (0, run_1.psBool)((0, mail_1.isOutgoingRoot)(ref.rootId));
-    const script = `${(0, scripts_1.accountScript)(emailAccount)}
-${(0, scripts_1.namedStoreScript)(emailAccount)}
-${(0, scripts_1.mailScopeScript)(ref, folder || '')}
-$scopePath = $scope.FolderPath
-$cutoff = (Get-Date).AddDays(-${daysBack}).ToString('MM/dd/yyyy HH:mm')
-# Sent Items and Drafts carry no ReceivedTime, so restricting on it there returns
-# an empty set that looks exactly like an empty folder. Filter each on the date
-# property it actually has.
-$filtered = $scope.Items.Restrict("[${dateProp}] >= '$cutoff'")
+const BODY_B64_PS = `[Convert]::ToBase64String([System.Text.Encoding]::UTF8.GetBytes([string]$bodyRaw))`;
+/** Recent mail from the Inbox root or one folder, newest first. */
+async function readInboxEmails(request) {
+    const dateProp = dateProperty(request.folder.rootId);
+    const outgoing = (0, mail_1.isOutgoingRoot)(request.folder.rootId);
+    const output = await (0, run_1.runPowerShellJson)(`${(0, scripts_1.accountScript)(request.account)}
+${scripts_1.NAMED_STORE_PS}
+${(0, scripts_1.mailScopeScript)(request.folder, request.folderLabel)}
+$scopePath = [string]$scope.FolderPath
+${(0, scripts_1.cutoffScript)(request.daysBack)}
+${(0, scripts_1.itemsSinceScript)('scope', dateProp)}
 $filtered.Sort('[${dateProp}]', $true)
-$results = @()
-$cap = [Math]::Min($filtered.Count, ${limit})
-for ($i = 1; $i -le $cap; $i++) {
-    $item = $filtered.Item($i)
-    $subj = if ($item.Subject) { $item.Subject.Trim() } else { '' }
-    $bodyText = if ($item.Body) { $item.Body } else { '' }
-    $bodyPreview = if ($bodyText.Length -gt 600) { $bodyText.Substring(0, 600) } else { $bodyText }
-    $attNames = @()
-    foreach ($att in $item.Attachments) { $attNames += $att.FileName }
-    $stamp = ''
-    try { $stamp = $item.${dateProp}.ToString('yyyy-MM-dd HH:mm') } catch {}
-    # Outgoing mail has no meaningful sender line of its own — report who it is TO,
-    # or a Sent Items listing reads as a folder of mail from yourself.
+$limit = ${(0, run_1.psInt)(request.limit)}
+$previewChars = ${(0, run_1.psInt)(request.previewChars)}
+$rows = @()
+$count = $filtered.Count
+for ($i = 1; $i -le $count -and $rows.Count -lt $limit; $i++) {
+    $item = $null
+    try { $item = $filtered.Item($i) } catch {}
+    if ($item -eq $null) { continue }
+    $stamp = $null
+    try { $stamp = $item.${dateProp} } catch {}
+    # Sorted newest first, so the first item older than the window ends it.
+    if ($stamp -ne $null -and $stamp -lt $cutoff) { break }
+    $preview = ''
+    if ($previewChars -gt 0) {
+        $bodyText = ''
+        try { $bodyText = [string]$item.Body } catch {}
+        $preview = if ($bodyText.Length -gt $previewChars) { $bodyText.Substring(0, $previewChars) } else { $bodyText }
+    }
+    $attachmentNames = @()
+    try { foreach ($att in $item.Attachments) { $attachmentNames += [string]$att.FileName } } catch {}
     $who = ''
-    try { $who = if ($item.To) { $item.To } else { '' } } catch {}
-    $results += [PSCustomObject]@{
-        entryId       = $item.EntryID
-        storeId       = $storeId
-        folderPath    = $scopePath
-        subject       = $subj
-        senderName    = if (${isOutgoing}) { $who } elseif ($item.SenderName) { $item.SenderName } else { '' }
-        senderEmail   = if (${isOutgoing}) { $who } elseif ($item.SenderEmailAddress) { $item.SenderEmailAddress } else { '' }
-        receivedTime  = $stamp
-        bodyPreview   = $bodyPreview
-        attachmentNames = $attNames
-        attachmentCount = $item.Attachments.Count
+    $whoEmail = ''
+    if (${(0, run_1.psBool)(outgoing)}) {
+        # Outgoing mail reports who it went TO; "from" is always the mailbox itself.
+        try { $who = [string]$item.To } catch {}
+        $whoEmail = $who
+    } else {
+        try { $who = [string]$item.SenderName } catch {}
+        try { $whoEmail = [string]$item.SenderEmailAddress } catch {}
+    }
+    $rows += [PSCustomObject]@{
+        entryId         = [string]$item.EntryID
+        storeId         = $storeId
+        folderPath      = $scopePath
+        subject         = ([string]$item.Subject).Trim()
+        senderName      = $who
+        senderEmail     = $whoEmail
+        receivedTime    = if ($stamp -ne $null) { $stamp.ToString('yyyy-MM-dd HH:mm') } else { '' }
+        bodyPreview     = $preview
+        attachmentNames = @($attachmentNames)
     }
 }
-ConvertTo-Json $results -Depth 3
-`;
-    return (0, json_1.parseArray)(await (0, run_1.runPowerShell)(script, 30000)).map(item => {
-        const e = (0, json_1.record)(item);
+ConvertTo-Json -Depth 4 -InputObject @($rows)
+`, 'standard');
+    return (0, json_1.toArray)(output).map(row => {
+        const e = (0, json_1.record)(row);
+        const attachmentNames = (0, json_1.toArray)(e.attachmentNames).map(json_1.str);
         return {
             entryId: (0, json_1.str)(e.entryId),
             storeId: (0, json_1.str)(e.storeId),
-            folderPath: (0, json_1.str)(e.folderPath),
             subject: (0, json_1.str)(e.subject),
             senderName: (0, json_1.str)(e.senderName),
             senderEmail: (0, json_1.str)(e.senderEmail),
             receivedTime: (0, json_1.str)(e.receivedTime),
             bodyPreview: (0, json_1.str)(e.bodyPreview),
-            attachmentNames: (0, json_1.toArray)(e.attachmentNames).map(json_1.str),
-            attachmentCount: typeof e.attachmentCount === 'number' ? e.attachmentCount : 0,
+            attachmentNames,
+            attachmentCount: attachmentNames.length,
+            folderPath: (0, json_1.str)(e.folderPath),
         };
     });
 }
 /**
- * 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.
+ * One email's full plain-text body, by id.
  *
- * 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.
+ * `Body`, not `HTMLBody`: Outlook's own plain-text rendering is what every other
+ * reader here consumes, and markup costs an order of magnitude more for the same
+ * sentences. The tradeoff is that an HTML table's rows flatten.
  */
-async function readEmailBody(entryId, storeId, maxChars = 8000, includeQuoted = false) {
-    (0, run_1.requireWindows)();
-    const script = `
-$outlook = New-Object -ComObject Outlook.Application
-$ns = $outlook.GetNamespace('mapi')
-$ns.Logon()
-${(0, scripts_1.getItemScript)(entryId, storeId)}
-if ($item -eq $null) { throw "Email not found for EntryID '${(0, run_1.psEscape)(entryId)}'" }
-$cls = 0
-try { $cls = [int]$item.Class } catch {}
-if ($cls -ne 43 -and $cls -ne 46) { throw "The item for this EntryID is not an email (Class=$cls). Re-run readInboxEmails for a current EntryID." }
+async function readEmailBody(email) {
+    const output = await (0, run_1.runPowerShellJson)(`${scripts_1.SESSION_PS}
+${(0, scripts_1.itemLookupScript)(email)}
+$class = 0
+try { $class = [int]$item.Class } catch {}
+# 43 = olMail, 46 = olReport (a non-delivery report is still worth reading).
+if ($class -ne 43 -and $class -ne 46) {
+    throw "${(0, errors_1.failureTag)('NOT_FOUND', 'email')}The item with entry id '$lookupId' is not an email (class $class)."
+}
 $bodyRaw = ''
-try { if ($item.Body) { $bodyRaw = [string]$item.Body } } catch {}
-$attNames = @()
-try { foreach ($att in $item.Attachments) { $attNames += $att.FileName } } catch {}
+try { $bodyRaw = [string]$item.Body } catch {}
+$attachmentNames = @()
+try { foreach ($att in $item.Attachments) { $attachmentNames += [string]$att.FileName } } catch {}
 ${scripts_1.SENDER_SMTP_PS}
 $received = ''
 try { $received = $item.ReceivedTime.ToString('yyyy-MM-dd HH:mm') } catch {}
-$out = [PSCustomObject]@{
-    entryId         = $item.EntryID
-    subject         = if ($item.Subject) { $item.Subject.Trim() } else { '' }
-    senderName      = if ($item.SenderName) { $item.SenderName } else { '' }
+ConvertTo-Json -Compress -Depth 3 -InputObject ([PSCustomObject]@{
+    entryId         = [string]$item.EntryID
+    subject         = ([string]$item.Subject).Trim()
+    senderName      = [string]$item.SenderName
     senderEmail     = $senderSmtp
     receivedTime    = $received
-    body            = [Convert]::ToBase64String([System.Text.Encoding]::UTF8.GetBytes($bodyRaw))
-    attachmentNames = $attNames
-}
-ConvertTo-Json $out -Depth 3 -Compress
-`;
-    const raw = await (0, run_1.runPowerShell)(script, 20000);
-    if (!raw || !raw.trim())
-        throw new errors_1.NotFoundError('email', 'Failed to read email body.');
-    const parsed = (0, json_1.parseObject)(raw);
-    const { body, quoted, separator } = (0, mail_1.splitQuotedOriginal)(decodeBody(parsed.body));
-    const attachmentNames = (0, json_1.toArray)(parsed.attachmentNames).map(json_1.str);
-    // The quoted thread is context, never the sender's own answer, so it is capped
-    // harder than the reply itself — its useful part (what was asked) is at the
-    // top of it.
-    const quotedCap = Math.min(maxChars, 4000);
+    body            = ${BODY_B64_PS}
+    attachmentNames = @($attachmentNames)
+})
+`, 'quick');
+    const e = (0, json_1.record)(output);
     return {
-        entryId: (0, json_1.str)(parsed.entryId),
-        subject: (0, json_1.str)(parsed.subject),
-        senderName: (0, json_1.str)(parsed.senderName),
-        senderEmail: (0, json_1.str)(parsed.senderEmail),
-        receivedTime: (0, json_1.str)(parsed.receivedTime),
-        body: body.length > maxChars ? body.slice(0, maxChars) : body,
-        truncated: body.length > maxChars,
-        bodyLength: body.length,
-        quoteSeparator: separator,
-        quotedLength: quoted.length,
-        quotedOriginal: includeQuoted ? quoted.slice(0, quotedCap) : '',
-        attachmentNames,
-        attachmentCount: attachmentNames.length,
+        entryId: (0, json_1.str)(e.entryId) || email.entryId,
+        subject: (0, json_1.str)(e.subject),
+        senderName: (0, json_1.str)(e.senderName),
+        senderEmail: (0, json_1.str)(e.senderEmail),
+        receivedTime: (0, json_1.str)(e.receivedTime),
+        body: (0, json_1.base64Text)(e.body),
+        attachmentNames: (0, json_1.toArray)(e.attachmentNames).map(json_1.str),
     };
 }
 /**
- * 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.
+ * Walk every folder under the Inbox for the mail matching the request.
  *
- * 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. Where the store
- * won't run that subject query — an IMAP mailbox accepts it and then matches
- * nothing — an unbounded scan falls back to the last 60 days rather than
- * walking every item the mailbox has ever held.
+ * The window is enforced twice — a date Restrict per folder, then a per-item
+ * check — because Restrict is not reliable across stores, and a scan that
+ * silently widens on some mailboxes is the failure this guards against.
+ * `subjectLike` also drives a server-side prefilter, purely as an optimization:
+ * every subject is re-checked, so a store that can't run the query (IMAP stores
+ * accept it and match nothing) returns the same set, only slower.
  */
-async function searchInboxByFilter(emailAccount, filter = {}, daysBack = 0) {
-    if (process.platform !== 'win32')
-        return [];
-    const subjectLike = filter.subjectLike ? (0, run_1.psEscape)(filter.subjectLike) : '';
-    // DASL's `like` takes SQL wildcards, so the glob the filter is written in is
-    // translated for the server-side prefilter. The client-side re-check keeps
-    // the glob form, which is what PowerShell's own -like reads.
-    const subjectDasl = filter.subjectLike
-        ? (0, run_1.psEscape)(filter.subjectLike.replace(/\*/g, '%').replace(/\?/g, '_'))
-        : '';
-    const subjectPatternSrc = filter.subjectPattern ? (0, run_1.psEscape)(filter.subjectPattern.source) : '';
-    const script = `
-$subjLike = '${subjectLike}'
-$subjDasl = '${subjectDasl}'
-${(0, scripts_1.accountScript)(emailAccount)}
-${(0, scripts_1.namedStoreScript)(emailAccount)}
-$inbox = $store.GetDefaultFolder(6)
-$results = @()
-$seen = @{}
-$folders = [System.Collections.ArrayList]@($inbox)
-$fi = 0
-while ($fi -lt $folders.Count) {
-    try { foreach ($sub in $folders[$fi].Folders) { [void]$folders.Add($sub) } } catch {}
-    $fi++
+async function searchInboxByFilter(request) {
+    const subjectFiltered = !!(request.subjectLike || request.subjectPattern || request.excludeReplies);
+    // The server-side prefilter speaks DASL, whose `like` wildcards are % and _.
+    // A literal % or _ in the glob is left as a wildcard there: that can only
+    // widen the prefilter, and the exact test below narrows it again.
+    const subjectDasl = request.subjectLike ? request.subjectLike.replace(/\*/g, '%').replace(/\?/g, '_') : '';
+    const output = await (0, run_1.runPowerShellJson)(`${(0, scripts_1.accountScript)(request.account)}
+${scripts_1.NAMED_STORE_PS}
+$inbox = $store.GetDefaultFolder(${(0, run_1.psInt)(mail_1.FolderId.Inbox)})
+$subjectLike = ${(0, run_1.psString)(request.subjectLike ? (0, mail_1.subjectGlobSource)(request.subjectLike) : '')}
+$subjectDasl = ${(0, run_1.psString)(subjectDasl)}
+$subjectPattern = ${(0, run_1.psString)(request.subjectPattern?.source ?? '')}
+$replyPattern = ${(0, run_1.psString)(request.excludeReplies ? mail_1.REPLY_PREFIX_SOURCE : '')}
+$requireSubject = ${(0, run_1.psBool)(subjectFiltered)}
+$requireAttachment = ${(0, run_1.psBool)(request.requireAttachment)}
+$includeBody = ${(0, run_1.psBool)(request.includeBody)}
+${(0, scripts_1.cutoffScript)(request.daysBack)}
+# Sent, Drafts, Deleted and Junk are siblings of the Inbox on an Exchange profile
+# and CHILDREN of it on an IMAP one. They are cut by id — their names are
+# localized — before the walk, so each takes its whole subtree with it.
+$skipIds = @{}
+foreach ($role in @(${mail_1.NON_INCOMING_ROOTS.map(run_1.psInt).join(', ')})) {
+    try {
+        $roleFolder = $store.GetDefaultFolder($role)
+        if ($roleFolder -ne $null) { $skipIds[[string]$roleFolder.EntryID] = $true }
+    } catch {}
 }
-# The subject prefilter is a DASL property query rather than Outlook's Jet
-# syntax: "[Subject] like '...'" is rejected outright by some stores — an IMAP
-# mailbox answers "Condition is not valid" — while DASL is accepted wherever
-# Restrict is. The two syntaxes cannot be mixed in one filter string, so the
-# date clause stays Jet and the subject one is applied as a second Restrict on
-# top of it. The pattern is CONCATENATED into the query, never interpolated:
-# interpolating would let a caller's $(...) run, and would break the query
-# outright on an apostrophe.
-$subjQuery = '@SQL=' + [char]34 + 'urn:schemas:httpmail:subject' + [char]34 + ' like ' + [char]39 + $subjDasl + [char]39
-$daysBack = ${daysBack}
-foreach ($folder in $folders) {
-    if ($daysBack -gt 0) {
-        $cutoff = (Get-Date).AddDays(-$daysBack).ToString('MM/dd/yyyy HH:mm')
-        $filtered = $folder.Items.Restrict("[ReceivedTime] >= '$cutoff'")
-    } else {
-        $filtered = $folder.Items
+$skipNames = ${(0, run_1.psArray)(request.excludeFolders)}
+$onlyNames = ${(0, run_1.psArray)(request.includeFolders)}
+function Test-FolderNamed([string]$name, [string]$path, $list) {
+    foreach ($entry in $list) {
+        if ($name -ieq $entry -or $path -ieq $entry) { return $true }
     }
-${subjectLike ? `    # Narrowing on the subject server-side is what keeps this cheap — a date-only
-    # restrict hands back every item in the window for every folder in the tree,
-    # which is thousands of COM round-trips on a busy mailbox. It is only an
-    # optimization though: every subject is re-checked below, so a store that
-    # cannot run the query returns the same answer, slower.
-    $narrowed = $null
+    return $false
+}
+# Traversal and scanning are separate, and the two lists are not symmetric: an
+# excluded folder is never queued, so its subtree goes with it, while an
+# included one only marks a folder the walk reached anyway — the walk still
+# passes through folders nobody named to reach a nested one somebody did.
+$rootName = ''
+try { $rootName = [string]$inbox.Name } catch {}
+$rootPath = ''
+try { $rootPath = [string]$inbox.FolderPath } catch {}
+$folders = [System.Collections.ArrayList]@($inbox)
+$inScope = [System.Collections.ArrayList]@(($onlyNames.Count -eq 0) -or (Test-FolderNamed $rootName $rootPath $onlyNames))
+$walked = 0
+while ($walked -lt $folders.Count) {
     try {
-        $candidate = $filtered.Restrict($subjQuery)
-        if ($candidate.Count -gt 0) { $narrowed = $candidate }
+        foreach ($sub in $folders[$walked].Folders) {
+            if ($skipIds.ContainsKey([string]$sub.EntryID)) { continue }
+            $subName = ''
+            try { $subName = [string]$sub.Name } catch {}
+            $subPath = ''
+            try { $subPath = [string]$sub.FolderPath } catch {}
+            if (Test-FolderNamed $subName $subPath $skipNames) { continue }
+            [void]$folders.Add($sub)
+            [void]$inScope.Add(($onlyNames.Count -eq 0) -or (Test-FolderNamed $subName $subPath $onlyNames))
+        }
     } catch {}
-    if ($narrowed -ne $null) {
-        $filtered = $narrowed
-    } elseif ($daysBack -le 0) {
-        # Nothing narrowed it and nothing bounds it, which would walk every item
-        # the folder has ever held; cap the sweep at a window instead.
-        $cutoff = (Get-Date).AddDays(-60).ToString('MM/dd/yyyy HH:mm')
-        $filtered = $folder.Items.Restrict("[ReceivedTime] >= '$cutoff'")
+    $walked++
+}
+# The subject prefilter is DASL rather than Jet: some stores reject Jet's
+# "[Subject] like" outright, while DASL is accepted wherever Restrict is. The
+# two syntaxes can't share one filter, so it is a second Restrict on top of the
+# date one. The pattern is concatenated into the query, never interpolated.
+$subjectQuery = '@SQL=' + [char]34 + 'urn:schemas:httpmail:subject' + [char]34 + ' like ' + [char]39 + $subjectDasl.Replace("'", "''") + [char]39
+# A list, not an array: += copies the whole array per row, and a wide scan returns thousands.
+$rows = New-Object System.Collections.ArrayList
+$seen = @{}
+for ($fx = 0; $fx -lt $folders.Count; $fx++) {
+    if (-not $inScope[$fx]) { continue }
+    $folder = $folders[$fx]
+    ${(0, scripts_1.itemsSinceScript)('folder', 'ReceivedTime').trim()}
+    if ($subjectDasl) {
+        try {
+            $candidate = $filtered.Restrict($subjectQuery)
+            if ($candidate.Count -gt 0) { $filtered = $candidate }
+        } catch {}
     }
-` : ''}    $fCount = $filtered.Count
-    for ($i = 1; $i -le $fCount; $i++) {
-        $item = $filtered.Item($i)
-        if ($seen.ContainsKey($item.EntryID)) { continue }
-        $seen[$item.EntryID] = $true
-        $subject = $item.Subject
-        if (-not $subject) { continue }
-        $subject = $subject.Trim()
-        ${subjectLike ? `if ($subject -notlike $subjLike) { continue }` : ''}
-        ${subjectPatternSrc ? `if ($subject -notmatch '${subjectPatternSrc}') { continue }` : ''}
-        ${filter.excludeReplies ? `if ($subject -imatch '^(re|fw[d]?)\\s*:') { continue }` : ''}
-        ${filter.requireAttachment ? `if ($item.Attachments.Count -eq 0) { continue }` : ''}
-        $attNames = @()
-        foreach ($att in $item.Attachments) { $attNames += $att.FileName }
-        $bodyRaw = if ($item.Body) { $item.Body } else { '' }
-        $bodyB64 = [Convert]::ToBase64String([System.Text.Encoding]::UTF8.GetBytes($bodyRaw))
+    $folderPath = ''
+    try { $folderPath = [string]$folder.FolderPath } catch {}
+    $count = $filtered.Count
+    for ($i = 1; $i -le $count; $i++) {
+        $item = $null
+        try { $item = $filtered.Item($i) } catch {}
+        # A restricted collection can hand back nothing for an index, and an item
+        # with no id can't be acted on by anything this package does.
+        if ($item -eq $null) { continue }
+        $entryId = [string]$item.EntryID
+        if (-not $entryId -or $seen.ContainsKey($entryId)) { continue }
+        $seen[$entryId] = $true
+        $subject = ''
+        try { $subject = ([string]$item.Subject).Trim() } catch {}
+        if ($requireSubject -and -not $subject) { continue }
+        if ($subjectLike -and $subject -notmatch $subjectLike) { continue }
+        if ($subjectPattern -and $subject -notmatch $subjectPattern) { continue }
+        if ($replyPattern -and $subject -imatch $replyPattern) { continue }
+        $received = $null
+        try { $received = $item.ReceivedTime } catch {}
+        if ($received -ne $null -and $received -lt $cutoff) { continue }
+        $attachmentNames = @()
+        try { foreach ($att in $item.Attachments) { $attachmentNames += [string]$att.FileName } } catch {}
+        if ($requireAttachment -and $attachmentNames.Count -eq 0) { continue }
+        $bodyRaw = ''
+        if ($includeBody) { try { $bodyRaw = [string]$item.Body } catch {} }
 ${scripts_1.SENDER_SMTP_PS}
-        $received = ''
-        try { $received = $item.ReceivedTime.ToString('yyyy-MM-dd HH:mm') } catch {}
-        $results += [PSCustomObject]@{
-            entryId = $item.EntryID
-            storeId = $storeId
-            subject = $item.Subject.Trim()
-            senderName = if ($item.SenderName) { $item.SenderName } else { '' }
-            senderEmail = $senderSmtp
-            receivedTime = $received
-            body = $bodyB64
-            attachmentNames = $attNames
-            folderPath = $folder.FolderPath
-        }
+        [void]$rows.Add([PSCustomObject]@{
+            entryId         = $entryId
+            storeId         = $storeId
+            subject         = $subject
+            senderName      = [string]$item.SenderName
+            senderEmail     = $senderSmtp
+            receivedTime    = if ($received -ne $null) { $received.ToString('yyyy-MM-dd HH:mm') } else { '' }
+            body            = ${BODY_B64_PS}
+            attachmentNames = @($attachmentNames)
+            folderPath      = $folderPath
+        })
     }
 }
-ConvertTo-Json $results -Depth 3
-`;
-    // Returns whole message bodies, so this is the call most likely to push against
-    // the stdout cap — raise `maxBufferBytes` via configure() before a scan that
-    // matches thousands of emails.
-    return (0, json_1.parseArray)(await (0, run_1.runPowerShell)(script, 300000)).map(item => {
-        const e = (0, json_1.record)(item);
+ConvertTo-Json -Depth 4 -InputObject @($rows)
+`, 'scan');
+    return (0, json_1.toArray)(output).map(row => {
+        const e = (0, json_1.record)(row);
         return {
             entryId: (0, json_1.str)(e.entryId),
             storeId: (0, json_1.str)(e.storeId),
@@ -305,64 +284,57 @@ ConvertTo-Json $results -Depth 3
             senderName: (0, json_1.str)(e.senderName),
             senderEmail: (0, json_1.str)(e.senderEmail),
             receivedTime: (0, json_1.str)(e.receivedTime),
-            body: decodeBody(e.body),
+            body: (0, json_1.base64Text)(e.body),
             attachmentNames: (0, json_1.toArray)(e.attachmentNames).map(json_1.str),
             folderPath: (0, json_1.str)(e.folderPath),
         };
     });
 }
-/**
- * Read the email currently selected (or open) in Outlook — full body,
- * attachments listed by name but not saved.
- */
+/** The email currently selected — or open — in Outlook. */
 async function readSelectedEmail() {
-    (0, run_1.requireWindows)();
-    const script = `
+    const output = await (0, run_1.runPowerShellJson)(`
 $outlook = New-Object -ComObject Outlook.Application
 $item = $null
 try {
     $explorer = $outlook.ActiveExplorer()
-    if ($explorer -ne $null) {
-        $sel = $explorer.Selection
-        if ($sel -ne $null -and $sel.Count -ge 1) { $item = $sel.Item(1) }
-    }
+    if ($explorer -ne $null -and $explorer.Selection.Count -ge 1) { $item = $explorer.Selection.Item(1) }
 } catch {}
 if ($item -eq $null) {
     try {
-        $insp = $outlook.ActiveInspector()
-        if ($insp -ne $null) { $item = $insp.CurrentItem }
+        $inspector = $outlook.ActiveInspector()
+        if ($inspector -ne $null) { $item = $inspector.CurrentItem }
     } catch {}
 }
-if ($item -eq $null) { throw 'No email is selected in Outlook. Open Outlook, select (or open) an email, then try again.' }
-if ($item.MessageClass -notlike 'IPM.Note*') { throw 'The selected Outlook item is not an email.' }
-$attNames = @()
-foreach ($att in $item.Attachments) { $attNames += $att.FileName }
-$subject = ''
-if ($item.Subject) { $subject = $item.Subject.Trim() }
-$bodyRaw = if ($item.Body) { $item.Body } else { '' }
-$bodyB64 = [Convert]::ToBase64String([System.Text.Encoding]::UTF8.GetBytes($bodyRaw))
+if ($item -eq $null) {
+    throw "${(0, errors_1.failureTag)('NOT_FOUND', 'email')}No email is selected in Outlook. Select or open an email, then try again."
+}
+if ([string]$item.MessageClass -notlike 'IPM.Note*') {
+    throw "${(0, errors_1.failureTag)('INVALID_REQUEST')}The item selected in Outlook is not an email."
+}
+$attachmentNames = @()
+try { foreach ($att in $item.Attachments) { $attachmentNames += [string]$att.FileName } } catch {}
+$bodyRaw = ''
+try { $bodyRaw = [string]$item.Body } catch {}
 $storeId = ''
-try { $storeId = $item.Parent.Store.StoreID } catch {}
+try { $storeId = [string]$item.Parent.Store.StoreID } catch {}
+$folderPath = ''
+try { $folderPath = [string]$item.Parent.FolderPath } catch {}
 ${scripts_1.SENDER_SMTP_PS}
 $received = ''
 try { $received = $item.ReceivedTime.ToString('yyyy-MM-dd HH:mm') } catch {}
-$result = [PSCustomObject]@{
-    entryId = $item.EntryID
-    storeId = $storeId
-    subject = $subject
-    senderName = if ($item.SenderName) { $item.SenderName } else { '' }
-    senderEmail = $senderSmtp
-    receivedTime = $received
-    body = $bodyB64
-    attachmentNames = $attNames
-}
-ConvertTo-Json $result -Depth 3
-`;
-    const raw = await (0, run_1.runPowerShell)(script, 30000);
-    if (!raw || raw.trim() === '' || raw.trim() === 'null') {
-        throw new errors_1.NotFoundError('email', 'Failed to read the selected Outlook email.');
-    }
-    const e = (0, json_1.parseObject)(raw);
+ConvertTo-Json -Compress -Depth 3 -InputObject ([PSCustomObject]@{
+    entryId         = [string]$item.EntryID
+    storeId         = $storeId
+    subject         = ([string]$item.Subject).Trim()
+    senderName      = [string]$item.SenderName
+    senderEmail     = $senderSmtp
+    receivedTime    = $received
+    body            = ${BODY_B64_PS}
+    attachmentNames = @($attachmentNames)
+    folderPath      = $folderPath
+})
+`, 'quick');
+    const e = (0, json_1.record)(output);
     return {
         entryId: (0, json_1.str)(e.entryId),
         storeId: (0, json_1.str)(e.storeId),
@@ -370,35 +342,22 @@ ConvertTo-Json $result -Depth 3
         senderName: (0, json_1.str)(e.senderName),
         senderEmail: (0, json_1.str)(e.senderEmail),
         receivedTime: (0, json_1.str)(e.receivedTime),
-        body: decodeBody(e.body),
-        attachmentNames: (0, json_1.toArray)(e.attachmentNames).map(json_1.str),
+        body: (0, json_1.base64Text)(e.body),
+        attachmentNames: (0, json_1.strList)(e.attachmentNames),
+        folderPath: (0, json_1.str)(e.folderPath),
     };
 }
 /**
- * Open an email in Outlook by its EntryID.
- *
- * `storeId` disambiguates across mailboxes — without one, `GetItemFromID` only
- * looks in the default store, so an id from a shared or secondary mailbox
- * simply isn't found. It's tried first and the bare lookup is the fallback, so
- * a caller holding a stale StoreID (or none) still resolves whatever it can.
+ * Open an email in Outlook.
  *
- * EntryIDs are rewritten when an item MOVES between folders, so an id recorded
- * before its mail was filed can resolve to nothing — or, worse, to a different
- * message. The caller is the one that knows what the email was supposed to be;
- * this throws a plain not-found rather than guessing.
+ * Entry ids are rewritten when an item MOVES between folders, so an id recorded
+ * before its mail was filed can stop resolving. That fails as NOT_FOUND rather
+ * than guessing — the caller is the one who knows what the email was.
  */
-async function openOutlookEmail(entryId, storeId) {
-    (0, run_1.requireWindows)();
-    const script = `
-$outlook = New-Object -ComObject Outlook.Application
-$ns = $outlook.GetNamespace('mapi')
-$ns.Logon()
-$item = $null
-${storeId ? `try { ${(0, scripts_1.getItemScript)(entryId, storeId)} } catch { $item = $null }` : ''}
-if ($item -eq $null) { try { ${(0, scripts_1.getItemScript)(entryId)} } catch { $item = $null } }
-if ($item -eq $null) { throw "Email not found for EntryID '${(0, run_1.psEscape)(entryId)}'" }
+async function openOutlookEmail(email) {
+    await (0, run_1.runPowerShell)(`${scripts_1.SESSION_PS}
+${(0, scripts_1.itemLookupScript)(email)}
 $item.Display()
-`;
-    await (0, run_1.runPowerShell)(script);
+`, 'quick');
 }
 //# sourceMappingURL=read.js.map