@dawnlit/outlook-bridge 1.1.1 → 2.0.0

package/dist/windows/scripts.d.ts

@@ -1,79 +1,89 @@
-import type { MailFolderRef } from '../types';
+import type { EmailLocator, MailFolderRef } from '../types';
 /**
- * Session plus the mailbox the address names; binds `$target`, `$account` and
- * `$storeFolder`.
+ * Open the MAPI session, binding `$outlook` and `$ns`.
  *
- * An address can name a mailbox two different ways, and only one of them is an
- * Account. A mailbox opened as a secondary store has no Account object, so
- * resolving through Accounts alone closes every operation to it — including the
- * reads, which never needed an Account in the first place. Both are resolved
- * here and EITHER is enough: `$account` is null for a store-only mailbox, and
- * the operations that genuinely require an identity to act as (sending) check
- * for it themselves rather than being denied the mailbox up front.
+ * `Logon()` is a no-op against an Outlook that is already running and starts
+ * one that isn't, which removes a class of "works only while Outlook is open"
+ * failure.
+ */
+export declare const SESSION_PS = "\n$outlook = New-Object -ComObject Outlook.Application\n$ns = $outlook.GetNamespace('MAPI')\n$ns.Logon()\n";
+/**
+ * The session plus the mailbox an address names; binds `$target`, `$account`
+ * and `$storeFolder`.
  *
- * Fails rather than falling back to the default account. A bad address must
- * never silently send from — or read — the wrong mailbox, and the thrown
- * sentence is the one `classifyRunFailure` recognises to raise
- * `AccountNotFoundError`, so the wording is load-bearing.
+ * An address can name a mailbox two ways, and only one is an Account. A mailbox
+ * mounted as a secondary store — a shared mailbox, or one added after Outlook
+ * started — has no Account object, so both are resolved and EITHER is enough:
+ * `$account` is null for a store-only mailbox, and the operations that need an
+ * identity to act as (sending) check for it themselves.
  *
- * The store is matched on the target address BEFORE the account's display name,
- * which is what keeps the named-store route (see `namedStoreScript`) selecting
- * the folders it selected before on a profile where the two differ.
+ * Never falls back to the default account: a bad address must not silently
+ * read or send from the wrong mailbox.
+ *
+ * The store is matched on the address BEFORE the account's display name, so a
+ * profile where the two differ selects the same folders it always has.
  */
 export declare function accountScript(emailAccount: string): string;
 /**
- * The mailbox's own store, as `$store`. Requires `accountScript`.
+ * The mailbox's store as `$store` (and its id as `$storeId`), reached through
+ * the account's delivery store. Requires `accountScript`.
  *
- * Falls back to the resolved store folder because a store-only mailbox has no
- * account to read a DeliveryStore off — reaching through `$account` directly is
- * what makes an operation fail on exactly those mailboxes.
+ * Falls back to the resolved store folder, because a store-only mailbox has no
+ * account to read a delivery store off.
  */
 export declare const DELIVERY_STORE_PS = "\n$store = if ($account -ne $null) { $account.DeliveryStore } else { $storeFolder.Store }\n$storeId = $store.StoreID\n";
 /**
- * The store `accountScript` resolved through the namespace's top-level folders,
- * as `$store`.
+ * The mailbox's store as `$store`, reached through the namespace's top-level
+ * folder for it. Requires `accountScript`.
  *
- * Kept alongside `DELIVERY_STORE_PS` rather than replaced by it: the reading
- * operations resolve the store this way, and on a profile where a mailbox is
- * open under a display name that differs from the delivery store's, the two do
- * not select the same folders. Changing which one a reader uses changes what it
- * returns, so each keeps the route it was verified against.
+ * Kept beside DELIVERY_STORE_PS rather than replaced by it: the readers resolve
+ * their store this way, and on a profile where a mailbox is open under a display
+ * name that differs from its delivery store's, the two routes do not select the
+ * same folders. Each operation keeps the route it was verified against.
+ */
+export declare const NAMED_STORE_PS: string;
+/**
+ * Resolve one email into `$<variable>`, or fail as NOT_FOUND.
  *
- * The folder search itself now lives in `accountScript`, which has to attempt it
- * anyway to resolve a mailbox that has no account. This throws when it found
- * nothing, which is the case where the address named an account whose store is
- * not open in this profile.
+ * The StoreID is tried first, since it lets an id from any mounted mailbox
+ * resolve; the bare lookup (default store) is the fallback for a caller holding
+ * a stale StoreID or none.
  */
-export declare function namedStoreScript(emailAccount: string): string;
+export declare function itemLookupScript(email: EmailLocator, variable?: string): string;
 /**
- * Resolve one item into `$item`. A StoreID disambiguates across mailboxes, so
- * pass it whenever the listing that produced the id carried one.
+ * The sender's SMTP address as `$senderSmtp`. Requires `$item`.
+ *
+ * An Exchange sender's SenderEmailAddress is an X.500 DN, not an address; a
+ * caller replying to it or matching it against anything needs the address.
  */
