al-sem 0.0.1

package/src/index/capability/dispatch.ts

@@ -0,0 +1,164 @@
+// src/index/capability/dispatch.ts
+//
+// Phase 0b-β dispatch family extractor. Detects dynamic object-dispatch calls:
+//
+//   object-run callees (pre-classified by the Callee model at L2):
+//     Codeunit.Run(targetId, ...)  → execute, codeunit
+//     Page.Run(targetId, ...)      → execute, page
+//     Report.Run(targetId, ...)    → execute, report
+//
+//   member callees (not pre-classified as object-run by the L2 indexer):
+//     Page.RunModal(targetId, ...) → execute, page, modal: true
+//     Report.Execute(targetId, ...) → execute, report
+//
+// Target-id argument (1st positional) is classified via classifyValueSource:
+//   literal / enum / database_reference → static
+//   parameter                           → userDynamic
+//   table-field                         → configDynamic
+//   expression / unknown                → unresolved
+//
+// resourceId resolution is deferred — stable-identity map wiring through to
+// extraction time is a Phase 1c follow-up.
+//
+// Never throws.
+
+import type { ObjectRunKind } from "../../model/callee.ts";
+import type {
+	CapabilityConfidence,
+	CapabilityFact,
+	DispatchExtra,
+	ValueSource,
+} from "../../model/capability.ts";
+import type { CoverageReason } from "../../model/coverage.ts";
+import type { ExtractionContext } from "./extractor.ts";
+import { classifyValueSource } from "./value-source.ts";
+
+// ─── Member-callee dispatch table ────────────────────────────────────────────
+// Covers methods that the L2 indexer does NOT pre-classify as "object-run"
+// because they use non-canonical method names (RunModal, Execute).
+
+interface MemberDispatchSpec {
+	objectType: ObjectRunKind;
+	modal?: true;
+}
+
+// Keys are lowercased "receiver|method" pairs.
+const MEMBER_DISPATCH_MAP = new Map<string, MemberDispatchSpec>([
+	["page|runmodal", { objectType: "Page", modal: true }],
+	["report|execute", { objectType: "Report" }],
+]);
+
+// ─── Public extractor ─────────────────────────────────────────────────────────
+
+/**
+ * Phase 0b-β dispatch family extractor.
+ *
+ * Scans `callSites` for two callee shapes:
+ *  - `"object-run"` — pre-classified by the L2 indexer for `.Run` methods on
+ *    Codeunit / Page / Report. `objectKind` gives the target object type.
+ *  - `"member"` — for `Page.RunModal` and `Report.Execute`, which the L2
+ *    indexer emits as member callees because their method name differs from
+ *    the canonical `.Run`.
+ *
+ * Emits one `CapabilityFact` (op: "execute") per matched call site.
+ *
+ * Never throws.
+ */
+export function extractDispatch(ctx: ExtractionContext): {
+	facts: CapabilityFact[];
+	reasons: CoverageReason[];
+} {
+	try {
+		const facts: CapabilityFact[] = [];
+
+		for (const cs of ctx.routine?.features?.callSites ?? []) {
+			const callee = cs.callee;
+			if (!callee) continue;
+
+			if (callee.kind === "object-run") {
+				// Pre-classified by the L2 indexer: Codeunit.Run, Page.Run, Report.Run
+				const objectType = callee.objectKind;
+				const targetArgSource = classifyTargetArg(cs.argumentInfos, 0, ctx);
+				const extra: DispatchExtra = { kind: "dispatch", objectType };
+				facts.push(buildFact(ctx, objectType, targetArgSource, extra, cs.id));
+			} else if (callee.kind === "member") {
+				// Page.RunModal / Report.Execute — not pre-classified as object-run
+				const key = `${callee.receiver.toLowerCase()}|${callee.method.toLowerCase()}`;
+				const spec = MEMBER_DISPATCH_MAP.get(key);
+				if (spec === undefined) continue;
+
+				const targetArgSource = classifyTargetArg(cs.argumentInfos, 0, ctx);
+				const extra: DispatchExtra = {
+					kind: "dispatch",
+					objectType: spec.objectType,
+					...(spec.modal === true ? { modal: true } : {}),
+				};
+				facts.push(buildFact(ctx, spec.objectType, targetArgSource, extra, cs.id));
+			}
+		}
+
+		return { facts, reasons: [] };
+	} catch {
+		return { facts: [], reasons: ["extraction-failed"] };
+	}
+}
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function classifyTargetArg(
+	argumentInfos: readonly { kind: string; text: string }[] | undefined,
+	index: number,
+	ctx: ExtractionContext,
+): ValueSource {
+	const arg = argumentInfos?.[index];
+	return arg !== undefined ? classifyValueSource(arg as never, ctx) : { kind: "unknown" };
+}
+
+function buildFact(
+	ctx: ExtractionContext,
+	objectType: ObjectRunKind,
+	targetArgSource: ValueSource,
+	extra: DispatchExtra,
+	witnessCallsiteId: string,
+): CapabilityFact {
+	const resourceKind = objectTypeToResourceKind(objectType);
+	return {
+		subject: ctx.routine.id,
+		op: "execute",
+		resourceKind,
+		resourceArgSource: targetArgSource,
+		confidence: confidenceFromSource(targetArgSource),
+		provenance: "direct",
+		via: "self",
+		witnessCallsiteId,
+		extra,
+	};
+}
+
+function objectTypeToResourceKind(objectType: ObjectRunKind): "codeunit" | "page" | "report" {
+	switch (objectType) {
+		case "Codeunit":
+			return "codeunit";
+		case "Page":
+			return "page";
+		case "Report":
+			return "report";
+	}
+}
+
+function confidenceFromSource(vs: ValueSource): CapabilityConfidence {
+	switch (vs.kind) {
+		case "literal":
+		case "enum":
+			return "static";
+		case "constant-var":
+			return confidenceFromSource(vs.initializer);
+		case "parameter":
+			return "userDynamic";
+		case "table-field":
+			return "configDynamic";
+		case "expression":
+		case "unknown":
+			return "unresolved";
+	}
+}

