al-sem 0.0.1

package/src/providers/workspace.ts

@@ -0,0 +1,117 @@
+import { readFileSync } from "node:fs";
+import { readdir } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+import { sha256OfStrings } from "../hash.ts";
+import type { AppIdentity } from "../model/identity.ts";
+import type { ProviderDiagnostic, ProviderResult, SourceProvider, SourceUnit } from "./types.ts";
+
+/**
+ * Directory names the walk skips. Kept deliberately minimal: only directories
+ * that NEVER carry user-authored source. `node_modules` is the JS-tooling cache
+ * (large; never AL); `.alpackages` is read separately by the app-package
+ * reader as binary `.app` files (walking it as a directory would surface those
+ * binary payloads, which the `.al` extension filter ignores anyway, but
+ * skipping avoids the no-op walk on potentially thousands of entries).
+ *
+ * Everything else — including dot-prefixed directories the user puts in their
+ * workspace — is walked. A folder is just a folder; its name carries no
+ * semantic meaning for analysis.
+ */
+const SKIP_DIR_EXACT: ReadonlySet<string> = new Set(["node_modules", ".alpackages"]);
+
+/** Recursively list files under a directory. */
+async function walk(dir: string): Promise<string[]> {
+	const out: string[] = [];
+	let entries: { name: string; isDirectory(): boolean }[];
+	try {
+		entries = await readdir(dir, { withFileTypes: true });
+	} catch {
+		return out;
+	}
+	for (const entry of entries) {
+		const full = join(dir, entry.name);
+		if (entry.isDirectory()) {
+			if (SKIP_DIR_EXACT.has(entry.name)) continue;
+			out.push(...(await walk(full)));
+		} else {
+			out.push(full);
+		}
+	}
+	return out;
+}
+
+/** Enumerates .al files in a workspace directory and reads its app.json identity. */
+export class WorkspaceProvider implements SourceProvider {
+	readonly name = "workspace" as const;
+
+	async collect(rootPath: string): Promise<ProviderResult> {
+		const diagnostics: ProviderDiagnostic[] = [];
+
+		// --- app.json identity ---
+		let appGuid = "unknown";
+		let appName = "unknown";
+		let appPublisher = "unknown";
+		let appVersion = "0.0.0.0";
+		try {
+			const appJsonRaw = readFileSync(join(rootPath, "app.json"), "utf8");
+			const appJson = JSON.parse(appJsonRaw) as {
+				id?: string;
+				name?: string;
+				publisher?: string;
+				version?: string;
+			};
+			appGuid = appJson.id ?? appGuid;
+			appName = appJson.name ?? appName;
+			appPublisher = appJson.publisher ?? appPublisher;
+			appVersion = appJson.version ?? appVersion;
+		} catch {
+			diagnostics.push({
+				severity: "warning",
+				message: `No readable app.json at ${rootPath} — workspace app identity unknown`,
+				sourceRef: rootPath,
+			});
+		}
+
+		// --- enumerate .al files ---
+		const allFiles = await walk(rootPath);
+		const units: SourceUnit[] = [];
+		const contents: string[] = [];
+		for (const absPath of allFiles) {
+			if (!absPath.toLowerCase().endsWith(".al")) continue;
+			let content: string;
+			try {
+				content = readFileSync(absPath, "utf8");
+			} catch (err) {
+				diagnostics.push({
+					severity: "warning",
+					message: `Could not read ${absPath}: ${(err as Error).message}`,
+					sourceRef: absPath,
+				});
+				continue;
+			}
+			const relativePath = relative(rootPath, absPath).split(sep).join("/");
+			units.push({
+				id: `ws:${relativePath}`,
+				kind: "source",
+				appGuid,
+				relativePath,
+				absolutePath: absPath,
+				content,
+				sourceProvider: "workspace",
+				analysisRole: "primary",
+			});
+			contents.push(content);
+		}
+
+		const identity: AppIdentity = {
+			appGuid,
+			publisher: appPublisher,
+			name: appName,
+			version: appVersion,
+			sourceAggregateHash: sha256OfStrings(contents.sort()),
+			sourceKind: "workspace",
+		};
+
+		return { units, apps: [identity], diagnostics };
+	}
+}

package/src/resolve/call-resolver.ts

