@shapeshift-labs/loom 0.1.18 → 0.1.19

package/dist/graph.js

@@ -1,12 +1,8 @@
-import path from 'node:path';
-import { abs, nowIso, pathExists, readJson, resolveRoot, writeJson } from './common.js';
+import { abs, pathExists, readJson, resolveRoot, writeJson } from './common.js';
 import { readLoomConfig } from './config.js';
-import { FRONTIER_SWARM_CODEX_LIVE_RUN_GRAPH_EVENTS_ARTIFACT, materializeSwarmCodexLiveRunGraphEvents } from './graph-live.js';
 import { FRONTIER_RUN_GRAPH_SOURCE, normalizeFrontierRunEvents, parseFrontierRunEventsInput } from './graph-frontier-run.js';
 export const LOOM_NATIVE_RUN_GRAPH_SOURCE = 'loom-native';
-export const FRONTIER_SWARM_CODEX_RUN_GRAPH_SOURCE = 'frontier-swarm-codex';
 export const LOOM_RUN_GRAPH_CHUNK_TEMPLATE_KIND = 'loom.run-graph.chunk-template';
-export { FRONTIER_SWARM_CODEX_LIVE_RUN_GRAPH_EVENTS_ARTIFACT, FRONTIER_SWARM_CODEX_LIVE_RUN_GRAPH_EVENT_KIND, materializeSwarmCodexLiveRunGraphEvents, parseSwarmCodexRunGraphInput } from './graph-live.js';
 export { FRONTIER_RUN_GRAPH_SOURCE, normalizeFrontierRunEvents, parseFrontierRunEventsInput } from './graph-frontier-run.js';
 export function buildRunGraphChunkTemplate(options) {
     const nodes = uniqueStrings([
@@ -105,95 +101,6 @@ export async function writeLoomRunGraph(graph, options = {}) {
     await writeJson(file, graph);
     return file;
 }
-export function normalizeSwarmCodexRunGraph(input, options = {}) {
-    assertSwarmCodexRunGraph(input);
-    return normalizeSwarmCodexRunGraphArtifact(input, options);
-}
-export function normalizeSwarmCodexLiveRunGraphEvents(input, options = {}) {
-    const artifact = materializeSwarmCodexLiveRunGraphEvents(input, options);
-    const eventTypes = Array.from(new Set(input.map((event) => event.type).filter(Boolean)));
-    return normalizeSwarmCodexRunGraphArtifact(artifact, options, {
-        artifactKind: FRONTIER_SWARM_CODEX_LIVE_RUN_GRAPH_EVENTS_ARTIFACT,
-        eventCount: input.length,
-        eventTypes
-    }, {
-        swarmCodexLive: toJsonValue({
-            eventCount: input.length,
-            eventTypes,
-            firstGeneratedAt: input[0]?.generatedAt,
-            lastGeneratedAt: input.at(-1)?.generatedAt
-        })
-    }, input);
-}
-function normalizeSwarmCodexRunGraphArtifact(input, options = {}, sourceMetadata = {}, extraMetadata = {}, liveEvents = []) {
-    const root = resolveRoot(options.root);
-    const runId = options.runId ?? swarmRunGraphRunId(input);
-    const graph = normalizeSwarmCodexJobGraph(input);
-    const decisionGraph = normalizeSwarmCodexDecisionGraph(input, liveEvents);
-    const typedCounts = summarizeTypedCounts(decisionGraph);
-    const panels = createLoomRunGraphPanelRecords(decisionGraph);
-    return {
-        kind: 'loom.run-graph',
-        version: 1,
-        generatedAt: timestampToIso(input.generatedAt),
-        root,
-        runId,
-        source: FRONTIER_SWARM_CODEX_RUN_GRAPH_SOURCE,
-        sourceKind: FRONTIER_SWARM_CODEX_RUN_GRAPH_SOURCE,
-        sourceMetadata: {
-            kind: FRONTIER_SWARM_CODEX_RUN_GRAPH_SOURCE,
-            artifactKind: input.kind,
-            artifactId: input.id,
-            ...(options.sourcePath ? { path: options.sourcePath } : {}),
-            runDir: input.runDir,
-            outDir: input.outDir,
-            importedAt: nowIso(),
-            ...sourceMetadata
-        },
-        summary: {
-            nodes: graph.nodes.length,
-            edges: graph.edges.length,
-            roots: graph.roots.length,
-            leaves: graph.leaves.length,
-            issues: graph.issues.length,
-            ...(Object.keys(typedCounts).length ? { typedCounts } : {})
-        },
-        graph,
-        decisionGraph,
-        ...(panels.length ? { projections: { panels } } : {}),
-        metadata: {
-            swarmCodex: toJsonValue({
-                id: input.id,
-                summary: input.summary,
-                indexes: input.indexes,
-                nodes: input.nodes,
-                edges: input.edges
-            }),
-            ...extraMetadata
-        }
-    };
-}
-export async function importSwarmCodexRunGraph(input, options = {}) {
-    const graph = Array.isArray(input)
-        ? normalizeSwarmCodexLiveRunGraphEvents(input, options)
-        : normalizeSwarmCodexRunGraph(input, options);
-    const runId = options.runId ?? graph.runId ?? 'current';
-    const file = await writeLoomRunGraph(graph, { root: options.root, runId });
-    const artifactKind = graph.sourceMetadata?.artifactKind === FRONTIER_SWARM_CODEX_LIVE_RUN_GRAPH_EVENTS_ARTIFACT
-        ? 'live run graph events'
-        : 'run graph';
-    return {
-        ok: true,
-        message: `imported frontier-swarm-codex ${artifactKind} ${runId}`,
-        path: file,
-        runId,
-        present: true,
-        source: FRONTIER_SWARM_CODEX_RUN_GRAPH_SOURCE,
-        sourceKind: FRONTIER_SWARM_CODEX_RUN_GRAPH_SOURCE,
-        sourceMetadata: graph.sourceMetadata,
-        graphSummary: graph.summary
-    };
-}
 export async function importFrontierRunEvents(input, options = {}) {
     const events = typeof input === 'string' ? parseFrontierRunEventsInput(input) : input;
     const graph = normalizeFrontierRunEvents(events, options);
@@ -231,341 +138,6 @@ function assertLoomRunGraph(value, file = 'run graph') {
     if (value.decisionGraph !== undefined)
         assertLoomDecisionGraph(value.decisionGraph, file);
 }
-function normalizeSwarmCodexJobGraph(input) {
-    const nodeIds = new Set();
-    const edges = [];
-    const issues = [];
-    const seenEdges = new Set();
-    for (const node of input.nodes) {
-        if (typeof node.id === 'string' && node.id)
-            nodeIds.add(node.id);
-    }
-    for (const edge of input.edges) {
-        const from = typeof edge.from === 'string' ? edge.from : '';
-        const to = typeof edge.to === 'string' ? edge.to : '';
-        if (!from || !to) {
-            issues.push({
-                code: 'invalid-edge',
-                severity: 'warning',
-                message: `swarm edge ${edge.id || '<unknown>'} is missing from/to`
-            });
-            continue;
-        }
-        if (!nodeIds.has(from)) {
-            issues.push({
-                code: 'missing-edge-node',
-                severity: 'warning',
-                message: `swarm edge ${edge.id || '<unknown>'} references missing source node ${from}`,
-                path: `/edges/${edge.id || edges.length}/from`
-            });
-            nodeIds.add(from);
-        }
-        if (!nodeIds.has(to)) {
-            issues.push({
-                code: 'missing-edge-node',
-                severity: 'warning',
-                message: `swarm edge ${edge.id || '<unknown>'} references missing target node ${to}`,
-                path: `/edges/${edge.id || edges.length}/to`
-            });
-            nodeIds.add(to);
-        }
-        const normalized = { from, to, type: normalizeSwarmCodexEdgeKind(edge.kind) };
-        const key = `${normalized.type}\0${normalized.from}\0${normalized.to}`;
-        if (seenEdges.has(key))
-            continue;
-        seenEdges.add(key);
-        edges.push(normalized);
-    }
-    const nodes = Array.from(nodeIds).sort();
-    edges.sort((left, right) => left.from.localeCompare(right.from) ||
-        left.to.localeCompare(right.to) ||
-        left.type.localeCompare(right.type));
-    const dependentsByJobId = emptyGraphIndex(nodes);
-    const dependenciesByJobId = emptyGraphIndex(nodes);
-    for (const edge of edges) {
-        dependentsByJobId[edge.from]?.push(edge.to);
-        dependenciesByJobId[edge.to]?.push(edge.from);
-    }
-    sortGraphIndex(dependentsByJobId);
-    sortGraphIndex(dependenciesByJobId);
-    return {
-        nodes,
-        edges,
-        dependentsByJobId,
-        dependenciesByJobId,
-        roots: nodes.filter((node) => dependenciesByJobId[node]?.length === 0),
-        leaves: nodes.filter((node) => dependentsByJobId[node]?.length === 0),
-        issues
-    };
-}
-function normalizeSwarmCodexEdgeKind(kind) {
-    return kind === 'dependsOn' ? 'depends-on' : kind;
-}
-function normalizeSwarmCodexDecisionGraph(input, liveEvents = []) {
-    const nodes = input.nodes
-        .filter((node) => node && typeof node.id === 'string' && node.id)
-        .map((node) => normalizeSwarmCodexDecisionNode(node))
-        .sort((left, right) => left.id.localeCompare(right.id));
-    const edges = input.edges
-        .filter((edge) => edge && typeof edge.from === 'string' && typeof edge.to === 'string' && edge.from && edge.to)
-        .map((edge) => normalizeSwarmCodexDecisionEdge(edge))
-        .sort((left, right) => left.id.localeCompare(right.id));
-    const events = liveEvents
-        .map((event, index) => normalizeSwarmCodexDecisionEvent(event, index))
-        .sort((left, right) => left.generatedAt.localeCompare(right.generatedAt) || left.id.localeCompare(right.id));
-    const records = normalizeSwarmCodexDecisionRecords(nodes);
-    const snapshots = [
-        normalizeSwarmCodexDecisionSnapshot(input, nodes, edges, events, records)
-    ];
-    return {
-        kind: 'loom.decision-graph',
-        version: 1,
-        generatedAt: timestampToIso(input.generatedAt),
-        nodes,
-        edges,
-        events,
-        snapshots,
-        indexes: createDecisionGraphIndexes(nodes, edges),
-        records,
-        metadata: toJsonRecord({
-            sourceKind: input.kind,
-            sourceId: input.id,
-            runDir: input.runDir,
-            outDir: input.outDir,
-            summary: input.summary
-        })
-    };
-}
-function normalizeSwarmCodexDecisionNode(node) {
-    const kind = normalizeSwarmCodexDecisionNodeKind(node.kind);
-    const timestamp = typeof node.generatedAt === 'number' ? timestampToIso(node.generatedAt) : undefined;
-    const data = toJsonRecord(node.data);
-    const refs = stringRecord(node.refs);
-    return {
-        id: node.id,
-        kind,
-        ...(kind !== node.kind ? { sourceKind: node.kind } : {}),
-        ...(node.label ? { label: node.label } : {}),
-        ...(node.taskId ? { taskId: node.taskId } : {}),
-        ...(node.jobId ? { jobId: node.jobId } : {}),
-        ...(node.lane ? { lane: node.lane } : {}),
-        ...(node.model ? { model: node.model } : {}),
-        ...(node.computeId ? { computeId: node.computeId } : {}),
-        ...(node.modelTier ? { modelTier: node.modelTier } : {}),
-        ...(node.bucket ? { bucket: node.bucket } : {}),
-        ...(node.status ? { status: node.status } : {}),
-        ...(node.outcome ? { outcome: node.outcome } : {}),
-        ...(node.path ? { path: node.path } : {}),
-        ...(kind === 'worker' ? { workerId: node.jobId ?? node.id } : {}),
-        ...(kind === 'candidate' ? { candidateId: node.jobId ?? node.id } : {}),
-        ...(timestamp ? { createdAt: timestamp, updatedAt: timestamp } : {}),
-        ...(refs ? { refs } : {}),
-        ...(data ? { data } : {})
-    };
-}
-function normalizeSwarmCodexDecisionNodeKind(kind) {
-    if (kind === 'run')
-        return 'intent';
-    if (kind === 'job')
-        return 'worker';
-    if (kind === 'panel-projection')
-        return 'panel';
-    if (kind === 'improvement-loop')
-        return 'rsi';
-    return kind;
-}
-function normalizeSwarmCodexDecisionEdge(edge) {
-    const kind = normalizeSwarmCodexEdgeKind(edge.kind);
-    const data = toJsonRecord(edge.data);
-    return {
-        id: edge.id || `${kind}:${edge.from}->${edge.to}`,
-        kind,
-        from: edge.from,
-        to: edge.to,
-        ...(kind !== edge.kind ? { sourceKind: edge.kind } : {}),
-        ...(edge.label ? { label: edge.label } : {}),
-        ...(data ? { data } : {})
-    };
-}
-function normalizeSwarmCodexDecisionEvent(event, index) {
-    const nodes = (event.nodes ?? [])
-        .filter((node) => node && typeof node.id === 'string' && node.id)
-        .map((node) => normalizeSwarmCodexDecisionNode(node))
-        .sort((left, right) => left.id.localeCompare(right.id));
-    const edges = (event.edges ?? [])
-        .filter((edge) => edge && typeof edge.from === 'string' && typeof edge.to === 'string' && edge.from && edge.to)
-        .map((edge) => normalizeSwarmCodexDecisionEdge(edge))
-        .sort((left, right) => left.id.localeCompare(right.id));
-    const data = toJsonRecord(event.data);
-    return {
-        kind: 'loom.decision-graph.event',
-        version: 1,
-        id: decisionGraphEventId(event, index),
-        type: event.type,
-        generatedAt: timestampToIso(event.generatedAt),
-        ...(event.runId ? { runId: event.runId } : {}),
-        ...(event.taskId ? { taskId: event.taskId } : {}),
-        ...(event.jobId ? { jobId: event.jobId } : {}),
-        ...(event.lane ? { lane: event.lane } : {}),
-        ...(nodes.length ? { nodeIds: nodes.map((node) => node.id), nodes } : {}),
-        ...(edges.length ? { edgeIds: edges.map((edge) => edge.id), edges } : {}),
-        ...(data ? { data } : {})
-    };
-}
-function decisionGraphEventId(event, index) {
-    const scope = event.jobId ?? event.taskId ?? event.runId ?? 'event';
-    return `${scope}:${event.type}:${index}`;
-}
-function normalizeSwarmCodexDecisionSnapshot(input, nodes, edges, events, records) {
-    return {
-        kind: 'loom.decision-graph.snapshot',
-        version: 1,
-        id: `snapshot:${input.id}`,
-        generatedAt: timestampToIso(input.generatedAt),
-        label: 'current',
-        nodeIds: nodes.map((node) => node.id),
-        edgeIds: edges.map((edge) => edge.id),
-        eventIds: events.map((event) => event.id),
-        summary: {
-            nodes: nodes.length,
-            edges: edges.length,
-            events: events.length,
-            records: records.length
-        },
-        data: toJsonRecord({
-            sourceKind: input.kind,
-            sourceId: input.id,
-            runDir: input.runDir,
-            outDir: input.outDir
-        })
-    };
-}
-function normalizeSwarmCodexDecisionRecords(nodes) {
-    const records = [];
-    for (const node of nodes) {
-        if (node.kind === 'candidate') {
-            records.push({
-                kind: 'loom.decision-graph.merge-candidate',
-                id: `record:merge-candidate:${node.id}`,
-                nodeId: node.id,
-                taskId: node.taskId,
-                jobId: node.jobId,
-                lane: node.lane,
-                label: node.label,
-                status: node.status,
-                createdAt: node.createdAt,
-                updatedAt: node.updatedAt,
-                candidateId: node.candidateId ?? node.id,
-                sourceNodeId: node.id,
-                admissionStatus: admissionStatusFromNode(node),
-                admissionReasonCodes: admissionReasonsFromNode(node),
-                disposition: node.outcome,
-                data: node.data
-            });
-        }
-        else if (node.kind === 'evidence') {
-            records.push({
-                kind: 'loom.decision-graph.evidence',
-                id: `record:evidence:${node.id}`,
-                nodeId: node.id,
-                taskId: node.taskId,
-                jobId: node.jobId,
-                lane: node.lane,
-                label: node.label,
-                status: node.status,
-                createdAt: node.createdAt,
-                updatedAt: node.updatedAt,
-                evidenceKind: evidenceKindFromNode(node),
-                path: node.path,
-                producerNodeId: node.id,
-                data: node.data
-            });
-        }
-        else if (node.kind === 'gate') {
-            records.push({
-                kind: 'loom.decision-graph.gate',
-                id: `record:gate:${node.id}`,
-                nodeId: node.id,
-                taskId: node.taskId,
-                jobId: node.jobId,
-                lane: node.lane,
-                label: node.label,
-                status: node.status,
-                createdAt: node.createdAt,
-                updatedAt: node.updatedAt,
-                gateId: node.id,
-                data: node.data
-            });
-        }
-        else if (node.kind === 'replay') {
-            records.push({
-                kind: 'loom.decision-graph.replay',
-                id: `record:replay:${node.id}`,
-                nodeId: node.id,
-                taskId: node.taskId,
-                jobId: node.jobId,
-                lane: node.lane,
-                label: node.label,
-                status: node.status,
-                createdAt: node.createdAt,
-                updatedAt: node.updatedAt,
-                result: node.outcome,
-                data: node.data
-            });
-        }
-        else if (node.kind === 'rsi') {
-            records.push({
-                kind: 'loom.decision-graph.improvement-loop',
-                id: `record:improvement-loop:${node.id}`,
-                nodeId: node.id,
-                taskId: node.taskId,
-                jobId: node.jobId,
-                lane: node.lane,
-                label: node.label,
-                status: node.status,
-                createdAt: node.createdAt,
-                updatedAt: node.updatedAt,
-                loopId: node.id,
-                data: node.data
-            });
-        }
-        else if (node.kind === 'semantic-change') {
-            records.push({
-                kind: 'loom.decision-graph.semantic-change',
-                id: `record:semantic-change:${node.id}`,
-                nodeId: node.id,
-                taskId: node.taskId,
-                jobId: node.jobId,
-                lane: node.lane,
-                label: node.label,
-                status: node.status,
-                createdAt: node.createdAt,
-                updatedAt: node.updatedAt,
-                changeId: node.id,
-                conflictReason: stringFromData(node.data, 'conflictReason'),
-                data: node.data
-            });
-        }
-        else if (node.kind === 'tournament') {
-            records.push({
-                kind: 'loom.decision-graph.tournament',
-                id: `record:tournament:${node.id}`,
-                nodeId: node.id,
-                taskId: node.taskId,
-                jobId: node.jobId,
-                lane: node.lane,
-                label: node.label,
-                status: node.status,
-                createdAt: node.createdAt,
-                updatedAt: node.updatedAt,
-                candidateIds: stringArrayFromData(node.data, 'candidateIds'),
-                winnerCandidateId: stringFromData(node.data, 'winnerCandidateId'),
-                data: node.data
-            });
-        }
-    }
-    return records;
-}
 export function createLoomRunGraphPanelRecords(graph) {
     const kinds = ['intent', 'decomposition', 'tournament', 'performance', 'evidence', 'merge', 'rsi'];
     return kinds.map((panelKind) => ({
@@ -594,75 +166,6 @@ function panelSourceEdgeIds(graph, panelKind) {
     const nodes = new Set(panelSourceNodeIds(graph, panelKind));
     return graph.edges.filter((edge) => nodes.has(edge.from) || nodes.has(edge.to)).map((edge) => edge.id);
 }
-function summarizeTypedCounts(graph) {
-    const out = {};
-    for (const node of graph.nodes) {
-        if (node.kind === 'intent')
-            out.intents = (out.intents ?? 0) + 1;
-        else if (node.kind === 'task')
-            out.tasks = (out.tasks ?? 0) + 1;
-        else if (node.kind === 'worker')
-            out.workers = (out.workers ?? 0) + 1;
-        else if (node.kind === 'candidate')
-            out.candidates = (out.candidates ?? 0) + 1;
-        else if (node.kind === 'evidence')
-            out.evidence = (out.evidence ?? 0) + 1;
-        else if (node.kind === 'gate')
-            out.gates = (out.gates ?? 0) + 1;
-        else if (node.kind === 'decision')
-            out.decisions = (out.decisions ?? 0) + 1;
-        else if (node.kind === 'merge')
-            out.merges = (out.merges ?? 0) + 1;
-        else if (node.kind === 'replay')
-            out.replay = (out.replay ?? 0) + 1;
-        else if (node.kind === 'panel')
-            out.panels = (out.panels ?? 0) + 1;
-        else if (node.kind === 'tournament')
-            out.tournaments = (out.tournaments ?? 0) + 1;
-        else if (node.kind === 'rsi')
-            out.rsiLoops = (out.rsiLoops ?? 0) + 1;
-        else if (node.kind === 'semantic-change')
-            out.semanticChanges = (out.semanticChanges ?? 0) + 1;
-    }
-    for (const record of graph.records ?? []) {
-        if (record.kind === 'loom.decision-graph.panel-projection')
-            out.panels = Math.max(out.panels ?? 0, 1);
-    }
-    return out;
-}
-function createDecisionGraphIndexes(nodes, edges) {
-    const indexes = {
-        byNodeKind: {},
-        byEdgeKind: {},
-        byTaskId: {},
-        byJobId: {},
-        byLane: {}
-    };
-    for (const node of nodes) {
-        addIndexValue(indexes.byNodeKind, node.kind, node.id);
-        if (node.taskId)
-            addIndexValue(indexes.byTaskId, node.taskId, node.id);
-        if (node.jobId)
-            addIndexValue(indexes.byJobId, node.jobId, node.id);
-        if (node.lane)
-            addIndexValue(indexes.byLane, node.lane, node.id);
-    }
-    for (const edge of edges) {
-        addIndexValue(indexes.byEdgeKind, edge.kind, edge.id);
-    }
-    sortGraphIndex(indexes.byNodeKind);
-    sortGraphIndex(indexes.byEdgeKind);
-    sortGraphIndex(indexes.byTaskId);
-    sortGraphIndex(indexes.byJobId);
-    sortGraphIndex(indexes.byLane);
-    return indexes;
-}
-function addIndexValue(index, key, value) {
-    const values = index[key] ?? [];
-    if (!values.includes(value))
-        values.push(value);
-    index[key] = values;
-}
 function assertLoomDecisionGraph(value, file) {
     if (!value || typeof value !== 'object')
         throw new Error(`invalid ${file}: expected decisionGraph object`);
@@ -680,77 +183,6 @@ function assertLoomDecisionGraph(value, file) {
     if (!Array.isArray(value.snapshots))
         throw new Error(`invalid ${file}: expected decisionGraph snapshots array`);
 }
-function emptyGraphIndex(nodes) {
-    const out = {};
-    for (const node of nodes)
-        out[node] = [];
-    return out;
-}
-function sortGraphIndex(index) {
-    for (const values of Object.values(index)) {
-        values.sort();
-    }
-}
-function swarmRunGraphRunId(input) {
-    const basename = path.basename(input.runDir || '');
-    if (basename && basename !== path.sep)
-        return basename;
-    const idPart = input.id.split(':').filter(Boolean).at(-1);
-    return idPart || 'current';
-}
-function timestampToIso(value) {
-    const date = new Date(value);
-    return Number.isFinite(date.getTime()) ? date.toISOString() : nowIso();
-}
-function assertSwarmCodexRunGraph(value) {
-    if (!value || typeof value !== 'object')
-        throw new Error('invalid swarm run graph: expected object');
-    if (value.kind !== 'frontier.swarm-codex.run-graph') {
-        throw new Error('invalid swarm run graph: expected kind "frontier.swarm-codex.run-graph"');
-    }
-    if (value.version !== 1)
-        throw new Error('invalid swarm run graph: expected version 1');
-    if (!Array.isArray(value.nodes))
-        throw new Error('invalid swarm run graph: expected nodes array');
-    if (!Array.isArray(value.edges))
-        throw new Error('invalid swarm run graph: expected edges array');
-}
-function toJsonValue(value) {
-    if (value === null)
-        return null;
-    if (typeof value === 'boolean' || typeof value === 'string')
-        return value;
-    if (typeof value === 'number')
-        return Number.isFinite(value) ? value : null;
-    if (Array.isArray(value))
-        return value.map((item) => toJsonValue(item));
-    if (typeof value === 'object') {
-        const out = {};
-        for (const [key, item] of Object.entries(value)) {
-            if (item === undefined || typeof item === 'function' || typeof item === 'symbol')
-                continue;
-            out[key] = toJsonValue(item);
-        }
-        return out;
-    }
-    return String(value);
-}
-function toJsonRecord(value) {
-    const json = toJsonValue(value);
-    if (!json || typeof json !== 'object' || Array.isArray(json))
-        return undefined;
-    return Object.keys(json).length > 0 ? json : undefined;
-}
-function stringRecord(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        return undefined;
-    const out = {};
-    for (const [key, item] of Object.entries(value)) {
-        if (typeof item === 'string')
-            out[key] = item;
-    }
-    return Object.keys(out).length > 0 ? out : undefined;
-}
 function uniqueStrings(values) {
     return Array.from(new Set(values.filter((value) => typeof value === 'string' && value.length > 0))).sort();
 }
@@ -796,39 +228,4 @@ function stableChunkId(kind, nodes, edges) {
     const edgePart = edges.map((edge) => `${edge.type}:${edge.from}->${edge.to}`).join('|');
     return `chunk:${kind}:${[...nodes].join(',')}:${edgePart}`;
 }
-function admissionStatusFromNode(node) {
-    const value = stringFromData(node.data, 'admissionStatus') ?? stringFromData(node.data, 'mergeReadiness');
-    if (value === 'safe' || value === 'safe-with-losses' || value === 'review-required' || value === 'blocked') {
-        return value;
-    }
-    return undefined;
-}
-function admissionReasonsFromNode(node) {
-    const values = stringArrayFromData(node.data, 'admissionReasonCodes') ?? stringArrayFromData(node.data, 'reasonCodes');
-    const allowed = new Set([
-        'missing-sidecar',
-        'empty-sidecar',
-        'stale-source-hash',
-        'symbol-conflict',
-        'effect-conflict',
-        'lossy-import',
-        'tests-missing'
-    ]);
-    const out = (values ?? []).filter((value) => allowed.has(value));
-    return out.length ? out : undefined;
-}
-function evidenceKindFromNode(node) {
-    return stringFromData(node.data, 'evidenceKind');
-}
-function stringFromData(data, key) {
-    const value = data?.[key];
-    return typeof value === 'string' && value ? value : undefined;
-}
-function stringArrayFromData(data, key) {
-    const value = data?.[key];
-    if (!Array.isArray(value))
-        return undefined;
-    const out = value.filter((item) => typeof item === 'string' && item.length > 0);
-    return out.length ? out : undefined;
-}
 //# sourceMappingURL=graph.js.map