al-sem 0.0.1

package/src/snapshot/app-snapshot.ts

@@ -0,0 +1,74 @@
+import type { DependencyPackageRef } from "../deps/dependency-artifact.ts";
+import { buildAppModel } from "../deps/dependency-pipeline.ts";
+import { classifyRoots } from "../engine/root-classifier.ts";
+import type { Diagnostic } from "../model/finding.ts";
+import type { SemanticModel } from "../model/model.ts";
+import { readAppManifest } from "../symbols/app-manifest.ts";
+import { packageHash } from "../symbols/package-hash.ts";
+import { composeSnapshot } from "./compose.ts";
+import type { CapabilitySnapshot } from "./types.ts";
+
+/** Build a DependencyPackageRef from a standalone .app file path. Throws on an unreadable
+ *  or identity-less package (the caller surfaces the message). */
+function refFromAppPath(appPath: string): DependencyPackageRef {
+	const manifest = readAppManifest(appPath);
+	if (manifest.error !== undefined || manifest.identity.appGuid === "") {
+		throw new Error(
+			`not a readable .app package: ${appPath}${manifest.error ? ` (${manifest.error})` : ""}`,
+		);
+	}
+	return {
+		appPath,
+		appGuid: manifest.identity.appGuid,
+		publisher: manifest.identity.publisher,
+		name: manifest.identity.name,
+		version: manifest.identity.version,
+		packageHash: packageHash(appPath),
+		manifestDependencies: manifest.dependencies,
+		includesSource: manifest.includesSource,
+	};
+}
+
+/** Parse a single .app into a PRIMARY SemanticModel: self-contained (no external deps),
+ *  entities marked primary, roots classified. Cross-app calls into unresolved deps leave
+ *  capability cones partial (honestly reflected in per-routine coverage). */
+export async function buildPrimaryAppModel(
+	appPath: string,
+): Promise<{ model: SemanticModel; diagnostics: Diagnostic[] }> {
+	const ref = refFromAppPath(appPath);
+	const { model, diagnostics, summaryMode } = await buildAppModel(ref, [], ref.packageHash);
+	// Self-contained => every entity is this .app's own; promote dependency->primary.
+	for (const a of model.apps) a.analysisRole = "primary";
+	for (const o of model.objects) o.analysisRole = "primary";
+	for (const r of model.routines) r.analysisRole = "primary";
+	// Note: Table has no analysisRole field — tables are accessed through ObjectDecl.
+	// The dep path skips root classification; a primary snapshot needs it.
+	model.rootClassifications = classifyRoots(model);
+	// No silent clean: if the .app is symbol-only / unparseable, behavioral summaries are absent —
+	// surface it so a structural-only snapshot is not mistaken for a complete one. A
+	// symbol-only package (no embedded source by ResourceExposurePolicy) carries only
+	// bodyless ABI routines; `buildAppModel` still labels that `summaryMode: "full"`, so we
+	// derive the honest structural-only label from `includesSource` as well.
+	const effectiveMode = ref.includesSource ? summaryMode : "structural-only-symbol-package";
+	if (effectiveMode !== "full") {
+		// [APP###] codes are the .app-as-primary-subject diagnostic series (distinct from [DEP###]).
+		diagnostics.push({
+			severity: "info",
+			stage: "symbol-read",
+			message: `[APP001] ${ref.name}: ${effectiveMode} — snapshot carries structural ABI only (no behavioral capability facts)`,
+			sourceRef: ref.appGuid,
+		});
+	}
+	return { model, diagnostics };
+}
+
+/** Compose a CapabilitySnapshot directly from a single .app file. */
+export async function loadSnapshotFromApp(
+	appPath: string,
+	alsemVersion: string,
+	deterministic: boolean,
+): Promise<{ snapshot: CapabilitySnapshot; diagnostics: Diagnostic[] }> {
+	const { model, diagnostics } = await buildPrimaryAppModel(appPath);
+	const snapshot = composeSnapshot(model, { workspaceDir: appPath, alsemVersion, deterministic });
+	return { snapshot, diagnostics };
+}

package/src/snapshot/compose.ts