@@ -0,0 +1,117 @@
+import type { ObjectRunKind } from "../model/callee.ts";
+import type { CallSite, Routine } from "../model/entities.ts";
+import { type CallEdge, type DispatchKind, TREE_SITTER_EVIDENCE } from "../model/graph.ts";
+import type { SemanticIndex } from "../model/model.ts";
+import type { SymbolTable } from "./symbol-table.ts";
+
+/** Map an object-run objectKind to its CallEdge dispatch kind. */
+function objectRunDispatchKind(objectKind: ObjectRunKind): DispatchKind {
+	if (objectKind === "Page") return "page-run";
+	if (objectKind === "Report") return "report-run";
+	return "codeunit-run";
+}
+
+/**
+ * Upgrade a callsite's argumentBindings with callee-side var-ness once the callee
+ * is known. This upgrades `calleeParameterIsVar` and sets `bindingResolution` to
+ * "resolved" for any binding that was previously "unresolved-callee".
+ * Bindings with `bindingResolution === "non-record-arg"` are left untouched.
+ *
+ * See CallSite.argumentBindings JSDoc in entities.ts for the mutation contract:
+ * this function is the sole permitted writer to existing bindings, and
+ * re-entrant resolution is unsupported. The assertion below makes any future
+ * double-upgrade fail loudly instead of silently corrupting bindings.
+ */
+function upgradeBindings(callSite: CallSite, calleeRoutine: Routine): void {
+	// Sanity: re-running upgradeBindings on the same callsite is unsound (see
+	// entities.ts CallSite.argumentBindings mutation contract). Cheap dev-time check:
+	for (const binding of callSite.argumentBindings) {
+		if (binding.bindingResolution === "resolved" || binding.bindingResolution === "ambiguous") {
+			throw new Error(
+				`call-resolver: argumentBindings for callsite ${callSite.id} already upgraded; re-entrant resolution is not supported`,
+			);
+		}
+	}
+	const calleeParams = calleeRoutine.parameters;
+	for (let i = 0; i < callSite.argumentBindings.length; i++) {
+		const binding = callSite.argumentBindings[i];
+		if (binding === undefined) continue;
+		if (binding.bindingResolution === "non-record-arg") continue;
+		const calleeParam = calleeParams[i];
+		if (calleeParam === undefined) continue; // arity mismatch — leave defaults
+		binding.calleeParameterIsVar = calleeParam.isVar;
+		binding.bindingResolution = "resolved";
+	}
+}
+
+/** Resolve one call site within `routine` into a CallEdge. */
+function resolveCallSite(routine: Routine, callSite: CallSite, symbols: SymbolTable): CallEdge {
+	const base = {
+		from: routine.id,
+		callsiteId: callSite.id,
+		operationId: callSite.operationId,
+		provenance: [TREE_SITTER_EVIDENCE],
+	};
+	const callee = callSite.callee;
+
+	switch (callee.kind) {
+		case "bare": {
+			// A bare call resolves to a procedure in the SAME object (AL has no free functions).
+			const target = symbols.routineInObject(routine.objectId, callee.name);
+			if (target) {
+				// Phase 2: upgrade argumentBindings now that we know the callee signature.
+				upgradeBindings(callSite, target);
+				return { ...base, to: target.id, dispatchKind: "direct", resolution: "resolved" };
+			}
+			return { ...base, dispatchKind: "unresolved", resolution: "unknown" };
+		}
+		case "object-run": {
+			const dispatchKind = objectRunDispatchKind(callee.objectKind);
+			if (callee.targetRef === undefined) {
+				// Dynamic target (a variable) — known shape, unknown target.
+				return { ...base, dispatchKind: "dynamic", resolution: "unknown" };
+			}
+			const targetObject = callee.targetIsName
+				? symbols.objectByTypeName(callee.targetType, callee.targetRef)
+				: symbols.objectByTypeNumber(callee.targetType, Number.parseInt(callee.targetRef, 10));
+			if (!targetObject) {
+				// Target named/numbered but not in indexed source (e.g. symbol-only dependency).
+				return { ...base, dispatchKind, resolution: "opaque" };
+			}
+			// Resolve to the object's entry routine: OnRun trigger for codeunits, else the
+			// first routine. If none, the edge is resolved-to-object but routine-less.
+			const entry =
+				symbols.routineInObject(targetObject.id, "OnRun") ??
+				symbols.routinesInObject(targetObject.id)[0];
+			if (entry) {
+				// Phase 2: upgrade argumentBindings now that we know the callee signature.
+				upgradeBindings(callSite, entry);
+				return { ...base, to: entry.id, dispatchKind, resolution: "resolved" };
+			}
+			return { ...base, dispatchKind, resolution: "opaque" };
+		}
+		case "member": {
+			// A method call on an instance variable. Phase 1 does not type-track non-record
+			// variables, so the receiver type is unknown -> unresolved method dispatch.
+			return { ...base, dispatchKind: "method", resolution: "unknown" };
+		}
+		default: {
+			return { ...base, dispatchKind: "unresolved", resolution: "unknown" };
+		}
+	}
+}
+
+/**
+ * Resolve every call site in the index into a CallEdge. Exactly one edge per call site.
+ * Unresolved calls are DATA (a CallEdge with no `to` and a non-"resolved" resolution),
+ * never a silent gap.
+ */
+export function resolveCalls(index: SemanticIndex, symbols: SymbolTable): CallEdge[] {
+	const edges: CallEdge[] = [];
+	for (const routine of index.routines) {
+		for (const callSite of routine.features.callSites) {
+			edges.push(resolveCallSite(routine, callSite, symbols));
+		}
+	}
+	return edges;
+}

