logpare 0.0.2 → 0.0.4

package/README.md

@@ -34,12 +34,29 @@ Top templates by frequency:
 
 ## Installation
 
+### As a CLI tool (recommended for command-line usage)
+
+Install globally to use `logpare` directly from anywhere:
+
+```bash
+npm install -g logpare
+
+# Now works directly
+logpare server.log
+```
+
+### As a library
+
+Install locally in your project for programmatic usage:
+
 ```bash
 npm install logpare
 # or
 pnpm add logpare
 ```
 
+> **Note:** Local installs require `npx` to run the CLI: `npx logpare server.log`
+
 ## CLI Usage
 
 LogPare includes a command-line interface for quick log compression:
@@ -64,6 +81,12 @@ logpare --output templates.txt error.log
 logpare access.log error.log server.log
 ```
 
+> **Using a local install?** Prefix commands with `npx`:
+> ```bash
+> npx logpare server.log
+> cat /var/log/syslog | npx logpare
+> ```
+
 ### CLI Options
 
 | Option | Short | Description | Default |
@@ -134,18 +157,101 @@ const result = drain.getResult('detailed');
 ## Output Formats
 
 ### Summary (default)
-Compact overview with top templates and rare events.
+
+Compact overview with top templates and rare events:
+
+```
+=== Log Compression Summary ===
+Input: 10,847 lines → 23 templates (99.8% reduction)
+
+Top templates by frequency:
+1. [4,521x] INFO Connection from <*> established
+2. [3,892x] DEBUG Request <*> processed in <*>
+3. [1,203x] WARN Retry attempt <*> for <*>
+
+Rare events (≤5 occurrences):
+- [1x] FATAL Database connection lost
+- [2x] ERROR Out of memory exception in <*>
+```
 
 ### Detailed
-Full template list with sample variable values.
+
+Full template list with all diagnostic metadata:
+
+```
+Template #1: INFO Connection from <*> established
+  Occurrences: 4,521
+  Severity: info
+  First seen: line 1
+  Last seen: line 10,234
+  Sample values: [["192.168.1.1"], ["10.0.0.55"], ["172.16.0.1"]]
+  URLs: api.example.com, cdn.example.com
+  Status codes: 200, 201
+  Correlation IDs: req-abc123, trace-xyz789
+  Durations: 45ms, 120ms, 2.5s
+```
 
 ### JSON
-Machine-readable format for programmatic use.
+
+Machine-readable format with version field and complete metadata:
+
+```json
+{
+  "version": "1.1",
+  "stats": {
+    "inputLines": 10847,
+    "uniqueTemplates": 23,
+    "compressionRatio": 0.998,
+    "estimatedTokenReduction": 0.95,
+    "processingTimeMs": 234
+  },
+  "templates": [{
+    "id": "abc123",
+    "pattern": "INFO Connection from <*> established",
+    "occurrences": 4521,
+    "severity": "info",
+    "isStackFrame": false,
+    "firstSeen": 1,
+    "lastSeen": 10234,
+    "sampleVariables": [["192.168.1.1"], ["10.0.0.55"]],
+    "urlSamples": ["api.example.com"],
+    "fullUrlSamples": ["https://api.example.com/v1/users"],
+    "statusCodeSamples": [200, 201],
+    "correlationIdSamples": ["req-abc123"],
+    "durationSamples": ["45ms", "120ms"]
+  }]
+}
+```
 
 ```typescript
 compress(logs, { format: 'json' });
 ```
 
+## Diagnostic Metadata
+
+LogPare automatically extracts diagnostic information from matching log lines:
+
+| Metadata | Description | Supported Formats |
+|----------|-------------|-------------------|
+| **URLs** | Hostnames and full URLs | `https://...`, `http://...` |
+| **Status codes** | HTTP status codes | `status 404`, `HTTP/1.1 500`, `code=200` |
+| **Correlation IDs** | Request/trace identifiers | `trace-id: xxx`, `request-id: xxx`, UUIDs |
+| **Durations** | Timing values | `45ms`, `1.5s`, `200µs`, `2min`, `1h` |
+
+This metadata is preserved in templates and available in detailed/JSON output formats.
+
+## Severity Detection
+
+Each template is automatically tagged with a severity level:
+
+| Severity | Detected Patterns |
+|----------|------------------|
+| `error` | ERROR, FATAL, Exception, Failed, TypeError, ReferenceError, panic |
+| `warning` | WARN, Warning, Deprecated, [Violation] |
+| `info` | Default for other logs |
+
+Stack traces are also automatically detected (V8/Node.js, Firefox, Chrome DevTools formats) and marked with `isStackFrame: true`.
+
 ## API Reference
 
 ### `compress(lines, options?)`
