al-sem 0.0.1

package/src/index/variable-indexer.ts

@@ -0,0 +1,134 @@
+import type { ParameterSymbol, RecordVariable, VariableSymbol } from "../model/entities.ts";
+import type { SourceAnchor } from "../model/identity.ts";
+import type { RoutineId } from "../model/ids.ts";
+import type { Node } from "../parser/native/wrapper.ts";
+import { extractInitializer } from "./variable-initializer-extractor.ts";
+import { canonicalizeTypeText, normalizeDeclaredType } from "./variable-type-normalizer.ts";
+
+/**
+ * Build a unified `VariableSymbol[]` for a routine's lexical scope.
+ *
+ * Output order:
+ *  1. Parameters in declaration order (parameterIndex ascending).
+ *  2. Local var declarations in source order.
+ *
+ * Records appear here AND in the existing `IntraproceduralFeatures.recordVariables`
+ * for backward compatibility. The `recordVariables` argument is used to mirror
+ * `tableId` resolution onto record-typed `VariableSymbol` entries (so callers
+ * don't have to cross-reference).
+ *
+ * Parameters do NOT carry initializers (body assignments to parameters are
+ * re-assignments, not initial assignments — capturing them would muddy the
+ * "where does this var's value come from?" semantics).
+ *
+ * Never throws.
+ */
+export function extractVariables(
+	routineNode: Node,
+	routineId: RoutineId,
+	sourceUnitId: string,
+	parameters: ParameterSymbol[],
+	recordVariables: RecordVariable[],
+): VariableSymbol[] {
+	try {
+		const recordByNameLc = new Map(recordVariables.map((rv) => [rv.name.toLowerCase(), rv]));
+		const out: VariableSymbol[] = [];
+
+		// 1. Parameters — one VariableSymbol per ParameterSymbol.
+		for (const p of parameters) {
+			const lcName = p.name.toLowerCase();
+			const recordMirror = recordByNameLc.get(lcName);
+			const sym: VariableSymbol = {
+				name: lcName,
+				declaredType: canonicalizeTypeText(p.typeText),
+				isParameter: true,
+				parameterIndex: p.index,
+				sourceAnchor: syntheticParamAnchor(routineId, sourceUnitId),
+				...(recordMirror?.tableId !== undefined ? { tableId: recordMirror.tableId } : {}),
+			};
+			out.push(sym);
+		}
+
+		// 2. Locals — walk `var_section` blocks in the routine node.
+		const bodyNode = findCodeBlock(routineNode);
+		for (const decl of findVariableDeclarations(routineNode)) {
+			const nameNode = decl.childForFieldName?.("name") ?? decl.namedChild(0);
+			if (nameNode === null || nameNode === undefined) continue;
+			const nameText = (nameNode as { text?: unknown }).text;
+			if (typeof nameText !== "string") continue;
+			const lcName = nameText.toLowerCase();
+
+			// Skip parameter shadowing — parameters already emitted above.
+			if (out.some((v) => v.isParameter && v.name === lcName)) continue;
+
+			const declaredType = normalizeDeclaredType(decl);
+			const recordMirror = recordByNameLc.get(lcName);
+			const initializer = bodyNode !== null ? extractInitializer(bodyNode, lcName) : undefined;
+
+			const sym: VariableSymbol = {
+				name: lcName,
+				declaredType,
+				isParameter: false,
+				sourceAnchor: anchorFromNode(decl, sourceUnitId, routineId),
+				...(recordMirror?.tableId !== undefined ? { tableId: recordMirror.tableId } : {}),
+				...(initializer !== undefined ? { initializer } : {}),
+			};
+			out.push(sym);
+		}
+
+		return out;
+	} catch {
+		return [];
+	}
+}
+
+function findCodeBlock(routineNode: Node): Node | null {
+	for (let i = 0; i < routineNode.namedChildCount; i++) {
+		const c = routineNode.namedChild(i);
+		if (c === null) continue;
+		if (c.type === "code_block") return c;
+	}
+	return null;
+}
+
+function findVariableDeclarations(routineNode: Node): Node[] {
+	const out: Node[] = [];
+	function visit(n: Node) {
+		if (n.type === "variable_declaration") {
+			out.push(n);
+			return; // don't descend into a found declaration
+		}
+		// Don't descend into the routine body — locals are declared in
+		// `var_section` at the routine level, not nested inside the body.
+		if (n.type === "code_block") return;
+		for (let i = 0; i < n.namedChildCount; i++) {
+			const c = n.namedChild(i);
+			if (c !== null) visit(c);
+		}
+	}
+	visit(routineNode);
+	return out;
+}
+
+function syntheticParamAnchor(routineId: RoutineId, sourceUnitId: string): SourceAnchor {
+	return {
+		sourceUnitId,
+		range: { startLine: 0, startColumn: 0, endLine: 0, endColumn: 0 },
+		enclosingRoutineId: routineId,
+		syntaxKind: "parameter",
+	};
+}
+
+function anchorFromNode(node: Node, sourceUnitId: string, routineId: RoutineId): SourceAnchor {
+	return {
+		sourceUnitId,
+		range: {
+			startLine: node.startPosition.row,
+			startColumn: node.startPosition.column,
+			endLine: node.endPosition.row,
+			endColumn: node.endPosition.column,
+		},
+		enclosingRoutineId: routineId,
+		syntaxKind: "variable_declaration",
+	};
+}

