@shapeshift-labs/frontier-swarm 0.5.8 → 0.5.10

package/dist/index.js

@@ -52,6 +52,10 @@ export const FRONTIER_SWARM_PARITY_ORACLE_KIND = 'frontier.swarm.parity-oracle';
 export const FRONTIER_SWARM_PARITY_ORACLE_VERSION = 1;
 export const FRONTIER_SWARM_DIVERGENCE_REPORT_KIND = 'frontier.swarm.divergence-report';
 export const FRONTIER_SWARM_DIVERGENCE_REPORT_VERSION = 1;
+export const FRONTIER_SWARM_TRACE_SHARD_KIND = 'frontier.swarm.trace-shard';
+export const FRONTIER_SWARM_TRACE_SHARD_VERSION = 1;
+export const FRONTIER_SWARM_TRACE_INDEX_KIND = 'frontier.swarm.trace-index';
+export const FRONTIER_SWARM_TRACE_INDEX_VERSION = 1;
 export const FRONTIER_SWARM_OBSERVABILITY_POINT_KIND = 'frontier.swarm.observability-point';
 export const FRONTIER_SWARM_OBSERVABILITY_POINT_VERSION = 1;
 export const FRONTIER_SWARM_WATCHPOINT_PLAN_KIND = 'frontier.swarm.watchpoint-plan';
@@ -457,6 +461,11 @@ export function createSwarmMergeBundle(input) {
     const commandsPassed = result.verification.filter((entry) => entry.status === 0 || entry.required === false && entry.status === undefined);
     const commandsFailed = result.verification.filter((entry) => entry.status !== undefined && entry.status !== 0 && entry.required !== false);
     const ownedFilesTouched = job ? changedPaths.filter((file) => job.allowedWrites.some((glob) => matchesGlob(file, glob))) : changedPaths;
+    const traceShards = [
+        ...(input.traceShards ?? []),
+        ...traceShardInputsFromUnknown(result.metadata?.traceShards),
+        ...traceShardInputsFromUnknown(inputMetadata?.traceShards)
+    ].map((shard) => normalizeTraceShardForBundle(shard, result, job, generatedAt));
     const reasons = mergeBundleReasons(result, disposition, input.staleAgainstHead ?? false);
     return {
         kind: FRONTIER_SWARM_MERGE_BUNDLE_KIND,
@@ -488,6 +497,7 @@ export function createSwarmMergeBundle(input) {
         staleAgainstHead: input.staleAgainstHead ?? false,
         reasons,
         ...(semanticImport ? { semanticImport } : {}),
+        traceShards,
         ...(inputMetadata ? { metadata: inputMetadata } : {})
     };
 }
@@ -1106,6 +1116,97 @@ export function createSwarmDivergenceReport(input = {}) {
         ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
     };
 }