package/src/index/capability/events.ts

@@ -0,0 +1,65 @@
+// src/index/capability/events.ts
+//
+// Phase 0b-β events family extractor. Scope: SUBSCRIBE side only.
+//
+// A routine with an [EventSubscriber(...)] attribute is a subscriber to a
+// published event. The structured attribute (already in routine.attributesParsed)
+// tells us which publisher + event name; for this phase we emit a presence
+// fact (op="subscribe", resourceKind="event") without resolving the publisher
+// routine — that happens in Task 20 (event-dispatch composition).
+//
+// PUBLISH side: routines with [IntegrationEvent] / [BusinessEvent] /
+// [InternalEvent] attributes emit NO fact here. publish facts arise on the
+// CALLER of a publisher, via event-dispatch edges (Task 20) + capability
+// composition (Task 22).
+//
+// Never throws.
+
+import { findAttribute } from "../../model/attributes.ts";
+import type { CapabilityFact, EventExtra } from "../../model/capability.ts";
+import type { CoverageReason } from "../../model/coverage.ts";
+import type { ExtractionContext } from "./extractor.ts";
+
+/**
+ * Phase 0b-β events family extractor.
+ *
+ * Emits one `subscribe` CapabilityFact for routines with an
+ * [EventSubscriber(...)] attribute. Publisher-decorated routines
+ * ([IntegrationEvent] / [BusinessEvent] / [InternalEvent]) emit nothing —
+ * their publish facts arise from callers via event-dispatch edges (Task 20).
+ *
+ * Never throws.
+ */
+export function extractEvents(ctx: ExtractionContext): {
+	facts: CapabilityFact[];
+	reasons: CoverageReason[];
+} {
+	try {
+		const attrs = ctx.routine?.attributesParsed ?? [];
+
+		if (findAttribute(attrs, "EventSubscriber") === undefined) {
+			return { facts: [], reasons: [] };
+		}
+
+		// TODO Phase 0b-β.5: detect Business/Internal/Trigger via publisher's
+		// attribute lookup rather than defaulting to "Integration".
+		const extra: EventExtra = {
+			kind: "event",
+			eventClass: "Integration",
+		};
+
+		const fact: CapabilityFact = {
+			subject: ctx.routine.id,
+			op: "subscribe",
+			resourceKind: "event",
+			confidence: "static",
+			provenance: "direct",
+			via: "self",
+			extra,
+		};
+
+		return { facts: [fact], reasons: [] };
+	} catch {
+		return { facts: [], reasons: ["extraction-failed"] };
+	}
+}