@@ -0,0 +1,100 @@
+import type { SemanticModel } from "../model/model.ts";
+import { deriveCallsiteEvidence } from "./derive/callsite-evidence.ts";
+import { deriveCapabilityFacts } from "./derive/capability-facts.ts";
+import { deriveContracts } from "./derive/contracts.ts";
+import { deriveCoverage } from "./derive/coverage.ts";
+import { deriveEventDeclarations } from "./derive/event-declarations.ts";
+import { deriveIdentityTable } from "./derive/identity-table.ts";
+import { deriveInputs } from "./derive/inputs.ts";
+import { deriveOperationEvidence } from "./derive/operation-evidence.ts";
+import { derivePermissions } from "./derive/permissions.ts";
+import { deriveRootClassifications } from "./derive/root-classifications.ts";
+import { deriveSchema } from "./derive/schema.ts";
+import { deriveTypedEdges } from "./derive/typed-edges.ts";
+import { computeWorkspaceFingerprint } from "./derive/workspace-fingerprint.ts";
+import { type AppIdentity, type CapabilitySnapshot, SNAPSHOT_SCHEMA_VERSION } from "./types.ts";
+
+export interface ComposeOptions {
+	workspaceDir: string;
+	alsemVersion: string;
+	/** When true, timestamps are pinned to '1970-01-01T00:00:00Z' for
+	 *  byte-stable output. Default false. */
+	deterministic?: boolean;
+	/**
+	 * True when `analyzeWorkspace` was invoked with `noRootsConfig: true`
+	 * AND a `roots.config.json` existed on disk that would otherwise have
+	 * been loaded. Surfaces as
+	 * `snapshot.inputsMetadata.rootsConfigIgnored = true` so diff tools can
+	 * distinguish "no config file" from "config existed but ignored".
+	 *
+	 * The CALLER is responsible for the disk-existence check; the composer
+	 * just records the flag verbatim. Pass `false`/omit when the config
+	 * either didn't exist or was actually loaded.
+	 */
+	rootsConfigIgnored?: boolean;
+}
+
+/**
+ * Compose a CapabilitySnapshot from a SemanticModel by running every deriver
+ * in order. Identity-table comes first; every other deriver receives it as
+ * an argument.
+ *
+ * Engine-never-throws contract: each deriver is pure and total over the
+ * model. If a deriver throws unexpectedly, the exception propagates here
+ * (we do NOT swallow — composeSnapshot is a CLI/library boundary and
+ * silent failure here would mask real bugs).
+ */
+export function composeSnapshot(model: SemanticModel, opts: ComposeOptions): CapabilitySnapshot {
+	const identities = deriveIdentityTable(model);
+	const inputs = deriveInputs(model, opts.workspaceDir);
+	const workspaceFingerprint = computeWorkspaceFingerprint(inputs, opts.alsemVersion);
+
+	const apps = projectApps(model);
+
+	const snap: CapabilitySnapshot = {
+		schemaVersion: SNAPSHOT_SCHEMA_VERSION,
+		alsemVersion: opts.alsemVersion,
+		workspaceFingerprint,
+		generatedAt: opts.deterministic ? "1970-01-01T00:00:00Z" : new Date().toISOString(),
+		apps,
+		identities,
+		contractFacts: deriveContracts(model, identities),
+		schemaFacts: deriveSchema(model, identities),
+		permissionFacts: derivePermissions(model, identities),
+		rootClassifications: deriveRootClassifications(model, identities),
+		capabilityFacts: deriveCapabilityFacts(model, identities),
+		typedEdges: deriveTypedEdges(model, identities),
+		operationIndex: deriveOperationEvidence(model, identities),
+		callsiteIndex: deriveCallsiteEvidence(model, identities),
+		coverage: deriveCoverage(model, identities),
+		inputs,
+		eventDeclarations: deriveEventDeclarations(model, identities),
+	};
+
+	// Only attach inputsMetadata when there's actually something to record —
+	// keeps `inputsMetadata: {}` out of the serialized output for the common
+	// "nothing overridden" case.
+	if (opts.rootsConfigIgnored === true) {
+		snap.inputsMetadata = { rootsConfigIgnored: true };
+	}
+
+	return snap;
+}
+
+function projectApps(model: SemanticModel): AppIdentity[] {
+	const rawApps = (model as unknown as { apps?: Array<Record<string, unknown>> }).apps;
+	if (!Array.isArray(rawApps)) return [];
+	const out: AppIdentity[] = [];
+	for (const a of rawApps) {
+		const appGuid = String(a.appGuid ?? a.guid ?? a.id ?? "");
+		if (appGuid === "") continue;
+		out.push({
+			appGuid,
+			publisher: String(a.publisher ?? ""),
+			name: String(a.name ?? ""),
+			version: String(a.version ?? ""),
+		});
+	}
+	out.sort((x, y) => x.appGuid.localeCompare(y.appGuid));
+	return out;
+}