-export declare function getItemScript(entryId: string, storeId?: string): string;
+export declare const SENDER_SMTP_PS = "\n$senderSmtp = ''\ntry {\n    if ($item.SenderEmailType -eq 'EX') { $senderSmtp = [string]$item.Sender.GetExchangeUser().PrimarySmtpAddress }\n} catch {}\nif (-not $senderSmtp) { try { $senderSmtp = [string]$item.SenderEmailAddress } catch {} }\n";
+/** Recursive, case-insensitive folder search by name, depth-capped so a huge tree can't hang it. */
+export declare const FIND_FOLDER_PS = "\nfunction Find-FolderByName($root, [string]$name, [int]$depth) {\n    foreach ($f in $root.Folders) {\n        if ($f.Name -ieq $name) { return $f }\n    }\n    if ($depth -le 1) { return $null }\n    foreach ($f in $root.Folders) {\n        $hit = Find-FolderByName $f $name ($depth - 1)\n        if ($hit -ne $null) { return $hit }\n    }\n    return $null\n}\n";
 /**
- * The sender's real SMTP address, as `$senderSmtp`. Requires `$item`.
+ * `$cutoff`, the moment `daysBack` days ago, and `$cutoffFilter`, that moment
+ * as a date string for an `Items.Restrict` filter.
  *
- * An Exchange sender's `SenderEmailAddress` is an X500 DN rather than an
- * address; a caller that means to reply to it, or correlate it with anything,
- * needs the address it resolves to.
+ * Restrict parses date strings in the machine's own regional format, so the
+ * string is formatted in it ('g': short date and time) rather than a fixed
+ * pattern — 'MM/dd/yyyy' reads as a different day on a day-first locale. Every
+ * reader re-checks each item against `$cutoff` too, so the window holds even
+ * where a store reads the filter loosely.
  */
-export declare const SENDER_SMTP_PS = "\n$senderSmtp = ''\ntry {\n    if ($item.SenderEmailType -eq 'EX') { $senderSmtp = $item.Sender.GetExchangeUser().PrimarySmtpAddress }\n} catch {}\nif (-not $senderSmtp) { $senderSmtp = if ($item.SenderEmailAddress) { $item.SenderEmailAddress } else { '' } }\n";
+export declare function cutoffScript(daysBack: number): string;
 /**
- * Recursive folder-by-name search. Case-insensitive, depth-capped so a huge
- * mailbox tree can't hang the scan.
+ * `$<variable>` = the items of `$<folderVariable>` with `property` on or after
+ * `$cutoff`. Requires `cutoffScript`. A store that rejects the filter outright
+ * yields every item instead, which the per-item re-check then narrows.
  */
-export declare const FIND_FOLDER_PS = "\nfunction Find-FolderByName($root, $name, $depth) {\n    foreach ($f in $root.Folders) {\n        if ($f.Name -ieq $name) { return $f }\n    }\n    if ($depth -le 1) { return $null }\n    foreach ($f in $root.Folders) {\n        $hit = Find-FolderByName $f $name ($depth - 1)\n        if ($hit -ne $null) { return $hit }\n    }\n    return $null\n}\n";
+export declare function itemsSinceScript(folderVariable: string, property: string, variable: string): string;
 /**
- * Emit the PowerShell that resolves `$scope` from `$store`, walking a well-known
- * root down through any further segments. Also binds `$scopeCreated`.
- *
- * Split out so the emitted script can be parse-checked without an Outlook
- * session — the folder walk is the only part that varies per call, and a syntax
- * error in it would only ever surface as a failed live run.
+ * Resolve `$scope` from `$store`: a well-known root walked down through any
+ * further segments. Also binds `$scopeCreated`.
  *
- * `folderLabel` is the caller's original string, used verbatim in the error so
- * the message names what they typed rather than the parsed segments. Set
- * `createMissing` to build absent segments instead of throwing — the whole
- * chain, so a nested destination can be created in one call.
+ * Segments match direct children; a bare name that isn't a direct child falls
+ * back to a recursive search, so one folder string works across operations. A
+ * missing folder fails as NOT_FOUND naming what the caller typed and what the
+ * deepest folder reached does hold — never a silent fall back to the root. With
+ * `createMissing`, the whole missing chain is created instead.
  */
-export declare function mailScopeScript(ref: MailFolderRef, folderLabel?: string, createMissing?: boolean): string;
+export declare function mailScopeScript(ref: MailFolderRef, folderLabel: string, createMissing?: boolean): string;

package/dist/windows/scripts.js

@@ -1,53 +1,50 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FIND_FOLDER_PS = exports.SENDER_SMTP_PS = exports.DELIVERY_STORE_PS = void 0;
+exports.FIND_FOLDER_PS = exports.SENDER_SMTP_PS = exports.NAMED_STORE_PS = exports.DELIVERY_STORE_PS = exports.SESSION_PS = void 0;
 exports.accountScript = accountScript;
-exports.namedStoreScript = namedStoreScript;
-exports.getItemScript = getItemScript;
+exports.itemLookupScript = itemLookupScript;
+exports.cutoffScript = cutoffScript;
+exports.itemsSinceScript = itemsSinceScript;
 exports.mailScopeScript = mailScopeScript;
 // The PowerShell fragments more than one Windows operation is built from.
 //