package/src/index/capability/extractor.ts

@@ -0,0 +1,124 @@
+import type { CapabilityFact } from "../../model/capability.ts";
+import type { CoverageReason, CoverageStatus } from "../../model/coverage.ts";
+import type { Routine, VariableSymbol } from "../../model/entities.ts";
+import type { Diagnostic } from "../../model/finding.ts";
+import { extractBackground } from "./background.ts";
+import { extractCommit } from "./commit.ts";
+import { extractDispatch } from "./dispatch.ts";
+import { extractEvents } from "./events.ts";
+import { extractFileBlob } from "./file-blob.ts";
+import { extractHttp } from "./http.ts";
+import { extractHyperlink } from "./hyperlink.ts";
+import { extractIsolatedStorage } from "./isolated-storage.ts";
+import { extractTable } from "./table.ts";
+import { extractTelemetry } from "./telemetry.ts";
+import { extractUi } from "./ui.ts";
+
+/**
+ * Context passed to capability extractors. Extractors emit diagnostics
+ * and coverage gaps via the sinks here — they MUST NEVER throw
+ * (engine-never-throws contract per CLAUDE.md, formalized for
+ * extractors in spec §3.10).
+ *
+ * Phase 0a defines the shape; Phase 0b populates `variables` and routes
+ * to family extractors. Phase 0a's orchestrator is a no-op shell.
+ */
+export interface ExtractionContext {
+	routine: Routine;
+	/** Per-name lookup over routine.features.variables (lowercased keys).
+	 *  Built once by the orchestrator before dispatching to family extractors. */
+	variables: Map<string, VariableSymbol>;
+	/** Resolves a member-call's receiver name to its declared type.
+	 *  Returns "unknown" when the variable isn't in the index. */
+	receiverTypeOf(receiverName: string): string;
+	reportDiagnostic(d: Diagnostic): void;
+	reportCoverageGap(reason: CoverageReason, target?: string): void;
+}
+
+/**
+ * What an extractor (orchestrator or family) returns.
+ *  - facts        — the capability facts the extractor was able to recognize
+ *  - status       — "complete" = ran cleanly; "partial" = some nodes skipped
+ *                   due to grammar/parse gaps (diagnostics emitted);
+ *                   "unknown" = extractor itself errored on input shape it
+ *                   didn't recognize. Phase 0a shell returns "unknown".
+ *  - reasons      — coverage reasons contributing to non-"complete" status.
+ *                   Phase 0a shell returns ["extraction-failed"] — the
+ *                   shell hasn't extracted anything, so callers must treat
+ *                   the result as "we don't know".
+ *
+ * Extractors return `facts: []` only when the absence is KNOWN (no calls
+ * of the relevant family in the body). Phase 0a's shell returns
+ * `facts: []` because no extraction logic exists yet; the "unknown"
+ * status tells callers not to confuse this with "known absent".
+ */
+export interface CapabilityExtractionResult {
+	facts: CapabilityFact[];
+	status: CoverageStatus;
+	reasons: CoverageReason[];
+}
+
+/**
+ * Phase 0b-β orchestrator. Dispatches across all 11 family extractors,
+ * aggregates facts + reasons, rolls up overall status.
+ *
+ * Status roll-up:
+ *  - "complete" when no family reported reasons
+ *  - "partial"  when some families reported coverage reasons
+ *  - "unknown"  when the orchestrator itself threw (caught by outer try/catch)
+ *
+ * The orchestrator always rebuilds ctx.variables from routine.features.variables
+ * internally — callers pass any ctx (even a partially-constructed one); the
+ * orchestrator uses its own variable index for family dispatch. This ensures
+ * extraction is reproducible regardless of caller setup.
+ *
+ * Engine-never-throws contract per CLAUDE.md.
+ */
+export function extractCapabilities(
+	routine: Routine,
+	ctx: ExtractionContext,
+): CapabilityExtractionResult {
+	try {
+		// Rebuild variables Map from routine.features (caller's may be stale).
+		const variables = new Map<string, VariableSymbol>();
+		for (const v of routine?.features?.variables ?? []) {
+			variables.set(v.name, v);
+		}
+		const dispatchCtx: ExtractionContext = {
+			routine,
+			variables,
+			receiverTypeOf: (name) => variables.get(name.toLowerCase())?.declaredType ?? "unknown",
+			reportDiagnostic: ctx.reportDiagnostic,
+			reportCoverageGap: ctx.reportCoverageGap,
+		};
+
+		const allFacts: CapabilityFact[] = [];
+		const allReasons: CoverageReason[] = [];
+
+		for (const extractor of [
+			extractTable,
+			extractCommit,
+			extractDispatch,
+			extractHttp,
+			extractTelemetry,
+			extractIsolatedStorage,
+			extractHyperlink,
+			extractFileBlob,
+			extractBackground,
+			extractUi,
+			extractEvents,
+		]) {
+			const { facts, reasons } = extractor(dispatchCtx);
+			allFacts.push(...facts);
+			allReasons.push(...reasons);
+		}
+
+		const status: CoverageStatus = allReasons.length === 0 ? "complete" : "partial";
+		// Dedupe + sort reasons for determinism.
+		const dedupedReasons = Array.from(new Set(allReasons)).sort();
+
+		return { facts: allFacts, status, reasons: dedupedReasons };
+	} catch {
+		return { facts: [], status: "unknown", reasons: ["extraction-failed"] };
+	}
+}

