@dawnlit/outlook-bridge 1.1.1 → 2.0.0

package/dist/bridge.d.ts

@@ -0,0 +1,56 @@
+import type { Backend } from './backend';
+import { type BridgeOptions, type ResolvedConfig } from './runtime';
+import type { BridgeCapability, CapabilityMap, OutlookBridge } from './types';
+export declare const OPERATIONS: readonly (keyof OutlookBridge)[];
+/**
+ * The operations over one backend. A null backend is a platform without Outlook
+ * automation: every operation rejects with UNSUPPORTED_PLATFORM before looking
+ * at its arguments, since nothing about them could make it work.
+ */
+export declare function createOperations(backendOrNull: Backend | null): OutlookBridge;
+/**
+ * A bridge carrying its own settings, plus capability discovery.
+ *
+ * The exported functions are the same operations under the process-wide
+ * settings; an instance is what to use when the process holds more than one
+ * caller, or when a call needs its own timeout or AbortSignal.
+ */
+export interface OutlookBridgeInstance extends OutlookBridge {
+    /** The settings this bridge runs with. */
+    readonly options: ResolvedConfig;
+    /** Which operations work on this machine. */
+    capabilities(): CapabilityMap;
+    /** Whether one operation works on this machine. */
+    supports(operation: BridgeCapability): boolean;
+    /**
+     * A bridge like this one with some settings changed — how one call gets its
+     * own budget or cancellation: `bridge.withOptions({ signal }).readInboxEmails(...)`.
+     */
+    withOptions(options: BridgeOptions): OutlookBridgeInstance;
+}
+/**
+ * A bridge over `backend` whose every call runs with `config` in force.
+ *
+ * The platform code reads settings through `getConfig()`, so the config is put
+ * in place around each call rather than passed into it: `withConfig` scopes it
+ * to the call's whole async subtree, which is why two bridges with different
+ * settings can run concurrently without seeing each other's.
+ */
+export declare function createBridge(backend: Backend | null, config: ResolvedConfig): OutlookBridgeInstance;
+/**
+ * A bridge with its own settings, isolated from `configure()` and from every
+ * other bridge. Options left out take the process-wide values as they stand
+ * when this is called.
+ *
+ * ```ts
+ * const outlook = createOutlookBridge({ timeoutMs: 30_000 });
+ * const recent = await outlook.readInboxEmails('me@example.com', { daysBack: 7 });
+ * ```
+ */
+export declare function createOutlookBridge(options?: BridgeOptions): OutlookBridgeInstance;
+/** Which operations work on this machine: all of them on Windows and macOS, none elsewhere. */
+export declare function capabilities(): CapabilityMap;
+/** Whether one operation works on this machine. */
+export declare function supports(operation: BridgeCapability): boolean;
+/** The operations under the process-wide settings — what the package exports as plain functions. */
+export declare const defaultBridge: OutlookBridge;

package/dist/bridge.js