package/src/resolve/coverage.ts

@@ -0,0 +1,61 @@
+import type { Diagnostic } from "../model/finding.ts";
+import type { CallEdge } from "../model/graph.ts";
+import type { AnalysisCoverage, SemanticIndex } from "../model/model.ts";
+import type { SourceUnit } from "../providers/types.ts";
+
+/**
+ * Build the AnalysisCoverage record — the first-class "no silent clean" accounting.
+ * `sourceUnitsTotal` counts only `kind: "source"` units. `sourceUnitsParsed` subtracts
+ * units that produced a `warning`-severity index diagnostic (the throw path — a unit that
+ * parsed but had no object declaration produced an `info` diagnostic and still counts as
+ * parsed).
+ *
+ * `unresolvedCallsites` = every call edge whose target could not be determined
+ * (`resolution === "unknown"`). This covers `dispatchKind: "unresolved"`, `"method"` on
+ * untyped receivers, `"dynamic"` object-run calls, etc.
+ * `dynamicDispatchSites` = the dynamic-dispatch subset (`dispatchKind === "dynamic"`).
+ * Overlap between the two is intentional — dynamic sites are a named sub-category of
+ * unresolved.
+ */
+export function buildCoverage(
+	index: SemanticIndex,
+	callGraph: CallEdge[],
+	units: SourceUnit[],
+	indexDiagnostics: Diagnostic[],
+): AnalysisCoverage {
+	const sourceUnits = units.filter((u) => u.kind === "source");
+	const failedUnitRefs = new Set(
+		indexDiagnostics
+			.filter(
+				(d): d is Diagnostic & { sourceRef: string } =>
+					d.stage === "index" && d.severity === "warning" && d.sourceRef !== undefined,
+			)
+			.map((d) => d.sourceRef),
+	);
+	const sourceUnitsParsed = sourceUnits.filter((u) => !failedUnitRefs.has(u.id)).length;
+
+	const opaqueApps = index.identity.apps
+		.filter((a) => a.sourceKind === "symbol-only")
+		.map((a) => a.appGuid);
+
+	const routinesBodyAvailable = index.routines.filter((r) => r.bodyAvailable).length;
+	const routinesParseIncomplete = index.routines.filter((r) => r.parseIncomplete).map((r) => r.id);
+
+	const unresolvedCallsites = callGraph
+		.filter((e) => e.resolution === "unknown")
+		.map((e) => e.callsiteId);
+	const dynamicDispatchSites = callGraph
+		.filter((e) => e.dispatchKind === "dynamic")
+		.map((e) => e.operationId);
+
+	return {
+		sourceUnitsTotal: sourceUnits.length,
+		sourceUnitsParsed,
+		routinesTotal: index.routines.length,
+		routinesBodyAvailable,
+		routinesParseIncomplete,
+		opaqueApps,
+		unresolvedCallsites,
+		dynamicDispatchSites,
+	};
+}

package/src/resolve/event-graph.ts

