sneakoscope 8.3.2 → 8.4.0

package/dist/core/triwiki/context-graph/architecture/validation.js

@@ -0,0 +1,145 @@
+import { ARCHITECTURE_BASELINE_SCHEMA, ARCHITECTURE_INPUT_BUNDLE_SCHEMA, ARCHITECTURE_MAP_MANIFEST_SCHEMA, ARCHITECTURE_REVIEW_SCHEMA, MERMAID_PROJECTION_SCHEMA } from './contracts.js';
+import { verifyArchitectureBaselineSeal } from './baseline.js';
+function asRecord(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return null;
+    return value;
+}
+export function validateArchitectureInputBundle(value) {
+    const blockers = [];
+    const record = asRecord(value);
+    if (!record)
+        return { ok: false, blockers: ['not_an_object'] };
+    if (record.schema !== ARCHITECTURE_INPUT_BUNDLE_SCHEMA)
+        blockers.push('schema');
+    for (const key of [
+        'rootId',
+        'graphHash',
+        'topologyHash',
+        'ssotInventoryHash',
+        'voxelContextHash',
+        'policyHash',
+        'analyzerVersion',
+        'serializerVersion',
+        'canonicalHash'
+    ]) {
+        if (typeof record[key] !== 'string' || !record[key].length)
+            blockers.push(key);
+    }
+    if (!record.graph || typeof record.graph !== 'object')
+        blockers.push('graph');
+    if (!record.worktree || typeof record.worktree !== 'object')
+        blockers.push('worktree');
+    return { ok: blockers.length === 0, blockers: Object.freeze(blockers) };
+}
+export function validateArchitectureBaseline(value) {
+    const blockers = [];
+    const record = asRecord(value);
+    if (!record)
+        return { ok: false, blockers: ['not_an_object'] };
+    if (record.schema !== ARCHITECTURE_BASELINE_SCHEMA)
+        blockers.push('schema');
+    if (record.required !== true)
+        blockers.push('required');
+    if (record.capturedBeforeMutation !== true)
+        blockers.push('capturedBeforeMutation');
+    for (const key of [
+        'missionId',
+        'worktreeFingerprintHash',
+        'graphHash',
+        'policyHash',
+        'analyzerVersion',
+        'serializerVersion',
+        'canonicalPayloadHash',
+        'seal'
+    ]) {
+        if (typeof record[key] !== 'string' || !record[key].length)
+            blockers.push(key);
+    }
+    if (!Array.isArray(record.findings))
+        blockers.push('findings');
+    if (!record.metrics || typeof record.metrics !== 'object')
+        blockers.push('metrics');
+    if (blockers.length === 0) {
+        const baseline = value;
+        if (!verifyArchitectureBaselineSeal(baseline))
+            blockers.push('seal_mismatch');
+    }
+    return { ok: blockers.length === 0, blockers: Object.freeze(blockers) };
+}
+export function validateArchitectureReview(value) {
+    const blockers = [];
+    const record = asRecord(value);
+    if (!record)
+        return { ok: false, blockers: ['not_an_object'] };
+    if (record.schema !== ARCHITECTURE_REVIEW_SCHEMA)
+        blockers.push('schema');
+    for (const key of [
+        'missionId',
+        'baselineSeal',
+        'baselineHash',
+        'afterInputHash',
+        'canonicalPayloadHash'
+    ]) {
+        if (typeof record[key] !== 'string' || !record[key].length)
+            blockers.push(key);
+    }
+    if (record.verdict !== 'pass' && record.verdict !== 'block')
+        blockers.push('verdict');
+    for (const key of [
+        'changedPaths',
+        'accountedChangedPaths',
+        'unaccountedChangedPaths',
+        'newFindings',
+        'blockingFindingIds'
+    ]) {
+        if (!Array.isArray(record[key]))
+            blockers.push(key);
+    }
+    return { ok: blockers.length === 0, blockers: Object.freeze(blockers) };
+}
+export function validateMermaidProjection(value) {
+    const blockers = [];
+    const record = asRecord(value);
+    if (!record)
+        return { ok: false, blockers: ['not_an_object'] };
+    if (record.schema !== MERMAID_PROJECTION_SCHEMA)
+        blockers.push('schema');
+    for (const key of ['viewId', 'title', 'source', 'contentHash']) {
+        if (typeof record[key] !== 'string' || !record[key].length)
+            blockers.push(key);
+    }
+    if (record.direction !== 'LR' && record.direction !== 'TD')
+        blockers.push('direction');
+    if (!record.accounting || typeof record.accounting !== 'object')
+        blockers.push('accounting');
+    return { ok: blockers.length === 0, blockers: Object.freeze(blockers) };
+}
+export function validateArchitectureMapManifest(value) {
+    const blockers = [];
+    const record = asRecord(value);
+    if (!record)
+        return { ok: false, blockers: ['not_an_object'] };
+    if (record.schema !== ARCHITECTURE_MAP_MANIFEST_SCHEMA)
+        blockers.push('schema');
+    for (const key of ['graphHash', 'policyHash', 'serializerVersion']) {
+        if (typeof record[key] !== 'string' || !record[key].length)
+            blockers.push(key);
+    }
+    if (!Array.isArray(record.views) || record.views.length === 0)
+        blockers.push('views');
+    if (!record.projectionAccounting || typeof record.projectionAccounting !== 'object') {
+        blockers.push('projectionAccounting');
+    }
+    return { ok: blockers.length === 0, blockers: Object.freeze(blockers) };
+}
+export function assertValidInputBundle(bundle) {
+    const result = validateArchitectureInputBundle(bundle);
+    if (!result.ok)
+        throw new Error(`architecture_input_bundle_invalid: ${result.blockers.join(',')}`);
+}
+export function assertValidReview(review) {
+    const result = validateArchitectureReview(review);
+    if (!result.ok)
+        throw new Error(`architecture_review_invalid: ${result.blockers.join(',')}`);
+}

