sneakoscope 8.3.2 → 8.4.0

package/dist/core/triwiki/context-graph/projections/mermaid/ownership-workstream.js

@@ -0,0 +1,21 @@
+import { layerForModule } from '../../architecture/policy.js';
+import { projectFilteredView } from './view-builder.js';
+function modulePath(nodeId, path) {
+    if (path)
+        return path;
+    return nodeId.startsWith('module:') ? nodeId.slice('module:'.length) : nodeId;
+}
+export function buildOwnershipWorkstreamView(input) {
+    return projectFilteredView({
+        viewId: 'ownership-workstream',
+        snapshot: input.snapshot,
+        policy: input.policy,
+        ...(input.request ? { request: input.request } : {}),
+        filter: {
+            kinds: ['module'],
+            edgeTypes: ['owns', 'depends_on', 'imports']
+        },
+        groupByLayer: true,
+        layerOf: (node, policy) => layerForModule(policy, modulePath(node.id, node.path))
+    });
+}

package/dist/core/triwiki/context-graph/projections/mermaid/project-topology.js

@@ -0,0 +1,13 @@
+import { projectFilteredView } from './view-builder.js';
+export function buildProjectTopologyView(input) {
+    return projectFilteredView({
+        viewId: 'project-topology',
+        snapshot: input.snapshot,
+        policy: input.policy,
+        ...(input.request ? { request: input.request } : {}),
+        filter: {
+            kinds: ['module', 'file', 'command', 'route'],
+            edgeTypes: ['contains', 'depends_on', 'routes_to']
+        }
+    });
+}

package/dist/core/triwiki/context-graph/projections/mermaid/public-surface.js

@@ -0,0 +1,17 @@
+import { projectFilteredView } from './view-builder.js';
+export function buildPublicSurfaceView(input) {
+    const edgeTypes = ['reexports', 'owns', 'routes_to'];
+    if (input.snapshot.edges.some((edge) => edge.type === 'exports')) {
+        edgeTypes.push('exports');
+    }
+    return projectFilteredView({
+        viewId: 'public-surface',
+        snapshot: input.snapshot,
+        policy: input.policy,
+        ...(input.request ? { request: input.request } : {}),
+        filter: {
+            kinds: ['command', 'route', 'schema', 'config'],
+            edgeTypes
+        }
+    });
+}

package/dist/core/triwiki/context-graph/projections/mermaid/reduce.js

@@ -0,0 +1,44 @@
+import { byCodePoint } from '../../architecture/contracts.js';
+import { SelectionLedger } from './selection-ledger.js';
+export function reduceForBudget(input) {
+    const ledger = new SelectionLedger();
+    const protectedIds = input.protectedNodeIds ?? new Set();
+    const sortedNodes = [...input.nodes].sort((left, right) => byCodePoint(left.id, right.id));
+    for (const node of sortedNodes)
+        ledger.selectNode(node.id);
+    const admitted = [];
+    for (const node of sortedNodes) {
+        if (protectedIds.has(node.id)) {
+            admitted.push(node);
+            ledger.emitNode(node.id);
+            continue;
+        }
+        if (admitted.length >= input.budget.maxNodes) {
+            ledger.omitNode(node.id, 'budget_exhausted_after_protected_set');
+            continue;
+        }
+        admitted.push(node);
+        ledger.emitNode(node.id);
+    }
+    const admittedIds = new Set(admitted.map((node) => node.id));
+    const sortedEdges = [...input.edges].sort((left, right) => byCodePoint(left.id, right.id));
+    const admittedEdges = [];
+    for (const edge of sortedEdges) {
+        ledger.selectEdge(edge.id);
+        if (!admittedIds.has(edge.from) || !admittedIds.has(edge.to)) {
+            ledger.omitEdge(edge.id, 'outside_profile_scope', 'endpoint omitted');
+            continue;
+        }
+        if (admittedEdges.length >= input.budget.maxEdges) {
+            ledger.omitEdge(edge.id, 'budget_exhausted_after_protected_set');
+            continue;
+        }
+        admittedEdges.push(edge);
+        ledger.emitEdge(edge.id);
+    }
+    return {
+        nodes: Object.freeze(admitted),
+        edges: Object.freeze(admittedEdges),
+        ledger
+    };
+}

