al-sem 0.0.1

package/src/engine/dispatch-sites.ts

@@ -0,0 +1,199 @@
+/**
+ * enumerateDispatchSites — bridges the event-flow substrate with D43's dispatch-site
+ * guard analysis.
+ *
+ * For each call-site in the model where a non-publisher routine calls an event-publisher
+ * routine, this function produces a `DispatchSite` record capturing:
+ *  - Which publisher and event are involved.
+ *  - Which caller routine + call-site makes the dispatch.
+ *  - The caller's actual argument bound to the publisher's IsHandled formal (if any).
+ *  - Any post-call `conditionReference` entries in the caller body that reference the
+ *    IsHandled actual — these are the guards D43 reasons about.
+ *  - The set of tables the caller writes (transitively) when a post-call guard exists.
+ *
+ * ## Argument-binding strategy (fallback documented here)
+ *
+ * Phase 4's `CallArgumentBinding` carries a `sourceVariableName` for record-typed
+ * arguments, but Boolean arguments resolve as `bindingResolution: "non-record-arg"` with
+ * no `sourceVariableName`. Consequently, for a Boolean IsHandled formal we fall back to
+ * the raw `argumentTexts[handledFormalIndex]` value, lowercased. This is sound for
+ * canonical AL where the caller passes a declared local or parameter by its bare
+ * identifier — `OnBeforePost(Rec, IsHandled)` → text `"IsHandled"` → lowercased
+ * `"ishandled"`. The fallback is documented in `DispatchSiteHandledActual.variableName`.
+ */
+import { writesTablesOf } from "../detectors/capability-query.ts";
+import type { ConditionReference } from "../model/entities.ts";
+import type { CallsiteId, EventId, RoutineId, TableId } from "../model/ids.ts";
+import type { SemanticModel } from "../model/model.ts";
+import { type EventFlowIndexes, IS_HANDLED_RE } from "./event-flow.ts";
+import { compareStrings } from "./uncertainty-util.ts";
+
+export interface DispatchSiteHandledActual {
+	/**
+	 * Lowercased name of the caller's local/global variable passed by-var into the
+	 * publisher's IsHandled formal. Derived from the raw `argumentTexts` entry when
+	 * `argumentBindings` cannot carry Boolean-scalar identity (the common fallback path).
+	 */
+	variableName: string;
+	/** 0-based index of the publisher's IsHandled formal among its parameters. */
+	formalIndex: number;
+}
+
+export interface DispatchSite {
+	publisherRoutine: RoutineId;
+	eventId: EventId;
+	callerRoutine: RoutineId;
+	callsiteId: CallsiteId;
+	/**
+	 * Set when the publisher has a `var Boolean` formal matching IS_HANDLED_RE AND the
+	 * caller binds a recognizable identifier to that formal.
+	 */
+	handledActual?: DispatchSiteHandledActual;
+	/**
+	 * Caller's `conditionReferences` whose identifier matches `handledActual.variableName`
+	 * and whose `referenceAnchor` is AFTER the callsite's start position (line / column).
+	 */
+	postCallGuards: readonly ConditionReference[];
+	/**
+	 * Tables written by the caller's reachable cone when a post-call guard exists.
+	 * Initial cut: full caller-summary writes — branch-level slice is deferred to T3+.
+	 * Empty when there is no post-call guard or when the caller has no summary.
+	 */
+	guardedTablesWritten: readonly TableId[];
+}
+
+export function enumerateDispatchSites(
+	model: SemanticModel,
+	_ix: EventFlowIndexes,
+): readonly DispatchSite[] {
+	const out: DispatchSite[] = [];
+
+	// Index routines by id for O(1) lookup.
+	const routineById = new Map(model.routines.map((r) => [r.id, r] as const));
+
+	// Collect the set of event-publisher routine ids together with their associated
+	// event id (from the event graph). We prefer the event graph as the authoritative
+	// source because it carries the stable EventId.
+	const publisherEventId = new Map<RoutineId, EventId>();
+	for (const ev of model.eventGraph.events) {
+		if (ev.publisherRoutineId !== undefined) {
+			publisherEventId.set(ev.publisherRoutineId, ev.id);
+		}
+	}
+
+	// Walk typed edges. We look for edges whose target is an event-publisher routine.
+	// Relevant edge kinds: "direct-call", "object-run-resolved", "dependency-export".
+	// "event-dispatch" edges are publisher→subscriber (not caller→publisher), so they
+	// are explicitly skipped — they don't carry a callsiteId.
+	const typedEdges = model.typedEdges ?? [];
+	for (const edge of typedEdges) {
+		if (
+			edge.kind !== "direct-call" &&
+			edge.kind !== "object-run-resolved" &&
+			edge.kind !== "dependency-export"
+		) {
+			continue;
+		}
+
+		const publisherEventEntry = publisherEventId.get(edge.to);
+		if (publisherEventEntry === undefined) continue; // target is not a publisher
+
+		const caller = routineById.get(edge.from);
+		const publisher = routineById.get(edge.to);
+		if (!caller || !publisher) continue;
+
+		// Find the callsite in the caller's features that matches the edge's callsiteId.
+		const callSite = caller.features.callSites.find((cs) => cs.id === edge.callsiteId);
+		if (!callSite) continue;
+
+		// Find the publisher's IsHandled-shaped formal: var Boolean matching IS_HANDLED_RE.
+		// ParameterSymbol uses `isVar` (boolean) and `typeText` (raw type string).
+		let handledFormalIndex = -1;
+		for (let i = 0; i < publisher.parameters.length; i++) {
+			const p = publisher.parameters[i];
+			if (p === undefined) continue;
+			if (!p.isVar) continue;
+			if (!/^boolean$/i.test(p.typeText)) continue;
+			if (!IS_HANDLED_RE.test(p.name)) continue;
+			handledFormalIndex = i;
+			break;
+		}
+
+		// Identify the caller's actual variable bound to the IsHandled formal.
+		//
+		// Primary path: check argumentBindings for a sourceVariableName (works when the
+		// binding resolution succeeded and the argument is not a record). For Boolean
+		// formals, `bindingResolution` is typically "non-record-arg" with no
+		// `sourceVariableName`, so this path usually returns nothing.
+		//
+		// Fallback path: read `argumentTexts[handledFormalIndex]` directly. The raw text
+		// is the bare identifier the caller passed (e.g. "IsHandled"), and lowercasing it
+		// gives the canonical name for conditionReference matching.
+		let handledActual: DispatchSiteHandledActual | undefined;
+		if (handledFormalIndex >= 0) {
+			// Primary: try argumentBindings.sourceVariableName.
+			const binding = callSite.argumentBindings[handledFormalIndex];
+			const nameFromBinding =
+				binding !== undefined &&
+				binding.sourceKind !== "unknown" &&
+				typeof binding.sourceVariableName === "string" &&
+				binding.sourceVariableName.length > 0
+					? binding.sourceVariableName
+					: undefined;
+
+			// Fallback: raw argumentTexts entry, lowercased.
+			const nameFromText =
+				nameFromBinding === undefined
+					? (callSite.argumentTexts[handledFormalIndex]?.trim().toLowerCase() ?? undefined)
+					: undefined;
+
+			const varName = nameFromBinding ?? nameFromText;
+			if (varName !== undefined && varName.length > 0) {
+				handledActual = { variableName: varName, formalIndex: handledFormalIndex };
+			}
+		}
+
+		// Collect post-call conditionReferences from the CALLER's features.
+		// A reference is "post-call" when its referenceAnchor is strictly after the
+		// callsite's start position (same source unit, later line OR same line later column).
+		const postCallGuards: ConditionReference[] = [];
+		if (handledActual) {
+			const callRow = callSite.sourceAnchor.range.startLine;
+			const callCol = callSite.sourceAnchor.range.startColumn;
+			const actualLower = handledActual.variableName.toLowerCase();
+			for (const cref of caller.features.conditionReferences ?? []) {
+				if (cref.identifier !== actualLower) continue;
+				const r = cref.referenceAnchor.range;
+				if (r.startLine < callRow) continue;
+				if (r.startLine === callRow && r.startColumn <= callCol) continue;
+				postCallGuards.push(cref);
+			}
+		}
+
+		// Guarded writes: full caller transitive writes when at least one post-call guard
+		// exists. Branch-level slicing (then vs else) is deferred to T3.
+		let guardedTablesWritten: TableId[] = [];
+		if (postCallGuards.length > 0 && caller.summary !== undefined) {
+			guardedTablesWritten = writesTablesOf(caller.summary);
+		}
+
+		out.push({
+			publisherRoutine: publisher.id,
+			eventId: publisherEventEntry,
+			callerRoutine: caller.id,
+			callsiteId: edge.callsiteId,
+			handledActual,
+			postCallGuards,
+			guardedTablesWritten,
+		});
+	}
+
+	out.sort(
+		(a, b) =>
+			compareStrings(a.eventId, b.eventId) ||
+			compareStrings(a.callerRoutine, b.callerRoutine) ||
+			compareStrings(a.callsiteId, b.callsiteId),
+	);
+
+	return out;
+}