package/dist/core/triwiki/context-graph/architecture/voxel-context.js

@@ -0,0 +1,39 @@
+import { hashCanonical } from './fingerprint.js';
+export function emptyVoxelContext(profile = 'global') {
+    return Object.freeze({
+        provider: 'none',
+        version: '0',
+        seedNodeIds: Object.freeze([]),
+        seedPaths: Object.freeze([]),
+        riskDomains: Object.freeze([]),
+        profile,
+        workstreamHints: Object.freeze([]),
+        tokenBudgetHint: null,
+        protectedAreaIds: Object.freeze([])
+    });
+}
+export class NoneVoxelArchitectureContextProvider {
+    id = 'none';
+    version = '0';
+    async load(input) {
+        void input.root;
+        void input.missionId;
+        void input.taskText;
+        return emptyVoxelContext(input.profile ?? 'global');
+    }
+}
+const DEFAULT_PROVIDER = new NoneVoxelArchitectureContextProvider();
+export async function loadVoxelArchitectureContext(input) {
+    const provider = input.provider ?? DEFAULT_PROVIDER;
+    const loadInput = { root: input.root };
+    if (input.missionId !== undefined)
+        loadInput.missionId = input.missionId;
+    if (input.taskText !== undefined)
+        loadInput.taskText = input.taskText;
+    if (input.profile !== undefined)
+        loadInput.profile = input.profile;
+    return provider.load(loadInput);
+}
+export function voxelContextHash(context) {
+    return hashCanonical(context);
+}

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