+export function createSwarmTraceShard(input = {}) {
+    const generatedAt = input.generatedAt ?? Date.now();
+    const divergence = input.divergence
+        ? isSwarmDivergenceReport(input.divergence)
+            ? cloneJsonValue(input.divergence)
+            : createSwarmDivergenceReport(input.divergence)
+        : undefined;
+    const rowWindows = (input.rowWindows ?? []).map((window) => normalizeTraceRowWindow(window, generatedAt));
+    const hypotheses = (input.hypotheses ?? []).map((hypothesis) => normalizeTraceHypothesis(hypothesis, generatedAt));
+    const executableOwnershipRegions = (input.executableOwnershipRegions ?? []).map(normalizeExecutableOwnershipRegion);
+    const focusedTests = normalizeCommands(input.focusedTests ?? []);
+    const referenceEvidence = normalizeNamedRefs(input.referenceEvidence ?? [], 'reference-evidence');
+    const traceRefs = normalizeNamedRefs(input.traceRefs ?? [], 'trace');
+    const status = input.status ?? (divergence && divergence.status === 'failed' ? 'failed' : focusedTests.length || rowWindows.length || hypotheses.length ? 'passed' : 'unknown');
+    const id = input.id ?? 'swarm-trace-shard:' + stableHash([
+        input.jobId,
+        input.lane,
+        input.subject ?? divergence?.subject,
+        status,
+        divergence?.id,
+        rowWindows,
+        hypotheses,
+        executableOwnershipRegions,
+        generatedAt
+    ]);
+    return {
+        kind: FRONTIER_SWARM_TRACE_SHARD_KIND,
+        version: FRONTIER_SWARM_TRACE_SHARD_VERSION,
+        id,
+        ...(input.jobId ? { jobId: input.jobId } : {}),
+        ...(input.lane ? { lane: input.lane } : {}),
+        ...(input.subject ?? divergence?.subject ? { subject: input.subject ?? divergence?.subject } : {}),
+        status,
+        traceRefs,
+        ...(divergence ? { divergence } : {}),
+        rowWindows,
+        hypotheses,
+        executableOwnershipRegions,
+        focusedTests,
+        referenceEvidence,
+        generatedAt,
+        summary: summarizeTraceShards([{ rowWindows, hypotheses, executableOwnershipRegions, focusedTests, referenceEvidence, divergence }]),
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+export function createSwarmTraceIndex(input = {}) {
+    const generatedAt = input.generatedAt ?? Date.now();
+    const shards = [
+        ...(input.shards ?? []).map((shard) => isSwarmTraceShard(shard) ? cloneJsonValue(shard) : createSwarmTraceShard({ ...shard, generatedAt: shard.generatedAt ?? generatedAt })),
+        ...(input.bundles ?? []).flatMap((bundle) => bundle.traceShards)
+    ];
+    const uniqueById = new Map();
+    for (const shard of shards)
+        uniqueById.set(shard.id, shard);
+    const indexed = Array.from(uniqueById.values()).sort((left, right) => left.id.localeCompare(right.id));
+    return {
+        kind: FRONTIER_SWARM_TRACE_INDEX_KIND,
+        version: FRONTIER_SWARM_TRACE_INDEX_VERSION,
+        id: input.id ?? 'swarm-trace-index:' + stableHash([indexed.map((shard) => shard.id), generatedAt]),
+        generatedAt,
+        shards: indexed,
+        byJobId: groupObjects(indexed.filter((shard) => shard.jobId), (shard) => shard.jobId),
+        bySubject: groupObjects(indexed.filter((shard) => shard.subject), (shard) => shard.subject),
+        byRegion: groupTraceShardsByMany(indexed, traceShardRegions),
+        bySourcePath: groupTraceShardsByMany(indexed, traceShardSourcePaths),
+        summary: summarizeTraceShards(indexed),
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+export function querySwarmTraceIndex(index, query = {}) {
+    const needles = query.textIncludes ? [query.textIncludes.toLowerCase()] : [];
+    const minConfidence = query.minConfidence ?? 0;
+    const shards = index.shards.filter((shard) => ((query.jobId === undefined || shard.jobId === query.jobId)
+        && (query.lane === undefined || shard.lane === query.lane)
+        && (query.subject === undefined || shard.subject === query.subject)
+        && (query.status === undefined || shard.status === query.status)
+        && (query.region === undefined || traceShardRegions(shard).includes(query.region))
+        && (query.sourcePath === undefined || traceShardSourcePaths(shard).some((path) => path.includes(query.sourcePath)))
+        && (query.hasDivergence === undefined || Boolean(shard.divergence) === query.hasDivergence)
+        && (query.minConfidence === undefined || traceShardMaxConfidence(shard) >= minConfidence)
+        && (needles.length === 0 || needles.some((needle) => traceShardSearchText(shard).includes(needle)))));
+    return {
+        shards,
+        summary: {
+            shardCount: shards.length,
+            rowWindowCount: shards.reduce((total, shard) => total + shard.rowWindows.length, 0),
+            hypothesisCount: shards.reduce((total, shard) => total + shard.hypotheses.length, 0),
+            executableOwnershipRegionCount: shards.reduce((total, shard) => total + shard.executableOwnershipRegions.length, 0)
+        }
+    };
+}
 export function createSwarmWatchpointPlan(input = {}) {
     const generatedAt = input.generatedAt ?? Date.now();
     const watchpoints = (input.watchpoints ?? []).map(normalizeWatchpoint);
@@ -1624,6 +1725,7 @@ export function createSwarmCoordinatorDashboard(input = {}) {
     const mergeIndex = input.mergeIndex ?? (bundles.length ? createSwarmMergeIndex({ runId, planId, bundles, generatedAt }) : undefined);
     const queueOverlay = input.queueOverlay ?? (bundles.length ? createSwarmQueueOverlay({ runId, bundles, generatedAt }) : undefined);
     const evidenceIndex = input.evidenceIndex ?? (input.run ? createSwarmEvidenceIndex({ run: input.run, generatedAt }) : undefined);
+    const traceIndex = input.traceIndex ?? (bundles.some((bundle) => bundle.traceShards.length > 0) ? createSwarmTraceIndex({ bundles, generatedAt }) : undefined);
     const admission = input.admission;
     const jobsById = new Map((input.plan?.jobs ?? []).map((job) => [job.id, job]));
     const resultsById = new Map((input.run?.results ?? []).map((result) => [result.jobId, result]));
@@ -1650,6 +1752,7 @@ export function createSwarmCoordinatorDashboard(input = {}) {
         const result = resultsById.get(jobId);
         const entry = entriesById.get(jobId);
         const bundle = bundlesById.get(jobId);
+        const traceShards = traceIndex?.byJobId[jobId] ?? bundle?.traceShards ?? [];
         const processList = processesByJob[jobId] ?? [];
         const duplicateGroup = duplicateByJob.get(jobId);
         const admissionReasons = admissionDeferred.get(jobId) ?? [];
@@ -1660,7 +1763,7 @@ export function createSwarmCoordinatorDashboard(input = {}) {
                 : entry?.autoMergeable
                     ? 'not-admissible'
                     : 'unknown';
-        const score = scoreCoordinatorMergeJob(entry, bundle, evidenceIndex?.byJobId[jobId]?.length ?? 0, duplicateGroup, admissionStatus, admissionReasons);
+        const score = scoreCoordinatorMergeJob(entry, bundle, evidenceIndex?.byJobId[jobId]?.length ?? 0, duplicateGroup, admissionStatus, admissionReasons, traceShards);
         const evidencePaths = uniqueStrings([
             ...(entry?.evidencePaths ?? []),
             ...(result?.evidencePaths ?? []),
@@ -1699,6 +1802,7 @@ export function createSwarmCoordinatorDashboard(input = {}) {
             ...(entry?.semanticImport ?? result?.semanticImport ?? bundle?.semanticImport ? {
                 semanticImport: cloneJsonValue(entry?.semanticImport ?? result?.semanticImport ?? bundle?.semanticImport)
             } : {}),
+            ...(traceShards.length ? { traceSummary: createCoordinatorTraceSummary(traceShards) } : {}),
             generatedAt
         };
     }).sort((left, right) => right.mergeScore - left.mergeScore || left.jobId.localeCompare(right.jobId));
@@ -1721,6 +1825,7 @@ export function createSwarmCoordinatorDashboard(input = {}) {
         ...(mergeIndex ? { mergeIndex } : {}),
         ...(queueOverlay ? { queueOverlay } : {}),
         ...(evidenceIndex ? { evidenceIndex } : {}),
+        ...(traceIndex ? { traceIndex } : {}),
         ...(admission ? { admission } : {}),
         summary: {
             jobCount: jobs.length,
@@ -1731,6 +1836,9 @@ export function createSwarmCoordinatorDashboard(input = {}) {
             duplicateGroupCount: duplicateGroups.length,
             semanticSidecarCount: jobs.filter((job) => job.semanticImport && job.semanticImport.total > 0).length,
             semanticRegionCount: jobs.reduce((total, job) => total + job.semanticRegions.length, 0),
+            traceShardCount: traceIndex?.summary.shardCount ?? 0,
+            traceDivergenceCount: traceIndex?.summary.divergenceCount ?? 0,
+            executableOwnershipRegionCount: traceIndex?.summary.executableOwnershipRegionCount ?? 0,
             averageMergeScore: averageScore(jobs.map((job) => job.mergeScore))
         },
         ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
@@ -1746,6 +1854,9 @@ export function querySwarmCoordinatorDashboard(dashboard, query = {}) {
         && (query.region === undefined || job.changedRegions.includes(query.region) || job.semanticRegions.includes(query.region))
         && (query.hasSemanticImport === undefined || Boolean(job.semanticImport && job.semanticImport.total > 0) === query.hasSemanticImport)
         && (query.hasSemanticRegions === undefined || (job.semanticRegions.length > 0) === query.hasSemanticRegions)
+        && (query.hasTraceShards === undefined || Boolean(job.traceSummary && job.traceSummary.shardCount > 0) === query.hasTraceShards)
+        && (query.traceSubject === undefined || (dashboard.traceIndex?.bySubject[query.traceSubject] ?? []).some((shard) => shard.jobId === job.jobId))
+        && (query.traceRegion === undefined || (dashboard.traceIndex?.byRegion[query.traceRegion] ?? []).some((shard) => shard.jobId === job.jobId))
         && (query.staleAgainstHead === undefined || job.staleAgainstHead === query.staleAgainstHead)
         && (query.duplicateOnly !== true || Boolean(job.duplicateGroupId))
         && (query.minMergeScore === undefined || job.mergeScore >= query.minMergeScore)
@@ -3424,6 +3535,12 @@ function normalizeAutoReviewFinding(input, generatedAt) {
 function isSwarmObservabilityPoint(value) {
     return !!value && typeof value === 'object' && value.kind === FRONTIER_SWARM_OBSERVABILITY_POINT_KIND;
 }
+function isSwarmDivergenceReport(value) {
+    return !!value && typeof value === 'object' && value.kind === FRONTIER_SWARM_DIVERGENCE_REPORT_KIND;
+}
+function isSwarmTraceShard(value) {
+    return !!value && typeof value === 'object' && value.kind === FRONTIER_SWARM_TRACE_SHARD_KIND;
+}
 function isSwarmInstrumentationBudget(value) {
     return !!value && typeof value === 'object' && value.kind === FRONTIER_SWARM_INSTRUMENTATION_BUDGET_KIND;
 }
@@ -3441,6 +3558,158 @@ function groupObjects(items, key) {
     }
     return out;
 }
+function normalizeTraceRowWindow(input, generatedAt) {
+    const start = Number.isFinite(input.start) ? Math.floor(input.start) : undefined;
+    const end = Number.isFinite(input.end) ? Math.floor(input.end) : undefined;
+    const rowCount = Number.isFinite(input.rowCount) ? Math.max(0, Math.floor(input.rowCount)) : undefined;
+    const firstDivergenceAt = Number.isFinite(input.firstDivergenceAt) ? Math.floor(input.firstDivergenceAt) : undefined;
+    const deltaFields = uniqueStrings(input.deltaFields ?? []);
+    const id = input.id ?? 'swarm-trace-window:' + stableHash([start, end, rowCount, firstDivergenceAt, deltaFields, generatedAt]);
+    return {
+        id,
+        title: input.title ?? titleFromId(id),
+        ...(start !== undefined ? { start } : {}),
+        ...(end !== undefined ? { end } : {}),
+        ...(rowCount !== undefined ? { rowCount } : {}),
+        ...(firstDivergenceAt !== undefined ? { firstDivergenceAt } : {}),
+        deltaFields,
+        evidenceRefs: normalizeNamedRefs(input.evidenceRefs ?? [], 'trace-window-evidence'),
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+function normalizeTraceHypothesis(input, generatedAt) {
+    const line = Number.isFinite(input.line) ? Math.max(1, Math.floor(input.line)) : undefined;
+    const id = input.id ?? 'swarm-trace-hypothesis:' + stableHash([
+        input.sourcePath,
+        line,
+        input.symbol,
+        input.region,
+        input.reason,
+        generatedAt
+    ]);
+    return {
+        id,
+        title: input.title ?? titleFromId(input.symbol ?? input.region ?? id),
+        ...(input.sourcePath ? { sourcePath: input.sourcePath } : {}),
+        ...(line !== undefined ? { line } : {}),
+        ...(input.symbol ? { symbol: input.symbol } : {}),
+        ...(input.region ? { region: input.region } : {}),
+        confidence: input.confidence ?? 'medium',
+        ...(input.reason ? { reason: input.reason } : {}),
+        evidenceRefs: normalizeNamedRefs(input.evidenceRefs ?? [], 'trace-hypothesis-evidence'),
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+function normalizeExecutableOwnershipRegion(input) {
+    return {
+        id: normalizeId(input.id, 'executable ownership region id'),
+        kind: input.kind ?? 'semantic-region',
+        ...(input.sourcePath ? { sourcePath: input.sourcePath } : {}),
+        ...(input.symbol ? { symbol: input.symbol } : {}),
+        selectors: uniqueStrings(input.selectors ?? []),
+        affectedTests: normalizeCommands(input.affectedTests ?? []),
+        conflictingAssumptions: uniqueStrings(input.conflictingAssumptions ?? []),
+        traceRefs: normalizeNamedRefs(input.traceRefs ?? [], 'trace'),
+        riskLevel: input.riskLevel ?? 'unknown',
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+function traceShardInputsFromUnknown(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((entry) => !!entry && typeof entry === 'object');
+}
+function normalizeTraceShardForBundle(shard, result, job, generatedAt) {
+    return createSwarmTraceShard({
+        ...cloneJsonValue(shard),
+        jobId: shard.jobId ?? result.jobId,
+        lane: shard.lane ?? job?.lane,
+        generatedAt: shard.generatedAt ?? generatedAt
+    });
+}
+function summarizeTraceShards(shards) {
+    const rowWindowCount = shards.reduce((total, shard) => total + shard.rowWindows.length, 0);
+    const hypothesisCount = shards.reduce((total, shard) => total + shard.hypotheses.length, 0);
+    const executableOwnershipRegionCount = shards.reduce((total, shard) => total + shard.executableOwnershipRegions.length, 0);
+    const focusedTestCount = shards.reduce((total, shard) => total + shard.focusedTests.length, 0);
+    const referenceEvidenceCount = shards.reduce((total, shard) => total + shard.referenceEvidence.length, 0);
+    const divergenceCount = shards.filter((shard) => Boolean(shard.divergence)).length;
+    return {
+        shardCount: shards.length,
+        rowWindowCount,
+        hypothesisCount,
+        executableOwnershipRegionCount,
+        focusedTestCount,
+        referenceEvidenceCount,
+        divergenceCount,
+        hasDivergence: divergenceCount > 0
+    };
+}
+function groupTraceShardsByMany(shards, key) {
+    const out = {};
+    for (const shard of shards) {
+        for (const value of key(shard))
+            out[value] = [...(out[value] ?? []), shard];
+    }
+    return out;
+}
+function traceShardRegions(shard) {
+    return uniqueStrings([
+        ...shard.hypotheses.map((hypothesis) => hypothesis.region),
+        ...shard.executableOwnershipRegions.flatMap((region) => [region.id, ...region.selectors])
+    ]);
+}
+function traceShardSourcePaths(shard) {
+    return uniqueStrings([
+        ...shard.hypotheses.map((hypothesis) => hypothesis.sourcePath),
+        ...shard.executableOwnershipRegions.map((region) => region.sourcePath)
+    ]);
+}
+function traceShardMaxConfidence(shard) {
+    return Math.max(...[
+        shard.divergence ? confidenceWeight(shard.divergence.confidence) : 0,
+        ...shard.hypotheses.map((hypothesis) => confidenceWeight(hypothesis.confidence))
+    ]);
+}
+function traceShardSearchText(shard) {
+    return stableStringify({
+        id: shard.id,
+        jobId: shard.jobId,
+        lane: shard.lane,
+        subject: shard.subject,
+        status: shard.status,
+        divergence: shard.divergence,
+        rowWindows: shard.rowWindows,
+        hypotheses: shard.hypotheses,
+        executableOwnershipRegions: shard.executableOwnershipRegions
+    }).toLowerCase();
+}
+function confidenceWeight(confidence) {
+    if (confidence === 'high')
+        return 1;
+    if (confidence === 'medium')
+        return 0.65;
+    if (confidence === 'low')
+        return 0.35;
+    return 0.5;
+}
+function createCoordinatorTraceSummary(shards) {
+    const summary = summarizeTraceShards(shards);
+    const openDivergenceCount = shards.filter((shard) => (shard.status === 'failed'
+        || shard.divergence?.status === 'failed'
+        || shard.divergence?.severity === 'error'
+        || shard.divergence?.severity === 'critical')).length;
+    return {
+        shardCount: summary.shardCount,
+        rowWindowCount: summary.rowWindowCount,
+        hypothesisCount: summary.hypothesisCount,
+        executableOwnershipRegionCount: summary.executableOwnershipRegionCount,
+        focusedTestCount: summary.focusedTestCount,
+        referenceEvidenceCount: summary.referenceEvidenceCount,
+        divergenceCount: summary.divergenceCount,
+        openDivergenceCount
+    };
+}
 function clamp01(value) {
     if (!Number.isFinite(value))
         return 0;
@@ -3503,7 +3772,7 @@ function coordinatorDuplicateKeys(entry) {
         keys.push(`path:${entry.changedPaths.slice().sort().join('|')}`);
     return keys;
 }
-function scoreCoordinatorMergeJob(entry, bundle, evidenceEntryCount, duplicateGroup, admissionStatus, admissionReasons) {
+function scoreCoordinatorMergeJob(entry, bundle, evidenceEntryCount, duplicateGroup, admissionStatus, admissionReasons, traceShards = []) {
     if (!entry)
         return { score: 10, reasons: ['no-merge-index-entry'] };
     let score = entry.disposition === 'auto-mergeable' && entry.autoMergeable ? 85 : entry.disposition === 'needs-port' ? 60 : entry.disposition === 'discovery-only' ? 35 : 15;
@@ -3572,6 +3841,32 @@ function scoreCoordinatorMergeJob(entry, bundle, evidenceEntryCount, duplicateGr
         score -= 5;
         reasons.push('missing-semantic-sidecar');
     }
+    const traceSummary = createCoordinatorTraceSummary(traceShards);
+    if (traceSummary.shardCount > 0) {
+        score += Math.min(6, traceSummary.shardCount * 2);
+        reasons.push('trace-shard-evidence');
+    }
+    if (traceSummary.referenceEvidenceCount > 0) {
+        score += Math.min(6, traceSummary.referenceEvidenceCount * 2);
+        reasons.push('reference-evidence-attached');
+    }
+    if (traceSummary.focusedTestCount > 0) {
+        score += Math.min(6, traceSummary.focusedTestCount * 2);
+        reasons.push('focused-tests-attached');
+    }
+    if (traceSummary.executableOwnershipRegionCount > 0) {
+        score += Math.min(6, traceSummary.executableOwnershipRegionCount * 2);
+        reasons.push('executable-ownership-regions');
+    }
+    if (traceSummary.openDivergenceCount > 0) {
+        score -= Math.min(20, traceSummary.openDivergenceCount * 10);
+        reasons.push('trace-divergence-open');
+    }
+    const conflictingAssumptionCount = traceShards.reduce((total, shard) => total + shard.executableOwnershipRegions.reduce((inner, region) => inner + region.conflictingAssumptions.length, 0), 0);
+    if (conflictingAssumptionCount > 0) {
+        score -= Math.min(16, conflictingAssumptionCount * 4);
+        reasons.push('conflicting-trace-assumptions');
+    }
     if (bundle?.commandsPassed.length)
         score += Math.min(8, bundle.commandsPassed.length * 2);
     return { score: clampScore(score), reasons: uniqueStrings(reasons) };
@@ -4160,12 +4455,73 @@ function normalizeSemanticImportSummary(input) {
         semanticIndex: normalizeSemanticIndexSummary(object.semanticIndex),
         semanticSidecars: normalizeSemanticSidecarSummary(object.semanticSidecars),
         proofSpec: normalizeProofSpecSummary(object.proofSpec),
+        paradigmSemantics: normalizeParadigmSemanticsSummary(object.paradigmSemantics),
         sourceProjections: normalizeSourceProjectionSummary(object.sourceProjections),
         nativeCompiles: normalizeNativeCompileSummary(object.nativeCompiles),
         readiness: normalizeCounterRecord(object.readiness),
         ...(metadata ? { metadata } : {})
     };
 }
+const paradigmSemanticsSummaryGroups = [
+    'bindingScopes',
+    'bindings',
+    'patterns',
+    'typeConstraints',
+    'evaluationModels',
+    'memoryLocations',
+    'effectRegions',
+    'controlRegions',
+    'logicPrograms',
+    'actorSystems',
+    'stackEffects',
+    'arrayShapes',
+    'numericKernels',
+    'dataflowNetworks',
+    'clockModels',
+    'objectModels',
+    'macroExpansions',
+    'reflectionBoundaries',
+    'loweringRecords'
+];
+function normalizeParadigmSemanticsSummary(input) {
+    const object = toJsonObject(input);
+    const counts = Object.fromEntries(paradigmSemanticsSummaryGroups.map((group) => [
+        group,
+        nonNegativeCount(object?.[group])
+    ]));
+    const total = nonNegativeCount(object?.total) || Object.values(counts).reduce((sum, count) => sum + count, 0);
+    const byGroup = normalizeCounterRecord(object?.byGroup);
+    const byKind = normalizeCounterRecord(object?.byKind);
+    const hasRuntimeSemantics = object?.hasRuntimeSemantics === true
+        || counts.evaluationModels > 0
+        || counts.memoryLocations > 0
+        || counts.effectRegions > 0
+        || counts.controlRegions > 0
+        || counts.actorSystems > 0
+        || counts.clockModels > 0;
+    const hasLogicSemantics = object?.hasLogicSemantics === true || counts.logicPrograms > 0;
+    const hasStackSemantics = object?.hasStackSemantics === true || counts.stackEffects > 0;
+    const hasArraySemantics = object?.hasArraySemantics === true || counts.arrayShapes > 0 || counts.numericKernels > 0;
+    const hasMacroOrReflection = object?.hasMacroOrReflection === true || counts.macroExpansions > 0 || counts.reflectionBoundaries > 0;
+    const hasLowering = object?.hasLowering === true || counts.loweringRecords > 0;
+    return {
+        total,
+        ids: uniqueStrings(stringArray(object?.ids)),
+        groups: uniqueStrings(stringArray(object?.groups)),
+        kinds: uniqueStrings(stringArray(object?.kinds)),
+        evidence: nonNegativeCount(object?.evidence),
+        ...counts,
+        byGroup,
+        byKind,
+        hasRuntimeSemantics,
+        hasLogicSemantics,
+        hasStackSemantics,
+        hasArraySemantics,
+        hasMacroOrReflection,
+        hasLowering,
+        empty: object?.empty === true || total === 0
+    };
+}
 function normalizeProofSpecSummary(input) {
     const object = toJsonObject(input);
     const total = nonNegativeCount(object?.total);