har-o-scope 0.1.0

package/dist/lib/evaluate.js

@@ -0,0 +1,189 @@
+// ── Field accessor ──────────────────────────────────────────────
+const BLOCKED_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+export function getField(obj, path) {
+    const parts = path.split('.');
+    let current = obj;
+    for (const part of parts) {
+        if (current == null || typeof current !== 'object')
+            return undefined;
+        if (BLOCKED_KEYS.has(part))
+            return undefined;
+        current = current[part];
+    }
+    return current;
+}
+/**
+ * Resolve a field value with optional fallback.
+ * Fallback is used if the primary value is null, undefined, or zero.
+ * Zero triggers fallback because the main use case is transferSize
+ * falling back to contentSize where 0 means unavailable.
+ */
+function resolveFieldValue(entry, field, fieldFallback) {
+    const value = getField(entry, field);
+    if (fieldFallback !== undefined && (value === 0 || value == null)) {
+        return getField(entry, fieldFallback);
+    }
+    return value;
+}
+// ── Regex cache ─────────────────────────────────────────────────
+const regexCache = new Map();
+function getCachedRegex(pattern, flags) {
+    const key = `${pattern}\0${flags}`;
+    let re = regexCache.get(key);
+    if (!re) {
+        re = new RegExp(pattern, flags);
+        regexCache.set(key, re);
+    }
+    return re;
+}
+// ── Type guards ─────────────────────────────────────────────────
+export function isFieldCondition(node) {
+    return 'field' in node;
+}
+export function isHeaderCondition(node) {
+    return 'has_response_header' in node || 'no_response_header' in node;
+}
+export function isConditionGroup(node) {
+    return 'match_all' in node || 'match_any' in node;
+}
+// ── Response header access ──────────────────────────────────────
+function getResponseHeaders(entry) {
+    const headers = getField(entry, 'entry.response.headers');
+    return Array.isArray(headers) ? headers : [];
+}
+// ── Condition evaluation ────────────────────────────────────────
+export function evaluateFieldCondition(entry, cond) {
+    const value = resolveFieldValue(entry, cond.field, cond.field_fallback);
+    if (cond.equals !== undefined)
+        return value === cond.equals;
+    if (cond.not_equals !== undefined)
+        return value !== cond.not_equals;
+    if (cond.in !== undefined)
+        return cond.in.includes(value);
+    if (cond.not_in !== undefined)
+        return !cond.not_in.includes(value);
+    if (cond.gt !== undefined)
+        return typeof value === 'number' && value > cond.gt;
+    if (cond.gte !== undefined)
+        return typeof value === 'number' && value >= cond.gte;
+    if (cond.lt !== undefined)
+        return typeof value === 'number' && value < cond.lt;
+    if (cond.lte !== undefined)
+        return typeof value === 'number' && value <= cond.lte;
+    if (cond.matches !== undefined) {
+        const str = value == null ? '' : String(value);
+        return getCachedRegex(cond.matches, 'i').test(str);
+    }
+    if (cond.not_matches !== undefined) {
+        const str = value == null ? '' : String(value);
+        return !getCachedRegex(cond.not_matches, 'i').test(str);
+    }
+    return true;
+}
+function evaluateHeaderCondition(entry, cond) {
+    const headers = getResponseHeaders(entry);
+    if (cond.has_response_header) {
+        const { name, value_matches, value_gt, value_lt } = cond.has_response_header;
+        return headers.some((h) => {
+            if (h.name.toLowerCase() !== name.toLowerCase())
+                return false;
+            if (value_matches && !getCachedRegex(value_matches, 'i').test(h.value))
+                return false;
+            if (value_gt !== undefined) {
+                const num = parseFloat(h.value);
+                if (isNaN(num) || num <= value_gt)
+                    return false;
+            }
+            if (value_lt !== undefined) {
+                const num = parseFloat(h.value);
+                if (isNaN(num) || num >= value_lt)
+                    return false;
+            }
+            return true;
+        });
+    }
+    if (cond.no_response_header) {
+        const { name, value_matches } = cond.no_response_header;
+        const matchingHeader = headers.some((h) => {
+            if (h.name.toLowerCase() !== name.toLowerCase())
+                return false;
+            if (value_matches)
+                return getCachedRegex(value_matches, 'i').test(h.value);
+            return true;
+        });
+        return !matchingHeader;
+    }
+    return true;
+}
+export function evaluateCondition(entry, node) {
+    if (isFieldCondition(node))
+        return evaluateFieldCondition(entry, node);
+    if (isHeaderCondition(node))
+        return evaluateHeaderCondition(entry, node);
+    if (isConditionGroup(node)) {
+        if (node.match_all)
+            return node.match_all.every((child) => evaluateCondition(entry, child));
+        if (node.match_any)
+            return node.match_any.some((child) => evaluateCondition(entry, child));
+    }
+    return true;
+}
+// ── Severity computation ────────────────────────────────────────
+const SEVERITY_ORDER = { info: 0, warning: 1, critical: 2 };
+function escalateIfHigher(current, candidate) {
+    return (SEVERITY_ORDER[candidate] ?? 0) > (SEVERITY_ORDER[current] ?? 0) ? candidate : current;
+}
+export function computeSeverity(baseSeverity, escalation, affectedCount, totalCount) {
+    if (!escalation)
+        return baseSeverity;
+    let severity = baseSeverity;
+    const ratio = totalCount > 0 ? affectedCount / totalCount : 0;
+    if (escalation.warning_threshold !== undefined && affectedCount >= escalation.warning_threshold) {
+        severity = escalateIfHigher(severity, 'warning');
+    }
+    if (escalation.warning_ratio !== undefined && ratio > escalation.warning_ratio) {
+        severity = escalateIfHigher(severity, 'warning');
+    }
+    if (escalation.critical_threshold !== undefined && affectedCount >= escalation.critical_threshold) {
+        severity = escalateIfHigher(severity, 'critical');
+    }
+    if (escalation.critical_ratio !== undefined && ratio > escalation.critical_ratio) {
+        severity = escalateIfHigher(severity, 'critical');
+    }
+    return severity;
+}
+// ── Impact computation ──────────────────────────────────────────
+export function computeImpact(entries, affectedIndices, impactSpec) {
+    if (!impactSpec)
+        return 0;
+    if (impactSpec.value !== undefined)
+        return impactSpec.value;
+    let total = 0;
+    const baseline = impactSpec.baseline ?? 0;
+    for (const idx of affectedIndices) {
+        const entry = entries[idx];
+        if (impactSpec.field) {
+            const val = getField(entry, impactSpec.field);
+            if (typeof val === 'number')
+                total += val - baseline;
+        }
+        if (impactSpec.fields) {
+            let entrySum = 0;
+            for (const f of impactSpec.fields) {
+                const val = getField(entry, f);
+                if (typeof val === 'number')
+                    entrySum += val;
+            }
+            total += entrySum - baseline;
+        }
+    }
+    return total;
+}
+// ── Template interpolation ──────────────────────────────────────
+export function interpolate(template, vars) {
+    return template.replace(/\{(\w+)\}/g, (_, key) => {
+        if (key in vars)
+            return String(vars[key]);
+        return `{${key}}`;
+    });
+}