package/src/snapshot/derive/callsite-evidence.ts

@@ -0,0 +1,76 @@
+import type { SemanticModel } from "../../model/model.ts";
+import { createIdentityIndex } from "../../model/stable-identity.ts";
+import type { StableRoutineId } from "../../model/stable-identity.ts";
+import type { CallsiteEvidence, SnapshotIdentityTable } from "../types.ts";
+
+/**
+ * Emit CallsiteEvidence for every CallSite referenced as a CapabilityFact
+ * witness (direct or inherited) or as the anchor of a typed GraphEdge.
+ *
+ * Sort by callsiteId.
+ */
+export function deriveCallsiteEvidence(
+	model: SemanticModel,
+	_idx: SnapshotIdentityTable,
+): CallsiteEvidence[] {
+	const idCvt = createIdentityIndex();
+	const referenced = new Set<string>();
+
+	// Collect callsite ids from CapabilityFact witnesses.
+	for (const r of model.routines ?? []) {
+		const summary = r.summary;
+		if (summary === undefined) continue;
+		for (const f of [
+			...(summary.capabilityFactsDirect ?? []),
+			...(summary.capabilityFactsInherited ?? []),
+		]) {
+			if (f.witnessCallsiteId !== undefined) {
+				referenced.add(String(f.witnessCallsiteId));
+			}
+		}
+	}
+
+	// Collect callsite ids from typed graph edges.
+	for (const e of model.typedEdges ?? []) {
+		if ("callsiteId" in e && e.callsiteId !== undefined) {
+			referenced.add(String(e.callsiteId));
+		}
+	}
+
+	const out: CallsiteEvidence[] = [];
+	for (const r of model.routines ?? []) {
+		const stableObject = idCvt.toStableObjectId(r.objectId);
+		const stableRoutine = idCvt.toStableRoutineIdFromParts(
+			stableObject,
+			r.canonical?.normalizedSignatureHash ?? "",
+		) as StableRoutineId;
+
+		for (const cs of r.features?.callSites ?? []) {
+			if (!referenced.has(String(cs.id))) continue;
+			const a = cs.sourceAnchor;
+			out.push({
+				callsiteId: cs.id,
+				routine: stableRoutine,
+				sourceFile: a.sourceUnitId,
+				startLine: a.range.startLine,
+				startColumn: a.range.startColumn,
+				endLine: a.range.endLine,
+				endColumn: a.range.endColumn,
+				calleeDisplay: renderCallee(cs.callee),
+			});
+		}
+	}
+	out.sort((a, b) => String(a.callsiteId).localeCompare(String(b.callsiteId)));
+	return out;
+}
+
+function renderCallee(callee: unknown): string {
+	if (callee === null || callee === undefined || typeof callee !== "object") return "?";
+	const c = callee as Record<string, unknown>;
+	if (c.kind === "bare" && typeof c.name === "string") return c.name;
+	if (c.kind === "member" && typeof c.receiver === "string" && typeof c.method === "string") {
+		return `${c.receiver}.${c.method}`;
+	}
+	if (c.kind === "object-run" && typeof c.objectKind === "string") return `${c.objectKind}.Run`;
+	return String(c.kind ?? "?");
+}

package/src/snapshot/derive/capability-facts.ts