package/src/engine/effect-lattice.ts

@@ -0,0 +1,81 @@
+import type { TempState } from "../model/entities.ts";
+import type { TableId } from "../model/ids.ts";
+import type { DbEffect, EffectPresence } from "../model/summary.ts";
+import { compareStrings } from "./uncertainty-util.ts";
+
+// --- tri-state presence: no < unknown < yes ---
+const PRESENCE_RANK: Record<EffectPresence, number> = { no: 0, unknown: 1, yes: 2 };
+const PRESENCE_BY_RANK: EffectPresence[] = ["no", "unknown", "yes"];
+
+/** Lattice join: the more-informative presence wins (yes > unknown > no). Monotone. */
+export function joinPresence(a: EffectPresence, b: EffectPresence): EffectPresence {
+	const rank = Math.max(PRESENCE_RANK[a], PRESENCE_RANK[b]);
+	return PRESENCE_BY_RANK[rank] ?? "unknown";
+}
+
+/** Set union of two `writesTables` values; `"unknown"` absorbs. Result is sorted. */
+export function unionTables(
+	a: TableId[] | "unknown",
+	b: TableId[] | "unknown",
+): TableId[] | "unknown" {
+	if (a === "unknown" || b === "unknown") return "unknown";
+	return [...new Set([...a, ...b])].sort();
+}
+
+/** Normalise a TempState to a short stable key fragment. */
+function tempStateKey(t: TempState): string {
+	if (t.kind === "known") return t.value ? "t" : "f";
+	if (t.kind === "parameter-dependent") return `p${t.parameterIndex}`;
+	return "u";
+}
+
+/**
+ * Stable, path-insensitive effect key. Deliberately EXCLUDES `via` — two DbEffects for the
+ * same operation are the same fact regardless of how they propagated. Used to de-dupe.
+ */
+export function effectKeyOf(
+	e: Pick<DbEffect, "op" | "tableId" | "operationId" | "tempState">,
+): string {
+	return `${e.op}|${e.tableId}|${e.operationId}|${tempStateKey(e.tempState)}`;
+}
+
+// --- via precedence: most specific wins ---
+const VIA_RANK: Record<DbEffect["via"], number> = {
+	direct: 4,
+	"implicit-trigger": 3,
+	"event-subscriber": 2,
+	dynamic: 1,
+	inherited: 0,
+};
+
+/** Merge two `via` tags, keeping the most specific (direct > implicit-trigger > event-subscriber > dynamic > inherited). */
+export function mergeVia(a: DbEffect["via"], b: DbEffect["via"]): DbEffect["via"] {
+	return VIA_RANK[a] >= VIA_RANK[b] ? a : b;
+}
+
+/**
+ * Concatenate and de-dupe DbEffects by `effectKey`. The key is always recomputed via
+ * `effectKeyOf` — a caller-supplied `effectKey` is treated as a write target only, never
+ * trusted as input, so a divergent caller scheme can't cause silent dedupe failures. When
+ * two effects share a key, `via` is merged by precedence. Result is sorted by
+ * `(effectKey, operationId)` for determinism.
+ */
+export function mergeDbEffects(...lists: DbEffect[][]): DbEffect[] {
+	const byKey = new Map<string, DbEffect>();
+	for (const list of lists) {
+		for (const e of list) {
+			const key = effectKeyOf(e);
+			const normalized: DbEffect = { ...e, effectKey: key };
+			const existing = byKey.get(key);
+			if (existing) {
+				byKey.set(key, { ...existing, via: mergeVia(existing.via, normalized.via) });
+			} else {
+				byKey.set(key, normalized);
+			}
+		}
+	}
+	return [...byKey.values()].sort((a, b) => {
+		if (a.effectKey !== b.effectKey) return compareStrings(a.effectKey, b.effectKey);
+		return compareStrings(a.operationId, b.operationId);
+	});
+}

