1function profileNow() {
  2  return typeof performance !== 'undefined' && performance.now
  3    ? performance.now()
  4    : Date.now();
  5}
  6
  7function createDetectorProfile() {
  8  return { events: [] };
  9}
 10
 11function recordProfileEvent(profile, event) {
 12  if (!profile) return;
 13  const normalized = {
 14    engine: event.engine || 'unknown',
 15    phase: event.phase || 'unknown',
 16    ruleId: event.ruleId || 'unknown',
 17    target: event.target || '',
 18    ms: Number.isFinite(event.ms) ? event.ms : 0,
 19    findings: Number.isFinite(event.findings) ? event.findings : 0,
 20  };
 21  if (event.detail) normalized.detail = event.detail;
 22  if (Array.isArray(event.findingIds) && event.findingIds.length) {
 23    normalized.findingIds = event.findingIds;
 24  }
 25  if (typeof profile === 'function') {
 26    profile(normalized);
 27  } else if (typeof profile.record === 'function') {
 28    profile.record(normalized);
 29  } else if (Array.isArray(profile.events)) {
 30    profile.events.push(normalized);
 31  } else if (Array.isArray(profile)) {
 32    profile.push(normalized);
 33  }
 34}
 35
 36function extractFindingIds(findings) {
 37  if (!Array.isArray(findings) || findings.length === 0) return [];
 38  return [...new Set(findings.map(f => f?.id || f?.type || f?.antipattern).filter(Boolean))];
 39}
 40
 41function profileFindings(profile, meta, callback) {
 42  if (!profile) return callback();
 43  const started = profileNow();
 44  const findings = callback();
 45  recordProfileEvent(profile, {
 46    ...meta,
 47    ms: profileNow() - started,
 48    findings: Array.isArray(findings) ? findings.length : 0,
 49    findingIds: extractFindingIds(findings),
 50  });
 51  return findings;
 52}
 53
 54function profileStep(profile, meta, callback) {
 55  if (!profile) return callback();
 56  const started = profileNow();
 57  try {
 58    return callback();
 59  } finally {
 60    recordProfileEvent(profile, {
 61      ...meta,
 62      ms: profileNow() - started,
 63      findings: 0,
 64    });
 65  }
 66}
 67
 68async function profileFindingsAsync(profile, meta, callback) {
 69  if (!profile) return callback();
 70  const started = profileNow();
 71  const findings = await callback();
 72  recordProfileEvent(profile, {
 73    ...meta,
 74    ms: profileNow() - started,
 75    findings: Array.isArray(findings) ? findings.length : 0,
 76    findingIds: extractFindingIds(findings),
 77  });
 78  return findings;
 79}
 80
 81async function profileStepAsync(profile, meta, callback) {
 82  if (!profile) return callback();
 83  const started = profileNow();
 84  try {
 85    return await callback();
 86  } finally {
 87    recordProfileEvent(profile, {
 88      ...meta,
 89      ms: profileNow() - started,
 90      findings: 0,
 91    });
 92  }
 93}
 94
 95function percentile(sortedValues, pct) {
 96  if (!sortedValues.length) return 0;
 97  const idx = Math.min(
 98    sortedValues.length - 1,
 99    Math.max(0, Math.ceil((pct / 100) * sortedValues.length) - 1),
100  );
101  return sortedValues[idx];
102}
103
104function summarizeDetectorProfile(profile) {
105  const events = Array.isArray(profile)
106    ? profile
107    : (Array.isArray(profile?.events) ? profile.events : []);
108  const groups = new Map();
109  for (const event of events) {
110    const key = [
111      event.engine || 'unknown',
112      event.phase || 'unknown',
113      event.ruleId || 'unknown',
114      event.target || '',
115    ].join('\u0000');
116    let group = groups.get(key);
117    if (!group) {
118      group = {
119        engine: event.engine || 'unknown',
120        phase: event.phase || 'unknown',
121        ruleId: event.ruleId || 'unknown',
122        target: event.target || '',
123        calls: 0,
124        totalMs: 0,
125        findings: 0,
126        samples: [],
127      };
128      groups.set(key, group);
129    }
130    const ms = Number.isFinite(event.ms) ? event.ms : 0;
131    group.calls += 1;
132    group.totalMs += ms;
133    group.findings += Number.isFinite(event.findings) ? event.findings : 0;
134    group.samples.push(ms);
135  }
136  return [...groups.values()]
137    .map(group => {
138      const samples = group.samples.sort((a, b) => a - b);
139      return {
140        engine: group.engine,
141        phase: group.phase,
142        ruleId: group.ruleId,
143        target: group.target,
144        calls: group.calls,
145        totalMs: Number(group.totalMs.toFixed(3)),
146        avgMs: Number((group.totalMs / group.calls).toFixed(3)),
147        p50: Number(percentile(samples, 50).toFixed(3)),
148        p95: Number(percentile(samples, 95).toFixed(3)),
149        findings: group.findings,
150      };
151    })
152    .sort((a, b) => b.totalMs - a.totalMs);
153}
154
155export {
156  profileNow,
157  createDetectorProfile,
158  recordProfileEvent,
159  extractFindingIds,
160  profileFindings,
161  profileStep,
162  profileFindingsAsync,
163  profileStepAsync,
164  percentile,
165  summarizeDetectorProfile,
166};