@@ -172,6 +278,33 @@ Create a Drain instance for incremental processing.
 - `options.maxChildren`: `number` - Max children per node (default: `100`)
 - `options.maxClusters`: `number` - Max total templates (default: `1000`)
 - `options.preprocessing`: `ParsingStrategy` - Custom preprocessing
+- `options.onProgress`: `ProgressCallback` - Progress reporting callback
+
+#### Progress Reporting
+
+Track progress during long-running operations:
+
+```typescript
+import { createDrain } from 'logpare';
+
+const drain = createDrain({
+  onProgress: (event) => {
+    console.log(`${event.currentPhase}: ${event.processedLines} lines`);
+    if (event.percentComplete !== undefined) {
+      console.log(`Progress: ${event.percentComplete.toFixed(1)}%`);
+    }
+  }
+});
+
+drain.addLogLines(logs);
+const result = drain.getResult();
+```
+
+The callback receives `ProgressEvent` with:
+- `processedLines`: Lines processed so far
+- `totalLines`: Total lines (if known)
+- `currentPhase`: `'parsing'` | `'clustering'` | `'finalizing'`
+- `percentComplete`: 0-100 (only if `totalLines` known)
 
 ### `defineStrategy(overrides)`
 
@@ -190,6 +323,7 @@ const strategy = defineStrategy({
 LogPare automatically masks common variable types:
 
 - IPv4/IPv6 addresses
+- Port numbers (e.g., `:443`, `:8080`)
 - UUIDs
 - Timestamps (ISO, Unix)
 - File paths and URLs
@@ -197,6 +331,11 @@ LogPare automatically masks common variable types:
 - Block IDs (HDFS)
 - Numbers with units (e.g., `250ms`, `1024KB`)
 
+**Automatic detection features:**
+- **Severity tagging** — Templates are tagged as `error`, `warning`, or `info`
+- **Stack frame detection** — Identifies stack traces (V8, Firefox, Chrome formats)
+- **Diagnostic extraction** — Captures URLs, HTTP status codes, correlation IDs, and durations
+
 ## Performance
 
 - **Speed**: >10,000 lines/second

package/dist/{chunk-PVEO4LBX.js → chunk-VVVVUJFY.js}

@@ -1,5 +1,113 @@
 // src/preprocessing/patterns.ts
+var SEVERITY_PATTERNS = {
+  error: /\b(Error|ERROR|error|Uncaught|UNCAUGHT|Failed|FAILED|Exception|EXCEPTION|FATAL|fatal|TypeError|ReferenceError|SyntaxError|RangeError)\b/,
+  warning: /\b(Warning|WARNING|warn|WARN|\[Violation\]|Violation|DEPRECATED|deprecated|Deprecation)\b/
+};
+var STACK_FRAME_PATTERNS = [
+  /^\s*at\s+/,
+  // "    at Function.x" (V8/Node)
+  /^\s*@\s*\S+:\d+/,
+  // "@ file.js:123" (Firefox)
+  /^\s*\w+@\S+:\d+/,
+  // "fn@file.js:123" (Firefox named)
+  /^\s*\(anonymous\)\s*@/,
+  // "(anonymous) @ file.js:123" (Chrome DevTools)
+  /^\s*[A-Za-z_$][\w$]*\s+@\s+\S+:\d+/
+  // "functionName @ file.js:123"
+];
+function detectSeverity(line) {
+  if (SEVERITY_PATTERNS.error.test(line)) {
+    return "error";
+  }
+  if (SEVERITY_PATTERNS.warning.test(line)) {
+    return "warning";
+  }
+  return "info";
+}
+function isStackFrame(line) {
+  return STACK_FRAME_PATTERNS.some((pattern) => pattern.test(line));
+}
+function extractUrls(line) {
+  const urlPattern = /https?:\/\/[^\s"'<>]+/g;
+  const matches = line.match(urlPattern);
+  if (!matches) return [];
+  return matches.map((url) => {
+    try {
+      const parsed = new URL(url);
+      return parsed.hostname;
+    } catch {
+      return url;
+    }
+  }).filter((v, i, a) => a.indexOf(v) === i);
+}
+function extractFullUrls(line) {
+  const urlPattern = /https?:\/\/[^\s"'<>]+/g;
+  const matches = line.match(urlPattern);
+  if (!matches) return [];
+  return [...new Set(matches)];
+}
+function extractStatusCodes(line) {
+  const patterns = [
+    /\bstatus[:\s]+(\d{3})\b/gi,
+    // "status 404", "status: 500"
+    /\bHTTP[\/\s]\d\.\d\s+(\d{3})\b/gi,
+    // "HTTP/1.1 404", "HTTP 1.1 500"
+    /\bcode[:\s]+(\d{3})\b/gi,
+    // "code: 403", "code 500"
+    /\b(\d{3})\s+(?:OK|Not Found|Bad Request|Unauthorized|Forbidden|Internal Server Error|Service Unavailable)\b/gi
+  ];
+  const codes = [];
+  for (const pattern of patterns) {
+    const regex = new RegExp(pattern.source, pattern.flags);
+    let match;
+    while ((match = regex.exec(line)) !== null) {
+      const codeStr = match[1];
+      if (codeStr) {
+        const code = parseInt(codeStr, 10);
+        if (code >= 100 && code <= 599 && !codes.includes(code)) {
+          codes.push(code);
+        }
+      }
+    }
+  }
+  return codes;
+}
+function extractCorrelationIds(line) {
+  const patterns = [
+    // Named correlation IDs: trace-id=xxx, request_id: xxx, x-request-id=xxx
+    /\b(?:trace[-_]?id|request[-_]?id|correlation[-_]?id|x-request-id)[=:\s]+["']?([a-zA-Z0-9-_]+)["']?/gi,
+    // Standalone UUIDs (common correlation ID format)
+    /\b([a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12})\b/gi
+  ];
+  const ids = [];
+  for (const pattern of patterns) {
+    const regex = new RegExp(pattern.source, pattern.flags);
+    let match;
+    while ((match = regex.exec(line)) !== null) {
+      const id = match[1] || match[0];
+      if (id && !ids.includes(id)) {
+        ids.push(id);
+      }
+    }
+  }
+  return ids.slice(0, 3);
+}
+function extractDurations(line) {
+  const durationPattern = /\b(\d+(?:\.\d+)?)\s*(ms|milliseconds?|s|sec(?:onds?)?|µs|μs|us|microseconds?|ns|nanoseconds?|min(?:utes?)?|h(?:ours?)?|hr)\b/gi;
+  const durations = [];
+  let match;
+  while ((match = durationPattern.exec(line)) !== null) {
+    const duration = `${match[1]}${match[2]}`;
+    if (!durations.includes(duration)) {
+      durations.push(duration);
+    }
+  }
+  return durations.slice(0, 5);
+}
 var DEFAULT_PATTERNS = {
+  // Timestamps (most specific - must run before port to avoid fragmentation)
+  isoTimestamp: /\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:[.,]\d+)?(?:Z|[+-]\d{2}:?\d{2})?/g,
+  unixTimestamp: /\b\d{10,13}\b/g,
   // Network addresses
   ipv4: /\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/g,
   ipv6: /\b[0-9a-fA-F:]{7,39}\b/g,
@@ -8,15 +116,18 @@ var DEFAULT_PATTERNS = {
   uuid: /\b[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\b/g,
   hexId: /\b0x[0-9a-fA-F]+\b/g,
   blockId: /\bblk_-?\d+\b/g,
-  // Timestamps
-  isoTimestamp: /\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:[.,]\d+)?(?:Z|[+-]\d{2}:?\d{2})?/g,
-  unixTimestamp: /\b\d{10,13}\b/g,
   // Paths and URLs
-  filePath: /(?:\/[\w.-]+)+/g,
+  // Note: Don't match version-like paths (e.g., /2.7, /v1.0)
+  // Require at least 2 path segments or a segment with letters
+  filePath: /(?:\/[a-zA-Z][\w.-]*)+/g,
   url: /https?:\/\/[^\s]+/g,
-  // Numbers (applied last - most aggressive)
-  // Matches standalone numbers and numbers with units (e.g., 250ms, 1024KB)
-  numbers: /\b\d+(?:\.\d+)?[a-zA-Z]*\b/g
+  // Long numeric IDs only (6+ digits) - preserves status codes, line numbers
+  // Examples masked: request IDs (12345678), order numbers (1234567890)
+  // Examples preserved: HTTP 404, line:123, /v2.7
+  numericId: /\b\d{6,}\b/g,
+  // Numbers with optional duration/size suffixes
+  // Matches: 1500, 250ms, 1.5s, 100KB, etc.
+  numbers: /\b\d+(?:\.\d+)?(?:ms|s|µs|us|ns|min|h|hr|sec|[KkMmGgTt][Bb]?)?\b/g
 };
 var WILDCARD = "<*>";
 function applyPatterns(line, patterns, wildcard = WILDCARD) {
@@ -138,9 +249,31 @@ var LogCluster = class {
   firstSeen;
   /** Line index of most recent occurrence */
   lastSeen;
+  /** Detected severity level */
+  severity;
+  /** Sample URLs extracted from matching lines (hostnames only) */
+  urlSamples;
+  /** Full URLs extracted from matching lines (complete paths) */
+  fullUrlSamples;
+  /** HTTP status codes extracted from matching lines */
+  statusCodeSamples;
+  /** Correlation/trace IDs extracted from matching lines */
+  correlationIdSamples;
+  /** Duration/timing values extracted from matching lines */
+  durationSamples;
+  /** Whether this template represents a stack trace frame */
+  isStackFrame;
   /** Maximum number of sample variables to store */
   maxSamples;
-  constructor(id, tokens, lineIndex, maxSamples = 3) {
+  /** Maximum number of URL samples to store */
+  maxUrlSamples = 5;
+  /** Maximum number of status code samples to store */
+  maxStatusCodeSamples = 5;
+  /** Maximum number of correlation ID samples to store */
+  maxCorrelationIdSamples = 3;
+  /** Maximum number of duration samples to store */
+  maxDurationSamples = 5;
+  constructor(id, tokens, lineIndex, maxSamples = 3, originalLine = "") {
     this.id = id;
     this.tokens = tokens.slice();
     this.count = 1;
@@ -148,12 +281,39 @@ var LogCluster = class {
     this.firstSeen = lineIndex;
     this.lastSeen = lineIndex;
     this.maxSamples = maxSamples;
+    this.severity = detectSeverity(originalLine);
+    this.isStackFrame = isStackFrame(originalLine);
+    this.urlSamples = [];
+    this.fullUrlSamples = [];
+    this.statusCodeSamples = [];
+    this.correlationIdSamples = [];
+    this.durationSamples = [];
+    const urls = extractUrls(originalLine);
+    if (urls.length > 0) {
+      this.urlSamples.push(...urls.slice(0, this.maxUrlSamples));
+    }
+    const fullUrls = extractFullUrls(originalLine);
+    if (fullUrls.length > 0) {
+      this.fullUrlSamples.push(...fullUrls.slice(0, this.maxUrlSamples));
+    }
+    const statusCodes = extractStatusCodes(originalLine);
+    if (statusCodes.length > 0) {
+      this.statusCodeSamples.push(...statusCodes.slice(0, this.maxStatusCodeSamples));
+    }
+    const correlationIds = extractCorrelationIds(originalLine);
+    if (correlationIds.length > 0) {
+      this.correlationIdSamples.push(...correlationIds.slice(0, this.maxCorrelationIdSamples));
+    }
+    const durations = extractDurations(originalLine);
+    if (durations.length > 0) {
+      this.durationSamples.push(...durations.slice(0, this.maxDurationSamples));
+    }
   }
   /**
    * Update the cluster with a new matching log line.
    * Returns the variables extracted from this match.
    */
-  update(tokens, lineIndex) {
+  update(tokens, lineIndex, originalLine = "") {
     this.count++;
     this.lastSeen = lineIndex;
     const variables = [];
@@ -165,6 +325,48 @@ var LogCluster = class {
     if (this.sampleVariables.length < this.maxSamples) {
       this.sampleVariables.push(variables);
     }
+    if (originalLine) {
+      if (this.urlSamples.length < this.maxUrlSamples) {
+        const urls = extractUrls(originalLine);
+        for (const url of urls) {
+          if (!this.urlSamples.includes(url) && this.urlSamples.length < this.maxUrlSamples) {
+            this.urlSamples.push(url);
+          }
+        }
+      }
+      if (this.fullUrlSamples.length < this.maxUrlSamples) {
+        const fullUrls = extractFullUrls(originalLine);
+        for (const url of fullUrls) {
+          if (!this.fullUrlSamples.includes(url) && this.fullUrlSamples.length < this.maxUrlSamples) {
+            this.fullUrlSamples.push(url);
+          }
+        }
+      }
+      if (this.statusCodeSamples.length < this.maxStatusCodeSamples) {
+        const statusCodes = extractStatusCodes(originalLine);
+        for (const code of statusCodes) {
+          if (!this.statusCodeSamples.includes(code) && this.statusCodeSamples.length < this.maxStatusCodeSamples) {
+            this.statusCodeSamples.push(code);
+          }
+        }
+      }
+      if (this.correlationIdSamples.length < this.maxCorrelationIdSamples) {
+        const correlationIds = extractCorrelationIds(originalLine);
+        for (const id of correlationIds) {
+          if (!this.correlationIdSamples.includes(id) && this.correlationIdSamples.length < this.maxCorrelationIdSamples) {
+            this.correlationIdSamples.push(id);
+          }
+        }
+      }
+      if (this.durationSamples.length < this.maxDurationSamples) {
+        const durations = extractDurations(originalLine);
+        for (const duration of durations) {
+          if (!this.durationSamples.includes(duration) && this.durationSamples.length < this.maxDurationSamples) {
+            this.durationSamples.push(duration);
+          }
+        }
+      }
+    }
     return variables;
   }
   /**
@@ -259,8 +461,24 @@ function formatDetailed(templates, stats) {
   for (const template of templates) {
     lines.push(`=== Template ${template.id} (${template.occurrences.toLocaleString()} occurrences) ===`);
     lines.push(`Pattern: ${template.pattern}`);
+    lines.push(`Severity: ${template.severity}${template.isStackFrame ? " (stack frame)" : ""}`);
     lines.push(`First seen: line ${template.firstSeen + 1}`);
     lines.push(`Last seen: line ${template.lastSeen + 1}`);
+    if (template.fullUrlSamples.length > 0) {
+      lines.push("URLs:");
+      for (const url of template.fullUrlSamples) {
+        lines.push(`  - ${url}`);
+      }
+    }
+    if (template.statusCodeSamples.length > 0) {
+      lines.push(`Status codes: ${template.statusCodeSamples.join(", ")}`);
+    }
+    if (template.correlationIdSamples.length > 0) {
+      lines.push(`Correlation IDs: ${template.correlationIdSamples.join(", ")}`);
+    }
+    if (template.durationSamples.length > 0) {
+      lines.push(`Durations: ${template.durationSamples.join(", ")}`);
+    }
     if (template.sampleVariables.length > 0) {
       lines.push("Sample variables:");
       for (const vars of template.sampleVariables) {
@@ -275,7 +493,7 @@ function formatDetailed(templates, stats) {
 }
 function formatJson(templates, stats) {
   const output = {
-    version: "1.0",
+    version: "1.1",
     stats: {
       inputLines: stats.inputLines,
       uniqueTemplates: stats.uniqueTemplates,
@@ -286,7 +504,14 @@ function formatJson(templates, stats) {
       id: t.id,
       pattern: t.pattern,
       occurrences: t.occurrences,
+      severity: t.severity,
+      isStackFrame: t.isStackFrame,
       samples: t.sampleVariables,
+      urlSamples: t.urlSamples,
+      fullUrlSamples: t.fullUrlSamples,
+      statusCodeSamples: t.statusCodeSamples,
+      correlationIdSamples: t.correlationIdSamples,
+      durationSamples: t.durationSamples,
       firstSeen: t.firstSeen,
       lastSeen: t.lastSeen
     }))
@@ -311,6 +536,7 @@ var Drain = class {
   maxChildren;
   maxClusters;
   maxSamples;
+  onProgress;
   lineCount;
   nextClusterId;
   constructor(options = {}) {
@@ -321,6 +547,7 @@ var Drain = class {
     this.maxChildren = options.maxChildren ?? DEFAULTS.maxChildren;
     this.maxClusters = options.maxClusters ?? DEFAULTS.maxClusters;
     this.maxSamples = options.maxSamples ?? DEFAULTS.maxSamples;
+    this.onProgress = options.onProgress;
     this.lineCount = 0;
     this.nextClusterId = 1;
   }
@@ -340,21 +567,39 @@ var Drain = class {
     }
     const matchedCluster = this.treeSearch(tokens);
     if (matchedCluster !== null) {
-      matchedCluster.update(tokens, lineIndex);
+      matchedCluster.update(tokens, lineIndex, trimmed);
       matchedCluster.mergeTokens(tokens);
       return matchedCluster;
     }
     if (this.clusters.length >= this.maxClusters) {
       return null;
     }
-    return this.createCluster(tokens, lineIndex);
+    return this.createCluster(tokens, lineIndex, trimmed);
   }
   /**
-   * Process multiple log lines.
+   * Process multiple log lines with optional progress reporting.
    */
   addLogLines(lines) {
-    for (const line of lines) {
-      this.addLogLine(line);
+    const total = lines.length;
+    const reportInterval = Math.max(1, Math.floor(total / 100));
+    for (let i = 0; i < total; i++) {
+      this.addLogLine(lines[i]);
+      if (this.onProgress && i % reportInterval === 0) {
+        this.onProgress({
+          processedLines: i + 1,
+          totalLines: total,
+          currentPhase: "clustering",
+          percentComplete: Math.round((i + 1) / total * 100)
+        });
+      }
+    }
+    if (this.onProgress && total > 0) {
+      this.onProgress({
+        processedLines: total,
+        totalLines: total,
+        currentPhase: "finalizing",
+        percentComplete: 100
+      });
     }
   }
   /**
@@ -414,9 +659,9 @@ var Drain = class {
   /**
    * Create a new cluster and add it to the tree.
    */
-  createCluster(tokens, lineIndex) {
+  createCluster(tokens, lineIndex, originalLine = "") {
     const clusterId = `t${String(this.nextClusterId++).padStart(3, "0")}`;
-    const cluster = new LogCluster(clusterId, tokens, lineIndex, this.maxSamples);
+    const cluster = new LogCluster(clusterId, tokens, lineIndex, this.maxSamples, originalLine);
     const tokenCount = tokens.length;
     const tokenCountKey = String(tokenCount);
     const lengthNode = this.root.getOrCreateChild(tokenCountKey);
@@ -481,7 +726,14 @@ var Drain = class {
       occurrences: cluster.count,
       sampleVariables: cluster.sampleVariables,
       firstSeen: cluster.firstSeen,
-      lastSeen: cluster.lastSeen
+      lastSeen: cluster.lastSeen,
+      severity: cluster.severity,
+      urlSamples: cluster.urlSamples,
+      fullUrlSamples: cluster.fullUrlSamples,
+      statusCodeSamples: cluster.statusCodeSamples,
+      correlationIdSamples: cluster.correlationIdSamples,
+      durationSamples: cluster.durationSamples,
+      isStackFrame: cluster.isStackFrame
     }));
   }
   /**
@@ -553,9 +805,18 @@ function createDrain(options) {
 // src/api.ts
 function compress(lines, options = {}) {
   const { format = "summary", maxTemplates = 50, drain: drainOptions } = options;
+  const startTime = performance.now();
   const drain = createDrain(drainOptions);
   drain.addLogLines(lines);
-  return drain.getResult(format, maxTemplates);
+  const result = drain.getResult(format, maxTemplates);
+  const processingTimeMs = Math.round(performance.now() - startTime);
+  return {
+    ...result,
+    stats: {
+      ...result.stats,
+      processingTimeMs
+    }
+  };
 }
 function compressText(text, options = {}) {
   const lines = text.split(/\r?\n/);
@@ -563,6 +824,11 @@ function compressText(text, options = {}) {
 }
 
 export {
+  SEVERITY_PATTERNS,
+  STACK_FRAME_PATTERNS,
+  detectSeverity,
+  isStackFrame,
+  extractUrls,
   DEFAULT_PATTERNS,
   WILDCARD,
   defineStrategy,
@@ -571,4 +837,4 @@ export {
   compress,
   compressText
 };
-//# sourceMappingURL=chunk-PVEO4LBX.js.map
+//# sourceMappingURL=chunk-VVVVUJFY.js.map