lifecycleion 0.0.1

package/dist/lib/process-signal-manager.js

@@ -0,0 +1,1269 @@
+// 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`)
+    );
+  }
+}
+
+// src/lib/process-signal-manager.ts
+import { ulid } from "ulid";
+import readline from "readline";
+var SHARED_STATE_KEY = /* @__PURE__ */ Symbol.for("lifecycleion.ProcessSignalManager.v1");
+function getSharedState() {
+  const g = globalThis;
+  if (!g[SHARED_STATE_KEY]) {
+    g[SHARED_STATE_KEY] = {
+      keypressEventsEmittedOnStdin: false,
+      attachedInstances: /* @__PURE__ */ new Set(),
+      rawModeOwner: null,
+      rawModeEnabledByManager: false
+    };
+  }
+  return g[SHARED_STATE_KEY];
+}
+function transferRawModeOwnership(shared, currentOwner) {
+  if (shared.rawModeOwner !== currentOwner) {
+    return shared.rawModeOwner;
+  }
+  if (shared.attachedInstances.size === 0) {
+    shared.rawModeOwner = null;
+    return null;
+  }
+  for (const candidateID of shared.attachedInstances) {
+    if (shared.attachedInstances.has(candidateID)) {
+      shared.rawModeOwner = candidateID;
+      return candidateID;
+    }
+  }
+  shared.rawModeOwner = null;
+  return null;
+}
+var ProcessSignalManager = class {
+  // Unique identifier for this instance, used for tracking in shared state
+  instanceID;
+  onShutdownRequested;
+  onReloadRequested;
+  onInfoRequested;
+  onDebugRequested;
+  shutdownCallbackName;
+  reloadCallbackName;
+  infoCallbackName;
+  debugCallbackName;
+  shutdownSignalListeners;
+  reloadSignalListener;
+  infoSignalListener;
+  debugSignalListener;
+  keypressHandler;
+  _isAttached = false;
+  // Throttle state for keyboard events (default 200ms, 0 disables)
+  // Track throttle separately per action type so different keys don't interfere with each other
+  // Use -Infinity to ensure first press is never throttled (always fires immediately)
+  keypressThrottleMS;
+  lastActionTimes = {
+    shutdown: -Infinity,
+    reload: -Infinity,
+    info: -Infinity,
+    debug: -Infinity
+  };
+  constructor(options) {
+    this.instanceID = ulid();
+    this.onShutdownRequested = options.onShutdownRequested;
+    this.onReloadRequested = options.onReloadRequested;
+    this.onInfoRequested = options.onInfoRequested;
+    this.onDebugRequested = options.onDebugRequested;
+    this.shutdownCallbackName = options.shutdownCallbackName ?? "onShutdownRequested";
+    this.reloadCallbackName = options.reloadCallbackName ?? "onReloadRequested";
+    this.infoCallbackName = options.infoCallbackName ?? "onInfoRequested";
+    this.debugCallbackName = options.debugCallbackName ?? "onDebugRequested";
+    this.keypressThrottleMS = options.keypressThrottleMS ?? 200;
+    if (this.onShutdownRequested) {
+      const shutdownCallback = this.onShutdownRequested;
+      this.shutdownSignalListeners = {
+        SIGINT: () => safeHandleCallback(
+          this.shutdownCallbackName,
+          shutdownCallback,
+          "SIGINT"
+        ),
+        SIGTERM: () => safeHandleCallback(
+          this.shutdownCallbackName,
+          shutdownCallback,
+          "SIGTERM"
+        ),
+        SIGTRAP: () => safeHandleCallback(
+          this.shutdownCallbackName,
+          shutdownCallback,
+          "SIGTRAP"
+        )
+      };
+    }
+    if (this.onReloadRequested) {
+      const reloadCallback = this.onReloadRequested;
+      this.reloadSignalListener = () => safeHandleCallback(this.reloadCallbackName, reloadCallback);
+    }
+    if (this.onInfoRequested) {
+      const infoCallback = this.onInfoRequested;
+      this.infoSignalListener = () => safeHandleCallback(this.infoCallbackName, infoCallback);
+    }
+    if (this.onDebugRequested) {
+      const debugCallback = this.onDebugRequested;
+      this.debugSignalListener = () => safeHandleCallback(this.debugCallbackName, debugCallback);
+    }
+  }
+  /**
+   * Check if the manager is currently attached to signals and keypresses.
+   */
+  get isAttached() {
+    return this._isAttached;
+  }
+  /**
+   * Get detailed status information about what the manager is attached to.
+   *
+   * @returns Status object with handler registration and attachment state
+   */
+  getStatus() {
+    return {
+      isAttached: this._isAttached,
+      handlers: {
+        shutdown: !!this.onShutdownRequested,
+        reload: !!this.onReloadRequested,
+        info: !!this.onInfoRequested,
+        debug: !!this.onDebugRequested
+      },
+      listeningFor: {
+        shutdownSignals: this._isAttached && !!this.shutdownSignalListeners,
+        reloadSignal: this._isAttached && !!this.reloadSignalListener,
+        infoSignal: this._isAttached && !!this.infoSignalListener,
+        debugSignal: this._isAttached && !!this.debugSignalListener,
+        // Keypresses are only available if stdin is a TTY
+        keypresses: this._isAttached && process.stdin.isTTY && !!this.keypressHandler
+      }
+    };
+  }
+  /**
+   * Attach signal handlers and start listening for process signals and keyboard events.
+   * Idempotent - calling multiple times has no effect.
+   */
+  attach() {
+    if (this._isAttached) {
+      return;
+    }
+    try {
+      this.listenForShutdownSignals();
+      this.listenForReloadSignal();
+      this.listenForInfoSignal();
+      this.listenForDebugSignal();
+      this.listenForKeyPresses();
+      this._isAttached = true;
+    } catch (error) {
+      this.stopListeningForShutdownSignals();
+      this.stopListeningForReloadSignal();
+      this.stopListeningForInfoSignal();
+      this.stopListeningForDebugSignal();
+      this.restoreStdin();
+      throw error;
+    }
+  }
+  /**
+   * Detach signal handlers and stop listening for process signals and keyboard events.
+   * Cleans up all event listeners and restores stdin to normal mode.
+   *
+   * Idempotent - calling multiple times has no effect.
+   */
+  detach() {
+    if (!this._isAttached) {
+      return;
+    }
+    try {
+      this.stopListeningForShutdownSignals();
+      this.stopListeningForReloadSignal();
+      this.stopListeningForInfoSignal();
+      this.stopListeningForDebugSignal();
+      this.restoreStdin();
+    } finally {
+      this._isAttached = false;
+    }
+  }
+  /**
+   * Manually trigger a shutdown event
+   * if the manager is attached and a shutdown handler is registered
+   *
+   * @param method - The shutdown method (SIGINT, SIGTERM, or SIGTRAP) that will be passed to the shutdown callback
+   * @param shouldBypassAttachCheck - If true, triggers the callback even when not attached (useful for testing)
+   */
+  triggerShutdown(method, shouldBypassAttachCheck = false) {
+    if ((this._isAttached || shouldBypassAttachCheck) && this.onShutdownRequested) {
+      safeHandleCallback(
+        this.shutdownCallbackName,
+        this.onShutdownRequested,
+        method
+      );
+    }
+  }
+  /**
+   * Manually trigger a reload event
+   * if the manager is attached and a reload handler is registered
+   *
+   * @param shouldBypassAttachCheck - If true, triggers the callback even when not attached (useful for testing)
+   */
+  triggerReload(shouldBypassAttachCheck = false) {
+    if ((this._isAttached || shouldBypassAttachCheck) && this.onReloadRequested) {
+      safeHandleCallback(this.reloadCallbackName, this.onReloadRequested);
+    }
+  }
+  /**
+   * Manually trigger an info event
+   * if the manager is attached and an info handler is registered
+   *
+   * @param shouldBypassAttachCheck - If true, triggers the callback even when not attached (useful for testing)
+   */
+  triggerInfo(shouldBypassAttachCheck = false) {
+    if ((this._isAttached || shouldBypassAttachCheck) && this.onInfoRequested) {
+      safeHandleCallback(this.infoCallbackName, this.onInfoRequested);
+    }
+  }
+  /**
+   * Manually trigger a debug event
+   * if the manager is attached and a debug handler is registered
+   *
+   * @param shouldBypassAttachCheck - If true, triggers the callback even when not attached (useful for testing)
+   */
+  triggerDebug(shouldBypassAttachCheck = false) {
+    if ((this._isAttached || shouldBypassAttachCheck) && this.onDebugRequested) {
+      safeHandleCallback(this.debugCallbackName, this.onDebugRequested);
+    }
+  }
+  /**
+   * Check if an action should be throttled based on the last time it was successfully triggered.
+   * Uses leading-edge throttle: first press fires immediately, subsequent presses within the
+   * throttle window are ignored. Only updates timestamp when action is allowed (not throttled).
+   *
+   * This is the standard pattern for keyboard shortcuts and prevents accidental double-triggers
+   * while allowing predictable repeated actions at a maximum rate.
+   *
+   * @param action - The action type to check throttling for
+   * @returns true if the action should be throttled (ignored), false otherwise
+   */
+  shouldThrottle(action) {
+    if (this.keypressThrottleMS <= 0) {
+      return false;
+    }
+    const now = Date.now();
+    const timeSinceLastTrigger = now - this.lastActionTimes[action];
+    if (timeSinceLastTrigger < this.keypressThrottleMS) {
+      return true;
+    }
+    this.lastActionTimes[action] = now;
+    return false;
+  }
+  /**
+   * Register handlers for all shutdown signals (SIGINT, SIGTERM, SIGTRAP) if callback is provided.
+   * Each signal will trigger the shutdown callback with the appropriate method.
+   */
+  listenForShutdownSignals() {
+    if (this.shutdownSignalListeners) {
+      for (const signal of Object.keys(
+        this.shutdownSignalListeners
+      )) {
+        process.on(signal, this.shutdownSignalListeners[signal]);
+      }
+    }
+  }
+  /**
+   * Remove handlers for all shutdown signals if they were registered.
+   * Uses the same function references to ensure proper cleanup.
+   */
+  stopListeningForShutdownSignals() {
+    if (this.shutdownSignalListeners) {
+      for (const signal of Object.keys(
+        this.shutdownSignalListeners
+      )) {
+        process.off(signal, this.shutdownSignalListeners[signal]);
+      }
+    }
+  }
+  /**
+   * Register handler for SIGHUP signal if reload callback is provided.
+   * SIGHUP is commonly used to trigger configuration reloads.
+   */
+  listenForReloadSignal() {
+    if (this.reloadSignalListener) {
+      process.on("SIGHUP", this.reloadSignalListener);
+    }
+  }
+  /**
+   * Remove handler for SIGHUP signal.
+   * Uses the same function reference to ensure proper cleanup.
+   */
+  stopListeningForReloadSignal() {
+    if (this.reloadSignalListener) {
+      process.off("SIGHUP", this.reloadSignalListener);
+    }
+  }
+  /**
+   * Register handler for SIGUSR1 signal if info callback is provided.
+   * SIGUSR1 is commonly used for printing stats, health checks, etc.
+   */
+  listenForInfoSignal() {
+    if (this.infoSignalListener) {
+      process.on("SIGUSR1", this.infoSignalListener);
+    }
+  }
+  /**
+   * Remove handler for SIGUSR1 signal.
+   * Uses the same function reference to ensure proper cleanup.
+   */
+  stopListeningForInfoSignal() {
+    if (this.infoSignalListener) {
+      process.off("SIGUSR1", this.infoSignalListener);
+    }
+  }
+  /**
+   * Register handler for SIGUSR2 signal if debug callback is provided.
+   * SIGUSR2 is commonly used for toggling debug mode, dumping state, etc.
+   */
+  listenForDebugSignal() {
+    if (this.debugSignalListener) {
+      process.on("SIGUSR2", this.debugSignalListener);
+    }
+  }
+  /**
+   * Remove handler for SIGUSR2 signal.
+   * Uses the same function reference to ensure proper cleanup.
+   */
+  stopListeningForDebugSignal() {
+    if (this.debugSignalListener) {
+      process.off("SIGUSR2", this.debugSignalListener);
+    }
+  }
+  /**
+   * Enable keyboard event listening if stdin is a TTY.
+   * Sets stdin to raw mode and listens for Ctrl+C, Escape, R, I, and D keypresses.
+   *
+   * Note: Letter keys are case-insensitive (R/r, I/i, D/d all work).
+   *
+   * Uses add-then-check pattern to prevent race conditions:
+   * 1. Add ourselves to attachedInstances first
+   * 2. Check if we're the first (size === 1) to enable raw mode
+   * This ensures no gap where another instance could read stale state.
+   */
+  listenForKeyPresses() {
+    if (!process.stdin.isTTY || this.keypressHandler) {
+      return;
+    }
+    const shared = getSharedState();
+    if (!shared.keypressEventsEmittedOnStdin) {
+      shared.keypressEventsEmittedOnStdin = true;
+      readline.emitKeypressEvents(process.stdin);
+    }
+    this.keypressHandler = (str, key) => {
+      const keyObj = key;
+      const keyName = keyObj.name;
+      if (keyObj.ctrl && keyName === "c" && this.onShutdownRequested) {
+        if (this.shouldThrottle("shutdown")) {
+          return;
+        }
+        safeHandleCallback(
+          this.shutdownCallbackName,
+          this.onShutdownRequested,
+          "SIGINT"
+        );
+      } else if (keyName === "escape" && this.onShutdownRequested) {
+        if (this.shouldThrottle("shutdown")) {
+          return;
+        }
+        safeHandleCallback(
+          this.shutdownCallbackName,
+          this.onShutdownRequested,
+          "SIGINT"
+        );
+      } else if (keyName === "r" && this.onReloadRequested) {
+        if (this.shouldThrottle("reload")) {
+          return;
+        }
+        safeHandleCallback(this.reloadCallbackName, this.onReloadRequested);
+      } else if (keyName === "i" && this.onInfoRequested) {
+        if (this.shouldThrottle("info")) {
+          return;
+        }
+        safeHandleCallback(this.infoCallbackName, this.onInfoRequested);
+      } else if (keyName === "d" && this.onDebugRequested) {
+        if (this.shouldThrottle("debug")) {
+          return;
+        }
+        safeHandleCallback(this.debugCallbackName, this.onDebugRequested);
+      }
+    };
+    shared.attachedInstances.add(this.instanceID);
+    const isFirstInstance = shared.attachedInstances.size === 1;
+    try {
+      process.stdin.on("keypress", this.keypressHandler);
+    } catch (error) {
+      shared.attachedInstances.delete(this.instanceID);
+      this.keypressHandler = void 0;
+      throw error;
+    }
+    if (isFirstInstance) {
+      if (!process.stdin.isRaw) {
+        try {
+          process.stdin.setRawMode(true);
+          shared.rawModeOwner = this.instanceID;
+          shared.rawModeEnabledByManager = true;
+        } catch (error) {
+          this.cleanupKeypressHandler(shared, true);
+          throw error;
+        }
+      } else if (shared.rawModeEnabledByManager && (shared.rawModeOwner === null || !shared.attachedInstances.has(shared.rawModeOwner))) {
+        shared.rawModeOwner = this.instanceID;
+      } else if (!shared.rawModeEnabledByManager) {
+        shared.rawModeOwner = null;
+      }
+    }
+    if (isFirstInstance) {
+      try {
+        process.stdin.resume();
+      } catch (error) {
+        this.cleanupKeypressHandler(shared);
+        throw error;
+      }
+    }
+  }
+  /**
+   * Helper to clean up keypress handler registration on error.
+   * Removes handler, clears instance from shared state, and restores raw mode if needed.
+   *
+   * @param shared - The shared state object
+   * @param didAttemptRawModeEnable - If true, we attempted to enable raw mode (even if ownership wasn't recorded).
+   *   This handles the edge case where setRawMode(true) throws after actually enabling raw mode.
+   */
+  cleanupKeypressHandler(shared, didAttemptRawModeEnable = false) {
+    if (this.keypressHandler) {
+      try {
+        process.stdin.off("keypress", this.keypressHandler);
+      } catch {
+      }
+      this.keypressHandler = void 0;
+    }
+    shared.attachedInstances.delete(this.instanceID);
+    if (didAttemptRawModeEnable && process.stdin.isTTY && process.stdin.isRaw) {
+      shared.rawModeEnabledByManager = true;
+      if (shared.rawModeOwner === null) {
+        shared.rawModeOwner = this.instanceID;
+      }
+    }
+    if (shared.rawModeEnabledByManager && shared.rawModeOwner === this.instanceID && shared.attachedInstances.size > 0) {
+      transferRawModeOwnership(shared, this.instanceID);
+    } else if (shared.rawModeOwner !== null && shared.attachedInstances.size > 0 && shared.rawModeEnabledByManager && !shared.attachedInstances.has(shared.rawModeOwner)) {
+      for (const candidateID of shared.attachedInstances) {
+        if (shared.attachedInstances.has(candidateID)) {
+          shared.rawModeOwner = candidateID;
+          break;
+        }
+      }
+    }
+    const shouldRestoreRawMode = shared.attachedInstances.size === 0 && shared.rawModeEnabledByManager && (shared.rawModeOwner === this.instanceID || didAttemptRawModeEnable && shared.rawModeOwner === null);
+    if (shouldRestoreRawMode) {
+      try {
+        if (process.stdin.isTTY && process.stdin.isRaw) {
+          process.stdin.setRawMode(false);
+        }
+        shared.rawModeOwner = null;
+        shared.rawModeEnabledByManager = false;
+      } catch {
+        if (didAttemptRawModeEnable && shared.rawModeOwner === null) {
+          shared.rawModeOwner = this.instanceID;
+        }
+      }
+    }
+  }
+  /**
+   * Restore stdin to normal mode and clean up keypress listener.
+   * Uses remove-then-check pattern (mirror of add-then-check in attach):
+   * 1. Remove ourselves from attachedInstances first
+   * 2. Check if we're the last (size === 0) to disable raw mode and pause stdin
+   *
+   * Note: Can be called even if keypressHandler is undefined (e.g., during error recovery).
+   * In that case, we still update shared state and attempt terminal restoration if we
+   * were the recorded raw mode owner.
+   */
+  restoreStdin() {
+    const shared = getSharedState();
+    if (this.keypressHandler) {
+      try {
+        process.stdin.off("keypress", this.keypressHandler);
+      } catch {
+      }
+      this.keypressHandler = void 0;
+    }
+    shared.attachedInstances.delete(this.instanceID);
+    const isLastInstance = shared.attachedInstances.size === 0;
+    const isCurrentOwner = shared.rawModeOwner === this.instanceID;
+    if (!isLastInstance && isCurrentOwner && shared.rawModeEnabledByManager) {
+      transferRawModeOwnership(shared, this.instanceID);
+    } else if (!isLastInstance && shared.rawModeOwner !== null && shared.rawModeEnabledByManager && !shared.attachedInstances.has(shared.rawModeOwner)) {
+      for (const candidateID of shared.attachedInstances) {
+        if (shared.attachedInstances.has(candidateID)) {
+          shared.rawModeOwner = candidateID;
+          break;
+        }
+      }
+    }
+    if (isLastInstance && shared.rawModeOwner === this.instanceID && shared.rawModeEnabledByManager) {
+      try {
+        if (process.stdin.isTTY && process.stdin.isRaw) {
+          process.stdin.setRawMode(false);
+        }
+        shared.rawModeOwner = null;
+        shared.rawModeEnabledByManager = false;
+      } catch {
+      }
+    }
+    if (isLastInstance) {
+      try {
+        process.stdin.pause();
+      } catch {
+      }
+    }
+  }
+};
+export {
+  ProcessSignalManager
+};
+//# sourceMappingURL=process-signal-manager.js.map