package/dist/lib/health-score.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Health score: 0-100 pure function.
+ *
+ * Scoring formula (from CEO plan):
+ *   Base: 100
+ *   Deductions:
+ *     - critical finding: -15 * confidenceMultiplier
+ *     - warning finding: -5 * confidenceMultiplier
+ *     - info finding: -1 * confidenceMultiplier
+ *     - Confidence multiplier from root cause: >=0.6 high (1.0x), >=0.4 medium (0.7x), <0.4 low (0.5x)
+ *     - Timing penalty: median TTFB >1000ms: -10, >2000ms: -20
+ *     - Volume penalty: >200 requests: -5, >500 requests: -10
+ *   Floor: 0, Ceiling: 100
+ */
+import type { AnalysisResult, HealthScore, NormalizedEntry, RootCauseResult, Finding } from './types.js';
+export declare function computeHealthScore(result: AnalysisResult): HealthScore;
+export declare function computeHealthScoreFromParts(findings: Finding[], rootCause: RootCauseResult, entries: NormalizedEntry[]): HealthScore;
+//# sourceMappingURL=health-score.d.ts.map

package/dist/lib/health-score.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"health-score.d.ts","sourceRoot":"","sources":["../../src/lib/health-score.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,EACV,cAAc,EACd,WAAW,EAGX,eAAe,EACf,eAAe,EACf,OAAO,EACR,MAAM,YAAY,CAAA;AAEnB,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,cAAc,GAAG,WAAW,CAGtE;AAED,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,OAAO,EAAE,EACnB,SAAS,EAAE,eAAe,EAC1B,OAAO,EAAE,eAAe,EAAE,GACzB,WAAW,CA2Cb"}

