lifecycleion 0.0.1

package/dist/lib/retry-utils/index.js

@@ -0,0 +1,2133 @@
+// src/lib/strings.ts
+function isString(value) {
+  return typeof value === "string";
+}
+function splitGraphemes(text) {
+  const graphemes = [];
+  let grapheme = "";
+  let zwjSequence = "";
+  for (let i = 0; i < text.length; i++) {
+    const char = text[i];
+    const nextChar = text[i + 1] || "";
+    const code = char.charCodeAt(0);
+    if (code >= 768 && code <= 879 || // Combining Diacritical Marks
+    code >= 6832 && code <= 6911 || // Combining Diacritical Marks Extended
+    code >= 7616 && code <= 7679 || // Combining Diacritical Marks Supplement
+    code >= 65056 && code <= 65071 || // Combining Half Marks
+    code >= 3633 && code <= 3642 || // Thai combining marks
+    code >= 3655 && code <= 3662) {
+      grapheme += char;
+    } else if (char === "\u200D") {
+      zwjSequence += grapheme + char;
+      grapheme = "";
+    } else {
+      if (grapheme) {
+        if (zwjSequence) {
+          graphemes.push(zwjSequence + grapheme);
+          zwjSequence = "";
+        } else {
+          graphemes.push(grapheme);
+        }
+      }
+      grapheme = char;
+      if (char >= "\uD800" && char <= "\uDBFF" && nextChar >= "\uDC00" && nextChar <= "\uDFFF") {
+        grapheme += nextChar;
+        i++;
+      }
+    }
+  }
+  if (grapheme) {
+    if (zwjSequence) {
+      graphemes.push(zwjSequence + grapheme);
+    } else {
+      graphemes.push(grapheme);
+    }
+  }
+  return graphemes;
+}
+
+// src/lib/retry-utils/lib/retry-utils-errors.ts
+var RetryUtilsErrPolicyConfigInvalidStrategy = class extends Error {
+  constructor(strategyProvided, validStrategies) {
+    super("Invalid strategy provided.");
+    this.strategyProvided = strategyProvided;
+    this.validStrategies = validStrategies;
+    this.name = "RetryUtilsErrPolicyConfigInvalidStrategy";
+  }
+};
+var RetryUtilsErrRunnerAlreadyCompleted = class extends Error {
+  constructor(invokedMethod) {
+    super(
+      "The runner has already completed running the operation. Use the .reset() method, and .run() to run the operation again."
+    );
+    this.invokedMethod = invokedMethod;
+    this.name = "RetryUtilsErrRunnerAlreadyCompleted";
+  }
+};
+var RetryUtilsErrRunnerAlreadyRunning = class extends Error {
+  constructor(invokedMethod) {
+    super("The operation is already running and cannot be started again.");
+    this.invokedMethod = invokedMethod;
+    this.name = "RetryUtilsErrRunnerAlreadyRunning";
+  }
+};
+var RetryUtilsErrRunnerForceTryRetryInProgress = class extends Error {
+  constructor(invokedMethod) {
+    super("Force try retry is already in progress.");
+    this.invokedMethod = invokedMethod;
+    this.name = "RetryUtilsErrRunnerForceTryRetryInProgress";
+  }
+};
+var RetryUtilsErrRunnerNotPaused = class extends Error {
+  constructor(invokedMethod) {
+    super(
+      "The runner is not in a paused state. resume() can only be called when the runner state is stopped."
+    );
+    this.invokedMethod = invokedMethod;
+    this.name = "RetryUtilsErrRunnerNotPaused";
+  }
+};
+var RetryUtilsErrRunnerCancelPending = class extends Error {
+  constructor(invokedMethod) {
+    super(
+      "A cancel operation is pending. The operation cannot be started again."
+    );
+    this.invokedMethod = invokedMethod;
+    this.name = "RetryUtilsErrRunnerCancelPending";
+  }
+};
+var RetryUtilsErrRunnerRetryCanceled = class extends Error {
+  constructor(invokedMethod) {
+    super(
+      "The operation was already canceled. Use either .resume(), .forceTry() or .reset() and .run() to run the operation again."
+    );
+    this.invokedMethod = invokedMethod;
+    this.name = "RetryUtilsErrRunnerRetryCanceled";
+  }
+};
+var RetryUtilsErrRunnerLastRetryFatallyFailed = class extends Error {
+  constructor(invokedMethod) {
+    super(
+      "The last retry attempt failed fatally. The operation cannot be retried. Use either .reset() then .run() or .forceTry() to run the operation again."
+    );
+    this.invokedMethod = invokedMethod;
+    this.name = "RetryUtilsErrRunnerLastRetryFatallyFailed";
+  }
+};
+var RetryUtilsErrRunnerAttemptsExhausted = class extends Error {
+  constructor(invokedMethod) {
+    super(
+      "All attempts were exhausted. The operation cannot be retried. Use either .reset() then .run() or .forceTry() to run the operation again."
+    );
+    this.invokedMethod = invokedMethod;
+    this.name = "RetryUtilsErrRunnerAttemptsExhausted";
+  }
+};
+var RetryUtilsErrRunnerLockAcquisitionError = class extends Error {
+  constructor(invokedMethod) {
+    super(
+      "Failed to acquire operation lock. Cannot attempt to run the operation."
+    );
+    this.invokedMethod = invokedMethod;
+    this.name = "RetryUtilsErrRunnerLockAcquisitionError";
+  }
+};
+var RetryUtilsErrRunnerUnexpectedError = class extends Error {
+  constructor(invokedMethod, originalError) {
+    super("An unexpected error occurred.");
+    this.invokedMethod = invokedMethod;
+    this.originalError = originalError;
+    this.name = "RetryUtilsErrRunnerUnexpectedError";
+  }
+};
+var RetryUtilsErrRunnerUnknownState = class extends Error {
+  constructor(invokedMethod, runnerState) {
+    super("An unknown runner state was encountered.");
+    this.invokedMethod = invokedMethod;
+    this.runnerState = runnerState;
+    this.name = "RetryUtilsErrRunnerUnknownState";
+  }
+};
+var RetryUtilsErrRunnerNotRunning = class extends Error {
+  constructor(invokedMethod) {
+    super("The operation is not currently running.");
+    this.invokedMethod = invokedMethod;
+    this.name = "RetryUtilsErrRunnerNotRunning";
+  }
+};
+
+// src/lib/clamp.ts
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(value, max));
+}
+
+// src/lib/retry-utils/lib/utils.ts
+function calculateExponentialDelay({
+  retryCount,
+  minTimeoutMS,
+  maxTimeoutMS,
+  factor,
+  dispersion,
+  randomFn
+}) {
+  let delay = minTimeoutMS * Math.pow(factor, retryCount);
+  if (dispersion > 0) {
+    const dispersionAmount = delay * dispersion;
+    delay += randomFn() * (dispersionAmount * 2) - dispersionAmount;
+  }
+  return clamp(delay, minTimeoutMS, maxTimeoutMS);
+}
+function extractErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (error !== null && error !== void 0 && typeof error === "object" && "message" in error && typeof error.message === "string") {
+    return error.message;
+  }
+  if (error !== null && error !== void 0 && typeof error === "object" && "error" in error) {
+    const nested = error.error;
+    if (nested instanceof Error) {
+      return nested.message;
+    } else if (nested !== null && nested !== void 0 && typeof nested === "object" && "message" in nested && typeof nested.message === "string") {
+      return nested.message;
+    } else {
+      return String(nested);
+    }
+  }
+  return String(error);
+}
+function getMostCommonError(errors) {
+  if (errors.length === 0) {
+    return null;
+  }
+  const refCounts = /* @__PURE__ */ new Map();
+  for (const error of errors) {
+    refCounts.set(error, (refCounts.get(error) ?? 0) + 1);
+  }
+  const messageCounts = /* @__PURE__ */ new Map();
+  for (const error of errors) {
+    const message = extractErrorMessage(error);
+    const existing = messageCounts.get(message);
+    if (existing) {
+      existing.count += 1;
+    } else {
+      messageCounts.set(message, { count: 1, error });
+    }
+  }
+  let mostCommon = null;
+  let maxCount = 0;
+  for (const [error, count] of refCounts) {
+    if (count > maxCount) {
+      maxCount = count;
+      mostCommon = error;
+    }
+  }
+  for (const { count, error } of messageCounts.values()) {
+    if (count > maxCount) {
+      maxCount = count;
+      mostCommon = error;
+    }
+  }
+  return mostCommon;
+}
+
+// src/lib/retry-utils/lib/retry-policy.ts
+var RetryPolicy = class {
+  policy;
+  currentState = this.getEmptyCurrentState();
+  /**
+   * Gets the validated policy information for this retry policy instance.
+   * @returns {RetryPolicyValidated} The current retry policy settings.
+   */
+  get policyInfo() {
+    return this.policy;
+  }
+  /**
+   * Gets the total number of attempts made, including the initial attempt and any retries.
+   * @returns {number} The total number of attempts.
+   */
+  get attempts() {
+    if (this.currentState.wasSuccessful) {
+      return this.currentState.errors.length + 1;
+    } else {
+      return clamp(
+        this.currentState.errors.length,
+        this.wasInitialAttemptTaken ? 1 : 0,
+        Infinity
+      );
+    }
+  }
+  /**
+   * Checks if the initial attempt has been taken.
+   */
+  get wasInitialAttemptTaken() {
+    return this.currentState.wasInitialAttemptTaken;
+  }
+  /**
+   * Checks if the last operation attempt was successful. (used to calculate the number of attempts made)
+   */
+  get wasSuccessful() {
+    return this.currentState.wasSuccessful;
+  }
+  /**
+   * Gets the maximum number of retry attempts allowed by the current policy.
+   * @returns {number} The maximum number of retry attempts.
+   */
+  get maxRetryAttempts() {
+    return this.policy.maxRetryAttempts;
+  }
+  /**
+   * Gets the number of retry attempts made, excluding the initial attempt.
+   * @returns {number} The number of retries.
+   */
+  get retryCount() {
+    if (!this.wasInitialAttemptTaken) {
+      return 0;
+    }
+    return Math.max(this.attempts - 1, 0);
+  }
+  /**
+   * Checks if the retry attempts have been exhausted.
+   * @returns {boolean} True if the number of retries has reached the maximum allowed attempts; otherwise, false.
+   */
+  get areAttemptsExhausted() {
+    return this.retryCount >= this.maxRetryAttempts;
+  }
+  /**
+   * Gets a list of errors recorded from each retry attempt.
+   * @returns {unknown[]} An array of errors encountered during retry attempts.
+   */
+  get errors() {
+    return [...this.currentState.errors];
+  }
+  /**
+   * Gets the most common error encountered across all retry attempts.
+   *
+   * This method caches the most common error for performance. If the cache is invalidated due to a new error,
+   * it recalculates the most common error.
+   *
+   * @returns {unknown} The most common error, or null if no errors have been encountered.
+   */
+  get mostCommonError() {
+    if (this.currentState.mostCommonErrorCached.has) {
+      return this.currentState.mostCommonErrorCached.value;
+    } else {
+      const mostCommon = getMostCommonError(this.currentState.errors);
+      this.currentState.mostCommonErrorCached.has = true;
+      this.currentState.mostCommonErrorCached.value = mostCommon;
+      return mostCommon;
+    }
+  }
+  /**
+   * Gets the last error encountered during the retry attempts.
+   * @returns {unknown} The last error encountered, or null if no errors have been recorded.
+   */
+  get lastError() {
+    if (this.currentState.errors.length === 0) {
+      return null;
+    } else {
+      return this.currentState.errors[this.currentState.errors.length - 1];
+    }
+  }
+  /**
+   * Constructs a RetryPolicy instance with specified options.
+   *
+   * @param {RetryPolicyOptions} policy The retry policy options, including strategy, maximum retry attempts,
+   * and other parameters specific to the fixed or exponential strategy.
+   *
+   * Throws an error if an invalid retry strategy is provided.
+   */
+  constructor(policy) {
+    const DEFAULT_MAX_RETRY_ATTEMPTS = 10;
+    const DEFAULT_FACTOR = 1.5;
+    const DEFAULT_MIN_TIMEOUT_MS = 1e3;
+    const DEFAULT_MAX_TIMEOUT_MS = 3e4;
+    const DEFAULT_DISPERSION = 0.1;
+    if (policy.strategy === "fixed") {
+      this.policy = {
+        strategy: "fixed",
+        maxRetryAttempts: Math.floor(
+          clamp(
+            policy.maxRetryAttempts ?? DEFAULT_MAX_RETRY_ATTEMPTS,
+            1,
+            Infinity
+          )
+        ),
+        delayMS: clamp(policy.delayMS ?? DEFAULT_MIN_TIMEOUT_MS, 1, Infinity)
+      };
+    } else if (policy.strategy === "exponential") {
+      const minTimeoutMS = clamp(
+        policy.minTimeoutMS ?? DEFAULT_MIN_TIMEOUT_MS,
+        1,
+        Infinity
+      );
+      const maxTimeoutMS = clamp(
+        policy.maxTimeoutMS ?? DEFAULT_MAX_TIMEOUT_MS,
+        1,
+        Infinity
+      );
+      const finalMin = Math.min(minTimeoutMS, maxTimeoutMS);
+      const finalMax = Math.max(minTimeoutMS, maxTimeoutMS);
+      this.policy = {
+        strategy: "exponential",
+        maxRetryAttempts: Math.floor(
+          clamp(
+            policy.maxRetryAttempts ?? DEFAULT_MAX_RETRY_ATTEMPTS,
+            1,
+            Infinity
+          )
+        ),
+        factor: clamp(policy.factor ?? DEFAULT_FACTOR, 1, Infinity),
+        minTimeoutMS: finalMin,
+        maxTimeoutMS: finalMax,
+        dispersion: clamp(policy.dispersion ?? DEFAULT_DISPERSION, 0, 1)
+      };
+    } else {
+      throw new RetryUtilsErrPolicyConfigInvalidStrategy(
+        isString(policy["strategy"]) ? policy["strategy"] : "unknown",
+        ["fixed", "exponential"]
+      );
+    }
+  }
+  /**
+   * Resets the retry policy to its initial state.
+   *
+   * This method clears all recorded errors and marks the initial attempt as not taken,
+   * effectively resetting the state of the retry policy for a new operation.
+   */
+  reset() {
+    this.currentState = this.getEmptyCurrentState();
+  }
+  /**
+   * Determines if the initial operation attempt should proceed.
+   *
+   * This method checks if the initial attempt has already been taken and updates the state to reflect that
+   * the initial attempt is now being made. This method is used to ensure that the retry logic only kicks in after
+   * the first attempt has failed.
+   *
+   * Note that even upon success, you should call the reset method to clear the state for the next operation.
+   *
+   * @returns {boolean} True if the initial attempt has not been made yet; otherwise, false.
+   */
+  shouldDoFirstTry() {
+    if (this.currentState.wasInitialAttemptTaken) {
+      return false;
+    } else {
+      this.currentState.wasInitialAttemptTaken = true;
+      return true;
+    }
+  }
+  /**
+   * Marks the last operation attempt as successful.
+   */
+  markAsSuccessful() {
+    this.currentState.wasSuccessful = true;
+  }
+  /**
+   * Records an error that occurred during the last operation attempt.
+   *
+   * Does not check if was successful or not, nor checks if should retry or not.
+   */
+  reportError(error) {
+    this.currentState.errors.push(error);
+    this.currentState.mostCommonErrorCached.has = false;
+  }
+  /**
+   * Determines if a retry should be made based on the current state and the provided error.
+   *
+   * When called, this method stores the provided error, checks if further retries are allowed based on the
+   * maximum retry attempts, and calculates the delay for the next retry if applicable.
+   *
+   * It also invalidates the cached most common error since the error state has changed.
+   *
+   * @param {unknown} error The error that resulted from the last operation attempt. Can be omitted when `isQueryOnly` is `true`.
+   * @param {boolean} isQueryOnly If true, the method only queries if a retry should be made without storing the error.
+   * @returns {RetryQueryResult} An object indicating whether a retry should be attempted and the delay before the next attempt.
+   */
+  shouldRetry(error, isQueryOnly = false) {
+    if (this.currentState.wasSuccessful) {
+      if (!isQueryOnly) {
+        this.reportError(error);
+      }
+      return { shouldRetry: false, delayMS: 0 };
+    }
+    if (!isQueryOnly) {
+      this.reportError(error);
+    }
+    if (this.areAttemptsExhausted) {
+      return { shouldRetry: false, delayMS: 0 };
+    } else {
+      const delayMS = this.calculateNextDelay();
+      return { shouldRetry: true, delayMS };
+    }
+  }
+  /**
+   * Returning a fresh copy of the current state
+   * to be immutable and not changed by the caller
+   */
+  getEmptyCurrentState() {
+    return {
+      wasInitialAttemptTaken: false,
+      wasSuccessful: false,
+      errors: [],
+      mostCommonErrorCached: {
+        has: false,
+        value: null
+      }
+    };
+  }
+  /**
+   * Calculates the delay before the next retry attempt based on the current retry policy.
+   *
+   * For a fixed strategy, it returns the specified delay. For an exponential strategy, it calculates the delay
+   * based on the exponential backoff formula, considering the number of retry attempts, the base delay,
+   * the exponential factor, and any specified dispersion to introduce randomness.
+   *
+   * @returns {number} The calculated delay in milliseconds before the next retry attempt.
+   */
+  calculateNextDelay() {
+    if (this.policy.strategy === "fixed") {
+      return this.policy.delayMS;
+    } else if (this.policy.strategy === "exponential") {
+      return calculateExponentialDelay({
+        retryCount: this.retryCount,
+        minTimeoutMS: this.policy.minTimeoutMS,
+        maxTimeoutMS: this.policy.maxTimeoutMS,
+        factor: this.policy.factor,
+        dispersion: this.policy.dispersion,
+        randomFn: Math.random
+      });
+    }
+    return 1;
+  }
+};
+
+// src/lib/constants.ts
+var BLANK_SPACE = " ";
+var EOL = "\n";
+var DOUBLE_EOL = EOL + EOL;
+var INDENT = " ".repeat(4);
+var DOUBLE_INDENT = INDENT + INDENT;
+var ASCII_LOWERCASE = "abcdefghijklmnopqrstuvwxyz";
+var ASCII_UPPERCASE = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+var ASCII_LETTERS = ASCII_LOWERCASE + ASCII_UPPERCASE;
+var DIGITS = "0123456789";
+var HEX_DIGITS = DIGITS + "abcdefABCDEF";
+var PUNCTUATION = "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~";
+var WHITESPACE = " 	\n\r\v\f";
+var PRINTABLE = DIGITS + ASCII_LETTERS + PUNCTUATION + WHITESPACE;
+
+// src/lib/padding-utils.ts
+function padLeft(str, length, padStr = BLANK_SPACE) {
+  return str.padStart(length, padStr);
+}
+function padRight(str, length, padStr = BLANK_SPACE) {
+  return str.padEnd(length, padStr);
+}
+function padCenter(str, length, prefer = "left", padStr = BLANK_SPACE) {
+  const midStrLength = length - str.length;
+  if (midStrLength > 0) {
+    const padLeftAmount = prefer === "left" ? Math.ceil(midStrLength / 2) : Math.floor(midStrLength / 2);
+    const padRightAmount = prefer === "left" ? Math.floor(midStrLength / 2) : Math.ceil(midStrLength / 2);
+    return padLeft("", padLeftAmount, padStr) + str + padRight("", padRightAmount, padStr);
+  } else {
+    return str;
+  }
+}
+function padCenterPreferRight(str, length, padStr = BLANK_SPACE) {
+  return padCenter(str, length, "right", padStr);
+}
+
+// src/lib/ascii-tables/ascii-table-utils.ts
+import stringWidth from "string-width";
+var ASCIITableUtils = class _ASCIITableUtils {
+  static centerText(text, width) {
+    return padCenterPreferRight(text, width, " ");
+  }
+  static createSeparator(columnWidths, character = "=") {
+    const totalWidth = columnWidths.reduce((sum, width) => sum + width + 3, 0) - 1;
+    return `+${padRight("", totalWidth, character)}+`;
+  }
+  static wrapText(text, maxLength) {
+    const words = text.split(" ");
+    const lines = [];
+    let currentLine = "";
+    for (const word of words) {
+      if (stringWidth(currentLine) + stringWidth(word) + 1 <= maxLength) {
+        currentLine += (currentLine ? " " : "") + word;
+      } else {
+        if (currentLine) {
+          lines.push(currentLine);
+        }
+        if (stringWidth(word) <= maxLength) {
+          currentLine = word;
+        } else {
+          const subWords = _ASCIITableUtils.splitWord(word, maxLength);
+          lines.push(...subWords.slice(0, -1));
+          currentLine = subWords[subWords.length - 1];
+        }
+      }
+    }
+    if (currentLine) {
+      lines.push(currentLine);
+    }
+    return lines;
+  }
+  static splitWord(word, maxLength) {
+    const graphemes = splitGraphemes(word);
+    const subWords = [];
+    let currentSubWord = "";
+    for (const grapheme of graphemes) {
+      if (stringWidth(currentSubWord + grapheme) <= maxLength) {
+        currentSubWord += grapheme;
+      } else {
+        subWords.push(currentSubWord);
+        currentSubWord = grapheme;
+      }
+    }
+    if (currentSubWord) {
+      subWords.push(currentSubWord);
+    }
+    return subWords;
+  }
+};
+
+// src/lib/ascii-tables/multi-column-ascii-table.ts
+import stringWidth2 from "string-width";
+var MultiColumnASCIITable = class {
+  headers;
+  rows;
+  tableWidth;
+  emptyMessage;
+  widthMode;
+  constructor(headers, options = {}) {
+    this.headers = headers;
+    this.rows = [];
+    this.tableWidth = options.tableWidth || 80;
+    this.emptyMessage = options.emptyMessage || "";
+    this.widthMode = options.widthMode || "flex";
+    const minTableWidth = this.getMinimumWidth();
+    if (this.tableWidth < minTableWidth) {
+      throw new Error(
+        `Table width must be at least ${minTableWidth} to accommodate the headers.`
+      );
+    }
+  }
+  getMinimumWidth() {
+    return this.headers.length * 4 + 1;
+  }
+  addRow(row) {
+    if (row.length !== this.headers.length) {
+      throw new Error(
+        `Number of values in the row (${row.length}) must match the number of headers (${this.headers.length}).`
+      );
+    }
+    this.rows.push(row);
+  }
+  toString(options = {}) {
+    const tableWidth = options.tableWidth || this.tableWidth;
+    const emptyMessage = options.emptyMessage || this.emptyMessage;
+    if (this.rows.length === 0) {
+      const emptyTableWidth = Math.min(tableWidth, 40);
+      const separator = "+" + "-".repeat(emptyTableWidth - 2) + "+";
+      const emptyMessageLines = ASCIITableUtils.wrapText(
+        emptyMessage,
+        emptyTableWidth - 4
+      );
+      const emptyRows = emptyMessageLines.map((line) => {
+        const paddingLeft = " ".repeat(
+          Math.floor((emptyTableWidth - stringWidth2(line) - 4) / 2)
+        );
+        const paddingRight = " ".repeat(
+          Math.ceil((emptyTableWidth - stringWidth2(line) - 4) / 2)
+        );
+        return `| ${paddingLeft}${line}${paddingRight} |`;
+      });
+      if (emptyRows.length === 0) {
+        emptyRows.push(`| ${" ".repeat(emptyTableWidth - 4)} |`);
+      }
+      return [separator, ...emptyRows, separator].join("\n");
+    }
+    const columnWidths = this.calculateColumnWidths(options);
+    const headerSeparator = ASCIITableUtils.createSeparator(columnWidths);
+    const rowSeparator = ASCIITableUtils.createSeparator(columnWidths, "-");
+    let tableString = headerSeparator + "\n";
+    const header = this.renderRow(this.headers, columnWidths);
+    tableString += header + "\n" + rowSeparator + "\n";
+    const rows = this.rows.map((row) => {
+      return this.renderRow(row, columnWidths);
+    });
+    tableString += rows.join("\n" + rowSeparator + "\n");
+    tableString += "\n" + headerSeparator;
+    return tableString;
+  }
+  calculateColumnWidths(options = {}) {
+    const tableWidth = options.tableWidth || this.tableWidth;
+    const widthMode = options.widthMode || this.widthMode;
+    const numColumns = this.headers.length;
+    if (widthMode === "fixed") {
+      const availableWidth2 = tableWidth - (numColumns + 1) * 3 + 1;
+      const columnWidth = Math.floor(availableWidth2 / numColumns);
+      const extraWidth = availableWidth2 % numColumns;
+      const columnWidths = new Array(numColumns).fill(columnWidth);
+      for (let i = 0; i < extraWidth; i++) {
+        columnWidths[i] += 1;
+      }
+      return columnWidths;
+    }
+    const availableWidth = tableWidth - (numColumns + 1) * 3 + 1;
+    const maxColumnWidth = Math.floor(availableWidth / numColumns);
+    const totalContentWidth = this.headers.reduce(
+      (sum, header) => sum + stringWidth2(header),
+      0
+    );
+    if (availableWidth >= totalContentWidth) {
+      const remainingWidth = availableWidth - totalContentWidth;
+      const extraCharWidth = Math.floor(remainingWidth / numColumns);
+      const extraCharRemainder = remainingWidth % numColumns;
+      const columnWidths = this.headers.map((header, index) => {
+        const extraWidth = index < extraCharRemainder ? 1 : 0;
+        return stringWidth2(header) + extraCharWidth + extraWidth;
+      });
+      return columnWidths;
+    } else {
+      const columnWidths = this.headers.map(() => maxColumnWidth);
+      return columnWidths;
+    }
+  }
+  renderRow(row, columnWidths) {
+    const wrappedCells = row.map((value, index) => {
+      const wrappedLines = ASCIITableUtils.wrapText(value, columnWidths[index]);
+      return wrappedLines.map((line) => line.padEnd(columnWidths[index])).join("\n");
+    });
+    const maxLines = Math.max(
+      ...wrappedCells.map((cell) => cell.split("\n").length)
+    );
+    const paddedRows = [];
+    for (let i = 0; i < maxLines; i++) {
+      const rowLine = wrappedCells.map((cell, index) => {
+        const cellLines = cell.split("\n");
+        const cellLine = cellLines[i] || "";
+        const padding = " ".repeat(columnWidths[index] - stringWidth2(cellLine));
+        return " " + cellLine + padding + " ";
+      });
+      paddedRows.push("|" + rowLine.join("|") + "|");
+    }
+    return paddedRows.join("\n");
+  }
+};
+
+// src/lib/ascii-tables/key-value-ascii-table.ts
+import stringWidth3 from "string-width";
+var KeyValueASCIITable = class _KeyValueASCIITable {
+  tableWidth;
+  emptyMessage;
+  autoAdjustWidthWhenPossible = true;
+  rows = [];
+  constructor(options = {}) {
+    const minTableWidth = this.getMinimumWidth();
+    if (options.tableWidth && options.tableWidth < minTableWidth) {
+      throw new Error(
+        `Table width must be at least ${minTableWidth} to accommodate the table structure.`
+      );
+    }
+    this.tableWidth = options.tableWidth || 80;
+    this.autoAdjustWidthWhenPossible = options.autoAdjustWidthWhenPossible ?? true;
+    this.emptyMessage = options.emptyMessage || "";
+  }
+  getMinimumWidth() {
+    return 9;
+  }
+  /**
+   * Adds key and value to the table but placing the value on its own row.
+   *
+   * @param key
+   * @param value
+   */
+  addValueOnSeparateRow(key, value) {
+    const row = { kind: "own", key, value };
+    this.rows.push(row);
+  }
+  /**
+   * Adds key and value to the table.
+   *
+   * If provided value is an instance of ASCIITable or MultiColumnASCIITable, it will be rendered as a nested table on its own row for readability.
+   *
+   * @param key
+   * @param value
+   */
+  addRow(key, value) {
+    const row = { kind: "regular", key, value };
+    this.rows.push(row);
+  }
+  toString(options = {}) {
+    const tableWidth = options.tableWidth || this.tableWidth;
+    const canAutoAdjustWidthWhenPossible = options.autoAdjustWidthWhenPossible ?? this.autoAdjustWidthWhenPossible;
+    const emptyMessage = options.emptyMessage || this.emptyMessage;
+    if (this.rows.length === 0) {
+      const emptyTableWidth = Math.min(tableWidth, 40);
+      const separator = "+" + "-".repeat(emptyTableWidth - 2) + "+";
+      const emptyMessageLines = ASCIITableUtils.wrapText(
+        emptyMessage,
+        emptyTableWidth - 4
+      );
+      const emptyRows = emptyMessageLines.map((line) => {
+        const paddingLeft = padRight(
+          "",
+          Math.floor((emptyTableWidth - stringWidth3(line) - 4) / 2),
+          " "
+        );
+        const paddingRight = padRight(
+          "",
+          Math.ceil((emptyTableWidth - stringWidth3(line) - 4) / 2),
+          " "
+        );
+        return `| ${paddingLeft}${line}${paddingRight} |`;
+      });
+      if (emptyRows.length === 0) {
+        emptyRows.push(`| ${" ".repeat(emptyTableWidth - 4)} |`);
+      }
+      return [separator, ...emptyRows, separator].join("\n");
+    }
+    const columnWidths = this.calculateColumnWidths(options);
+    const headerSeparator = ASCIITableUtils.createSeparator(columnWidths);
+    const rowSeparator = ASCIITableUtils.createSeparator(columnWidths, "-");
+    let tableString = headerSeparator + "\n";
+    for (const [rowIndex, row] of this.rows.entries()) {
+      const { kind, key, value } = row;
+      if (kind === "own" || value instanceof _KeyValueASCIITable || value instanceof MultiColumnASCIITable || Array.isArray(value)) {
+        const keyString = ASCIITableUtils.centerText(
+          key,
+          columnWidths[0] + columnWidths[1] + 3
+        );
+        tableString += `| ${keyString} |
+`;
+        tableString += rowSeparator + "\n";
+        let valueString = "";
+        if (value instanceof _KeyValueASCIITable) {
+          valueString = this.formatValue(
+            value,
+            tableWidth - 4,
+            canAutoAdjustWidthWhenPossible,
+            ""
+          );
+        } else if (value instanceof MultiColumnASCIITable) {
+          valueString = this.formatValue(
+            value,
+            tableWidth - 4,
+            canAutoAdjustWidthWhenPossible,
+            ""
+          );
+        } else if (Array.isArray(value)) {
+          valueString = this.formatValue(
+            value,
+            tableWidth - 4,
+            canAutoAdjustWidthWhenPossible,
+            ""
+          );
+        } else if (row.kind === "own") {
+          valueString = this.formatTableRowOnOwnRow(
+            value,
+            tableWidth - 4,
+            tableWidth
+          );
+        }
+        const valueLines = valueString.split("\n");
+        const paddedValueLines = valueLines.map((line) => {
+          const padding = padRight("", tableWidth - stringWidth3(line) - 4, " ");
+          return `| ${line}${padding} |`;
+        });
+        tableString += paddedValueLines.join("\n") + "\n";
+        tableString += headerSeparator + "\n";
+      } else {
+        const keyLines = ASCIITableUtils.wrapText(key, columnWidths[0]);
+        const valueLines = ASCIITableUtils.wrapText(
+          this.formatValue(
+            value,
+            columnWidths[1],
+            canAutoAdjustWidthWhenPossible,
+            ""
+          ),
+          columnWidths[1]
+        );
+        const maxLines = Math.max(keyLines.length, valueLines.length);
+        for (let i = 0; i < maxLines; i++) {
+          const keyLine = keyLines[i] || "";
+          const valueLine = valueLines[i] || "";
+          const keyPadding = " ".repeat(columnWidths[0] - stringWidth3(keyLine));
+          const valuePadding = " ".repeat(
+            columnWidths[1] - stringWidth3(valueLine)
+          );
+          tableString += `| ${keyLine}${keyPadding} | ${valueLine}${valuePadding} |
+`;
+          if (i === maxLines - 1) {
+            if (rowIndex === this.rows.length - 1) {
+              tableString += headerSeparator + "\n";
+            } else {
+              tableString += rowSeparator + "\n";
+            }
+          }
+        }
+      }
+    }
+    return tableString.trim();
+  }
+  calculateColumnWidths(options = {}) {
+    const tableWidth = options.tableWidth || this.tableWidth;
+    const canAutoAdjustWidthWhenPossible = options.autoAdjustWidthWhenPossible ?? this.autoAdjustWidthWhenPossible;
+    const columnWidths = [0, 0];
+    for (const row of this.rows) {
+      const { key, value } = row;
+      const keyWidth = stringWidth3(key);
+      const maxKeyWidth = Math.floor((tableWidth - 7) / 2);
+      if (keyWidth > columnWidths[0]) {
+        columnWidths[0] = Math.min(keyWidth, maxKeyWidth);
+        columnWidths[1] = Math.max(0, tableWidth - columnWidths[0] - 7);
+      }
+      if (typeof value === "string") {
+        const valueWidth = Math.max(
+          ...value.split("\n").map((line) => stringWidth3(line))
+        );
+        if (valueWidth > columnWidths[1]) {
+          columnWidths[1] = Math.min(
+            valueWidth,
+            tableWidth - columnWidths[0] - 7
+          );
+          columnWidths[0] = Math.max(0, tableWidth - columnWidths[1] - 7);
+        }
+      } else if (row.kind === "own") {
+        let valueWidth = 0;
+        if (isString(value)) {
+          valueWidth = Math.max(
+            ...value.split("\n").map((line) => stringWidth3(line))
+          );
+        }
+        if (valueWidth > columnWidths[1]) {
+          columnWidths[1] = Math.min(
+            valueWidth,
+            tableWidth - columnWidths[0] - 7
+          );
+          columnWidths[0] = Math.max(0, tableWidth - columnWidths[1] - 7);
+        }
+      } else if (value instanceof _KeyValueASCIITable) {
+        let nestedTableColumnWidths = [];
+        if (canAutoAdjustWidthWhenPossible) {
+          const minWidth = value.getMinimumWidth();
+          const availableWidth2 = tableWidth - columnWidths[0] - 7;
+          const adjustedWidth = clamp(availableWidth2, minWidth, availableWidth2);
+          nestedTableColumnWidths = value.calculateColumnWidths({
+            tableWidth: adjustedWidth
+          });
+        } else {
+          nestedTableColumnWidths = value.calculateColumnWidths();
+        }
+        const nestedTableWidth = nestedTableColumnWidths.reduce((sum, width) => sum + width, 0) + nestedTableColumnWidths.length * 3 - 1;
+        const availableWidth = tableWidth - columnWidths[0] - 7;
+        if (nestedTableWidth > availableWidth) {
+          columnWidths[1] = availableWidth;
+        } else {
+          columnWidths[1] = Math.max(columnWidths[1], nestedTableWidth);
+        }
+      } else if (value instanceof MultiColumnASCIITable) {
+        let nestedTableColumnWidths = [];
+        if (canAutoAdjustWidthWhenPossible) {
+          const minWidth = value.getMinimumWidth();
+          const availableWidth2 = tableWidth - columnWidths[0] - 7;
+          const adjustedWidth = clamp(availableWidth2, minWidth, availableWidth2);
+          nestedTableColumnWidths = value.calculateColumnWidths({
+            tableWidth: adjustedWidth
+          });
+        } else {
+          nestedTableColumnWidths = value.calculateColumnWidths();
+        }
+        const nestedTableWidth = nestedTableColumnWidths.reduce((sum, width) => sum + width, 0) + nestedTableColumnWidths.length * 3 - 1;
+        const availableWidth = tableWidth - columnWidths[0] - 7;
+        if (nestedTableWidth > availableWidth) {
+          columnWidths[1] = availableWidth;
+        } else {
+          columnWidths[1] = Math.max(columnWidths[1], nestedTableWidth);
+        }
+      } else if (Array.isArray(value)) {
+        for (const nestedCell of value) {
+          const nestedKeyWidth = stringWidth3(nestedCell.key);
+          const maxNestedKeyWidth = Math.floor((tableWidth - 7) / 2);
+          if (nestedKeyWidth > columnWidths[0]) {
+            columnWidths[0] = Math.min(nestedKeyWidth, maxNestedKeyWidth);
+            columnWidths[1] = Math.max(0, tableWidth - columnWidths[0] - 7);
+          }
+          if (typeof nestedCell.value === "string") {
+            const nestedValueWidth = Math.max(
+              ...nestedCell.value.split("\n").map((line) => stringWidth3(line))
+            );
+            if (nestedValueWidth > columnWidths[1]) {
+              columnWidths[1] = Math.min(
+                nestedValueWidth,
+                tableWidth - columnWidths[0] - 7
+              );
+              columnWidths[0] = Math.max(0, tableWidth - columnWidths[1] - 7);
+            }
+          }
+        }
+      }
+    }
+    return columnWidths;
+  }
+  formatValue(value, cellWidth, canAutoAdjustWidthWhenPossible, indent = "") {
+    if (typeof value === "string") {
+      return value;
+    } else if (typeof value === "number") {
+      return String(value);
+    } else if (typeof value === "boolean") {
+      return String(value);
+    } else if (value === null) {
+      return "null";
+    } else if (value === void 0) {
+      return "undefined";
+    } else if (value instanceof _KeyValueASCIITable) {
+      let nestedTableLines;
+      if (canAutoAdjustWidthWhenPossible) {
+        const minWidth = value.getMinimumWidth();
+        const adjustedWidth = clamp(cellWidth, minWidth, cellWidth);
+        nestedTableLines = value.toString({ tableWidth: adjustedWidth }).split("\n");
+      } else {
+        nestedTableLines = value.toString().split("\n");
+      }
+      const indentedLines = nestedTableLines.map((line) => `${indent}${line}`);
+      return indentedLines.join("\n");
+    } else if (value instanceof MultiColumnASCIITable) {
+      let nestedTableLines;
+      if (canAutoAdjustWidthWhenPossible) {
+        const minWidth = value.getMinimumWidth();
+        const adjustedWidth = clamp(cellWidth, minWidth, cellWidth);
+        nestedTableLines = value.toString({ tableWidth: adjustedWidth }).split("\n");
+      } else {
+        nestedTableLines = value.toString().split("\n");
+      }
+      const indentedLines = nestedTableLines.map((line) => `${indent}${line}`);
+      return indentedLines.join("\n");
+    } else if (Array.isArray(value)) {
+      const nestedValueLines = [];
+      for (const { key, value: nestedValue } of value) {
+        const formattedKey = `${indent}${key}:`;
+        const formattedValue = this.formatValue(
+          nestedValue,
+          cellWidth - indent.length - stringWidth3(key) - 2,
+          canAutoAdjustWidthWhenPossible,
+          `${indent}`
+        );
+        const wrappedSpacer = padRight("", 4, " ");
+        const wrappedValue = formattedValue.split("\n").map((line) => `${indent}${wrappedSpacer}${line}`);
+        nestedValueLines.push(formattedKey);
+        nestedValueLines.push(...wrappedValue);
+        nestedValueLines.push("");
+      }
+      return nestedValueLines.slice(0, -1).join("\n");
+    } else {
+      throw new TypeError("Invalid value type provided");
+    }
+  }
+  formatTableRowOnOwnRow(value, width, maxRowLength) {
+    const lines = value.split("\n");
+    const paddedLines = lines.map((line) => {
+      const wrappedLines = ASCIITableUtils.wrapText(line, maxRowLength - 4);
+      return wrappedLines.map((wrappedLine) => {
+        const padding = padRight(
+          "",
+          width - stringWidth3(wrappedLine) - 2,
+          " "
+        );
+        return `${wrappedLine}${padding}`;
+      }).join("\n");
+    });
+    return paddedLines.join("\n");
+  }
+};
+
+// src/lib/error-to-string.ts
+function safeStringify(value) {
+  if (value === null || value === void 0) {
+    return String(value);
+  }
+  switch (typeof value) {
+    case "string":
+      return value;
+    case "number":
+    case "boolean":
+    case "bigint":
+      return String(value);
+    case "object":
+      return JSON.stringify(value);
+    case "function":
+      return "[Function]";
+    case "symbol":
+      return value.toString();
+    default:
+      return String(value);
+  }
+}
+function errorToString(error, maxRowLength = 80) {
+  const table = errorToASCIITable(error, maxRowLength);
+  return table.toString();
+}
+function errorToASCIITable(error, maxRowLength) {
+  const table = new KeyValueASCIITable({
+    tableWidth: maxRowLength,
+    autoAdjustWidthWhenPossible: true
+  });
+  if (error && typeof error === "object") {
+    const err = error;
+    table.addRow("Key", "Value");
+    if (err["message"]) {
+      table.addRow("Message", safeStringify(err["message"]));
+    }
+    if (err["name"]) {
+      table.addRow("Name", safeStringify(err["name"]));
+    }
+    if (err["code"]) {
+      table.addRow("Code", safeStringify(err["code"]));
+    }
+    if (err["errno"]) {
+      table.addRow("Errno", safeStringify(err["errno"]));
+    }
+    if (err["errPrefix"]) {
+      table.addRow("Prefix", safeStringify(err["errPrefix"]));
+    }
+    if (err["errType"]) {
+      table.addRow("errType", safeStringify(err["errType"]));
+    }
+    if (err["errCode"]) {
+      table.addRow("errCode", safeStringify(err["errCode"]));
+    }
+    if (err["additionalInfo"]) {
+      const additionalInfo = err["additionalInfo"];
+      const sensitiveFieldNames = err["sensitiveFieldNames"] || [];
+      for (const key in additionalInfo) {
+        if (sensitiveFieldNames.includes(key)) {
+          table.addRow(`AdditionalInfo.${key}`, "***");
+        } else {
+          const value = additionalInfo[key];
+          table.addRow(
+            `AdditionalInfo.${key}`,
+            stringifyValue(value, table, maxRowLength)
+          );
+        }
+      }
+    }
+    if (err["stack"]) {
+      table.addValueOnSeparateRow("Stack", safeStringify(err["stack"]));
+    }
+  }
+  return table;
+}
+function stringifyValue(value, table, maxRowLength) {
+  if (typeof value === "string") {
+    return value;
+  } else if (Array.isArray(value)) {
+    return value.map((item) => {
+      const result = stringifyValue(item, table, maxRowLength);
+      if (typeof result === "string") {
+        return result;
+      } else if (result instanceof KeyValueASCIITable) {
+        return result.toString();
+      } else {
+        return JSON.stringify(result);
+      }
+    }).join(", ");
+  } else if (typeof value === "object" && value !== null) {
+    if (value instanceof Error) {
+      return errorToASCIITable(value, maxRowLength - 4);
+    } else {
+      const entries = Object.entries(value).map(
+        ([key, val]) => ({
+          key,
+          value: stringifyValue(val, table, maxRowLength - 4)
+        })
+      );
+      return entries;
+    }
+  } else {
+    return String(value);
+  }
+}
+
+// src/lib/is-promise.ts
+function isPromise(obj) {
+  return !!obj && (typeof obj === "object" || typeof obj === "function") && // @ts-expect-error - obj is checked to be object/function, then property access works at runtime
+  typeof obj["then"] === "function";
+}
+
+// src/lib/is-function.ts
+function isFunction(value) {
+  return typeof value === "function" || value instanceof Function;
+}
+
+// src/lib/safe-handle-callback.ts
+function safeHandleCallback(callbackName, callback, ...args) {
+  const handleError = (error) => {
+    if (typeof globalThis.dispatchEvent === "function") {
+      globalThis.dispatchEvent(
+        new ErrorEvent("reportError", {
+          error: new Error(
+            `Error in a callback ${callbackName}: ${DOUBLE_EOL}${errorToString(error)}`
+          )
+        })
+      );
+    }
+  };
+  if (isFunction(callback)) {
+    try {
+      const result = callback(...args);
+      if (isPromise(result)) {
+        result.catch((error) => {
+          handleError(error);
+        });
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  } else {
+    handleError(
+      new Error(`Callback provided for ${callbackName} is not a function`)
+    );
+  }
+}
+
+// src/lib/promise-protected-resolver.ts
+var PromiseProtectedResolver = class {
+  promise;
+  get hasResolved() {
+    return this._hasResolved;
+  }
+  _hasResolved = false;
+  resolveHandler;
+  rejectHandler;
+  options;
+  constructor(options = {}) {
+    this.options = options;
+    this.promise = new Promise((resolve, reject) => {
+      this.resolveHandler = resolve;
+      this.rejectHandler = reject;
+    });
+  }
+  resolveOnce(value) {
+    if (!this._hasResolved && this.resolveHandler) {
+      this.executeBeforeCallback("resolve", value);
+      this._hasResolved = true;
+      this.resolveHandler(value);
+    }
+  }
+  rejectOnce(reason) {
+    if (!this._hasResolved && this.rejectHandler) {
+      this.executeBeforeCallback("reject", reason);
+      this._hasResolved = true;
+      this.rejectHandler(reason);
+    }
+  }
+  executeBeforeCallback(action, valueOrReason) {
+    if (this.options.beforeResolveOrReject) {
+      safeHandleCallback(
+        "beforeResolveOrReject",
+        this.options.beforeResolveOrReject,
+        action,
+        valueOrReason
+      );
+    }
+  }
+};
+
+// src/lib/id-helpers.ts
+import ObjectID from "bson-objectid";
+import {
+  v4 as UUIDv4,
+  v7 as UUIDv7,
+  validate as uuidValidate,
+  version as uuidVersion
+} from "uuid";
+import { ulid } from "ulid";
+
+// src/lib/unix-time-helpers.ts
+function convertMSToUnix(value) {
+  return Math.floor(value / 1e3);
+}
+
+// src/lib/id-helpers.ts
+var IDENTIFIER_TYPES = ["objectID", "uuid4", "uuid7", "ulid"];
+function assertIdentifierType(type) {
+  if (!IDENTIFIER_TYPES.includes(type)) {
+    throw new TypeError(
+      `Invalid ID type given: "${type}". Expected one of: ${IDENTIFIER_TYPES.join(", ")}`
+    );
+  }
+}
+function generateID(type, seedTime) {
+  assertIdentifierType(type);
+  if (seedTime !== void 0 && (!Number.isFinite(seedTime) || seedTime < 0)) {
+    throw new TypeError(
+      `seedTime must be a non-negative finite number (milliseconds), got: ${seedTime}`
+    );
+  }
+  if (type === "objectID") {
+    if (seedTime !== void 0) {
+      const unixTime = convertMSToUnix(seedTime);
+      return new ObjectID(unixTime).toHexString();
+    } else {
+      return new ObjectID().toHexString();
+    }
+  } else if (type === "uuid4") {
+    return UUIDv4();
+  } else if (type === "uuid7") {
+    if (seedTime !== void 0) {
+      return UUIDv7({ msecs: seedTime });
+    } else {
+      return UUIDv7();
+    }
+  } else if (type === "ulid") {
+    if (seedTime !== void 0) {
+      return ulid(seedTime);
+    } else {
+      return ulid();
+    }
+  } else {
+    throw new TypeError(`Unhandled identifier type: "${type}"`);
+  }
+}
+
+// src/lib/is-plain-object.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/lib/event-emitter.ts
+var EventEmitterProtected = class {
+  events;
+  constructor() {
+    this.events = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Subscribe to an event
+   * @param event The event name to subscribe to
+   * @param callback The callback function to be called when the event is emitted
+   * @returns A function to unsubscribe from the event
+   */
+  on(event, callback) {
+    if (!this.events.has(event)) {
+      this.events.set(event, /* @__PURE__ */ new Set());
+    }
+    const callbacks = this.events.get(event);
+    if (callbacks) {
+      callbacks.add(callback);
+    }
+    return () => {
+      const callbacks2 = this.events.get(event);
+      if (callbacks2) {
+        callbacks2.delete(callback);
+        if (callbacks2.size === 0) {
+          this.events.delete(event);
+        }
+      }
+    };
+  }
+  /**
+   * Subscribe to an event once - automatically unsubscribes after first emission
+   * @param event The event name to subscribe to
+   * @param callback The callback function to be called when the event is emitted
+   * @returns A function to unsubscribe from the event before it's called
+   */
+  once(event, callback) {
+    const unsubscribe = this.on(event, (data) => {
+      unsubscribe();
+      return callback(data);
+    });
+    return unsubscribe;
+  }
+  /**
+   * Check if a specific callback is registered for an event.
+   * Note: For 'once' handlers, this will return true for the wrapper function, not the original callback.
+   * This means hasListener will return false when checking for the original callback of a 'once' subscription.
+   *
+   * @param event The event name to check
+   * @param callback The callback function to look for
+   * @returns true if the exact callback is registered, false otherwise
+   */
+  hasListener(event, callback) {
+    const callbacks = this.events.get(event);
+    return callbacks?.has(callback) ?? false;
+  }
+  /**
+   * Check if an event has any subscribers
+   * @param event The event name to check
+   * @returns true if the event has subscribers, false otherwise
+   */
+  hasListeners(event) {
+    const callbacks = this.events.get(event);
+    return callbacks !== void 0 && callbacks.size > 0;
+  }
+  /**
+   * Get the number of subscribers for an event
+   * @param event The event name to check
+   * @returns The number of subscribers
+   */
+  listenerCount(event) {
+    const callbacks = this.events.get(event);
+    return callbacks ? callbacks.size : 0;
+  }
+  /**
+   * Remove all event listeners
+   * @param event Optional event name. If not provided, removes all listeners for all events
+   */
+  clear(event) {
+    if (event) {
+      this.events.delete(event);
+    } else {
+      this.events.clear();
+    }
+  }
+  /**
+   * Emit an event with optional data
+   * This method is protected to allow only derived classes to trigger events.
+   * @param event The event name to emit
+   * @param data Optional data to pass to the event handlers
+   */
+  emit(event, data) {
+    const callbacks = this.events.get(event);
+    if (callbacks) {
+      for (const callback of callbacks) {
+        safeHandleCallback(`event handler for ${event}`, callback, data);
+      }
+    }
+  }
+};
+
+// src/lib/retry-utils/lib/retry-runner.ts
+var AttemptContext = class {
+  handled = false;
+  id;
+  abortController;
+  startTime;
+  constructor() {
+    this.id = generateID("ulid");
+    this.abortController = new AbortController();
+    this.startTime = Date.now();
+  }
+};
+var OPERATION_STARTED = "operation-started";
+var OPERATION_ENDED = "operation-ended";
+var ATTEMPT_STARTED = "attempt-started";
+var ATTEMPT_HANDLED = "attempt-handled";
+var RetryRunner = class extends EventEmitterProtected {
+  // Human-readable label for debugging/logging purposes.
+  _operationLabel = "Unnamed Operation";
+  // Retry policy that determines retry behavior and tracks state.
+  policy;
+  // Prevents concurrent run/resume/forceTry calls.
+  _isOperationLocked = false;
+  // Mutable runtime state for the current operation.
+  currentState = this.getEmptyCurrentState();
+  // Grace period for cancellation before we force-complete.
+  _gracePeriodMS = 1e3;
+  // User-provided operation to retry on failure.
+  operation;
+  // Resolver for the current run/resume/forceTry operation.
+  currentOperationResolver;
+  // Resolvers for pending cancel() calls.
+  cancelResolvers = /* @__PURE__ */ new Set();
+  get operationLabel() {
+    return this._operationLabel;
+  }
+  get runnerState() {
+    return this.currentState.runnerState;
+  }
+  get timeTakenMS() {
+    if (this.currentState.finalTimeTakenMS !== null) {
+      return this.currentState.finalTimeTakenMS;
+    } else if (this.currentState.operationStartTime !== null) {
+      return Date.now() - this.currentState.operationStartTime;
+    }
+    return -1;
+  }
+  get attemptTimeTakenMS() {
+    if (this.currentState.currentAttemptContext instanceof AttemptContext && !this.currentState.currentAttemptContext.handled) {
+      return Date.now() - this.currentState.currentAttemptContext.startTime;
+    }
+    return this.currentState.lastAttemptTimeTakenMS;
+  }
+  get retryTimeRemaining() {
+    if (this.currentState.retryTimeoutHandle !== null && this.currentState.retryTimeoutStartTime !== null && this.currentState.retryTimeoutDelayMS !== null) {
+      const elapsed = Date.now() - this.currentState.retryTimeoutStartTime;
+      const remaining = this.currentState.retryTimeoutDelayMS - elapsed;
+      return Math.max(0, remaining);
+    } else {
+      return -1;
+    }
+  }
+  get canForceTry() {
+    return this.currentState.runnerState === "running" || this.currentState.runnerState === "exhausted" || this.currentState.runnerState === "fatal-error" || this.currentState.runnerState === "not-started" || this.currentState.runnerState === "stopping" || this.currentState.runnerState === "stopped";
+  }
+  get wasLastAttemptForced() {
+    return this.currentState.lastAttemptWasForceTry;
+  }
+  get errors() {
+    return this.policy.errors;
+  }
+  get wasInitialAttemptTaken() {
+    return this.policy.wasInitialAttemptTaken;
+  }
+  get areAttemptsExhausted() {
+    return this.policy.areAttemptsExhausted;
+  }
+  get attempts() {
+    return this.policy.attempts;
+  }
+  get mostCommonError() {
+    return this.policy.mostCommonError;
+  }
+  get lastError() {
+    return this.policy.lastError;
+  }
+  get maxRetryAttempts() {
+    return this.policy.maxRetryAttempts;
+  }
+  get policyInfo() {
+    return this.policy.policyInfo;
+  }
+  get retryCount() {
+    return this.policy.retryCount;
+  }
+  get wasSuccessful() {
+    return this.policy.wasSuccessful;
+  }
+  get isRetryPending() {
+    return this.currentState.retryTimeoutHandle !== null;
+  }
+  get isOperationRunning() {
+    return this.currentState.runnerState === "running" || this.currentState.runnerState === "stopping";
+  }
+  get isAttemptRunning() {
+    if (this.currentState.currentAttemptContext instanceof AttemptContext) {
+      return !this.currentState.currentAttemptContext.handled;
+    } else {
+      return false;
+    }
+  }
+  get graceCancelPeriodMS() {
+    return this._gracePeriodMS;
+  }
+  constructor(policy, operation, options) {
+    super();
+    this.policy = new RetryPolicy(policy);
+    this.operation = operation;
+    if (isPlainObject(options)) {
+      if (isString(options.operationLabel)) {
+        this._operationLabel = options.operationLabel;
+      }
+      if (isFunction(options.onOperationStarted)) {
+        this.on(
+          OPERATION_STARTED,
+          options.onOperationStarted
+        );
+      }
+      if (isFunction(options.onOperationEnded)) {
+        this.on(
+          OPERATION_ENDED,
+          options.onOperationEnded
+        );
+      }
+      if (isFunction(options.onAttemptStarted)) {
+        this.on(
+          ATTEMPT_STARTED,
+          options.onAttemptStarted
+        );
+      }
+      if (isFunction(options.onAttemptHandled)) {
+        this.on(
+          ATTEMPT_HANDLED,
+          options.onAttemptHandled
+        );
+      }
+    }
+  }
+  /**
+   * Set the grace period for cancellation in milliseconds
+   *
+   * Overrides the default grace period of 1000ms
+   * Non-finite or negative values default to 1000ms. Use 0 for immediate force-cancel.
+   */
+  overrideGraceCancelPeriodMS(value) {
+    if (!isFinite(value) || value < 0) {
+      this._gracePeriodMS = 1e3;
+    } else {
+      this._gracePeriodMS = value;
+    }
+  }
+  async waitForCompletion() {
+    switch (this.currentState.runnerState) {
+      case "completed":
+      case "exhausted":
+      case "fatal-error":
+      case "stopped":
+        return this.currentOperationResolver.promise;
+      case "running":
+      case "stopping":
+        return this.currentOperationResolver.promise;
+      case "not-started":
+        return {
+          status: "not_started",
+          code: "not_running",
+          error: new RetryUtilsErrRunnerNotRunning("waitForCompletion")
+        };
+      default:
+        throw new RetryUtilsErrRunnerUnknownState(
+          "waitForCompletion",
+          this.currentState.runnerState
+        );
+    }
+  }
+  async run(shouldWaitForCompletion = false) {
+    if (this._isOperationLocked) {
+      return {
+        status: "pre_operation_error",
+        code: "lock_error",
+        error: new RetryUtilsErrRunnerLockAcquisitionError("run")
+      };
+    }
+    this._isOperationLocked = true;
+    try {
+      const checkDisallowedStates = this.checkForDisallowedPerOperationStates(
+        "run",
+        [
+          "completed",
+          "running",
+          "stopping",
+          "stopped",
+          "fatal-error",
+          "exhausted"
+        ]
+      );
+      if (checkDisallowedStates.wasDisallowed && checkDisallowedStates.runResult) {
+        return checkDisallowedStates.runResult;
+      } else if (this.policy.shouldDoFirstTry()) {
+        this.currentState.runnerState = "running";
+        this.currentState.operationStartTime = Date.now();
+        this.currentState.finalTimeTakenMS = null;
+        this.emit(OPERATION_STARTED, { operationType: "initial" });
+        this.currentOperationResolver = new PromiseProtectedResolver();
+        void this.attemptOperation(false);
+        if (shouldWaitForCompletion) {
+          return this.currentOperationResolver.promise;
+        } else {
+          return { status: "running" };
+        }
+      } else {
+        return {
+          status: "pre_operation_error",
+          code: "unexpected_error",
+          error: new RetryUtilsErrRunnerUnexpectedError(
+            "run",
+            new Error(
+              "Not first try, but this should had been caught before this point"
+            )
+          )
+        };
+      }
+    } catch (error) {
+      return {
+        status: "pre_operation_error",
+        code: "unexpected_error",
+        error: new RetryUtilsErrRunnerUnexpectedError("run", error)
+      };
+    } finally {
+      this._isOperationLocked = false;
+    }
+  }
+  async cancel() {
+    if (this.currentState.runnerState === "running" || this.currentState.runnerState === "stopping") {
+      const cancellationPromiseProtectedResolver = new PromiseProtectedResolver();
+      this.cancelResolvers.add(cancellationPromiseProtectedResolver);
+      if (this.currentState.runnerState !== "stopping") {
+        this.currentState.runnerState = "stopping";
+        this.cleanupTimers();
+        if (!this.currentState.currentAttemptContext || this.currentState.currentAttemptContext.handled) {
+          this.confirmCancellation("stopped", {
+            status: "canceled"
+          });
+        } else {
+          this.currentState.currentAttemptContext.abortController.abort();
+          this.currentState.cancellationTimeoutHandle = setTimeout(() => {
+            if (this.currentState.currentAttemptContext instanceof AttemptContext && !this.currentState.currentAttemptContext.handled) {
+              if (this.currentState.runnerState === "stopping") {
+                const context = this.currentState.currentAttemptContext;
+                context.handled = true;
+                this.currentState.currentAttemptContext = null;
+                this.cleanupTimers();
+                const attemptTimeElapsedMS = Date.now() - context.startTime;
+                this.currentState.lastAttemptTimeTakenMS = attemptTimeElapsedMS;
+                this.emit(ATTEMPT_HANDLED, {
+                  attemptID: context.id,
+                  status: "skip",
+                  data: void 0,
+                  error: void 0,
+                  operationTimeElapsedMS: this.timeTakenMS,
+                  attemptTimeElapsedMS,
+                  wasCanceled: true
+                });
+                this.confirmCancellation(
+                  "stopped",
+                  {
+                    status: "canceled"
+                  },
+                  true
+                );
+              }
+            }
+          }, this._gracePeriodMS);
+        }
+      }
+      return cancellationPromiseProtectedResolver.promise;
+    } else {
+      return "not-running";
+    }
+  }
+  async reset() {
+    if (this.currentState.runnerState === "running" || this.currentState.runnerState === "stopping") {
+      await this.cancel();
+    }
+    this.currentState = this.getEmptyCurrentState();
+    this.policy.reset();
+  }
+  async resume(shouldWaitForCompletion = false) {
+    if (this._isOperationLocked) {
+      return {
+        status: "pre_operation_error",
+        code: "lock_error",
+        error: new RetryUtilsErrRunnerLockAcquisitionError("resume")
+      };
+    }
+    this._isOperationLocked = true;
+    try {
+      const checkDisallowedStates = this.checkForDisallowedPerOperationStates(
+        "resume",
+        ["completed", "running", "stopping", "fatal-error", "exhausted"]
+      );
+      if (checkDisallowedStates.wasDisallowed && checkDisallowedStates.runResult) {
+        return checkDisallowedStates.runResult;
+      } else {
+        if (this.currentState.runnerState !== "stopped") {
+          return {
+            status: "pre_operation_error",
+            code: "not_paused",
+            error: new RetryUtilsErrRunnerNotPaused("resume")
+          };
+        }
+        this.currentState.runnerState = "running";
+        this.currentState.operationStartTime = Date.now();
+        this.currentState.finalTimeTakenMS = null;
+        this.emit(OPERATION_STARTED, { operationType: "resume" });
+        this.currentOperationResolver = new PromiseProtectedResolver();
+        void this.attemptOperation(false);
+        if (shouldWaitForCompletion) {
+          return this.currentOperationResolver.promise;
+        } else {
+          return { status: "running" };
+        }
+      }
+    } catch (error) {
+      return {
+        status: "pre_operation_error",
+        code: "unexpected_error",
+        error: new RetryUtilsErrRunnerUnexpectedError("resume", error)
+      };
+    } finally {
+      this._isOperationLocked = false;
+    }
+  }
+  async forceTry(options) {
+    const shouldWaitForCompletion = options?.shouldWaitForCompletion ?? false;
+    const shouldAbortRunning = options?.shouldAbortRunning ?? false;
+    if (this._isOperationLocked) {
+      return {
+        status: "pre_operation_error",
+        code: "lock_error",
+        error: new RetryUtilsErrRunnerLockAcquisitionError("forceTry")
+      };
+    }
+    this._isOperationLocked = true;
+    try {
+      const checkDisallowedStates = this.checkForDisallowedPerOperationStates(
+        "forceTry",
+        ["completed"]
+      );
+      if (checkDisallowedStates.wasDisallowed && checkDisallowedStates.runResult) {
+        return checkDisallowedStates.runResult;
+      }
+      if (this.isAttemptRunning && !shouldAbortRunning) {
+        if (shouldWaitForCompletion) {
+          return this.currentOperationResolver.promise;
+        } else {
+          return { status: "running", reattached: true };
+        }
+      }
+      if (this.isAttemptRunning && this.currentState.lastAttemptWasForceTry) {
+        return {
+          status: "pre_operation_error",
+          code: "force_try_in_progress",
+          error: new RetryUtilsErrRunnerForceTryRetryInProgress("forceTry")
+        };
+      }
+      if (this.isAttemptRunning && this.currentState.currentAttemptContext) {
+        this.currentState.currentAttemptContext.abortController.abort();
+      }
+      if (this.currentState.retryTimeoutHandle !== null) {
+        clearTimeout(this.currentState.retryTimeoutHandle);
+        this.currentState.retryTimeoutHandle = null;
+        this.currentState.retryTimeoutStartTime = null;
+        this.currentState.retryTimeoutDelayMS = null;
+        this.currentState.lastAttemptWasForceTry = true;
+        void this.attemptOperation(true);
+        if (shouldWaitForCompletion) {
+          return this.currentOperationResolver.promise;
+        } else {
+          return { status: "running", reattached: false };
+        }
+      } else {
+        if (this.currentState.runnerState === "not-started") {
+          this.policy.shouldDoFirstTry();
+        } else if (this.currentState.runnerState === "stopping" || this.currentState.runnerState === "stopped") {
+          this.cleanupTimers();
+          this.confirmCancellation("running", {
+            status: null
+          });
+        }
+        this.currentState.runnerState = "running";
+        this.currentState.operationStartTime = Date.now();
+        this.currentState.finalTimeTakenMS = null;
+        this.emit(OPERATION_STARTED, { operationType: "force" });
+        if (!this.currentOperationResolver || this.currentOperationResolver.hasResolved) {
+          this.currentOperationResolver = new PromiseProtectedResolver();
+        }
+        void this.attemptOperation(true);
+        if (shouldWaitForCompletion) {
+          return this.currentOperationResolver.promise;
+        } else {
+          return { status: "running", reattached: false };
+        }
+      }
+    } catch (error) {
+      return {
+        status: "pre_operation_error",
+        code: "unexpected_error",
+        error: new RetryUtilsErrRunnerUnexpectedError(
+          "forceTry",
+          error
+        )
+      };
+    } finally {
+      this._isOperationLocked = false;
+    }
+  }
+  /**
+   * Returning a fresh copy of the current state
+   * to be immutable and not changed by the caller
+   */
+  getEmptyCurrentState() {
+    return {
+      runnerState: "not-started",
+      lastAttemptWasForceTry: false,
+      currentAttemptContext: null,
+      retryTimeoutHandle: null,
+      retryTimeoutStartTime: null,
+      retryTimeoutDelayMS: null,
+      cancellationTimeoutHandle: null,
+      operationStartTime: null,
+      finalTimeTakenMS: null,
+      lastAttemptTimeTakenMS: -1
+    };
+  }
+  checkForDisallowedPerOperationStates(methodName, disallowedStates) {
+    for (const checkForState of disallowedStates) {
+      if (checkForState === "completed" && this.currentState.runnerState === "completed") {
+        return {
+          wasDisallowed: true,
+          runResult: {
+            status: "pre_operation_error",
+            code: "already_completed",
+            error: new RetryUtilsErrRunnerAlreadyCompleted(methodName)
+          }
+        };
+      } else if (checkForState === "running" && this.currentState.runnerState === "running") {
+        return {
+          wasDisallowed: true,
+          runResult: {
+            status: "pre_operation_error",
+            code: "already_running",
+            error: new RetryUtilsErrRunnerAlreadyRunning(
+              methodName
+            )
+          }
+        };
+      } else if (checkForState === "stopping" && this.currentState.runnerState === "stopping") {
+        return {
+          wasDisallowed: true,
+          runResult: {
+            status: "pre_operation_error",
+            code: "cancel_pending",
+            error: new RetryUtilsErrRunnerCancelPending(
+              methodName
+            )
+          }
+        };
+      } else if (checkForState === "stopped" && this.currentState.runnerState === "stopped") {
+        return {
+          wasDisallowed: true,
+          runResult: {
+            status: "pre_operation_error",
+            code: "retry_canceled",
+            error: new RetryUtilsErrRunnerRetryCanceled("run")
+          }
+        };
+      } else if (checkForState === "fatal-error" && this.currentState.runnerState === "fatal-error") {
+        return {
+          wasDisallowed: true,
+          runResult: {
+            status: "pre_operation_error",
+            code: "fatally_failed",
+            error: new RetryUtilsErrRunnerLastRetryFatallyFailed(
+              methodName
+            )
+          }
+        };
+      } else if (checkForState === "exhausted" && (this.currentState.runnerState === "exhausted" || this.policy.areAttemptsExhausted)) {
+        return {
+          wasDisallowed: true,
+          runResult: {
+            status: "pre_operation_error",
+            code: "attempts_exhausted",
+            error: new RetryUtilsErrRunnerAttemptsExhausted(
+              methodName
+            )
+          }
+        };
+      }
+    }
+    return { wasDisallowed: false };
+  }
+  cleanupTimers() {
+    if (this.currentState.retryTimeoutHandle) {
+      clearTimeout(this.currentState.retryTimeoutHandle);
+      this.currentState.retryTimeoutHandle = null;
+      this.currentState.retryTimeoutStartTime = null;
+      this.currentState.retryTimeoutDelayMS = null;
+    }
+    if (this.currentState.cancellationTimeoutHandle) {
+      clearTimeout(this.currentState.cancellationTimeoutHandle);
+      this.currentState.cancellationTimeoutHandle = null;
+    }
+  }
+  confirmCancellation(runnerState, resolveInfo, wasForced = false) {
+    if (this.currentState.runnerState === "stopping") {
+      this.cleanupTimers();
+      this.currentState.runnerState = runnerState;
+      for (const resolver of this.cancelResolvers) {
+        resolver.resolveOnce(wasForced ? "forced" : "canceled");
+        this.cancelResolvers.delete(resolver);
+      }
+    } else {
+      this.currentState.runnerState = runnerState;
+    }
+    if (runnerState !== "running") {
+      this.currentState.finalTimeTakenMS = this.currentState.operationStartTime !== null ? Date.now() - this.currentState.operationStartTime : -1;
+      this.emit(OPERATION_ENDED, {
+        runnerState,
+        timeTakenMS: this.timeTakenMS
+      });
+      if (resolveInfo.status !== null) {
+        if (resolveInfo.status === "attempt_success") {
+          this.currentOperationResolver.resolveOnce({
+            status: "attempt_success",
+            ...resolveInfo.data !== void 0 ? { data: resolveInfo.data } : {}
+          });
+        } else {
+          const nonSuccessResult = {
+            status: resolveInfo.status
+          };
+          if (resolveInfo.code !== void 0) {
+            nonSuccessResult.code = resolveInfo.code;
+          }
+          if (resolveInfo.error !== void 0) {
+            nonSuccessResult.error = resolveInfo.error;
+          }
+          this.currentOperationResolver.resolveOnce(nonSuccessResult);
+        }
+      }
+    }
+  }
+  handleReportResult(context, status, valueInfo) {
+    if (
+      // Ensure the context matches the current context
+      this.currentState.currentAttemptContext && context.id !== this.currentState.currentAttemptContext.id || // Ensure the result hasn't already been handled
+      context.handled
+    ) {
+      return;
+    }
+    this.currentState.currentAttemptContext = null;
+    this.cleanupTimers();
+    context.handled = true;
+    let isSkip = false;
+    let shouldQueryForRetry = false;
+    let confirmCancellationInfo = {
+      run: false,
+      runnerState: null,
+      resolveInfo: null
+    };
+    if (status === "success") {
+      this.policy.markAsSuccessful();
+      confirmCancellationInfo = {
+        run: true,
+        runnerState: "completed",
+        resolveInfo: {
+          status: "attempt_success",
+          data: valueInfo.data
+        }
+      };
+    } else if (status === "error") {
+      shouldQueryForRetry = true;
+    } else if (status === "fatal") {
+      this.policy.shouldRetry(valueInfo.error ?? valueInfo.data, false);
+      confirmCancellationInfo = {
+        run: true,
+        runnerState: "fatal-error",
+        resolveInfo: {
+          status: "attempt_fatal",
+          error: valueInfo.error
+        }
+      };
+    } else {
+      isSkip = true;
+      shouldQueryForRetry = true;
+    }
+    if (shouldQueryForRetry) {
+      const shouldRetryQuery = this.policy.shouldRetry(
+        valueInfo.error ?? valueInfo.data,
+        isSkip
+      );
+      const isCanceledOrPendingCancel = this.currentState.runnerState === "stopping" || this.currentState.runnerState === "stopped";
+      if (isCanceledOrPendingCancel) {
+        confirmCancellationInfo = {
+          run: true,
+          runnerState: "stopped",
+          resolveInfo: {
+            status: "canceled"
+          }
+        };
+      } else {
+        if (shouldRetryQuery.shouldRetry) {
+          if (shouldRetryQuery.delayMS > 0) {
+            this.currentState.retryTimeoutStartTime = Date.now();
+            this.currentState.retryTimeoutDelayMS = shouldRetryQuery.delayMS;
+            this.currentState.retryTimeoutHandle = setTimeout(() => {
+              this.currentState.retryTimeoutHandle = null;
+              this.currentState.retryTimeoutStartTime = null;
+              this.currentState.retryTimeoutDelayMS = null;
+              void this.attemptOperation(false);
+            }, shouldRetryQuery.delayMS);
+          } else {
+            void this.attemptOperation(false);
+          }
+        } else {
+          confirmCancellationInfo = {
+            run: true,
+            runnerState: "exhausted",
+            resolveInfo: {
+              status: "attempts_exhausted",
+              error: valueInfo.error
+            }
+          };
+        }
+      }
+    }
+    const attemptTimeElapsedMS = Date.now() - context.startTime;
+    this.currentState.lastAttemptTimeTakenMS = attemptTimeElapsedMS;
+    this.emit(ATTEMPT_HANDLED, {
+      attemptID: context.id,
+      status,
+      data: valueInfo.data,
+      error: valueInfo.error,
+      operationTimeElapsedMS: this.timeTakenMS,
+      attemptTimeElapsedMS,
+      wasCanceled: this.currentState.runnerState === "stopping" || this.currentState.runnerState === "stopped"
+    });
+    if (confirmCancellationInfo.run && confirmCancellationInfo.runnerState !== null && confirmCancellationInfo.resolveInfo !== null) {
+      this.confirmCancellation(
+        confirmCancellationInfo.runnerState,
+        confirmCancellationInfo.resolveInfo
+      );
+    }
+    if (this.currentState.runnerState === "stopping") {
+      this.confirmCancellation("stopped", {
+        status: null
+      });
+    }
+  }
+  async attemptOperation(wasForced) {
+    if (this.currentState.currentAttemptContext instanceof AttemptContext) {
+      if (this.currentState.currentAttemptContext.handled) {
+        return;
+      }
+    }
+    if (this.currentState.runnerState === "running") {
+      this.currentState.lastAttemptWasForceTry = wasForced;
+      const context = new AttemptContext();
+      this.currentState.currentAttemptContext = context;
+      this.emit(ATTEMPT_STARTED, {
+        attemptID: context.id,
+        operationTimeElapsedMS: this.timeTakenMS,
+        attemptTimeElapsedMS: 0
+      });
+      const reportResult = (status, value) => {
+        if (status === "success" || status === "skip") {
+          this.handleReportResult(context, status, {
+            data: value
+          });
+        } else {
+          this.handleReportResult(context, status, {
+            error: value
+          });
+        }
+      };
+      try {
+        const result = this.operation(
+          reportResult,
+          context.abortController.signal
+        );
+        if (isPromise(result)) {
+          await result;
+        }
+      } catch (error) {
+        this.handleReportResult(context, "error", {
+          error
+        });
+      }
+    }
+  }
+};
+export {
+  ATTEMPT_HANDLED,
+  ATTEMPT_STARTED,
+  OPERATION_ENDED,
+  OPERATION_STARTED,
+  RetryPolicy,
+  RetryRunner,
+  RetryUtilsErrPolicyConfigInvalidStrategy,
+  RetryUtilsErrRunnerAlreadyCompleted,
+  RetryUtilsErrRunnerAlreadyRunning,
+  RetryUtilsErrRunnerAttemptsExhausted,
+  RetryUtilsErrRunnerCancelPending,
+  RetryUtilsErrRunnerForceTryRetryInProgress,
+  RetryUtilsErrRunnerLastRetryFatallyFailed,
+  RetryUtilsErrRunnerLockAcquisitionError,
+  RetryUtilsErrRunnerNotPaused,
+  RetryUtilsErrRunnerNotRunning,
+  RetryUtilsErrRunnerRetryCanceled,
+  RetryUtilsErrRunnerUnexpectedError,
+  RetryUtilsErrRunnerUnknownState
+};
+//# sourceMappingURL=index.js.map