package/dist/core/triwiki/context-graph/projections/mermaid/risk-domains.js

@@ -0,0 +1,23 @@
+import { projectFilteredView } from './view-builder.js';
+export function buildRiskDomainsView(input) {
+    const highRiskIds = input.snapshot.nodes
+        .filter((node) => node.kind === 'module' && (node.risk === 'high' || node.risk === 'protected'))
+        .map((node) => node.id);
+    const findingSubjectIds = [...(input.request?.findingSubjectIds ?? []), ...highRiskIds];
+    const request = {
+        ...(input.request?.profile ? { profile: input.request.profile } : {}),
+        ...(input.request?.seedNodeIds ? { seedNodeIds: input.request.seedNodeIds } : {}),
+        ...(input.request?.seedPaths ? { seedPaths: input.request.seedPaths } : {}),
+        ...(findingSubjectIds.length ? { findingSubjectIds } : {})
+    };
+    return projectFilteredView({
+        viewId: 'risk-domains',
+        snapshot: input.snapshot,
+        policy: input.policy,
+        request,
+        filter: {
+            kinds: ['risk_domain', 'module'],
+            edgeTypes: ['affected_by', 'owns']
+        }
+    });
+}

package/dist/core/triwiki/context-graph/projections/mermaid/runtime-control.js

@@ -0,0 +1,20 @@
+import { emptyProjection, projectFilteredView } from './view-builder.js';
+export function buildRuntimeControlView(input) {
+    const hasControl = input.snapshot.nodes.some((node) => node.kind === 'route' ||
+        node.kind === 'pipeline' ||
+        node.kind === 'gate' ||
+        node.kind === 'command');
+    if (!hasControl) {
+        return emptyProjection('runtime-control', 'Runtime control', 'TD', 'insufficient_graph: no route/pipeline/gate/command nodes');
+    }
+    return projectFilteredView({
+        viewId: 'runtime-control',
+        snapshot: input.snapshot,
+        policy: input.policy,
+        ...(input.request ? { request: input.request } : {}),
+        filter: {
+            kinds: ['route', 'pipeline', 'gate', 'command'],
+            edgeTypes: ['routes_to', 'gated_by', 'owns']
+        }
+    });
+}

package/dist/core/triwiki/context-graph/projections/mermaid/selection-ledger.js