@@ -0,0 +1,166 @@
+import { sha256Hex } from "../hash.ts";
+import { type AttributeInfo, findAttribute, qualifiedArg, stringArg } from "../model/attributes.ts";
+import type { Routine } from "../model/entities.ts";
+import {
+	type EventEdge,
+	type EventGraph,
+	type EventSymbol,
+	TREE_SITTER_EVIDENCE,
+} from "../model/graph.ts";
+import { encodeEventId, encodeObjectId } from "../model/ids.ts";
+import type { SemanticIndex } from "../model/model.ts";
+import type { SymbolTable } from "./symbol-table.ts";
+
+/** Determine the event kind from a publisher routine's structured attributes. */
+function publisherEventKind(attrs: readonly AttributeInfo[]): EventSymbol["eventKind"] {
+	if (findAttribute(attrs, "IntegrationEvent") !== undefined) return "integration";
+	if (findAttribute(attrs, "BusinessEvent") !== undefined) return "business";
+	return "unknown";
+}
+
+/**
+ * Read an `[EventSubscriber(ObjectType::X, X::"Y", 'EventName', 'ElementName', ...)]`
+ * attribute's target parts from the structured `AttributeInfo`, or null if no
+ * EventSubscriber is present.
+ *
+ * Args (positional, per AL spec):
+ *   0: ObjectType::<kind>            (qualified_enum_value — `value` = the kind)
+ *   1: <kind>::<ref> or <kind>::"ref" (database_reference — `member` = the ref)
+ *   2: '<eventName>'                  (string_literal)
+ *   3: '<elementName>'                (string_literal, may be empty)
+ *
+ * The grammar already distinguishes quoted vs unquoted target refs via
+ * `quoted_identifier` vs `identifier` inside `database_reference`, so the
+ * `.member` value is the unquoted ref regardless of source quoting.
+ */
+function parseSubscriberAttribute(attrs: readonly AttributeInfo[]): {
+	targetObjectType: string;
+	targetRef: string;
+	eventName: string;
+	elementName: string;
+} | null {
+	const attr = findAttribute(attrs, "EventSubscriber");
+	if (attr === undefined) return null;
+	const objectTypeArg = qualifiedArg(attr, 0);
+	const targetRefArg = qualifiedArg(attr, 1);
+	const eventName = stringArg(attr, 2);
+	const elementName = stringArg(attr, 3);
+	if (objectTypeArg === undefined || targetRefArg === undefined || eventName === undefined) {
+		return null;
+	}
+	return {
+		targetObjectType: objectTypeArg.member,
+		targetRef: targetRefArg.member,
+		eventName,
+		elementName: elementName ?? "",
+	};
+}
+
+/** Build the EventSymbol for a publisher routine. */
+function buildEventSymbol(routine: Routine, publisherObjectId: string): EventSymbol {
+	return {
+		id: encodeEventId(publisherObjectId, routine.name),
+		publisherObjectId,
+		publisherRoutineId: routine.id,
+		eventName: routine.name,
+		eventKind: publisherEventKind(routine.attributesParsed),
+		signatureHash: routine.canonical.normalizedSignatureHash,
+		parameters: routine.parameters,
+		provenance: [TREE_SITTER_EVIDENCE],
+	};
+}
+
+/**
+ * Build the event graph: EventSymbols from publisher routines, EventEdges from subscriber
+ * routines. A subscriber targeting an event al-sem cannot see (e.g. a Base App event in a
+ * symbol-only dependency) still produces an edge — with a synthesized eventId and a
+ * non-"resolved" resolution — never a silent gap.
+ */
+export function buildEventGraph(index: SemanticIndex, symbols: SymbolTable): EventGraph {
+	const events: EventSymbol[] = [];
+	const eventById = new Map<string, EventSymbol>();
+	const objectById = new Map(index.objects.map((o) => [o.id, o]));
+
+	// --- publishers ---
+	for (const routine of index.routines) {
+		if (routine.kind !== "event-publisher") continue;
+		const symbol = buildEventSymbol(routine, routine.objectId);
+		events.push(symbol);
+		eventById.set(symbol.id, symbol);
+	}
+
+	// --- subscribers ---
+	const edges: EventEdge[] = [];
+	for (const routine of index.routines) {
+		if (routine.kind !== "event-subscriber") continue;
+		const target = parseSubscriberAttribute(routine.attributesParsed);
+		if (!target) continue;
+
+		const subscriberObject = objectById.get(routine.objectId);
+		// routine.objectId should always resolve to an indexed object; the "unknown"
+		// sentinel here signals an inconsistent index (a routine without its owning object).
+		const subscriberAppId = subscriberObject?.appGuid ?? "unknown";
+
+		// Resolve the target object by type + name (AL names are case-insensitive).
+		const targetObject = symbols.objectByTypeName(target.targetObjectType, target.targetRef);
+
+		let eventId: string;
+		let resolution: EventEdge["resolution"];
+
+		if (targetObject) {
+			eventId = encodeEventId(targetObject.id, target.eventName);
+			// "resolved" only if we also found the matching publisher symbol.
+			if (eventById.has(eventId)) {
+				resolution = "resolved";
+			} else {
+				resolution = "maybe";
+				// Synthesize a symbol for a target object whose publisher was not indexed.
+				// (We are already in the else-branch of `eventById.has(eventId)`, so the
+				// symbol is guaranteed absent — no redundant guard needed here.)
+				const synthesized: EventSymbol = {
+					id: eventId,
+					publisherObjectId: targetObject.id,
+					eventName: target.eventName,
+					eventKind: "unknown",
+					elementName: target.elementName !== "" ? target.elementName : undefined,
+					signatureHash: sha256Hex(eventId),
+					parameters: [],
+					provenance: [{ source: "tree-sitter", note: "publisher not indexed" }],
+				};
+				events.push(synthesized);
+				eventById.set(eventId, synthesized);
+			}
+		} else {
+			// Target object not in indexed source — synthesize a pseudo object id.
+			// NOTE: `${pseudoObjectId}:${targetRef}` is a non-conforming sentinel string,
+			// NOT a valid ObjectId — downstream consumers must not attempt to parse it.
+			const pseudoObjectId = encodeObjectId("unknown", target.targetObjectType, 0);
+			eventId = encodeEventId(`${pseudoObjectId}:${target.targetRef}`, target.eventName);
+			resolution = "unknown";
+			if (!eventById.has(eventId)) {
+				const synthesized: EventSymbol = {
+					id: eventId,
+					publisherObjectId: `${pseudoObjectId}:${target.targetRef}`,
+					eventName: target.eventName,
+					eventKind: "unknown",
+					elementName: target.elementName !== "" ? target.elementName : undefined,
+					signatureHash: sha256Hex(eventId),
+					parameters: [],
+					provenance: [{ source: "tree-sitter", note: "target object not in indexed source" }],
+				};
+				events.push(synthesized);
+				eventById.set(eventId, synthesized);
+			}
+		}
+
+		edges.push({
+			eventId,
+			subscriberRoutineId: routine.id,
+			subscriberAppId,
+			resolution,
+			provenance: [TREE_SITTER_EVIDENCE],
+		});
+	}
+
+	return { events, edges };
+}