@@ -0,0 +1,70 @@
+// src/snapshot/derive/capability-facts.ts
+//
+// Flatten every routine's capabilityFactsDirect ∪ capabilityFactsInherited
+// into a single sorted CapabilityFact[] with `subject` rewritten from the
+// internal RoutineId to a StableRoutineId.
+//
+// Sort key: (subject, op, resourceKind, resourceId, confidence, provenance,
+// witnessCallsiteId, witnessOperationId) — drives determinism + round-trip tests.
+
+import type { CapabilityFact } from "../../model/capability.ts";
+import type { SemanticModel } from "../../model/model.ts";
+import { createIdentityIndex } from "../../model/stable-identity.ts";
+import type { StableRoutineId } from "../../model/stable-identity.ts";
+import type { SnapshotIdentityTable } from "../types.ts";
+
+/**
+ * Flatten every routine's capabilityFactsDirect ∪ capabilityFactsInherited
+ * into a single sorted CapabilityFact[] with subject rewritten to
+ * StableRoutineId.
+ *
+ * Sort key: (subject, op, resourceKind, resourceId, confidence, provenance,
+ * witnessCallsiteId, witnessOperationId). Used by the determinism + round-trip
+ * tests.
+ *
+ * `idx` is the SnapshotIdentityTable produced earlier; not consulted directly
+ * (id rewriting goes through createIdentityIndex), but accepting it keeps
+ * the deriver signature uniform with the rest of the family.
+ */
+export function deriveCapabilityFacts(
+	model: SemanticModel,
+	_idx: SnapshotIdentityTable,
+): CapabilityFact[] {
+	const idCvt = createIdentityIndex();
+	const all: CapabilityFact[] = [];
+	for (const r of model.routines ?? []) {
+		const summary = r.summary;
+		if (summary === undefined) continue;
+		const stableObject = idCvt.toStableObjectId(r.objectId);
+		const sigHash = r.canonical.normalizedSignatureHash;
+		const stableSubject = idCvt.toStableRoutineIdFromParts(
+			stableObject,
+			sigHash,
+		) as StableRoutineId;
+		for (const f of summary.capabilityFactsDirect ?? []) {
+			all.push({ ...f, subject: stableSubject as unknown as typeof f.subject });
+		}
+		for (const f of summary.capabilityFactsInherited ?? []) {
+			all.push({ ...f, subject: stableSubject as unknown as typeof f.subject });
+		}
+	}
+	all.sort(canonicalCompare);
+	return all;
+}
+
+function canonicalCompare(a: CapabilityFact, b: CapabilityFact): number {
+	return factKey(a).localeCompare(factKey(b));
+}
+
+function factKey(f: CapabilityFact): string {
+	return [
+		String(f.subject ?? ""),
+		f.op ?? "",
+		f.resourceKind ?? "",
+		String(f.resourceId ?? ""),
+		f.confidence ?? "",
+		f.provenance ?? "",
+		String(f.witnessCallsiteId ?? ""),
+		String(f.witnessOperationId ?? ""),
+	].join("|");
+}

package/src/snapshot/derive/contracts.ts