@@ -0,0 +1,507 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultBridge = exports.OPERATIONS = void 0;
+exports.createOperations = createOperations;
+exports.createBridge = createBridge;
+exports.createOutlookBridge = createOutlookBridge;
+exports.capabilities = capabilities;
+exports.supports = supports;
+// The public operations, implemented once for both platforms.
+//
+// Each operation checks its arguments, applies its defaults, does whatever work
+// is the same everywhere — composing a reply from a template, splitting a body
+// from its quoted thread, choosing where attachments go — and hands a finished
+// request to this machine's backend. Keeping that here means a default, a
+// range or a validation rule can't come to differ between Windows and macOS.
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const windows_1 = require("./windows");
+const mac_1 = require("./mac");
+const args_1 = require("./shared/args");
+const replyBody_1 = require("./shared/replyBody");
+const locate_1 = require("./shared/locate");
+const bounceReport_1 = require("./shared/bounceReport");
+const mail_1 = require("./mail");
+const errors_1 = require("./errors");
+const runtime_1 = require("./runtime");
+/** Every default, stated once. */
+const DEFAULTS = {
+    daysBack: 60,
+    inboxLimit: 50,
+    previewChars: 600,
+    bodyMaxChars: 8000,
+    quotedMaxChars: 4000,
+    folderDepth: 2,
+    draftsLimit: 100,
+    draftsPreviewChars: 300,
+    bounceDaysBack: 30,
+    sentGroupsLimit: 3000,
+    templateFolder: 'Templates',
+    templatesLimit: 20,
+};
+/** The widest window any scan accepts, in days. */
+const MAX_DAYS = 3650;
+/**
+ * Every operation name. `satisfies` makes this list fail to compile the moment
+ * it and the OutlookBridge interface disagree, in either direction.
+ */
+const OPERATION_NAMES = {
+    getOutlookAccounts: true,
+    sendOutlookEmail: true,
+    replyOutlookEmail: true,
+    readInboxEmails: true,
+    searchInboxByFilter: true,
+    readSelectedEmail: true,
+    readEmailBody: true,
+    openOutlookEmail: true,
+    locateEmail: true,
+    listInboxFolders: true,
+    moveOutlookEmails: true,
+    listOutlookDrafts: true,
+    sendDrafts: true,
+    sendAllDrafts: true,
+    deleteOutlookDrafts: true,
+    deleteOutlookEmails: true,
+    purgeDeletedItems: true,
+    saveEmailAttachment: true,
+    saveEmailAttachments: true,
+    cleanUndeliverableEmails: true,
+    collectBouncedRecipients: true,
+    readSentRecipientGroups: true,
+    readBounceReport: true,
+    listOutlookSignatures: true,
+    readOutlookSignatureHtml: true,
+    readTemplateEmails: true,
+    saveTemplateEmail: true,
+    editEmailTemplate: true,
+};
+exports.OPERATIONS = Object.freeze(Object.keys(OPERATION_NAMES));
+/** This machine's backend, or null where Outlook can't be automated. */
+function platformBackend() {
+    switch (process.platform) {
+        case 'win32':
+            return windows_1.windowsBackend;
+        case 'darwin':
+            return mac_1.macBackend;
+        default:
+            return null;
+    }
+}
+const PLATFORM_BACKEND = platformBackend();
+function dispositionOf(sendImmediately, openDraftWindow) {
+    if ((0, args_1.flag)(sendImmediately, 'sendImmediately', false))
+        return 'send';
+    return (0, args_1.flag)(openDraftWindow, 'openDraftWindow', true) ? 'display' : 'save';
+}
+/** Attachment paths as absolute paths to files that exist — Outlook resolves a relative path against its own directory, not the caller's. */
+function attachmentFiles(value) {
+    return (0, args_1.textList)(value, 'attachments').map(file => {
+        const absolute = path_1.default.resolve(file);
+        let isFile = false;
+        try {
+            isFile = fs_1.default.statSync(absolute).isFile();
+        }
+        catch {
+            // Reported below.
+        }
+        if (!isFile)
+            throw new errors_1.NotFoundError('file', `Attachment file '${absolute}' does not exist.`);
+        return absolute;
+    });
+}
+/**
+ * The operations over one backend. A null backend is a platform without Outlook
+ * automation: every operation rejects with UNSUPPORTED_PLATFORM before looking
+ * at its arguments, since nothing about them could make it work.
+ */
+function createOperations(backendOrNull) {
+    const backend = () => {
+        if (!backendOrNull)
+            throw new errors_1.UnsupportedPlatformError(process.platform);
+        return backendOrNull;
+    };
+    async function saveEmailAttachments(email, fileNames, options) {
+        const platform = backend();
+        const target = (0, args_1.emailLocator)(email);
+        const names = (0, args_1.nameList)(fileNames, 'fileNames');
+        const destDir = (0, args_1.optionalText)((0, args_1.optionsObject)(options).destDir, 'destDir');
+        if (names.length === 0)
+            return [];
+        const destination = (0, runtime_1.attachmentDestination)(destDir === undefined ? undefined : path_1.default.resolve(destDir));
+        try {
+            return await platform.saveEmailAttachments({ email: target, fileNames: names, destDir: destination.dir });
+        }
+        catch (error) {
+            destination.discardIfUnused();
+            throw error;
+        }
+    }
+    return {
+        async getOutlookAccounts() {
+            return backend().getOutlookAccounts();
+        },
+        async sendOutlookEmail(params) {
+            const platform = backend();
+            const p = (0, args_1.requireObject)(params, 'params');
+            const signatureName = (0, args_1.optionalText)(p.signatureName, 'signatureName');
+            const request = {
+                account: (0, args_1.requiredText)(p.emailAccount, 'emailAccount'),
+                to: (0, args_1.recipientList)(p.to, 'to'),
+                cc: (0, args_1.recipientList)(p.cc, 'cc'),
+                bcc: (0, args_1.recipientList)(p.bcc, 'bcc'),
+                subject: (0, args_1.requiredContent)(p.subject, 'subject'),
+                htmlBody: (0, args_1.requiredContent)(p.htmlBody, 'htmlBody'),
+                attachments: attachmentFiles(p.attachments),
+                disposition: dispositionOf(p.sendImmediately, p.openDraftWindow),
+            };
+            if (request.disposition === 'send' && request.to.length + request.cc.length + request.bcc.length === 0) {
+                throw new errors_1.InvalidRequestError('An email sent immediately needs at least one recipient.');
+            }
+            if (signatureName) {
+                request.htmlBody = (0, replyBody_1.placeSignature)(request.htmlBody, await (0, replyBody_1.resolveSignatureHtml)(platform, signatureName));
+            }
+            await platform.sendOutlookEmail(request);
+        },
+        async replyOutlookEmail(params) {
+            const platform = backend();
+            const p = (0, args_1.requireObject)(params, 'params');
+            const account = (0, args_1.requiredText)(p.emailAccount, 'emailAccount');
+            const email = (0, args_1.emailLocator)({ entryId: p.entryId, storeId: p.storeId }, 'params');
+            const html = await (0, replyBody_1.composeReplyHtml)({
+                account,
+                htmlBody: (0, args_1.optionalContent)(p.htmlBody, 'htmlBody'),
+                templateSubject: (0, args_1.optionalText)(p.templateSubject, 'templateSubject'),
+                templateFolder: (0, args_1.optionalText)(p.templateFolder, 'templateFolder') ?? DEFAULTS.templateFolder,
+                templateSection: (0, args_1.optionalText)(p.templateSection, 'templateSection'),
+                templatePlaceholders: (0, args_1.stringRecord)(p.templatePlaceholders, 'templatePlaceholders'),
+                signatureName: (0, args_1.optionalText)(p.signatureName, 'signatureName'),
+            }, platform);
+            return platform.replyOutlookEmail({
+                account,
+                email,
+                html,
+                replyAll: (0, args_1.flag)(p.replyAll, 'replyAll', false),
+                disposition: dispositionOf(p.sendImmediately, p.openDraftWindow),
+            });
+        },
+        async readInboxEmails(emailAccount, options) {
+            const platform = backend();
+            const o = (0, args_1.optionsObject)(options);
+            const { ref, label } = (0, mail_1.folderOption)((0, args_1.optionalText)(o.folder, 'folder'));
+            return platform.readInboxEmails({
+                account: (0, args_1.requiredText)(emailAccount, 'emailAccount'),
+                folder: ref,
+                folderLabel: label,
+                daysBack: (0, args_1.count)(o.daysBack, 'daysBack', DEFAULTS.daysBack, 1, MAX_DAYS),
+                limit: (0, args_1.count)(o.limit, 'limit', DEFAULTS.inboxLimit, 1, 100_000),
+                previewChars: (0, args_1.count)(o.previewChars, 'previewChars', DEFAULTS.previewChars, 0, 1_000_000),
+            });
+        },
+        async searchInboxByFilter(emailAccount, filter) {
+            const platform = backend();
+            const f = (0, args_1.optionsObject)(filter, 'filter');
+            return platform.searchInboxByFilter({
+                account: (0, args_1.requiredText)(emailAccount, 'emailAccount'),
+                daysBack: (0, args_1.count)(f.daysBack, 'daysBack', DEFAULTS.daysBack, 1, MAX_DAYS),
+                subjectLike: (0, args_1.optionalText)(f.subjectLike, 'subjectLike'),
+                subjectPattern: (0, args_1.optionalRegExp)(f.subjectPattern, 'subjectPattern'),
+                excludeReplies: (0, args_1.flag)(f.excludeReplies, 'excludeReplies', false),
+                requireAttachment: (0, args_1.flag)(f.requireAttachment, 'requireAttachment', false),
+                includeFolders: (0, args_1.textList)(f.includeFolders, 'includeFolders'),
+                excludeFolders: (0, args_1.textList)(f.excludeFolders, 'excludeFolders'),
+                includeBody: (0, args_1.flag)(f.includeBody, 'includeBody', true),
+            });
+        },
+        async readSelectedEmail() {
+            return backend().readSelectedEmail();
+        },
+        async readEmailBody(email, options) {
+            const platform = backend();
+            const target = (0, args_1.emailLocator)(email);
+            const o = (0, args_1.optionsObject)(options);
+            const maxChars = (0, args_1.count)(o.maxChars, 'maxChars', DEFAULTS.bodyMaxChars, 1, 100_000_000);
+            const maxQuotedChars = (0, args_1.count)(o.maxQuotedChars, 'maxQuotedChars', DEFAULTS.quotedMaxChars, 0, 100_000_000);
+            const includeQuoted = (0, args_1.flag)(o.includeQuoted, 'includeQuoted', false);
+            const raw = await platform.readEmailBody(target);
+            // The quoted thread is context, never the sender's own answer, so it is
+            // capped by the tighter of the two limits.
+            const { body, quoted, separator } = (0, mail_1.splitQuotedOriginal)(raw.body);
+            return {
+                entryId: raw.entryId,
+                subject: raw.subject,
+                senderName: raw.senderName,
+                senderEmail: raw.senderEmail,
+                receivedTime: raw.receivedTime,
+                body: body.slice(0, maxChars),
+                truncated: body.length > maxChars,
+                bodyLength: body.length,
+                quoteSeparator: separator,
+                quotedLength: quoted.length,
+                quotedOriginal: includeQuoted ? quoted.slice(0, Math.min(maxChars, maxQuotedChars)) : '',
+                attachmentNames: [...raw.attachmentNames],
+                attachmentCount: raw.attachmentNames.length,
+            };
+        },
+        async openOutlookEmail(email) {
+            const platform = backend();
+            await platform.openOutlookEmail((0, args_1.emailLocator)(email));
+        },
+        async locateEmail(description, options) {
+            const platform = backend();
+            const d = (0, args_1.requireObject)(description, 'description');
+            const wanted = {
+                subject: (0, args_1.optionalText)(d.subject, 'subject'),
+                sender: (0, args_1.optionalText)(d.sender, 'sender'),
+                receivedTime: (0, args_1.optionalText)(d.receivedTime, 'receivedTime'),
+            };
+            (0, locate_1.requireDescribed)(wanted);
+            const emailAccount = (0, args_1.optionalText)(d.emailAccount, 'emailAccount');
+            const folderPath = (0, args_1.optionalText)(d.folderPath, 'folderPath');
+            const fallbackDays = (0, args_1.count)((0, args_1.optionsObject)(options).daysBack, 'daysBack', DEFAULTS.daysBack, 1, MAX_DAYS);
+            const search = {
+                daysBack: Math.min(MAX_DAYS, (0, locate_1.daysBackFor)(wanted.receivedTime, fallbackDays)),
+                subjectLike: (0, locate_1.subjectPrefilter)(wanted.subject),
+                excludeReplies: false,
+                requireAttachment: false,
+                includeFolders: [],
+                excludeFolders: [],
+                // Judging a match reads subjects, senders and times, so the bodies
+                // (the heavy part of a scan) are left behind.
+                includeBody: false,
+            };
+            const accounts = emailAccount
+                ? [emailAccount]
+                : (0, locate_1.accountSearchOrder)(await platform.getOutlookAccounts(), folderPath);
+            let searched = 0;
+            let firstFailure;
+            for (const account of accounts) {
+                let matches;
+                try {
+                    matches = await platform.searchInboxByFilter({ account, ...search });
+                }
+                catch (error) {
+                    if (error instanceof errors_1.AbortedError)
+                        throw error;
+                    // One mailbox that can't be read shouldn't decide the answer
+                    // for the rest; only every one failing is an error.
+                    firstFailure ??= error;
+                    continue;
+                }
+                searched++;
+                const found = (0, locate_1.bestMatch)(wanted, matches);
+                if (found)
+                    return found;
+            }
+            if (searched === 0 && firstFailure !== undefined)
+                throw firstFailure;
+            return null;
+        },
+        async listInboxFolders(emailAccount, options) {
+            const platform = backend();
+            const o = (0, args_1.optionsObject)(options);
+            return platform.listInboxFolders({
+                account: (0, args_1.requiredText)(emailAccount, 'emailAccount'),
+                maxDepth: (0, args_1.count)(o.maxDepth, 'maxDepth', DEFAULTS.folderDepth, 1, 10),
+            });
+        },
+        async moveOutlookEmails(emailAccount, entryIds, folder, options) {
+            const platform = backend();
+            const account = (0, args_1.requiredText)(emailAccount, 'emailAccount');
+            const ids = (0, args_1.entryIdList)(entryIds);
+            const { ref, label } = (0, mail_1.folderOption)((0, args_1.requiredText)(folder, 'folder'));
+            const createIfMissing = (0, args_1.flag)((0, args_1.optionsObject)(options).createIfMissing, 'createIfMissing', false);
+            if (ids.length === 0)
+                return { folderPath: '', folderCreated: false, moved: 0, failed: [] };
+            return platform.moveOutlookEmails({
+                account,
+                entryIds: ids,
+                folder: ref,
+                folderLabel: label,
+                createIfMissing
+            });
+        },
+        async listOutlookDrafts(emailAccount, options) {
+            const platform = backend();
+            const o = (0, args_1.optionsObject)(options);
+            return platform.listOutlookDrafts({
+                account: (0, args_1.requiredText)(emailAccount, 'emailAccount'),
+                limit: (0, args_1.count)(o.limit, 'limit', DEFAULTS.draftsLimit, 1, 100_000),
+                previewChars: (0, args_1.count)(o.previewChars, 'previewChars', DEFAULTS.draftsPreviewChars, 0, 1_000_000),
+            });
+        },
+        async sendDrafts(emailAccount, entryIds) {
+            const platform = backend();
+            const account = (0, args_1.requiredText)(emailAccount, 'emailAccount');
+            const ids = (0, args_1.entryIdList)(entryIds);
+            if (ids.length === 0)
+                return { sent: 0, failed: [] };
+            return platform.sendDrafts({ account, entryIds: ids });
+        },
+        async sendAllDrafts(emailAccount) {
+            const platform = backend();
+            return platform.sendAllDrafts({ account: (0, args_1.requiredText)(emailAccount, 'emailAccount') });
+        },
+        async deleteOutlookDrafts(emailAccount, entryIds) {
+            const platform = backend();
+            const account = (0, args_1.requiredText)(emailAccount, 'emailAccount');
+            const ids = (0, args_1.entryIdList)(entryIds);
+            if (ids.length === 0)
+                return { deleted: 0, failed: [] };
+            return platform.deleteOutlookDrafts({ account, entryIds: ids });
+        },
+        async deleteOutlookEmails(emailAccount, entryIds, options) {
+            const platform = backend();
+            const account = (0, args_1.requiredText)(emailAccount, 'emailAccount');
+            const ids = (0, args_1.entryIdList)(entryIds);
+            const o = (0, args_1.optionsObject)(options);
+            const allowProtected = (0, args_1.flag)(o.allowProtected, 'allowProtected', false);
+            const dryRun = (0, args_1.flag)(o.dryRun, 'dryRun', false);
+            if (ids.length === 0)
+                return { dryRun, deleted: 0, refused: 0, failed: 0, items: [] };
+            return platform.deleteOutlookEmails({ account, entryIds: ids, allowProtected, dryRun });
+        },
+        async purgeDeletedItems(emailAccount, options) {
+            const platform = backend();
+            const o = (0, args_1.optionsObject)(options);
+            return platform.purgeDeletedItems({
+                account: (0, args_1.requiredText)(emailAccount, 'emailAccount'),
+                olderThanDays: (0, args_1.count)(o.olderThanDays, 'olderThanDays', 0, 0, 36_500),
+                dryRun: (0, args_1.flag)(o.dryRun, 'dryRun', false),
+            });
+        },
+        async saveEmailAttachment(email, fileName, options) {
+            const [saved] = await saveEmailAttachments(email, [fileName], options);
+            if (!saved)
+                throw new errors_1.NotFoundError('attachment', `Attachment '${fileName}' was not saved.`);
+            return saved;
+        },
+        saveEmailAttachments,
+        async cleanUndeliverableEmails(emailAccount, options) {
+            const platform = backend();
+            const o = (0, args_1.optionsObject)(options);
+            return platform.cleanUndeliverableEmails({
+                account: (0, args_1.requiredText)(emailAccount, 'emailAccount'),
+                daysBack: (0, args_1.count)(o.daysBack, 'daysBack', DEFAULTS.bounceDaysBack, 1, MAX_DAYS),
+                // Deleting has to be asked for.
+                dryRun: (0, args_1.flag)(o.dryRun, 'dryRun', true),
+            });
+        },
+        async collectBouncedRecipients(emailAccount, options) {
+            const platform = backend();
+            const o = (0, args_1.optionsObject)(options);
+            return platform.collectBouncedRecipients({
+                account: (0, args_1.requiredText)(emailAccount, 'emailAccount'),
+                daysBack: (0, args_1.count)(o.daysBack, 'daysBack', DEFAULTS.bounceDaysBack, 1, MAX_DAYS),
+                includeDeletedItems: (0, args_1.flag)(o.includeDeletedItems, 'includeDeletedItems', true),
+            });
+        },
+        async readSentRecipientGroups(emailAccount, options) {
+            const platform = backend();
+            const o = (0, args_1.optionsObject)(options);
+            return platform.readSentRecipientGroups({
+                account: (0, args_1.requiredText)(emailAccount, 'emailAccount'),
+                daysBack: (0, args_1.count)(o.daysBack, 'daysBack', DEFAULTS.bounceDaysBack, 1, MAX_DAYS),
+                limit: (0, args_1.count)(o.limit, 'limit', DEFAULTS.sentGroupsLimit, 1, 100_000),
+            });
+        },
+        async readBounceReport(emailAccount, options) {
+            const platform = backend();
+            const account = (0, args_1.requiredText)(emailAccount, 'emailAccount');
+            const o = (0, args_1.optionsObject)(options);
+            const daysBack = (0, args_1.count)(o.daysBack, 'daysBack', DEFAULTS.bounceDaysBack, 1, MAX_DAYS);
+            const includeDeletedItems = (0, args_1.flag)(o.includeDeletedItems, 'includeDeletedItems', true);
+            const bounced = await platform.collectBouncedRecipients({ account, daysBack, includeDeletedItems });
+            const sent = await platform.readSentRecipientGroups({ account, daysBack, limit: DEFAULTS.sentGroupsLimit });
+            return (0, bounceReport_1.buildBounceReport)(account, daysBack, bounced, sent);
+        },
+        async listOutlookSignatures() {
+            return backend().listOutlookSignatures();
+        },
+        async readOutlookSignatureHtml(name) {
+            const platform = backend();
+            return platform.readOutlookSignatureHtml((0, args_1.requiredText)(name, 'name'));
+        },
+        async readTemplateEmails(emailAccount, options) {
+            const platform = backend();
+            const o = (0, args_1.optionsObject)(options);
+            return platform.readTemplateEmails({
+                account: (0, args_1.requiredText)(emailAccount, 'emailAccount'),
+                folder: (0, args_1.optionalText)(o.folder, 'folder') ?? DEFAULTS.templateFolder,
+                limit: (0, args_1.count)(o.limit, 'limit', DEFAULTS.templatesLimit, 1, 200),
+                includeBody: (0, args_1.flag)(o.includeBody, 'includeBody', true),
+                subject: (0, args_1.optionalText)(o.subject, 'subject'),
+            });
+        },
+        async saveTemplateEmail(emailAccount, template) {
+            const platform = backend();
+            const account = (0, args_1.requiredText)(emailAccount, 'emailAccount');
+            const t = (0, args_1.requireObject)(template, 'template');
+            return platform.saveTemplateEmail({
+                account,
+                folder: (0, args_1.optionalText)(t.folder, 'folder') ?? DEFAULTS.templateFolder,
+                subject: (0, args_1.requiredText)(t.subject, 'subject'),
+                htmlBody: (0, args_1.requiredContent)(t.htmlBody, 'htmlBody'),
+            });
+        },
+        async editEmailTemplate(label, currentHtml) {
+            const platform = backend();
+            return platform.editEmailTemplate({
+                label: (0, args_1.requiredText)(label, 'label'),
+                html: (0, args_1.requiredContent)(currentHtml, 'currentHtml'),
+            });
+        },
+    };
+}
+function capabilityMap(backend) {
+    return Object.freeze(Object.fromEntries(exports.OPERATIONS.map(name => [name, backend !== null])));
+}
+/**
+ * A bridge over `backend` whose every call runs with `config` in force.
+ *
+ * The platform code reads settings through `getConfig()`, so the config is put
+ * in place around each call rather than passed into it: `withConfig` scopes it
+ * to the call's whole async subtree, which is why two bridges with different
+ * settings can run concurrently without seeing each other's.
+ */
+function createBridge(backend, config) {
+    const operations = createOperations(backend);
+    const map = capabilityMap(backend);
+    const instance = {
+        options: Object.freeze({ ...config }),
+        capabilities: () => map,
+        supports: (operation) => map[operation] === true,
+        withOptions: (options) => createBridge(backend, (0, runtime_1.mergeOptions)(config, options)),
+    };
+    for (const name of exports.OPERATIONS) {
+        instance[name] = (...args) => (0, runtime_1.withConfig)(config, () => operations[name](...args));
+    }
+    return instance;
+}
+/**
+ * A bridge with its own settings, isolated from `configure()` and from every
+ * other bridge. Options left out take the process-wide values as they stand
+ * when this is called.
+ *
+ * ```ts
+ * const outlook = createOutlookBridge({ timeoutMs: 30_000 });
+ * const recent = await outlook.readInboxEmails('me@example.com', { daysBack: 7 });
+ * ```
+ */
+function createOutlookBridge(options = {}) {
+    return createBridge(PLATFORM_BACKEND, (0, runtime_1.mergeOptions)((0, runtime_1.getGlobalConfig)(), options));
+}
+const PLATFORM_CAPABILITIES = capabilityMap(PLATFORM_BACKEND);
+/** Which operations work on this machine: all of them on Windows and macOS, none elsewhere. */
+function capabilities() {
+    return PLATFORM_CAPABILITIES;
+}
+/** Whether one operation works on this machine. */
+function supports(operation) {
+    return PLATFORM_CAPABILITIES[operation] === true;
+}
+/** The operations under the process-wide settings — what the package exports as plain functions. */
+exports.defaultBridge = createOperations(PLATFORM_BACKEND);
+//# sourceMappingURL=bridge.js.map