package/src/index/variable-initializer-extractor.ts

@@ -0,0 +1,155 @@
+import type { ValueSource } from "../model/capability.ts";
+import type { Node } from "../parser/native/wrapper.ts";
+
+/**
+ * Walk a routine body and return the simplest `ValueSource` describing the
+ * initial assignment to a named variable. Phase 0b-α captures ONE HOP:
+ *  - `X := 'literal'`          → `{kind: "literal", value: "literal"}`
+ *  - `X := 42`                 → `{kind: "literal", value: "42"}`
+ *  - `X := MyEnum::Value`      → `{kind: "enum", enumName, member}`
+ *  - `X := OtherVar`           → `{kind: "constant-var", varName: "othervar",
+ *                                   initializer: {kind: "unknown"}}`
+ *  - any other RHS             → `{kind: "expression"}`
+ *  - no assignment found       → `undefined`
+ *
+ * First assignment wins. Phase 0b-β chases chains.
+ *
+ * MUST NEVER throw.
+ *
+ * Probe findings (assignment_statement):
+ *  - LHS field: "left"  → identifier node
+ *  - RHS field: "right" → string_literal | integer | qualified_enum_value | identifier | …
+ *  - qualified_enum_value: namedChild(0) = quoted_identifier (includes ""), namedChild(1) = identifier
+ *
+ * @param bodyNode the routine's `code_block` AST node
+ * @param varNameLowercased the variable name, already lowercased
+ */
+export function extractInitializer(
+	bodyNode: Node,
+	varNameLowercased: string,
+): ValueSource | undefined {
+	try {
+		const assignment = findFirstAssignmentTo(bodyNode, varNameLowercased);
+		if (assignment === null) {
+			return undefined;
+		}
+		const rhs = getAssignmentRhs(assignment);
+		if (rhs === null) {
+			return undefined;
+		}
+		return classifyRhs(rhs);
+	} catch {
+		return undefined;
+	}
+}
+
+function findFirstAssignmentTo(node: Node, varNameLowercased: string): Node | null {
+	if (node.type === "assignment_statement") {
+		const targetText = getAssignmentTargetText(node);
+		if (targetText !== null && targetText.toLowerCase() === varNameLowercased) {
+			return node;
+		}
+	}
+	for (let i = 0; i < node.namedChildCount; i++) {
+		const child = node.namedChild(i);
+		if (child === null) continue;
+		const found = findFirstAssignmentTo(child, varNameLowercased);
+		if (found !== null) return found;
+	}
+	return null;
+}
+
+function getAssignmentTargetText(assignmentNode: Node): string | null {
+	// Probe confirmed: field "left" → identifier node
+	const target =
+		assignmentNode.childForFieldName?.("left") ??
+		assignmentNode.childForFieldName?.("target") ??
+		assignmentNode.namedChild(0);
+	if (target === null || target === undefined) return null;
+	const text = (target as { text?: unknown }).text;
+	return typeof text === "string" ? text : null;
+}
+
+function getAssignmentRhs(assignmentNode: Node): Node | null {
+	// Probe confirmed: field "right" → RHS node
+	const rhs =
+		assignmentNode.childForFieldName?.("right") ??
+		assignmentNode.childForFieldName?.("value") ??
+		assignmentNode.namedChild(assignmentNode.namedChildCount - 1);
+	return (rhs ?? null) as Node | null;
+}
+
+function classifyRhs(rhs: Node): ValueSource {
+	const type = rhs.type;
+
+	// Probe confirmed: string literal type is "string_literal" (includes surrounding quotes)
+	if (type === "string_literal" || type === "string_literal_value" || type === "text_literal") {
+		return { kind: "literal", value: stripSingleQuotes(rhs.text) };
+	}
+
+	// Probe confirmed: integer literal type is "integer" (not "integer_literal")
+	if (
+		type === "integer" ||
+		type === "integer_literal" ||
+		type === "decimal_literal" ||
+		type === "number_literal" ||
+		type === "decimal"
+	) {
+		return { kind: "literal", value: rhs.text.trim() };
+	}
+
+	if (type === "boolean_literal" || type === "true" || type === "false") {
+		return { kind: "literal", value: rhs.text.trim() };
+	}
+
+	// Probe confirmed: enum-qualified node type is "qualified_enum_value"
+	// namedChild(0) = quoted_identifier (includes surrounding double-quotes)
+	// namedChild(1) = identifier (member name)
+	if (type === "qualified_enum_value") {
+		const parts = parseQualifiedEnum(rhs);
+		if (parts !== null) {
+			return { kind: "enum", enumName: parts.enumName, member: parts.member };
+		}
+		return { kind: "expression" };
+	}
+
+	// Bare identifier → var-to-var reference (one hop)
+	if (type === "identifier") {
+		return {
+			kind: "constant-var",
+			varName: rhs.text.toLowerCase(),
+			initializer: { kind: "unknown" },
+		};
+	}
+
+	// Anything else (function call, member expression, binary expression, etc.)
+	return { kind: "expression" };
+}
+
+function stripSingleQuotes(s: string): string {
+	const t = s.trim();
+	if (t.length >= 2 && t[0] === "'" && t[t.length - 1] === "'") {
+		return t.slice(1, -1);
+	}
+	return t;
+}
+
+function stripDoubleQuotes(s: string): string {
+	const t = s.trim();
+	if (t.length >= 2 && t[0] === '"' && t[t.length - 1] === '"') {
+		return t.slice(1, -1);
+	}
+	return t;
+}
+
+function parseQualifiedEnum(node: Node): { enumName: string; member: string } | null {
+	// Probe confirmed: namedChild(0) = quoted_identifier, namedChild(1) = identifier
+	const enumNameNode = node.namedChild(0);
+	const memberNode = node.namedChild(node.namedChildCount - 1);
+	if (enumNameNode === null || enumNameNode === undefined) return null;
+	if (memberNode === null || memberNode === undefined) return null;
+	// quoted_identifier text includes surrounding double-quotes: `"Document Type"`
+	const enumName = stripDoubleQuotes((enumNameNode as { text: string }).text);
+	const member = (memberNode as { text: string }).text;
+	return { enumName, member };
+}