-// A fragment lives here once at least two modules emit it; one used by a single
-// operation stays beside that operation, where its rules are readable next to
-// the code that depends on them.
+// A fragment lives here once two modules emit it; one used by a single
+// operation stays beside that operation, where its rules read next to the code
+// relying on them. Every fragment follows run.ts's escaping rule: caller text
+// only ever appears as a psString literal.
 const run_1 = require("./run");
+const errors_1 = require("../errors");
 /**
- * Open a MAPI session. `$outlook` and `$ns` are what every later fragment reads.
+ * Open the MAPI session, binding `$outlook` and `$ns`.
  *
- * `Logon()` is a no-op against an Outlook that is already running and starts one
- * that isn't, so it costs nothing and removes a class of "works only when
- * Outlook happens to be open" failure.
+ * `Logon()` is a no-op against an Outlook that is already running and starts
+ * one that isn't, which removes a class of "works only while Outlook is open"
+ * failure.
  */
-const PS_PRELUDE = `
-$ErrorActionPreference = 'Stop'
+exports.SESSION_PS = `
 $outlook = New-Object -ComObject Outlook.Application
-$ns = $outlook.GetNamespace('mapi')
+$ns = $outlook.GetNamespace('MAPI')
 $ns.Logon()
 `;
 /**
- * Session plus the mailbox the address names; binds `$target`, `$account` and
- * `$storeFolder`.
+ * The session plus the mailbox an address names; binds `$target`, `$account`
+ * and `$storeFolder`.
  *
- * An address can name a mailbox two different ways, and only one of them is an
- * Account. A mailbox opened as a secondary store has no Account object, so
- * resolving through Accounts alone closes every operation to it — including the
- * reads, which never needed an Account in the first place. Both are resolved
- * here and EITHER is enough: `$account` is null for a store-only mailbox, and
- * the operations that genuinely require an identity to act as (sending) check
- * for it themselves rather than being denied the mailbox up front.
+ * An address can name a mailbox two ways, and only one is an Account. A mailbox
+ * mounted as a secondary store — a shared mailbox, or one added after Outlook
+ * started — has no Account object, so both are resolved and EITHER is enough:
+ * `$account` is null for a store-only mailbox, and the operations that need an
+ * identity to act as (sending) check for it themselves.
  *
- * Fails rather than falling back to the default account. A bad address must
- * never silently send from — or read — the wrong mailbox, and the thrown
- * sentence is the one `classifyRunFailure` recognises to raise
- * `AccountNotFoundError`, so the wording is load-bearing.
+ * Never falls back to the default account: a bad address must not silently
+ * read or send from the wrong mailbox.
  *
- * The store is matched on the target address BEFORE the account's display name,
- * which is what keeps the named-store route (see `namedStoreScript`) selecting
- * the folders it selected before on a profile where the two differ.
+ * The store is matched on the address BEFORE the account's display name, so a
+ * profile where the two differ selects the same folders it always has.
  */
 function accountScript(emailAccount) {
-    return `${PS_PRELUDE}
-$target = '${(0, run_1.psEscape)(emailAccount)}'
+    return `${exports.SESSION_PS}
+$target = ${(0, run_1.psString)(emailAccount)}
 $account = $null
 foreach ($a in $ns.Accounts) {
     if ($a.SmtpAddress -ieq $target) { $account = $a; break }
@@ -61,71 +58,75 @@ if ($storeFolder -eq $null -and $account -ne $null) {
         if ($f.Name -ieq $account.DisplayName) { $storeFolder = $f; break }
     }
 }
-if ($account -eq $null -and $storeFolder -eq $null) { throw "Account '$target' not found" }
+if ($account -eq $null -and $storeFolder -eq $null) {
+    throw "${(0, errors_1.failureTag)('ACCOUNT_NOT_FOUND')}Account '$target' not found in this Outlook profile."
+}
 `;
 }
 /**
- * The mailbox's own store, as `$store`. Requires `accountScript`.
+ * The mailbox's store as `$store` (and its id as `$storeId`), reached through
+ * the account's delivery store. Requires `accountScript`.
  *
- * Falls back to the resolved store folder because a store-only mailbox has no
- * account to read a DeliveryStore off — reaching through `$account` directly is
- * what makes an operation fail on exactly those mailboxes.
+ * Falls back to the resolved store folder, because a store-only mailbox has no
+ * account to read a delivery store off.
  */
 exports.DELIVERY_STORE_PS = `
 $store = if ($account -ne $null) { $account.DeliveryStore } else { $storeFolder.Store }
 $storeId = $store.StoreID
 `;
 /**
- * The store `accountScript` resolved through the namespace's top-level folders,
- * as `$store`.
- *
- * Kept alongside `DELIVERY_STORE_PS` rather than replaced by it: the reading
- * operations resolve the store this way, and on a profile where a mailbox is
- * open under a display name that differs from the delivery store's, the two do
- * not select the same folders. Changing which one a reader uses changes what it
- * returns, so each keeps the route it was verified against.
+ * The mailbox's store as `$store`, reached through the namespace's top-level
+ * folder for it. Requires `accountScript`.
  *
- * The folder search itself now lives in `accountScript`, which has to attempt it
- * anyway to resolve a mailbox that has no account. This throws when it found
- * nothing, which is the case where the address named an account whose store is
- * not open in this profile.
+ * Kept beside DELIVERY_STORE_PS rather than replaced by it: the readers resolve
+ * their store this way, and on a profile where a mailbox is open under a display
+ * name that differs from its delivery store's, the two routes do not select the
+ * same folders. Each operation keeps the route it was verified against.
  */