@@ -0,0 +1,131 @@
+// src/snapshot/derive/contracts.ts
+//
+// Project every routine + object in the SemanticModel to a ContractFact.
+//
+// - Routines: signatureFingerprint = SHA-256 of canonicalRoutineSignature
+//   (same text form hashed into normalizedSignatureHash at index time, but
+//   re-derived here to stay in the snapshot boundary — no dependency on the
+//   internal hash plumbing).
+// - Objects:  signatureFingerprint = SHA-256("${objectType}|${objectNumber}|${name}"),
+//   since objects have no parameter shape.
+// - Attributes are normalised per-attribute to { name, argsHash } where argsHash
+//   is SHA-256 of the canonical JSON of the args array.
+//
+// Event-publisher + interface ContractFact kinds are reserved for Phase 1+
+// (where the spec adds dedicated projections); covered today by routine/object kinds.
+//
+// Output is sorted by stableId for determinism.
+
+import { createHash } from "node:crypto";
+import { canonicalRoutineSignature } from "../../index/routine-signature.ts";
+import type { SemanticModel } from "../../model/model.ts";
+import { createIdentityIndex } from "../../model/stable-identity.ts";
+import type { AttributeFingerprint, ContractFact, SnapshotIdentityTable } from "../types.ts";
+
+/**
+ * Project every routine + object to a ContractFact.
+ *
+ * Output is sorted by stableId.
+ */
+export function deriveContracts(model: SemanticModel, _idx: SnapshotIdentityTable): ContractFact[] {
+	const idCvt = createIdentityIndex();
+	const out: ContractFact[] = [];
+
+	for (const obj of model.objects ?? []) {
+		const stableId = idCvt.toStableObjectId(obj.id);
+		// Objects don't carry accessModifier in the current model shape — default to "public".
+		const objAny = obj as unknown as Record<string, unknown>;
+		const visibility = mapVisibility(objAny.accessModifier);
+		// Objects don't carry attributesParsed in the current model shape — default to [].
+		const rawAttrs = objAny.attributesParsed;
+		const attributes = Array.isArray(rawAttrs) ? rawAttrs.map(fingerprintAttribute) : [];
+		const obsoleteState = objAny.obsoleteState as "Pending" | "Removed" | "No" | undefined;
+		const obsoleteReason = objAny.obsoleteReason as string | undefined;
+
+		const fact: ContractFact = {
+			kind: "object",
+			stableId,
+			visibility,
+			signatureFingerprint: sha256(`${obj.objectType}|${obj.objectNumber}|${obj.name}`),
+			attributes,
+		};
+		if (obsoleteState !== undefined && obsoleteState !== "No") {
+			fact.obsoleteState = obsoleteState;
+		}
+		if (obsoleteReason !== undefined) {
+			fact.obsoleteReason = obsoleteReason;
+		}
+		out.push(fact);
+	}
+
+	for (const r of model.routines ?? []) {
+		const stableObject = idCvt.toStableObjectId(r.objectId);
+		const stableId = idCvt.toStableRoutineIdFromParts(
+			stableObject,
+			r.canonical.normalizedSignatureHash,
+		);
+		const visibility = mapVisibility(r.accessModifier);
+		const attributes = (r.attributesParsed ?? []).map(fingerprintAttribute);
+		const rAny = r as unknown as Record<string, unknown>;
+		const obsoleteState = rAny.obsoleteState as "Pending" | "Removed" | "No" | undefined;
+		const obsoleteReason = rAny.obsoleteReason as string | undefined;
+
+		// Re-derive the signature text and hash it — keeps snapshot derivation
+		// self-contained and independent of the internal normalizedSignatureHash.
+		const sigText = canonicalRoutineSignature(
+			r.name,
+			r.parameters,
+			rAny.returnTypeText as string | undefined,
+		);
+
+		const fact: ContractFact = {
+			kind: "routine",
+			stableId,
+			visibility,
+			signatureFingerprint: sha256(sigText),
+			attributes,
+		};
+		if (obsoleteState !== undefined && obsoleteState !== "No") {
+			fact.obsoleteState = obsoleteState;
+		}
+		if (obsoleteReason !== undefined) {
+			fact.obsoleteReason = obsoleteReason;
+		}
+		out.push(fact);
+	}
+
+	out.sort((a, b) => a.stableId.localeCompare(b.stableId));
+	return out;
+}
+
+function mapVisibility(am: unknown): ContractFact["visibility"] {
+	if (typeof am !== "string") return "public";
+	const lc = am.toLowerCase();
+	if (lc === "public") return "public";
+	if (lc === "internal") return "internal";
+	if (lc === "protected") return "protected";
+	if (lc === "local") return "local";
+	return "public";
+}
+
+function fingerprintAttribute(a: {
+	name: string;
+	args?: unknown[];
+}): AttributeFingerprint {
+	return {
+		name: a.name,
+		argsHash: sha256(canonicalJson(a.args ?? [])),
+	};
+}
+
+function canonicalJson(v: unknown): string {
+	if (v === null || typeof v !== "object") return JSON.stringify(v);
+	if (Array.isArray(v)) return `[${v.map(canonicalJson).join(",")}]`;
+	const o = v as Record<string, unknown>;
+	const keys = Object.keys(o).sort();
+	return `{${keys.map((k) => `${JSON.stringify(k)}:${canonicalJson(o[k])}`).join(",")}}`;
+}
+
+function sha256(s: string): string {
+	return createHash("sha256").update(s, "utf8").digest("hex");
+}

package/src/snapshot/derive/coverage.ts

@@ -0,0 +1,35 @@
+import type { CoverageRecord } from "../../model/coverage.ts";
+import type { SemanticModel } from "../../model/model.ts";
+import { createIdentityIndex } from "../../model/stable-identity.ts";
+import type { StableRoutineId } from "../../model/stable-identity.ts";
+import type { SnapshotIdentityTable } from "../types.ts";
+
+/**
+ * Flatten per-routine summary.coverage to CoverageRecord[] with subject
+ * rewritten internal RoutineId → StableRoutineId via routine.canonical
+ * .normalizedSignatureHash.
+ *
+ * Sorted by subject.
+ */
+export function deriveCoverage(
+	model: SemanticModel,
+	_idx: SnapshotIdentityTable,
+): CoverageRecord[] {
+	const idCvt = createIdentityIndex();
+	const out: CoverageRecord[] = [];
+	for (const r of model.routines ?? []) {
+		const cov = r.summary?.coverage;
+		if (cov === undefined) continue;
+		const stableObject = idCvt.toStableObjectId(r.objectId);
+		const stableSubject = idCvt.toStableRoutineIdFromParts(
+			stableObject,
+			r.canonical?.normalizedSignatureHash ?? "",
+		) as StableRoutineId;
+		out.push({
+			...cov,
+			subject: stableSubject as unknown as typeof cov.subject,
+		});
+	}
+	out.sort((a, b) => String(a.subject).localeCompare(String(b.subject)));
+	return out;
+}