package/src/index/variable-type-normalizer.ts

@@ -0,0 +1,83 @@
+import type { Node } from "../parser/native/wrapper.ts";
+
+/**
+ * Convert a tree-sitter-al `variable_declaration` node into a normalized
+ * AL type string. Drives Phase 0b-β capability-extractor dispatch (member-
+ * call receivers resolve their `declaredType` and route to the appropriate
+ * family extractor).
+ *
+ * Output shape examples (canonical reference — must match test fixtures):
+ *  - `"HttpClient"` (built-in type, no qualifier)
+ *  - `"Record Customer"` (record, unquoted single-word table name)
+ *  - `"Record \"Sales Line\""` (record, quoted multi-word table name)
+ *  - `"Codeunit \"Sales-Post\""` (codeunit, quoted name with hyphen)
+ *  - `"Page \"Customer Card\""`
+ *  - `"Text"` / `"Text[100]"` (primitive with optional length)
+ *  - `"Integer"`, `"Decimal"`, `"Boolean"`, etc.
+ *
+ * The function MUST NEVER throw on malformed declarations. Returns
+ * `"unknown"` when the type-expression child is missing or unrecognizable.
+ * Phase 0b-β capability extractors treat `"unknown"` as a coverage gap.
+ *
+ * AST probe findings (tree-sitter-al):
+ *   - `variable_declaration` exposes the type under field name `"type"`,
+ *     which maps to a `type_specification` node.
+ *   - `type_specification` children include: `basic_type`, `record_type`,
+ *     `object_reference_type`, `text_type` (and others for future types).
+ *   - `typeNode.text` gives the verbatim source text, e.g. `Record "Sales Line"`.
+ *   - Whitespace canonicalization (collapsing runs, preserving quoted content)
+ *     is sufficient for a stable normalized string.
+ */
+export function normalizeDeclaredType(variableDeclarationNode: Node): string {
+	try {
+		// The grammar exposes the type_specification under field "type".
+		const typeNode = variableDeclarationNode.childForFieldName("type");
+		if (typeNode === null || typeNode === undefined) {
+			return "unknown";
+		}
+
+		const raw = typeNode.text;
+		if (typeof raw !== "string" || raw.length === 0) {
+			return "unknown";
+		}
+
+		return canonicalizeTypeText(raw);
+	} catch {
+		return "unknown";
+	}
+}
+
+/**
+ * Trim and collapse internal whitespace runs to a single space, while
+ * preserving quoted AL identifiers (`"Sales Line"`) verbatim — they may
+ * contain spaces that must not be collapsed or stripped.
+ */
+export function canonicalizeTypeText(raw: string): string {
+	let out = "";
+	let inQuotes = false;
+	let lastWasSpace = false;
+
+	for (const ch of raw.trim()) {
+		if (ch === '"') {
+			inQuotes = !inQuotes;
+			out += ch;
+			lastWasSpace = false;
+			continue;
+		}
+		if (inQuotes) {
+			out += ch;
+			continue;
+		}
+		if (ch === " " || ch === "\t" || ch === "\n" || ch === "\r") {
+			if (!lastWasSpace) {
+				out += " ";
+				lastWasSpace = true;
+			}
+			continue;
+		}
+		out += ch;
+		lastWasSpace = false;
+	}
+
+	return out;
+}