package/dist/lib/health-score.js

@@ -0,0 +1,74 @@
+export function computeHealthScore(result) {
+    const { findings, rootCause, entries } = result;
+    return computeHealthScoreFromParts(findings, rootCause, entries);
+}
+export function computeHealthScoreFromParts(findings, rootCause, entries) {
+    const confidenceMultiplier = getConfidenceMultiplier(rootCause);
+    const findingDeductions = [];
+    let findingPoints = 0;
+    for (const finding of findings) {
+        let points;
+        switch (finding.severity) {
+            case 'critical':
+                points = 15;
+                break;
+            case 'warning':
+                points = 5;
+                break;
+            case 'info':
+                points = 1;
+                break;
+            default:
+                points = 0;
+        }
+        if (points > 0) {
+            const adjusted = Math.round(points * confidenceMultiplier * 10) / 10;
+            findingDeductions.push({ reason: `${finding.severity}: ${finding.ruleId}`, points: adjusted });
+            findingPoints += adjusted;
+        }
+    }
+    const timingPenalty = computeTimingPenalty(entries);
+    const volumePenalty = computeVolumePenalty(entries.length);
+    const totalDeductions = findingPoints + timingPenalty + volumePenalty;
+    const score = Math.max(0, Math.min(100, Math.round(100 - totalDeductions)));
+    return {
+        score,
+        breakdown: {
+            findingDeductions,
+            timingPenalty,
+            volumePenalty,
+            confidenceMultiplier,
+            totalDeductions,
+        },
+    };
+}
+function getConfidenceMultiplier(rootCause) {
+    const maxWeight = Math.max(rootCause.client, rootCause.network, rootCause.server);
+    if (maxWeight >= 0.6)
+        return 1.0;
+    if (maxWeight >= 0.4)
+        return 0.7;
+    return 0.5;
+}
+function computeTimingPenalty(entries) {
+    // Filter to non-WebSocket, non-long-poll entries with wait > 0
+    const waits = entries
+        .filter((e) => !e.isWebSocket && !e.isLongPoll && e.timings.wait > 0)
+        .map((e) => e.timings.wait)
+        .sort((a, b) => a - b);
+    if (waits.length === 0)
+        return 0;
+    const median = waits[Math.floor(waits.length / 2)];
+    if (median > 2000)
+        return 20;
+    if (median > 1000)
+        return 10;
+    return 0;
+}
+function computeVolumePenalty(count) {
+    if (count > 500)
+        return 10;
+    if (count > 200)
+        return 5;
+    return 0;
+}

package/dist/lib/html-report.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Self-contained HTML report generator.
+ *
+ * Produces a standalone HTML file with inlined CSS. No JavaScript, no external
+ * dependencies. Opens in any browser. Dark mode via prefers-color-scheme.
+ *
+ * Content: health score donut, root cause, finding count by severity,
+ * all findings with descriptions and recommendations, timing summary.
+ */
+import type { AnalysisResult, HealthScore } from './types.js';
+export interface HtmlReportOptions {
+    title?: string;
+}
+export declare function generateHtmlReport(result: AnalysisResult, healthScore: HealthScore, options?: HtmlReportOptions): string;
+//# sourceMappingURL=html-report.d.ts.map