package/src/engine/entry-points.ts

@@ -0,0 +1,57 @@
+import { roleOf } from "../model/entities.ts";
+import type { RoutineId } from "../model/ids.ts";
+import type { SemanticModel } from "../model/model.ts";
+
+/**
+ * Identify primary-app routines that BC dispatches to without an in-app caller — the root
+ * set for reachability analysis. An entry point is a primary-app routine whose `kind` is
+ * `trigger` (OnRun, OnOpenPage, OnValidate, OnInsert, etc.) or `event-subscriber`.
+ *
+ * Used by D8 (transaction-span roots). For D14's forward-reachability question, use
+ * `findReachableRoots` instead — it adds non-local procedures as roots, because they
+ * may be called from outside the app.
+ */
+export function findEntryPoints(model: SemanticModel): RoutineId[] {
+	const out: RoutineId[] = [];
+	for (const r of model.routines) {
+		if (roleOf(r) !== "primary") continue;
+		if (r.kind === "event-subscriber" || r.kind === "trigger") {
+			out.push(r.id);
+		}
+	}
+	return out.sort();
+}
+
+/**
+ * Root set for "is this routine ever invoked?" reachability analysis (D14 dead-routine).
+ * Adds to `findEntryPoints` the procedures we cannot prove are app-scoped:
+ *  - default-access (public): callable from any app that declares us as a dependency;
+ *  - `protected`: callable from overriding codeunits;
+ *  - `internal`: callable only from apps named in this workspace's `internalsVisibleTo`.
+ *
+ * `internal` is added as a root only when `internalReachableExternally` is true (some
+ * app is granted access). With no `internalsVisibleTo` entries, `internal` is
+ * effectively app-scoped, so its dead-routine reachability collapses to the `local`
+ * case — D14 then flags `internal` procedures with no in-app caller.
+ *
+ * D8's transaction-span computation deliberately does NOT use this — its roots are
+ * trigger/event boundaries (the natural unit of work), not every exported procedure.
+ */
+export function findReachableRoots(
+	model: SemanticModel,
+	opts: { internalReachableExternally: boolean } = { internalReachableExternally: false },
+): RoutineId[] {
+	const out: RoutineId[] = [];
+	for (const r of model.routines) {
+		if (roleOf(r) !== "primary") continue;
+		if (r.kind === "event-subscriber" || r.kind === "trigger") {
+			out.push(r.id);
+			continue;
+		}
+		if (r.kind !== "procedure") continue;
+		if (r.accessModifier === "local") continue;
+		if (r.accessModifier === "internal" && !opts.internalReachableExternally) continue;
+		out.push(r.id);
+	}
+	return out.sort();
+}