@@ -0,0 +1,94 @@
+import { byCodePoint } from '../../architecture/contracts.js';
+export class SelectionLedger {
+    selectedNodes = new Set();
+    emittedNodes = new Set();
+    omittedNodes = [];
+    aggregatedNodes = new Map();
+    selectedEdges = new Set();
+    emittedEdges = new Set();
+    omittedEdges = [];
+    aggregatedEdges = new Map();
+    selectNode(id) {
+        this.selectedNodes.add(id);
+    }
+    emitNode(id) {
+        this.selectedNodes.add(id);
+        this.emittedNodes.add(id);
+    }
+    omitNode(id, reason, detail) {
+        this.selectedNodes.add(id);
+        const omission = detail === undefined
+            ? { id, reason }
+            : { id, reason, detail };
+        this.omittedNodes.push(Object.freeze(omission));
+    }
+    aggregateNodes(aggregateId, memberIds) {
+        this.selectedNodes.add(aggregateId);
+        for (const id of memberIds)
+            this.selectedNodes.add(id);
+        this.emittedNodes.add(aggregateId);
+        this.aggregatedNodes.set(aggregateId, [...memberIds].sort(byCodePoint));
+    }
+    selectEdge(id) {
+        this.selectedEdges.add(id);
+    }
+    emitEdge(id) {
+        this.selectedEdges.add(id);
+        this.emittedEdges.add(id);
+    }
+    omitEdge(id, reason, detail) {
+        this.selectedEdges.add(id);
+        const omission = detail === undefined
+            ? { id, reason }
+            : { id, reason, detail };
+        this.omittedEdges.push(Object.freeze(omission));
+    }
+    aggregateEdges(aggregateId, memberIds) {
+        this.selectedEdges.add(aggregateId);
+        for (const id of memberIds)
+            this.selectedEdges.add(id);
+        this.emittedEdges.add(aggregateId);
+        this.aggregatedEdges.set(aggregateId, [...memberIds].sort(byCodePoint));
+    }
+    toAccounting() {
+        return Object.freeze({
+            selectedNodeIds: Object.freeze([...this.selectedNodes].sort(byCodePoint)),
+            emittedNodeIds: Object.freeze([...this.emittedNodes].sort(byCodePoint)),
+            aggregatedNodeMembers: Object.freeze(Object.fromEntries([...this.aggregatedNodes.entries()]
+                .sort(([left], [right]) => byCodePoint(left, right))
+                .map(([key, value]) => [key, Object.freeze(value)]))),
+            omittedNodes: Object.freeze([...this.omittedNodes].sort((left, right) => byCodePoint(left.id, right.id))),
+            selectedEdgeIds: Object.freeze([...this.selectedEdges].sort(byCodePoint)),
+            emittedEdgeIds: Object.freeze([...this.emittedEdges].sort(byCodePoint)),
+            aggregatedEdgeMembers: Object.freeze(Object.fromEntries([...this.aggregatedEdges.entries()]
+                .sort(([left], [right]) => byCodePoint(left, right))
+                .map(([key, value]) => [key, Object.freeze(value)]))),
+            omittedEdges: Object.freeze([...this.omittedEdges].sort((left, right) => byCodePoint(left.id, right.id)))
+        });
+    }
+    assertBalanced() {
+        const accounting = this.toAccounting();
+        const nodeCovered = new Set([
+            ...accounting.emittedNodeIds,
+            ...Object.values(accounting.aggregatedNodeMembers).flat(),
+            ...accounting.omittedNodes.map((entry) => entry.id)
+        ]);
+        for (const id of accounting.selectedNodeIds) {
+            if (!nodeCovered.has(id) && !accounting.emittedNodeIds.includes(id)) {
+                if (!Object.prototype.hasOwnProperty.call(accounting.aggregatedNodeMembers, id)) {
+                    throw new Error(`projection_node_unaccounted: ${id}`);
+                }
+            }
+        }
+        const edgeCovered = new Set([
+            ...accounting.emittedEdgeIds,
+            ...Object.values(accounting.aggregatedEdgeMembers).flat(),
+            ...accounting.omittedEdges.map((entry) => entry.id)
+        ]);
+        for (const id of accounting.selectedEdgeIds) {
+            if (!edgeCovered.has(id) && !Object.prototype.hasOwnProperty.call(accounting.aggregatedEdgeMembers, id)) {
+                throw new Error(`projection_edge_unaccounted: ${id}`);
+            }
+        }
+    }
+}

package/dist/core/triwiki/context-graph/projections/mermaid/serializer.js