package/src/snapshot/derive/event-declarations.ts

@@ -0,0 +1,140 @@
+// src/snapshot/derive/event-declarations.ts
+//
+// Project model.eventGraph into a bipartite EventDeclaration[]:
+//
+//   publisher entries — one per EventSymbol (routines with
+//     [IntegrationEvent] / [BusinessEvent] / [InternalEvent] attributes),
+//     sourced from eventGraph.events.
+//
+//   subscriber entries — one per EventEdge (routines with
+//     [EventSubscriber(…)] attributes), sourced from eventGraph.edges,
+//     carrying a SubscriberBinding = {publisherObject, eventName}.
+//
+// StableEventId format: `${stablePublisherObject}::${eventName}::${signatureHash}`
+// (via IdentityIndex.toStableEventId).
+//
+// Sort key: (kind, routine, eventId).
+
+import type { EventEdge, EventSymbol } from "../../model/graph.ts";
+import type { SemanticModel } from "../../model/model.ts";
+import { createIdentityIndex } from "../../model/stable-identity.ts";
+import type {
+	StableEventId,
+	StableObjectId,
+	StableRoutineId,
+} from "../../model/stable-identity.ts";
+import type { EventDeclaration, SnapshotIdentityTable, SubscriberBinding } from "../types.ts";
+
+/**
+ * Project model.eventGraph into bipartite EventDeclaration[]:
+ *   publisher entries — one per routine with [IntegrationEvent] /
+ *                       [BusinessEvent] / [InternalEvent] attribute
+ *                       (from eventGraph.events)
+ *   subscriber entries — one per routine with [EventSubscriber(…)]
+ *                        attribute (from eventGraph.edges), carrying
+ *                        SubscriberBinding = {publisherObject, eventName}
+ *
+ * Sorted by (kind, routine, eventId).
+ */
+export function deriveEventDeclarations(
+	model: SemanticModel,
+	_idx: SnapshotIdentityTable,
+): EventDeclaration[] {
+	const idCvt = createIdentityIndex();
+
+	// Build a RoutineId → StableRoutineId lookup and a RoutineId → sourceAnchor lookup.
+	const routineToStable = new Map<string, StableRoutineId>();
+	const routineToAnchor = new Map<string, (typeof model.routines)[number]["sourceAnchor"]>();
+
+	for (const r of model.routines ?? []) {
+		const stableObject = idCvt.toStableObjectId(r.objectId);
+		const stable = idCvt.toStableRoutineIdFromParts(
+			stableObject,
+			r.canonical?.normalizedSignatureHash ?? "",
+		) as StableRoutineId;
+		const rid = r.id as unknown as string;
+		routineToStable.set(rid, stable);
+		routineToAnchor.set(rid, r.sourceAnchor);
+	}
+
+	// Build an EventId → EventSymbol lookup for subscriber binding resolution.
+	const eventById = new Map<string, EventSymbol>();
+	for (const evt of model.eventGraph?.events ?? []) {
+		eventById.set(evt.id as unknown as string, evt);
+	}
+
+	const out: EventDeclaration[] = [];
+
+	// Publisher entries — one per EventSymbol that has a publisherRoutineId.
+	for (const evt of model.eventGraph?.events ?? []) {
+		const pubRoutineKey = evt.publisherRoutineId as unknown as string | undefined;
+		if (!pubRoutineKey) continue;
+
+		const stableRoutine = routineToStable.get(pubRoutineKey);
+		const anchor = routineToAnchor.get(pubRoutineKey);
+		if (stableRoutine === undefined || anchor === undefined) continue;
+
+		const stablePublisherObject = idCvt.toStableObjectId(
+			evt.publisherObjectId as unknown as string,
+		) as StableObjectId;
+		const eventId = idCvt.toStableEventId(
+			stablePublisherObject,
+			evt.eventName,
+			evt.signatureHash,
+		) as StableEventId;
+
+		out.push({
+			kind: "publisher",
+			routine: stableRoutine,
+			eventId,
+			sourceAnchor: anchor,
+		});
+	}
+
+	// Subscriber entries — one per EventEdge.
+	for (const edge of model.eventGraph?.edges ?? []) {
+		const subRoutineKey = edge.subscriberRoutineId as unknown as string;
+		const stableRoutine = routineToStable.get(subRoutineKey);
+		const anchor = routineToAnchor.get(subRoutineKey);
+		if (stableRoutine === undefined || anchor === undefined) continue;
+
+		// Look up the associated EventSymbol to get publisher object + event name.
+		const eventKey = edge.eventId as unknown as string;
+		const evt = eventById.get(eventKey);
+
+		const stablePublisherObject = (
+			evt
+				? idCvt.toStableObjectId(evt.publisherObjectId as unknown as string)
+				: (eventKey as string)
+		) as StableObjectId;
+
+		const eventName = evt?.eventName ?? "";
+		const signatureHash = evt?.signatureHash ?? "";
+
+		const eventId = idCvt.toStableEventId(
+			stablePublisherObject,
+			eventName,
+			signatureHash,
+		) as StableEventId;
+
+		const binding: SubscriberBinding = {
+			publisherObject: stablePublisherObject,
+			eventName,
+		};
+
+		out.push({
+			kind: "subscriber",
+			routine: stableRoutine,
+			eventId,
+			binding,
+			sourceAnchor: anchor,
+		});
+	}
+
+	out.sort((a, b) =>
+		[a.kind, String(a.routine), String(a.eventId)]
+			.join("|")
+			.localeCompare([b.kind, String(b.routine), String(b.eventId)].join("|")),
+	);
+	return out;
+}

