@gracker/smartperfetto 1.0.19 → 1.0.21

package/dist/agent/scene/sceneIntervalBuilder.js

@@ -5,6 +5,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildDisplayedScenes = buildDisplayedScenes;
 exports.buildAnalysisIntervals = buildAnalysisIntervals;
+exports.isAnalysisEligibleScene = isAnalysisEligibleScene;
+exports.selectAnalysisEligibleScenes = selectAnalysisEligibleScenes;
+exports.filterDisplayedScenesForSelection = filterDisplayedScenesForSelection;
 exports.computePriority = computePriority;
 const helpers_1 = require("../strategies/helpers");
 const domainManifest_1 = require("../config/domainManifest");
@@ -37,6 +40,7 @@ const SCENE_DISPLAY_NAMES = {
     screen_unlock: '解锁屏幕',
     notification: '通知操作',
     split_screen: '分屏操作',
+    pip: '画中画',
     tap: '点击',
     long_press: '长按',
     idle: '空闲',
@@ -49,6 +53,36 @@ const SCENE_DISPLAY_NAMES = {
     ime_hide: '键盘收起',
     window_transition: '窗口转场',
 };
+const SCENE_DEDUPE_TOLERANCE_NS = 150000000n;
+const SCROLL_CHAIN_TOLERANCE_NS = 250000000n;
+const CONTEXT_WINDOW_NS = 750000000n;
+const MAX_CONTEXT_ROWS_PER_GROUP = 6;
+const CLEAN_TIMELINE_SCENE_TYPES = new Set([
+    'cold_start',
+    'warm_start',
+    'hot_start',
+    'scroll',
+    'inertial_scroll',
+    'tap',
+    'long_press',
+    'idle',
+    'app_foreground',
+    'home_screen',
+    'screen_on',
+    'screen_off',
+    'screen_sleep',
+    'screen_unlock',
+    'notification',
+    'split_screen',
+    'pip',
+    'back_key',
+    'home_key',
+    'recents_key',
+    'anr',
+    'ime_show',
+    'ime_hide',
+    'window_transition',
+]);
 /** Known launcher / home-screen package patterns */
 const LAUNCHER_PATTERNS = [
     'miui.home', 'launcher', 'trebuchet', 'lawnchair',
@@ -61,6 +95,7 @@ function isLauncherPackage(pkg) {
 function buildDisplayedScenes(envelopes) {
     const scenes = [];
     const jankRowsForFallback = [];
+    const rowsByStep = new Map();
     let hasGestureLikeScene = false;
     let traceDurationSec = 0;
     for (const env of envelopes) {
@@ -70,6 +105,7 @@ function buildDisplayedScenes(envelopes) {
         if (!stepId)
             continue;
         const rows = (0, helpers_1.payloadToObjectRows)(env.data);
+        rowsByStep.set(stepId, rows);
         if (stepId === 'trace_time_range') {
             const first = rows[0];
             if (first?.duration_sec)
@@ -133,6 +169,13 @@ function buildDisplayedScenes(envelopes) {
                     scenes.push(scene);
             }
         }
+        else if (stepId === 'system_events') {
+            for (const row of rows) {
+                const scene = sceneFromSystemEvent(row, scenes.length);
+                if (scene)
+                    scenes.push(scene);
+            }
+        }
         else if (stepId === 'navigation_keys' || stepId === 'gesture_navigation') {
             for (const row of rows) {
                 const scene = sceneFromNavigationKey(row, scenes.length);
@@ -189,6 +232,7 @@ function buildDisplayedScenes(envelopes) {
             });
         }
     }
+    enrichDisplayedScenes(scenes, rowsByStep);
     // Sort by startTs so the timeline rendering and Stage 3 prompt see scenes
     // in chronological order regardless of which skill step produced them
     // (the scene_reconstruction skill's step order is structural, not temporal).
@@ -209,11 +253,12 @@ function buildDisplayedScenes(envelopes) {
 }
 function buildAnalysisIntervals(scenes, options) {
     const manifest = options.manifest ?? domainManifest_1.DEFAULT_DOMAIN_MANIFEST;
-    const routes = (0, domainManifest_1.getSceneReconstructionRoutes)(manifest);
+    const routes = (0, domainManifest_1.getSceneReconstructionRoutes)(options.routeProfile ?? 'legacy', manifest);
     if (routes.length === 0 || scenes.length === 0)
         return [];
     // Score each scene then pick a matching route in priority order.
     const scored = scenes
+        .filter(isAnalysisEligibleScene)
         .map((scene) => ({ scene, priority: computePriority(scene) }))
         .sort((a, b) => b.priority - a.priority);
     const intervals = [];
@@ -233,6 +278,32 @@ function buildAnalysisIntervals(scenes, options) {
     }
     return intervals;
 }
+function isAnalysisEligibleScene(scene) {
+    return scene.analysisEligible !== false &&
+        scene.sceneRole !== 'marker' &&
+        scene.sceneRole !== 'context';
+}
+function selectAnalysisEligibleScenes(scenes, selection) {
+    return filterDisplayedScenesForSelection(scenes, selection)
+        .filter(isAnalysisEligibleScene);
+}
+function filterDisplayedScenesForSelection(scenes, selection) {
+    if (!selection || selection.scope === 'all')
+        return scenes;
+    if (selection.scope === 'scene_types') {
+        const selectedTypes = new Set(selection.sceneTypes ?? []);
+        if (selectedTypes.size === 0)
+            return [];
+        return scenes.filter((scene) => selectedTypes.has(scene.sceneType));
+    }
+    if (selection.scope === 'scene_ids') {
+        const selectedIds = new Set(selection.sceneIds ?? []);
+        if (selectedIds.size === 0)
+            return [];
+        return scenes.filter((scene) => selectedIds.has(scene.id));
+    }
+    return [];
+}
 /**
  * Compute the same numeric priority the legacy strategy used: 90 when the
  * scene exceeds its threshold (a "problem" scene), 50 otherwise.
@@ -465,6 +536,40 @@ function sceneFromScreenStateChange(row, index) {
         analysisState: 'not_planned',
     };
 }
+function sceneFromSystemEvent(row, index) {
+    const startTs = String(row.ts ?? '');
+    if (!startTs)
+        return null;
+    const dur = String(row.dur ?? '0');
+    const endTs = safeAddNs(startTs, dur) ?? startTs;
+    const durationMs = nsToMs(dur);
+    const safeDurationMs = Number.isFinite(durationMs) ? durationMs : 0;
+    const rawType = String(row.event_type ?? '').trim();
+    const sceneType = rawType === 'screen_unlock' ? 'screen_unlock'
+        : rawType === 'notification' ? 'notification'
+            : rawType === 'split_screen' ? 'split_screen'
+                : rawType === 'pip' ? 'pip'
+                    : null;
+    if (!sceneType)
+        return null;
+    const eventText = String(row.event ?? '').trim();
+    return {
+        id: `system_events-${index}`,
+        sceneType,
+        sourceStepId: 'system_events',
+        startTs,
+        endTs,
+        durationMs: safeDurationMs,
+        processName: 'system',
+        label: `${displayNameOf(sceneType)} (${formatDuration(safeDurationMs)})`,
+        metadata: {
+            event: eventText,
+            eventType: rawType,
+        },
+        severity: 'good',
+        analysisState: 'not_planned',
+    };
+}
 // ---------------------------------------------------------------------------
 // New scene factories: navigation keys, ANR, IME, window transitions
 // ---------------------------------------------------------------------------
@@ -569,6 +674,478 @@ function sceneFromWindowTransition(row, index) {
         analysisState: 'not_planned',
     };
 }
+// ---------------------------------------------------------------------------
+// Scene contract enrichment and deterministic fusion
+// ---------------------------------------------------------------------------
+function enrichDisplayedScenes(scenes, rowsByStep) {
+    seedSceneContracts(scenes);
+    mergeCleanTimelineRows(scenes, getRows(rowsByStep, 'clean_timeline'));
+    attachRuntimeContext(scenes, rowsByStep);
+    linkScrollMarkersAndFling(scenes);
+    finalizeSceneContracts(scenes);
+}
+function seedSceneContracts(scenes) {
+    for (const scene of scenes) {
+        const primaryRef = evidenceRefForScene(scene, 'primary');
+        scene.sceneRole ?? (scene.sceneRole = defaultSceneRole(scene));
+        scene.analysisEligible ?? (scene.analysisEligible = scene.sceneRole === 'action');
+        scene.evidenceRefs = mergeEvidenceRefs(scene.evidenceRefs, [primaryRef]);
+        scene.confidenceReasons = uniqueStrings([
+            ...(scene.confidenceReasons ?? []),
+            `primary:${scene.sourceStepId}`,
+        ]);
+        scene.conflicts ?? (scene.conflicts = []);
+    }
+}
+function mergeCleanTimelineRows(scenes, rows) {
+    rows.forEach((row, index) => {
+        const sceneType = normalizeCleanTimelineSceneType(row.event_type);
+        if (!sceneType)
+            return;
+        const ref = evidenceRefForRow('clean_timeline', row, index, 'supporting');
+        const existing = findMatchingSceneForRow(scenes, sceneType, row);
+        if (existing) {
+            addSupportingEvidence(existing, ref, row, 'clean_timeline');
+            return;
+        }
+        const scene = sceneFromCleanTimeline(row, index);
+        if (!scene)
+            return;
+        scene.evidenceRefs = mergeEvidenceRefs(scene.evidenceRefs, [ref]);
+        scene.confidenceReasons = uniqueStrings([
+            ...(scene.confidenceReasons ?? []),
+            'derived:clean_timeline',
+        ]);
+        scenes.push(scene);
+    });
+}
+function sceneFromCleanTimeline(row, index) {
+    const sceneType = normalizeCleanTimelineSceneType(row.event_type);
+    if (!sceneType)
+        return null;
+    const startTs = String(row.ts ?? '');
+    if (!startTs)
+        return null;
+    const dur = String(row.dur ?? '0');
+    const endTs = safeAddNs(startTs, dur) ?? startTs;
+    const durationMs = nsToMs(dur);
+    const safeDurationMs = Number.isFinite(durationMs) ? durationMs : 0;
+    const eventId = String(row.event_id ?? '').trim();
+    const processName = String(row.app_package ?? '').trim() || defaultProcessNameForSceneType(sceneType);
+    const sceneRole = defaultSceneRoleForType(sceneType);
+    return {
+        id: eventId ? `clean_timeline-${eventId}` : `clean_timeline-${sceneType}-${startTs}-${index}`,
+        sceneType,
+        sourceStepId: 'clean_timeline',
+        startTs,
+        endTs,
+        durationMs: safeDurationMs,
+        processName,
+        label: `${displayNameOf(sceneType)} (${formatDuration(safeDurationMs)})`,
+        metadata: {
+            eventId: eventId || undefined,
+            event: row.event,
+            eventType: row.event_type,
+            timeOffset: row.time_offset,
+            rating: row.rating,
+        },
+        severity: severityFromRating(row.rating) ?? severityFor(sceneType, safeDurationMs, row),
+        sceneRole,
+        analysisEligible: sceneRole === 'action',
+        analysisState: 'not_planned',
+    };
+}
+function normalizeCleanTimelineSceneType(value) {
+    const sceneType = String(value ?? '').trim();
+    if (!sceneType)
+        return null;
+    if (sceneType === 'system')
+        return null;
+    return CLEAN_TIMELINE_SCENE_TYPES.has(sceneType) ? sceneType : null;
+}
+function findMatchingSceneForRow(scenes, sceneType, row) {
+    const rowStart = safeBigInt(row.ts);
+    if (rowStart === null)
+        return null;
+    const rowEnd = rowStart + (safeBigInt(row.dur) ?? 0n);
+    return scenes.find((scene) => {
+        if (!areSceneTypesEquivalent(scene.sceneType, sceneType))
+            return false;
+        const sceneStart = safeBigInt(scene.startTs);
+        const sceneEnd = safeBigInt(scene.endTs);
+        if (sceneStart === null || sceneEnd === null)
+            return false;
+        return rangesOverlapOrClose(sceneStart, sceneEnd, rowStart, rowEnd, SCENE_DEDUPE_TOLERANCE_NS);
+    }) ?? null;
+}
+function areSceneTypesEquivalent(left, right) {
+    if (left === right)
+        return true;
+    const appContext = new Set(['app_foreground', 'home_screen']);
+    if (appContext.has(left) && appContext.has(right))
+        return true;
+    return false;
+}
+function addSupportingEvidence(scene, ref, row, reason) {
+    scene.evidenceRefs = mergeEvidenceRefs(scene.evidenceRefs, [ref]);
+    scene.confidenceReasons = uniqueStrings([...(scene.confidenceReasons ?? []), `support:${reason}`]);
+    scene.context = {
+        ...(scene.context ?? {}),
+        cleanTimeline: appendBoundedContext(scene.context?.cleanTimeline, compactContextRow(row)),
+    };
+    const supportingApp = String(row.app_package ?? '').trim();
+    if (supportingApp && isMeaningfulProcess(scene.processName) && scene.processName !== supportingApp) {
+        scene.conflicts = [
+            ...(scene.conflicts ?? []),
+            {
+                type: 'app_mismatch',
+                severity: 'warning',
+                message: `scene app ${scene.processName} differs from ${reason} app ${supportingApp}`,
+                evidenceRefs: [evidenceRefForScene(scene, 'primary'), ref],
+            },
+        ];
+    }
+}
+function attachRuntimeContext(scenes, rowsByStep) {
+    const operationRows = getRows(rowsByStep, 'operation_chain');
+    const activityRows = getRows(rowsByStep, 'activity_lifecycle');
+    const appStateRows = [
+        ...getRows(rowsByStep, 'app_state_tracking'),
+        ...getRows(rowsByStep, 'app_states'),
+    ];
+    const deviceRows = getRows(rowsByStep, 'device_state');
+    for (const scene of scenes) {
+        const operationChain = contextRowsNearScene(operationRows, scene, CONTEXT_WINDOW_NS);
+        const activityLifecycle = contextRowsNearScene(activityRows, scene, CONTEXT_WINDOW_NS);
+        const appState = contextRowsNearScene(appStateRows, scene, CONTEXT_WINDOW_NS, (row) => sameMeaningfulProcess(scene.processName, row.app_package));
+        const deviceState = contextRowsNearScene(deviceRows, scene, CONTEXT_WINDOW_NS);
+        const context = {
+            ...(scene.context ?? {}),
+            ...(operationChain.length > 0 ? { operationChain } : {}),
+            ...(activityLifecycle.length > 0 ? { activityLifecycle } : {}),
+            ...(appState.length > 0 ? { appState } : {}),
+            ...(deviceState.length > 0 ? { deviceState } : {}),
+        };
+        if (Object.keys(context).length > 0) {
+            scene.context = context;
+        }
+        if (operationChain.length > 0) {
+            scene.evidenceRefs = mergeEvidenceRefs(scene.evidenceRefs, [
+                evidenceRefForContext('operation_chain', operationChain[0]),
+            ]);
+            scene.confidenceReasons = uniqueStrings([...(scene.confidenceReasons ?? []), 'context:operation_chain']);
+        }
+    }
+}
+function contextRowsNearScene(rows, scene, windowNs, predicate) {
+    const sceneStart = safeBigInt(scene.startTs);
+    const sceneEnd = safeBigInt(scene.endTs);
+    if (sceneStart === null || sceneEnd === null)
+        return [];
+    const start = sceneStart - windowNs;
+    const end = sceneEnd + windowNs;
+    const selected = [];
+    for (const row of rows) {
+        if (predicate && !predicate(row))
+            continue;
+        const rowTs = safeBigInt(row.ts);
+        if (rowTs === null || rowTs < start || rowTs > end)
+            continue;
+        selected.push(compactContextRow(row));
+        if (selected.length >= MAX_CONTEXT_ROWS_PER_GROUP)
+            break;
+    }
+    return selected;
+}
+function linkScrollMarkersAndFling(scenes) {
+    const scrolls = scenes.filter(scene => scene.sceneType === 'scroll');
+    const flings = scenes.filter(scene => scene.sceneType === 'inertial_scroll');
+    const markers = scenes.filter(scene => scene.sceneType === 'scroll_start');
+    for (const marker of markers) {
+        marker.sceneRole = 'marker';
+        marker.analysisEligible = false;
+        const parent = findContainingOrNearestScene(marker, scrolls, SCROLL_CHAIN_TOLERANCE_NS);
+        if (!parent)
+            continue;
+        linkParentChild(parent, marker);
+        marker.confidenceReasons = uniqueStrings([...(marker.confidenceReasons ?? []), 'linked:scroll_start']);
+    }
+    for (const fling of flings) {
+        const parent = findContainingOrNearestScene(fling, scrolls, SCROLL_CHAIN_TOLERANCE_NS, true);
+        if (!parent)
+            continue;
+        linkParentChild(parent, fling);
+        parent.confidenceReasons = uniqueStrings([...(parent.confidenceReasons ?? []), 'linked:inertial_scroll']);
+        fling.confidenceReasons = uniqueStrings([...(fling.confidenceReasons ?? []), 'linked:active_scroll']);
+    }
+}
+function findContainingOrNearestScene(target, candidates, toleranceNs, requireSameProcess = false) {
+    const targetStart = safeBigInt(target.startTs);
+    const targetEnd = safeBigInt(target.endTs);
+    if (targetStart === null || targetEnd === null)
+        return null;
+    let best = null;
+    for (const scene of candidates) {
+        if (scene.id === target.id)
+            continue;
+        if (requireSameProcess && !sameMeaningfulProcess(scene.processName, target.processName))
+            continue;
+        const sceneStart = safeBigInt(scene.startTs);
+        const sceneEnd = safeBigInt(scene.endTs);
+        if (sceneStart === null || sceneEnd === null)
+            continue;
+        if (!rangesOverlapOrClose(sceneStart, sceneEnd, targetStart, targetEnd, toleranceNs))
+            continue;
+        const distance = targetStart >= sceneStart && targetStart <= sceneEnd
+            ? 0n
+            : minBigInt(absBigInt(targetStart - sceneEnd), absBigInt(sceneStart - targetEnd));
+        if (!best || distance < best.distance) {
+            best = { scene, distance };
+        }
+    }
+    return best?.scene ?? null;
+}
+function linkParentChild(parent, child) {
+    child.parentSceneId = parent.id;
+    parent.childSceneIds = uniqueStrings([...(parent.childSceneIds ?? []), child.id]);
+}
+function finalizeSceneContracts(scenes) {
+    for (const scene of scenes) {
+        scene.sceneRole ?? (scene.sceneRole = defaultSceneRole(scene));
+        scene.analysisEligible ?? (scene.analysisEligible = scene.sceneRole === 'action');
+        scene.evidenceRefs = mergeEvidenceRefs(scene.evidenceRefs, [evidenceRefForScene(scene, 'primary')]);
+        scene.conflicts = dedupeConflicts(scene.conflicts ?? []);
+        const score = computeConfidenceScore(scene);
+        scene.confidenceScore = score;
+        scene.confidenceLevel = confidenceLevelForScore(score);
+        scene.confidenceReasons = uniqueStrings(scene.confidenceReasons ?? []);
+    }
+}
+function computeConfidenceScore(scene) {
+    const sourceBase = baseConfidenceForSource(scene.sourceStepId);
+    const evidenceCount = scene.evidenceRefs?.length ?? 0;
+    const supportBonus = Math.min(0.12, Math.max(0, evidenceCount - 1) * 0.04);
+    const metadataScore = confidenceScoreFromMetadata(scene.metadata?.confidence);
+    const conflictPenalty = Math.min(0.25, (scene.conflicts ?? []).length * 0.08);
+    const rolePenalty = scene.sceneRole === 'marker' ? 0.08 : scene.sceneRole === 'context' ? 0.05 : 0;
+    const raw = Math.max(sourceBase, metadataScore ?? 0) + supportBonus - conflictPenalty - rolePenalty;
+    return Math.max(0.35, Math.min(0.95, Number(raw.toFixed(2))));
+}
+function baseConfidenceForSource(sourceStepId) {
+    if (sourceStepId === 'app_launches')
+        return 0.9;
+    if (sourceStepId === 'user_gestures')
+        return 0.78;
+    if (sourceStepId === 'inertial_scrolls')
+        return 0.76;
+    if (sourceStepId === 'scroll_initiation')
+        return 0.64;
+    if (sourceStepId === 'system_events')
+        return 0.72;
+    if (sourceStepId === 'screen_state_changes')
+        return 0.78;
+    if (sourceStepId === 'top_app_changes')
+        return 0.72;
+    if (sourceStepId === 'idle_periods')
+        return 0.62;
+    if (sourceStepId === 'clean_timeline')
+        return 0.68;
+    if (sourceStepId === 'jank_events')
+        return 0.58;
+    return 0.7;
+}
+function confidenceScoreFromMetadata(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        if (value > 1)
+            return Math.min(0.95, value / 100);
+        return Math.max(0, Math.min(0.95, value));
+    }
+    const text = String(value ?? '').trim().toLowerCase();
+    if (!text)
+        return null;
+    if (text === '高' || text === 'high')
+        return 0.86;
+    if (text === '中' || text === 'medium')
+        return 0.74;
+    if (text === '低' || text === 'low')
+        return 0.58;
+    return null;
+}
+function confidenceLevelForScore(score) {
+    if (score >= 0.82)
+        return 'high';
+    if (score >= 0.65)
+        return 'medium';
+    return 'low';
+}
+function defaultSceneRole(scene) {
+    return defaultSceneRoleForType(scene.sceneType);
+}
+function defaultSceneRoleForType(sceneType) {
+    if (sceneType === 'scroll_start')
+        return 'marker';
+    if (sceneType === 'app_foreground' || sceneType === 'home_screen' || sceneType === 'idle') {
+        return 'context';
+    }
+    return 'action';
+}
+function defaultProcessNameForSceneType(sceneType) {
+    if (sceneType === 'screen_unlock'
+        || sceneType === 'notification'
+        || sceneType === 'split_screen'
+        || sceneType === 'pip'
+        || sceneType === 'screen_on'
+        || sceneType === 'screen_off'
+        || sceneType === 'screen_sleep'
+        || sceneType === 'ime_show'
+        || sceneType === 'ime_hide'
+        || sceneType === 'window_transition') {
+        return 'system';
+    }
+    return 'unknown';
+}
+function severityFromRating(value) {
+    const text = String(value ?? '');
+    if (!text)
+        return null;
+    if (text.includes('🔴'))
+        return 'bad';
+    if (text.includes('🟡'))
+        return 'warning';
+    if (text.includes('🟢'))
+        return 'good';
+    return null;
+}
+function evidenceRefForScene(scene, role) {
+    return {
+        sourceStepId: scene.sourceStepId,
+        role,
+        rowSelector: {
+            ts: scene.startTs,
+            sceneType: scene.sceneType,
+        },
+    };
+}
+function evidenceRefForRow(sourceStepId, row, rowIndex, role) {
+    const ref = {
+        sourceStepId,
+        rowIndex,
+        role,
+    };
+    const eventId = String(row.event_id ?? '').trim();
+    if (eventId)
+        ref.eventId = eventId;
+    const selector = {};
+    if (row.ts !== undefined && row.ts !== null)
+        selector.ts = String(row.ts);
+    const eventType = row.event_type ?? row.gesture_type ?? row.key_name ?? row.ime_action;
+    if (eventType !== undefined && eventType !== null)
+        selector.eventType = String(eventType);
+    if (Object.keys(selector).length > 0)
+        ref.rowSelector = selector;
+    return ref;
+}
+function evidenceRefForContext(sourceStepId, row) {
+    const selector = {};
+    if (row.ts !== undefined && row.ts !== null)
+        selector.ts = String(row.ts);
+    if (row.event !== undefined && row.event !== null)
+        selector.event = String(row.event);
+    if (row.category !== undefined && row.category !== null)
+        selector.category = String(row.category);
+    return {
+        sourceStepId,
+        role: 'context',
+        ...(Object.keys(selector).length > 0 ? { rowSelector: selector } : {}),
+    };
+}
+function mergeEvidenceRefs(existing, next) {
+    const merged = [...(existing ?? [])];
+    for (const ref of next) {
+        const key = evidenceRefKey(ref);
+        if (merged.some(item => evidenceRefKey(item) === key))
+            continue;
+        merged.push(ref);
+    }
+    return merged;
+}
+function evidenceRefKey(ref) {
+    const selector = ref.rowSelector ? JSON.stringify(ref.rowSelector) : '';
+    return `${ref.sourceStepId}:${ref.eventId ?? ''}:${ref.rowIndex ?? ''}:${ref.role ?? ''}:${selector}`;
+}
+function dedupeConflicts(conflicts) {
+    const seen = new Set();
+    const result = [];
+    for (const conflict of conflicts) {
+        const key = `${conflict.type}:${conflict.severity}:${conflict.message}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        result.push(conflict);
+    }
+    return result;
+}
+function getRows(rowsByStep, stepId) {
+    return rowsByStep.get(stepId) ?? [];
+}
+function compactContextRow(row) {
+    const compact = {};
+    for (const key of [
+        'event_id',
+        'time_offset',
+        'ts',
+        'dur',
+        'dur_ms',
+        'event_type',
+        'event',
+        'category',
+        'priority',
+        'app_package',
+        'activity_name',
+        'lifecycle_event',
+        'oom_adj',
+        'state_label',
+        'value',
+    ]) {
+        if (row[key] !== undefined && row[key] !== null)
+            compact[key] = row[key];
+    }
+    return compact;
+}
+function appendBoundedContext(existing, next) {
+    const rows = [...(existing ?? [])];
+    const key = JSON.stringify(next);
+    if (!rows.some(row => JSON.stringify(row) === key))
+        rows.push(next);
+    return rows.slice(0, MAX_CONTEXT_ROWS_PER_GROUP);
+}
+function rangesOverlapOrClose(aStart, aEnd, bStart, bEnd, toleranceNs) {
+    if (aEnd + toleranceNs < bStart)
+        return false;
+    if (bEnd + toleranceNs < aStart)
+        return false;
+    return true;
+}
+function sameMeaningfulProcess(left, right) {
+    const l = String(left ?? '').trim();
+    const r = String(right ?? '').trim();
+    if (!isMeaningfulProcess(l) || !isMeaningfulProcess(r))
+        return false;
+    return l === r;
+}
+function isMeaningfulProcess(value) {
+    const text = String(value ?? '').trim();
+    return !!text && text !== 'unknown' && text !== 'system';
+}
+function uniqueStrings(values) {
+    return Array.from(new Set(values.filter(Boolean)));
+}
+function absBigInt(value) {
+    return value < 0n ? -value : value;
+}
+function minBigInt(left, right) {
+    return left < right ? left : right;
+}
 function aggregateJankFramesToIntervals(rows) {
     if (rows.length === 0)
         return [];