package/src/resolve/implicit-edges.ts

@@ -0,0 +1,53 @@
+import type { RecordOpType } from "../model/entities.ts";
+import { type CallEdge, type ResolutionQuality, TREE_SITTER_EVIDENCE } from "../model/graph.ts";
+import type { SemanticIndex } from "../model/model.ts";
+import type { SymbolTable } from "./symbol-table.ts";
+
+/**
+ * Maps a trigger-invoking record op to (the table trigger name it invokes, the resolution
+ * quality of the edge). `Validate` always runs the field's OnValidate, so "resolved".
+ * `Insert`/`Modify`/`Delete` run the table trigger only when called with
+ * `RunTrigger = true`, which Phase 1 does not capture — so "maybe".
+ */
+const TRIGGER_OPS: Partial<
+	Record<RecordOpType, { triggerName: string; resolution: ResolutionQuality }>
+> = {
+	Validate: { triggerName: "OnValidate", resolution: "resolved" },
+	Insert: { triggerName: "OnInsert", resolution: "maybe" },
+	Modify: { triggerName: "OnModify", resolution: "maybe" },
+	Delete: { triggerName: "OnDelete", resolution: "maybe" },
+};
+
+/**
+ * Build implicit-trigger CallEdges. For each trigger-invoking record op whose record
+ * variable resolves to a table that IS in indexed source, emit an edge to that table's
+ * trigger routine. Tables al-sem cannot see (symbol-only dependencies, unknown tables)
+ * produce no edge — that absence is reflected in AnalysisCoverage, not invented here.
+ */
+export function buildImplicitTriggerEdges(index: SemanticIndex, symbols: SymbolTable): CallEdge[] {
+	const edges: CallEdge[] = [];
+	for (const routine of index.routines) {
+		for (const op of routine.features.recordOperations) {
+			const mapping = TRIGGER_OPS[op.op];
+			if (!mapping) continue;
+			if (!op.tableId) continue; // table not resolved -> cannot find its trigger
+			const table = symbols.tableById(op.tableId);
+			if (!table) continue;
+			// The table's object id: tables are objects too. Look it up by type+number.
+			const tableObject = symbols.objectByTypeNumber("Table", table.tableNumber);
+			if (!tableObject) continue;
+			const trigger = symbols.routineInObject(tableObject.id, mapping.triggerName);
+			if (!trigger) continue;
+			edges.push({
+				from: routine.id,
+				to: trigger.id,
+				callsiteId: op.id, // the record-op's operation id doubles as the callsite ref
+				operationId: op.id,
+				dispatchKind: "implicit-trigger",
+				resolution: mapping.resolution,
+				provenance: [TREE_SITTER_EVIDENCE],
+			});
+		}
+	}
+	return edges;
+}

