sneakoscope 7.3.0 → 7.6.0

package/dist/core/triwiki/context-graph/compiler/index.js

@@ -0,0 +1,237 @@
+import path from 'node:path';
+import { CONTEXT_GRAPH_META_SCHEMA, CONTEXT_GRAPH_SCHEMA_REVISION } from '../contracts.js';
+import { buildContextGraphIndex, computeStronglyConnectedComponents, outgoingEdges } from '../graph-index.js';
+import { tryNormalizeGraphPath } from '../paths.js';
+import { runContextGraphLint } from '../lint/index.js';
+import { withContextGraphCompileLock } from '../store/compile-lock.js';
+import { appendContextGraphEvent } from '../store/event-log.js';
+import { readContextGraphMeta, readContextGraphSnapshot, readContextGraphSnapshotHash, writeContextGraphSnapshot } from '../store/snapshot-store.js';
+import { computeContextGraphCacheKey } from './cache-key.js';
+import { DEFAULT_CONTEXT_GRAPH_LIMITS, runContextGraphExtractors } from './extract.js';
+import { applyContextGraphFreshness } from './freshness.js';
+import { applyContextGraphCaps, carryForwardFromSnapshot, mergeContextGraphFragments } from './merge.js';
+import { buildContextGraphSnapshot, contextGraphCycleId } from './serialize.js';
+const MAX_META_SKIPPED = 200;
+function resolveLimits(partial) {
+    return { ...DEFAULT_CONTEXT_GRAPH_LIMITS, ...(partial ?? {}) };
+}
+function normalizeChangedPaths(root, changedPaths) {
+    if (changedPaths === null || changedPaths === undefined)
+        return null;
+    const out = new Set();
+    for (const candidate of changedPaths) {
+        const normalized = tryNormalizeGraphPath(root, candidate);
+        if (normalized)
+            out.add(normalized);
+    }
+    return [...out].sort();
+}
+function failure(reason, blockers, durationMs, extra = {}) {
+    return {
+        ok: false,
+        snapshot: null,
+        meta: null,
+        issues: [],
+        wrote: false,
+        snapshotHash: null,
+        previousSnapshotHash: null,
+        durationMs,
+        skipped: [],
+        blockers,
+        reason,
+        cacheKey: null,
+        cacheReusable: false,
+        incremental: false,
+        droppedEdges: [],
+        ...extra
+    };
+}
+function cyclesOf(snapshot) {
+    const index = buildContextGraphIndex(snapshot);
+    const components = computeStronglyConnectedComponents(snapshot.nodes.map((node) => node.id), (nodeId) => outgoingEdges(index, nodeId).map((edge) => ({ to: edge.to })));
+    return components.map((nodes) => ({ id: contextGraphCycleId(nodes), nodes }));
+}
+async function compileLocked(input, root, startedAt) {
+    const observedAt = input.observedAt ?? new Date().toISOString();
+    const limits = resolveLimits(input.limits);
+    const changedPaths = normalizeChangedPaths(root, input.changedPaths);
+    const cacheKey = await computeContextGraphCacheKey({
+        root,
+        extractors: input.extractors
+    });
+    await appendContextGraphEvent(root, {
+        type: 'compile.started',
+        at: observedAt,
+        cacheKey: cacheKey.key,
+        incremental: changedPaths !== null
+    });
+    const extraction = await runContextGraphExtractors({
+        root,
+        extractors: input.extractors,
+        changedPaths,
+        limits,
+        observedAt,
+        cacheKey: cacheKey.key,
+        useFragmentCache: (input.useFragmentCache ?? true) && cacheKey.reusable
+    });
+    if (extraction.blockers.length > 0) {
+        await appendContextGraphEvent(root, {
+            type: 'compile.blocked',
+            at: observedAt,
+            cacheKey: cacheKey.key,
+            reason: extraction.blockers[0] ?? 'extractor_failed'
+        });
+        return failure('extractor_failed', extraction.blockers, Date.now() - startedAt, {
+            cacheKey: cacheKey.key,
+            cacheReusable: cacheKey.reusable,
+            issues: extraction.issues
+        });
+    }
+    const carryForward = changedPaths === null ? null : await previousGeneration(root, cacheKey, changedPaths);
+    const merged = mergeContextGraphFragments({
+        fragments: extraction.fragments,
+        ...(carryForward === null ? {} : { carryForward })
+    });
+    const freshness = await applyContextGraphFreshness({
+        root,
+        nodes: merged.nodes,
+        edges: merged.edges
+    });
+    const capped = applyContextGraphCaps(freshness.nodes, merged.edges, limits);
+    const skipped = [...merged.skipped, ...capped.skipped];
+    const provisional = buildContextGraphSnapshot({
+        nodes: capped.nodes,
+        edges: capped.edges,
+        cycles: [],
+        extractors: merged.extractors
+    });
+    const snapshot = buildContextGraphSnapshot({
+        nodes: provisional.nodes,
+        edges: provisional.edges,
+        cycles: cyclesOf(provisional),
+        extractors: provisional.extractors
+    });
+    const inputHashes = { ...merged.inputHashes };
+    for (const [file, hash] of Object.entries(freshness.sourceHashes)) {
+        if (inputHashes[file] === undefined)
+            inputHashes[file] = hash;
+    }
+    const lint = runContextGraphLint({
+        root,
+        snapshot,
+        sourceHashes: freshness.sourceHashes,
+        skipped,
+        env: input.env ?? process.env
+    });
+    const issues = [...extraction.issues, ...merged.issues, ...lint.issues];
+    const errors = issues.filter((issue) => issue.severity === 'error');
+    if (errors.length > 0) {
+        await appendContextGraphEvent(root, {
+            type: 'compile.blocked',
+            at: observedAt,
+            cacheKey: cacheKey.key,
+            snapshotHash: snapshot.snapshotHash,
+            errorCount: errors.length,
+            warningCount: issues.length - errors.length,
+            reason: errors[0]?.code ?? 'lint_error'
+        });
+        return {
+            ok: false,
+            snapshot,
+            meta: null,
+            issues,
+            wrote: false,
+            snapshotHash: snapshot.snapshotHash,
+            previousSnapshotHash: null,
+            durationMs: Date.now() - startedAt,
+            skipped,
+            blockers: errors.map((issue) => `lint:${issue.code}`),
+            reason: 'lint_error',
+            cacheKey: cacheKey.key,
+            cacheReusable: cacheKey.reusable,
+            incremental: carryForward !== null,
+            droppedEdges: merged.dropped
+        };
+    }
+    const durationMs = Date.now() - startedAt;
+    const previousSnapshotHash = await readContextGraphSnapshotHash(root);
+    const meta = {
+        schema: CONTEXT_GRAPH_META_SCHEMA,
+        schemaRevision: CONTEXT_GRAPH_SCHEMA_REVISION,
+        snapshotHash: snapshot.snapshotHash,
+        previousSnapshotHash,
+        generatedAt: observedAt,
+        cacheKey: cacheKey.key,
+        cacheKeyParts: cacheKey.parts,
+        inputHashes,
+        nodeCount: snapshot.nodeCount,
+        edgeCount: snapshot.edgeCount,
+        lint: { ok: true, errors: 0, warnings: issues.length },
+        skipped: skipped.slice(0, MAX_META_SKIPPED),
+        durationMs
+    };
+    await writeContextGraphSnapshot({ root, snapshot, meta });
+    await appendContextGraphEvent(root, {
+        type: 'compile.committed',
+        at: observedAt,
+        cacheKey: cacheKey.key,
+        snapshotHash: snapshot.snapshotHash,
+        previousSnapshotHash,
+        nodeCount: snapshot.nodeCount,
+        edgeCount: snapshot.edgeCount,
+        errorCount: 0,
+        warningCount: issues.length,
+        durationMs,
+        incremental: carryForward !== null
+    });
+    return {
+        ok: true,
+        snapshot,
+        meta,
+        issues,
+        wrote: true,
+        snapshotHash: snapshot.snapshotHash,
+        previousSnapshotHash,
+        durationMs,
+        skipped,
+        blockers: [],
+        reason: null,
+        cacheKey: cacheKey.key,
+        cacheReusable: cacheKey.reusable,
+        incremental: carryForward !== null,
+        droppedEdges: merged.dropped
+    };
+}
+async function previousGeneration(root, cacheKey, changedPaths) {
+    if (!cacheKey.reusable)
+        return null;
+    const [snapshotLoad, metaLoad] = await Promise.all([
+        readContextGraphSnapshot(root),
+        readContextGraphMeta(root)
+    ]);
+    if (snapshotLoad.status !== 'ok' || !snapshotLoad.snapshot)
+        return null;
+    if (metaLoad.status !== 'ok' || !metaLoad.meta)
+        return null;
+    if (metaLoad.meta.snapshotHash !== snapshotLoad.snapshot.snapshotHash)
+        return null;
+    if (metaLoad.meta.schemaRevision !== CONTEXT_GRAPH_SCHEMA_REVISION)
+        return null;
+    if (metaLoad.meta.cacheKeyParts.schemaRevision !== cacheKey.parts.schemaRevision)
+        return null;
+    return carryForwardFromSnapshot(snapshotLoad.snapshot.nodes, snapshotLoad.snapshot.edges, changedPaths);
+}
+export async function compileContextGraph(input) {
+    const startedAt = Date.now();
+    const root = path.resolve(input.root);
+    const outcome = await withContextGraphCompileLock(root, () => compileLocked(input, root, startedAt));
+    if (outcome.acquired)
+        return outcome.value;
+    await appendContextGraphEvent(root, {
+        type: 'compile.lock_contended',
+        at: input.observedAt ?? new Date().toISOString(),
+        reason: 'lock_held'
+    });
+    return failure('lock_held', ['lock_held'], Date.now() - startedAt);
+}
+export { DEFAULT_CONTEXT_GRAPH_LIMITS } from './extract.js';