@@ -0,0 +1,81 @@
+import { byCodePoint } from '../../architecture/contracts.js';
+import { hashCanonical } from '../../architecture/fingerprint.js';
+import { GENERATED_HEADER, MERMAID_TEXT_LIMIT } from './contracts.js';
+import { MERMAID_PROJECTION_SCHEMA } from './contracts.js';
+function nodePrimaryCanonical(node) {
+    return node.canonicalNodeIds[0] ?? node.id;
+}
+function edgeSortKey(edge) {
+    return [edge.fromCanonicalId, edge.relation, edge.toCanonicalId, edge.canonicalEdgeIds[0] ?? ''].join('\0');
+}
+function sortStatements(statements) {
+    const comments = statements.filter((entry) => entry.kind === 'comment');
+    const subgraphs = statements
+        .filter((entry) => entry.kind === 'subgraph')
+        .sort((left, right) => byCodePoint(left.canonicalId, right.canonicalId));
+    const nodes = statements
+        .filter((entry) => entry.kind === 'node')
+        .sort((left, right) => byCodePoint(nodePrimaryCanonical(left), nodePrimaryCanonical(right)));
+    const edges = statements
+        .filter((entry) => entry.kind === 'edge')
+        .sort((left, right) => byCodePoint(edgeSortKey(left), edgeSortKey(right)));
+    return [...comments, ...subgraphs, ...nodes, ...edges];
+}
+function renderStatement(statement, indent) {
+    if (statement.kind === 'comment')
+        return [`${indent}%% ${statement.text}`];
+    if (statement.kind === 'node')
+        return [`${indent}${statement.id}["${statement.label}"]`];
+    if (statement.kind === 'edge') {
+        const arrow = statement.style === 'dotted' ? '-.->' : '-->';
+        return [`${indent}${statement.from} ${arrow}|"${statement.relation}"| ${statement.to}`];
+    }
+    const lines = [`${indent}subgraph ${statement.id}["${statement.label}"]`];
+    for (const child of sortStatements(statement.statements)) {
+        lines.push(...renderStatement(child, `${indent}  `));
+    }
+    lines.push(`${indent}end`);
+    return lines;
+}
+export function serializeMermaidDocument(doc) {
+    const lines = [
+        GENERATED_HEADER,
+        `%% title: ${doc.title}`,
+        `flowchart ${doc.direction}`
+    ];
+    for (const statement of sortStatements(doc.statements)) {
+        lines.push(...renderStatement(statement, ''));
+    }
+    const text = `${lines.join('\n')}\n`;
+    const bytes = Buffer.byteLength(text, 'utf8');
+    if (bytes > MERMAID_TEXT_LIMIT) {
+        throw new Error(`mermaid_budget_overrun: ${bytes}>${MERMAID_TEXT_LIMIT}`);
+    }
+    return text;
+}
+export function emptyAccounting() {
+    return Object.freeze({
+        selectedNodeIds: Object.freeze([]),
+        emittedNodeIds: Object.freeze([]),
+        aggregatedNodeMembers: Object.freeze({}),
+        omittedNodes: Object.freeze([]),
+        selectedEdgeIds: Object.freeze([]),
+        emittedEdgeIds: Object.freeze([]),
+        aggregatedEdgeMembers: Object.freeze({}),
+        omittedEdges: Object.freeze([])
+    });
+}
+export function toMermaidProjection(input) {
+    const text = serializeMermaidDocument(input.doc);
+    return Object.freeze({
+        schema: MERMAID_PROJECTION_SCHEMA,
+        viewId: input.viewId,
+        direction: input.doc.direction,
+        title: input.doc.title,
+        source: text,
+        accounting: input.accounting,
+        contentHash: hashCanonical(text),
+        byteLength: Buffer.byteLength(text, 'utf8'),
+        text
+    });
+}

package/dist/core/triwiki/context-graph/projections/mermaid/ssot-provenance.js

@@ -0,0 +1,17 @@
+import { emptyProjection, projectFilteredView } from './view-builder.js';
+export function buildSsotProvenanceView(input) {
+    const hasSsotKinds = input.snapshot.nodes.some((node) => node.kind === 'source' || node.kind === 'wiki_claim' || node.kind === 'proof');
+    if (!hasSsotKinds) {
+        return emptyProjection('ssot-provenance', 'SSOT provenance', 'TD', 'insufficient_graph: no source/wiki_claim/proof nodes');
+    }
+    return projectFilteredView({
+        viewId: 'ssot-provenance',
+        snapshot: input.snapshot,
+        policy: input.policy,
+        ...(input.request ? { request: input.request } : {}),
+        filter: {
+            kinds: ['source', 'wiki_claim', 'proof'],
+            edgeTypes: ['cites', 'derived_from', 'verified_by']
+        }
+    });
+}

package/dist/core/triwiki/context-graph/projections/mermaid/verification-coverage.js

@@ -0,0 +1,17 @@
+import { emptyProjection, projectFilteredView } from './view-builder.js';
+export function buildVerificationCoverageView(input) {
+    const hasVerification = input.snapshot.nodes.some((node) => node.kind === 'test' || node.kind === 'gate' || node.kind === 'proof');
+    if (!hasVerification) {
+        return emptyProjection('verification-coverage', 'Verification coverage', 'LR', 'insufficient_graph: no test/gate/proof nodes');
+    }
+    return projectFilteredView({
+        viewId: 'verification-coverage',
+        snapshot: input.snapshot,
+        policy: input.policy,
+        ...(input.request ? { request: input.request } : {}),
+        filter: {
+            kinds: ['test', 'gate', 'proof', 'module'],
+            edgeTypes: ['tests', 'verified_by', 'gated_by']
+        }
+    });
+}

package/dist/core/triwiki/context-graph/projections/mermaid/view-builder-common.js

@@ -0,0 +1 @@
+export { buildMermaidView, emptyMermaidView, emptyProjection, projectFilteredView } from './view-builder.js';

package/dist/core/triwiki/context-graph/projections/mermaid/view-builder.js