package/src/resolve/record-types.ts

@@ -0,0 +1,36 @@
+import type { SemanticIndex } from "../model/model.ts";
+import type { SymbolTable } from "./symbol-table.ts";
+
+/**
+ * Back-fill `tableId` on record variables and record operations, and `recordVariableId`
+ * on record operations, by resolving table names against the SymbolTable. Mutates the
+ * index's routines in place (the established pattern — Phase 1's routine indexer also
+ * mutates `callSite.loopStack` in place). A record variable naming a table al-sem cannot
+ * see (e.g. a base-app table in a symbol-only dependency) is left with `tableId`
+ * undefined — never guessed.
+ */
+export function resolveRecordTypes(index: SemanticIndex, symbols: SymbolTable): void {
+	for (const routine of index.routines) {
+		const { recordVariables, recordOperations } = routine.features;
+
+		// --- resolve record variables ---
+		// name (lowercased) -> the resolved variable, for matching operations below.
+		const varByName = new Map<string, (typeof recordVariables)[number]>();
+		for (const variable of recordVariables) {
+			varByName.set(variable.name.toLowerCase(), variable);
+			if (variable.tableName) {
+				const table = symbols.tableByName(variable.tableName);
+				if (table) variable.tableId = table.id;
+			}
+		}
+
+		// --- resolve record operations against their record variable ---
+		for (const op of recordOperations) {
+			const variable = varByName.get(op.recordVariableName.toLowerCase());
+			if (variable) {
+				op.recordVariableId = variable.id;
+				if (variable.tableId) op.tableId = variable.tableId;
+			}
+		}
+	}
+}

package/src/resolve/resolver.ts

@@ -0,0 +1,23 @@
+import type { Diagnostic } from "../model/finding.ts";
+import type { SemanticIndex, SemanticModel } from "../model/model.ts";
+import type { SourceUnit } from "../providers/types.ts";
+import { buildCoverage } from "./coverage.ts";
+import { resolveSemanticGraph } from "./semantic-graph.ts";
+
+/**
+ * L3 orchestrator for the WORKSPACE pipeline: extend a SemanticIndex into a SemanticModel by
+ * resolving its semantic graphs (`resolveSemanticGraph`) and adding the workspace coverage
+ * record. `units` and `indexDiagnostics` feed only `buildCoverage`.
+ *
+ * Pass `[]` for both `units` and `indexDiagnostics` in unit tests that work from a
+ * pre-built index.
+ */
+export function resolveModel(
+	index: SemanticIndex,
+	units: SourceUnit[],
+	indexDiagnostics: Diagnostic[],
+): SemanticModel {
+	const { callGraph, eventGraph } = resolveSemanticGraph(index);
+	const coverage = buildCoverage(index, callGraph, units, indexDiagnostics);
+	return { ...index, callGraph, eventGraph, coverage, rootClassifications: [] };
+}

package/src/resolve/semantic-graph.ts