package/src/index/capability/file-blob.ts

@@ -0,0 +1,137 @@
+import type { CapabilityConfidence, CapabilityFact, ValueSource } from "../../model/capability.ts";
+import type { CoverageReason } from "../../model/coverage.ts";
+import type { ExtractionContext } from "./extractor.ts";
+import { classifyValueSource } from "./value-source.ts";
+
+// Probe result: F.Create / F.WriteAllText / TB.CreateOutStream all land in
+// callSites as member callees. F.Copy lands in recordOperations (op="Copy")
+// because RECORD_OP_MAP matches "copy" regardless of receiver type.
+
+/** Write-side File methods found in callSites (member callee). */
+const FILE_CALLSITE_METHODS = new Set(["create", "writealltext"]);
+
+/** Write-side TempBlob methods found in callSites (member callee). */
+const TEMPBLOB_CALLSITE_METHODS = new Set(["createoutstream"]);
+
+/** Write-side ops found in recordOperations for File-typed receivers. */
+const FILE_RECORD_OPS = new Set(["copy"]);
+
+/**
+ * Phase 0b-β file-blob family extractor. Detects write-side method calls on
+ * variables typed `File` or `Codeunit "Temp Blob"`.
+ *
+ * Maps to op="write-blob", resourceKind="file". Receiver type resolved via
+ * ctx.receiverTypeOf, keyed against the normalised declared-type strings:
+ *   - File variables → "File"
+ *   - TempBlob variables → 'Codeunit "Temp Blob"' (quotes preserved)
+ *
+ * Probed split: callSites handle Create / WriteAllText / CreateOutStream;
+ * recordOperations handles Copy (RECORD_OP_MAP picks it up by name
+ * independently of receiver type — the File-type guard filters it here).
+ *
+ * The first positional arg, when present (filename/path), is classified as a
+ * ValueSource and exposed via resourceArgSource. Methods with no filename arg
+ * (CreateOutStream, Copy-via-recordOp which carries no fieldArgumentInfos)
+ * receive { kind: "unknown" } → confidence "unresolved".
+ *
+ * Read-side methods (.CreateInStream, etc.) are deliberately out of scope.
+ *
+ * Never throws.
+ */
+export function extractFileBlob(ctx: ExtractionContext): {
+	facts: CapabilityFact[];
+	reasons: CoverageReason[];
+} {
+	try {
+		const facts: CapabilityFact[] = [];
+
+		// Branch A: callSites — File.Create, File.WriteAllText, TempBlob.CreateOutStream.
+		for (const cs of ctx.routine?.features?.callSites ?? []) {
+			const callee = cs.callee;
+			if (!callee || callee.kind !== "member") continue;
+			if (typeof callee.receiver !== "string" || typeof callee.method !== "string") continue;
+			const methodLc = callee.method.toLowerCase();
+			const receiverType = ctx.receiverTypeOf(callee.receiver);
+
+			const isFile = receiverType === "File" && FILE_CALLSITE_METHODS.has(methodLc);
+			const isTempBlob = isTempBlobType(receiverType) && TEMPBLOB_CALLSITE_METHODS.has(methodLc);
+			if (!isFile && !isTempBlob) continue;
+
+			// First arg is the filename/path (Create, WriteAllText) or an OutStream
+			// (CreateOutStream — no filename semantics). Classify either way;
+			// non-string args will resolve to "expression"/"unknown" → unresolved.
+			const argInfo = cs.argumentInfos?.[0];
+			const argSource: ValueSource =
+				argInfo !== undefined ? classifyValueSource(argInfo, ctx) : { kind: "unknown" };
+
+			facts.push({
+				subject: ctx.routine.id,
+				op: "write-blob",
+				resourceKind: "file",
+				resourceArgSource: argSource,
+				confidence: confidenceFromSource(argSource),
+				provenance: "direct",
+				via: "self",
+				witnessCallsiteId: cs.id,
+			});
+		}
+
+		// Branch B: recordOperations — File.Copy.
+		// RECORD_OP_MAP recognises "copy" by name regardless of receiver type,
+		// so it surfaces here. fieldArgumentInfos is absent for Copy (not in
+		// FIELD_ARGS_OPS), so arg source falls back to unknown → unresolved.
+		for (const ro of ctx.routine?.features?.recordOperations ?? []) {
+			const recv = ro.recordVariableName;
+			if (typeof recv !== "string") continue;
+			const receiverType = ctx.receiverTypeOf(recv);
+			if (receiverType !== "File") continue;
+			if (!FILE_RECORD_OPS.has(ro.op.toLowerCase())) continue;
+
+			const argInfo = ro.fieldArgumentInfos?.[0];
+			const argSource: ValueSource =
+				argInfo !== undefined ? classifyValueSource(argInfo, ctx) : { kind: "unknown" };
+
+			facts.push({
+				subject: ctx.routine.id,
+				op: "write-blob",
+				resourceKind: "file",
+				resourceArgSource: argSource,
+				confidence: confidenceFromSource(argSource),
+				provenance: "direct",
+				via: "self",
+				witnessOperationId: ro.id,
+			});
+		}
+
+		return { facts, reasons: [] };
+	} catch {
+		return { facts: [], reasons: ["extraction-failed"] };
+	}
+}
+
+/**
+ * Match the normalised declared-type for TempBlob variables.
+ * Probe result: `Codeunit "Temp Blob"` (with double-quotes around the object
+ * name, as the variable-symbol normaliser preserves them).
+ */
+function isTempBlobType(t: string): boolean {
+	const lc = t.toLowerCase();
+	return lc.includes("temp blob") || lc === "tempblob";
+}
+
+function confidenceFromSource(vs: ValueSource): CapabilityConfidence {
+	switch (vs.kind) {
+		case "literal":
+		case "enum":
+			return "static";
+		case "constant-var":
+			return confidenceFromSource(vs.initializer);
+		case "parameter":
+			return "userDynamic";
+		case "table-field":
+			return "configDynamic";
+		case "expression":
+		case "unknown":
+			return "unresolved";
+	}
+}

