@memorax/memorax-code 0.1.6 → 0.1.8

package/lib/memorax-code-backend/dist/viewer/history/claude-transcript.js

@@ -1,648 +0,0 @@
-import { createHash } from "node:crypto";
-import { open, readdir, stat } from "node:fs/promises";
-import { homedir } from "node:os";
-import { basename, join, resolve as resolvePath } from "node:path";
-import { memoryViewerEventKey } from "../projection/event-identity.js";
-import { claudeTranscriptMemoryActivitiesFromJsonLines } from "../../clients/claude/transcript-turn.js";
-import { resolveMemoryProject, } from "../../memory/project.js";
-const projections = new Map();
-const EMPTY_TRANSCRIPT_HISTORY = Object.freeze([]);
-const MAX_TRANSCRIPT_FILES = 250;
-const MAX_TRANSCRIPT_FILE_BYTES = 8 * 1024 * 1024;
-const MAX_TRANSCRIPT_REFRESH_BYTES = 64 * 1024 * 1024;
-const MAX_TRANSCRIPT_EVENTS_PER_FILE = 2_000;
-const MAX_TRANSCRIPT_RETAINED_EVENTS = 4_000;
-const MAX_TRANSCRIPT_RETAINED_BYTES = 32 * 1024 * 1024;
-export function claudeLocalProjectsRoot(env = process.env) {
-    const claudeHome = env.CLAUDE_CONFIG_DIR?.trim()
-        || env.CLAUDE_HOME?.trim()
-        || join(homedir(), ".claude");
-    return join(resolvePath(claudeHome), "projects");
-}
-export async function readClaudeLocalTranscriptHistory(projectsRoot, resolveProject = resolveMemoryProject) {
-    if (typeof projectsRoot !== "string" || !projectsRoot.trim()) {
-        return EMPTY_TRANSCRIPT_HISTORY;
-    }
-    const normalizedRoot = resolvePath(projectsRoot.trim());
-    let projection = projections.get(normalizedRoot);
-    if (projection && projection.identity !== resolveProject)
-        projection = undefined;
-    if (!projection) {
-        projection = { identity: resolveProject, files: new Map(), values: [] };
-        projections.set(normalizedRoot, projection);
-    }
-    if (projection.refresh)
-        return projection.refresh;
-    const refresh = refreshProjection(projection, normalizedRoot, resolveProject);
-    projection.refresh = refresh;
-    try {
-        return await refresh;
-    }
-    finally {
-        if (projection.refresh === refresh)
-            projection.refresh = undefined;
-    }
-}
-export function clearClaudeLocalTranscriptProjections() {
-    projections.clear();
-}
-async function refreshProjection(projection, projectsRoot, resolveProject) {
-    const files = await discoverTranscriptFiles(projectsRoot);
-    const activePaths = new Set(files.map((file) => file.path));
-    let changed = false;
-    let allowBackfill = false;
-    for (const path of projection.files.keys()) {
-        if (activePaths.has(path))
-            continue;
-        projection.files.delete(path);
-        changed = true;
-        allowBackfill = true;
-    }
-    let remainingBytes = MAX_TRANSCRIPT_REFRESH_BYTES;
-    for (const file of files) {
-        const cached = projection.files.get(file.path);
-        const unchanged = cached
-            && cached.observedSize === file.size
-            && cached.modifiedAtMs === file.modifiedAtMs
-            && cached.changedAtMs === file.changedAtMs
-            && cached.inode === file.inode;
-        if (unchanged && (!allowBackfill || cached.projectionTruncated !== true)) {
-            continue;
-        }
-        if (remainingBytes <= 0)
-            continue;
-        const bytesToRead = Math.min(file.size, MAX_TRANSCRIPT_FILE_BYTES);
-        if (bytesToRead > remainingBytes)
-            continue;
-        const rangeStart = Math.max(0, file.size - bytesToRead);
-        let buffer;
-        try {
-            buffer = await readFileRange(file.path, rangeStart, file.size);
-        }
-        catch {
-            if (cached) {
-                projection.files.delete(file.path);
-                changed = true;
-                allowBackfill = true;
-            }
-            continue;
-        }
-        remainingBytes -= buffer.byteLength;
-        const parsed = projectTranscriptChunk(buffer, resolveProject, initialParserState(file.sessionId), rangeStart > 0);
-        const events = parsed.events.slice(-MAX_TRANSCRIPT_EVENTS_PER_FILE);
-        projection.files.set(file.path, {
-            observedSize: file.size,
-            modifiedAtMs: file.modifiedAtMs,
-            changedAtMs: file.changedAtMs,
-            inode: file.inode,
-            events,
-            projectionTruncated: false,
-        });
-        if (!sameTranscriptEvents(events, cached?.events)) {
-            changed = true;
-            allowBackfill = true;
-        }
-    }
-    if (changed) {
-        projection.values = retainTranscriptProjectionEvents(projection);
-    }
-    return projection.values;
-}
-function retainTranscriptProjectionEvents(projection) {
-    const candidates = [...projection.files.values()]
-        .flatMap((file) => file.events)
-        .sort(compareEvents);
-    const retained = [];
-    let retainedBytes = 0;
-    for (let index = candidates.length - 1; index >= 0; index -= 1) {
-        const event = candidates[index];
-        if (!event || retained.length >= MAX_TRANSCRIPT_RETAINED_EVENTS)
-            break;
-        const eventBytes = transcriptEventRetainedBytes(event);
-        if (retainedBytes + eventBytes > MAX_TRANSCRIPT_RETAINED_BYTES)
-            break;
-        retained.push(event);
-        retainedBytes += eventBytes;
-    }
-    const retainedEvents = new Set(retained);
-    for (const [path, cached] of projection.files) {
-        const events = cached.events.filter((event) => retainedEvents.has(event));
-        const projectionTruncated = events.length !== cached.events.length;
-        if (projectionTruncated || cached.projectionTruncated === true) {
-            projection.files.set(path, { ...cached, events, projectionTruncated });
-        }
-    }
-    return retained.reverse();
-}
-function transcriptEventRetainedBytes(event) {
-    return 256 + Buffer.byteLength([
-        event.eventKey,
-        event.timestamp,
-        event.projectId ?? "",
-        event.projectLabel ?? "",
-        event.content,
-    ].join("\u0000"));
-}
-function sameTranscriptEvents(current, cached) {
-    return cached !== undefined
-        && current.length === cached.length
-        && current.every((event, index) => {
-            const previous = cached[index];
-            return previous !== undefined
-                && event.eventKey === previous.eventKey
-                && event.timestamp === previous.timestamp
-                && event.projectId === previous.projectId
-                && event.projectLabel === previous.projectLabel
-                && event.content === previous.content
-                && event.ok === previous.ok
-                && event.turnOutcome === previous.turnOutcome;
-        });
-}
-async function discoverTranscriptFiles(projectsRoot) {
-    let projectDirectories;
-    try {
-        projectDirectories = await readdir(projectsRoot, { withFileTypes: true });
-    }
-    catch {
-        return [];
-    }
-    const candidates = [];
-    for (const directory of projectDirectories) {
-        if (!directory.isDirectory())
-            continue;
-        const directoryPath = join(projectsRoot, directory.name);
-        let entries;
-        try {
-            entries = await readdir(directoryPath, { withFileTypes: true });
-        }
-        catch {
-            continue;
-        }
-        for (const entry of entries) {
-            if (!entry.isFile() || !entry.name.endsWith(".jsonl"))
-                continue;
-            const sessionId = safeIdentifier(basename(entry.name, ".jsonl"));
-            if (sessionId)
-                candidates.push({ path: join(directoryPath, entry.name), sessionId });
-        }
-    }
-    const files = [];
-    for (const candidate of candidates) {
-        try {
-            const metadata = await stat(candidate.path);
-            if (!metadata.isFile())
-                continue;
-            files.push({
-                ...candidate,
-                size: metadata.size,
-                modifiedAtMs: metadata.mtimeMs,
-                changedAtMs: metadata.ctimeMs,
-                inode: metadata.ino,
-            });
-        }
-        catch {
-            // A live Claude session may rotate a file between directory listing and stat.
-        }
-    }
-    return files
-        .sort((left, right) => right.modifiedAtMs - left.modifiedAtMs || left.path.localeCompare(right.path))
-        .slice(0, MAX_TRANSCRIPT_FILES);
-}
-function projectTranscriptChunk(buffer, resolveProject, initialState, skipLeadingPartial) {
-    const events = [];
-    const recordTurns = new Map();
-    const recordParents = new Map();
-    const terminalRecords = new Map();
-    const ambiguousTurns = new Set();
-    const partialAnswers = new Map();
-    let state = initialState;
-    let lineStart = 0;
-    if (skipLeadingPartial) {
-        const newline = buffer.indexOf(0x0a);
-        if (newline < 0)
-            return { consumedByteLength: buffer.byteLength, events, state };
-        lineStart = newline + 1;
-    }
-    const completeChunkStart = lineStart;
-    let consumedByteLength = lineStart;
-    while (lineStart < buffer.byteLength) {
-        const newline = buffer.indexOf(0x0a, lineStart);
-        if (newline < 0)
-            break;
-        const lineEnd = newline > lineStart && buffer[newline - 1] === 0x0d ? newline - 1 : newline;
-        const raw = parseRecord(buffer.subarray(lineStart, lineEnd).toString("utf8"));
-        consumedByteLength = newline + 1;
-        lineStart = newline + 1;
-        if (!raw)
-            continue;
-        const type = stringValue(raw.type);
-        const message = record(raw.message);
-        const recordId = safeIdentifier(raw.uuid);
-        const messageId = safeIdentifier(message?.id);
-        const parentId = safeIdentifier(raw.parentUuid ?? raw.parent_uuid);
-        if (parentId) {
-            if (recordId)
-                recordParents.set(recordId, parentId);
-            if (messageId)
-                recordParents.set(messageId, parentId);
-        }
-        const inheritedLineage = parentId ? recordTurns.get(parentId) : undefined;
-        const declaredSessionId = stringValue(raw.sessionId);
-        const sessionId = declaredSessionId
-            ? safeIdentifier(declaredSessionId)
-            : state.activeSessionId;
-        const cwd = stringValue(raw.cwd);
-        const project = cwd ? resolveProject(cwd) : state.activeProject;
-        const compatibleInheritedLineage = inheritedLineage
-            && transcriptLineageMatchesRecord(inheritedLineage, declaredSessionId, sessionId, cwd, project)
-            ? inheritedLineage
-            : undefined;
-        if (isHiddenRecord(raw)) {
-            if (raw.isSidechain !== true && compatibleInheritedLineage) {
-                if (recordId)
-                    recordTurns.set(recordId, compatibleInheritedLineage);
-                if (messageId)
-                    recordTurns.set(messageId, compatibleInheritedLineage);
-            }
-            continue;
-        }
-        if (type !== "user" && type !== "assistant")
-            continue;
-        const timestamp = safeTimestamp(raw.timestamp);
-        if (!sessionId || !timestamp)
-            continue;
-        state = {
-            ...state,
-            activeSessionId: sessionId,
-            ...(project ? { activeProject: project } : {}),
-        };
-        if (type === "user") {
-            const interruptedMessageId = safeIdentifier(raw.interruptedMessageId ?? raw.interrupted_message_id);
-            if (interruptedMessageId) {
-                const interruptedCandidate = recordTurns.get(interruptedMessageId) ?? inheritedLineage;
-                const interruptedLineage = interruptedCandidate
-                    && transcriptLineageMatchesRecord(interruptedCandidate, declaredSessionId, sessionId, cwd, project)
-                    ? interruptedCandidate
-                    : undefined;
-                if (!interruptedLineage)
-                    continue;
-                if (recordId)
-                    recordTurns.set(recordId, interruptedLineage);
-                if (messageId)
-                    recordTurns.set(messageId, interruptedLineage);
-                const interruptedTurnId = interruptedLineage.turnId;
-                if (ambiguousTurns.has(interruptedTurnId))
-                    continue;
-                const terminalRecord = terminalRecords.get(interruptedTurnId);
-                if (terminalRecord) {
-                    ambiguousTurns.add(interruptedTurnId);
-                    removeTurnEndEvent(events, interruptedLineage.sessionId, interruptedTurnId);
-                    continue;
-                }
-                terminalRecords.set(interruptedTurnId, recordId || interruptedMessageId);
-                events.push(turnEndEvent({
-                    sessionId: interruptedLineage.sessionId,
-                    turnId: interruptedTurnId,
-                    timestamp,
-                    answer: partialAnswers.get(interruptedTurnId) ?? "",
-                    interrupted: true,
-                    error: "Claude Code turn was interrupted.",
-                    project: interruptedLineage.project,
-                }));
-                if (state.activeTurnId === interruptedTurnId
-                    && state.activeSessionId === interruptedLineage.sessionId) {
-                    state = { ...state, activeTurnId: "", activeTurnLineage: undefined };
-                }
-                continue;
-            }
-            if (!isInteractiveUserRecord(raw, message) || hasOnlyToolResults(message?.content)) {
-                if (recordId && compatibleInheritedLineage)
-                    recordTurns.set(recordId, compatibleInheritedLineage);
-                if (messageId && compatibleInheritedLineage)
-                    recordTurns.set(messageId, compatibleInheritedLineage);
-                continue;
-            }
-            const prompt = visibleText(message?.content);
-            const turnId = safeIdentifier(raw.promptId ?? raw.prompt_id)
-                || safeIdentifier(raw.uuid);
-            if (!prompt || !turnId)
-                continue;
-            const lineage = {
-                turnId,
-                sessionId,
-                ...(project ? { project } : {}),
-            };
-            state = { ...state, activeTurnId: turnId, activeTurnLineage: lineage };
-            if (recordId)
-                recordTurns.set(recordId, lineage);
-            if (messageId)
-                recordTurns.set(messageId, lineage);
-            events.push(turnStartEvent({ sessionId, turnId, timestamp, prompt, project }));
-            continue;
-        }
-        const assistantLineage = parentId
-            ? compatibleInheritedLineage
-            : state.activeTurnLineage
-                && transcriptLineageMatchesRecord(state.activeTurnLineage, declaredSessionId, sessionId, cwd, project)
-                ? state.activeTurnLineage
-                : undefined;
-        if (!assistantLineage)
-            continue;
-        const assistantTurnId = assistantLineage.turnId;
-        if (ambiguousTurns.has(assistantTurnId))
-            continue;
-        if (recordId)
-            recordTurns.set(recordId, assistantLineage);
-        if (messageId)
-            recordTurns.set(messageId, assistantLineage);
-        const answer = visibleText(message?.content);
-        if (answer)
-            partialAnswers.set(assistantTurnId, answer);
-        if (!isTerminalAssistantRecord(raw, message))
-            continue;
-        const terminalRecord = recordId || `${parentId}\u0000${timestamp}`;
-        const previousTerminalRecord = terminalRecords.get(assistantTurnId);
-        if (previousTerminalRecord && previousTerminalRecord !== terminalRecord) {
-            if (!recordId || !recordDescendsFrom(recordId, previousTerminalRecord, recordParents)) {
-                ambiguousTurns.add(assistantTurnId);
-                removeTurnEndEvent(events, assistantLineage.sessionId, assistantTurnId);
-                continue;
-            }
-            removeTurnEndEvent(events, assistantLineage.sessionId, assistantTurnId);
-        }
-        if (previousTerminalRecord === terminalRecord)
-            continue;
-        terminalRecords.set(assistantTurnId, terminalRecord);
-        const reachedTokenLimit = stringValue(message?.stop_reason) === "max_tokens";
-        const interrupted = raw.isApiErrorMessage === true || Boolean(raw.error) || reachedTokenLimit;
-        events.push(turnEndEvent({
-            sessionId: assistantLineage.sessionId,
-            turnId: assistantTurnId,
-            timestamp,
-            answer,
-            interrupted,
-            ...(interrupted ? {
-                error: reachedTokenLimit
-                    ? "Claude Code response reached its token limit."
-                    : "Claude Code recorded an API error.",
-            } : {}),
-            project: assistantLineage.project,
-        }));
-    }
-    const activityEvents = projectTranscriptMemoryActivities(buffer.subarray(completeChunkStart, consumedByteLength).toString("utf8"), initialState.activeSessionId, events, terminalRecords);
-    return {
-        consumedByteLength,
-        events: mergeTranscriptEvents([], [...events, ...activityEvents]),
-        state,
-    };
-}
-function projectTranscriptMemoryActivities(transcript, sessionId, lifecycleEvents, acceptedTerminalRecords) {
-    const finalizedTurnScopes = new Set(lifecycleEvents
-        .filter((event) => event.type === "turn_end" && event.sessionId === sessionId && event.turnId)
-        .map((event) => JSON.stringify([event.sessionId, event.turnId, event.projectId ?? null])));
-    const starts = new Map(lifecycleEvents
-        .filter((event) => event.type === "turn_start" && event.sessionId === sessionId && event.turnId)
-        .map((event) => [event.turnId, event]));
-    return claudeTranscriptMemoryActivitiesFromJsonLines(transcript, {
-        sessionId,
-        includeAuthority: true,
-    })
-        .flatMap((activity) => {
-        const turnId = safeIdentifier(activity.promptId);
-        const toolUseId = safeIdentifier(activity.toolUseId);
-        const terminalRecordId = safeIdentifier(activity.terminalRecordId);
-        const start = turnId ? starts.get(turnId) : undefined;
-        if (!start
-            || !turnId
-            || !toolUseId
-            || !terminalRecordId
-            || acceptedTerminalRecords.get(turnId) !== terminalRecordId
-            || activity.ok === undefined) {
-            return [];
-        }
-        const turnScope = JSON.stringify([sessionId, turnId, start.projectId ?? null]);
-        if (!finalizedTurnScopes.has(turnScope))
-            return [];
-        const timestamp = safeTimestamp(activity.timestamp)
-            || syntheticActivityTimestamp(start.timestamp, activity.index, activity.occurrence);
-        if (!timestamp)
-            return [];
-        const identity = createHash("sha256")
-            .update(JSON.stringify([
-            "claude-native-memory-activity-v1",
-            sessionId,
-            turnId,
-            toolUseId,
-            activity.occurrence,
-            activity.type,
-        ]))
-            .digest("hex")
-            .slice(0, 32);
-        const id = `claude-local:${sessionId}:${activity.type}:${identity}`;
-        const itemCount = activity.type === "memory_cli_search"
-            && activity.ok
-            && Number.isSafeInteger(activity.itemCount)
-            && (activity.itemCount ?? -1) >= 0
-            && (activity.itemCount ?? 101) <= 100
-            ? activity.itemCount
-            : undefined;
-        return [{
-                id,
-                eventKey: memoryViewerEventKey({ id, client: "claude", sessionId }),
-                client: "claude",
-                type: activity.type,
-                timestamp,
-                source: "memory_cli",
-                operation: activity.type === "memory_cli_add" ? "writeback" : "query",
-                ok: activity.ok,
-                ...(start.projectId ? { projectId: start.projectId } : {}),
-                ...(start.projectLabel ? { projectLabel: start.projectLabel } : {}),
-                ...(start.project ? { project: start.project } : {}),
-                sessionId,
-                turnId,
-                content: activity.type === "memory_cli_add"
-                    ? "Claude Code invoked memory add."
-                    : "Claude Code invoked memory search.",
-                ...(itemCount === undefined ? {} : { itemCount }),
-                ...(activity.ok === false ? { error: "Claude Code recorded a failed memory command." } : {}),
-            }];
-    });
-}
-function syntheticActivityTimestamp(turnTimestamp, index, occurrence) {
-    const parsed = Date.parse(turnTimestamp);
-    return Number.isFinite(parsed)
-        ? new Date(parsed + index * 100 + occurrence).toISOString()
-        : "";
-}
-function transcriptLineageMatchesRecord(lineage, declaredSessionId, sessionId, cwd, project) {
-    if (declaredSessionId && sessionId !== lineage.sessionId)
-        return false;
-    if (!cwd)
-        return true;
-    return project?.projectId === lineage.project?.projectId;
-}
-function turnStartEvent(input) {
-    const id = `claude-local:${input.sessionId}:turn_start:${input.turnId}`;
-    return {
-        id,
-        eventKey: memoryViewerEventKey({ id, client: "claude", sessionId: input.sessionId }),
-        client: "claude",
-        type: "turn_start",
-        timestamp: input.timestamp,
-        source: "unknown",
-        operation: "query",
-        ok: true,
-        ...projectFields(input.project),
-        sessionId: input.sessionId,
-        turnId: input.turnId,
-        content: input.prompt,
-        prompt: input.prompt,
-    };
-}
-function turnEndEvent(input) {
-    const id = `claude-local:${input.sessionId}:turn_end:${input.turnId}`;
-    return {
-        id,
-        eventKey: memoryViewerEventKey({ id, client: "claude", sessionId: input.sessionId }),
-        client: "claude",
-        type: "turn_end",
-        timestamp: input.timestamp,
-        source: "unknown",
-        operation: "reply",
-        ok: !input.interrupted,
-        ...projectFields(input.project),
-        sessionId: input.sessionId,
-        turnId: input.turnId,
-        content: input.answer,
-        ...(input.answer ? { answer: input.answer } : {}),
-        turnOutcome: input.interrupted ? "interrupted" : "completed",
-        ...(input.error ? { error: input.error } : {}),
-    };
-}
-function removeTurnEndEvent(events, sessionId, turnId) {
-    const index = events.findIndex((event) => (event.type === "turn_end"
-        && event.sessionId === sessionId
-        && event.turnId === turnId));
-    if (index >= 0)
-        events.splice(index, 1);
-}
-function recordDescendsFrom(recordId, ancestorId, parents) {
-    const visited = new Set();
-    let current = recordId;
-    while (current && !visited.has(current)) {
-        if (current === ancestorId)
-            return true;
-        visited.add(current);
-        current = parents.get(current) ?? "";
-    }
-    return false;
-}
-function initialParserState(sessionId) {
-    return { activeTurnId: "", activeSessionId: sessionId };
-}
-function mergeTranscriptEvents(current, appended) {
-    if (appended.length === 0)
-        return current;
-    const events = new Map(current.map((event) => [event.eventKey, event]));
-    for (const event of appended)
-        events.set(event.eventKey, event);
-    return [...events.values()].sort(compareEvents).slice(-MAX_TRANSCRIPT_EVENTS_PER_FILE);
-}
-async function readFileRange(path, start, end) {
-    const handle = await open(path, "r");
-    try {
-        const buffer = Buffer.allocUnsafe(Math.max(0, end - start));
-        let offset = 0;
-        while (offset < buffer.byteLength) {
-            const { bytesRead } = await handle.read(buffer, offset, buffer.byteLength - offset, start + offset);
-            if (bytesRead === 0)
-                break;
-            offset += bytesRead;
-        }
-        return buffer.subarray(0, offset);
-    }
-    finally {
-        await handle.close();
-    }
-}
-function isHiddenRecord(raw) {
-    return raw.isMeta === true
-        || raw.isSidechain === true
-        || raw.isCompactSummary === true
-        || raw.isVisibleInTranscriptOnly === true;
-}
-function isInteractiveUserRecord(raw, message) {
-    if (raw.userType !== "external" || message?.role !== "user")
-        return false;
-    const origin = record(raw.origin);
-    return stringValue(origin?.kind).toLowerCase() !== "task-notification"
-        && stringValue(raw.promptSource ?? raw.prompt_source).toLowerCase() !== "system"
-        && !stringValue(raw.interruptedMessageId ?? raw.interrupted_message_id);
-}
-function isTerminalAssistantRecord(raw, message) {
-    if (message?.role !== "assistant")
-        return false;
-    if (raw.isApiErrorMessage === true || raw.error)
-        return true;
-    const stopReason = stringValue(message.stop_reason);
-    return Boolean(stopReason && stopReason !== "tool_use");
-}
-function hasOnlyToolResults(value) {
-    return Array.isArray(value)
-        && value.length > 0
-        && value.every((part) => stringValue(record(part)?.type) === "tool_result");
-}
-function visibleText(value) {
-    if (typeof value === "string")
-        return value.trim();
-    if (!Array.isArray(value))
-        return "";
-    return value
-        .map((part) => {
-        const block = record(part);
-        return stringValue(block?.type) === "text" ? stringValue(block?.text) : "";
-    })
-        .filter(Boolean)
-        .join("\n\n");
-}
-function projectFields(identity) {
-    if (!identity)
-        return {};
-    return {
-        projectId: identity.projectId,
-        projectLabel: identity.projectLabel,
-        project: identity.projectLabel,
-    };
-}
-function safeIdentifier(value) {
-    const candidate = stringValue(value);
-    if (!candidate || candidate.length > 512 || /[\u0000-\u001f\u007f\\/]/.test(candidate))
-        return "";
-    return candidate;
-}
-function safeTimestamp(value) {
-    const candidate = stringValue(value);
-    const parsed = Date.parse(candidate);
-    return Number.isFinite(parsed) ? new Date(parsed).toISOString() : "";
-}
-function parseRecord(line) {
-    if (!line.trim())
-        return undefined;
-    try {
-        return record(JSON.parse(line));
-    }
-    catch {
-        return undefined;
-    }
-}
-function record(value) {
-    return value && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : undefined;
-}
-function stringValue(value) {
-    return typeof value === "string" ? value.trim() : "";
-}
-function compareEvents(left, right) {
-    return Date.parse(left.timestamp) - Date.parse(right.timestamp) || left.eventKey.localeCompare(right.eventKey);
-}