@@ -0,0 +1,29 @@
+import type { CallEdge, EventGraph } from "../model/graph.ts";
+import type { SemanticIndex } from "../model/model.ts";
+import { resolveCalls } from "./call-resolver.ts";
+import { buildEventGraph } from "./event-graph.ts";
+import { buildImplicitTriggerEdges } from "./implicit-edges.ts";
+import { resolveRecordTypes } from "./record-types.ts";
+import { type SymbolTable, buildSymbolTable } from "./symbol-table.ts";
+
+export interface SemanticGraphResult {
+	symbols: SymbolTable;
+	callGraph: CallEdge[];
+	eventGraph: EventGraph;
+}
+
+/**
+ * The shared graph-resolution core: build the symbol table, resolve record-variable table
+ * types in place, then build the call graph (call edges + implicit-trigger edges) and event
+ * graph. Used by both the workspace pipeline (`resolveModel`) and the dependency-mode
+ * pipeline. Does NOT build coverage — that is workspace-specific and stays in `resolveModel`.
+ */
+export function resolveSemanticGraph(index: SemanticIndex): SemanticGraphResult {
+	const symbols = buildSymbolTable(index);
+	resolveRecordTypes(index, symbols);
+	const callEdges = resolveCalls(index, symbols);
+	const implicitEdges = buildImplicitTriggerEdges(index, symbols);
+	const callGraph = [...callEdges, ...implicitEdges];
+	const eventGraph = buildEventGraph(index, symbols);
+	return { symbols, callGraph, eventGraph };
+}

package/src/resolve/symbol-table.ts

@@ -0,0 +1,69 @@
+import type { ObjectDecl, Routine, Table } from "../model/entities.ts";
+import type { ObjectId } from "../model/ids.ts";
+import type { SemanticIndex } from "../model/model.ts";
+
+/**
+ * A read-only lookup index over a SemanticIndex. Built once, queried by every resolver.
+ * All name lookups are case-insensitive (AL identifiers are case-insensitive).
+ */
+export interface SymbolTable {
+	objectByTypeNumber(objectType: string, objectNumber: number): ObjectDecl | undefined;
+	objectByTypeName(objectType: string, name: string): ObjectDecl | undefined;
+	tableByName(name: string): Table | undefined;
+	tableById(id: string): Table | undefined;
+	routineInObject(objectId: ObjectId, routineName: string): Routine | undefined;
+	routinesInObject(objectId: ObjectId): Routine[];
+	routineById(routineId: string): Routine | undefined;
+}
+
+export function buildSymbolTable(index: SemanticIndex): SymbolTable {
+	const byTypeNumber = new Map<string, ObjectDecl>();
+	const byTypeName = new Map<string, ObjectDecl>();
+	for (const o of index.objects) {
+		byTypeNumber.set(`${o.objectType.toLowerCase()}/${o.objectNumber}`, o);
+		byTypeName.set(`${o.objectType.toLowerCase()}/${o.name.toLowerCase()}`, o);
+	}
+
+	const tablesByName = new Map<string, Table>();
+	const tablesById = new Map<string, Table>();
+	for (const t of index.tables) {
+		tablesByName.set(t.name.toLowerCase(), t);
+		tablesById.set(t.id, t);
+	}
+
+	// Routines keyed by `${objectId}::${routineName.toLowerCase()}`, and grouped per object.
+	const routineByKey = new Map<string, Routine>();
+	const routinesByObject = new Map<string, Routine[]>();
+	const routinesById = new Map<string, Routine>();
+	for (const r of index.routines) {
+		routineByKey.set(`${r.objectId}::${r.name.toLowerCase()}`, r);
+		routinesById.set(r.id, r);
+		const list = routinesByObject.get(r.objectId);
+		if (list) list.push(r);
+		else routinesByObject.set(r.objectId, [r]);
+	}
+
+	return {
+		objectByTypeNumber(objectType, objectNumber) {
+			return byTypeNumber.get(`${objectType.toLowerCase()}/${objectNumber}`);
+		},
+		objectByTypeName(objectType, name) {
+			return byTypeName.get(`${objectType.toLowerCase()}/${name.toLowerCase()}`);
+		},
+		tableByName(name) {
+			return tablesByName.get(name.toLowerCase());
+		},
+		tableById(id) {
+			return tablesById.get(id);
+		},
+		routineInObject(objectId, routineName) {
+			return routineByKey.get(`${objectId}::${routineName.toLowerCase()}`);
+		},
+		routinesInObject(objectId) {
+			return routinesByObject.get(objectId) ?? [];
+		},
+		routineById(routineId) {
+			return routinesById.get(routineId);
+		},
+	};
+}