@dereekb/firebase-server 13.31.0 → 13.32.0

package/model/index.esm.js

@@ -1,8 +1,9 @@
-import { mapObjectKeysToLowercase, multiValueMapBuilder, batch, runAsyncTasksForValues, asArray, pushArrayItemsIntoArray, UNSET_INDEX_NUMBER, areEqualPOJOValues, performAsyncTasks, removeValuesAtIndexesFromArrayCopy, takeFront, makeModelMap, computeNextFreeIndexOnSortedValuesFunction, readIndexNumber, asPromise, dateOrMillisecondsToDate, filterOnlyUndefinedValues, iterablesAreSetEquivalent, mapIdentityFunction, makeValuesGroupMap, filterMaybeArrayValues, cutStringFunction, takeLast, separateValues, unique, addMilliseconds, mergeSlashPaths, ModelRelationUtility, isThrottled, isPast, unixDateTimeSecondsNumberFromDate, slashPathDetails, MS_IN_MINUTE, expirationDetails, dateFromDateOrTimeMillisecondsNumber, cachedGetter, MS_IN_HOUR, documentFileExtensionForMimeType, useCallback, ZIP_FILE_MIME_TYPE, MAP_IDENTITY, pushItemOrArrayItemsIntoArray, asDecisionFunction } from '@dereekb/util';
+import { notificationHealthCheckIssue, KnownNotificationHealthCheckIssueCode, NotificationHealthCheckStatus, MailgunNotificationHealthCheckIssueCode, untrackableNotificationHealthCheckProbe, CREATE_NOTIFICATION_ID_REQUIRED_ERROR_CODE, NOTIFICATION_BOX_DOES_NOT_EXIST_ERROR_CODE, NOTIFICATION_BOX_EXCLUSION_TARGET_INVALID_ERROR_CODE, NOTIFICATION_BOX_EXISTS_FOR_MODEL_ERROR_CODE, NOTIFICATION_BOX_RECIPIENT_DOES_NOT_EXIST_ERROR_CODE, NOTIFICATION_MODEL_ALREADY_INITIALIZED_ERROR_CODE, NOTIFICATION_USER_BLOCKED_FROM_BEING_ADD_TO_RECIPIENTS_ERROR_CODE, NOTIFICATION_USER_HEALTH_CHECK_PROBE_THROTTLED_ERROR_CODE, NOTIFICATION_USER_HEALTH_CHECK_THROTTLED_ERROR_CODE, NOTIFICATION_USER_HEALTH_CHECK_VERIFY_THROTTLED_ERROR_CODE, NOTIFICATION_USER_INVALID_UID_FOR_CREATE_ERROR_CODE, NOTIFICATION_USER_LOCKED_CONFIG_FROM_BEING_UPDATED_ERROR_CODE, notificationUserHealthCheckParamsType, rollupNotificationHealthCheckResultStatus, rollupNotificationDeliveryHealthCheckResultStatus, isPendingNotificationHealthCheckProbe, notificationUserHealthCheckNextProbeAt, notificationUserHealthCheckNextVerifyAt, notificationUserHealthCheckNextRunAt, DEFAULT_NOTIFICATION_TEMPLATE_TYPE, NotificationDeliveryMethod, NotificationBoxRecipientFlag, effectiveNotificationBoxRecipientTemplateConfig, firestoreDummyKey, mergeNotificationBoxRecipients, mergeNotificationUserNotificationBoxRecipientConfigs, applyExclusionsToNotificationUserNotificationBoxRecipientConfigs, mergeNotificationBoxRecipientTemplateConfigs, notificationSendExclusionCanSendFunction, mergeNotificationUserDefaultNotificationBoxRecipientConfig, NotificationRecipientSendFlag, allowedNotificationRecipients, loadDocumentsForIds, getDocumentSnapshotDataPairsWithData, cleanupOldNotificationLoggedEventDaysParamsType, cleanupSentNotificationsParamsType, createNotificationBoxParamsType, createNotificationSummaryParamsType, createNotificationUserParamsType, resyncNotificationUserParamsType, sendNotificationParamsType, sendQueuedNotificationsParamsType, updateNotificationBoxParamsType, updateNotificationBoxRecipientParamsType, updateNotificationSummaryParamsType, updateNotificationUserParamsType, updateNotificationUserDefaultNotificationBoxRecipientConfig, effectiveNotificationBoxRecipientConfig, updateNotificationUserNotificationBoxRecipientConfigs, calculateNsForNotificationUserNotificationBoxRecipientConfigs, getDocumentSnapshotDataPairs, iterateFirestoreDocumentSnapshotPairs, notificationUsersFlaggedForNeedsSyncQuery, notificationSummaryIdForModel, loadNotificationBoxDocumentForReferencePair, updateNotificationUserNotificationSendExclusions, notificationBoxRecipientTemplateConfigArrayToRecord, updateNotificationRecipient, setIdAndKeyFromKeyIdRefOnDocumentData, inferKeyFromTwoWayFlatFirestoreModelKey, NotificationSendType, getDocumentSnapshotData, notificationSendFlagsImplyIsComplete, NotificationSendState, mergeNotificationSendMessagesResult, notificationsPastSendAtTimeQuery, loadDocumentsForDocumentReferencesFromValues, notificationLoggedEventDayId, shouldSaveNotificationToNotificationWeek, notificationsReadyForCleanupQuery, notificationLoggedEventDaysOlderThanQuery, initializeAllApplicableNotificationBoxesParamsType, initializeAllApplicableNotificationSummariesParamsType, initializeNotificationModelParamsType, firestoreModelKeyCollectionName, notificationBoxesFlaggedForNeedsInitializationQuery, notificationSummariesFlaggedForNeedsInitializationQuery, noContentNotificationMessageFunctionFactory, _createNotificationDocumentFromPair, createNotificationDocumentPair, NOTIFICATION_SUMMARY_EMBEDDED_NOTIFICATION_ITEM_SUBJECT_MAX_LENGTH, NOTIFICATION_SUMMARY_EMBEDDED_NOTIFICATION_ITEM_MESSAGE_MAX_LENGTH, sortNotificationItemsFunction, NOTIFICATION_SUMMARY_ITEM_LIMIT, NOTIFICATION_TASK_SUBTASK_CHECKPOINT_PROCESSING, NOTIFICATION_TASK_SUBTASK_CHECKPOINT_CLEANUP, completeSubtaskProcessingAndScheduleCleanupTaskResult, delayCompletion, notificationTaskComplete, notificationTaskDelayRetry, DEFAULT_NOTIFICATION_TASK_SUBTASK_CLEANUP_RETRY_DELAY, DEFAULT_NOTIFICATION_TASK_SUBTASK_CLEANUP_RETRY_ATTEMPTS, STORAGE_FILE_GROUP_CREATE_INPUT_ERROR_CODE, STORAGE_FILE_ALREADY_PROCESSED_ERROR_CODE, STORAGE_FILE_CANNOT_BE_DELETED_YET_ERROR_CODE, STORAGE_FILE_GROUP_QUEUED_FOR_INITIALIZATION_ERROR_CODE, STORAGE_FILE_MODEL_ALREADY_INITIALIZED_ERROR_CODE, STORAGE_FILE_NOT_FLAGGED_FOR_DELETION_ERROR_CODE, STORAGE_FILE_NOT_FLAGGED_FOR_GROUPS_SYNC_ERROR_CODE, STORAGE_FILE_PROCESSING_NOT_ALLOWED_FOR_INVALID_STATE_ERROR_CODE, STORAGE_FILE_PROCESSING_NOT_AVAILABLE_FOR_TYPE_ERROR_CODE, STORAGE_FILE_PROCESSING_NOT_QUEUED_FOR_PROCESSING_ERROR_CODE, UPLOADED_FILE_DOES_NOT_EXIST_ERROR_CODE, UPLOADED_FILE_INITIALIZATION_DISCARDED_ERROR_CODE, UPLOADED_FILE_INITIALIZATION_FAILED_ERROR_CODE, UPLOADED_FILE_NOT_ALLOWED_TO_BE_INITIALIZED_ERROR_CODE, createStorageFileParamsType, createStorageFileGroupParamsType, createStorageFileSignedUploadUrlParamsType, deleteAllQueuedStorageFilesParamsType, deleteStorageFileParamsType, downloadMultipleStorageFilesParamsType, downloadStorageFileParamsType, initializeAllStorageFilesFromUploadsParamsType, initializeStorageFileFromUploadParamsType, processAllQueuedStorageFilesParamsType, processStorageFileParamsType, readMultipleStorageFilesMetadataParamsType, readStorageFileMetadataParamsType, regenerateAllFlaggedStorageFileGroupsContentParamsType, regenerateStorageFileGroupContentParamsType, syncAllFlaggedStorageFilesWithGroupsParamsType, syncStorageFileWithGroupsParamsType, updateStorageFileParamsType, updateStorageFileGroupParamsType, UPLOADS_FOLDER_PATH, iterateStorageListFilesByEachFile, StorageFileProcessingState, storageFilesQueuedForProcessingQuery, STORAGE_FILE_PROCESSING_STUCK_THROTTLE_CHECK_MS, StorageFileState, createNotificationDocument, storageFileProcessingNotificationTaskTemplate, storageFilesQueuedForDeleteQuery, loadStorageFileGroupDocumentForReferencePair, calculateStorageFileGroupEmbeddedFileUpdate, iterateFirestoreDocumentSnapshotPairBatches, storageFileFlaggedForSyncWithGroupsQuery, createStorageFileDocumentPairFactory, StorageFileCreationType, storageFileGroupZipFileStoragePath, STORAGE_FILE_GROUP_ZIP_STORAGE_FILE_PURPOSE, calculateStorageFileGroupRegeneration, getDocumentSnapshotDataPair, storageFileGroupsFlaggedForContentRegenerationQuery, DEFAULT_CREATE_STORAGE_FILE_SIGNED_UPLOAD_URL_EXPIRES_IN_MS, CREATE_STORAGE_FILE_SIGNED_UPLOAD_URL_MIN_EXPIRES_IN_MS, CREATE_STORAGE_FILE_SIGNED_UPLOAD_URL_MAX_EXPIRES_IN_MS, CREATE_STORAGE_FILE_SIGNED_UPLOAD_URL_MAX_FILENAME_LENGTH, initializeAllApplicableStorageFileGroupsParamsType, initializeStorageFileModelParamsType, storageFileGroupsFlaggedForNeedsInitializationQuery, STORAGE_FILE_GROUP_ZIP_STORAGE_FILE_PURPOSE_CREATE_ZIP_SUBTASK, storedFileReaderFactory, STORAGE_FILE_PROCESSING_NOTIFICATION_TASK_TYPE, copyStoragePath, notificationSubtaskComplete, STORAGE_FILE_GROUP_ZIP_INFO_JSON_FILE_NAME, limitUploadFileTypeDeterminer, combineUploadFileTypeDeterminers, STORAGEFILE_RELATED_FILE_METADATA_KEY, storageFilePurposeAndUserQuery } from '@dereekb/firebase';
+import { MailgunEventName, mailgunDomainState, mailgunSuppressionsForRecipient, mailgunRecentEventsForRecipient, mailgunValidateEmail, mailgunDomainEventDate, mailgunDomainEventFailureReason, MailgunEventSeverity, mailgunEventsForMessageId, bareMailgunMessageId } from '@dereekb/nestjs/mailgun';
+import { mapObjectKeysToLowercase, multiValueMapBuilder, batch, runAsyncTasksForValues, asArray, pushArrayItemsIntoArray, filterMaybeArrayValues, takeFront, UNSET_INDEX_NUMBER, areEqualPOJOValues, performAsyncTasks, removeValuesAtIndexesFromArrayCopy, makeModelMap, computeNextFreeIndexOnSortedValuesFunction, readIndexNumber, asPromise, dateOrMillisecondsToDate, filterOnlyUndefinedValues, iterablesAreSetEquivalent, mapIdentityFunction, makeValuesGroupMap, cutStringFunction, takeLast, separateValues, unique, addMilliseconds, mergeSlashPaths, ModelRelationUtility, isThrottled, isPast, unixDateTimeSecondsNumberFromDate, slashPathDetails, MS_IN_MINUTE, expirationDetails, dateFromDateOrTimeMillisecondsNumber, cachedGetter, MS_IN_HOUR, documentFileExtensionForMimeType, useCallback, ZIP_FILE_MIME_TYPE, MAP_IDENTITY, pushItemOrArrayItemsIntoArray, asDecisionFunction } from '@dereekb/util';
 import { yearWeekCode, isSameDate, findMaxDate, findMinDate } from '@dereekb/date';
-import { CREATE_NOTIFICATION_ID_REQUIRED_ERROR_CODE, NOTIFICATION_BOX_DOES_NOT_EXIST_ERROR_CODE, NOTIFICATION_BOX_EXCLUSION_TARGET_INVALID_ERROR_CODE, NOTIFICATION_BOX_EXISTS_FOR_MODEL_ERROR_CODE, NOTIFICATION_BOX_RECIPIENT_DOES_NOT_EXIST_ERROR_CODE, NOTIFICATION_MODEL_ALREADY_INITIALIZED_ERROR_CODE, NOTIFICATION_USER_BLOCKED_FROM_BEING_ADD_TO_RECIPIENTS_ERROR_CODE, NOTIFICATION_USER_INVALID_UID_FOR_CREATE_ERROR_CODE, NOTIFICATION_USER_LOCKED_CONFIG_FROM_BEING_UPDATED_ERROR_CODE, firestoreDummyKey, mergeNotificationBoxRecipients, mergeNotificationUserNotificationBoxRecipientConfigs, applyExclusionsToNotificationUserNotificationBoxRecipientConfigs, mergeNotificationBoxRecipientTemplateConfigs, effectiveNotificationBoxRecipientTemplateConfig, notificationSendExclusionCanSendFunction, mergeNotificationUserDefaultNotificationBoxRecipientConfig, DEFAULT_NOTIFICATION_TEMPLATE_TYPE, NotificationRecipientSendFlag, allowedNotificationRecipients, loadDocumentsForIds, getDocumentSnapshotDataPairsWithData, cleanupOldNotificationLoggedEventDaysParamsType, cleanupSentNotificationsParamsType, createNotificationBoxParamsType, createNotificationSummaryParamsType, createNotificationUserParamsType, resyncNotificationUserParamsType, sendNotificationParamsType, sendQueuedNotificationsParamsType, updateNotificationBoxParamsType, updateNotificationBoxRecipientParamsType, updateNotificationSummaryParamsType, updateNotificationUserParamsType, updateNotificationUserDefaultNotificationBoxRecipientConfig, effectiveNotificationBoxRecipientConfig, updateNotificationUserNotificationBoxRecipientConfigs, calculateNsForNotificationUserNotificationBoxRecipientConfigs, getDocumentSnapshotDataPairs, iterateFirestoreDocumentSnapshotPairs, notificationUsersFlaggedForNeedsSyncQuery, notificationSummaryIdForModel, loadNotificationBoxDocumentForReferencePair, updateNotificationUserNotificationSendExclusions, notificationBoxRecipientTemplateConfigArrayToRecord, updateNotificationRecipient, setIdAndKeyFromKeyIdRefOnDocumentData, inferKeyFromTwoWayFlatFirestoreModelKey, NotificationSendType, getDocumentSnapshotData, notificationSendFlagsImplyIsComplete, NotificationSendState, mergeNotificationSendMessagesResult, notificationsPastSendAtTimeQuery, loadDocumentsForDocumentReferencesFromValues, notificationLoggedEventDayId, shouldSaveNotificationToNotificationWeek, notificationsReadyForCleanupQuery, notificationLoggedEventDaysOlderThanQuery, initializeAllApplicableNotificationBoxesParamsType, initializeAllApplicableNotificationSummariesParamsType, initializeNotificationModelParamsType, firestoreModelKeyCollectionName, notificationBoxesFlaggedForNeedsInitializationQuery, notificationSummariesFlaggedForNeedsInitializationQuery, noContentNotificationMessageFunctionFactory, _createNotificationDocumentFromPair, createNotificationDocumentPair, NOTIFICATION_SUMMARY_EMBEDDED_NOTIFICATION_ITEM_SUBJECT_MAX_LENGTH, NOTIFICATION_SUMMARY_EMBEDDED_NOTIFICATION_ITEM_MESSAGE_MAX_LENGTH, sortNotificationItemsFunction, NOTIFICATION_SUMMARY_ITEM_LIMIT, NOTIFICATION_TASK_SUBTASK_CHECKPOINT_PROCESSING, NOTIFICATION_TASK_SUBTASK_CHECKPOINT_CLEANUP, completeSubtaskProcessingAndScheduleCleanupTaskResult, delayCompletion, notificationTaskComplete, notificationTaskDelayRetry, DEFAULT_NOTIFICATION_TASK_SUBTASK_CLEANUP_RETRY_DELAY, DEFAULT_NOTIFICATION_TASK_SUBTASK_CLEANUP_RETRY_ATTEMPTS, STORAGE_FILE_GROUP_CREATE_INPUT_ERROR_CODE, STORAGE_FILE_ALREADY_PROCESSED_ERROR_CODE, STORAGE_FILE_CANNOT_BE_DELETED_YET_ERROR_CODE, STORAGE_FILE_GROUP_QUEUED_FOR_INITIALIZATION_ERROR_CODE, STORAGE_FILE_MODEL_ALREADY_INITIALIZED_ERROR_CODE, STORAGE_FILE_NOT_FLAGGED_FOR_DELETION_ERROR_CODE, STORAGE_FILE_NOT_FLAGGED_FOR_GROUPS_SYNC_ERROR_CODE, STORAGE_FILE_PROCESSING_NOT_ALLOWED_FOR_INVALID_STATE_ERROR_CODE, STORAGE_FILE_PROCESSING_NOT_AVAILABLE_FOR_TYPE_ERROR_CODE, STORAGE_FILE_PROCESSING_NOT_QUEUED_FOR_PROCESSING_ERROR_CODE, UPLOADED_FILE_DOES_NOT_EXIST_ERROR_CODE, UPLOADED_FILE_INITIALIZATION_DISCARDED_ERROR_CODE, UPLOADED_FILE_INITIALIZATION_FAILED_ERROR_CODE, UPLOADED_FILE_NOT_ALLOWED_TO_BE_INITIALIZED_ERROR_CODE, createStorageFileParamsType, createStorageFileGroupParamsType, createStorageFileSignedUploadUrlParamsType, deleteAllQueuedStorageFilesParamsType, deleteStorageFileParamsType, downloadMultipleStorageFilesParamsType, downloadStorageFileParamsType, initializeAllStorageFilesFromUploadsParamsType, initializeStorageFileFromUploadParamsType, processAllQueuedStorageFilesParamsType, processStorageFileParamsType, readMultipleStorageFilesMetadataParamsType, readStorageFileMetadataParamsType, regenerateAllFlaggedStorageFileGroupsContentParamsType, regenerateStorageFileGroupContentParamsType, syncAllFlaggedStorageFilesWithGroupsParamsType, syncStorageFileWithGroupsParamsType, updateStorageFileParamsType, updateStorageFileGroupParamsType, UPLOADS_FOLDER_PATH, iterateStorageListFilesByEachFile, StorageFileProcessingState, storageFilesQueuedForProcessingQuery, STORAGE_FILE_PROCESSING_STUCK_THROTTLE_CHECK_MS, StorageFileState, createNotificationDocument, storageFileProcessingNotificationTaskTemplate, storageFilesQueuedForDeleteQuery, loadStorageFileGroupDocumentForReferencePair, calculateStorageFileGroupEmbeddedFileUpdate, iterateFirestoreDocumentSnapshotPairBatches, storageFileFlaggedForSyncWithGroupsQuery, createStorageFileDocumentPairFactory, StorageFileCreationType, storageFileGroupZipFileStoragePath, STORAGE_FILE_GROUP_ZIP_STORAGE_FILE_PURPOSE, calculateStorageFileGroupRegeneration, getDocumentSnapshotDataPair, storageFileGroupsFlaggedForContentRegenerationQuery, DEFAULT_CREATE_STORAGE_FILE_SIGNED_UPLOAD_URL_EXPIRES_IN_MS, CREATE_STORAGE_FILE_SIGNED_UPLOAD_URL_MIN_EXPIRES_IN_MS, CREATE_STORAGE_FILE_SIGNED_UPLOAD_URL_MAX_EXPIRES_IN_MS, CREATE_STORAGE_FILE_SIGNED_UPLOAD_URL_MAX_FILENAME_LENGTH, initializeAllApplicableStorageFileGroupsParamsType, initializeStorageFileModelParamsType, storageFileGroupsFlaggedForNeedsInitializationQuery, STORAGE_FILE_GROUP_ZIP_STORAGE_FILE_PURPOSE_CREATE_ZIP_SUBTASK, storedFileReaderFactory, STORAGE_FILE_PROCESSING_NOTIFICATION_TASK_TYPE, copyStoragePath, notificationSubtaskComplete, STORAGE_FILE_GROUP_ZIP_INFO_JSON_FILE_NAME, limitUploadFileTypeDeterminer, combineUploadFileTypeDeterminers, STORAGEFILE_RELATED_FILE_METADATA_KEY, storageFilePurposeAndUserQuery } from '@dereekb/firebase';
 import { preconditionConflictError, assertSnapshotData, internalServerError, badRequestError } from '@dereekb/firebase-server';