package/dist/core/triwiki/context-graph/compiler/serialize.js

@@ -0,0 +1,115 @@
+import { sha256 } from '../../../fsx.js';
+import { CONTEXT_GRAPH_SCHEMA, CONTEXT_GRAPH_SCHEMA_REVISION } from '../contracts.js';
+import { compareContextGraphIds, shortDigest } from '../ids.js';
+function orderedMetadata(metadata) {
+    const out = {};
+    if (!metadata)
+        return out;
+    for (const key of Object.keys(metadata).sort()) {
+        const value = metadata[key];
+        if (value === undefined)
+            continue;
+        out[key] = Array.isArray(value) ? [...value] : value;
+    }
+    return out;
+}
+function orderedLocator(locator) {
+    return {
+        ...(locator.line === undefined ? {} : { line: locator.line }),
+        ...(locator.column === undefined ? {} : { column: locator.column }),
+        ...(locator.endLine === undefined ? {} : { endLine: locator.endLine }),
+        ...(locator.endColumn === undefined ? {} : { endColumn: locator.endColumn })
+    };
+}
+export function orderedNode(node) {
+    return {
+        id: node.id,
+        kind: node.kind,
+        label: node.label,
+        ...(node.path === undefined ? {} : { path: node.path }),
+        ...(node.locator === undefined ? {} : { locator: orderedLocator(node.locator) }),
+        ...(node.contentHash === undefined ? {} : { contentHash: node.contentHash }),
+        trust: node.trust,
+        freshness: node.freshness,
+        risk: node.risk,
+        tokenCost: node.tokenCost,
+        metadata: orderedMetadata(node.metadata)
+    };
+}
+export function orderedEdge(edge, includeObservedAt = true) {
+    const provenance = edge.provenance;
+    return {
+        id: edge.id,
+        from: edge.from,
+        to: edge.to,
+        type: edge.type,
+        confidence: edge.confidence,
+        provenance: {
+            path: provenance.path,
+            ...(provenance.line === undefined ? {} : { line: provenance.line }),
+            hash: provenance.hash,
+            extractor: provenance.extractor
+        },
+        observedAt: includeObservedAt ? edge.observedAt : ''
+    };
+}
+export function sortContextGraphNodes(nodes) {
+    return [...nodes].sort((left, right) => compareContextGraphIds(left.id, right.id));
+}
+export function sortContextGraphEdges(edges) {
+    return [...edges].sort((left, right) => compareContextGraphIds(left.id, right.id));
+}
+export function contextGraphCycleId(nodes) {
+    return `cycle:${shortDigest([...nodes].sort(compareContextGraphIds).join('\n'))}`;
+}
+export function sortContextGraphCycles(cycles) {
+    return cycles
+        .map((cycle) => ({ id: cycle.id, nodes: [...cycle.nodes].sort(compareContextGraphIds) }))
+        .sort((left, right) => compareContextGraphIds(left.id, right.id));
+}
+export function sortExtractorStats(stats) {
+    return [...stats]
+        .map((stat) => ({
+        id: stat.id,
+        revision: stat.revision,
+        nodeCount: stat.nodeCount,
+        edgeCount: stat.edgeCount,
+        issueCount: stat.issueCount,
+        skippedCount: stat.skippedCount
+    }))
+        .sort((left, right) => compareContextGraphIds(left.id, right.id));
+}
+export function canonicalContextGraphHashInput(draft) {
+    return JSON.stringify({
+        schema: CONTEXT_GRAPH_SCHEMA,
+        schemaRevision: CONTEXT_GRAPH_SCHEMA_REVISION,
+        nodes: sortContextGraphNodes(draft.nodes).map(orderedNode),
+        edges: sortContextGraphEdges(draft.edges).map((edge) => orderedEdge(edge, false)),
+        cycles: sortContextGraphCycles(draft.cycles),
+        extractors: sortExtractorStats(draft.extractors)
+    });
+}
+export function computeContextGraphSnapshotHash(draft) {
+    return sha256(canonicalContextGraphHashInput(draft));
+}
+export function buildContextGraphSnapshot(draft) {
+    const nodes = sortContextGraphNodes(draft.nodes).map(orderedNode);
+    const edges = sortContextGraphEdges(draft.edges).map((edge) => orderedEdge(edge));
+    const cycles = sortContextGraphCycles(draft.cycles);
+    const extractors = sortExtractorStats(draft.extractors);
+    const snapshotHash = computeContextGraphSnapshotHash({ nodes, edges, cycles, extractors });
+    return {
+        schema: CONTEXT_GRAPH_SCHEMA,
+        schemaRevision: CONTEXT_GRAPH_SCHEMA_REVISION,
+        snapshotHash,
+        nodes,
+        edges,
+        cycles,
+        extractors,
+        nodeCount: nodes.length,
+        edgeCount: edges.length
+    };
+}
+export function serializeContextGraphSnapshot(snapshot) {
+    return `${JSON.stringify(snapshot, null, 2)}\n`;
+}