@@ -0,0 +1,173 @@
+import { byCodePoint } from '../../architecture/contracts.js';
+import * as ast from './ast.js';
+import { assertInjective, mermaidEdgeId, mermaidNodeId, mermaidSubgraphId } from './ids.js';
+import { reduceForBudget } from './reduce.js';
+import { serializeMermaidDocument, toMermaidProjection } from './serializer.js';
+import { viewSpecFor } from './view-specs.js';
+function labelFor(node) {
+    return node.label || node.path || node.id;
+}
+function filterGraph(snapshot, filter) {
+    const kindSet = new Set(filter.kinds);
+    const edgeSet = new Set(filter.edgeTypes);
+    const nodes = snapshot.nodes
+        .filter((node) => kindSet.has(node.kind))
+        .sort((left, right) => byCodePoint(left.id, right.id));
+    const candidateIds = new Set(nodes.map((node) => node.id));
+    const edges = snapshot.edges
+        .filter((edge) => edgeSet.has(edge.type) && candidateIds.has(edge.from) && candidateIds.has(edge.to))
+        .sort((left, right) => byCodePoint(left.id, right.id));
+    return { nodes, edges };
+}
+export function buildMermaidView(input) {
+    const spec = viewSpecFor(input.viewId);
+    const { nodes: candidateNodes, edges: candidateEdges } = filterGraph(input.snapshot, input.filter);
+    const protectedIds = new Set(input.protectedNodeIds ?? []);
+    const profileKey = input.profile ?? 'global';
+    const budget = input.policy.profiles[profileKey];
+    const reduced = reduceForBudget({
+        nodes: candidateNodes,
+        edges: candidateEdges,
+        budget,
+        protectedNodeIds: protectedIds
+    });
+    const idMap = assertInjective(reduced.nodes.map((node) => node.id));
+    const statements = [ast.comment(`atlas-view: ${input.viewId}`)];
+    if (input.groupByLayer && input.layerOf) {
+        const byLayer = new Map();
+        for (const node of reduced.nodes) {
+            const layer = input.layerOf(node, input.policy) ?? 'unassigned';
+            const list = byLayer.get(layer) ?? [];
+            list.push(node);
+            byLayer.set(layer, list);
+        }
+        for (const layer of [...byLayer.keys()].sort(byCodePoint)) {
+            const nodes = byLayer.get(layer) ?? [];
+            const subgraphNodes = nodes.map((node) => ast.node({
+                id: idMap.get(node.id),
+                label: labelFor(node),
+                canonicalNodeIds: [node.id]
+            }));
+            statements.push(ast.subgraph({
+                id: mermaidSubgraphId(`layer:${layer}`),
+                label: layer,
+                canonicalId: `layer:${layer}`,
+                statements: subgraphNodes
+            }));
+        }
+    }
+    else {
+        for (const node of reduced.nodes) {
+            statements.push(ast.node({
+                id: idMap.get(node.id),
+                label: labelFor(node),
+                canonicalNodeIds: [node.id]
+            }));
+        }
+    }
+    for (const edge of reduced.edges) {
+        const fromId = idMap.get(edge.from);
+        const toId = idMap.get(edge.to);
+        if (!fromId || !toId)
+            continue;
+        const style = protectedIds.has(edge.from) || protectedIds.has(edge.to)
+            ? 'dotted'
+            : 'solid';
+        statements.push(ast.edge({
+            from: fromId,
+            to: toId,
+            relation: edge.type,
+            style,
+            canonicalEdgeIds: [edge.id],
+            fromCanonicalId: edge.from,
+            toCanonicalId: edge.to
+        }));
+        void mermaidEdgeId(edge.from, edge.to, edge.type);
+    }
+    for (const seed of protectedIds) {
+        if (!idMap.has(seed))
+            void mermaidNodeId(seed);
+    }
+    reduced.ledger.assertBalanced();
+    const doc = ast.document({
+        direction: spec.direction,
+        title: spec.title,
+        statements
+    });
+    void serializeMermaidDocument(doc);
+    const built = toMermaidProjection({
+        viewId: input.viewId,
+        doc,
+        accounting: reduced.ledger.toAccounting()
+    });
+    return Object.freeze({
+        text: built.text,
+        projection: Object.freeze({
+            schema: built.schema,
+            viewId: built.viewId,
+            direction: built.direction,
+            title: built.title,
+            source: built.source,
+            accounting: built.accounting,
+            contentHash: built.contentHash,
+            byteLength: built.byteLength
+        })
+    });
+}
+export function emptyMermaidView(input) {
+    const statements = [ast.comment(input.reason)];
+    const reduced = reduceForBudget({
+        nodes: [],
+        edges: [],
+        budget: { maxNodes: 1, maxEdges: 1, maxLabelChars: 56, tokenBudget: 0 }
+    });
+    const built = toMermaidProjection({
+        viewId: input.viewId,
+        doc: ast.document({
+            direction: input.direction,
+            title: input.title,
+            statements
+        }),
+        accounting: reduced.ledger.toAccounting()
+    });
+    return Object.freeze({
+        text: built.text,
+        projection: Object.freeze({
+            schema: built.schema,
+            viewId: built.viewId,
+            direction: built.direction,
+            title: built.title,
+            source: built.source,
+            accounting: built.accounting,
+            contentHash: built.contentHash,
+            byteLength: built.byteLength
+        })
+    });
+}
+export function projectFilteredView(input) {
+    const protectedNodeIds = [
+        ...(input.request?.seedNodeIds ?? []),
+        ...(input.request?.findingSubjectIds ?? [])
+    ];
+    const built = buildMermaidView({
+        snapshot: input.snapshot,
+        policy: input.policy,
+        viewId: input.viewId,
+        filter: input.filter,
+        ...(protectedNodeIds.length ? { protectedNodeIds } : {}),
+        ...(input.groupByLayer === true ? { groupByLayer: true } : {}),
+        ...(input.layerOf ? { layerOf: input.layerOf } : {}),
+        ...(input.request?.profile ? { profile: input.request.profile } : {})
+    });
+    return Object.freeze({
+        ...built.projection,
+        text: built.text
+    });
+}
+export function emptyProjection(viewId, title, direction, reason) {
+    const built = emptyMermaidView({ viewId, title, direction, reason });
+    return Object.freeze({
+        ...built.projection,
+        text: built.text
+    });
+}