-import { hoursToMilliseconds, addHours, isFuture, addMinutes, addSeconds, addDays } from 'date-fns';
+import { isAfter, hoursToMilliseconds, addHours, isFuture, addMinutes, addSeconds, addDays } from 'date-fns';
 import { Optional, Inject, Injectable, Module, Global } from '@nestjs/common';
 import { ConfigModule } from '@nestjs/config';
 import { BaseError } from 'make-error';
@@ -11,15 +12,18 @@ import { inflateSync } from 'node:zlib';
 import { PDFName, PDFDocument, PDFRawStream, PDFArray, PDFNumber, PDFStream, PDFDict, PDFRef } from '@cantoo/pdf-lib';
 import archiver from 'archiver';
 
-function _array_like_to_array$a(arr, len) {
+function _array_like_to_array$c(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
     for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
     return arr2;
 }
-function _array_with_holes$4(arr) {
+function _array_with_holes$6(arr) {
     if (Array.isArray(arr)) return arr;
 }
-function asyncGeneratorStep$h(gen, resolve, reject, _next, _throw, key, arg) {
+function _array_without_holes$9(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$c(arr);
+}
+function asyncGeneratorStep$j(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
         var value = info.value;
@@ -33,22 +37,38 @@ function asyncGeneratorStep$h(gen, resolve, reject, _next, _throw, key, arg) {
         Promise.resolve(value).then(_next, _throw);
     }
 }
-function _async_to_generator$h(fn) {
+function _async_to_generator$j(fn) {
     return function() {
         var self = this, args = arguments;
         return new Promise(function(resolve, reject) {
             var gen = fn.apply(self, args);
             function _next(value) {
-                asyncGeneratorStep$h(gen, resolve, reject, _next, _throw, "next", value);
+                asyncGeneratorStep$j(gen, resolve, reject, _next, _throw, "next", value);
             }
             function _throw(err) {
-                asyncGeneratorStep$h(gen, resolve, reject, _next, _throw, "throw", err);
+                asyncGeneratorStep$j(gen, resolve, reject, _next, _throw, "throw", err);
             }
             _next(undefined);
         });
     };
 }
-function _iterable_to_array_limit$4(arr, i) {
+function _define_property$g(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array$9(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _iterable_to_array_limit$6(arr, i) {
     var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
     if (_i == null) return;
     var _arr = [];
@@ -72,21 +92,61 @@ function _iterable_to_array_limit$4(arr, i) {
     }
     return _arr;
 }
-function _non_iterable_rest$4() {
+function _non_iterable_rest$6() {
     throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
-function _sliced_to_array$4(arr, i) {
-    return _array_with_holes$4(arr) || _iterable_to_array_limit$4(arr, i) || _unsupported_iterable_to_array$a(arr, i) || _non_iterable_rest$4();
+function _non_iterable_spread$9() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
-function _unsupported_iterable_to_array$a(o, minLen) {
+function _object_spread$f(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$g(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys$e(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props$e(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys$e(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _sliced_to_array$6(arr, i) {
+    return _array_with_holes$6(arr) || _iterable_to_array_limit$6(arr, i) || _unsupported_iterable_to_array$c(arr, i) || _non_iterable_rest$6();
+}
+function _to_consumable_array$9(arr) {
+    return _array_without_holes$9(arr) || _iterable_to_array$9(arr) || _unsupported_iterable_to_array$c(arr) || _non_iterable_spread$9();
+}
+function _unsupported_iterable_to_array$c(o, minLen) {
     if (!o) return;
-    if (typeof o === "string") return _array_like_to_array$a(o, minLen);
+    if (typeof o === "string") return _array_like_to_array$c(o, minLen);
     var n = Object.prototype.toString.call(o).slice(8, -1);
     if (n === "Object" && o.constructor) n = o.constructor.name;
     if (n === "Map" || n === "Set") return Array.from(n);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$a(o, minLen);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$c(o, minLen);
 }
-function _ts_generator$h(thisArg, body) {
+function _ts_generator$j(thisArg, body) {
     var f, y, t, _ = {
         label: 0,
         sent: function() {
@@ -185,283 +245,2089 @@ function _ts_generator$h(thisArg, body) {
         };
     }
 }
-var DEFAULT_MAILGUN_NOTIFICATION_EMAIL_SEND_SERVICE_MAX_BATCH_SIZE_PER_REQUEST = 50;
 /**
- * Creates a {@link NotificationEmailSendService} that sends notification emails via Mailgun.
+ * How long a dispatched probe may stay unresolved before it is reported as failed.
  *
- * Groups messages by their send template name, batches them (up to `maxBatchSizePerRequest`),
- * converts each batch to a {@link MailgunTemplateEmailRequest} using the configured template builders,
- * and dispatches them through the Mailgun API.
+ * Mailgun normally records a `delivered` or `failed` event within seconds; a probe with no event after
+ * this long is not going to arrive.
+ */ var DEFAULT_MAILGUN_HEALTH_CHECK_PROBE_TIMEOUT_MINUTES = 15;
+/**
+ * Creates a {@link NotificationEmailSendServiceHealthCheckService} backed by the Mailgun API.
  *
- * @param config - Service configuration including the Mailgun service, template builders, and batch size.
- * @returns A {@link NotificationEmailSendService} that batches and sends emails through Mailgun.
+ * Attach the result to a {@link NotificationEmailSendService} as its `healthCheckService` and the
+ * notification health check will pick it up automatically.
+ *
+ * @param config - The Mailgun service plus optional probe builder and inspection limits.
+ * @returns A health check service for the email delivery method.
  *
  * @example
  * ```ts
- * const emailService = mailgunNotificationEmailSendService({
- *   mailgunService,
- *   defaultSendTemplateName: 'notification',
- *   messageBuilders: {
- *     notification: buildNotificationTemplate
- *   }
- * });
- *
- * const sendInstance = await emailService.buildSendInstanceForEmailNotificationMessages(messages);
- * const result = await sendInstance();
+ * const emailSendService = mailgunNotificationEmailSendService({ mailgunService, messageBuilders });
+ *
+ * const sendServiceWithHealthCheck: NotificationEmailSendService = {
+ *   ...emailSendService,
+ *   healthCheckService: mailgunNotificationEmailSendServiceHealthCheckService({
+ *     mailgunService,
+ *     probeBuilder: ({ recipient }) => ({
+ *       to: recipient,
+ *       template: 'notificationtemplate',
+ *       subject: 'Email delivery test'
+ *     })
+ *   })
+ * };
  * ```
- */ function mailgunNotificationEmailSendService(config) {
-    var mailgunService = config.mailgunService, defaultSendTemplateName = config.defaultSendTemplateName, inputMaxBatchSizePerRequest = config.maxBatchSizePerRequest, inputMessageBuilders = config.messageBuilders;
-    var lowercaseKeysMessageBuilders = mapObjectKeysToLowercase(inputMessageBuilders);
-    var maxBatchSizePerRequest = inputMaxBatchSizePerRequest !== null && inputMaxBatchSizePerRequest !== void 0 ? inputMaxBatchSizePerRequest : DEFAULT_MAILGUN_NOTIFICATION_EMAIL_SEND_SERVICE_MAX_BATCH_SIZE_PER_REQUEST;
-    var sendService = {
-        buildSendInstanceForEmailNotificationMessages: function buildSendInstanceForEmailNotificationMessages(notificationMessages) {
-            return _async_to_generator$h(function() {
-                var templateMap, messageSendBatches, templateRequestArrays, templateRequests, sendFn;
-                return _ts_generator$h(this, function(_state) {
+ */ function mailgunNotificationEmailSendServiceHealthCheckService(config) {
+    var mailgunService = config.mailgunService, probeBuilder = config.probeBuilder, recentEventsLimit = config.recentEventsLimit, recentEventsWindowDays = config.recentEventsWindowDays, validateAddress = config.validateAddress, inputProbeTimeoutMinutes = config.probeTimeoutMinutes;
+    var probeTimeoutMinutes = inputProbeTimeoutMinutes !== null && inputProbeTimeoutMinutes !== void 0 ? inputProbeTimeoutMinutes : DEFAULT_MAILGUN_HEALTH_CHECK_PROBE_TIMEOUT_MINUTES;
+    var mailgunApi = mailgunService.mailgunApi;
+    return {
+        supportsProbe: probeBuilder != null,
+        runHealthCheck: function runHealthCheck(request) {
+            return _async_to_generator$j(function() {
+                var // MARK: recent activity
+                _issues, _issues1, target, uid, sendProbe, pendingProbe, now, begin, _ref, domainState, suppressions, recentEvents, validation, issues, bounce, complaint, unsubscribe, probeResult;
+                return _ts_generator$j(this, function(_state) {
                     switch(_state.label){
                         case 0:
-                            templateMap = multiValueMapBuilder();
-                            // group by templates
-                            notificationMessages.forEach(function(x) {
-                                var _ref, _ref1;
-                                var _x_emailContent;
-                                var sendTemplateName = (_ref = (_ref1 = (_x_emailContent = x.emailContent) === null || _x_emailContent === void 0 ? void 0 : _x_emailContent.sendTemplateName) !== null && _ref1 !== void 0 ? _ref1 : x.content.sendTemplateName) !== null && _ref !== void 0 ? _ref : defaultSendTemplateName;
-                                if (sendTemplateName == null) {
-                                    throw new Error("mailgunNotificationEmailSendService(): A sendTemplateName for a message was not available and no default was provided. Consider configuring a default send template.");
-                                }
-                                templateMap.add(sendTemplateName, x);
-                            });
-                            // build send batches
-                            messageSendBatches = templateMap.entries().flatMap(function(param) {
-                                var _param = _sliced_to_array$4(param, 2), templateType = _param[0], messages = _param[1];
-                                return batch(messages, maxBatchSizePerRequest).map(function(x) {
-                                    return [
-                                        templateType,
-                                        x
-                                    ];
-                                });
-                            });
+                            target = request.target, uid = request.uid, sendProbe = request.sendProbe, pendingProbe = request.pendingProbe, now = request.now;
+                            begin = recentEventsWindowDays == null ? undefined : new Date(now.getTime() - recentEventsWindowDays * 24 * 60 * 60 * 1000);
                             return [
                                 4,
-                                Promise.all(messageSendBatches.map(function(param) {
-                                    var _param = _sliced_to_array$4(param, 2), sendTemplateName = _param[0], messages = _param[1];
-                                    return _async_to_generator$h(function() {
-                                        var sendTemplateNameToLowercase, builderForKey, input;
-                                        return _ts_generator$h(this, function(_state) {
-                                            sendTemplateNameToLowercase = sendTemplateName.toLowerCase();
-                                            builderForKey = lowercaseKeysMessageBuilders[sendTemplateNameToLowercase];
-                                            if (builderForKey) {
-                                                input = {
-                                                    mailgunService: mailgunService,
-                                                    sendTemplateName: sendTemplateName,
-                                                    messages: messages
-                                                };
-                                                return [
-                                                    2,
-                                                    builderForKey(input)
-                                                ];
-                                            }
-                                            throw new Error('mailgunNotificationEmailSendService(): A template builder was not available for template type "'.concat(sendTemplateName, '".'));
-                                        });
-                                    })();
-                                }))
+                                Promise.all([
+                                    //
+                                    mailgunDomainState(mailgunApi),
+                                    mailgunSuppressionsForRecipient(mailgunApi, target),
+                                    mailgunRecentEventsForRecipient(mailgunApi, target, {
+                                        limit: recentEventsLimit,
+                                        begin: begin
+                                    }),
+                                    validateAddress ? mailgunValidateEmail(mailgunApi, target) : Promise.resolve(undefined)
+                                ])
                             ];
                         case 1:
-                            templateRequestArrays = _state.sent();
-                            templateRequests = templateRequestArrays.flat();
-                            sendFn = function sendFn() {
-                                return _async_to_generator$h(function() {
-                                    var success, failed, result;
-                                    return _ts_generator$h(this, function(_state) {
-                                        switch(_state.label){
-                                            case 0:
-                                                success = [];
-                                                failed = [];
-                                                // send the template emails
-                                                return [
-                                                    4,
-                                                    runAsyncTasksForValues(templateRequests, function(x) {
-                                                        var recipients = asArray(x.to).map(function(z) {
-                                                            return z.email;
-                                                        });
-                                                        return mailgunService.sendTemplateEmail(x).then(function() {
-                                                            pushArrayItemsIntoArray(success, recipients);
-                                                        }).catch(function(e) {
-                                                            pushArrayItemsIntoArray(failed, recipients);
-                                                            console.error('mailgunNotificationEmailSendService(): failed sending template emails', e);
-                                                        // suppress error
-                                                        });
-                                                    }, {
-                                                        maxParallelTasks: 3
-                                                    })
-                                                ];
-                                            case 1:
-                                                _state.sent();
-                                                result = {
-                                                    success: success,
-                                                    failed: failed,
-                                                    ignored: []
-                                                };
-                                                return [
-                                                    2,
-                                                    result
-                                                ];
+                            _ref = _sliced_to_array$6.apply(void 0, [
+                                _state.sent(),
+                                4
+                            ]), domainState = _ref[0], suppressions = _ref[1], recentEvents = _ref[2], validation = _ref[3];
+                            issues = [];
+                            // MARK: domain
+                            if (domainState.unknown) {
+                                issues.push(notificationHealthCheckIssue(KnownNotificationHealthCheckIssueCode.SEND_SERVICE_HEALTH_CHECK_UNAVAILABLE, NotificationHealthCheckStatus.UNKNOWN, {
+                                    message: 'The email provider could not be reached to confirm the sending domain is healthy.',
+                                    data: {
+                                        domain: domainState.domain
+                                    }
+                                }));
+                            } else if (domainState.disabled || domainState.state != null && domainState.state !== 'active') {
+                                issues.push(notificationHealthCheckIssue(MailgunNotificationHealthCheckIssueCode.DOMAIN_NOT_ACTIVE, NotificationHealthCheckStatus.ERROR, {
+                                    message: 'The system that sends our email is not currently active, so no email is going out to anyone.',
+                                    fix: 'This is a system-wide problem. Contact support so it can be escalated.',
+                                    data: {
+                                        domain: domainState.domain,
+                                        state: domainState.state,
+                                        disabled: domainState.disabled
+                                    }
+                                }));
+                            }
+                            // MARK: suppressions
+                            bounce = suppressions.bounce, complaint = suppressions.complaint, unsubscribe = suppressions.unsubscribe;
+                            if (bounce) {
+                                issues.push(notificationHealthCheckIssue(MailgunNotificationHealthCheckIssueCode.SUPPRESSED_BOUNCE, NotificationHealthCheckStatus.ERROR, {
+                                    message: 'Email to this address previously bounced, so our email provider is now blocking every message to it.',
+                                    fix: 'Contact support to have the block removed. If the address has a typo, correct it on your account first.',
+                                    data: {
+                                        address: bounce.address,
+                                        code: bounce.code,
+                                        error: bounce.error,
+                                        createdAt: bounce.created_at
+                                    }
+                                }));
+                            }
+                            if (complaint) {
+                                issues.push(notificationHealthCheckIssue(MailgunNotificationHealthCheckIssueCode.SUPPRESSED_COMPLAINT, NotificationHealthCheckStatus.ERROR, {
+                                    message: 'One of our emails was reported as spam from this address, so our email provider is now blocking every message to it.',
+                                    fix: 'Contact support to have the block removed.',
+                                    data: {
+                                        address: complaint.address,
+                                        createdAt: complaint.created_at
+                                    }
+                                }));
+                            }
+                            if (unsubscribe) {
+                                issues.push(notificationHealthCheckIssue(MailgunNotificationHealthCheckIssueCode.SUPPRESSED_UNSUBSCRIBE, NotificationHealthCheckStatus.WARNING, {
+                                    message: 'This address has unsubscribed from our email, so most messages will not be delivered to it.',
+                                    fix: 'Contact support to resubscribe this address.',
+                                    data: {
+                                        address: unsubscribe.address,
+                                        tags: unsubscribe.tags,
+                                        createdAt: unsubscribe.created_at
+                                    }
+                                }));
+                            }
+                            (_issues = issues).push.apply(_issues, _to_consumable_array$9(recentEventActivityIssues(recentEvents)));
+                            // MARK: validation
+                            if (validation) {
+                                if (validation.result === 'undeliverable') {
+                                    issues.push(notificationHealthCheckIssue(MailgunNotificationHealthCheckIssueCode.ADDRESS_UNDELIVERABLE, NotificationHealthCheckStatus.ERROR, {
+                                        message: 'This address does not appear to be able to receive email.',
+                                        fix: 'Check the address for typos and correct it on your account.',
+                                        data: {
+                                            address: validation.address,
+                                            result: validation.result,
+                                            risk: validation.risk,
+                                            reason: validation.reason
                                         }
-                                    });
-                                })();
-                            };
+                                    }));
+                                }
+                                if (validation.is_disposable_address) {
+                                    issues.push(notificationHealthCheckIssue(MailgunNotificationHealthCheckIssueCode.ADDRESS_DISPOSABLE, NotificationHealthCheckStatus.WARNING, {
+                                        message: 'This address belongs to a disposable email service, which often stops accepting mail after a short time.',
+                                        fix: 'Use a permanent email address for notifications.',
+                                        data: {
+                                            address: validation.address
+                                        }
+                                    }));
+                                }
+                            }
+                            return [
+                                4,
+                                resolveProbe({
+                                    mailgunService: mailgunService,
+                                    probeBuilder: probeBuilder,
+                                    probeTimeoutMinutes: probeTimeoutMinutes,
+                                    target: target,
+                                    uid: uid,
+                                    sendProbe: sendProbe,
+                                    pendingProbe: pendingProbe,
+                                    now: now
+                                })
+                            ];
+                        case 2:
+                            probeResult = _state.sent();
+                            (_issues1 = issues).push.apply(_issues1, _to_consumable_array$9(probeResult.issues));
                             return [
                                 2,
-                                sendFn
+                                {
+                                    issues: issues,
+                                    probe: probeResult.probe
+                                }
                             ];
                     }
                 });
             })();
         }
     };
-    return sendService;
-}
-
-/**
- * Creates an error indicating that a required notification ID was missing during creation.
- *
- * Thrown when attempting to create a {@link Notification} document without providing the mandatory ID field.
- *
- * @returns A precondition conflict error with the notification ID required error code.
- */ function createNotificationIdRequiredError() {
-    return preconditionConflictError({
-        message: "The required id was not present when attempting to create a Notification.",
-        code: CREATE_NOTIFICATION_ID_REQUIRED_ERROR_CODE
-    });
 }
 /**
- * Creates an error indicating that a notification model (box or summary) has already been initialized.
- *
- * Thrown during initialization when `throwErrorIfAlreadyInitialized` is true and the model's
- * setup flag (`s`) indicates it was previously initialized.
- *
- * @returns A precondition conflict error with the already-initialized error code.
- */ function notificationModelAlreadyInitializedError() {
-    return preconditionConflictError({
-        message: "This model has already been initialized.",
-        code: NOTIFICATION_MODEL_ALREADY_INITIALIZED_ERROR_CODE
-    });
-}
+ * Mailgun event names that settle a message's fate. Anything else (`accepted`, `opened`, …) leaves the
+ * outcome still open.
+ */ var CONCLUSIVE_MAILGUN_EVENT_NAMES = new Set([
+    MailgunEventName.DELIVERED,
+    MailgunEventName.FAILED,
+    MailgunEventName.REJECTED
+]);
 /**
- * Creates an error indicating that a {@link NotificationBox} is associated with an unregistered model type.
- *
- * Thrown when the model key's collection name does not match any registered notification model type.
+ * Formats a failure reason as a sentence suffix.
  *
- * @param key - The Firestore model key that has no registered notification model type.
- * @returns A precondition conflict error with the unregistered model type error code.
- */ function notificationBoxUnregistredModelTypeInitializationError(key) {
-    return preconditionConflictError({
-        message: "This NotificationBox is associated with an unregistered model type.",
-        code: NOTIFICATION_MODEL_ALREADY_INITIALIZED_ERROR_CODE,
-        data: {
-            key: key
-        }
-    });
+ * @param reason - The provider's explanation, when it recorded one.
+ * @returns `: <reason>` when a reason is available, otherwise a full stop.
+ */ function failureReasonSuffix(reason) {
+    return reason ? ": ".concat(reason) : '.';
 }
 /**
- * Creates an error indicating that no {@link NotificationBox} exists for the target model.
- *
- * Thrown when an operation requires a NotificationBox but none has been created for the given model key.
- *
- * @returns A precondition conflict error with the box-not-found error code.
- */ function notificationBoxDoesNotExist() {
-    return preconditionConflictError({
-        message: "A NotificationBox does not exist for this model.",
-        code: NOTIFICATION_BOX_DOES_NOT_EXIST_ERROR_CODE
+ * Classifies a recipient's recent Mailgun events into findings.
+ *
+ * The most recent conclusive event is what matters: a delivery after a failure means the problem is
+ * already resolved, so an old failure should not be reported as a current one.
+ *
+ * @param recentEvents - The recipient's recent events, newest first.
+ * @returns The findings describing the recipient's recent email activity.
+ */ function recentEventActivityIssues(recentEvents) {
+    if (!recentEvents.length) {
+        return [
+            notificationHealthCheckIssue(MailgunNotificationHealthCheckIssueCode.NO_RECENT_ACTIVITY, NotificationHealthCheckStatus.WARNING, {
+                message: 'No email has been sent to this address recently, so the problem is more likely to be in what triggers the notifications than in the email itself.',
+                fix: 'Check the settings above, and contact support if you expected to receive something.'
+            })
+        ];
+    }
+    // events come back newest-first
+    var conclusiveEvent = recentEvents.find(function(x) {
+        return CONCLUSIVE_MAILGUN_EVENT_NAMES.has(x.event);
     });
+    if (!conclusiveEvent) {
+        return [
+            notificationHealthCheckIssue(MailgunNotificationHealthCheckIssueCode.NO_RECENT_ACTIVITY, NotificationHealthCheckStatus.UNKNOWN, {
+                message: 'Recent email to this address has been accepted for delivery, but no delivery outcome has been recorded yet.',
+                data: {
+                    eventCount: recentEvents.length
+                }
+            })
+        ];
+    }
+    var eventDate = mailgunDomainEventDate(conclusiveEvent);
+    if (conclusiveEvent.event === MailgunEventName.DELIVERED) {
+        return [
+            notificationHealthCheckIssue(MailgunNotificationHealthCheckIssueCode.RECENT_DELIVERY_SUCCESS, NotificationHealthCheckStatus.OK, {
+                message: 'Our email provider successfully delivered email to this address recently.',
+                fix: 'If you still cannot find it, check your spam or junk folder and any email filters or rules you have set up.',
+                data: {
+                    deliveredAt: eventDate
+                }
+            })
+        ];
+    }
+    var reason = mailgunDomainEventFailureReason(conclusiveEvent);
+    var isPermanent = conclusiveEvent.severity === MailgunEventSeverity.PERMANENT;
+    return [
+        notificationHealthCheckIssue(MailgunNotificationHealthCheckIssueCode.RECENT_DELIVERY_FAILURE, isPermanent ? NotificationHealthCheckStatus.ERROR : NotificationHealthCheckStatus.WARNING, {
+            message: "The last email we sent to this address did not get through".concat(failureReasonSuffix(reason)),
+            fix: isPermanent ? 'This will not resolve on its own. Check the address for typos, then contact support.' : 'This is often temporary. Re-run this check later to see if it clears.',
+            data: {
+                event: conclusiveEvent.event,
+                severity: conclusiveEvent.severity,
+                reason: reason,
+                at: eventDate
+            }
+        })
+    ];
 }
 /**
- * Creates an error indicating that the exclusion target is invalid.
+ * Resolves an in-flight probe, or dispatches a new one.
  *
- * Thrown when the target recipient on the {@link NotificationBox} does not exist on the box
- * or does not have a UID, making it ineligible for exclusion.
+ * Resolving takes priority over dispatching: if a probe is already in flight there is no reason to send
+ * a second message to the same inbox.
  *
- * @returns A precondition conflict error with the invalid exclusion target error code.
- */ function notificationBoxExclusionTargetInvalidError() {
-    return preconditionConflictError({
-        message: "The target for exclusion is invalid. The target recipient on the NotificationBox must be exist on the NotificationBox and have a uid to be excluded.",
-        code: NOTIFICATION_BOX_EXCLUSION_TARGET_INVALID_ERROR_CODE
-    });
+ * @param input - The probe target, whether dispatching is permitted, and any probe already in flight.
+ * @returns The probe findings and the resulting probe state.
+ */ function resolveProbe(input) {
+    return _async_to_generator$j(function() {
+        var sendProbe, pendingProbe, result;
+        return _ts_generator$j(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    sendProbe = input.sendProbe, pendingProbe = input.pendingProbe;
+                    if (!pendingProbe) return [
+                        3,
+                        2
+                    ];
+                    return [
+                        4,
+                        resolvePendingProbe(input, pendingProbe)
+                    ];
+                case 1:
+                    result = _state.sent();
+                    return [
+                        3,
+                        5
+                    ];
+                case 2:
+                    if (!sendProbe) return [
+                        3,
+                        4
+                    ];
+                    return [
+                        4,
+                        dispatchProbe(input)
+                    ];
+                case 3:
+                    result = _state.sent();
+                    return [
+                        3,
+                        5
+                    ];
+                case 4:
+                    result = {
+                        issues: []
+                    };
+                    _state.label = 5;
+                case 5:
+                    return [
+                        2,
+                        result
+                    ];
+            }
+        });
+    })();
+}
+/**
+ * Looks up the outcome of a probe that was dispatched by an earlier run.
+ *
+ * An empty event list means Mailgun has not recorded an outcome *yet*, not that the message failed —
+ * only once the probe has outlived its timeout is silence treated as a failure.
+ *
+ * @param input - The probe target and timeout.
+ * @param pendingProbe - The probe awaiting an outcome.
+ * @returns The probe findings and the probe's updated state.
+ */ function resolvePendingProbe(input, pendingProbe) {
+    return _async_to_generator$j(function() {
+        var mailgunService, probeTimeoutMinutes, target, now, events, delivered, failure, probeAgeMinutes, result, reason;
+        return _ts_generator$j(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    mailgunService = input.mailgunService, probeTimeoutMinutes = input.probeTimeoutMinutes, target = input.target, now = input.now;
+                    return [
+                        4,
+                        mailgunEventsForMessageId(mailgunService.mailgunApi, pendingProbe.id, {
+                            recipient: target
+                        })
+                    ];
+                case 1:
+                    events = _state.sent();
+                    delivered = events.find(function(x) {
+                        return x.event === MailgunEventName.DELIVERED;
+                    });
+                    failure = events.find(function(x) {
+                        return x.event === MailgunEventName.FAILED || x.event === MailgunEventName.REJECTED;
+                    });
+                    probeAgeMinutes = (now.getTime() - pendingProbe.at.getTime()) / (60 * 1000);
+                    if (delivered) {
+                        result = {
+                            issues: [
+                                notificationHealthCheckIssue(KnownNotificationHealthCheckIssueCode.PROBE_DELIVERED, NotificationHealthCheckStatus.OK, {
+                                    message: 'The test email we sent was delivered successfully.',
+                                    fix: 'If it is not in your inbox, check your spam or junk folder and any email filters you have set up.',
+                                    data: {
+                                        deliveredAt: mailgunDomainEventDate(delivered)
+                                    }
+                                })
+                            ],
+                            probe: _object_spread_props$e(_object_spread$f({}, pendingProbe), {
+                                s: NotificationHealthCheckStatus.OK,
+                                d: 'Delivered'
+                            })
+                        };
+                    } else if (failure) {
+                        reason = mailgunDomainEventFailureReason(failure);
+                        result = {
+                            issues: [
+                                notificationHealthCheckIssue(KnownNotificationHealthCheckIssueCode.PROBE_FAILED, NotificationHealthCheckStatus.ERROR, {
+                                    message: "The test email we sent did not get through".concat(failureReasonSuffix(reason)),
+                                    fix: 'Check the address for typos, then contact support with this report.',
+                                    data: {
+                                        event: failure.event,
+                                        severity: failure.severity,
+                                        reason: reason
+                                    }
+                                })
+                            ],
+                            probe: _object_spread_props$e(_object_spread$f({}, pendingProbe), {
+                                s: NotificationHealthCheckStatus.ERROR,
+                                d: reason !== null && reason !== void 0 ? reason : 'Delivery failed'
+                            })
+                        };
+                    } else if (probeAgeMinutes > probeTimeoutMinutes) {
+                        result = {
+                            issues: [
+                                notificationHealthCheckIssue(KnownNotificationHealthCheckIssueCode.PROBE_FAILED, NotificationHealthCheckStatus.ERROR, {
+                                    message: 'The test email we sent never reached a delivery result, which means it did not arrive.',
+                                    fix: 'Contact support with this report.',
+                                    data: {
+                                        dispatchedAt: pendingProbe.at,
+                                        probeTimeoutMinutes: probeTimeoutMinutes
+                                    }
+                                })
+                            ],
+                            probe: _object_spread_props$e(_object_spread$f({}, pendingProbe), {
+                                s: NotificationHealthCheckStatus.ERROR,
+                                d: 'No delivery result recorded'
+                            })
+                        };
+                    } else {
+                        result = {
+                            issues: [
+                                notificationHealthCheckIssue(KnownNotificationHealthCheckIssueCode.PROBE_PENDING, NotificationHealthCheckStatus.PENDING, {
+                                    message: 'We sent a test email and are still waiting to hear whether it arrived.',
+                                    fix: 'Nothing to do — the result appears here on its own as soon as our email provider reports it.',
+                                    data: {
+                                        dispatchedAt: pendingProbe.at
+                                    }
+                                })
+                            ],
+                            probe: pendingProbe
+                        };
+                    }
+                    return [
+                        2,
+                        result
+                    ];
+            }
+        });
+    })();
+}
+/**
+ * Records a dispatch attempt that produced nothing to track it by.
+ *
+ * A probe is recorded all the same, with no correlation id and a status that is already settled. That
+ * matters beyond the report: the test message window is derived from the recorded probe's `at`, so an
+ * attempt that recorded nothing would leave both the server's throttle and the client's countdown with
+ * nothing to key on — the action would come back looking successful and be immediately repeatable, one
+ * provider call per click. An attempt is an attempt whether or not it can be followed up.
+ *
+ * The provider's own status distinguishes the two very different cases: a send it accepted but did not
+ * give an id for (typical of an environment with sending suppressed, where the address is probably fine
+ * and simply unverifiable), and a send it refused outright (a real failure, reported as one).
+ *
+ * @param sendResult - What the provider returned for the send.
+ * @param input - The probe target and dispatch time.
+ * @returns The finding describing the attempt, and the settled probe recording it.
+ */ function dispatchWithoutMessageIdResult(sendResult, input) {
+    var target = input.target, now = input.now;
+    var status = sendResult.status, message = sendResult.message;
+    var accepted = status != null && status >= 200 && status < 300;
+    var data = {
+        status: status,
+        message: message
+    };
+    var probeStatus = accepted ? NotificationHealthCheckStatus.UNKNOWN : NotificationHealthCheckStatus.ERROR;
+    return {
+        issues: accepted ? [
+            notificationHealthCheckIssue(KnownNotificationHealthCheckIssueCode.PROBE_DISPATCH_FAILED, NotificationHealthCheckStatus.UNKNOWN, {
+                message: 'Our email provider accepted the test email but did not give us a way to track it, so we cannot confirm whether it arrives.',
+                fix: 'Check your inbox — and your spam or junk folder — for a test email sent just now.',
+                data: data
+            })
+        ] : [
+            notificationHealthCheckIssue(KnownNotificationHealthCheckIssueCode.PROBE_DISPATCH_FAILED, NotificationHealthCheckStatus.ERROR, {
+                message: "Our email provider refused to send the test email".concat(failureReasonSuffix(message)),
+                fix: 'Contact support with this report.',
+                data: data
+            })
+        ],
+        probe: untrackableNotificationHealthCheckProbe({
+            at: now,
+            s: probeStatus,
+            tg: target,
+            d: accepted ? 'Sent, but not trackable' : message !== null && message !== void 0 ? message : 'Refused by the email provider'
+        })
+    };
+}
+/**
+ * Sends a new probe message and records it as pending.
+
+/**
+ * Sends a new probe message and records it as pending.
+ *
+ * @param input - The probe target and message builder.
+ * @returns The probe findings and the newly dispatched probe, if one could be sent.
+ */ function dispatchProbe(input) {
+    return _async_to_generator$j(function() {
+        var mailgunService, probeBuilder, target, uid, now, recipient, result, request, sendResult, messageId, e;
+        return _ts_generator$j(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    mailgunService = input.mailgunService, probeBuilder = input.probeBuilder, target = input.target, uid = input.uid, now = input.now;
+                    if (!probeBuilder) {
+                        return [
+                            2,
+                            {
+                                issues: [
+                                    notificationHealthCheckIssue(MailgunNotificationHealthCheckIssueCode.PROBE_NOT_CONFIGURED, NotificationHealthCheckStatus.SKIPPED, {
+                                        message: 'Sending a test email is not available on this system.',
+                                        data: {
+                                            target: target
+                                        }
+                                    })
+                                ]
+                            }
+                        ];
+                    }
+                    recipient = {
+                        email: target
+                    };
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        4,
+                        ,
+                        5
+                    ]);
+                    return [
+                        4,
+                        probeBuilder({
+                            mailgunService: mailgunService,
+                            recipient: recipient,
+                            uid: uid
+                        })
+                    ];
+                case 2:
+                    request = _state.sent();
+                    return [
+                        4,
+                        mailgunService.sendTemplateEmail(request)
+                    ];
+                case 3:
+                    sendResult = _state.sent();
+                    messageId = sendResult.id;
+                    result = messageId ? {
+                        issues: [
+                            notificationHealthCheckIssue(KnownNotificationHealthCheckIssueCode.PROBE_PENDING, NotificationHealthCheckStatus.PENDING, {
+                                message: 'We just sent a test email to this address, and our email provider accepted it for delivery.',
+                                fix: 'Nothing to do — the result appears here on its own as soon as our email provider reports it.',
+                                data: {
+                                    dispatchedAt: now,
+                                    status: sendResult.status
+                                }
+                            })
+                        ],
+                        probe: {
+                            id: bareMailgunMessageId(messageId),
+                            at: now,
+                            s: NotificationHealthCheckStatus.PENDING,
+                            tg: target
+                        }
+                    } : dispatchWithoutMessageIdResult(sendResult, input);
+                    return [
+                        3,
+                        5
+                    ];
+                case 4:
+                    e = _state.sent();
+                    // recorded like any other attempt, so the window applies — a provider that is throwing is the last
+                    // one that should be called again on the user's next click
+                    result = {
+                        issues: [
+                            notificationHealthCheckIssue(KnownNotificationHealthCheckIssueCode.PROBE_DISPATCH_FAILED, NotificationHealthCheckStatus.ERROR, {
+                                message: 'The test email could not be sent at all, which points to a problem with our email system rather than your address.',
+                                fix: 'Contact support with this report.',
+                                data: {
+                                    error: "".concat(e)
+                                }
+                            })
+                        ],
+                        probe: untrackableNotificationHealthCheckProbe({
+                            at: now,
+                            s: NotificationHealthCheckStatus.ERROR,
+                            tg: target,
+                            d: 'Could not be sent'
+                        })
+                    };
+                    return [
+                        3,
+                        5
+                    ];
+                case 5:
+                    return [
+                        2,
+                        result
+                    ];
+            }
+        });
+    })();
+}
+
+function _array_like_to_array$b(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes$5(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function asyncGeneratorStep$i(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$i(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$i(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$i(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _iterable_to_array_limit$5(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest$5() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array$5(arr, i) {
+    return _array_with_holes$5(arr) || _iterable_to_array_limit$5(arr, i) || _unsupported_iterable_to_array$b(arr, i) || _non_iterable_rest$5();
+}
+function _unsupported_iterable_to_array$b(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$b(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$b(o, minLen);
+}
+function _ts_generator$i(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var DEFAULT_MAILGUN_NOTIFICATION_EMAIL_SEND_SERVICE_MAX_BATCH_SIZE_PER_REQUEST = 50;
+/**
+ * Creates a {@link NotificationEmailSendService} that sends notification emails via Mailgun.
+ *
+ * Groups messages by their send template name, batches them (up to `maxBatchSizePerRequest`),
+ * converts each batch to a {@link MailgunTemplateEmailRequest} using the configured template builders,
+ * and dispatches them through the Mailgun API.
+ *
+ * @param config - Service configuration including the Mailgun service, template builders, and batch size.
+ * @returns A {@link NotificationEmailSendService} that batches and sends emails through Mailgun.
+ *
+ * @example
+ * ```ts
+ * const emailService = mailgunNotificationEmailSendService({
+ *   mailgunService,
+ *   defaultSendTemplateName: 'notification',
+ *   messageBuilders: {
+ *     notification: buildNotificationTemplate
+ *   }
+ * });
+ *
+ * const sendInstance = await emailService.buildSendInstanceForEmailNotificationMessages(messages);
+ * const result = await sendInstance();
+ * ```
+ */ function mailgunNotificationEmailSendService(config) {
+    var mailgunService = config.mailgunService, defaultSendTemplateName = config.defaultSendTemplateName, inputMaxBatchSizePerRequest = config.maxBatchSizePerRequest, inputMessageBuilders = config.messageBuilders;
+    var lowercaseKeysMessageBuilders = mapObjectKeysToLowercase(inputMessageBuilders);
+    var maxBatchSizePerRequest = inputMaxBatchSizePerRequest !== null && inputMaxBatchSizePerRequest !== void 0 ? inputMaxBatchSizePerRequest : DEFAULT_MAILGUN_NOTIFICATION_EMAIL_SEND_SERVICE_MAX_BATCH_SIZE_PER_REQUEST;
+    var sendService = {
+        buildSendInstanceForEmailNotificationMessages: function buildSendInstanceForEmailNotificationMessages(notificationMessages) {
+            return _async_to_generator$i(function() {
+                var templateMap, messageSendBatches, templateRequestArrays, templateRequests, sendFn;
+                return _ts_generator$i(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            templateMap = multiValueMapBuilder();
+                            // group by templates
+                            notificationMessages.forEach(function(x) {
+                                var _ref, _ref1;
+                                var _x_emailContent;
+                                var sendTemplateName = (_ref = (_ref1 = (_x_emailContent = x.emailContent) === null || _x_emailContent === void 0 ? void 0 : _x_emailContent.sendTemplateName) !== null && _ref1 !== void 0 ? _ref1 : x.content.sendTemplateName) !== null && _ref !== void 0 ? _ref : defaultSendTemplateName;
+                                if (sendTemplateName == null) {
+                                    throw new Error("mailgunNotificationEmailSendService(): A sendTemplateName for a message was not available and no default was provided. Consider configuring a default send template.");
+                                }
+                                templateMap.add(sendTemplateName, x);
+                            });
+                            // build send batches
+                            messageSendBatches = templateMap.entries().flatMap(function(param) {
+                                var _param = _sliced_to_array$5(param, 2), templateType = _param[0], messages = _param[1];
+                                return batch(messages, maxBatchSizePerRequest).map(function(x) {
+                                    return [
+                                        templateType,
+                                        x
+                                    ];
+                                });
+                            });
+                            return [
+                                4,
+                                Promise.all(messageSendBatches.map(function(param) {
+                                    var _param = _sliced_to_array$5(param, 2), sendTemplateName = _param[0], messages = _param[1];
+                                    return _async_to_generator$i(function() {
+                                        var sendTemplateNameToLowercase, builderForKey, input;
+                                        return _ts_generator$i(this, function(_state) {
+                                            sendTemplateNameToLowercase = sendTemplateName.toLowerCase();
+                                            builderForKey = lowercaseKeysMessageBuilders[sendTemplateNameToLowercase];
+                                            if (builderForKey) {
+                                                input = {
+                                                    mailgunService: mailgunService,
+                                                    sendTemplateName: sendTemplateName,
+                                                    messages: messages
+                                                };
+                                                return [
+                                                    2,
+                                                    builderForKey(input)
+                                                ];
+                                            }
+                                            throw new Error('mailgunNotificationEmailSendService(): A template builder was not available for template type "'.concat(sendTemplateName, '".'));
+                                        });
+                                    })();
+                                }))
+                            ];
+                        case 1:
+                            templateRequestArrays = _state.sent();
+                            templateRequests = templateRequestArrays.flat();
+                            sendFn = function sendFn() {
+                                return _async_to_generator$i(function() {
+                                    var success, failed, result;
+                                    return _ts_generator$i(this, function(_state) {
+                                        switch(_state.label){
+                                            case 0:
+                                                success = [];
+                                                failed = [];
+                                                // send the template emails
+                                                return [
+                                                    4,
+                                                    runAsyncTasksForValues(templateRequests, function(x) {
+                                                        var recipients = asArray(x.to).map(function(z) {
+                                                            return z.email;
+                                                        });
+                                                        return mailgunService.sendTemplateEmail(x).then(function() {
+                                                            pushArrayItemsIntoArray(success, recipients);
+                                                        }).catch(function(e) {
+                                                            pushArrayItemsIntoArray(failed, recipients);
+                                                            console.error('mailgunNotificationEmailSendService(): failed sending template emails', e);
+                                                        // suppress error
+                                                        });
+                                                    }, {
+                                                        maxParallelTasks: 3
+                                                    })
+                                                ];
+                                            case 1:
+                                                _state.sent();
+                                                result = {
+                                                    success: success,
+                                                    failed: failed,
+                                                    ignored: []
+                                                };
+                                                return [
+                                                    2,
+                                                    result
+                                                ];
+                                        }
+                                    });
+                                })();
+                            };
+                            return [
+                                2,
+                                sendFn
+                            ];
+                    }
+                });
+            })();
+        }
+    };
+    return sendService;
+}
+
+/**
+ * Creates an error indicating that a required notification ID was missing during creation.
+ *
+ * Thrown when attempting to create a {@link Notification} document without providing the mandatory ID field.
+ *
+ * @returns A precondition conflict error with the notification ID required error code.
+ */ function createNotificationIdRequiredError() {
+    return preconditionConflictError({
+        message: "The required id was not present when attempting to create a Notification.",
+        code: CREATE_NOTIFICATION_ID_REQUIRED_ERROR_CODE
+    });
+}
+/**
+ * Creates an error indicating that a notification model (box or summary) has already been initialized.
+ *
+ * Thrown during initialization when `throwErrorIfAlreadyInitialized` is true and the model's
+ * setup flag (`s`) indicates it was previously initialized.
+ *
+ * @returns A precondition conflict error with the already-initialized error code.
+ */ function notificationModelAlreadyInitializedError() {
+    return preconditionConflictError({
+        message: "This model has already been initialized.",
+        code: NOTIFICATION_MODEL_ALREADY_INITIALIZED_ERROR_CODE
+    });
+}
+/**
+ * Creates an error indicating that a {@link NotificationBox} is associated with an unregistered model type.
+ *
+ * Thrown when the model key's collection name does not match any registered notification model type.
+ *
+ * @param key - The Firestore model key that has no registered notification model type.
+ * @returns A precondition conflict error with the unregistered model type error code.
+ */ function notificationBoxUnregistredModelTypeInitializationError(key) {
+    return preconditionConflictError({
+        message: "This NotificationBox is associated with an unregistered model type.",
+        code: NOTIFICATION_MODEL_ALREADY_INITIALIZED_ERROR_CODE,
+        data: {
+            key: key
+        }
+    });
+}
+/**
+ * Creates an error indicating that no {@link NotificationBox} exists for the target model.
+ *
+ * Thrown when an operation requires a NotificationBox but none has been created for the given model key.
+ *
+ * @returns A precondition conflict error with the box-not-found error code.
+ */ function notificationBoxDoesNotExist() {
+    return preconditionConflictError({
+        message: "A NotificationBox does not exist for this model.",
+        code: NOTIFICATION_BOX_DOES_NOT_EXIST_ERROR_CODE
+    });
+}
+/**
+ * Creates an error indicating that the exclusion target is invalid.
+ *
+ * Thrown when the target recipient on the {@link NotificationBox} does not exist on the box
+ * or does not have a UID, making it ineligible for exclusion.
+ *
+ * @returns A precondition conflict error with the invalid exclusion target error code.
+ */ function notificationBoxExclusionTargetInvalidError() {
+    return preconditionConflictError({
+        message: "The target for exclusion is invalid. The target recipient on the NotificationBox must be exist on the NotificationBox and have a uid to be excluded.",
+        code: NOTIFICATION_BOX_EXCLUSION_TARGET_INVALID_ERROR_CODE
+    });
+}
+/**
+ * Creates an error indicating that a {@link NotificationBox} already exists for this model.
+ *
+ * Thrown when attempting to create a duplicate NotificationBox for a model that already has one.
+ *
+ * @returns A precondition conflict error with the box-exists error code.
+ */ function notificationBoxExistsForModelError() {
+    return preconditionConflictError({
+        message: "A NotificationBox already exists for this model.",
+        code: NOTIFICATION_BOX_EXISTS_FOR_MODEL_ERROR_CODE
+    });
+}
+/**
+ * Creates an error indicating that the target recipient does not exist on the {@link NotificationBox}.
+ *
+ * Thrown when attempting to update a recipient that is not registered on the box
+ * and `insert=true` was not passed to allow creating a new recipient entry.
+ *
+ * @returns A precondition conflict error with the recipient-not-found error code.
+ */ function notificationBoxRecipientDoesNotExistsError() {
+    return preconditionConflictError({
+        message: "An existing NotificationBox recipient for the target does not exist. You must pass insert=true to create a new recipient.",
+        code: NOTIFICATION_BOX_RECIPIENT_DOES_NOT_EXIST_ERROR_CODE
+    });
+}
+/**
+ * Creates an error indicating that a health check was run again before its throttle window passed.
+ *
+ * Thrown by the {@link NotificationUser} health check when the stored check is too recent.
+ *
+ * @param nextRunAt - The time the next health check may be run.
+ * @returns A precondition conflict error with the health-check-throttled error code.
+ */ function notificationUserHealthCheckThrottledError(nextRunAt) {
+    return preconditionConflictError({
+        message: "A notification delivery health check was run too recently. The next one can be run at ".concat(nextRunAt.toISOString(), "."),
+        code: NOTIFICATION_USER_HEALTH_CHECK_THROTTLED_ERROR_CODE,
+        data: {
+            // serialized: the error's data travels to the client as JSON
+            nextRunAt: nextRunAt.toISOString()
+        }
+    });
+}
+/**
+ * Creates an error indicating that a test message was requested again before its throttle window passed.
+ *
+ * Thrown by the {@link NotificationUser} health check when a probe was dispatched too recently. Separate
+ * from {@link notificationUserHealthCheckThrottledError}: running the check does not consume the test
+ * message allowance.
+ *
+ * @param nextProbeAt - The time the next test message may be dispatched.
+ * @returns A precondition conflict error with the probe-throttled error code.
+ */ function notificationUserHealthCheckProbeThrottledError(nextProbeAt) {
+    return preconditionConflictError({
+        message: "A notification delivery test message was sent too recently. The next one can be sent at ".concat(nextProbeAt.toISOString(), "."),
+        code: NOTIFICATION_USER_HEALTH_CHECK_PROBE_THROTTLED_ERROR_CODE,
+        data: {
+            // serialized: the error's data travels to the client as JSON
+            nextProbeAt: nextProbeAt.toISOString()
+        }
+    });
+}
+/**
+ * Creates an error indicating that pending probes were verified again before their throttle window passed.
+ *
+ * Thrown by the {@link NotificationUser} health check on a `verifyPendingProbesOnly` run that arrives too
+ * soon after the last one. Separate from {@link notificationUserHealthCheckThrottledError}: verifying an
+ * in-flight test message is a poll, so it neither answers to nor consumes the user's run allowance.
+ *
+ * @param nextVerifyAt - The time the next verification may be run.
+ * @returns A precondition conflict error with the verify-throttled error code.
+ */ function notificationUserHealthCheckVerifyThrottledError(nextVerifyAt) {
+    return preconditionConflictError({
+        message: "The pending notification delivery test messages were verified too recently. The next verification can be run at ".concat(nextVerifyAt.toISOString(), "."),
+        code: NOTIFICATION_USER_HEALTH_CHECK_VERIFY_THROTTLED_ERROR_CODE,
+        data: {
+            // serialized: the error's data travels to the client as JSON
+            nextVerifyAt: nextVerifyAt.toISOString()
+        }
+    });
+}
+/**
+ * Creates an error indicating that the given UID does not correspond to an existing Firebase Auth user.
+ *
+ * Thrown during {@link NotificationUser} creation when the provided UID cannot be found in Firebase Auth.
+ *
+ * @param uid - The Firebase Auth user ID that was not found.
+ * @returns A precondition conflict error with the invalid-uid error code.
+ */ function notificationUserInvalidUidForCreateError(uid) {
+    return preconditionConflictError({
+        message: "The user with the uid '".concat(uid, "' does not exist. Cannot create a NotificationUser for them."),
+        code: NOTIFICATION_USER_INVALID_UID_FOR_CREATE_ERROR_CODE,
+        data: {
+            uid: uid
+        }
+    });
+}
+/**
+ * Creates an error indicating that the user has blocked themselves from being added as a recipient.
+ *
+ * Thrown when a {@link NotificationUser} has the `bk` (blocked-from-add) flag set on their config
+ * and an operation attempts to insert them into a {@link NotificationBox}'s recipient list.
+ *
+ * @param uid - The Firebase Auth user ID of the blocked user.
+ * @returns A precondition conflict error with the blocked-from-add error code.
+ */ function notificationUserBlockedFromBeingAddedToRecipientsError(uid) {
+    return preconditionConflictError({
+        message: "The user with the uid '".concat(uid, "' has blocked themselves from from being added recipients."),
+        code: NOTIFICATION_USER_BLOCKED_FROM_BEING_ADD_TO_RECIPIENTS_ERROR_CODE,
+        data: {
+            uid: uid
+        }
+    });
+}
+/**
+ * Creates an error indicating that the user has locked their notification configuration from external updates.
+ *
+ * Thrown when a {@link NotificationUser} has the `lk` (locked) flag set on their config
+ * and an operation attempts to modify their recipient settings on a {@link NotificationBox}.
+ *
+ * @param uid - The Firebase Auth user ID of the locked user.
+ * @returns A precondition conflict error with the locked-config error code.
+ */ function notificationUserLockedConfigFromBeingUpdatedError(uid) {
+    return preconditionConflictError({
+        message: "The user with the uid '".concat(uid, "' has locked their config from being updated."),
+        code: NOTIFICATION_USER_LOCKED_CONFIG_FROM_BEING_UPDATED_ERROR_CODE,
+        data: {
+            uid: uid
+        }
+    });
+}
+
+function _array_like_to_array$a(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes$4(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _array_without_holes$8(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$a(arr);
+}
+function asyncGeneratorStep$h(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$h(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$h(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$h(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _define_property$f(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array$8(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _iterable_to_array_limit$4(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest$4() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _non_iterable_spread$8() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread$e(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$f(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys$d(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props$d(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys$d(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _sliced_to_array$4(arr, i) {
+    return _array_with_holes$4(arr) || _iterable_to_array_limit$4(arr, i) || _unsupported_iterable_to_array$a(arr, i) || _non_iterable_rest$4();
+}
+function _to_consumable_array$8(arr) {
+    return _array_without_holes$8(arr) || _iterable_to_array$8(arr) || _unsupported_iterable_to_array$a(arr) || _non_iterable_spread$8();
+}
+function _unsupported_iterable_to_array$a(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$a(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$a(o, minLen);
+}
+function _ts_generator$h(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+/**
+ * The maximum number of the user's notification boxes to inspect in a single health check.
+ *
+ * A user can be subscribed to an unbounded number of boxes; a health check is interactive, so it
+ * samples rather than walking all of them.
+ */ var DEFAULT_MAX_NOTIFICATION_BOXES_TO_INSPECT_PER_HEALTH_CHECK = 10;
+/**
+ * Issue codes that describe a delivery probe rather than a configuration finding.
+ *
+ * A verify-only run refreshes these and carries every other finding forward unchanged.
+ */ var PROBE_NOTIFICATION_HEALTH_CHECK_ISSUE_CODES = new Set([
+    KnownNotificationHealthCheckIssueCode.PROBE_PENDING,
+    KnownNotificationHealthCheckIssueCode.PROBE_DELIVERED,
+    KnownNotificationHealthCheckIssueCode.PROBE_FAILED,
+    KnownNotificationHealthCheckIssueCode.PROBE_DISPATCH_FAILED
+]);
+/**
+ * Factory for the `healthCheck` action on a {@link NotificationUser}.
+ *
+ * @param context - The notification server actions context.
+ * @returns A transform-and-validate function that runs a delivery health check for a notification user.
+ */ function notificationUserHealthCheckFactory(context) {
+    var firebaseServerActionTransformFunctionFactory = context.firebaseServerActionTransformFunctionFactory, notificationBoxCollection = context.notificationBoxCollection, notificationSendService = context.notificationSendService, authService = context.authService, notificationUserHealthCheckConfig = context.notificationUserHealthCheckConfig;
+    var probeThrottleMinutes = notificationUserHealthCheckConfig === null || notificationUserHealthCheckConfig === void 0 ? void 0 : notificationUserHealthCheckConfig.probeThrottleMinutes;
+    var runThrottleMinutes = notificationUserHealthCheckConfig === null || notificationUserHealthCheckConfig === void 0 ? void 0 : notificationUserHealthCheckConfig.runThrottleMinutes;
+    var verifyThrottleSeconds = notificationUserHealthCheckConfig === null || notificationUserHealthCheckConfig === void 0 ? void 0 : notificationUserHealthCheckConfig.verifyThrottleSeconds;
+    return firebaseServerActionTransformFunctionFactory(notificationUserHealthCheckParamsType, function(params) {
+        return _async_to_generator$h(function() {
+            var inputMethods, inputSendProbe, inputVerifyPendingProbesOnly, inputNotificationTemplateType, inputSkipSubscriptionChecks, inputForce, inputReturnFullHealthCheck, sendProbe, verifyPendingProbesOnly, skipSubscriptionChecks, force;
+            return _ts_generator$h(this, function(_state) {
+                inputMethods = params.methods, inputSendProbe = params.sendProbe, inputVerifyPendingProbesOnly = params.verifyPendingProbesOnly, inputNotificationTemplateType = params.notificationTemplateType, inputSkipSubscriptionChecks = params.skipSubscriptionChecks, inputForce = params.force, inputReturnFullHealthCheck = params.returnFullHealthCheck;
+                sendProbe = inputSendProbe === true;
+                verifyPendingProbesOnly = inputVerifyPendingProbesOnly === true;
+                skipSubscriptionChecks = inputSkipSubscriptionChecks === true || verifyPendingProbesOnly;
+                // Privileged, and unverifiable from here: the action cannot see who is calling, so the API layer is
+                // responsible for clearing this unless the caller is an admin. See NotificationUserHealthCheckParams.
+                force = inputForce === true;
+                return [
+                    2,
+                    function(notificationUserDocument) {
+                        return _async_to_generator$h(function() {
+                            var _ref, _ref1, _ref2, _ref3, now, notificationUser, uid, previousHealthCheck, nextProbeAt, nextVerifyAt, nextRunAt, notificationTemplateType, authDetails, methodContexts, requestedMethods, methodContextsToCheck, subscriptions, _tmp, disabledMethodsByBox, accountIssues, probesDispatched, probesResolved, methodResults, freshResultsByMethod, mergedMethodResults, healthCheck, probedMethods, returnFullHealthCheck, returnedHealthCheck;
+                            return _ts_generator$h(this, function(_state) {
+                                switch(_state.label){
+                                    case 0:
+                                        now = new Date();
+                                        return [
+                                            4,
+                                            assertSnapshotData(notificationUserDocument)
+                                        ];
+                                    case 1:
+                                        notificationUser = _state.sent();
+                                        uid = notificationUser.uid, previousHealthCheck = notificationUser.hc;
+                                        // Runs, test messages and verifications are throttled independently, because they cost different
+                                        // things: a run reads provider state, a probe delivers a real message, and a verification only asks
+                                        // a provider what became of a message already sent. None of them may consume another's allowance —
+                                        // in particular, polling an in-flight test message must not push the user's next run out, which is
+                                        // why a verify-only run answers to its own window and advances `vat` rather than `at` below.
+                                        //
+                                        // The probe window is scoped to the methods being probed, since each method has its own test
+                                        // message action — a test email must not hold the test text message off.
+                                        //
+                                        // `force` skips every window, so an admin diagnosing someone else's delivery does not have to wait
+                                        // out that user's own throttle.
+                                        if (!force) {
+                                            if (sendProbe) {
+                                                nextProbeAt = notificationUserHealthCheckNextProbeAt({
+                                                    healthCheck: previousHealthCheck,
+                                                    methods: inputMethods,
+                                                    throttleMinutes: probeThrottleMinutes
+                                                });
+                                                if (nextProbeAt != null && isAfter(nextProbeAt, now)) {
+                                                    throw notificationUserHealthCheckProbeThrottledError(nextProbeAt);
+                                                }
+                                            } else if (verifyPendingProbesOnly) {
+                                                nextVerifyAt = notificationUserHealthCheckNextVerifyAt({
+                                                    healthCheck: previousHealthCheck,
+                                                    throttleSeconds: verifyThrottleSeconds
+                                                });
+                                                if (nextVerifyAt != null && isAfter(nextVerifyAt, now)) {
+                                                    throw notificationUserHealthCheckVerifyThrottledError(nextVerifyAt);
+                                                }
+                                            } else {
+                                                nextRunAt = notificationUserHealthCheckNextRunAt({
+                                                    healthCheck: previousHealthCheck,
+                                                    throttleMinutes: runThrottleMinutes
+                                                });
+                                                if (nextRunAt != null && isAfter(nextRunAt, now)) {
+                                                    throw notificationUserHealthCheckThrottledError(nextRunAt);
+                                                }
+                                            }
+                                        }
+                                        notificationTemplateType = inputNotificationTemplateType || DEFAULT_NOTIFICATION_TEMPLATE_TYPE;
+                                        return [
+                                            4,
+                                            authService.userContext(uid).loadDetails().catch(function() {
+                                                return undefined;
+                                            })
+                                        ];
+                                    case 2:
+                                        authDetails = _state.sent();
+                                        methodContexts = buildNotificationDeliveryMethodContexts({
+                                            notificationUser: notificationUser,
+                                            notificationSendService: notificationSendService,
+                                            authEmail: authDetails === null || authDetails === void 0 ? void 0 : authDetails.email,
+                                            authPhone: authDetails === null || authDetails === void 0 ? void 0 : authDetails.phoneNumber,
+                                            uid: uid
+                                        });
+                                        requestedMethods = (inputMethods === null || inputMethods === void 0 ? void 0 : inputMethods.length) ? new Set(inputMethods) : undefined;
+                                        methodContextsToCheck = methodContexts.filter(function(x) {
+                                            return requestedMethods ? requestedMethods.has(x.method) : true;
+                                        });
+                                        if (!skipSubscriptionChecks) return [
+                                            3,
+                                            3
+                                        ];
+                                        _tmp = undefined;
+                                        return [
+                                            3,
+                                            5
+                                        ];
+                                    case 3:
+                                        return [
+                                            4,
+                                            inspectNotificationUserSubscriptions({
+                                                notificationUser: notificationUser,
+                                                notificationBoxCollection: notificationBoxCollection,
+                                                notificationTemplateType: notificationTemplateType
+                                            })
+                                        ];
+                                    case 4:
+                                        _tmp = _state.sent();
+                                        _state.label = 5;
+                                    case 5:
+                                        subscriptions = _tmp;
+                                        disabledMethodsByBox = (_ref = subscriptions === null || subscriptions === void 0 ? void 0 : subscriptions.issuesByMethod) !== null && _ref !== void 0 ? _ref : new Map();
+                                        accountIssues = verifyPendingProbesOnly ? _to_consumable_array$8((_ref1 = previousHealthCheck === null || previousHealthCheck === void 0 ? void 0 : previousHealthCheck.is) !== null && _ref1 !== void 0 ? _ref1 : []) : //
+                                        _to_consumable_array$8(notificationUserAccountIssues({
+                                            notificationUser: notificationUser,
+                                            accountDisabled: (authDetails === null || authDetails === void 0 ? void 0 : authDetails.disabled) === true,
+                                            accountExists: authDetails != null
+                                        })).concat(_to_consumable_array$8((_ref2 = subscriptions === null || subscriptions === void 0 ? void 0 : subscriptions.sharedIssues) !== null && _ref2 !== void 0 ? _ref2 : []));
+                                        // MARK: per-method
+                                        probesDispatched = 0;
+                                        probesResolved = 0;
+                                        return [
+                                            4,
+                                            Promise.all(methodContextsToCheck.map(function(methodContext) {
+                                                return _async_to_generator$h(function() {
+                                                    var _ref, _disabledMethodsByBox_get, method, target, label, sendServiceConfigured, healthCheckService, previousMethodResult, previousProbe, pendingProbe, providerHasSomethingToReport, willConsultProvider, issues, probe, // on a verify-only run only the probe findings are refreshed
+                                                    _issues, response, e, methodResult;
+                                                    return _ts_generator$h(this, function(_state) {
+                                                        switch(_state.label){
+                                                            case 0:
+                                                                method = methodContext.method, target = methodContext.target, label = methodContext.label, sendServiceConfigured = methodContext.sendServiceConfigured, healthCheckService = methodContext.healthCheckService;
+                                                                previousMethodResult = previousHealthCheck === null || previousHealthCheck === void 0 ? void 0 : previousHealthCheck.m.find(function(x) {
+                                                                    return x.me === method;
+                                                                });
+                                                                previousProbe = previousMethodResult === null || previousMethodResult === void 0 ? void 0 : previousMethodResult.pr;
+                                                                pendingProbe = isPendingNotificationHealthCheckProbe(previousProbe) ? previousProbe : undefined;
+                                                                // A verify-only run is a poll of an in-flight test message, so it consults a provider only
+                                                                // where there is actually a probe to ask about. With nothing pending it costs no provider
+                                                                // calls at all, which is what makes it cheap enough to be polled on a short window.
+                                                                providerHasSomethingToReport = !verifyPendingProbesOnly || pendingProbe != null;
+                                                                // whether the provider will be consulted, and so whether fresh probe findings are coming
+                                                                willConsultProvider = healthCheckService != null && target != null && providerHasSomethingToReport;
+                                                                // A verify-only run carries the previous findings forward. The stale probe findings are only
+                                                                // dropped when the provider is actually going to replace them — otherwise the method would
+                                                                // lose its probe explanation while still reporting the probe itself.
+                                                                issues = verifyPendingProbesOnly ? ((_ref = previousMethodResult === null || previousMethodResult === void 0 ? void 0 : previousMethodResult.is) !== null && _ref !== void 0 ? _ref : []).filter(function(x) {
+                                                                    return !(willConsultProvider && isProbeIssueCode(x.c));
+                                                                }) : _to_consumable_array$8(notificationDeliveryMethodConfigIssues({
+                                                                    methodContext: methodContext,
+                                                                    notificationUser: notificationUser,
+                                                                    notificationTemplateType: notificationTemplateType
+                                                                })).concat(_to_consumable_array$8((_disabledMethodsByBox_get = disabledMethodsByBox.get(method)) !== null && _disabledMethodsByBox_get !== void 0 ? _disabledMethodsByBox_get : []));
+                                                                // keep any previously resolved probe visible unless the provider supplies a newer one
+                                                                probe = previousProbe;
+                                                                if (!(healthCheckService && target != null && providerHasSomethingToReport)) return [
+                                                                    3,
+                                                                    5
+                                                                ];
+                                                                _state.label = 1;
+                                                            case 1:
+                                                                _state.trys.push([
+                                                                    1,
+                                                                    3,
+                                                                    ,
+                                                                    4
+                                                                ]);
+                                                                return [
+                                                                    4,
+                                                                    healthCheckService.runHealthCheck({
+                                                                        method: method,
+                                                                        target: target,
+                                                                        uid: uid,
+                                                                        sendProbe: sendProbe,
+                                                                        pendingProbe: pendingProbe,
+                                                                        notificationTemplateType: notificationTemplateType,
+                                                                        now: now
+                                                                    })
+                                                                ];
+                                                            case 2:
+                                                                response = _state.sent();
+                                                                (_issues = issues).push.apply(_issues, _to_consumable_array$8(verifyPendingProbesOnly ? response.issues.filter(function(x) {
+                                                                    return isProbeIssueCode(x.c);
+                                                                }) : response.issues));
+                                                                if (response.probe) {
+                                                                    probe = response.probe;
+                                                                    // A probe the provider gave no correlation id for cannot be told apart from the last one
+                                                                    // by id, so the dispatch time is what settles whether this is a new attempt.
+                                                                    if (response.probe.id !== (previousProbe === null || previousProbe === void 0 ? void 0 : previousProbe.id) || response.probe.at.getTime() !== (previousProbe === null || previousProbe === void 0 ? void 0 : previousProbe.at.getTime())) {
+                                                                        probesDispatched += 1;
+                                                                    } else if (pendingProbe && !isPendingNotificationHealthCheckProbe(response.probe)) {
+                                                                        probesResolved += 1;
+                                                                    }
+                                                                }
+                                                                return [
+                                                                    3,
+                                                                    4
+                                                                ];
+                                                            case 3:
+                                                                e = _state.sent();
+                                                                issues.push(notificationHealthCheckIssue(KnownNotificationHealthCheckIssueCode.SEND_SERVICE_HEALTH_CHECK_UNAVAILABLE, NotificationHealthCheckStatus.UNKNOWN, {
+                                                                    message: "The ".concat(label.toLowerCase(), " provider could not be reached, so its delivery status is unknown."),
+                                                                    fix: 'Try again in a few minutes. If this keeps happening, the delivery provider may be having an outage.',
+                                                                    data: {
+                                                                        error: "".concat(e)
+                                                                    }
+                                                                }));
+                                                                return [
+                                                                    3,
+                                                                    4
+                                                                ];
+                                                            case 4:
+                                                                return [
+                                                                    3,
+                                                                    6
+                                                                ];
+                                                            case 5:
+                                                                if (sendServiceConfigured && !healthCheckService && !verifyPendingProbesOnly && target != null) {
+                                                                    issues.push(notificationHealthCheckIssue(KnownNotificationHealthCheckIssueCode.SEND_SERVICE_HEALTH_CHECK_UNAVAILABLE, NotificationHealthCheckStatus.SKIPPED, {
+                                                                        message: "".concat(label, " delivery could not be verified with the provider, so only your settings were checked."),
+                                                                        data: {
+                                                                            method: method
+                                                                        }
+                                                                    }));
+                                                                }
+                                                                _state.label = 6;
+                                                            case 6:
+                                                                methodResult = {
+                                                                    me: method,
+                                                                    s: rollupNotificationDeliveryHealthCheckResultStatus({
+                                                                        is: issues,
+                                                                        pr: probe
+                                                                    }),
+                                                                    tg: target == null ? undefined : String(target),
+                                                                    is: issues,
+                                                                    pr: probe,
+                                                                    // whether probing is supported is only knowable here, so it is reported for a client that
+                                                                    // offers a per-method test message action. A supporting provider with nothing to deliver to
+                                                                    // still cannot be probed.
+                                                                    pb: (healthCheckService === null || healthCheckService === void 0 ? void 0 : healthCheckService.supportsProbe) === true && target != null ? true : undefined
+                                                                };
+                                                                return [
+                                                                    2,
+                                                                    methodResult
+                                                                ];
+                                                        }
+                                                    });
+                                                })();
+                                            }))
+                                        ];
+                                    case 6:
+                                        methodResults = _state.sent();
+                                        // A run can be scoped to a subset of methods (a probe poll usually is). Carry forward the
+                                        // previous result for every method that was not re-checked so the stored health check stays a
+                                        // complete picture rather than shrinking to whatever was last asked about.
+                                        freshResultsByMethod = new Map(methodResults.map(function(x) {
+                                            return [
+                                                x.me,
+                                                x
+                                            ];
+                                        }));
+                                        mergedMethodResults = filterMaybeArrayValues(methodContexts.map(function(x) {
+                                            var _freshResultsByMethod_get;
+                                            return (_freshResultsByMethod_get = freshResultsByMethod.get(x.method)) !== null && _freshResultsByMethod_get !== void 0 ? _freshResultsByMethod_get : previousHealthCheck === null || previousHealthCheck === void 0 ? void 0 : previousHealthCheck.m.find(function(y) {
+                                                return y.me === x.method;
+                                            });
+                                        }));
+                                        healthCheck = {
+                                            // A verify-only run refreshes the probe findings of the check that is already stored rather than
+                                            // producing a new diagnosis, so it leaves `at` — and with it the user's run window — where it
+                                            // was. Only `vat` moves, which is what a poll paces itself against.
+                                            at: verifyPendingProbesOnly ? (_ref3 = previousHealthCheck === null || previousHealthCheck === void 0 ? void 0 : previousHealthCheck.at) !== null && _ref3 !== void 0 ? _ref3 : now : now,
+                                            vat: now,
+                                            s: rollupNotificationHealthCheckResultStatus({
+                                                is: accountIssues,
+                                                m: mergedMethodResults
+                                            }),
+                                            t: notificationTemplateType,
+                                            is: accountIssues,
+                                            m: mergedMethodResults
+                                        };
+                                        return [
+                                            4,
+                                            notificationUserDocument.update({
+                                                hc: healthCheck
+                                            })
+                                        ];
+                                    case 7:
+                                        _state.sent();
+                                        // The complete check is what gets STORED; what comes BACK can be narrower. A probe run is about one
+                                        // method's test message, and a client renders the report from the document anyway, so returning the
+                                        // whole account's diagnosis is payload the caller did not ask for.
+                                        //
+                                        // The same predicate as the `pb` flag, so what is returned matches what the client was told it could
+                                        // test. An empty set means nothing probe-capable was in scope, and then there is no narrower answer
+                                        // to give than the diagnosis explaining why nothing was sent.
+                                        probedMethods = new Set(sendProbe ? methodContextsToCheck.filter(function(x) {
+                                            var _x_healthCheckService;
+                                            return ((_x_healthCheckService = x.healthCheckService) === null || _x_healthCheckService === void 0 ? void 0 : _x_healthCheckService.supportsProbe) === true && x.target != null;
+                                        }).map(function(x) {
+                                            return x.method;
+                                        }) : []);
+                                        returnFullHealthCheck = inputReturnFullHealthCheck === true || !sendProbe || probedMethods.size === 0;
+                                        returnedHealthCheck = returnFullHealthCheck ? healthCheck : narrowNotificationHealthCheckToMethods(healthCheck, probedMethods);
+                                        return [
+                                            2,
+                                            {
+                                                healthCheck: returnedHealthCheck,
+                                                probesDispatched: probesDispatched,
+                                                probesResolved: probesResolved
+                                            }
+                                        ];
+                                }
+                            });
+                        })();
+                    }
+                ];
+            });
+        })();
+    });
 }
 /**
- * Creates an error indicating that a {@link NotificationBox} already exists for this model.
- *
- * Thrown when attempting to create a duplicate NotificationBox for a model that already has one.
- *
- * @returns A precondition conflict error with the box-exists error code.
- */ function notificationBoxExistsForModelError() {
-    return preconditionConflictError({
-        message: "A NotificationBox already exists for this model.",
-        code: NOTIFICATION_BOX_EXISTS_FOR_MODEL_ERROR_CODE
+ * Narrows a health check down to a subset of its delivery methods.
+ *
+ * Used for the result of a test message call, which is about the method it just sent through rather than
+ * the whole account. `s` is re-rolled over the methods that are kept so the returned check is
+ * self-consistent, and the account-wide findings are dropped — they are not what the call was about. Only
+ * ever applied to the RETURNED value; the stored check keeps every method and finding.
+ *
+ * @param healthCheck - The complete check.
+ * @param methods - The delivery methods to keep.
+ * @returns The check, covering only those methods.
+ */ function narrowNotificationHealthCheckToMethods(healthCheck, methods) {
+    var m = healthCheck.m.filter(function(x) {
+        return methods.has(x.me);
+    });
+    return _object_spread_props$d(_object_spread$e({}, healthCheck), {
+        is: [],
+        m: m,
+        s: rollupNotificationHealthCheckResultStatus({
+            is: [],
+            m: m
+        })
     });
 }
 /**
- * Creates an error indicating that the target recipient does not exist on the {@link NotificationBox}.
- *
- * Thrown when attempting to update a recipient that is not registered on the box
- * and `insert=true` was not passed to allow creating a new recipient entry.
- *
- * @returns A precondition conflict error with the recipient-not-found error code.
- */ function notificationBoxRecipientDoesNotExistsError() {
-    return preconditionConflictError({
-        message: "An existing NotificationBox recipient for the target does not exist. You must pass insert=true to create a new recipient.",
-        code: NOTIFICATION_BOX_RECIPIENT_DOES_NOT_EXIST_ERROR_CODE
-    });
+ * Builds the per-method view of what is configured and where each method would deliver to.
+ *
+ * Target resolution mirrors the send pipeline: a recipient's explicit override on their global or
+ * default config wins, otherwise the value on their Firebase Auth record is used.
+ *
+ * @param input - The user, the configured send service, and their auth contact details.
+ * @returns One context per delivery method, in report order.
+ */ function buildNotificationDeliveryMethodContexts(input) {
+    var _ref, _gc_e, _ref1, _gc_t;
+    var notificationUser = input.notificationUser, notificationSendService = input.notificationSendService, authEmail = input.authEmail, authPhone = input.authPhone, uid = input.uid;
+    var gc = notificationUser.gc, dc = notificationUser.dc;
+    var emailSendService = notificationSendService.emailSendService, textSendService = notificationSendService.textSendService, notificationSummarySendService = notificationSendService.notificationSummarySendService, notificationSummaryIdForUidFunction = notificationSendService.notificationSummaryIdForUidFunction;
+    var emailContext = {
+        method: NotificationDeliveryMethod.EMAIL,
+        label: 'Email',
+        sendServiceConfigured: emailSendService != null,
+        healthCheckService: emailSendService === null || emailSendService === void 0 ? void 0 : emailSendService.healthCheckService,
+        target: (_ref = (_gc_e = gc.e) !== null && _gc_e !== void 0 ? _gc_e : dc.e) !== null && _ref !== void 0 ? _ref : authEmail,
+        readTemplateConfigFlag: function readTemplateConfigFlag(x) {
+            return x.se;
+        },
+        requiresExplicitOptIn: false
+    };
+    var textContext = {
+        method: NotificationDeliveryMethod.TEXT,
+        label: 'Text message',
+        sendServiceConfigured: textSendService != null,
+        healthCheckService: textSendService === null || textSendService === void 0 ? void 0 : textSendService.healthCheckService,
+        target: (_ref1 = (_gc_t = gc.t) !== null && _gc_t !== void 0 ? _gc_t : dc.t) !== null && _ref1 !== void 0 ? _ref1 : authPhone,
+        readTemplateConfigFlag: function readTemplateConfigFlag(x) {
+            return x.st;
+        },
+        // the send pipeline only texts recipients who have explicitly opted in
+        requiresExplicitOptIn: true
+    };
+    var summaryContext = {
+        method: NotificationDeliveryMethod.NOTIFICATION_SUMMARY,
+        label: 'In-app notification',
+        sendServiceConfigured: notificationSummarySendService != null,
+        healthCheckService: notificationSummarySendService === null || notificationSummarySendService === void 0 ? void 0 : notificationSummarySendService.healthCheckService,
+        target: notificationSummaryIdForUidFunction === null || notificationSummaryIdForUidFunction === void 0 ? void 0 : notificationSummaryIdForUidFunction(uid),
+        readTemplateConfigFlag: function readTemplateConfigFlag(x) {
+            return x.sn;
+        },
+        requiresExplicitOptIn: false
+    };
+    var pushContext = {
+        method: NotificationDeliveryMethod.PUSH,
+        label: 'Push notification',
+        // push delivery is not part of the send service yet
+        sendServiceConfigured: false,
+        readTemplateConfigFlag: function readTemplateConfigFlag(x) {
+            return x.sp;
+        },
+        requiresExplicitOptIn: true
+    };
+    return [
+        emailContext,
+        textContext,
+        summaryContext,
+        pushContext
+    ];
 }
 /**
- * Creates an error indicating that the given UID does not correspond to an existing Firebase Auth user.
- *
- * Thrown during {@link NotificationUser} creation when the provided UID cannot be found in Firebase Auth.
- *
- * @param uid - The Firebase Auth user ID that was not found.
- * @returns A precondition conflict error with the invalid-uid error code.
- */ function notificationUserInvalidUidForCreateError(uid) {
-    return preconditionConflictError({
-        message: "The user with the uid '".concat(uid, "' does not exist. Cannot create a NotificationUser for them."),
-        code: NOTIFICATION_USER_INVALID_UID_FOR_CREATE_ERROR_CODE,
-        data: {
-            uid: uid
+ * Evaluates the checks that suppress every delivery method at once, rather than any single one.
+ *
+ * Reported at the top level of the health check so a single account-wide problem does not appear once
+ * per delivery method.
+ *
+ * @param input - The user and the state of their auth record.
+ * @returns The account-wide findings.
+ */ function notificationUserAccountIssues(input) {
+    var notificationUser = input.notificationUser, accountDisabled = input.accountDisabled, accountExists = input.accountExists;
+    var gc = notificationUser.gc, dc = notificationUser.dc, b = notificationUser.b, x = notificationUser.x;
+    var issues = [];
+    if (!accountExists) {
+        issues.push(notificationHealthCheckIssue(KnownNotificationHealthCheckIssueCode.NO_DELIVERY_TARGET, NotificationHealthCheckStatus.ERROR, {
+            message: 'Your sign-in account could not be read, so no contact details could be resolved.',
+            fix: 'Contact support with this report.'
+        }));
+        return issues; // nothing else can be determined without the auth record
+    }
+    if (accountDisabled) {
+        issues.push(notificationHealthCheckIssue(KnownNotificationHealthCheckIssueCode.RECIPIENT_DISABLED, NotificationHealthCheckStatus.ERROR, {
+            message: 'Your account is disabled, so no notifications are being sent to you.',
+            fix: 'Contact support to have your account re-enabled.'
+        }));
+    }
+    // The global config is applied as a final override at send time, so it is the decisive one.
+    var flagScopes = [
+        [
+            'global',
+            gc.f
+        ],
+        [
+            'default',
+            dc.f
+        ]
+    ];
+    flagScopes.forEach(function(param) {
+        var _param = _sliced_to_array$4(param, 2), scope = _param[0], flag = _param[1];
+        if (flag === NotificationBoxRecipientFlag.OPT_OUT) {
+            issues.push(notificationHealthCheckIssue(KnownNotificationHealthCheckIssueCode.RECIPIENT_OPTED_OUT, NotificationHealthCheckStatus.ERROR, {
+                message: 'You have opted out of notifications, so none are being sent to you.',
+                fix: 'Turn notifications back on in your notification settings.',
+                data: {
+                    scope: scope
+                }
+            }));
+        } else if (flag === NotificationBoxRecipientFlag.DISABLED) {
+            issues.push(notificationHealthCheckIssue(KnownNotificationHealthCheckIssueCode.RECIPIENT_DISABLED, NotificationHealthCheckStatus.ERROR, {
+                message: 'Notifications have been turned off for your account, so none are being sent to you.',
+                fix: 'Contact support to have notifications re-enabled.',
+                data: {
+                    scope: scope
+                }
+            }));
         }
     });
+    if (!b.length) {
+        issues.push(notificationHealthCheckIssue(KnownNotificationHealthCheckIssueCode.NO_NOTIFICATION_BOXES, NotificationHealthCheckStatus.WARNING, {
+            message: 'You are not subscribed to notifications for anything yet, so there is nothing to notify you about.',
+            fix: 'This usually resolves itself once you are added to a group or record that sends notifications.'
+        }));
+    }
+    if (x.length) {
+        issues.push(notificationHealthCheckIssue(KnownNotificationHealthCheckIssueCode.NOTIFICATION_BOX_EXCLUSIONS, NotificationHealthCheckStatus.WARNING, {
+            message: "Notifications from ".concat(x.length, " subscription").concat(x.length === 1 ? '' : 's', " are being suppressed for your account."),
+            fix: 'Contact support if you expect notifications from one of these.',
+            data: {
+                exclusions: takeFront(x, 10)
+            }
+        }));
+    }
+    return issues;
 }
 /**
- * Creates an error indicating that the user has blocked themselves from being added as a recipient.
- *
- * Thrown when a {@link NotificationUser} has the `bk` (blocked-from-add) flag set on their config
- * and an operation attempts to insert them into a {@link NotificationBox}'s recipient list.
- *
- * @param uid - The Firebase Auth user ID of the blocked user.
- * @returns A precondition conflict error with the blocked-from-add error code.
- */ function notificationUserBlockedFromBeingAddedToRecipientsError(uid) {
-    return preconditionConflictError({
-        message: "The user with the uid '".concat(uid, "' has blocked themselves from from being added recipients."),
-        code: NOTIFICATION_USER_BLOCKED_FROM_BEING_ADD_TO_RECIPIENTS_ERROR_CODE,
-        data: {
-            uid: uid
-        }
-    });
+ * Evaluates the user's own configuration for a single delivery method.
+ *
+ * These mirror the gates in {@link expandNotificationRecipients}, so each finding corresponds to a real
+ * reason the send pipeline would drop a message.
+ *
+ * @param input - The delivery method context, the user, and the template type being evaluated.
+ * @returns The findings for the method.
+ */ function notificationDeliveryMethodConfigIssues(input) {
+    var _gc_c, _dc_c;
+    var methodContext = input.methodContext, notificationUser = input.notificationUser, notificationTemplateType = input.notificationTemplateType;
+    var method = methodContext.method, label = methodContext.label, sendServiceConfigured = methodContext.sendServiceConfigured, target = methodContext.target, readTemplateConfigFlag = methodContext.readTemplateConfigFlag, requiresExplicitOptIn = methodContext.requiresExplicitOptIn;
+    var gc = notificationUser.gc, dc = notificationUser.dc;
+    var issues = [];
+    if (!sendServiceConfigured) {
+        issues.push(notificationHealthCheckIssue(KnownNotificationHealthCheckIssueCode.SEND_SERVICE_NOT_CONFIGURED, NotificationHealthCheckStatus.SKIPPED, {
+            message: "".concat(label, " notifications are not enabled on this system."),
+            data: {
+                method: method
+            }
+        }));
+        return issues; // nothing else about this method is meaningful
+    }
+    if (target == null) {
+        issues.push(notificationHealthCheckIssue(KnownNotificationHealthCheckIssueCode.NO_DELIVERY_TARGET, NotificationHealthCheckStatus.ERROR, {
+            message: "There is no ".concat(label.toLowerCase(), " destination on your account, so nothing can be delivered."),
+            fix: method === NotificationDeliveryMethod.EMAIL ? 'Add an email address to your account.' : 'Add a phone number to your notification settings.',
+            data: {
+                method: method
+            }
+        }));
+        return issues; // every remaining check is about a destination that does not exist
+    }
+    // per-template channel flags on the global and default configs
+    var globalTemplateFlag = readEffectiveTemplateConfigFlag((_gc_c = gc.c) === null || _gc_c === void 0 ? void 0 : _gc_c[notificationTemplateType], readTemplateConfigFlag);
+    var defaultTemplateFlag = readEffectiveTemplateConfigFlag((_dc_c = dc.c) === null || _dc_c === void 0 ? void 0 : _dc_c[notificationTemplateType], readTemplateConfigFlag);
+    if (globalTemplateFlag === false) {
+        issues.push(notificationHealthCheckIssue(KnownNotificationHealthCheckIssueCode.METHOD_DISABLED_GLOBALLY, NotificationHealthCheckStatus.ERROR, {
+            message: "".concat(label, " is switched off for you across every notification, which overrides all other settings."),
+            fix: "Turn ".concat(label.toLowerCase(), " back on in your notification settings."),
+            data: {
+                method: method,
+                notificationTemplateType: notificationTemplateType,
+                scope: 'global'
+            }
+        }));
+    } else if (defaultTemplateFlag === false) {
+        issues.push(notificationHealthCheckIssue(KnownNotificationHealthCheckIssueCode.METHOD_DISABLED_FOR_TEMPLATE, NotificationHealthCheckStatus.WARNING, {
+            message: "".concat(label, " is switched off in your default settings for this kind of notification."),
+            fix: "Turn ".concat(label.toLowerCase(), " back on for this notification type."),
+            data: {
+                method: method,
+                notificationTemplateType: notificationTemplateType,
+                scope: 'default'
+            }
+        }));
+    } else if (requiresExplicitOptIn && globalTemplateFlag !== true && defaultTemplateFlag !== true) {
+        issues.push(notificationHealthCheckIssue(KnownNotificationHealthCheckIssueCode.METHOD_DISABLED_FOR_TEMPLATE, NotificationHealthCheckStatus.WARNING, {
+            message: "".concat(label, " is only sent to people who have turned it on, and you have not turned it on."),
+            fix: "Turn ".concat(label.toLowerCase(), " on in your notification settings."),
+            data: {
+                method: method,
+                notificationTemplateType: notificationTemplateType,
+                requiresExplicitOptIn: true
+            }
+        }));
+    }
+    return issues;
 }
 /**
- * Creates an error indicating that the user has locked their notification configuration from external updates.
+ * Resolves a single channel flag out of a template config, applying the `sd` send-default fallback.
  *
- * Thrown when a {@link NotificationUser} has the `lk` (locked) flag set on their config
- * and an operation attempts to modify their recipient settings on a {@link NotificationBox}.
+ * @param config - The template config to read, if the user has one for this template type.
+ * @param readFlag - Selects the delivery method's flag out of an effective config.
+ * @returns The flag's effective value, or undefined when the config leaves it unset.
+ */ function readEffectiveTemplateConfigFlag(config, readFlag) {
+    return config ? readFlag(effectiveNotificationBoxRecipientTemplateConfig(config)) : undefined;
+}
+/**
+ * Inspects the user's notification box subscriptions.
+ *
+ * This catches the failure modes that live between the user's own settings and the boxes that actually
+ * drive delivery: a config that never synced across, a box that was never initialized, or a recipient
+ * entry that was disabled or excluded on the box side.
+ *
+ * @param input - The user, the notification box collection, and the template type being evaluated.
+ * @returns The account-wide findings plus any findings scoped to a single delivery method.
+ */ function inspectNotificationUserSubscriptions(input) {
+    return _async_to_generator$h(function() {
+        var notificationUser, notificationBoxCollection, notificationTemplateType, uid, bc, ns, sharedIssues, issuesByMethod, activeConfigs, configsToInspect, documentAccessor, boxPairs, uninitializedBoxIds, invalidBoxIds, unsyncedBoxIds, disabledBoxIdsByMethod;
+        return _ts_generator$h(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    notificationUser = input.notificationUser, notificationBoxCollection = input.notificationBoxCollection, notificationTemplateType = input.notificationTemplateType;
+                    uid = notificationUser.uid, bc = notificationUser.bc, ns = notificationUser.ns;
+                    sharedIssues = [];
+                    issuesByMethod = new Map();
+                    if (ns) {
+                        sharedIssues.push(notificationHealthCheckIssue(KnownNotificationHealthCheckIssueCode.NEEDS_CONFIG_SYNC, NotificationHealthCheckStatus.WARNING, {
+                            message: 'Your notification settings have not finished saving everywhere yet.',
+                            fix: 'This usually clears itself within a few minutes. Re-run this check to confirm.'
+                        }));
+                    }
+                    activeConfigs = bc.filter(function(x) {
+                        return !x.rm;
+                    });
+                    configsToInspect = takeFront(activeConfigs, DEFAULT_MAX_NOTIFICATION_BOXES_TO_INSPECT_PER_HEALTH_CHECK);
+                    if (!configsToInspect.length) {
+                        return [
+                            2,
+                            {
+                                sharedIssues: sharedIssues,
+                                issuesByMethod: issuesByMethod
+                            }
+                        ];
+                    }
+                    documentAccessor = notificationBoxCollection.documentAccessor();
+                    return [
+                        4,
+                        Promise.all(configsToInspect.map(function(config) {
+                            return _async_to_generator$h(function() {
+                                var box;
+                                return _ts_generator$h(this, function(_state) {
+                                    switch(_state.label){
+                                        case 0:
+                                            return [
+                                                4,
+                                                documentAccessor.loadDocumentForId(config.nb).snapshotData().catch(function() {
+                                                    return undefined;
+                                                })
+                                            ];
+                                        case 1:
+                                            box = _state.sent();
+                                            return [
+                                                2,
+                                                {
+                                                    config: config,
+                                                    box: box
+                                                }
+                                            ];
+                                    }
+                                });
+                            })();
+                        }))
+                    ];
+                case 1:
+                    boxPairs = _state.sent();
+                    uninitializedBoxIds = [];
+                    invalidBoxIds = [];
+                    unsyncedBoxIds = [];
+                    disabledBoxIdsByMethod = new Map();
+                    boxPairs.forEach(function(param) {
+                        var config = param.config, box = param.box;
+                        if (!box) {
+                            return; // a box that has never been created simply has nothing to send
+                        }
+                        if (box.fi) {
+                            invalidBoxIds.push(config.nb);
+                        } else if (box.s) {
+                            uninitializedBoxIds.push(config.nb);
+                        }
+                        var boxRecipient = box.r.find(function(x) {
+                            return x.uid === uid;
+                        });
+                        if (!boxRecipient || config.ns) {
+                            unsyncedBoxIds.push(config.nb);
+                        }
+                        collectDisabledMethodsForBoxRecipient({
+                            boxRecipient: boxRecipient,
+                            config: config,
+                            notificationTemplateType: notificationTemplateType
+                        }).forEach(function(method) {
+                            var _disabledBoxIdsByMethod_get;
+                            var existing = (_disabledBoxIdsByMethod_get = disabledBoxIdsByMethod.get(method)) !== null && _disabledBoxIdsByMethod_get !== void 0 ? _disabledBoxIdsByMethod_get : [];
+                            existing.push(config.nb);
+                            disabledBoxIdsByMethod.set(method, existing);
+                        });
+                    });
+                    if (invalidBoxIds.length) {
+                        sharedIssues.push(notificationHealthCheckIssue(KnownNotificationHealthCheckIssueCode.SUBSCRIPTION_BROKEN, NotificationHealthCheckStatus.ERROR, {
+                            message: "".concat(invalidBoxIds.length, " of your subscriptions are broken and will not send notifications."),
+                            fix: 'Contact support with this report so the subscription can be repaired.',
+                            data: {
+                                notificationBoxIds: invalidBoxIds
+                            }
+                        }));
+                    }
+                    if (uninitializedBoxIds.length) {
+                        sharedIssues.push(notificationHealthCheckIssue(KnownNotificationHealthCheckIssueCode.SUBSCRIPTION_NOT_READY, NotificationHealthCheckStatus.WARNING, {
+                            message: "".concat(uninitializedBoxIds.length, " of your subscriptions are still being set up, so their notifications are delayed."),
+                            fix: 'This usually clears itself within a few minutes.',
+                            data: {
+                                notificationBoxIds: uninitializedBoxIds
+                            }
+                        }));
+                    }
+                    if (unsyncedBoxIds.length) {
+                        sharedIssues.push(notificationHealthCheckIssue(KnownNotificationHealthCheckIssueCode.NEEDS_CONFIG_SYNC, NotificationHealthCheckStatus.WARNING, {
+                            message: "Your settings for ".concat(unsyncedBoxIds.length, " subscription").concat(unsyncedBoxIds.length === 1 ? '' : 's', " have not been applied yet."),
+                            fix: 'Re-run this check in a few minutes. If it persists, contact support with this report.',
+                            data: {
+                                notificationBoxIds: unsyncedBoxIds
+                            }
+                        }));
+                    }
+                    disabledBoxIdsByMethod.forEach(function(notificationBoxIds, method) {
+                        issuesByMethod.set(method, [
+                            notificationHealthCheckIssue(KnownNotificationHealthCheckIssueCode.METHOD_DISABLED_FOR_BOX, NotificationHealthCheckStatus.WARNING, {
+                                message: "This delivery method is switched off for ".concat(notificationBoxIds.length, " of your subscriptions."),
+                                fix: 'Check the per-subscription settings in your notification settings.',
+                                data: {
+                                    method: method,
+                                    notificationBoxIds: notificationBoxIds
+                                }
+                            })
+                        ]);
+                    });
+                    return [
+                        2,
+                        {
+                            sharedIssues: sharedIssues,
+                            issuesByMethod: issuesByMethod
+                        }
+                    ];
+            }
+        });
+    })();
+}
+/**
+ * Determines which delivery methods are switched off for a user within a single notification box.
+ *
+ * Reads the box's own recipient entry when present, since that is what the send pipeline consults,
+ * and falls back to the user's mirrored config otherwise.
+ *
+ * @param input - The box's recipient entry, the user's mirrored config, and the template type.
+ * @returns The delivery methods explicitly switched off for the user in this box.
+ */ function collectDisabledMethodsForBoxRecipient(input) {
+    var _effectiveRecipient_c;
+    var boxRecipient = input.boxRecipient, config = input.config, notificationTemplateType = input.notificationTemplateType;
+    var effectiveRecipient = boxRecipient !== null && boxRecipient !== void 0 ? boxRecipient : config;
+    // a flagged or excluded recipient receives nothing at all from this box, which is reported
+    // separately rather than as a per-method finding
+    if (effectiveRecipient.f || effectiveRecipient.x) {
+        return [];
+    }
+    var templateConfig = (_effectiveRecipient_c = effectiveRecipient.c) === null || _effectiveRecipient_c === void 0 ? void 0 : _effectiveRecipient_c[notificationTemplateType];
+    if (!templateConfig) {
+        return [];
+    }
+    var effective = effectiveNotificationBoxRecipientTemplateConfig(templateConfig);
+    return filterMaybeArrayValues([
+        //
+        effective.se === false ? NotificationDeliveryMethod.EMAIL : undefined,
+        effective.st === false ? NotificationDeliveryMethod.TEXT : undefined,
+        effective.sp === false ? NotificationDeliveryMethod.PUSH : undefined,
+        effective.sn === false ? NotificationDeliveryMethod.NOTIFICATION_SUMMARY : undefined
+    ]);
+}
+/**
+ * True if the issue code describes a delivery probe rather than a configuration finding.
  *
- * @param uid - The Firebase Auth user ID of the locked user.
- * @returns A precondition conflict error with the locked-config error code.
- */ function notificationUserLockedConfigFromBeingUpdatedError(uid) {
-    return preconditionConflictError({
-        message: "The user with the uid '".concat(uid, "' has locked their config from being updated."),
-        code: NOTIFICATION_USER_LOCKED_CONFIG_FROM_BEING_UPDATED_ERROR_CODE,
-        data: {
-            uid: uid
-        }
-    });
+ * @param code - The issue code to test.
+ * @returns True if the code is one of the probe lifecycle codes.
+ */ function isProbeIssueCode(code) {
+    return PROBE_NOTIFICATION_HEALTH_CHECK_ISSUE_CODES.has(code);
 }
 
 function _array_like_to_array$9(arr, len) {
@@ -1507,6 +3373,7 @@ function _ts_generator$f(thisArg, body) {
         updateNotificationUser: updateNotificationUserFactory(context),
         resyncNotificationUser: resyncNotificationUserFactory(context),
         resyncAllNotificationUsers: resyncAllNotificationUsersFactory(context),
+        notificationUserHealthCheck: notificationUserHealthCheckFactory(context),
         createNotificationSummary: createNotificationSummaryFactory(context),
         updateNotificationSummary: updateNotificationSummaryFactory(context),
         createNotificationBox: createNotificationBoxFactory(context),
@@ -14544,4 +16411,4 @@ function _ts_generator(thisArg, body) {
     };
 }
 
-export { AbstractAppNotificationModule, BASE_NOTIFICATION_SERVER_ACTION_CONTEXT_TOKEN, BASE_STORAGE_FILE_SERVER_ACTION_CONTEXT_TOKEN, DEFAULT_COMPRESS_IMAGE_FORMAT, DEFAULT_COMPRESS_IMAGE_INITIAL_QUALITY, DEFAULT_COMPRESS_IMAGE_MAX_DIMENSION, DEFAULT_COMPRESS_IMAGE_MIN_QUALITY, DEFAULT_COMPRESS_IMAGE_QUALITY_STEP, DEFAULT_COMPRESS_PDF_IMAGE_MAX_DIMENSION, DEFAULT_COMPRESS_PDF_IMAGE_QUALITY, DEFAULT_COMPRESS_PDF_IMAGE_SIZE_THRESHOLD_BYTES, DEFAULT_DOWNLOAD_MULTIPLE_STORAGE_FILES_MAX_PARALLEL_TASKS, DEFAULT_MAILGUN_NOTIFICATION_EMAIL_SEND_SERVICE_MAX_BATCH_SIZE_PER_REQUEST, DEFAULT_READ_MULTIPLE_STORAGE_FILES_METADATA_MAX_PARALLEL_TASKS, GlobalNotificationModule, KNOWN_BUT_UNCONFIGURED_NOTIFICATION_TEMPLATE_TYPE_DELETE_AFTER_RETRY_ATTEMPTS, KNOWN_BUT_UNCONFIGURED_NOTIFICATION_TEMPLATE_TYPE_HOURS_DELAY, MAKE_TEMPLATE_FOR_NOTIFICATION_RELATED_MODEL_INITIALIZATION_FUNCTION_DELETE_RESPONSE, MAKE_TEMPLATE_FOR_STORAGEFILE_RELATED_MODEL_INITIALIZATION_FUNCTION_DELETE_RESPONSE, MutableNotificationExpediteService, NOTIFICATION_BOX_NOT_INITIALIZED_DELAY_MINUTES, NOTIFICATION_INIT_SERVER_ACTIONS_CONTEXT_CONFIG_TOKEN, NOTIFICATION_MAX_SEND_ATTEMPTS, NOTIFICATION_SERVER_ACTION_CONTEXT_TOKEN, NOTIFICATION_TASK_MINIMUM_SET_AT_THROTTLE_TIME_MINUTES, NOTIFICATION_TASK_TYPE_FAILURE_DELAY_HOURS, NOTIFICATION_TASK_TYPE_FAILURE_DELAY_MS, NOTIFICATION_TASK_TYPE_MAX_SEND_ATTEMPTS, NOTIFICATION_TEMPLATE_SERVICE_CONFIGS_ARRAY_TOKEN, NOTIFICATION_TEMPLATE_SERVICE_DEFAULTS_OVERRIDE_TOKEN, NotificationExpediteService, NotificationInitServerActions, NotificationSendService, NotificationServerActions, NotificationTaskService, NotificationTaskSubTaskMissingRequiredDataTermination, NotificationTemplateService, SEND_QUEUE_NOTIFICATIONS_TASK_EXCESS_THRESHOLD, STORAGE_FILE_INIT_SERVER_ACTIONS_CONTEXT_CONFIG_TOKEN, STORAGE_FILE_SERVER_ACTION_CONTEXT_TOKEN, STORAGE_FILE_SIGNED_UPLOAD_POLICIES_TOKEN, StorageFileInitServerActions, StorageFileInitializeFromUploadService, StorageFileServerActions, UNKNOWN_NOTIFICATION_TASK_TYPE_DELETE_AFTER_RETRY_ATTEMPTS, UNKNOWN_NOTIFICATION_TASK_TYPE_HOURS_DELAY, UNKNOWN_NOTIFICATION_TEMPLATE_TYPE_DELETE_AFTER_RETRY_ATTEMPTS, UNKNOWN_NOTIFICATION_TEMPLATE_TYPE_HOURS_DELAY, _initializeStorageFileFromUploadFileFactory, _processStorageFileInTransactionFactory, _syncStorageFileWithGroupsInTransactionFactory, allStorageFileGroupStorageFileProcessingPurposeSubtaskProcessors, appNotificationModuleMetadata, appStorageFileModuleMetadata, cleanupOldNotificationLoggedEventDaysFactory, cleanupSentNotificationsFactory, compressImageBufferToTargetSize, compressPdfImagesToTargetSize, createNotificationBoxFactory, createNotificationBoxInTransactionFactory, createNotificationIdRequiredError, createNotificationSummaryFactory, createNotificationUserFactory, createOrRunUniqueNotificationDocument, createStorageFileFactory, createStorageFileGroupFactory, createStorageFileGroupInTransactionFactory, createStorageFileGroupInputError, createStorageFileSignedUploadUrlFactory, deleteAllQueuedStorageFilesFactory, deleteStorageFileFactory, downloadMultipleStorageFilesFactory, downloadStorageFileFactory, expandNotificationRecipients, exportMutableNotificationExpediteService, firestoreNotificationSummarySendService, ignoreSendNotificationTextSendService, initializeAllApplicableNotificationBoxesFactory, initializeAllApplicableNotificationSummariesFactory, initializeAllApplicableStorageFileGroupsFactory, initializeAllStorageFilesFromUploadsFactory, initializeNotificationBoxFactory, initializeNotificationBoxInTransactionFactory, initializeNotificationModelInTransaction, initializeNotificationSummaryFactory, initializeNotificationSummaryInTransactionFactory, initializeStorageFileFromUploadFactory, initializeStorageFileGroupFactory, initializeStorageFileGroupInTransactionFactory, initializeStorageFileModelInTransaction, mailgunNotificationEmailSendService, makeNewNotificationSummaryTemplate, markStorageFileForDeleteTemplate, notificationBoxDoesNotExist, notificationBoxExclusionTargetInvalidError, notificationBoxExistsForModelError, notificationBoxRecipientDoesNotExistsError, notificationBoxUnregistredModelTypeInitializationError, notificationExpediteServiceInstance, notificationInitServerActions, notificationInitServerActionsFactory, notificationModelAlreadyInitializedError, notificationServerActions, notificationServerActionsContextFactory, notificationServerActionsFactory, notificationTaskService, notificationTaskSubTaskMissingRequiredDataTermination, notificationTaskSubtaskNotificationTaskHandlerFactory, notificationTemplateServiceInstance, notificationUserBlockedFromBeingAddedToRecipientsError, notificationUserInvalidUidForCreateError, notificationUserLockedConfigFromBeingUpdatedError, processAllQueuedStorageFilesFactory, processStorageFileFactory, provideMutableNotificationExpediteService, queryAndFlagStorageFilesForDelete, readMultipleStorageFilesMetadataFactory, readStorageFileMetadataFactory, regenerateAllFlaggedStorageFileGroupsContentFactory, regenerateStorageFileGroupContentFactory, resyncAllNotificationUsersFactory, resyncNotificationUserFactory, sendNotificationFactory, sendQueuedNotificationsFactory, storageFileAlreadyProcessedError, storageFileCannotBeDeletedYetError, storageFileCreateSignedUploadUrlToolDetailsFactory, storageFileGroupQueuedForInitializationError, storageFileGroupZipStorageFileProcessingPurposeSubtaskProcessor, storageFileInitServerActions, storageFileInitServerActionsFactory, storageFileInitializeFromUploadService, storageFileInitializeFromUploadServiceInitializerResultPermanentFailure, storageFileModelAlreadyInitializedError, storageFileNotFlaggedForDeletionError, storageFileNotFlaggedForGroupsSyncError, storageFileProcessingNotAllowedForInvalidStateError, storageFileProcessingNotAvailableForTypeError, storageFileProcessingNotQueuedForProcessingError, storageFileProcessingNotificationTaskHandler, storageFileProcessingNotificationTaskHandlerDefaultCleanup, storageFileServerActions, storageFileServerActionsContextFactory, storageFileServerActionsFactory, syncAllFlaggedStorageFilesWithGroupsFactory, syncStorageFileWithGroupsFactory, updateNotificationBoxFactory, updateNotificationBoxRecipientExclusionInTransactionFactory, updateNotificationBoxRecipientFactory, updateNotificationBoxRecipientInTransactionFactory, updateNotificationSummaryFactory, updateNotificationUserFactory, updateNotificationUserNotificationBoxRecipientConfig, updateStorageFileFactory, updateStorageFileGroupFactory, uploadedFileDoesNotExistError, uploadedFileInitializationDiscardedError, uploadedFileInitializationFailedError, uploadedFileIsNotAllowedToBeInitializedError };
+export { AbstractAppNotificationModule, BASE_NOTIFICATION_SERVER_ACTION_CONTEXT_TOKEN, BASE_STORAGE_FILE_SERVER_ACTION_CONTEXT_TOKEN, DEFAULT_COMPRESS_IMAGE_FORMAT, DEFAULT_COMPRESS_IMAGE_INITIAL_QUALITY, DEFAULT_COMPRESS_IMAGE_MAX_DIMENSION, DEFAULT_COMPRESS_IMAGE_MIN_QUALITY, DEFAULT_COMPRESS_IMAGE_QUALITY_STEP, DEFAULT_COMPRESS_PDF_IMAGE_MAX_DIMENSION, DEFAULT_COMPRESS_PDF_IMAGE_QUALITY, DEFAULT_COMPRESS_PDF_IMAGE_SIZE_THRESHOLD_BYTES, DEFAULT_DOWNLOAD_MULTIPLE_STORAGE_FILES_MAX_PARALLEL_TASKS, DEFAULT_MAILGUN_HEALTH_CHECK_PROBE_TIMEOUT_MINUTES, DEFAULT_MAILGUN_NOTIFICATION_EMAIL_SEND_SERVICE_MAX_BATCH_SIZE_PER_REQUEST, DEFAULT_MAX_NOTIFICATION_BOXES_TO_INSPECT_PER_HEALTH_CHECK, DEFAULT_READ_MULTIPLE_STORAGE_FILES_METADATA_MAX_PARALLEL_TASKS, GlobalNotificationModule, KNOWN_BUT_UNCONFIGURED_NOTIFICATION_TEMPLATE_TYPE_DELETE_AFTER_RETRY_ATTEMPTS, KNOWN_BUT_UNCONFIGURED_NOTIFICATION_TEMPLATE_TYPE_HOURS_DELAY, MAKE_TEMPLATE_FOR_NOTIFICATION_RELATED_MODEL_INITIALIZATION_FUNCTION_DELETE_RESPONSE, MAKE_TEMPLATE_FOR_STORAGEFILE_RELATED_MODEL_INITIALIZATION_FUNCTION_DELETE_RESPONSE, MutableNotificationExpediteService, NOTIFICATION_BOX_NOT_INITIALIZED_DELAY_MINUTES, NOTIFICATION_INIT_SERVER_ACTIONS_CONTEXT_CONFIG_TOKEN, NOTIFICATION_MAX_SEND_ATTEMPTS, NOTIFICATION_SERVER_ACTION_CONTEXT_TOKEN, NOTIFICATION_TASK_MINIMUM_SET_AT_THROTTLE_TIME_MINUTES, NOTIFICATION_TASK_TYPE_FAILURE_DELAY_HOURS, NOTIFICATION_TASK_TYPE_FAILURE_DELAY_MS, NOTIFICATION_TASK_TYPE_MAX_SEND_ATTEMPTS, NOTIFICATION_TEMPLATE_SERVICE_CONFIGS_ARRAY_TOKEN, NOTIFICATION_TEMPLATE_SERVICE_DEFAULTS_OVERRIDE_TOKEN, NotificationExpediteService, NotificationInitServerActions, NotificationSendService, NotificationServerActions, NotificationTaskService, NotificationTaskSubTaskMissingRequiredDataTermination, NotificationTemplateService, SEND_QUEUE_NOTIFICATIONS_TASK_EXCESS_THRESHOLD, STORAGE_FILE_INIT_SERVER_ACTIONS_CONTEXT_CONFIG_TOKEN, STORAGE_FILE_SERVER_ACTION_CONTEXT_TOKEN, STORAGE_FILE_SIGNED_UPLOAD_POLICIES_TOKEN, StorageFileInitServerActions, StorageFileInitializeFromUploadService, StorageFileServerActions, UNKNOWN_NOTIFICATION_TASK_TYPE_DELETE_AFTER_RETRY_ATTEMPTS, UNKNOWN_NOTIFICATION_TASK_TYPE_HOURS_DELAY, UNKNOWN_NOTIFICATION_TEMPLATE_TYPE_DELETE_AFTER_RETRY_ATTEMPTS, UNKNOWN_NOTIFICATION_TEMPLATE_TYPE_HOURS_DELAY, _initializeStorageFileFromUploadFileFactory, _processStorageFileInTransactionFactory, _syncStorageFileWithGroupsInTransactionFactory, allStorageFileGroupStorageFileProcessingPurposeSubtaskProcessors, appNotificationModuleMetadata, appStorageFileModuleMetadata, cleanupOldNotificationLoggedEventDaysFactory, cleanupSentNotificationsFactory, compressImageBufferToTargetSize, compressPdfImagesToTargetSize, createNotificationBoxFactory, createNotificationBoxInTransactionFactory, createNotificationIdRequiredError, createNotificationSummaryFactory, createNotificationUserFactory, createOrRunUniqueNotificationDocument, createStorageFileFactory, createStorageFileGroupFactory, createStorageFileGroupInTransactionFactory, createStorageFileGroupInputError, createStorageFileSignedUploadUrlFactory, deleteAllQueuedStorageFilesFactory, deleteStorageFileFactory, downloadMultipleStorageFilesFactory, downloadStorageFileFactory, expandNotificationRecipients, exportMutableNotificationExpediteService, firestoreNotificationSummarySendService, ignoreSendNotificationTextSendService, initializeAllApplicableNotificationBoxesFactory, initializeAllApplicableNotificationSummariesFactory, initializeAllApplicableStorageFileGroupsFactory, initializeAllStorageFilesFromUploadsFactory, initializeNotificationBoxFactory, initializeNotificationBoxInTransactionFactory, initializeNotificationModelInTransaction, initializeNotificationSummaryFactory, initializeNotificationSummaryInTransactionFactory, initializeStorageFileFromUploadFactory, initializeStorageFileGroupFactory, initializeStorageFileGroupInTransactionFactory, initializeStorageFileModelInTransaction, mailgunNotificationEmailSendService, mailgunNotificationEmailSendServiceHealthCheckService, makeNewNotificationSummaryTemplate, markStorageFileForDeleteTemplate, notificationBoxDoesNotExist, notificationBoxExclusionTargetInvalidError, notificationBoxExistsForModelError, notificationBoxRecipientDoesNotExistsError, notificationBoxUnregistredModelTypeInitializationError, notificationExpediteServiceInstance, notificationInitServerActions, notificationInitServerActionsFactory, notificationModelAlreadyInitializedError, notificationServerActions, notificationServerActionsContextFactory, notificationServerActionsFactory, notificationTaskService, notificationTaskSubTaskMissingRequiredDataTermination, notificationTaskSubtaskNotificationTaskHandlerFactory, notificationTemplateServiceInstance, notificationUserBlockedFromBeingAddedToRecipientsError, notificationUserHealthCheckFactory, notificationUserHealthCheckProbeThrottledError, notificationUserHealthCheckThrottledError, notificationUserHealthCheckVerifyThrottledError, notificationUserInvalidUidForCreateError, notificationUserLockedConfigFromBeingUpdatedError, processAllQueuedStorageFilesFactory, processStorageFileFactory, provideMutableNotificationExpediteService, queryAndFlagStorageFilesForDelete, readMultipleStorageFilesMetadataFactory, readStorageFileMetadataFactory, regenerateAllFlaggedStorageFileGroupsContentFactory, regenerateStorageFileGroupContentFactory, resyncAllNotificationUsersFactory, resyncNotificationUserFactory, sendNotificationFactory, sendQueuedNotificationsFactory, storageFileAlreadyProcessedError, storageFileCannotBeDeletedYetError, storageFileCreateSignedUploadUrlToolDetailsFactory, storageFileGroupQueuedForInitializationError, storageFileGroupZipStorageFileProcessingPurposeSubtaskProcessor, storageFileInitServerActions, storageFileInitServerActionsFactory, storageFileInitializeFromUploadService, storageFileInitializeFromUploadServiceInitializerResultPermanentFailure, storageFileModelAlreadyInitializedError, storageFileNotFlaggedForDeletionError, storageFileNotFlaggedForGroupsSyncError, storageFileProcessingNotAllowedForInvalidStateError, storageFileProcessingNotAvailableForTypeError, storageFileProcessingNotQueuedForProcessingError, storageFileProcessingNotificationTaskHandler, storageFileProcessingNotificationTaskHandlerDefaultCleanup, storageFileServerActions, storageFileServerActionsContextFactory, storageFileServerActionsFactory, syncAllFlaggedStorageFilesWithGroupsFactory, syncStorageFileWithGroupsFactory, updateNotificationBoxFactory, updateNotificationBoxRecipientExclusionInTransactionFactory, updateNotificationBoxRecipientFactory, updateNotificationBoxRecipientInTransactionFactory, updateNotificationSummaryFactory, updateNotificationUserFactory, updateNotificationUserNotificationBoxRecipientConfig, updateStorageFileFactory, updateStorageFileGroupFactory, uploadedFileDoesNotExistError, uploadedFileInitializationDiscardedError, uploadedFileInitializationFailedError, uploadedFileIsNotAllowedToBeInitializedError };