lifecycleion 0.0.1

package/dist/lib/logger/index.js

@@ -0,0 +1,2470 @@
+// 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/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";
+
+// src/lib/clamp.ts
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(value, max));
+}
+
+// src/lib/ascii-tables/key-value-ascii-table.ts
+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`)
+    );
+  }
+}
+async function safeHandleCallbackAndWait(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)}`
+          )
+        })
+      );
+    }
+    return { success: false, error };
+  };
+  if (isFunction(callback)) {
+    try {
+      const result = callback(...args);
+      if (isPromise(result)) {
+        const value = await result;
+        return { success: true, value };
+      } else {
+        return { success: true, value: result };
+      }
+    } catch (error) {
+      return handleError(error);
+    }
+  } else {
+    return handleError(
+      new Error(`Callback provided for ${callbackName} is not a function`)
+    );
+  }
+}
+
+// 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);
+      }
+    }
+  }
+};
+var EventEmitter = class extends EventEmitterProtected {
+  /**
+   * Emit an event with optional data
+   * This method is public, allowing any code with access to the emitter to trigger events.
+   * @param event The event name to emit
+   * @param data Optional data to pass to the event handlers
+   */
+  emit(event, data) {
+    super.emit(event, data);
+  }
+};
+
+// src/lib/unix-time-helpers.ts
+function ms() {
+  return Date.now();
+}
+
+// src/lib/curly-brackets.ts
+var CurlyBrackets = function(str = "", locals = {}, fallback = "(null)") {
+  if (!str.includes("{{")) {
+    return str;
+  }
+  const compiled = CurlyBrackets.compileTemplate(str, fallback);
+  return compiled(locals);
+};
+CurlyBrackets.compileTemplate = function(str, fallback = "(null)") {
+  const pattern = /(?:\\)?{{(\s*[\w.]+?)(?:\\)?\s*}}/g;
+  return (locals) => {
+    return str.replace(pattern, (match, p1) => {
+      if (typeof p1 !== "string") {
+        return match;
+      }
+      const hasLeadingEscape = match.startsWith("\\");
+      const hasEndingEscape = match.endsWith("\\}}");
+      const isFullyEscaped = hasLeadingEscape && hasEndingEscape;
+      if (isFullyEscaped) {
+        return match.slice(1, -3) + "}}";
+      }
+      if (hasLeadingEscape) {
+        return match.slice(1);
+      }
+      if (hasEndingEscape) {
+        return "{{" + p1.trim() + "}}";
+      }
+      const key = p1.trim();
+      const parts = key.split(".");
+      let replacement = locals;
+      for (const part of parts) {
+        if (replacement !== void 0 && replacement !== null && typeof replacement === "object" && part in replacement) {
+          replacement = replacement[part];
+        } else {
+          replacement = void 0;
+          break;
+        }
+      }
+      if (replacement === void 0 || replacement === null) {
+        return fallback;
+      }
+      return String(replacement);
+    });
+  };
+};
+CurlyBrackets.escape = function(str) {
+  return str.replace(/(\\)?{{/g, (match, backslash) => backslash ? match : "\\{{").replace(/(\\)?}}/g, (match, backslash) => backslash ? match : "\\}}");
+};
+
+// src/lib/is-number.ts
+function isNumber(value) {
+  return typeof value === "number" && !isNaN(value);
+}
+
+// src/lib/logger/sinks/array.ts
+var ArraySink = class {
+  logs = [];
+  transformer;
+  closed = false;
+  constructor(options) {
+    this.transformer = options?.transformer;
+  }
+  write(entry) {
+    if (this.closed) {
+      return;
+    }
+    if (this.transformer) {
+      try {
+        const transformed = this.transformer(entry);
+        if (transformed !== false) {
+          this.logs.push(transformed);
+          return;
+        }
+      } catch {
+      }
+    }
+    this.logs.push(entry);
+  }
+  /**
+   * Clear all stored logs
+   */
+  clear() {
+    this.logs = [];
+  }
+  /**
+   * Get logs in a snapshot-friendly format for testing
+   */
+  getSnapshotFriendlyLogs() {
+    return this.logs.map((log) => `${log.type}: ${log.message}`);
+  }
+  /**
+   * Close the sink and stop accepting new logs
+   */
+  close() {
+    this.closed = true;
+  }
+};
+
+// src/lib/logger/sinks/console.ts
+import { format } from "date-fns";
+
+// src/lib/logger/types.ts
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["ERROR"] = 0] = "ERROR";
+  LogLevel2[LogLevel2["WARN"] = 1] = "WARN";
+  LogLevel2[LogLevel2["NOTICE"] = 2] = "NOTICE";
+  LogLevel2[LogLevel2["SUCCESS"] = 3] = "SUCCESS";
+  LogLevel2[LogLevel2["INFO"] = 3] = "INFO";
+  LogLevel2[LogLevel2["DEBUG"] = 4] = "DEBUG";
+  LogLevel2[LogLevel2["RAW"] = 99] = "RAW";
+  return LogLevel2;
+})(LogLevel || {});
+function getLogLevel(type) {
+  switch (type) {
+    case "error":
+      return 0 /* ERROR */;
+    case "warn":
+      return 1 /* WARN */;
+    case "notice":
+      return 2 /* NOTICE */;
+    case "success":
+      return 3 /* SUCCESS */;
+    case "info":
+      return 3 /* INFO */;
+    case "debug":
+      return 4 /* DEBUG */;
+    case "raw":
+      return 99 /* RAW */;
+  }
+}
+
+// src/lib/logger/utils/color.ts
+import chalk from "chalk";
+var browserColors = {
+  error: "color: #a95450;",
+  // red
+  info: "color: #ffffff;",
+  // white
+  warn: "color: #f5f566;",
+  // yellow
+  success: "color: #56b97f;",
+  // green
+  notice: "color: #5883bf;",
+  // blue
+  debug: "color: #808080;"
+  // gray
+};
+var chalkColors = {
+  error: "red",
+  info: "white",
+  warn: "yellow",
+  success: "green",
+  notice: "blue",
+  debug: "gray"
+};
+function colorize(type, text) {
+  const isBrowser = typeof globalThis !== "undefined" && "window" in globalThis && "document" in globalThis;
+  if (isBrowser) {
+    return {
+      coloredText: `%c${text}`,
+      style: browserColors[type]
+    };
+  } else {
+    const colorName = chalkColors[type];
+    const chalkColor = chalk[colorName];
+    return {
+      coloredText: chalkColor(text)
+    };
+  }
+}
+
+// src/lib/logger/sinks/console.ts
+var ConsoleSink = class {
+  colors;
+  timestamps;
+  typeLabels;
+  closed = false;
+  muted;
+  minLevel;
+  constructor(options = {}) {
+    this.colors = options.colors ?? true;
+    this.timestamps = options.timestamps ?? false;
+    this.typeLabels = options.typeLabels ?? false;
+    this.muted = options.muted ?? false;
+    this.minLevel = options.minLevel ?? 3 /* INFO */;
+  }
+  write(entry) {
+    if (this.closed || this.muted) {
+      return;
+    }
+    if (entry.type === "raw") {
+      console.log(entry.message);
+      return;
+    }
+    const logLevel = getLogLevel(entry.type);
+    if (logLevel > this.minLevel) {
+      return;
+    }
+    let formattedMessage = "";
+    if (this.timestamps) {
+      const formattedTimestamp = format(entry.timestamp, "MM-dd-yyyy HH:mm:ss");
+      formattedMessage = "[" + formattedTimestamp + "] ";
+    }
+    if (this.typeLabels) {
+      formattedMessage += `[${entry.type.toUpperCase()}] `;
+    }
+    if (entry.serviceName) {
+      formattedMessage += `[${entry.serviceName}] `;
+    }
+    if (entry.entityName) {
+      formattedMessage += `[${entry.entityName}] `;
+    }
+    formattedMessage += entry.message;
+    if (this.colors) {
+      const { coloredText, style } = colorize(entry.type, formattedMessage);
+      switch (entry.type) {
+        case "error":
+          if (style) {
+            console.error(coloredText, style);
+          } else {
+            console.error(coloredText);
+          }
+          break;
+        case "info":
+          if (style) {
+            console.info(coloredText, style);
+          } else {
+            console.info(coloredText);
+          }
+          break;
+        case "warn":
+          if (style) {
+            console.warn(coloredText, style);
+          } else {
+            console.warn(coloredText);
+          }
+          break;
+        case "success":
+        case "notice":
+        case "debug":
+          if (style) {
+            console.log(coloredText, style);
+          } else {
+            console.log(coloredText);
+          }
+          break;
+      }
+    } else {
+      switch (entry.type) {
+        case "error":
+          console.error(formattedMessage);
+          break;
+        case "info":
+          console.info(formattedMessage);
+          break;
+        case "warn":
+          console.warn(formattedMessage);
+          break;
+        case "success":
+        case "notice":
+        case "debug":
+          console.log(formattedMessage);
+          break;
+      }
+    }
+  }
+  /**
+   * Set the minimum log level for this sink
+   */
+  setMinLevel(level) {
+    this.minLevel = level;
+  }
+  /**
+   * Get the current minimum log level
+   */
+  getMinLevel() {
+    return this.minLevel;
+  }
+  /**
+   * Mute the sink to stop writing logs to console
+   */
+  mute() {
+    this.muted = true;
+  }
+  /**
+   * Unmute the sink to resume writing logs to console
+   */
+  unmute() {
+    this.muted = false;
+  }
+  /**
+   * Check if the sink is currently muted
+   */
+  isMuted() {
+    return this.muted;
+  }
+  /**
+   * Close the sink and stop accepting new logs
+   */
+  close() {
+    this.closed = true;
+  }
+};
+
+// src/lib/logger/utils/redaction.ts
+import datamask from "datamask";
+
+// src/lib/deep-clone.ts
+function deepClone(obj) {
+  return cloneInternal(obj, /* @__PURE__ */ new WeakMap());
+}
+function cloneInternal(obj, seen) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (seen.has(obj)) {
+    return seen.get(obj);
+  }
+  if (obj instanceof Date) {
+    return new Date(obj);
+  }
+  if (obj instanceof RegExp) {
+    const flags = obj.flags;
+    const cloned2 = new RegExp(obj.source, flags);
+    cloned2.lastIndex = obj.lastIndex;
+    return cloned2;
+  }
+  if (obj instanceof Map) {
+    const cloned2 = /* @__PURE__ */ new Map();
+    seen.set(obj, cloned2);
+    for (const [key, value] of obj) {
+      cloned2.set(cloneInternal(key, seen), cloneInternal(value, seen));
+    }
+    return cloned2;
+  }
+  if (obj instanceof Set) {
+    const cloned2 = /* @__PURE__ */ new Set();
+    seen.set(obj, cloned2);
+    for (const value of obj) {
+      cloned2.add(cloneInternal(value, seen));
+    }
+    return cloned2;
+  }
+  if (ArrayBuffer.isView(obj) && !(obj instanceof DataView)) {
+    const typedArray = obj;
+    const cloned2 = typedArray.slice();
+    return cloned2;
+  }
+  if (Array.isArray(obj)) {
+    const cloned2 = [];
+    seen.set(obj, cloned2);
+    for (const item of obj) {
+      cloned2.push(cloneInternal(item, seen));
+    }
+    return cloned2;
+  }
+  const cloned = {};
+  seen.set(obj, cloned);
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      cloned[key] = cloneInternal(obj[key], seen);
+    }
+  }
+  return cloned;
+}
+
+// src/lib/logger/utils/redaction.ts
+var defaultRedactFunction = (_keyName, value) => {
+  if (typeof value === "string") {
+    return datamask.string(value, "*", 60);
+  }
+  return "***REDACTED***";
+};
+function setNestedValue(obj, path, value) {
+  const parts = path.split(".");
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    const next = current[part];
+    if (next === void 0 || next === null || typeof next !== "object") {
+      return;
+    }
+    current = next;
+  }
+  const lastPart = parts[parts.length - 1];
+  if (lastPart !== void 0 && lastPart in current) {
+    current[lastPart] = value;
+  }
+}
+function getNestedValue(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === void 0 || current === null || typeof current !== "object" || !(part in current)) {
+      return void 0;
+    }
+    current = current[part];
+  }
+  return current;
+}
+function applyRedaction(params, redactedKeys, redactFunction) {
+  if (!redactedKeys || redactedKeys.length === 0) {
+    return params;
+  }
+  const redactFn = redactFunction || defaultRedactFunction;
+  const redactedParams = deepClone(params);
+  for (const key of redactedKeys) {
+    if (key.includes(".")) {
+      const value = getNestedValue(redactedParams, key);
+      if (value !== void 0) {
+        const redactedValue = redactFn(key, value);
+        setNestedValue(redactedParams, key, redactedValue);
+      }
+    } else {
+      if (key in redactedParams) {
+        redactedParams[key] = redactFn(key, redactedParams[key]);
+      }
+    }
+  }
+  return redactedParams;
+}
+
+// src/lib/logger/utils/error-object.ts
+function prepareErrorObjectLog(prefix, error) {
+  prefix = prefix.trim();
+  let prefixLine = "";
+  if (prefix.length > 0) {
+    prefixLine = prefix + ": " + DOUBLE_EOL;
+  }
+  return prefixLine + errorToString(error);
+}
+
+// src/lib/logger/logger-service.ts
+var LoggerService = class _LoggerService {
+  handleLog;
+  serviceName;
+  entityName;
+  constructor(handleLog, serviceName, entityName) {
+    this.handleLog = handleLog;
+    this.serviceName = serviceName;
+    this.entityName = entityName;
+  }
+  /**
+   * Create a scoped logger for a specific entity within this service
+   */
+  entity(entityName) {
+    return new _LoggerService(this.handleLog, this.serviceName, entityName);
+  }
+  /**
+   * Log an error message
+   */
+  error(message, options) {
+    this.handleLog("error", message, {
+      ...options ?? {},
+      serviceName: this.serviceName,
+      entityName: this.entityName
+    });
+  }
+  /**
+   * Log an error object with optional prefix
+   */
+  errorObject(prefix, error, options) {
+    const message = prepareErrorObjectLog(prefix, error);
+    this.handleLog("error", message, {
+      ...options ?? {},
+      serviceName: this.serviceName,
+      entityName: this.entityName,
+      error
+    });
+  }
+  /**
+   * Log an informational message
+   */
+  info(message, options) {
+    this.handleLog("info", message, {
+      ...options ?? {},
+      serviceName: this.serviceName,
+      entityName: this.entityName
+    });
+  }
+  /**
+   * Log a warning message
+   */
+  warn(message, options) {
+    this.handleLog("warn", message, {
+      ...options ?? {},
+      serviceName: this.serviceName,
+      entityName: this.entityName
+    });
+  }
+  /**
+   * Log a success message
+   */
+  success(message, options) {
+    this.handleLog("success", message, {
+      ...options ?? {},
+      serviceName: this.serviceName,
+      entityName: this.entityName
+    });
+  }
+  /**
+   * Log a notice message
+   */
+  notice(message, options) {
+    this.handleLog("notice", message, {
+      ...options ?? {},
+      serviceName: this.serviceName,
+      entityName: this.entityName
+    });
+  }
+  /**
+   * Log a debug message
+   */
+  debug(message, options) {
+    this.handleLog("debug", message, {
+      ...options ?? {},
+      serviceName: this.serviceName,
+      entityName: this.entityName
+    });
+  }
+  /**
+   * Log a raw message without any formatting
+   */
+  raw(message, options) {
+    this.handleLog("raw", message, {
+      ...options ?? {},
+      serviceName: this.serviceName,
+      entityName: this.entityName
+    });
+  }
+};
+
+// src/lib/logger/sinks/file.ts
+import fs, { promises as fsPromises } from "fs";
+var FileSinkError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "FileSinkError";
+  }
+};
+var FileSink = class {
+  logDir;
+  basename;
+  maxSizeMB;
+  jsonFormat;
+  maxRetries;
+  minLevel;
+  onError;
+  logFileStream;
+  currentLogFile;
+  currentLogSize = 0;
+  writeQueue = [];
+  isInitialized = false;
+  initPromise;
+  isProcessing = false;
+  lastError;
+  consecutiveFailures = 0;
+  totalEntriesWritten = 0;
+  totalEntriesFailed = 0;
+  closing = false;
+  closed = false;
+  closeTimeoutMS;
+  constructor(options) {
+    this.logDir = options.logDir;
+    this.basename = options.basename;
+    this.maxSizeMB = options.maxSizeMB ?? 10;
+    this.jsonFormat = options.jsonFormat ?? false;
+    this.maxRetries = options.maxRetries ?? 3;
+    this.closeTimeoutMS = options.closeTimeoutMS ?? 3e4;
+    this.minLevel = options.minLevel ?? 3 /* INFO */;
+    this.onError = options.onError;
+    this.initPromise = this.initialize();
+  }
+  write(entry) {
+    if (this.closing || this.closed) {
+      return;
+    }
+    if (entry.type !== "raw") {
+      const logLevel = getLogLevel(entry.type);
+      if (logLevel > this.minLevel) {
+        return;
+      }
+    }
+    this.writeQueue.push({ entry, attempts: 0 });
+    if (this.isInitialized) {
+      void this.processQueue();
+    } else if (this.initPromise) {
+      void this.initPromise.then(() => this.processQueue());
+    }
+  }
+  /**
+   * Set the minimum log level for this sink
+   */
+  setMinLevel(level) {
+    this.minLevel = level;
+  }
+  /**
+   * Get the current minimum log level
+   */
+  getMinLevel() {
+    return this.minLevel;
+  }
+  /**
+   * Get current health status of the sink
+   */
+  getHealth() {
+    return {
+      isHealthy: this.consecutiveFailures === 0 && this.isInitialized,
+      queueSize: this.writeQueue.length,
+      lastError: this.lastError,
+      consecutiveFailures: this.consecutiveFailures,
+      isInitialized: this.isInitialized
+    };
+  }
+  /**
+   * Flush all pending writes and wait for completion
+   * Returns statistics about the flush operation
+   * @param timeoutMS Maximum time to wait in milliseconds (default: 30000ms / 30s)
+   */
+  async flush(timeoutMS = 3e4) {
+    if (this.initPromise) {
+      await this.initPromise;
+    }
+    const startWritten = this.totalEntriesWritten;
+    const startFailed = this.totalEntriesFailed;
+    const startTime = Date.now();
+    while (this.writeQueue.length > 0 || this.isProcessing) {
+      if (Date.now() - startTime > timeoutMS) {
+        const entriesWritten2 = this.totalEntriesWritten - startWritten;
+        const entriesFailed2 = this.totalEntriesFailed - startFailed;
+        return {
+          success: false,
+          entriesWritten: entriesWritten2,
+          entriesFailed: entriesFailed2,
+          timedOut: true
+        };
+      }
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+    const entriesWritten = this.totalEntriesWritten - startWritten;
+    const entriesFailed = this.totalEntriesFailed - startFailed;
+    return {
+      success: entriesFailed === 0,
+      entriesWritten,
+      entriesFailed,
+      timedOut: false
+    };
+  }
+  /**
+   * Close the log file and wait for all pending writes
+   */
+  async close() {
+    this.closing = true;
+    const startTime = Date.now();
+    if (this.initPromise) {
+      let timeoutHandle;
+      const timeoutSentinel = { timedOut: true };
+      try {
+        const timeoutPromise = new Promise(
+          (resolve) => {
+            timeoutHandle = setTimeout(
+              () => resolve(timeoutSentinel),
+              this.closeTimeoutMS
+            );
+          }
+        );
+        const result = await Promise.race([
+          this.initPromise.then(() => void 0),
+          timeoutPromise
+        ]);
+        if (result === timeoutSentinel) {
+          Promise.resolve(this.initPromise).catch(() => {
+          });
+        }
+      } finally {
+        if (timeoutHandle) {
+          clearTimeout(timeoutHandle);
+        }
+      }
+    }
+    while (this.writeQueue.length > 0 || this.isProcessing) {
+      if (Date.now() - startTime > this.closeTimeoutMS) {
+        break;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+    this.closed = true;
+    if (this.logFileStream) {
+      return new Promise((resolve) => {
+        if (!this.logFileStream) {
+          return resolve();
+        }
+        this.logFileStream.end(() => {
+          this.logFileStream = void 0;
+          resolve();
+        });
+      });
+    }
+  }
+  /**
+   * Initialize the file sink asynchronously
+   */
+  async initialize() {
+    try {
+      await fsPromises.mkdir(this.logDir, { recursive: true });
+      await this.setupLogFile();
+      this.isInitialized = true;
+      await this.processQueue();
+    } catch {
+    }
+  }
+  /**
+   * Process the write queue
+   * Processes entries one at a time with retry logic
+   */
+  async processQueue() {
+    if (this.isProcessing || this.closed || this.writeQueue.length === 0) {
+      return;
+    }
+    this.isProcessing = true;
+    try {
+      while (this.writeQueue.length > 0) {
+        const queuedEntry = this.writeQueue.shift();
+        if (!queuedEntry) {
+          break;
+        }
+        try {
+          await this.writeEntry(queuedEntry.entry);
+          this.consecutiveFailures = 0;
+          this.totalEntriesWritten++;
+        } catch (error) {
+          const err = error instanceof Error ? error : new Error(String(error));
+          this.lastError = err;
+          this.consecutiveFailures++;
+          const willRetry = queuedEntry.attempts < this.maxRetries;
+          if (this.onError) {
+            try {
+              this.onError(
+                err,
+                queuedEntry.entry,
+                queuedEntry.attempts + 1,
+                willRetry
+              );
+            } catch {
+            }
+          }
+          if (willRetry) {
+            queuedEntry.attempts++;
+            this.writeQueue.push(queuedEntry);
+          } else {
+            this.totalEntriesFailed++;
+          }
+        }
+      }
+    } finally {
+      this.isProcessing = false;
+    }
+  }
+  /**
+   * Write a single entry to the file
+   * If stream is broken, it will be recreated on next attempt
+   */
+  async writeEntry(entry) {
+    if (this.closed) {
+      throw new FileSinkError("Cannot write to closed sink");
+    }
+    if (!this.logFileStream) {
+      await this.setupLogFile();
+    }
+    if (!this.logFileStream) {
+      throw new FileSinkError("No log file stream available");
+    }
+    await this.rotateIfNeeded();
+    const messageToWrite = this.formatEntry(entry);
+    const messageBytes = Buffer.byteLength(messageToWrite, "utf8");
+    const maxSizeBytes = this.maxSizeMB * 1024 * 1024;
+    if (this.currentLogSize + messageBytes > maxSizeBytes) {
+      await this.rotateFile();
+    }
+    return new Promise((resolve, reject) => {
+      if (!this.logFileStream) {
+        return resolve();
+      }
+      this.logFileStream.write(messageToWrite, (err) => {
+        if (err) {
+          this.destroyStream();
+          reject(new FileSinkError("Error writing to log file", err));
+        } else {
+          this.currentLogSize += messageBytes;
+          resolve();
+        }
+      });
+    });
+  }
+  /**
+   * Format a log entry for file output
+   */
+  formatEntry(entry) {
+    let formatted;
+    if (this.jsonFormat) {
+      formatted = JSON.stringify({
+        timestamp: entry.timestamp,
+        type: entry.type,
+        serviceName: entry.serviceName,
+        entityName: entry.entityName,
+        message: entry.message,
+        params: entry.redactedParams
+        // Use redacted params for file output
+      });
+    } else {
+      let text = "";
+      if (entry.type !== "raw") {
+        text = `[${entry.type}] `;
+        if (entry.serviceName) {
+          text += `[${entry.serviceName}] `;
+        }
+        if (entry.entityName) {
+          text += `[${entry.entityName}] `;
+        }
+      }
+      text += entry.message;
+      formatted = text;
+    }
+    return formatted + "\n";
+  }
+  /**
+   * Setup the log file
+   */
+  async setupLogFile() {
+    const currentDate = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    const currentLogFile = `${this.logDir}/${this.basename}-${currentDate}.log`;
+    try {
+      await fsPromises.mkdir(this.logDir, { recursive: true });
+      try {
+        await fsPromises.access(currentLogFile);
+      } catch {
+        await fsPromises.writeFile(currentLogFile, "", { flag: "a" });
+      }
+      this.logFileStream = fs.createWriteStream(currentLogFile, { flags: "a" });
+      this.currentLogFile = currentLogFile;
+      this.logFileStream.on("error", () => {
+        this.destroyStream();
+      });
+      try {
+        const stats = await fsPromises.stat(currentLogFile);
+        this.currentLogSize = stats.size;
+      } catch {
+        this.currentLogSize = 0;
+      }
+      const maxSizeBytes = this.maxSizeMB * 1024 * 1024;
+      if (this.currentLogSize >= maxSizeBytes) {
+        await this.rotateFile();
+      }
+    } catch (error) {
+      throw new FileSinkError(
+        `Failed to setup log file: ${currentLogFile}`,
+        error
+      );
+    }
+  }
+  /**
+   * Destroy the current stream
+   */
+  destroyStream() {
+    if (this.logFileStream) {
+      try {
+        this.logFileStream.destroy();
+      } catch {
+      } finally {
+        this.logFileStream = void 0;
+      }
+    }
+  }
+  /**
+   * Rotate log file if needed based on size or date
+   */
+  async rotateIfNeeded() {
+    if (!this.logFileStream || !this.currentLogFile) {
+      return;
+    }
+    const currentDate = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    const expectedFile = `${this.logDir}/${this.basename}-${currentDate}.log`;
+    if (this.currentLogFile !== expectedFile) {
+      await this.setupLogFile();
+      return;
+    }
+    const maxSizeBytes = this.maxSizeMB * 1024 * 1024;
+    if (this.currentLogSize >= maxSizeBytes) {
+      await this.rotateFile();
+    }
+  }
+  /**
+   * Rotate the current log file
+   * Queue processing pauses during rotation, then resumes
+   */
+  async rotateFile() {
+    if (!this.logFileStream || !this.currentLogFile) {
+      return;
+    }
+    const currentDate = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    await new Promise((resolve) => {
+      if (!this.logFileStream) {
+        return resolve();
+      }
+      this.logFileStream.end(() => {
+        this.logFileStream = void 0;
+        resolve();
+      });
+    });
+    const timestamp = Math.floor(Date.now() / 1e3);
+    const rotatedFile = `${this.logDir}/${this.basename}-${currentDate}-${timestamp}.log`;
+    try {
+      await fsPromises.rename(this.currentLogFile, rotatedFile);
+    } catch (error) {
+      throw new FileSinkError(
+        `Error rotating log file from ${this.currentLogFile} to ${rotatedFile}`,
+        error
+      );
+    }
+    await this.setupLogFile();
+  }
+};
+
+// src/lib/logger/sinks/named-pipe.ts
+import * as fs2 from "fs";
+import { promises as fsPromises2 } from "fs";
+import * as os from "os";
+var PipeErrorType = /* @__PURE__ */ ((PipeErrorType2) => {
+  PipeErrorType2["WRITE"] = "write";
+  PipeErrorType2["CLOSE"] = "close";
+  PipeErrorType2["NOT_FOUND"] = "not_found";
+  PipeErrorType2["NOT_A_PIPE"] = "not_a_pipe";
+  PipeErrorType2["PERMISSION"] = "permission";
+  PipeErrorType2["UNSUPPORTED_PLATFORM"] = "unsupported_platform";
+  return PipeErrorType2;
+})(PipeErrorType || {});
+var NamedPipeSink = class {
+  pipePath;
+  jsonFormat;
+  onError;
+  formatter;
+  pipeStream;
+  writeQueue = [];
+  isInitialized = false;
+  _isReconnecting = false;
+  initPromise;
+  closing = false;
+  closed = false;
+  closeTimeoutMS;
+  constructor(options) {
+    this.pipePath = options.pipePath;
+    this.jsonFormat = options.jsonFormat ?? false;
+    this.onError = options.onError;
+    this.formatter = options.formatter;
+    this.closeTimeoutMS = options.closeTimeoutMS ?? 3e4;
+    this.initPromise = this.initializePipe();
+  }
+  write(entry) {
+    if (this.closing || this.closed) {
+      return;
+    }
+    if (!this.isInitialized) {
+      this.writeQueue.push(entry);
+      return;
+    }
+    this.writeEntry(entry);
+  }
+  /**
+   * Attempt to reconnect to the named pipe.
+   * Useful when the pipe reader restarts or after a temporary error.
+   * Queued writes during the outage will be flushed on successful reconnection.
+   */
+  get isReconnecting() {
+    return this._isReconnecting;
+  }
+  async reconnect() {
+    if (this._isReconnecting) {
+      await this.initPromise;
+      return { success: false, reason: "already_reconnecting" };
+    }
+    this._isReconnecting = true;
+    try {
+      if (this.pipeStream && !this.pipeStream.destroyed) {
+        this.pipeStream.end();
+        this.pipeStream = void 0;
+      }
+      this.isInitialized = false;
+      this.initPromise = this.initializePipe();
+      await this.initPromise;
+      if (this.isInitialized) {
+        return { success: true };
+      } else {
+        return {
+          success: false,
+          reason: "error",
+          error: new Error("Failed to initialize pipe connection")
+        };
+      }
+    } finally {
+      this._isReconnecting = false;
+    }
+  }
+  async close() {
+    this.closing = true;
+    let timeoutHandle;
+    const timeoutSentinel = { timedOut: true };
+    try {
+      const timeoutPromise = new Promise((resolve) => {
+        timeoutHandle = setTimeout(
+          () => resolve(timeoutSentinel),
+          this.closeTimeoutMS
+        );
+      });
+      const result = await Promise.race([
+        this.initPromise.then(() => void 0),
+        timeoutPromise
+      ]);
+      if (result === timeoutSentinel) {
+        Promise.resolve(this.initPromise).catch(() => {
+        });
+      }
+    } finally {
+      if (timeoutHandle) {
+        clearTimeout(timeoutHandle);
+      }
+    }
+    this.closed = true;
+    if (this.pipeStream && !this.pipeStream.destroyed) {
+      return new Promise((resolve) => {
+        try {
+          this.pipeStream?.end(() => {
+            this.pipeStream = void 0;
+            resolve();
+          });
+        } catch (error) {
+          this.handleError(
+            "close" /* CLOSE */,
+            error instanceof Error ? error : new Error(String(error))
+          );
+          resolve();
+        }
+      });
+    }
+  }
+  /**
+   * Initialize the named pipe connection
+   */
+  async initializePipe() {
+    const platform2 = os.platform();
+    if (platform2 !== "linux" && platform2 !== "darwin") {
+      this.handleError(
+        "unsupported_platform" /* UNSUPPORTED_PLATFORM */,
+        new Error(
+          `Named pipes are only supported on Linux and macOS, current platform: ${platform2}`
+        )
+      );
+      return;
+    }
+    try {
+      const stats = await fsPromises2.stat(this.pipePath);
+      if (!stats.isFIFO()) {
+        this.handleError(
+          "not_a_pipe" /* NOT_A_PIPE */,
+          new Error(`${this.pipePath} exists but is not a named pipe (FIFO)`)
+        );
+        return;
+      }
+      this.pipeStream = fs2.createWriteStream(this.pipePath, {
+        flags: "a"
+        // Append mode
+      });
+      this.pipeStream.on("error", (err) => {
+        this.handleError("write" /* WRITE */, err);
+        this.pipeStream = void 0;
+      });
+      this.isInitialized = true;
+      this.processQueue();
+    } catch (error) {
+      this.handleError(
+        "not_found" /* NOT_FOUND */,
+        new Error(
+          `Could not open named pipe at ${this.pipePath}: ${error.message}`
+        )
+      );
+    }
+  }
+  /**
+   * Process queued entries
+   */
+  processQueue() {
+    while (this.writeQueue.length > 0 && !this.closed) {
+      const entry = this.writeQueue.shift();
+      if (entry) {
+        this.writeEntry(entry);
+      }
+    }
+  }
+  /**
+   * Write a single entry
+   */
+  writeEntry(entry) {
+    if (this.closed) {
+      return;
+    }
+    if (!this.pipeStream || this.pipeStream.destroyed) {
+      return;
+    }
+    try {
+      const messageToWrite = this.formatEntry(entry);
+      if (!this.pipeStream.write(messageToWrite)) {
+        this.pipeStream.once("drain", () => {
+        });
+      }
+    } catch (error) {
+      this.handleError(
+        "write" /* WRITE */,
+        error instanceof Error ? error : new Error(String(error))
+      );
+    }
+  }
+  /**
+   * Format a log entry for pipe output
+   */
+  formatEntry(entry) {
+    if (this.formatter) {
+      try {
+        return this.formatter(entry) + "\n";
+      } catch {
+      }
+    }
+    let formatted;
+    if (this.jsonFormat) {
+      formatted = JSON.stringify({
+        timestamp: entry.timestamp,
+        type: entry.type,
+        serviceName: entry.serviceName,
+        entityName: entry.entityName,
+        message: entry.message,
+        params: entry.redactedParams
+      });
+    } else {
+      let text = "";
+      if (entry.type !== "raw") {
+        text = `[${entry.type}] `;
+        if (entry.serviceName) {
+          text += `[${entry.serviceName}] `;
+        }
+        if (entry.entityName) {
+          text += `[${entry.entityName}] `;
+        }
+      }
+      text += entry.message;
+      formatted = text;
+    }
+    return formatted + "\n";
+  }
+  /**
+   * Handle errors
+   */
+  handleError(errorType, error) {
+    if (this.onError) {
+      this.onError(errorType, error, this.pipePath);
+    } else {
+      console.error(`NamedPipeSink error (${errorType}): ${error.message}`);
+    }
+  }
+};
+
+// src/lib/logger/index.ts
+var Logger = class _Logger extends EventEmitter {
+  isLoggerClass = true;
+  sinks;
+  redactFunction;
+  callProcessExit;
+  beforeExitCallback;
+  onSinkError;
+  _didExit = false;
+  _exitCode = 0;
+  _exitRequested = false;
+  _isPendingExit = false;
+  _closed = false;
+  _reportErrorListenerRegistered = false;
+  _reportErrorListener = null;
+  constructor(options = {}) {
+    super();
+    this.sinks = options.sinks || [];
+    this.redactFunction = options.redactFunction;
+    this.callProcessExit = options.callProcessExit ?? true;
+    this.beforeExitCallback = options.beforeExitCallback;
+    this.onSinkError = options.onSinkError;
+  }
+  get didExit() {
+    return this._didExit;
+  }
+  get exitCode() {
+    return this._exitCode;
+  }
+  get isPendingExit() {
+    return this._isPendingExit;
+  }
+  get hasExitedOrPending() {
+    return this._didExit || this._isPendingExit;
+  }
+  get closed() {
+    return this._closed;
+  }
+  /**
+   * Exit the process with the specified code
+   */
+  exit(code) {
+    const isFirstExit = !this._exitRequested;
+    this._exitRequested = true;
+    if (!this._didExit) {
+      this._isPendingExit = true;
+    }
+    this.emit("logger", { eventType: "exit-called", code, isFirstExit });
+    if (this.beforeExitCallback) {
+      safeHandleCallbackAndWait(
+        "beforeExit",
+        this.beforeExitCallback,
+        code,
+        isFirstExit
+      ).then((result) => {
+        if (result.success && result.value?.action === "wait") {
+          return;
+        }
+        this.processExit(code);
+      }).catch(() => {
+        this.processExit(code);
+      });
+    } else {
+      this.processExit(code);
+    }
+  }
+  /**
+   * Set or update the beforeExit callback
+   *
+   * This allows setting the callback after Logger construction, which is useful
+   * when the callback needs to reference objects that depend on the Logger instance.
+   *
+   * **Note:** This method overwrites any existing beforeExit callback (including
+   * one set in the Logger constructor). Pass `undefined` to remove the callback.
+   *
+   * **Error Handling:** If the callback throws an error or rejects, the logger will
+   * proceed with exit anyway to prevent the process from hanging. The error will be
+   * reported via the global `reportError` event.
+   *
+   * @param callback - Function to call before process exit (receives exitCode and isFirstExit).
+   *                   Must return BeforeExitResult indicating whether to proceed with exit or wait.
+   *                   Return `{ action: 'proceed' }` to continue with exit.
+   *                   Return `{ action: 'wait' }` to prevent exit (e.g., shutdown already in progress).
+   *                   If the callback throws, exit proceeds automatically.
+   *
+   *                   Pass undefined to remove the callback.
+   *
+   * @example
+   * ```typescript
+   * const logger = new Logger();
+   * const lifecycle = new LifecycleManager({ logger });
+   *
+   * // Set callback after both are constructed
+   * logger.setBeforeExitCallback(async (exitCode, isFirstExit) => {
+   *   if (isFirstExit) {
+   *     await lifecycle.stopAllComponents();
+   *   }
+   *   return { action: 'proceed' };
+   * });
+   *
+   * // Later, remove the callback
+   * logger.setBeforeExitCallback(undefined);
+   * ```
+   */
+  setBeforeExitCallback(callback) {
+    this.beforeExitCallback = callback;
+  }
+  /**
+   * Log an error message
+   */
+  error(message, options) {
+    this.handleLog("error", message, options);
+  }
+  /**
+   * Log an error object with optional prefix
+   */
+  errorObject(prefix, error, options) {
+    const message = prepareErrorObjectLog(prefix, error);
+    this.handleLog("error", message, { ...options ?? {}, error });
+  }
+  /**
+   * Log an informational message
+   */
+  info(message, options) {
+    this.handleLog("info", message, options);
+  }
+  /**
+   * Log a warning message
+   */
+  warn(message, options) {
+    this.handleLog("warn", message, options);
+  }
+  /**
+   * Log a success message
+   */
+  success(message, options) {
+    this.handleLog("success", message, options);
+  }
+  /**
+   * Log a notice message
+   */
+  notice(message, options) {
+    this.handleLog("notice", message, options);
+  }
+  /**
+   * Log a debug message
+   */
+  debug(message, options) {
+    this.handleLog("debug", message, options);
+  }
+  /**
+   * Log a raw message without any formatting
+   */
+  raw(message, options) {
+    this.handleLog("raw", message, options);
+  }
+  /**
+   * Create a scoped logger with a service name
+   */
+  service(serviceName) {
+    return new LoggerService(this.handleLog.bind(this), serviceName);
+  }
+  /**
+   * Registers a listener for the 'reportError' event.
+   *
+   * If the listener is already registered, it returns 'already_registered'.
+   * If 'globalThis.reportError' is not available, it returns 'not_available'.
+   * Otherwise, it registers the listener and returns 'success'.
+   *
+   * @param prefix - The prefix to use when logging the error object. Default is 'Uncaught exception'.
+   * @returns 'success' if the listener is registered successfully,
+   *          'already_registered' if the listener is already registered,
+   *          'not_available' if 'globalThis.reportError' is not available.
+   */
+  registerReportErrorListener(prefix = "Uncaught exception") {
+    if (this._reportErrorListenerRegistered) {
+      return "already_registered";
+    }
+    if (typeof globalThis.reportError === "undefined") {
+      return "not_available";
+    }
+    this._reportErrorListener = (event) => {
+      const errorEvent = event;
+      this.errorObject(prefix, errorEvent.error);
+      this.emit("logger", {
+        eventType: "uncaughtException",
+        error: errorEvent.error
+      });
+    };
+    globalThis.addEventListener("reportError", this._reportErrorListener);
+    this._reportErrorListenerRegistered = true;
+    return "success";
+  }
+  /**
+   * Unregister the listener for the 'reportError' event.
+   *
+   * If the listener is not registered, it returns 'not_registered'.
+   * Otherwise, it unregister the listener and returns 'success'.
+   *
+   * @returns 'success' if the listener is unregistered successfully,
+   *          'not_registered' if the listener is not registered.
+   */
+  unregisterReportErrorListener() {
+    if (!this._reportErrorListenerRegistered || !this._reportErrorListener) {
+      return "not_registered";
+    }
+    globalThis.removeEventListener("reportError", this._reportErrorListener);
+    this._reportErrorListener = null;
+    this._reportErrorListenerRegistered = false;
+    return "success";
+  }
+  /**
+   * Check if the 'reportError' event listener is registered
+   *
+   * @returns 'true' if the listener is registered, 'false' otherwise.
+   */
+  isReportErrorListenerRegistered() {
+    return this._reportErrorListenerRegistered;
+  }
+  /**
+   * Check if 'globalThis.reportError' is available
+   *
+   * @returns 'true' if 'globalThis.reportError' is available, 'false' otherwise.
+   */
+  isReportErrorAvailable() {
+    return typeof globalThis.reportError !== "undefined";
+  }
+  /**
+   * Add a sink to the logger
+   */
+  addSink(sink) {
+    this.sinks.push(sink);
+  }
+  /**
+   * Remove a sink from the logger
+   * Returns true if the sink was found and removed, false otherwise
+   */
+  removeSink(sink) {
+    const index = this.sinks.indexOf(sink);
+    if (index !== -1) {
+      this.sinks.splice(index, 1);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Get a readonly copy of the current sinks
+   */
+  getSinks() {
+    return [...this.sinks];
+  }
+  /**
+   * Close all sinks and cleanup resources
+   * After closing, the logger is marked as closed and all sinks are removed
+   */
+  async close() {
+    this._closed = true;
+    await Promise.all(
+      this.sinks.map(async (sink) => {
+        if (sink.close) {
+          try {
+            await sink.close();
+          } catch (error) {
+            this.handleSinkError(error, "close", sink);
+          }
+        }
+      })
+    );
+    this.sinks = [];
+    this.emit("logger", { eventType: "close" });
+  }
+  /**
+   * Create a logger optimized for testing.
+   * Includes an ArraySink by default for easy log inspection.
+   * Process exit is disabled to prevent tests from terminating.
+   */
+  static createTestOptimizedLogger(options) {
+    const arraySink = new ArraySink({
+      transformer: options?.arrayLogTransformer
+    });
+    const consoleSink = options?.includeConsoleSink ? new ConsoleSink({ muted: options?.muteConsole ?? true }) : void 0;
+    const sinks = [arraySink];
+    if (consoleSink) {
+      sinks.push(consoleSink);
+    }
+    sinks.push(...options?.sinks || []);
+    return {
+      logger: new _Logger({
+        sinks,
+        callProcessExit: false
+      }),
+      arraySink,
+      consoleSink
+    };
+  }
+  /**
+   * Create a logger optimized for frontend/browser use.
+   * Includes a ConsoleSink by default for browser devtools output.
+   * Process exit is disabled since browsers don't have process.exit.
+   */
+  static createFrontendOptimizedLogger(options) {
+    const consoleSink = new ConsoleSink({
+      muted: options?.muteConsole ?? false
+    });
+    return {
+      logger: new _Logger({
+        sinks: [consoleSink, ...options?.sinks || []],
+        callProcessExit: false
+      }),
+      consoleSink
+    };
+  }
+  /**
+   * Internal method to handle all log operations
+   */
+  handleLog(type, template, options) {
+    if (this._closed) {
+      return;
+    }
+    const timestamp = ms();
+    const exitCode = options?.exitCode;
+    const serviceName = options?.serviceName?.trim() || void 0;
+    const entityName = options?.entityName?.trim() || void 0;
+    const params = options?.params;
+    const tags = options?.tags;
+    const redactedKeys = options?.redactedKeys;
+    const message = params ? CurlyBrackets(template, params) : template;
+    const redactedParams = params ? applyRedaction(params, redactedKeys, this.redactFunction) : void 0;
+    const entry = {
+      timestamp,
+      type,
+      serviceName,
+      entityName,
+      template,
+      message,
+      params,
+      redactedParams,
+      redactedKeys: params && redactedKeys && redactedKeys.length > 0 ? redactedKeys : void 0,
+      error: options?.error,
+      exitCode: isNumber(exitCode) ? exitCode : void 0,
+      tags: tags && tags.length > 0 ? tags : void 0
+    };
+    for (const sink of this.sinks) {
+      try {
+        const result = sink.write(entry);
+        if (isPromise(result)) {
+          result.catch((error) => {
+            this.handleSinkError(error, "write", sink);
+          });
+        }
+      } catch (error) {
+        this.handleSinkError(error, "write", sink);
+      }
+    }
+    this.emit("logger", {
+      eventType: "log",
+      logType: type,
+      message,
+      timestamp
+    });
+    if (isNumber(exitCode)) {
+      this.exit(exitCode);
+    }
+  }
+  /**
+   * Handle sink errors by calling the onSinkError callback or falling back to console.error
+   */
+  handleSinkError(error, context, sink) {
+    if (this.onSinkError) {
+      try {
+        this.onSinkError(error, context, sink);
+      } catch {
+        console.error(`Error in onSinkError handler: ${error.message}`);
+      }
+    } else {
+      console.error(
+        `Error ${context === "write" ? "writing to" : "closing"} sink: ${error.message}`
+      );
+    }
+  }
+  /**
+   * Process the exit
+   */
+  processExit(code) {
+    this._didExit = true;
+    this._exitCode = code;
+    this._isPendingExit = false;
+    this.emit("logger", { eventType: "exit-process", code });
+    void this.close().finally(() => {
+      if (this.callProcessExit) {
+        if (typeof globalThis.process !== "undefined" && typeof globalThis.process.exit === "function") {
+          globalThis.process.exit(code);
+        }
+      }
+    });
+  }
+};
+export {
+  ArraySink,
+  ConsoleSink,
+  FileSink,
+  LogLevel,
+  Logger,
+  NamedPipeSink,
+  PipeErrorType,
+  getLogLevel
+};
+//# sourceMappingURL=index.js.map