package/dist/core/triwiki/context-graph/projections/mermaid/view-specs.js

@@ -0,0 +1,33 @@
+import { ARCHITECTURE_MAP_VIEW_IDS } from '../../architecture/contracts.js';
+const SPECS = Object.freeze([
+    { viewId: 'project-topology', title: 'Project topology', direction: 'LR', filename: 'project-topology.mmd' },
+    { viewId: 'module-dependency', title: 'Module dependency', direction: 'TD', filename: 'module-dependency.mmd' },
+    { viewId: 'public-surface', title: 'Public surface', direction: 'LR', filename: 'public-surface.mmd' },
+    { viewId: 'ssot-provenance', title: 'SSOT provenance', direction: 'TD', filename: 'ssot-provenance.mmd' },
+    { viewId: 'runtime-control', title: 'Runtime control', direction: 'TD', filename: 'runtime-control.mmd' },
+    { viewId: 'verification-coverage', title: 'Verification coverage', direction: 'LR', filename: 'verification-coverage.mmd' },
+    { viewId: 'risk-domains', title: 'Risk domains', direction: 'TD', filename: 'risk-domains.mmd' },
+    { viewId: 'change-impact', title: 'Change impact', direction: 'LR', filename: 'change-impact.mmd' },
+    { viewId: 'architecture-delta', title: 'Architecture delta', direction: 'TD', filename: 'architecture-delta.mmd' },
+    { viewId: 'ownership-workstream', title: 'Ownership workstream', direction: 'LR', filename: 'ownership-workstream.mmd' }
+]);
+export function architectureMapViewSpecs() {
+    return SPECS;
+}
+export function viewSpecFor(viewId) {
+    const spec = SPECS.find((entry) => entry.viewId === viewId);
+    if (!spec)
+        throw new Error(`unknown_architecture_map_view: ${viewId}`);
+    return spec;
+}
+export function assertViewIdsMatchWo() {
+    const fromSpecs = SPECS.map((spec) => spec.viewId);
+    if (fromSpecs.length !== ARCHITECTURE_MAP_VIEW_IDS.length) {
+        throw new Error('architecture_map_view_id_count_mismatch');
+    }
+    for (let index = 0; index < ARCHITECTURE_MAP_VIEW_IDS.length; index += 1) {
+        if (fromSpecs[index] !== ARCHITECTURE_MAP_VIEW_IDS[index]) {
+            throw new Error(`architecture_map_view_id_mismatch: ${fromSpecs[index]}`);
+        }
+    }
+}