package/dist/lib/html-report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"html-report.d.ts","sourceRoot":"","sources":["../../src/lib/html-report.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAW,MAAM,YAAY,CAAA;AAEtE,MAAM,WAAW,iBAAiB;IAChC,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,cAAc,EACtB,WAAW,EAAE,WAAW,EACxB,OAAO,CAAC,EAAE,iBAAiB,GAC1B,MAAM,CAmHR"}

package/dist/lib/html-report.js

@@ -0,0 +1,299 @@
+export function generateHtmlReport(result, healthScore, options) {
+    const title = options?.title ?? 'HAR Analysis Report';
+    const timestamp = new Date().toISOString();
+    const { findings, rootCause, metadata, entries } = result;
+    const score = healthScore.score;
+    // Sort findings: critical first, then warning, then info
+    const sorted = [...findings].sort((a, b) => {
+        const order = { critical: 0, warning: 1, info: 2 };
+        return order[a.severity] - order[b.severity];
+    });
+    const counts = {
+        critical: findings.filter(f => f.severity === 'critical').length,
+        warning: findings.filter(f => f.severity === 'warning').length,
+        info: findings.filter(f => f.severity === 'info').length,
+    };
+    // Root cause
+    const rcEntries = Object.entries(rootCause);
+    rcEntries.sort((a, b) => b[1] - a[1]);
+    const topCause = rcEntries[0];
+    const rootCauseText = topCause[1] === 0
+        ? 'None (no findings)'
+        : `${topCause[0].charAt(0).toUpperCase() + topCause[0].slice(1)} (${Math.round(topCause[1] * 100)}%)`;
+    // Timing
+    const totalTimeMs = metadata.totalTimeMs;
+    const totalTimeStr = totalTimeMs >= 10_000
+        ? `${(totalTimeMs / 1000).toFixed(1)}s`
+        : `${Math.round(totalTimeMs)}ms`;
+    // Health score donut SVG
+    const circumference = 2 * Math.PI * 45;
+    const offset = circumference * (1 - score / 100);
+    const scoreColor = score >= 90 ? 'var(--good)' : score >= 50 ? 'var(--ok)' : 'var(--bad)';
+    const donutSvg = `<svg viewBox="0 0 100 100" class="donut">
+      <circle cx="50" cy="50" r="45" fill="none" stroke="var(--surface-hover)" stroke-width="8"/>
+      <circle cx="50" cy="50" r="45" fill="none" stroke="${scoreColor}" stroke-width="8"
+        stroke-dasharray="${circumference.toFixed(1)}" stroke-dashoffset="${offset.toFixed(1)}"
+        stroke-linecap="round" transform="rotate(-90 50 50)"/>
+      <text x="50" y="50" text-anchor="middle" dominant-baseline="central"
+        fill="var(--text)" font-size="24" font-weight="700">${score}</text>
+      <text x="50" y="66" text-anchor="middle" fill="var(--text-3)" font-size="8">/100</text>
+    </svg>`;
+    // Findings HTML
+    const findingsHtml = sorted.length > 0
+        ? sorted.map(f => renderFinding(f)).join('\n')
+        : '<p class="no-findings">No issues found.</p>';
+    // Severity summary badges
+    const badgesHtml = [
+        counts.critical > 0 ? `<span class="badge critical">${counts.critical} critical</span>` : '',
+        counts.warning > 0 ? `<span class="badge warning">${counts.warning} warning</span>` : '',
+        counts.info > 0 ? `<span class="badge info">${counts.info} info</span>` : '',
+    ].filter(Boolean).join('\n          ');
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${escapeHtml(title)}</title>
+  <style>${CSS}</style>
+</head>
+<body>
+  <div class="report">
+    <header class="report-header">
+      <h1>${escapeHtml(title)}</h1>
+      <time datetime="${timestamp}">${new Date(timestamp).toLocaleString()}</time>
+    </header>
+
+    <section class="summary">
+      <div class="score-card">
+        ${donutSvg}
+      </div>
+      <div class="stats">
+        <div class="stat">
+          <span class="stat-label">Requests</span>
+          <span class="stat-value">${metadata.totalRequests}</span>
+        </div>
+        <div class="stat">
+          <span class="stat-label">Total Time</span>
+          <span class="stat-value">${totalTimeStr}</span>
+        </div>
+        <div class="stat">
+          <span class="stat-label">Root Cause</span>
+          <span class="stat-value">${rootCauseText}</span>
+        </div>
+        <div class="stat">
+          <span class="stat-label">Analysis</span>
+          <span class="stat-value">${metadata.analysisTimeMs}ms</span>
+        </div>
+      </div>
+    </section>
+
+    <section class="findings-section">
+      <h2>Findings (${findings.length})</h2>
+      <div class="badges">
+        ${badgesHtml || '<span class="badge info">0 issues</span>'}
+      </div>
+      <div class="findings">
+        ${findingsHtml}
+      </div>
+    </section>
+
+    <footer class="report-footer">
+      Generated by <a href="https://github.com/vegaPDX/har-o-scope">har-o-scope</a>
+    </footer>
+  </div>
+</body>
+</html>`;
+}
+function renderFinding(f) {
+    return `<div class="finding ${f.severity}">
+          <div class="finding-header">
+            <span class="severity-badge ${f.severity}">${f.severity.toUpperCase()}</span>
+            <span class="finding-title">${escapeHtml(f.title)}</span>
+          </div>
+          <p class="finding-desc">${escapeHtml(f.description)}</p>
+          <p class="finding-fix">${escapeHtml(f.recommendation)}</p>
+          <span class="finding-meta">Rule: ${escapeHtml(f.ruleId)} · Category: ${escapeHtml(f.category)} · Affected: ${f.affectedEntries.length} entries</span>
+        </div>`;
+}
+function escapeHtml(s) {
+    return s
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+// ── Inlined CSS ─────────────────────────────────────────────────
+const CSS = `
+    :root {
+      --bg: #0f1117;
+      --surface: #1a1d27;
+      --surface-hover: #252830;
+      --border: #2f323b;
+      --text: #e4e4e7;
+      --text-2: #a1a1aa;
+      --text-3: #71717a;
+      --accent: #3b82f6;
+      --critical: #ef4444;
+      --critical-bg: #451a1a;
+      --warning: #f59e0b;
+      --warning-bg: #451a00;
+      --info: #3b82f6;
+      --info-bg: #1a2744;
+      --good: #22c55e;
+      --ok: #f59e0b;
+      --bad: #ef4444;
+    }
+    @media (prefers-color-scheme: light) {
+      :root {
+        --bg: #ffffff;
+        --surface: #f9fafb;
+        --surface-hover: #f3f4f6;
+        --border: #e5e7eb;
+        --text: #18181b;
+        --text-2: #52525b;
+        --text-3: #a1a1aa;
+        --critical-bg: #fef2f2;
+        --warning-bg: #fffbeb;
+        --info-bg: #eff6ff;
+      }
+    }
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body {
+      font-family: 'IBM Plex Sans', system-ui, -apple-system, sans-serif;
+      font-size: 14px;
+      line-height: 1.5;
+      color: var(--text);
+      background: var(--bg);
+    }
+    .report {
+      max-width: 720px;
+      margin: 0 auto;
+      padding: 32px 24px;
+    }
+    .report-header {
+      margin-bottom: 32px;
+    }
+    .report-header h1 {
+      font-size: 20px;
+      font-weight: 700;
+      margin-bottom: 4px;
+    }
+    .report-header time {
+      font-size: 12px;
+      color: var(--text-3);
+    }
+    .summary {
+      display: flex;
+      align-items: center;
+      gap: 32px;
+      padding: 24px;
+      background: var(--surface);
+      border: 1px solid var(--border);
+      border-radius: 8px;
+      margin-bottom: 32px;
+    }
+    .score-card { flex-shrink: 0; }
+    .donut { width: 100px; height: 100px; }
+    .stats {
+      display: grid;
+      grid-template-columns: 1fr 1fr;
+      gap: 16px;
+      flex: 1;
+    }
+    .stat-label {
+      display: block;
+      font-size: 11px;
+      font-weight: 500;
+      color: var(--text-3);
+      text-transform: uppercase;
+      letter-spacing: 0.05em;
+      margin-bottom: 2px;
+    }
+    .stat-value {
+      font-size: 16px;
+      font-weight: 600;
+      font-family: 'IBM Plex Mono', ui-monospace, monospace;
+    }
+    .findings-section { margin-bottom: 32px; }
+    .findings-section h2 {
+      font-size: 16px;
+      font-weight: 600;
+      margin-bottom: 8px;
+    }
+    .badges { display: flex; gap: 8px; margin-bottom: 16px; }
+    .badge {
+      font-size: 11px;
+      font-weight: 600;
+      padding: 2px 8px;
+      border-radius: 4px;
+    }
+    .badge.critical { color: var(--critical); background: var(--critical-bg); }
+    .badge.warning { color: var(--warning); background: var(--warning-bg); }
+    .badge.info { color: var(--info); background: var(--info-bg); }
+    .finding {
+      padding: 16px;
+      border: 1px solid var(--border);
+      border-radius: 8px;
+      margin-bottom: 12px;
+    }
+    .finding.critical { border-left: 3px solid var(--critical); }
+    .finding.warning { border-left: 3px solid var(--warning); }
+    .finding.info { border-left: 3px solid var(--info); }
+    .finding-header {
+      display: flex;
+      align-items: center;
+      gap: 8px;
+      margin-bottom: 8px;
+    }
+    .severity-badge {
+      font-size: 10px;
+      font-weight: 700;
+      padding: 1px 6px;
+      border-radius: 3px;
+      letter-spacing: 0.03em;
+    }
+    .severity-badge.critical { color: var(--critical); background: var(--critical-bg); }
+    .severity-badge.warning { color: var(--warning); background: var(--warning-bg); }
+    .severity-badge.info { color: var(--info); background: var(--info-bg); }
+    .finding-title {
+      font-size: 14px;
+      font-weight: 600;
+    }
+    .finding-desc {
+      font-size: 13px;
+      color: var(--text-2);
+      margin-bottom: 8px;
+    }
+    .finding-fix {
+      font-size: 13px;
+      color: var(--text-2);
+      margin-bottom: 8px;
+      padding-left: 12px;
+      border-left: 2px solid var(--accent);
+    }
+    .finding-meta {
+      font-size: 11px;
+      color: var(--text-3);
+      font-family: 'IBM Plex Mono', ui-monospace, monospace;
+    }
+    .no-findings {
+      color: var(--text-2);
+      padding: 24px;
+      text-align: center;
+    }
+    .report-footer {
+      text-align: center;
+      font-size: 11px;
+      color: var(--text-3);
+      padding-top: 24px;
+      border-top: 1px solid var(--border);
+    }
+    .report-footer a {
+      color: var(--accent);
+      text-decoration: none;
+    }
+    @media (max-width: 500px) {
+      .summary { flex-direction: column; gap: 16px; }
+      .stats { grid-template-columns: 1fr 1fr; }
+    }
+`;

package/dist/lib/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * har-o-scope public API.
+ *
+ * This barrel file IS the API contract. Anything not re-exported here is internal.
+ * ~15 public exports specified in eng review #2.
+ */
+export { analyze, setBuiltinRules } from './analyze.js';
+export type { AnalysisResult, AnalysisOptions } from './types.js';
+export { diff } from './diff.js';
+export { normalizeUrlForGrouping } from './diff.js';
+export type { DiffResult, TimingDelta, FindingDelta } from './types.js';
+export { computeHealthScore, computeHealthScoreFromParts } from './health-score.js';
+export type { HealthScore, ScoreBreakdown, ScoreDeduction } from './types.js';
+export { sanitize } from './sanitizer.js';
+export { sanitizeTrace, sanitizeUrl, sanitizeHeaderValue } from './trace-sanitizer.js';
+export type { SanitizeOptions, SanitizeCategory, SanitizeMode } from './types.js';
+export { validate } from './validator.js';
+export type { ValidationResult, ValidationError } from './types.js';
+export { parseHar, normalizeHar } from './normalizer.js';
+export { generateHtmlReport } from './html-report.js';
+export type { HtmlReportOptions } from './html-report.js';
+export { HarError, HAR_ERRORS, RULE_ERRORS, CLI_ERRORS, createWarning } from './errors.js';
+export type { AnalysisWarning } from './types.js';
+export type { NormalizedEntry, NormalizedTimings, ResourceType, Finding, RootCauseResult, IssueSeverity, IssueCategory, AnalysisMetadata, Har, Entry, Header, } from './types.js';
+export type { YamlRule, IssueRulesFile, SharedConditionsFile, FiltersFile, FieldCondition, ConditionNode, ConditionGroup, ResponseHeaderCondition, SeverityEscalation, ImpactSpec, RootCauseWeight, } from './schema.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/lib/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AACvD,YAAY,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAGjE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAChC,OAAO,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAA;AACnD,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAGvE,OAAO,EAAE,kBAAkB,EAAE,2BAA2B,EAAE,MAAM,mBAAmB,CAAA;AACnF,YAAY,EAAE,WAAW,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAG7E,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AACzC,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAA;AACtF,YAAY,EAAE,eAAe,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAGjF,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AACzC,YAAY,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAGnE,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAGxD,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AACrD,YAAY,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAGzD,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAC1F,YAAY,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAGjD,YAAY,EACV,eAAe,EACf,iBAAiB,EACjB,YAAY,EACZ,OAAO,EACP,eAAe,EACf,aAAa,EACb,aAAa,EACb,gBAAgB,EAChB,GAAG,EACH,KAAK,EACL,MAAM,GACP,MAAM,YAAY,CAAA;AAGnB,YAAY,EACV,QAAQ,EACR,cAAc,EACd,oBAAoB,EACpB,WAAW,EACX,cAAc,EACd,aAAa,EACb,cAAc,EACd,uBAAuB,EACvB,kBAAkB,EAClB,UAAU,EACV,eAAe,GAChB,MAAM,aAAa,CAAA"}

package/dist/lib/index.js

@@ -0,0 +1,24 @@
+/**
+ * har-o-scope public API.
+ *
+ * This barrel file IS the API contract. Anything not re-exported here is internal.
+ * ~15 public exports specified in eng review #2.
+ */
+// Analysis
+export { analyze, setBuiltinRules } from './analyze.js';
+// Diff
+export { diff } from './diff.js';
+export { normalizeUrlForGrouping } from './diff.js';
+// Health Score
+export { computeHealthScore, computeHealthScoreFromParts } from './health-score.js';
+// Sanitization
+export { sanitize } from './sanitizer.js';
+export { sanitizeTrace, sanitizeUrl, sanitizeHeaderValue } from './trace-sanitizer.js';
+// Validation
+export { validate } from './validator.js';
+// Parsing / Normalization (useful for advanced consumers)
+export { parseHar, normalizeHar } from './normalizer.js';
+// HTML Report
+export { generateHtmlReport } from './html-report.js';
+// Errors
+export { HarError, HAR_ERRORS, RULE_ERRORS, CLI_ERRORS, createWarning } from './errors.js';

package/dist/lib/normalizer.d.ts

@@ -0,0 +1,18 @@
+/**
+ * HAR normalizer: parses HAR JSON and produces NormalizedEntry[].
+ *
+ * Pre-computes fields needed by the rule engine: startTimeMs, totalDuration,
+ * transferSizeResolved, isLongPoll, isWebSocket, resourceType.
+ * Handles edge cases: missing fields, sanitized Chrome exports (transferSize=0),
+ * WebSocket entries, long-polls.
+ */
+import type { Har } from 'har-format';
+import type { NormalizedEntry } from './types.js';
+import type { AnalysisWarning } from './types.js';
+export interface NormalizeResult {
+    entries: NormalizedEntry[];
+    warnings: AnalysisWarning[];
+}
+export declare function normalizeHar(har: Har): NormalizeResult;
+export declare function parseHar(input: string): Har;
+//# sourceMappingURL=normalizer.d.ts.map