package/src/index/capability/http.ts

@@ -0,0 +1,159 @@
+import type {
+	CapabilityConfidence,
+	CapabilityFact,
+	HttpExtra,
+	ValueSource,
+} from "../../model/capability.ts";
+import type { CoverageReason } from "../../model/coverage.ts";
+import type { CallsiteId, OperationId } from "../../model/ids.ts";
+import type { ExtractionContext } from "./extractor.ts";
+import { classifyValueSource } from "./value-source.ts";
+
+const HTTP_METHOD_SET = new Set<HttpExtra["method"]>([
+	"Send",
+	"Get",
+	"Post",
+	"Put",
+	"Delete",
+	"Patch",
+]);
+
+function isHttpMethod(v: string): v is HttpExtra["method"] {
+	return HTTP_METHOD_SET.has(v as HttpExtra["method"]);
+}
+
+function buildHttpFact(
+	ctx: ExtractionContext,
+	method: HttpExtra["method"],
+	urlSource: ValueSource,
+	bodyArgSource: ValueSource | undefined,
+	witness: { kind: "operation"; id: OperationId } | { kind: "callsite"; id: CallsiteId },
+): CapabilityFact {
+	const extra: HttpExtra = {
+		kind: "http",
+		method,
+		...(bodyArgSource !== undefined ? { bodyArgSource } : {}),
+	};
+	const witnessFields =
+		witness.kind === "operation"
+			? { witnessOperationId: witness.id }
+			: { witnessCallsiteId: witness.id };
+	return {
+		subject: ctx.routine.id,
+		op: "send",
+		resourceKind: "http",
+		resourceArgSource: urlSource,
+		confidence: confidenceFromSource(urlSource),
+		provenance: "direct",
+		via: "self",
+		...witnessFields,
+		extra,
+	};
+}
+
+/**
+ * Phase 0b-β http family extractor. Scans both `recordOperations` and
+ * `callSites` for HttpClient method calls.
+ *
+ * Why both? `intraprocedural-ops.ts` recognizes any `Receiver.Get(...)` /
+ * `.Delete(...)` as a RecordOperation regardless of receiver type — so HTTP
+ * `.Get` and `.Delete` land in `recordOperations`. The other methods (`.Post`,
+ * `.Put`, `.Patch`, `.Send`) surface as member callsites. The receiver-type
+ * guard via `ctx.receiverTypeOf(recv) === "HttpClient"` identifies which calls
+ * are actually HTTP.
+ *
+ * URL ValueSource (1st arg for url-taking methods) drives confidence:
+ *   literal/enum → static, parameter → userDynamic, table-field → configDynamic,
+ *   expression/unknown → unresolved, constant-var → recurse on initializer.
+ *
+ * Body ValueSource (2nd arg for url-taking methods, 1st arg for `.Send`)
+ * captured in HttpExtra.bodyArgSource for Phase 6 taint propagation.
+ *
+ * `.Delete` has no fieldArgumentInfos (not in FIELD_ARGS_OPS in
+ * intraprocedural-ops.ts) — urlSource falls back to `{ kind: "unknown" }` and
+ * confidence to "unresolved". This is intentional: Delete takes the key-filter
+ * state already set on the record, not a URL argument.
+ *
+ * Never throws.
+ */
+export function extractHttp(ctx: ExtractionContext): {
+	facts: CapabilityFact[];
+	reasons: CoverageReason[];
+} {
+	try {
+		const facts: CapabilityFact[] = [];
+
+		// Branch A: HttpClient.Get / .Delete from recordOperations.
+		// `intraprocedural-ops.ts` maps `.get` and `.delete` via RECORD_OP_MAP
+		// regardless of the receiver's declared type — we filter here.
+		for (const ro of ctx.routine?.features?.recordOperations ?? []) {
+			const recv = ro.recordVariableName;
+			if (typeof recv !== "string") continue;
+			if (ctx.receiverTypeOf(recv) !== "HttpClient") continue;
+			const method = ro.op;
+			if (!isHttpMethod(method)) continue;
+
+			// Get captures fieldArgumentInfos (in FIELD_ARGS_OPS); Delete does not.
+			const urlInfo = ro.fieldArgumentInfos?.[0];
+			const urlSource: ValueSource =
+				urlInfo !== undefined ? classifyValueSource(urlInfo, ctx) : { kind: "unknown" };
+
+			const bodyInfo = ro.fieldArgumentInfos?.[1];
+			const bodyArgSource: ValueSource | undefined =
+				bodyInfo !== undefined ? classifyValueSource(bodyInfo, ctx) : undefined;
+
+			facts.push(
+				buildHttpFact(ctx, method, urlSource, bodyArgSource, { kind: "operation", id: ro.id }),
+			);
+		}
+
+		// Branch B: HttpClient.Post / .Put / .Patch / .Send from callSites.
+		// These are member callsites (callee.kind === "member") not caught by
+		// RECORD_OP_MAP. Callee fields: `receiver` (receiver expr text) and
+		// `method` (method name). Both confirmed from the Callee model type.
+		for (const cs of ctx.routine?.features?.callSites ?? []) {
+			const callee = cs.callee;
+			if (!callee || callee.kind !== "member") continue;
+			const recv = callee.receiver;
+			const member = callee.method;
+			if (ctx.receiverTypeOf(recv) !== "HttpClient") continue;
+			if (!isHttpMethod(member)) continue;
+
+			// .Send(Request, Response) — no URL arg; first arg is the request body.
+			// .Post/.Put/.Patch(Url, Request, Response) — first arg is URL, second is body.
+			const isSend = member === "Send";
+			const urlInfo = isSend ? undefined : cs.argumentInfos?.[0];
+			const bodyInfo = isSend ? cs.argumentInfos?.[0] : cs.argumentInfos?.[1];
+
+			const urlSource: ValueSource =
+				urlInfo !== undefined ? classifyValueSource(urlInfo, ctx) : { kind: "unknown" };
+			const bodyArgSource: ValueSource | undefined =
+				bodyInfo !== undefined ? classifyValueSource(bodyInfo, ctx) : undefined;
+
+			facts.push(
+				buildHttpFact(ctx, member, urlSource, bodyArgSource, { kind: "callsite", id: cs.id }),
+			);
+		}
+
+		return { facts, reasons: [] };
+	} catch {
+		return { facts: [], reasons: ["extraction-failed"] };
+	}
+}
+
+function confidenceFromSource(vs: ValueSource): CapabilityConfidence {
+	switch (vs.kind) {
+		case "literal":
+		case "enum":
+			return "static";
+		case "constant-var":
+			return confidenceFromSource(vs.initializer);
+		case "parameter":
+			return "userDynamic";
+		case "table-field":
+			return "configDynamic";
+		case "expression":
+		case "unknown":
+			return "unresolved";
+	}
+}