package/src/index.ts

@@ -0,0 +1,267 @@
+// al-sem: Static semantic analysis engine for Business Central AL code
+// Public entry point and library export surface.
+
+export * from "./model/index.ts";
+export type { SourceUnit, SourceProvider } from "./providers/types.ts";
+export { ExternalSourceProvider } from "./providers/external.ts";
+export {
+	buildCompactReport,
+	formatCompactJson,
+	type CompactReport,
+} from "./cli/format-compact-json.ts";
+export { formatSarif } from "./cli/format-sarif.ts";
+export {
+	projectFinding,
+	type FindingLocation,
+	type FindingSummary,
+} from "./projection/finding-summary.ts";
+export { filterFindings, type FilterOptions } from "./projection/finding-filters.ts";
+export {
+	groupFindings,
+	type FindingGroup,
+	type GroupBy,
+} from "./projection/finding-groups.ts";
+export { fingerprintOf } from "./projection/finding-fingerprint.ts";
+export { rollupFindings, type RolledOrSingle } from "./projection/rollup-findings.ts";
+export {
+	applyBaseline,
+	loadBaseline,
+	saveBaseline,
+	type BaselineFile,
+} from "./cli/baseline.ts";
+export { computeExitCode, parseFailOn } from "./cli/exit-code.ts";
+
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { loadRootsConfig } from "./config/roots-config.ts";
+import { withDependencyArtifacts } from "./deps/dependency-artifact.ts";
+import { resolveDependencyArtifacts } from "./deps/dependency-resolver.ts";
+import {
+	parseWorkspaceDependencies,
+	parseWorkspaceInternalsVisibleTo,
+} from "./deps/workspace-dependencies.ts";
+import {
+	ALL_DETECTORS,
+	DEFAULT_DETECTORS,
+	type Detector,
+	runDetectors,
+} from "./detectors/registry.ts";
+import { buildCombinedGraph } from "./engine/combined-graph.ts";
+import { overlayConfigRoots } from "./engine/root-classifier-overlay.ts";
+import { classifyRoots } from "./engine/root-classifier.ts";
+import { computeSummaries } from "./engine/summary-engine.ts";
+import { buildSemanticIndex } from "./index/indexer.ts";
+import type { DetectorStats, Diagnostic, Finding } from "./model/finding.ts";
+import type { SemanticIndex, SemanticModel } from "./model/model.ts";
+import { makeLap } from "./perf/profiler.ts";
+import { discoverSources } from "./providers/discover.ts";
+import type { ExternalSourceProvider } from "./providers/external.ts";
+import type { SourceUnit } from "./providers/types.ts";
+import { resolveModel } from "./resolve/resolver.ts";
+import type { ManifestDependency } from "./symbols/app-manifest.ts";
+
+export interface AnalyzeWorkspaceOptions {
+	workspaceRoot: string;
+	alpackagesDir?: string;
+	externalProvider?: ExternalSourceProvider;
+	/** When true, createdAt is pinned to the epoch so output is byte-deterministic. */
+	deterministic?: boolean;
+	/** Skip the behavioral dependency cold run — structural ABI only, conservative effects. */
+	noDepSummaries?: boolean;
+	/** Override the dependency cache directory (default ~/.al-sem/cache/). */
+	dependencyCacheDir?: string;
+	/**
+	 * Detector registry to run. Default: `DEFAULT_DETECTORS`. Pass `ALL_DETECTORS` to
+	 * include opt-in detectors (currently: D40 — see `OPT_IN_DETECTORS`). Callers can
+	 * also pass a custom `Detector[]` for fine-grained selection.
+	 */
+	detectors?: Detector[];
+	/**
+	 * If true, skip loading `roots.config.json` even if it exists. §4.3 Task 7
+	 * surfaces this via the `--no-roots-config` CLI flag; the snapshot pipeline
+	 * records the ignore decision so diff can distinguish "no config" from
+	 * "config ignored". Overlay resolution is also skipped — output equals AST.
+	 */
+	noRootsConfig?: boolean;
+}
+
+export interface AnalyzeWorkspaceResult {
+	model: SemanticModel;
+	findings: Finding[];
+	diagnostics: Diagnostic[];
+	detectorStats: DetectorStats[];
+}
+
+/** The raw, pre-resolve product of discovery + indexing — input to `resolveModel`. */
+export interface IndexWorkspaceResult {
+	index: SemanticIndex;
+	/** Source units from discovery, needed by the resolver for coverage. */
+	units: SourceUnit[];
+	/** Index-phase diagnostics only — what resolveModel's coverage accounting consumes. */
+	indexDiagnostics: Diagnostic[];
+	/** Discovery + index diagnostics merged — the full list for callers. */
+	diagnostics: Diagnostic[];
+}
+
+/**
+ * Discovers sources, parses, and indexes them into a raw `SemanticIndex` — without
+ * running the resolver. `analyzeWorkspace` builds on this; tests of `resolveModel` use
+ * it to obtain a genuinely unresolved index. Never throws — failures surface as
+ * diagnostics.
+ */
+export async function indexWorkspace(
+	options: AnalyzeWorkspaceOptions,
+): Promise<IndexWorkspaceResult> {
+	// Normalize paths so discoverSources hashes a canonical absolute path.
+	const workspaceRoot = resolve(options.workspaceRoot);
+	const alpackagesDir = options.alpackagesDir ? resolve(options.alpackagesDir) : undefined;
+
+	const discovery = await discoverSources({
+		workspaceRoot,
+		alpackagesDir,
+		externalProvider: options.externalProvider,
+	});
+
+	const identity = options.deterministic
+		? discovery.identity
+		: { ...discovery.identity, createdAt: new Date().toISOString() };
+
+	const { index, diagnostics } = await buildSemanticIndex(
+		discovery.units,
+		identity,
+		discovery.modelInstanceId,
+	);
+
+	const allDiagnostics: Diagnostic[] = [
+		...discovery.diagnostics.map(
+			(d): Diagnostic => ({
+				severity: d.severity,
+				stage: "discover",
+				message: d.message,
+				sourceRef: d.sourceRef,
+			}),
+		),
+		...diagnostics,
+	];
+
+	return {
+		index,
+		units: discovery.units,
+		indexDiagnostics: diagnostics,
+		diagnostics: allDiagnostics,
+	};
+}
+
+/**
+ * Discovers, indexes, resolves, summarises, and runs detectors over a workspace — the full
+ * pipeline. Returns the SemanticModel (with routine summaries populated), the Finding[], and
+ * all diagnostics. Never throws — failures surface as diagnostics.
+ */
+export async function analyzeWorkspace(
+	options: AnalyzeWorkspaceOptions,
+): Promise<AnalyzeWorkspaceResult> {
+	// Coarse phase profiler — routes through the structured profiler (stderr when
+	// AL_SEM_PROFILE=1; captured by the benchmark harness via collectPhases). Zero cost when off.
+	const alap = makeLap("analyze:");
+
+	const workspace = await indexWorkspace(options); // raw, pre-resolve — contract unchanged
+	alap("indexWorkspace");
+
+	// --- L1.5: resolve dependency artifacts (cache hit | cold run) ---
+	// Default to `<workspaceRoot>/.alpackages` (BC compiler convention) when not given explicitly,
+	// so the CLI's common `al-sem analyze <workspace>` form picks up deps without an extra flag.
+	const workspaceRoot = resolve(options.workspaceRoot);
+	const alpackagesDir =
+		options.alpackagesDir !== undefined
+			? resolve(options.alpackagesDir)
+			: existsSync(join(workspaceRoot, ".alpackages"))
+				? join(workspaceRoot, ".alpackages")
+				: undefined;
+	let appJsonText = "";
+	try {
+		appJsonText = readFileSync(join(workspaceRoot, "app.json"), "utf8");
+	} catch {
+		/* no app.json — parseWorkspaceDependencies returns [] */
+	}
+	const workspaceDeps: ManifestDependency[] = parseWorkspaceDependencies(appJsonText);
+	let depArtifacts: Awaited<ReturnType<typeof resolveDependencyArtifacts>> = {
+		artifacts: [],
+		diagnostics: [],
+	};
+	if (alpackagesDir !== undefined) {
+		depArtifacts = await resolveDependencyArtifacts(alpackagesDir, workspaceDeps, {
+			cacheDir: options.dependencyCacheDir,
+			noDepSummaries: options.noDepSummaries,
+		});
+	}
+	alap("resolveDependencyArtifacts");
+
+	// --- merge + run the workspace resolve/summarize/detect stages over the merged index ---
+	const analysisIndex = withDependencyArtifacts(workspace.index, depArtifacts.artifacts);
+	const model = resolveModel(analysisIndex, workspace.units, workspace.indexDiagnostics);
+	model.identity.primaryDependencies = workspaceDeps;
+	model.identity.primaryInternalsVisibleTo = parseWorkspaceInternalsVisibleTo(appJsonText);
+	alap("resolveModel");
+
+	const graph = buildCombinedGraph(model);
+	alap("buildCombinedGraph");
+	const summarizeDiagnostics: Diagnostic[] = [];
+	computeSummaries(model, graph, summarizeDiagnostics);
+	alap("computeSummaries");
+
+	// §4.3 — derive AST classifications, then merge any roots.config.json
+	// overlay on top. The overlay is pure; only `analyzeWorkspace` does the
+	// file I/O (via `loadRootsConfig`). `noRootsConfig` short-circuits the
+	// loader entirely (Task 7 wires the CLI flag).
+	const astRoots = classifyRoots(model);
+	const loadedRootsConfig = options.noRootsConfig
+		? {
+				config: undefined,
+				contentHash: undefined,
+				path: undefined,
+				diagnostics: [] as Diagnostic[],
+			}
+		: loadRootsConfig(workspaceRoot);
+	const { roots, diagnostics: overlayDiagnostics } = overlayConfigRoots(
+		astRoots,
+		loadedRootsConfig.config,
+		model,
+	);
+	model.rootClassifications = roots;
+	if (loadedRootsConfig.path !== undefined && loadedRootsConfig.contentHash !== undefined) {
+		model.identity.rootsConfig = {
+			path: loadedRootsConfig.path,
+			contentHash: loadedRootsConfig.contentHash,
+		};
+	}
+	alap("classifyRoots+overlay");
+
+	const {
+		findings,
+		diagnostics: detectDiagnostics,
+		detectorStats,
+	} = runDetectors(model, graph, options.detectors);
+	alap("runDetectors");
+
+	return {
+		model,
+		findings,
+		diagnostics: [
+			...workspace.diagnostics,
+			...depArtifacts.diagnostics,
+			...summarizeDiagnostics,
+			...loadedRootsConfig.diagnostics,
+			...overlayDiagnostics,
+			...detectDiagnostics,
+		],
+		detectorStats,
+	};
+}
+
+export { composeSnapshot } from "./snapshot/compose.ts";
+export type { CapabilitySnapshot, SnapshotFormat, SnapshotShardingMode } from "./snapshot/types.ts";
+export { serializeJson } from "./snapshot/serialize-json.ts";
+export { serializeCbor } from "./snapshot/serialize-cbor.ts";
+export { serializeCborGz } from "./snapshot/serialize-cbor-gz.ts";
+export { serializeSharded } from "./snapshot/shard.ts";
+export { deserializeSnapshot } from "./snapshot/deserialize.ts";