package/dist/core/triwiki/context-graph/store/architecture-map-store.js

@@ -0,0 +1,71 @@
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { loadArchitectureMapPolicy } from '../architecture/policy.js';
+import { buildArchitectureMapViews } from '../projections/mermaid/index.js';
+const WIKI_PREFIX = '.sneakoscope/wiki/';
+export const ARCHITECTURE_MAP_DIR_REL = '.sneakoscope/wiki/architecture-map';
+export const ARCHITECTURE_MAP_GLOBAL_VIEW_FILES = Object.freeze([
+    'project-topology.mmd',
+    'module-dependency.mmd',
+    'public-surface.mmd',
+    'ssot-provenance.mmd',
+    'runtime-control.mmd',
+    'verification-coverage.mmd',
+    'risk-domains.mmd'
+]);
+export const ARCHITECTURE_MAP_ARTIFACT_RELS = Object.freeze([
+    `${ARCHITECTURE_MAP_DIR_REL}/manifest.json`,
+    `${ARCHITECTURE_MAP_DIR_REL}/metrics.json`,
+    `${ARCHITECTURE_MAP_DIR_REL}/findings.json`,
+    ...ARCHITECTURE_MAP_GLOBAL_VIEW_FILES.map((name) => `${ARCHITECTURE_MAP_DIR_REL}/views/${name}`)
+]);
+function byCodePoint(left, right) {
+    if (left < right)
+        return -1;
+    return left > right ? 1 : 0;
+}
+function wikiRelative(artifactRel) {
+    if (!artifactRel.startsWith(WIKI_PREFIX)) {
+        throw new Error(`architecture_map_publish_artifact_outside_wiki:${artifactRel}`);
+    }
+    return artifactRel.slice(WIKI_PREFIX.length);
+}
+export async function publishArchitectureMapToStage(stageWikiAbs, snapshot, options) {
+    const policy = options.policy ?? loadArchitectureMapPolicy(options.root);
+    const built = buildArchitectureMapViews(snapshot, policy, {
+        rootId: options.root,
+        missionId: options.missionId ?? null
+    });
+    const written = [];
+    const writeJson = async (rel, value) => {
+        const dest = path.join(stageWikiAbs, wikiRelative(rel));
+        await fsp.mkdir(path.dirname(dest), { recursive: true });
+        await fsp.writeFile(dest, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+        written.push(rel);
+    };
+    const writeText = async (rel, text) => {
+        const dest = path.join(stageWikiAbs, wikiRelative(rel));
+        await fsp.mkdir(path.dirname(dest), { recursive: true });
+        await fsp.writeFile(dest, text.endsWith('\n') ? text : `${text}\n`, 'utf8');
+        written.push(rel);
+    };
+    await writeJson(`${ARCHITECTURE_MAP_DIR_REL}/manifest.json`, built.manifest);
+    await writeJson(`${ARCHITECTURE_MAP_DIR_REL}/metrics.json`, built.metrics);
+    await writeJson(`${ARCHITECTURE_MAP_DIR_REL}/findings.json`, { findings: built.findings });
+    for (const view of built.views) {
+        await writeText(`${ARCHITECTURE_MAP_DIR_REL}/views/${view.filename}`, view.text);
+    }
+    const expected = new Set(ARCHITECTURE_MAP_ARTIFACT_RELS);
+    for (const rel of written) {
+        if (!expected.has(rel))
+            throw new Error(`architecture_map_publish_unexpected_artifact:${rel}`);
+    }
+    if (written.length !== ARCHITECTURE_MAP_ARTIFACT_RELS.length) {
+        throw new Error(`architecture_map_publish_incomplete:${written.length}/${ARCHITECTURE_MAP_ARTIFACT_RELS.length}`);
+    }
+    return {
+        written: [...written].sort(byCodePoint),
+        stageMapDir: path.join(stageWikiAbs, wikiRelative(ARCHITECTURE_MAP_DIR_REL)),
+        built
+    };
+}