package/dist/core/triwiki/context-graph/contracts.js

@@ -0,0 +1,236 @@
+import { compareContextGraphIds } from './ids.js';
+export const CONTEXT_GRAPH_SCHEMA = 'sks.context-graph.v1';
+export const CONTEXT_GRAPH_FRAGMENT_SCHEMA = 'sks.context-graph-fragment.v1';
+export const CONTEXT_GRAPH_META_SCHEMA = 'sks.context-graph-meta.v1';
+export const CONTEXT_GRAPH_SCHEMA_REVISION = '1.0.0';
+export const CONTEXT_GRAPH_MISSING_ERROR = 'context_graph_missing';
+export const CONTEXT_GRAPH_STALE_ERROR = 'context_graph_stale';
+export const CONTEXT_GRAPH_CORRUPT_ERROR = 'context_graph_corrupt';
+export const CONTEXT_GRAPH_REPAIR_COMMAND = 'sks wiki refresh --code';
+export const CONTEXT_GRAPH_NODE_KINDS = [
+    'file',
+    'symbol',
+    'module',
+    'command',
+    'route',
+    'pipeline',
+    'test',
+    'gate',
+    'schema',
+    'config',
+    'wiki_claim',
+    'source',
+    'proof',
+    'risk_domain'
+];
+export const CONTEXT_GRAPH_EDGE_TYPES = [
+    'contains',
+    'defines',
+    'imports',
+    'reexports',
+    'references',
+    'calls',
+    'depends_on',
+    'routes_to',
+    'owns',
+    'tests',
+    'verified_by',
+    'gated_by',
+    'affected_by',
+    'cites',
+    'derived_from',
+    'supports',
+    'contradicts',
+    'supersedes',
+    'invalidates',
+    'cochanged_with',
+    'conflicts_with'
+];
+export const CONTEXT_GRAPH_LINT_ERROR_CODES = [
+    'duplicate_node_conflict',
+    'dangling_edge',
+    'edge_without_provenance',
+    'absolute_or_escaping_path',
+    'symlink_escape',
+    'secret_like_value',
+    'unsupported_node_kind',
+    'unsupported_edge_type',
+    'non_deterministic_serialization',
+    'protected_gate_without_source_relation',
+    'manifest_dag_cycle',
+    'hash_mismatch',
+    'snapshot_meta_mismatch',
+    'freshness_claim_mismatch',
+    'invalid_node_field',
+    'invalid_edge_field'
+];
+export const CONTEXT_GRAPH_LINT_WARNING_CODES = [
+    'orphan_wiki_claim',
+    'single_source_low_trust_synthesis',
+    'unknown_freshness',
+    'high_fan_in_without_verification',
+    'unreachable_in_profile',
+    'extractor_skipped_input'
+];
+export const CONTEXT_GRAPH_STALE_REASONS = [
+    'head_changed',
+    'dirty_fingerprint_changed',
+    'schema_revision_changed',
+    'tsconfig_changed',
+    'command_manifest_changed',
+    'gate_manifest_changed',
+    'proof_index_changed',
+    'wiki_context_changed',
+    'git_state_unknown',
+    'source_hash_mismatch',
+    'meta_mismatch',
+    'cache_key_changed'
+];
+const NODE_KIND_SET = new Set(CONTEXT_GRAPH_NODE_KINDS);
+const EDGE_TYPE_SET = new Set(CONTEXT_GRAPH_EDGE_TYPES);
+const EDGE_CONFIDENCE_SET = new Set(['exact', 'syntactic', 'manifest', 'observed', 'derived']);
+const FRESHNESS_SET = new Set(['fresh', 'stale', 'unknown']);
+const RISK_SET = new Set(['low', 'medium', 'high', 'protected']);
+export function isContextGraphNodeKind(value) {
+    return typeof value === 'string' && NODE_KIND_SET.has(value);
+}
+export function isContextGraphEdgeType(value) {
+    return typeof value === 'string' && EDGE_TYPE_SET.has(value);
+}
+export function lintError(code, message, extra = {}) {
+    return { ...extra, code, severity: 'error', message };
+}
+export function lintWarning(code, message, extra = {}) {
+    return { ...extra, code, severity: 'warning', message };
+}
+export function emptyContextGraphFragment(extractor, revision) {
+    return {
+        schema: CONTEXT_GRAPH_FRAGMENT_SCHEMA,
+        extractor,
+        extractorRevision: revision,
+        nodes: [],
+        edges: [],
+        issues: [],
+        skipped: [],
+        inputHashes: {}
+    };
+}
+function record(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+}
+function validateNode(value, index, issues) {
+    const node = record(value);
+    if (!node) {
+        issues.push(lintError('invalid_node_field', `node[${index}] is not an object`));
+        return null;
+    }
+    const id = typeof node.id === 'string' ? node.id : '';
+    if (!id) {
+        issues.push(lintError('invalid_node_field', `node[${index}] has no id`));
+        return null;
+    }
+    if (!isContextGraphNodeKind(node.kind)) {
+        issues.push(lintError('unsupported_node_kind', `node ${id} has unsupported kind`, { nodeId: id }));
+    }
+    if (typeof node.label !== 'string' || !node.label) {
+        issues.push(lintError('invalid_node_field', `node ${id} has no label`, { nodeId: id }));
+    }
+    if (typeof node.trust !== 'number' || node.trust < 0 || node.trust > 1) {
+        issues.push(lintError('invalid_node_field', `node ${id} trust must be 0..1`, { nodeId: id }));
+    }
+    if (!FRESHNESS_SET.has(String(node.freshness))) {
+        issues.push(lintError('invalid_node_field', `node ${id} has invalid freshness`, { nodeId: id }));
+    }
+    if (!RISK_SET.has(String(node.risk))) {
+        issues.push(lintError('invalid_node_field', `node ${id} has invalid risk`, { nodeId: id }));
+    }
+    if (typeof node.tokenCost !== 'number' || node.tokenCost < 0) {
+        issues.push(lintError('invalid_node_field', `node ${id} tokenCost must be >= 0`, { nodeId: id }));
+    }
+    if (!record(node.metadata)) {
+        issues.push(lintError('invalid_node_field', `node ${id} metadata must be an object`, { nodeId: id }));
+    }
+    return id;
+}
+function validateEdge(value, index, nodeIds, issues) {
+    const edge = record(value);
+    if (!edge) {
+        issues.push(lintError('invalid_edge_field', `edge[${index}] is not an object`));
+        return;
+    }
+    const id = typeof edge.id === 'string' ? edge.id : '';
+    if (!id) {
+        issues.push(lintError('invalid_edge_field', `edge[${index}] has no id`));
+        return;
+    }
+    if (!isContextGraphEdgeType(edge.type)) {
+        issues.push(lintError('unsupported_edge_type', `edge ${id} has unsupported type`, { edgeId: id }));
+    }
+    if (!EDGE_CONFIDENCE_SET.has(String(edge.confidence))) {
+        issues.push(lintError('invalid_edge_field', `edge ${id} has invalid confidence`, { edgeId: id }));
+    }
+    const from = typeof edge.from === 'string' ? edge.from : '';
+    const to = typeof edge.to === 'string' ? edge.to : '';
+    if (!from || !nodeIds.has(from)) {
+        issues.push(lintError('dangling_edge', `edge ${id} has no resolvable from node`, { edgeId: id }));
+    }
+    if (!to || !nodeIds.has(to)) {
+        issues.push(lintError('dangling_edge', `edge ${id} has no resolvable to node`, { edgeId: id }));
+    }
+    const provenance = record(edge.provenance);
+    if (!provenance || typeof provenance.path !== 'string' || !provenance.path || typeof provenance.hash !== 'string' || !provenance.hash) {
+        issues.push(lintError('edge_without_provenance', `edge ${id} has no usable provenance`, { edgeId: id }));
+    }
+    if (typeof edge.observedAt !== 'string' || !edge.observedAt) {
+        issues.push(lintError('invalid_edge_field', `edge ${id} has no observedAt`, { edgeId: id }));
+    }
+}
+export function validateContextGraphSnapshot(value) {
+    const issues = [];
+    const snapshot = record(value);
+    if (!snapshot) {
+        issues.push(lintError('invalid_node_field', 'snapshot is not an object'));
+        return { ok: false, issues };
+    }
+    if (snapshot.schema !== CONTEXT_GRAPH_SCHEMA) {
+        issues.push(lintError('snapshot_meta_mismatch', `snapshot schema must be ${CONTEXT_GRAPH_SCHEMA}`));
+    }
+    if (typeof snapshot.snapshotHash !== 'string' || !snapshot.snapshotHash) {
+        issues.push(lintError('hash_mismatch', 'snapshot has no snapshotHash'));
+    }
+    const nodes = Array.isArray(snapshot.nodes) ? snapshot.nodes : null;
+    const edges = Array.isArray(snapshot.edges) ? snapshot.edges : null;
+    if (!nodes || !edges) {
+        issues.push(lintError('invalid_node_field', 'snapshot must carry nodes and edges arrays'));
+        return { ok: false, issues };
+    }
+    const nodeIds = new Set();
+    let previousNodeId = null;
+    for (const [index, raw] of nodes.entries()) {
+        const id = validateNode(raw, index, issues);
+        if (!id)
+            continue;
+        if (nodeIds.has(id))
+            issues.push(lintError('duplicate_node_conflict', `duplicate node id ${id}`, { nodeId: id }));
+        nodeIds.add(id);
+        if (previousNodeId !== null && compareContextGraphIds(previousNodeId, id) > 0) {
+            issues.push(lintError('non_deterministic_serialization', `nodes are not sorted by id at ${id}`, { nodeId: id }));
+        }
+        previousNodeId = id;
+    }
+    let previousEdgeId = null;
+    for (const [index, raw] of edges.entries()) {
+        validateEdge(raw, index, nodeIds, issues);
+        const edgeId = record(raw)?.id;
+        if (typeof edgeId !== 'string')
+            continue;
+        if (previousEdgeId !== null && compareContextGraphIds(previousEdgeId, edgeId) > 0) {
+            issues.push(lintError('non_deterministic_serialization', `edges are not sorted by id at ${edgeId}`, { edgeId }));
+        }
+        previousEdgeId = edgeId;
+    }
+    if (snapshot.nodeCount !== nodes.length || snapshot.edgeCount !== edges.length) {
+        issues.push(lintError('snapshot_meta_mismatch', 'snapshot counts do not match the serialized arrays'));
+    }
+    return { ok: issues.every((issue) => issue.severity !== 'error'), issues };
+}