-function namedStoreScript(emailAccount) {
-    return `
-if ($storeFolder -eq $null) { throw "Store folder not found for account '${(0, run_1.psEscape)(emailAccount)}'" }
+exports.NAMED_STORE_PS = `
+if ($storeFolder -eq $null) {
+    throw "${(0, errors_1.failureTag)('ACCOUNT_NOT_FOUND')}Account '$target' has no mailbox open in this Outlook profile."
+}
 $store = $storeFolder.Store
 $storeId = $store.StoreID
 `;
-}
 /**
- * Resolve one item into `$item`. A StoreID disambiguates across mailboxes, so
- * pass it whenever the listing that produced the id carried one.
+ * Resolve one email into `$<variable>`, or fail as NOT_FOUND.
+ *
+ * The StoreID is tried first, since it lets an id from any mounted mailbox
+ * resolve; the bare lookup (default store) is the fallback for a caller holding
+ * a stale StoreID or none.
  */
-function getItemScript(entryId, storeId) {
-    return storeId
-        ? `$item = $ns.GetItemFromID('${(0, run_1.psEscape)(entryId)}', '${(0, run_1.psEscape)(storeId)}')`
-        : `$item = $ns.GetItemFromID('${(0, run_1.psEscape)(entryId)}')`;
+function itemLookupScript(email, variable = 'item') {
+    const byStore = email.storeId
+        ? `try { $${variable} = $ns.GetItemFromID($lookupId, ${(0, run_1.psString)(email.storeId)}) } catch { $${variable} = $null }`
+        : '';
+    return `
+$lookupId = ${(0, run_1.psString)(email.entryId)}
+$${variable} = $null
+${byStore}
+if ($${variable} -eq $null) { try { $${variable} = $ns.GetItemFromID($lookupId) } catch { $${variable} = $null } }
+if ($${variable} -eq $null) {
+    throw "${(0, errors_1.failureTag)('NOT_FOUND', 'email')}No email found for entry id '$lookupId'. It may have been moved or deleted - list the mail again for a current id."
+}
+`;
 }
 /**
- * The sender's real SMTP address, as `$senderSmtp`. Requires `$item`.
+ * The sender's SMTP address as `$senderSmtp`. Requires `$item`.
  *
- * An Exchange sender's `SenderEmailAddress` is an X500 DN rather than an
- * address; a caller that means to reply to it, or correlate it with anything,
- * needs the address it resolves to.
+ * An Exchange sender's SenderEmailAddress is an X.500 DN, not an address; a
+ * caller replying to it or matching it against anything needs the address.
  */
 exports.SENDER_SMTP_PS = `
 $senderSmtp = ''
 try {
-    if ($item.SenderEmailType -eq 'EX') { $senderSmtp = $item.Sender.GetExchangeUser().PrimarySmtpAddress }
+    if ($item.SenderEmailType -eq 'EX') { $senderSmtp = [string]$item.Sender.GetExchangeUser().PrimarySmtpAddress }
 } catch {}
-if (-not $senderSmtp) { $senderSmtp = if ($item.SenderEmailAddress) { $item.SenderEmailAddress } else { '' } }
+if (-not $senderSmtp) { try { $senderSmtp = [string]$item.SenderEmailAddress } catch {} }
 `;
-/**
- * Recursive folder-by-name search. Case-insensitive, depth-capped so a huge
- * mailbox tree can't hang the scan.
- */
+/** Recursive, case-insensitive folder search by name, depth-capped so a huge tree can't hang it. */
 exports.FIND_FOLDER_PS = `
-function Find-FolderByName($root, $name, $depth) {
+function Find-FolderByName($root, [string]$name, [int]$depth) {
     foreach ($f in $root.Folders) {
         if ($f.Name -ieq $name) { return $f }
     }
@@ -138,25 +139,50 @@ function Find-FolderByName($root, $name, $depth) {
 }
 `;
 /**
- * Emit the PowerShell that resolves `$scope` from `$store`, walking a well-known
- * root down through any further segments. Also binds `$scopeCreated`.
+ * `$cutoff`, the moment `daysBack` days ago, and `$cutoffFilter`, that moment
+ * as a date string for an `Items.Restrict` filter.
  *
- * Split out so the emitted script can be parse-checked without an Outlook
- * session — the folder walk is the only part that varies per call, and a syntax
- * error in it would only ever surface as a failed live run.
+ * Restrict parses date strings in the machine's own regional format, so the
+ * string is formatted in it ('g': short date and time) rather than a fixed
+ * pattern — 'MM/dd/yyyy' reads as a different day on a day-first locale. Every
+ * reader re-checks each item against `$cutoff` too, so the window holds even
+ * where a store reads the filter loosely.
+ */
+function cutoffScript(daysBack) {
+    return `
+$cutoff = (Get-Date).AddDays(-${(0, run_1.psInt)(daysBack)})
+$cutoffFilter = $cutoff.ToString('g').Replace("'", "''")
+`;
+}
+/**
+ * `$<variable>` = the items of `$<folderVariable>` with `property` on or after
+ * `$cutoff`. Requires `cutoffScript`. A store that rejects the filter outright
+ * yields every item instead, which the per-item re-check then narrows.
+ */
+function itemsSinceScript(folderVariable, property, variable) {
+    return `
+$${variable} = $null
+try { $${variable} = $${folderVariable}.Items.Restrict("[${property}] >= '$cutoffFilter'") } catch { $${variable} = $${folderVariable}.Items }
+`;
+}
+/**
+ * Resolve `$scope` from `$store`: a well-known root walked down through any
+ * further segments. Also binds `$scopeCreated`.
  *
- * `folderLabel` is the caller's original string, used verbatim in the error so
- * the message names what they typed rather than the parsed segments. Set
- * `createMissing` to build absent segments instead of throwing — the whole
- * chain, so a nested destination can be created in one call.
+ * Segments match direct children; a bare name that isn't a direct child falls
+ * back to a recursive search, so one folder string works across operations. A
+ * missing folder fails as NOT_FOUND naming what the caller typed and what the
+ * deepest folder reached does hold — never a silent fall back to the root. With
+ * `createMissing`, the whole missing chain is created instead.
  */
-function mailScopeScript(ref, folderLabel = '', createMissing = false) {
-    const root = `$store.GetDefaultFolder(${ref.rootId})`;
+function mailScopeScript(ref, folderLabel, createMissing = false) {
+    const root = `$store.GetDefaultFolder(${(0, run_1.psInt)(ref.rootId)})`;
     if (ref.segments.length === 0)
         return `$scope = ${root}\n$scopeCreated = $false`;
     return `
 ${exports.FIND_FOLDER_PS}
-$segments = @(${ref.segments.map(s => `'${(0, run_1.psEscape)(s)}'`).join(',')})
+$folderLabel = ${(0, run_1.psString)(folderLabel)}
+$segments = @(${ref.segments.map(run_1.psString).join(', ')})
 $scopeRoot = ${root}
 $scope = $scopeRoot
 $deepest = $scopeRoot
@@ -167,13 +193,11 @@ foreach ($seg in $segments) {
     if ($next -eq $null) { $deepest = $scope; $scope = $null; break }
     $scope = $next
 }
-# A bare name that isn't a direct child still resolves by recursive search, so one
-# folder string keeps working across tools.
 if ($scope -eq $null -and $segments.Count -eq 1) {
     $scope = Find-FolderByName $scopeRoot $segments[0] 3
 }
 if ($scope -eq $null -and ${createMissing ? '$true' : '$false'}) {
-    # Rebuild the whole chain from the root, creating only what is genuinely absent.
+    # Rebuild the chain from the root, creating only what is genuinely absent.
     $scope = $scopeRoot
     foreach ($seg in $segments) {
         $next = $null
@@ -185,7 +209,7 @@ if ($scope -eq $null -and ${createMissing ? '$true' : '$false'}) {
 if ($scope -eq $null) {
     $names = @()
     foreach ($f in $deepest.Folders) { $names += $f.Name }
-    throw "Folder '${(0, run_1.psEscape)(folderLabel)}' not found. Folders under '$($deepest.Name)': $($names -join ', ')"
+    throw "${(0, errors_1.failureTag)('NOT_FOUND', 'folder')}Folder '$folderLabel' not found. Folders under '$($deepest.Name)': $($names -join ', ')"
 }`;
 }
 //# sourceMappingURL=scripts.js.map

package/dist/windows/scripts.js.map

@@ -1 +1 @@
-{"version":3,"file":"scripts.js","sourceRoot":"","sources":["../../src/windows/scripts.ts"],"names":[],"mappings":";;;AA2CA,sCAkBC;AA6BD,4CAMC;AAMD,sCAIC;AAgDD,0CAoCC;AA9LD,0EAA0E;AAC1E,EAAE;AACF,gFAAgF;AAChF,8EAA8E;AAC9E,iCAAiC;AACjC,+BAAiC;AAGjC;;;;;;GAMG;AACH,MAAM,UAAU,GAAG;;;;;CAKlB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,SAAgB,aAAa,CAAC,YAAoB;IAC9C,OAAO,GAAG,UAAU;aACX,IAAA,cAAQ,EAAC,YAAY,CAAC;;;;;;;;;;;;;;;CAelC,CAAC;AACF,CAAC;AAED;;;;;;GAMG;AACU,QAAA,iBAAiB,GAAG;;;CAGhC,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,SAAgB,gBAAgB,CAAC,YAAoB;IACjD,OAAO;2EACgE,IAAA,cAAQ,EAAC,YAAY,CAAC;;;CAGhG,CAAC;AACF,CAAC;AAED;;;GAGG;AACH,SAAgB,aAAa,CAAC,OAAe,EAAE,OAAgB;IAC3D,OAAO,OAAO;QACV,CAAC,CAAC,8BAA8B,IAAA,cAAQ,EAAC,OAAO,CAAC,OAAO,IAAA,cAAQ,EAAC,OAAO,CAAC,IAAI;QAC7E,CAAC,CAAC,8BAA8B,IAAA,cAAQ,EAAC,OAAO,CAAC,IAAI,CAAC;AAC9D,CAAC;AAED;;;;;;GAMG;AACU,QAAA,cAAc,GAAG;;;;;;CAM7B,CAAC;AAEF;;;GAGG;AACU,QAAA,cAAc,GAAG;;;;;;;;;;;;CAY7B,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,SAAgB,eAAe,CAAC,GAAkB,EAAE,WAAW,GAAG,EAAE,EAAE,aAAa,GAAG,KAAK;IACvF,MAAM,IAAI,GAAG,2BAA2B,GAAG,CAAC,MAAM,GAAG,CAAC;IACtD,IAAI,GAAG,CAAC,QAAQ,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,YAAY,IAAI,0BAA0B,CAAC;IACjF,OAAO;EACT,sBAAc;gBACA,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,IAAA,cAAQ,EAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC;eACpD,IAAI;;;;;;;;;;;;;;;4BAeS,aAAa,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,QAAQ;;;;;;;;;;;;;qBAazC,IAAA,cAAQ,EAAC,WAAW,CAAC;EACxC,CAAC;AACH,CAAC"}
+{"version":3,"file":"scripts.js","sourceRoot":"","sources":["../../src/windows/scripts.ts"],"names":[],"mappings":";;;AAuCA,sCAoBC;AAsCD,4CAaC;AAyCD,oCAKC;AAOD,4CAKC;AAYD,0CAmCC;AAvND,0EAA0E;AAC1E,EAAE;AACF,uEAAuE;AACvE,+EAA+E;AAC/E,8EAA8E;AAC9E,2CAA2C;AAC3C,+BAAwC;AACxC,sCAAuC;AAGvC;;;;;;GAMG;AACU,QAAA,UAAU,GAAG;;;;CAIzB,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,SAAgB,aAAa,CAAC,YAAoB;IAC9C,OAAO,GAAG,kBAAU;YACZ,IAAA,cAAQ,EAAC,YAAY,CAAC;;;;;;;;;;;;;;;aAerB,IAAA,mBAAU,EAAC,mBAAmB,CAAC;;CAE3C,CAAC;AACF,CAAC;AAED;;;;;;GAMG;AACU,QAAA,iBAAiB,GAAG;;;CAGhC,CAAC;AAEF;;;;;;;;GAQG;AACU,QAAA,cAAc,GAAG;;aAEjB,IAAA,mBAAU,EAAC,mBAAmB,CAAC;;;;CAI3C,CAAC;AAEF;;;;;;GAMG;AACH,SAAgB,gBAAgB,CAAC,KAAmB,EAAE,QAAQ,GAAG,MAAM;IACnE,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO;QACzB,CAAC,CAAC,UAAU,QAAQ,mCAAmC,IAAA,cAAQ,EAAC,KAAK,CAAC,OAAO,CAAC,gBAAgB,QAAQ,YAAY;QAClH,CAAC,CAAC,EAAE,CAAC;IACT,OAAO;cACG,IAAA,cAAQ,EAAC,KAAK,CAAC,OAAO,CAAC;GAClC,QAAQ;EACT,OAAO;OACF,QAAQ,wBAAwB,QAAQ,8CAA8C,QAAQ;OAC9F,QAAQ;aACF,IAAA,mBAAU,EAAC,WAAW,EAAE,OAAO,CAAC;;CAE5C,CAAC;AACF,CAAC;AAED;;;;;GAKG;AACU,QAAA,cAAc,GAAG;;;;;;CAM7B,CAAC;AAEF,oGAAoG;AACvF,QAAA,cAAc,GAAG;;;;;;;;;;;;CAY7B,CAAC;AAEF;;;;;;;;;GASG;AACH,SAAgB,YAAY,CAAC,QAAgB;IACzC,OAAO;gCACqB,IAAA,WAAK,EAAC,QAAQ,CAAC;;CAE9C,CAAC;AACF,CAAC;AAED;;;;GAIG;AACH,SAAgB,gBAAgB,CAAC,cAAsB,EAAE,QAAgB,EAAE,QAAgB;IACvF,OAAO;GACR,QAAQ;SACF,QAAQ,OAAO,cAAc,qBAAqB,QAAQ,qCAAqC,QAAQ,OAAO,cAAc;CACpI,CAAC;AACF,CAAC;AAED;;;;;;;;;GASG;AACH,SAAgB,eAAe,CAAC,GAAkB,EAAE,WAAmB,EAAE,aAAa,GAAG,KAAK;IAC1F,MAAM,IAAI,GAAG,2BAA2B,IAAA,WAAK,EAAC,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC;IAC7D,IAAI,GAAG,CAAC,QAAQ,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,YAAY,IAAI,0BAA0B,CAAC;IACjF,OAAO;EACT,sBAAc;iBACC,IAAA,cAAQ,EAAC,WAAW,CAAC;gBACtB,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,cAAQ,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;eACtC,IAAI;;;;;;;;;;;;;4BAaS,aAAa,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,QAAQ;;;;;;;;;;;;;aAajD,IAAA,mBAAU,EAAC,WAAW,EAAE,QAAQ,CAAC;EAC5C,CAAC;AACH,CAAC","sourcesContent":["// The PowerShell fragments more than one Windows operation is built from.\n//\n// A fragment lives here once two modules emit it; one used by a single\n// operation stays beside that operation, where its rules read next to the code\n// relying on them. Every fragment follows run.ts's escaping rule: caller text\n// only ever appears as a psString literal.\nimport { psInt, psString } from './run';\nimport { failureTag } from '../errors';\nimport type { EmailLocator, MailFolderRef } from '../types';\n\n/**\n * Open the MAPI session, binding `$outlook` and `$ns`.\n *\n * `Logon()` is a no-op against an Outlook that is already running and starts\n * one that isn't, which removes a class of \"works only while Outlook is open\"\n * failure.\n */\nexport const SESSION_PS = `\n$outlook = New-Object -ComObject Outlook.Application\n$ns = $outlook.GetNamespace('MAPI')\n$ns.Logon()\n`;\n\n/**\n * The session plus the mailbox an address names; binds `$target`, `$account`\n * and `$storeFolder`.\n *\n * An address can name a mailbox two ways, and only one is an Account. A mailbox\n * mounted as a secondary store — a shared mailbox, or one added after Outlook\n * started — has no Account object, so both are resolved and EITHER is enough:\n * `$account` is null for a store-only mailbox, and the operations that need an\n * identity to act as (sending) check for it themselves.\n *\n * Never falls back to the default account: a bad address must not silently\n * read or send from the wrong mailbox.\n *\n * The store is matched on the address BEFORE the account's display name, so a\n * profile where the two differ selects the same folders it always has.\n */\nexport function accountScript(emailAccount: string): string {\n    return `${SESSION_PS}\n$target = ${psString(emailAccount)}\n$account = $null\nforeach ($a in $ns.Accounts) {\n    if ($a.SmtpAddress -ieq $target) { $account = $a; break }\n}\n$storeFolder = $null\nforeach ($f in $ns.Folders) {\n    if ($f.Name -ieq $target) { $storeFolder = $f; break }\n}\nif ($storeFolder -eq $null -and $account -ne $null) {\n    foreach ($f in $ns.Folders) {\n        if ($f.Name -ieq $account.DisplayName) { $storeFolder = $f; break }\n    }\n}\nif ($account -eq $null -and $storeFolder -eq $null) {\n    throw \"${failureTag('ACCOUNT_NOT_FOUND')}Account '$target' not found in this Outlook profile.\"\n}\n`;\n}\n\n/**\n * The mailbox's store as `$store` (and its id as `$storeId`), reached through\n * the account's delivery store. Requires `accountScript`.\n *\n * Falls back to the resolved store folder, because a store-only mailbox has no\n * account to read a delivery store off.\n */\nexport const DELIVERY_STORE_PS = `\n$store = if ($account -ne $null) { $account.DeliveryStore } else { $storeFolder.Store }\n$storeId = $store.StoreID\n`;\n\n/**\n * The mailbox's store as `$store`, reached through the namespace's top-level\n * folder for it. Requires `accountScript`.\n *\n * Kept beside DELIVERY_STORE_PS rather than replaced by it: the readers resolve\n * their store this way, and on a profile where a mailbox is open under a display\n * name that differs from its delivery store's, the two routes do not select the\n * same folders. Each operation keeps the route it was verified against.\n */\nexport const NAMED_STORE_PS = `\nif ($storeFolder -eq $null) {\n    throw \"${failureTag('ACCOUNT_NOT_FOUND')}Account '$target' has no mailbox open in this Outlook profile.\"\n}\n$store = $storeFolder.Store\n$storeId = $store.StoreID\n`;\n\n/**\n * Resolve one email into `$<variable>`, or fail as NOT_FOUND.\n *\n * The StoreID is tried first, since it lets an id from any mounted mailbox\n * resolve; the bare lookup (default store) is the fallback for a caller holding\n * a stale StoreID or none.\n */\nexport function itemLookupScript(email: EmailLocator, variable = 'item'): string {\n    const byStore = email.storeId\n        ? `try { $${variable} = $ns.GetItemFromID($lookupId, ${psString(email.storeId)}) } catch { $${variable} = $null }`\n        : '';\n    return `\n$lookupId = ${psString(email.entryId)}\n$${variable} = $null\n${byStore}\nif ($${variable} -eq $null) { try { $${variable} = $ns.GetItemFromID($lookupId) } catch { $${variable} = $null } }\nif ($${variable} -eq $null) {\n    throw \"${failureTag('NOT_FOUND', 'email')}No email found for entry id '$lookupId'. It may have been moved or deleted - list the mail again for a current id.\"\n}\n`;\n}\n\n/**\n * The sender's SMTP address as `$senderSmtp`. Requires `$item`.\n *\n * An Exchange sender's SenderEmailAddress is an X.500 DN, not an address; a\n * caller replying to it or matching it against anything needs the address.\n */\nexport const SENDER_SMTP_PS = `\n$senderSmtp = ''\ntry {\n    if ($item.SenderEmailType -eq 'EX') { $senderSmtp = [string]$item.Sender.GetExchangeUser().PrimarySmtpAddress }\n} catch {}\nif (-not $senderSmtp) { try { $senderSmtp = [string]$item.SenderEmailAddress } catch {} }\n`;\n\n/** Recursive, case-insensitive folder search by name, depth-capped so a huge tree can't hang it. */\nexport const FIND_FOLDER_PS = `\nfunction Find-FolderByName($root, [string]$name, [int]$depth) {\n    foreach ($f in $root.Folders) {\n        if ($f.Name -ieq $name) { return $f }\n    }\n    if ($depth -le 1) { return $null }\n    foreach ($f in $root.Folders) {\n        $hit = Find-FolderByName $f $name ($depth - 1)\n        if ($hit -ne $null) { return $hit }\n    }\n    return $null\n}\n`;\n\n/**\n * `$cutoff`, the moment `daysBack` days ago, and `$cutoffFilter`, that moment\n * as a date string for an `Items.Restrict` filter.\n *\n * Restrict parses date strings in the machine's own regional format, so the\n * string is formatted in it ('g': short date and time) rather than a fixed\n * pattern — 'MM/dd/yyyy' reads as a different day on a day-first locale. Every\n * reader re-checks each item against `$cutoff` too, so the window holds even\n * where a store reads the filter loosely.\n */\nexport function cutoffScript(daysBack: number): string {\n    return `\n$cutoff = (Get-Date).AddDays(-${psInt(daysBack)})\n$cutoffFilter = $cutoff.ToString('g').Replace(\"'\", \"''\")\n`;\n}\n\n/**\n * `$<variable>` = the items of `$<folderVariable>` with `property` on or after\n * `$cutoff`. Requires `cutoffScript`. A store that rejects the filter outright\n * yields every item instead, which the per-item re-check then narrows.\n */\nexport function itemsSinceScript(folderVariable: string, property: string, variable: string): string {\n    return `\n$${variable} = $null\ntry { $${variable} = $${folderVariable}.Items.Restrict(\"[${property}] >= '$cutoffFilter'\") } catch { $${variable} = $${folderVariable}.Items }\n`;\n}\n\n/**\n * Resolve `$scope` from `$store`: a well-known root walked down through any\n * further segments. Also binds `$scopeCreated`.\n *\n * Segments match direct children; a bare name that isn't a direct child falls\n * back to a recursive search, so one folder string works across operations. A\n * missing folder fails as NOT_FOUND naming what the caller typed and what the\n * deepest folder reached does hold — never a silent fall back to the root. With\n * `createMissing`, the whole missing chain is created instead.\n */\nexport function mailScopeScript(ref: MailFolderRef, folderLabel: string, createMissing = false): string {\n    const root = `$store.GetDefaultFolder(${psInt(ref.rootId)})`;\n    if (ref.segments.length === 0) return `$scope = ${root}\\n$scopeCreated = $false`;\n    return `\n${FIND_FOLDER_PS}\n$folderLabel = ${psString(folderLabel)}\n$segments = @(${ref.segments.map(psString).join(', ')})\n$scopeRoot = ${root}\n$scope = $scopeRoot\n$deepest = $scopeRoot\n$scopeCreated = $false\nforeach ($seg in $segments) {\n    $next = $null\n    foreach ($f in $scope.Folders) { if ($f.Name -ieq $seg) { $next = $f; break } }\n    if ($next -eq $null) { $deepest = $scope; $scope = $null; break }\n    $scope = $next\n}\nif ($scope -eq $null -and $segments.Count -eq 1) {\n    $scope = Find-FolderByName $scopeRoot $segments[0] 3\n}\nif ($scope -eq $null -and ${createMissing ? '$true' : '$false'}) {\n    # Rebuild the chain from the root, creating only what is genuinely absent.\n    $scope = $scopeRoot\n    foreach ($seg in $segments) {\n        $next = $null\n        foreach ($f in $scope.Folders) { if ($f.Name -ieq $seg) { $next = $f; break } }\n        if ($next -eq $null) { $next = $scope.Folders.Add($seg); $scopeCreated = $true }\n        $scope = $next\n    }\n}\nif ($scope -eq $null) {\n    $names = @()\n    foreach ($f in $deepest.Folders) { $names += $f.Name }\n    throw \"${failureTag('NOT_FOUND', 'folder')}Folder '$folderLabel' not found. Folders under '$($deepest.Name)': $($names -join ', ')\"\n}`;\n}\n"]}

package/dist/windows/send.d.ts

@@ -1,11 +1,6 @@
-import type { ReplyEmailParams, ReplyEmailResult, SendEmailParams } from '../types';
-/** Send (or display for review) an email through Outlook COM. */
-export declare function sendOutlookEmail(params: SendEmailParams): Promise<void>;
-/**
- * Reply to an email, inserting the caller's HTML above the quoted original.
- *
- * The body may be given directly or named as a saved template — see
- * `composeReplyHtml`, which resolves the template, its section and its
- * placeholders before anything reaches Outlook.
- */
-export declare function replyOutlookEmail(params: ReplyEmailParams): Promise<ReplyEmailResult>;
+import type { ReplyRequest, SendRequest } from '../backend';
+import type { ReplyEmailResult } from '../types';
+/** Send, display or file a new email. */
+export declare function sendOutlookEmail(request: SendRequest): Promise<void>;
+/** Reply to an email, with the composed HTML above the quoted original. */
+export declare function replyOutlookEmail(request: ReplyRequest): Promise<ReplyEmailResult>;