@@ -7,4 +7,8 @@ export function contextGraphExtractors() {
 export function codeNavigationGraphExtractors(options = {}) {
     return [createCodeGraphExtractor(options)];
 }
+export function architectureMapGraphExtractors(options = {}) {
+    return [createCodeGraphExtractor(options), createTopologyGraphExtractor(), createEvidenceGraphExtractor()];
+}
+export const ARCHITECTURE_MAP_EXTRACTOR_IDS = Object.freeze(['code', 'topology', 'triwiki-evidence']);
 export { createCodeGraphExtractor, createEvidenceGraphExtractor, createTopologyGraphExtractor };

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

@@ -5,3 +5,5 @@ export { rankModuleCandidates, sortCandidates } from './module-view.js';
 export { codePackEntryId, describeContextGraphNode, estimateEntryTokenCost, projectedFreshness, projectedTrustScore } from './node-summary.js';
 export { ATTENTION_FACT_TRUST_FLOOR, attentionHydrateHint, isFactGradeAnchor, projectContextGraphAnchors, projectContextPackAnchors, resolveContextGraphAnchorNode } from './anchors.js';
 export { CONTEXT_GRAPH_ATTENTION_TOKEN_BUDGET, readContextGraphAttention } from './attention.js';
+export * as mermaid from './mermaid/index.js';
+export { buildArchitectureMapViews, buildArchitectureMapManifest, buildMermaidView, buildModuleDependencyView, serializeMermaidDocument, GENERATED_HEADER } from './mermaid/index.js';

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

@@ -0,0 +1,68 @@
+import { byCodePoint } from '../../architecture/contracts.js';
+import * as ast from './ast.js';
+import { assertInjective, mermaidSubgraphId } from './ids.js';
+import { emptyAccounting, toMermaidProjection } from './serializer.js';
+import { emptyProjection } from './view-builder.js';
+export function buildArchitectureDeltaView(input) {
+    void input.policy;
+    const beforeNodes = new Set(input.delta.beforeNodeIds);
+    const afterNodes = new Set(input.delta.afterNodeIds);
+    const added = [...afterNodes].filter((id) => !beforeNodes.has(id)).sort(byCodePoint);
+    const removed = [...beforeNodes].filter((id) => !afterNodes.has(id)).sort(byCodePoint);
+    const retained = [...afterNodes].filter((id) => beforeNodes.has(id)).sort(byCodePoint);
+    if (!added.length && !removed.length && !retained.length) {
+        return emptyProjection('architecture-delta', 'Architecture delta', 'TD', 'empty_delta: no before/after node ids');
+    }
+    const labels = new Map(input.snapshot.nodes.map((node) => [node.id, node.label || node.path || node.id]));
+    const allIds = [...added, ...removed, ...retained];
+    const idMap = assertInjective(allIds);
+    const statements = [
+        ast.comment('atlas-view: architecture-delta'),
+        ast.subgraph({
+            id: mermaidSubgraphId('delta:added'),
+            label: 'added',
+            canonicalId: 'delta:added',
+            statements: added.map((id) => ast.node({
+                id: idMap.get(id),
+                label: `+ ${labels.get(id) ?? id}`,
+                canonicalNodeIds: [id]
+            }))
+        }),
+        ast.subgraph({
+            id: mermaidSubgraphId('delta:removed'),
+            label: 'removed',
+            canonicalId: 'delta:removed',
+            statements: removed.map((id) => ast.node({
+                id: idMap.get(id),
+                label: `- ${labels.get(id) ?? id}`,
+                canonicalNodeIds: [id]
+            }))
+        }),
+        ast.subgraph({
+            id: mermaidSubgraphId('delta:retained'),
+            label: 'retained',
+            canonicalId: 'delta:retained',
+            statements: retained.map((id) => ast.node({
+                id: idMap.get(id),
+                label: labels.get(id) ?? id,
+                canonicalNodeIds: [id]
+            }))
+        })
+    ];
+    const beforeEdges = new Set(input.delta.beforeEdgeIds ?? []);
+    const afterEdges = new Set(input.delta.afterEdgeIds ?? []);
+    if (beforeEdges.size || afterEdges.size) {
+        const addedEdges = [...afterEdges].filter((id) => !beforeEdges.has(id)).sort(byCodePoint);
+        const removedEdges = [...beforeEdges].filter((id) => !afterEdges.has(id)).sort(byCodePoint);
+        statements.push(ast.comment(`edges +${addedEdges.length}/-${removedEdges.length}`));
+    }
+    return toMermaidProjection({
+        viewId: 'architecture-delta',
+        doc: ast.document({
+            direction: 'TD',
+            title: 'Architecture delta',
+            statements
+        }),
+        accounting: emptyAccounting()
+    });
+}

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

@@ -0,0 +1,49 @@
+import { byCodePoint } from '../../architecture/contracts.js';
+import { asRelationLabel, mermaidLabel } from './escape.js';
+function freezeIds(ids) {
+    return Object.freeze([...ids].sort(byCodePoint));
+}
+export function comment(text) {
+    return Object.freeze({ kind: 'comment', text: mermaidLabel(text, 200) });
+}
+export function node(input) {
+    if (!input.canonicalNodeIds.length)
+        throw new Error('mermaid_node_without_canonical_id');
+    return Object.freeze({
+        kind: 'node',
+        id: input.id,
+        label: mermaidLabel(input.label),
+        canonicalNodeIds: freezeIds(input.canonicalNodeIds)
+    });
+}
+export function edge(input) {
+    if (!input.canonicalEdgeIds.length)
+        throw new Error('mermaid_edge_without_canonical_id');
+    return Object.freeze({
+        kind: 'edge',
+        from: input.from,
+        to: input.to,
+        relation: asRelationLabel(input.relation),
+        style: input.style ?? 'solid',
+        canonicalEdgeIds: freezeIds(input.canonicalEdgeIds),
+        fromCanonicalId: input.fromCanonicalId,
+        toCanonicalId: input.toCanonicalId
+    });
+}
+export function subgraph(input) {
+    return Object.freeze({
+        kind: 'subgraph',
+        id: input.id,
+        label: mermaidLabel(input.label),
+        canonicalId: input.canonicalId,
+        statements: Object.freeze([...input.statements])
+    });
+}
+export function document(input) {
+    return Object.freeze({
+        kind: 'flowchart',
+        direction: input.direction,
+        title: mermaidLabel(input.title, 120),
+        statements: Object.freeze([...input.statements])
+    });
+}

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

@@ -0,0 +1,43 @@
+import { byCodePoint } from '../../architecture/contracts.js';
+import { buildArchitectureScope, sliceArchitectureGraph } from '../../architecture/slice.js';
+import { emptyProjection, projectFilteredView } from './view-builder.js';
+export function buildChangeImpactView(input) {
+    const seedPaths = input.request?.seedPaths ?? [];
+    const seedNodeIds = input.request?.seedNodeIds ?? [];
+    if (!seedPaths.length && !seedNodeIds.length) {
+        return emptyProjection('change-impact', 'Change impact', 'LR', 'mission_helper: seed paths/node ids required');
+    }
+    const scope = buildArchitectureScope({
+        profile: input.request?.profile ?? 'implementation',
+        seedNodeIds,
+        seedPaths
+    });
+    const slice = sliceArchitectureGraph(input.snapshot, input.policy, scope);
+    const nodeIdSet = new Set(slice.nodeIds);
+    const edgeIdSet = new Set(slice.edgeIds);
+    const sliced = {
+        ...input.snapshot,
+        nodes: input.snapshot.nodes
+            .filter((node) => nodeIdSet.has(node.id))
+            .sort((left, right) => byCodePoint(left.id, right.id)),
+        edges: input.snapshot.edges
+            .filter((edge) => edgeIdSet.has(edge.id))
+            .sort((left, right) => byCodePoint(left.id, right.id)),
+        nodeCount: nodeIdSet.size,
+        edgeCount: edgeIdSet.size
+    };
+    return projectFilteredView({
+        viewId: 'change-impact',
+        snapshot: sliced,
+        policy: input.policy,
+        request: {
+            ...(input.request?.profile ? { profile: input.request.profile } : { profile: 'implementation' }),
+            seedNodeIds: slice.protectedNodeIds,
+            ...(seedPaths.length ? { seedPaths } : {})
+        },
+        filter: {
+            kinds: ['module', 'file', 'symbol', 'test', 'gate', 'command', 'route'],
+            edgeTypes: ['imports', 'calls', 'tests', 'gated_by', 'routes_to', 'depends_on', 'contains']
+        }
+    });
+}

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

@@ -0,0 +1,5 @@
+import { MERMAID_PROJECTION_SCHEMA } from '../../architecture/contracts.js';
+export { MERMAID_PROJECTION_SCHEMA };
+export const GENERATED_HEADER = '%% GENERATED BY SKS. DO NOT EDIT. SOURCE: TriWiki Context Graph + machine-readable control manifests. %%';
+export const MERMAID_TEXT_LIMIT = 50_000;
+export const MERMAID_LABEL_DISPLAY_LIMIT = 96;

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

@@ -0,0 +1,45 @@
+import { MERMAID_LABEL_DISPLAY_LIMIT } from './contracts.js';
+const MERMAID_EMPTY_LABEL = '(unlabeled)';
+const ELLIPSIS = '...';
+const INVISIBLE_FORMAT = /[\u200b-\u200f\u202a-\u202e\u2060-\u2064\u2066-\u2069\ufeff]/g;
+const CONTROL_RANGE = /[\u0000-\u001f\u007f-\u009f]/g;
+const WHITESPACE_RUN = /\s+/g;
+const HOME_PATH = /(?:^|[\s"'])(?:\/Users|\/home)\/[^\s"']+/g;
+const SECRETISH = /\b(?:sk-[A-Za-z0-9_-]{8,}|ghp_[A-Za-z0-9]{20,}|xox[baprs]-[A-Za-z0-9-]{10,})\b/g;
+const MERMAID_ESCAPES = [
+    [/#/g, '#35;'],
+    [/"/g, '#34;'],
+    [/</g, '#60;'],
+    [/>/g, '#62;'],
+    [/\|/g, '#124;'],
+    [/`/g, "'"]
+];
+function boundCodePoints(text, limit) {
+    const points = Array.from(text);
+    if (points.length <= limit)
+        return text;
+    return `${points.slice(0, Math.max(1, limit - ELLIPSIS.length)).join('')}${ELLIPSIS}`;
+}
+export function mermaidLabel(text, displayLimit = MERMAID_LABEL_DISPLAY_LIMIT) {
+    if (!Number.isInteger(displayLimit) || displayLimit < 8) {
+        throw new Error('mermaid_display_limit_out_of_range');
+    }
+    const normalized = String(text ?? '')
+        .normalize('NFC')
+        .replace(INVISIBLE_FORMAT, '')
+        .replace(CONTROL_RANGE, ' ')
+        .replace(HOME_PATH, '[redacted-path]')
+        .replace(SECRETISH, '[redacted-secret]')
+        .replace(WHITESPACE_RUN, ' ')
+        .trim();
+    const bounded = boundCodePoints(normalized, displayLimit);
+    if (!bounded)
+        return MERMAID_EMPTY_LABEL;
+    let escaped = bounded;
+    for (const [pattern, replacement] of MERMAID_ESCAPES)
+        escaped = escaped.replace(pattern, replacement);
+    return escaped;
+}
+export function asRelationLabel(text) {
+    return mermaidLabel(text, 48);
+}

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

@@ -0,0 +1,73 @@
+import { sha256 } from '../../../../fsx.js';
+const BASE32_ALPHABET = 'abcdefghijklmnopqrstuvwxyz234567';
+const DIGEST_CHARS = 12;
+function base32Lower(bytes) {
+    let out = '';
+    let value = 0;
+    let bits = 0;
+    for (const byte of bytes) {
+        value = (value << 8) | byte;
+        bits += 8;
+        while (bits >= 5) {
+            bits -= 5;
+            out += BASE32_ALPHABET.charAt((value >>> bits) & 31);
+        }
+        value &= (1 << bits) - 1;
+    }
+    if (bits > 0)
+        out += BASE32_ALPHABET.charAt((value << (5 - bits)) & 31);
+    return out;
+}
+function digestToken(value, chars) {
+    return base32Lower(Buffer.from(sha256(value), 'hex')).slice(0, chars);
+}
+function joinInjective(parts) {
+    return parts.map((part) => `${part.length}:${part}`).join('');
+}
+export function mermaidNodeId(sourceId) {
+    if (typeof sourceId !== 'string' || sourceId.length === 0) {
+        throw new Error('mermaid_empty_source_id');
+    }
+    for (const length of [DIGEST_CHARS, 16, 24, 32, 64]) {
+        const id = `n_${digestToken(sourceId, length)}`;
+        return id;
+    }
+    throw new Error('MERMAID_NODE_ID_COLLISION');
+}
+export function mermaidSubgraphId(sourceId) {
+    if (typeof sourceId !== 'string' || sourceId.length === 0) {
+        throw new Error('mermaid_empty_subgraph_source_id');
+    }
+    return `sg_${digestToken(sourceId, DIGEST_CHARS)}`;
+}
+export function mermaidEdgeId(fromSourceId, toSourceId, edgeType) {
+    if (!fromSourceId || !toSourceId || !edgeType)
+        throw new Error('mermaid_empty_edge_endpoint');
+    return `e_${digestToken(joinInjective([fromSourceId, toSourceId, edgeType]), DIGEST_CHARS)}`;
+}
+export function assertInjective(sourceIds) {
+    const bySourceId = new Map();
+    const owners = new Map();
+    for (const sourceId of sourceIds) {
+        if (bySourceId.has(sourceId))
+            throw new Error(`mermaid_duplicate_source_id: ${sourceId}`);
+        let assigned = null;
+        for (const length of [DIGEST_CHARS, 16, 24, 32, 64]) {
+            const candidate = `n_${digestToken(sourceId, length)}`;
+            const owner = owners.get(candidate);
+            if (owner === undefined) {
+                owners.set(candidate, sourceId);
+                assigned = candidate;
+                break;
+            }
+            if (owner === sourceId) {
+                assigned = candidate;
+                break;
+            }
+        }
+        if (!assigned)
+            throw new Error(`mermaid_node_id_collision: ${sourceId}`);
+        bySourceId.set(sourceId, assigned);
+    }
+    return bySourceId;
+}

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

@@ -0,0 +1,113 @@
+import { GLOBAL_ARCHITECTURE_MAP_VIEW_IDS } from '../../architecture/contracts.js';
+import { analyzeArchitectureFindings } from '../../architecture/findings.js';
+import { buildArchitectureInputBundle, policyContentHash } from '../../architecture/input-bundle.js';
+import { computeArchitectureMetrics } from '../../architecture/metrics.js';
+import { mergeGraphWithTopology } from '../../architecture/topology-overlay.js';
+import { buildArchitectureMapManifest } from './manifest.js';
+import { buildModuleDependencyView } from './module-dependency.js';
+import { buildProjectTopologyView } from './project-topology.js';
+import { buildPublicSurfaceView } from './public-surface.js';
+import { buildRiskDomainsView } from './risk-domains.js';
+import { buildRuntimeControlView } from './runtime-control.js';
+import { buildSsotProvenanceView } from './ssot-provenance.js';
+import { buildVerificationCoverageView } from './verification-coverage.js';
+import { viewSpecFor } from './view-specs.js';
+export * from './contracts.js';
+export * from './ast.js';
+export * from './ids.js';
+export * from './escape.js';
+export * from './serializer.js';
+export * from './selection-ledger.js';
+export * from './reduce.js';
+export * from './view-specs.js';
+export * from './view-builder.js';
+export * from './view-builder-common.js';
+export * from './project-topology.js';
+export * from './module-dependency.js';
+export * from './public-surface.js';
+export * from './ssot-provenance.js';
+export * from './runtime-control.js';
+export * from './verification-coverage.js';
+export * from './risk-domains.js';
+export * from './change-impact.js';
+export * from './architecture-delta.js';
+export * from './ownership-workstream.js';
+export * from './manifest.js';
+const GLOBAL_BUILDERS = {
+    'project-topology': buildProjectTopologyView,
+    'module-dependency': buildModuleDependencyView,
+    'public-surface': buildPublicSurfaceView,
+    'ssot-provenance': buildSsotProvenanceView,
+    'runtime-control': buildRuntimeControlView,
+    'verification-coverage': buildVerificationCoverageView,
+    'risk-domains': buildRiskDomainsView
+};
+function asProjection(built) {
+    return 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 buildArchitectureMapViews(snapshot, policy, options = {}) {
+    const rootId = options.rootId ?? 'workspace';
+    const bundle = buildArchitectureInputBundle({
+        rootId,
+        graph: snapshot,
+        policy,
+        topologyMode: 'from-snapshot'
+    });
+    const merged = mergeGraphWithTopology(bundle.graph, bundle.topology);
+    const workingSnapshot = {
+        ...snapshot,
+        nodes: [...merged.nodes],
+        edges: [...merged.edges],
+        nodeCount: merged.nodes.length,
+        edgeCount: merged.edges.length
+    };
+    const views = [];
+    for (const viewId of GLOBAL_ARCHITECTURE_MAP_VIEW_IDS) {
+        const built = GLOBAL_BUILDERS[viewId]({ snapshot: workingSnapshot, policy });
+        const spec = viewSpecFor(viewId);
+        views.push(Object.freeze({
+            viewId,
+            filename: spec.filename,
+            text: built.text,
+            projection: asProjection(built)
+        }));
+    }
+    const manifest = buildArchitectureMapManifest({
+        views: views.map((view) => ({
+            viewId: view.viewId,
+            projection: view.projection,
+            text: view.text
+        })),
+        graphHash: bundle.graphHash,
+        policyHash: bundle.policyHash.length ? bundle.policyHash : policyContentHash(policy),
+        topologyHash: bundle.topologyHash,
+        inputBundleHash: bundle.canonicalHash,
+        analyzerVersion: bundle.analyzerVersion,
+        serializerVersion: bundle.serializerVersion,
+        missionId: options.missionId ?? null
+    });
+    const findings = analyzeArchitectureFindings({ bundle, policy });
+    const metrics = computeArchitectureMetrics({
+        graph: workingSnapshot,
+        topology: bundle.topology,
+        layerViolationCount: findings.filter((finding) => finding.code === 'forbidden_dependency').length,
+        ssotCollisionCount: findings.filter((finding) => finding.code === 'ssot_collision').length,
+        authorityBypassCount: findings.filter((finding) => finding.code === 'authority_bypass').length,
+        protectedVerificationGapCount: findings.filter((finding) => finding.code === 'protected_verification_gap').length
+    });
+    return Object.freeze({
+        views: Object.freeze(views),
+        manifest,
+        metrics,
+        findings
+    });
+}

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

@@ -0,0 +1,37 @@
+import { ARCHITECTURE_ANALYZER_VERSION, ARCHITECTURE_MAP_MANIFEST_SCHEMA, ARCHITECTURE_SERIALIZER_VERSION, byCodePoint } from '../../architecture/contracts.js';
+import { hashCanonical } from '../../architecture/fingerprint.js';
+export function buildArchitectureMapManifest(input) {
+    const sorted = [...input.views].sort((left, right) => byCodePoint(left.viewId, right.viewId));
+    const viewRows = Object.freeze(sorted.map((entry) => Object.freeze({
+        viewId: entry.viewId,
+        contentHash: entry.projection.contentHash,
+        byteLength: entry.projection.byteLength
+    })));
+    const projectionAccounting = Object.freeze(Object.fromEntries(sorted.map((entry) => [entry.viewId, entry.projection.accounting])));
+    const topologyHash = input.topologyHash ?? '';
+    const inputBundleHash = input.inputBundleHash ?? '';
+    const analyzerVersion = input.analyzerVersion ?? ARCHITECTURE_ANALYZER_VERSION;
+    const serializerVersion = input.serializerVersion ?? ARCHITECTURE_SERIALIZER_VERSION;
+    const sourceBinding = Object.freeze({
+        graphHash: input.graphHash,
+        topologyHash,
+        policyHash: input.policyHash
+    });
+    const payload = {
+        schema: ARCHITECTURE_MAP_MANIFEST_SCHEMA,
+        missionId: input.missionId ?? null,
+        graphHash: input.graphHash,
+        topologyHash,
+        policyHash: input.policyHash,
+        inputBundleHash,
+        analyzerVersion,
+        serializerVersion,
+        views: viewRows,
+        projectionAccounting,
+        sourceBinding
+    };
+    return Object.freeze({
+        ...payload,
+        canonicalHash: hashCanonical(payload)
+    });
+}

package/dist/core/triwiki/context-graph/projections/mermaid/module-dependency.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 buildModuleDependencyView(input) {
+    return projectFilteredView({
+        viewId: 'module-dependency',
+        snapshot: input.snapshot,
+        policy: input.policy,
+        ...(input.request ? { request: input.request } : {}),
+        filter: {
+            kinds: ['module'],
+            edgeTypes: ['imports', 'reexports']
+        },
+        groupByLayer: true,
+        layerOf: (node, policy) => layerForModule(policy, modulePath(node.id, node.path))
+    });
+}