package/src/snapshot/derive/identity-table.ts

@@ -0,0 +1,58 @@
+// src/snapshot/derive/identity-table.ts
+//
+// Walk the SemanticModel and produce a SnapshotIdentityTable — every
+// Stable*Id referenced anywhere in the snapshot paired with a human-readable
+// display name. Output is sorted by stableId and deduped so that
+// (stableIds[i], displayNames[i]) is a 1:1 pairing.
+//
+// Currently covers objects, tables, and routines. Phase 1+ derivers add
+// events, fields, and permission sets via the same map-then-sort pattern.
+//
+// Routine StableId: `${stableObjectId}#${normalizedSignatureHash}` — the
+// hash comes from `routine.canonical.normalizedSignatureHash`, which both the
+// native-AL and .app-symbol paths populate via canonicalRoutineSignature.
+
+import type { SemanticModel } from "../../model/model.ts";
+import { createIdentityIndex } from "../../model/stable-identity.ts";
+import type { SnapshotIdentityTable } from "../types.ts";
+
+/**
+ * Walk the model, collect every Stable*Id referenced in the snapshot + pair
+ * with a human-readable display name. Output sorted by stableId and deduped —
+ * (stableIds[i], displayNames[i]) is a 1:1 pairing.
+ *
+ * Currently collects:
+ *   - objects:  every entry in model.objects   → toStableObjectId
+ *   - tables:   every entry in model.tables    → toStableTableId
+ *   - routines: every entry in model.routines  → toStableRoutineIdFromParts(stableObject, sigHash)
+ *
+ * Phase 1+ derivers add events, fields, permission sets via the same
+ * map-then-sort pattern.
+ */
+export function deriveIdentityTable(model: SemanticModel): SnapshotIdentityTable {
+	const idx = createIdentityIndex();
+	const pairs = new Map<string, string>();
+
+	for (const obj of model.objects ?? []) {
+		const stable = idx.toStableObjectId(obj.id);
+		pairs.set(stable, obj.name);
+	}
+
+	for (const tbl of model.tables ?? []) {
+		const stable = idx.toStableTableId(tbl.id);
+		pairs.set(stable, tbl.name);
+	}
+
+	for (const r of model.routines ?? []) {
+		const stableObject = idx.toStableObjectId(r.objectId);
+		// normalizedSignatureHash is populated on both native-AL and .app-symbol
+		// paths by canonicalRoutineSignature — use it directly.
+		const sigHash = r.canonical.normalizedSignatureHash;
+		const stable = idx.toStableRoutineIdFromParts(stableObject, sigHash);
+		pairs.set(stable, r.name);
+	}
+
+	const stableIds = Array.from(pairs.keys()).sort();
+	const displayNames = stableIds.map((id) => pairs.get(id) ?? "");
+	return { stableIds, displayNames };
+}