@shortlink-org/portolan 0.2.4 → 0.4.0

package/plugins/extract-http-clients/extract_test.go

@@ -0,0 +1,1561 @@
+package extracthttpclients
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/shortlink-org/portolan/catalog"
+	"github.com/shortlink-org/portolan/internal/gohttp"
+	"github.com/shortlink-org/portolan/plugin"
+)
+
+func writeHTTPFixture(t *testing.T, root, name, contents string) {
+	t.Helper()
+	path := filepath.Join(root, name)
+	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(path, []byte(contents), 0o644); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestExtractsRawGeneratedAndSOAPClients(t *testing.T) {
+	root := t.TempDir()
+	writeHTTPFixture(t, root, "go.mod", "module example.com/gateway\n")
+	writeHTTPFixture(t, root, "partner/openapi.yaml", `openapi: 3.0.3
+info:
+  title: Partner API
+  version: 1.2.0
+paths:
+  /v1/trips/{tripId}:
+    get:
+      operationId: getTrip
+      tags: [trips]
+`)
+	writeHTTPFixture(t, root, "partner/client.gen.go", `// Code generated by oapi-codegen; DO NOT EDIT.
+package partner
+import (
+  "context"
+  "fmt"
+  "net/http"
+)
+type Client struct{}
+type ClientInterface interface { GetTrip(context.Context, string) (*http.Response, error) }
+func NewGetTripRequest(server, tripID string) (*http.Request, error) {
+  operationPath := fmt.Sprintf("/v1/trips/%s", tripID)
+  return http.NewRequest(http.MethodGet, server+operationPath, nil)
+}
+
+`)
+	writeHTTPFixture(t, root, "partner/adapter.go", `package partner
+import "context"
+func Load(ctx context.Context, c *Client, id string) error {
+  _, err := c.GetTripWithResponse(ctx, id)
+  return err
+}
+`)
+	writeHTTPFixture(t, root, "core/update.go", `package core
+import (
+  "bytes"
+  "context"
+  "net/http"
+)
+const updatePath = "/v1/update"
+func Update(ctx context.Context, baseURL string, body []byte) error {
+  req, err := http.NewRequestWithContext(ctx, http.MethodPost, baseURL+updatePath, bytes.NewReader(body))
+  if err != nil { return err }
+  _ = req
+  return nil
+}
+`)
+	writeHTTPFixture(t, root, "transport/handler.go", `package transport
+import (
+  "context"
+  "example.com/gateway/core"
+)
+func Handle(ctx context.Context, baseURL string, body []byte) error {
+  return core.Update(ctx, baseURL, body)
+}
+`)
+	writeHTTPFixture(t, root, "soap/cancel.go", `package soapclient
+import (
+  "context"
+  soap "github.com/hooklift/gowsdl/soap"
+)
+const CancelAction = "urn:CancelBooking"
+func Cancel(ctx context.Context, client soap.HTTPClient, request, response any) error {
+  if request == nil {
+    return nil
+  }
+  return client.CallContext(ctx, CancelAction, request, response)
+}
+`)
+	writeHTTPFixture(t, root, "soap/booking.wsdl", `<?xml version="1.0"?>
+<definitions name="BookingService" targetNamespace="urn:booking"
+  xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
+  xmlns:tns="urn:booking"
+  xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+  xmlns="http://schemas.xmlsoap.org/wsdl/">
+  <message name="CancelRequest"><part name="body" type="xsd:string"/></message>
+  <message name="CancelResponse"><part name="body" type="xsd:string"/></message>
+  <portType name="BookingPortType">
+    <operation name="CancelBooking"><input message="tns:CancelRequest"/><output message="tns:CancelResponse"/></operation>
+  </portType>
+  <binding name="BookingBinding" type="tns:BookingPortType">
+    <soap:binding style="document"/>
+    <operation name="CancelBooking">
+      <soap:operation soapAction="urn:CancelBooking"/>
+    </operation>
+  </binding>
+  <service name="BookingService">
+    <port name="BookingPort" binding="tns:BookingBinding">
+      <soap:address location="https://booking.example/soap"/>
+    </port>
+  </service>
+</definitions>
+`)
+
+	resp, err := extract(plugin.Input{Root: root}, Options{Context: "edge", Service: "gateway"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var got catalog.Catalog
+	if err := json.Unmarshal([]byte(resp.Files[0].Contents), &got); err != nil {
+		t.Fatal(err)
+	}
+	service := got.Contexts[0].Services[0]
+	if len(service.Consumes) != 3 {
+		t.Fatalf("consumes = %+v", service.Consumes)
+	}
+	var generated, raw, soapCall *catalog.RpcCall
+	for i := range service.Consumes {
+		call := &service.Consumes[i]
+		switch {
+		case strings.Contains(call.ID, "getTrip"):
+			generated = call
+		case strings.Contains(call.ID, "POST /v1/update"):
+			raw = call
+		case strings.Contains(call.ID, "CancelBooking"):
+			soapCall = call
+		}
+	}
+	if generated == nil || generated.Status != catalog.StatusDeclared || generated.Peer != "partner" {
+		t.Fatalf("generated = %+v", generated)
+	}
+	if raw == nil || raw.Status != catalog.StatusUnresolved || raw.Source != "core/update.go:9" {
+		t.Fatalf("raw = %+v", raw)
+	}
+	if soapCall == nil || soapCall.Status != catalog.StatusDeclared || soapCall.Peer != "booking" {
+		t.Fatalf("soap = %+v", soapCall)
+	}
+	if len(got.Externals) != 2 {
+		t.Fatalf("externals = %+v", got.Externals)
+	}
+	if len(got.Flows) != 4 {
+		t.Fatalf("flows = %+v", got.Flows)
+	}
+	var sawCondition, sawChain bool
+	for _, flow := range got.Flows {
+		for _, node := range flow.Steps {
+			if step, ok := node.(*catalog.Step); ok && strings.Contains(step.Note, "request == nil") {
+				sawCondition = true
+			}
+			if step, ok := node.(*catalog.Step); ok && strings.Contains(step.Note, "Handle → Update") {
+				sawChain = true
+			}
+		}
+	}
+	if !sawCondition {
+		t.Fatal("SOAP source condition was not preserved")
+	}
+	if !sawChain {
+		t.Fatal("generic entry point was not followed to its outbound call")
+	}
+}
+
+func TestFlowTracesConfigThroughConstructorFieldAndWrapper(t *testing.T) {
+	root := t.TempDir()
+	writeHTTPFixture(t, root, "go.mod", "module example.com/payments\n")
+	writeHTTPFixture(t, root, "client/client.go", `package client
+import (
+  "context"
+  "net/http"
+	"net/url"
+)
+type Config struct { BaseURL string }
+type Client struct { baseURL url.URL }
+func Build(config map[string]string) (*Client, error) {
+  return New(Config{BaseURL: config["url"]})
+}
+func New(cfg Config) (*Client, error) {
+  parsed, err := url.Parse(cfg.BaseURL)
+  if err != nil { return nil, err }
+  return &Client{baseURL: *parsed}, nil
+}
+func (c *Client) request(ctx context.Context, method, path string) error {
+  req, err := http.NewRequestWithContext(ctx, method, c.baseURL.String()+path, nil)
+  if err != nil { return err }
+  _ = req
+  return nil
+}
+func (c *Client) Search(ctx context.Context) error {
+  return c.request(ctx, http.MethodPost, "/v1/search")
+}
+`)
+
+	resp, err := extract(plugin.Input{Root: root}, Options{Context: "pay", Service: "gateway"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var got catalog.Catalog
+	if err := json.Unmarshal([]byte(resp.Files[0].Contents), &got); err != nil {
+		t.Fatal(err)
+	}
+	if len(got.Flows) != 1 {
+		t.Fatalf("flows = %+v", got.Flows)
+	}
+	flow := got.Flows[0]
+	if flow.Name != "Client Search → outbound APIs" {
+		t.Fatalf("flow name = %q", flow.Name)
+	}
+	if flow.EntryPoint != "client:Client.Search" {
+		t.Fatalf("flow entrypoint = %q", flow.EntryPoint)
+	}
+	step, ok := flow.Steps[0].(*catalog.Step)
+	if !ok {
+		t.Fatalf("step = %#v", flow.Steps[0])
+	}
+	if step.Label != "POST /v1/search" {
+		t.Fatalf("step label = %q", step.Label)
+	}
+	if consumes := got.Contexts[0].Services[0].Consumes; len(consumes) != 1 || consumes[0].ID != "http-client/POST /v1/search" {
+		t.Fatalf("consumes = %+v", consumes)
+	}
+	if !strings.Contains(step.Note, `config["url"] → Build → New → Client.baseURL → request URL`) {
+		t.Fatalf("step note = %q", step.Note)
+	}
+	if !strings.Contains(step.Note, "Client.Search → Client.request") {
+		t.Fatalf("step chain = %q", step.Note)
+	}
+}
+
+func TestFlowKeepsDistinctCallsThroughClosureArguments(t *testing.T) {
+	root := t.TempDir()
+	writeHTTPFixture(t, root, "go.mod", "module example.com/closure\n")
+	writeHTTPFixture(t, root, "client.go", `package closure
+import (
+  "context"
+  "net/http"
+)
+func request(ctx context.Context, path string) error {
+  req, err := http.NewRequestWithContext(ctx, http.MethodGet, "https://example.test"+path, nil)
+  if err != nil { return err }
+  _ = req
+  return nil
+}
+func Refresh(ctx context.Context) {
+  go func(path string) { _ = request(ctx, path) }("/v1/primary")
+  go func(path string) { _ = request(ctx, path) }("/v1/secondary")
+}
+`)
+
+	resp, err := extract(plugin.Input{Root: root}, Options{Context: "ops", Service: "refresher"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var got catalog.Catalog
+	if err := json.Unmarshal([]byte(resp.Files[0].Contents), &got); err != nil {
+		t.Fatal(err)
+	}
+	if len(got.Flows) != 1 {
+		t.Fatalf("flows = %+v", got.Flows)
+	}
+	var labels []string
+	for _, node := range got.Flows[0].Steps {
+		if step, ok := node.(*catalog.Step); ok {
+			labels = append(labels, step.Label)
+		}
+	}
+	if strings.Join(labels, ",") != "GET /v1/primary,GET /v1/secondary" {
+		t.Fatalf("labels = %+v", labels)
+	}
+}
+
+func TestFlowDoesNotLinkMethodsByNameAlone(t *testing.T) {
+	root := t.TempDir()
+	writeHTTPFixture(t, root, "go.mod", "module example.com/close\n")
+	writeHTTPFixture(t, root, "client.go", `package close
+import "net/http"
+type LocalCloser struct{}
+func (LocalCloser) Close() error {
+  _, err := http.Get("https://audit.example/v1/closed")
+  return err
+}
+func Fetch() error {
+  response, err := http.Get("https://data.example/v1/items")
+  if err != nil { return err }
+  defer response.Body.Close()
+  return nil
+}
+`)
+
+	resp, err := extract(plugin.Input{Root: root}, Options{Context: "edge", Service: "reader"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var got catalog.Catalog
+	if err := json.Unmarshal([]byte(resp.Files[0].Contents), &got); err != nil {
+		t.Fatal(err)
+	}
+	for _, flow := range got.Flows {
+		if flow.Name != "Fetch → outbound APIs" {
+			continue
+		}
+		if len(flow.Steps) != 1 {
+			t.Fatalf("Fetch steps = %+v", flow.Steps)
+		}
+		step := flow.Steps[0].(*catalog.Step)
+		if step.Label != "GET /v1/items" {
+			t.Fatalf("Fetch step = %+v", step)
+		}
+		return
+	}
+	t.Fatalf("Fetch flow missing: %+v", got.Flows)
+}
+
+func TestBuildsEndpointRootedProviderFlowFromSource(t *testing.T) {
+	root := t.TempDir()
+	writeHTTPFixture(t, root, "go.mod", "module example.com/travel\n")
+	writeHTTPFixture(t, root, "app/main.go", `package app
+import (
+  "example.com/travel/actions/search"
+  "example.com/travel/connector"
+)
+type Router struct{}
+func (*Router) POST(string, func()) {}
+type Requester interface { ConnExec(connector.API) }
+func Start(r *Router) {
+  r.POST("/search", func() { SearchAction() })
+  app := App{}
+  r.POST("/direct-search", app.DirectSearch)
+}
+type App struct{}
+func (App) DirectSearch() {
+  conn := connector.BuildConnector("runtime-name")
+  conn.Search()
+}
+func SearchAction() {
+  request := &search.Request{}
+  ActionFlow(request)
+}
+func ActionFlow(request Requester) {
+  conn := connector.BuildConnector("runtime-name")
+  request.ConnExec(conn)
+}
+`)
+	writeHTTPFixture(t, root, "actions/search/request.go", `package search
+import "example.com/travel/connector"
+type Request struct{}
+func (*Request) ConnExec(conn connector.API) { conn.Search() }
+`)
+	writeHTTPFixture(t, root, "connector/factory.go", `package connector
+import (
+  "example.com/travel/provider/alpha"
+  "example.com/travel/provider/beta"
+  "example.com/travel/provider/opaque"
+)
+type API interface { Search() }
+func BuildConnector(name string) API {
+  switch name {
+  case "alpha":
+    return alpha.New()
+  case "beta":
+    client := beta.New()
+    return client
+  case "opaque":
+    return opaque.New()
+  default:
+    return nil
+  }
+}
+`)
+	writeHTTPFixture(t, root, "provider/opaque/client.go", `package opaque
+type Connector struct{}
+func New() *Connector { return &Connector{} }
+func (*Connector) Search() {}
+`)
+	writeHTTPFixture(t, root, "provider/alpha/client.go", `package alpha
+import (
+  alphaclient "example.com/travel/provider/alpha/client"
+  alphaport "example.com/travel/provider/alpha/port"
+)
+type Connector struct{ Client alphaport.API }
+func New() *Connector {
+  client := alphaclient.New()
+  return &Connector{Client: client}
+}
+func (c *Connector) Search() {
+  c.Client.Search()
+  c.Client.Retrieve()
+}
+`)
+	writeHTTPFixture(t, root, "provider/alpha/port/api.go", `package port
+type API interface {
+  Search()
+  Retrieve()
+}
+`)
+	writeHTTPFixture(t, root, "provider/alpha/client/client.go", `package client
+import "net/http"
+type Client struct{}
+func New() *Client { return &Client{} }
+func (c *Client) Search() { c.SearchRequest() }
+func (*Client) SearchRequest() { _, _ = http.Get("https://alpha.example/v1/search") }
+func (c *Client) Retrieve() { c.RetrieveRequest() }
+func (*Client) RetrieveRequest() { _, _ = http.Get("https://alpha.example/v1/retrieve") }
+`)
+	writeHTTPFixture(t, root, "provider/beta/client.go", `package beta
+import betaclient "example.com/travel/provider/beta/client"
+type Connector struct{ Client *betaclient.Client }
+func New() *Connector { return &Connector{Client: &betaclient.Client{}} }
+func (c *Connector) Search() { c.Client.Search() }
+`)
+	writeHTTPFixture(t, root, "provider/beta/client/client.go", `package client
+import "net/http"
+type Client struct{}
+func (*Client) Search() { _, _ = http.Get("https://beta.example/v2/offers") }
+`)
+	writeHTTPFixture(t, root, "jobs/refresh.go", `package jobs
+import "net/http"
+func Refresh() { _, _ = http.Get("https://cache.example/refresh") }
+`)
+
+	resp, err := extract(plugin.Input{Root: root}, Options{Context: "travel", Service: "search"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var got catalog.Catalog
+	if err := json.Unmarshal([]byte(resp.Files[0].Contents), &got); err != nil {
+		t.Fatal(err)
+	}
+	if len(got.Flows) != 3 {
+		t.Fatalf("flows = %+v", got.Flows)
+	}
+	var endpoint, direct, background *catalog.Flow
+	for index := range got.Flows {
+		flow := &got.Flows[index]
+		if flow.Name == "POST /search → provider APIs" {
+			endpoint = flow
+		}
+		if flow.Name == "POST /direct-search → provider APIs" {
+			direct = flow
+		}
+		if flow.Name == "Refresh → outbound APIs" {
+			background = flow
+		}
+		if strings.Contains(flow.Name, "Connector Search") {
+			t.Fatalf("covered provider fragment was retained: %+v", flow)
+		}
+		if flow.Name == "Alpha Search Request → outbound APIs" {
+			t.Fatalf("covered nested provider fragment was retained: %+v", flow)
+		}
+	}
+	if endpoint == nil || direct == nil || background == nil {
+		t.Fatalf("endpoint = %+v, direct = %+v, background = %+v", endpoint, direct, background)
+	}
+	if !strings.Contains(background.Summary, "No source caller was found") {
+		t.Fatalf("standalone reason = %q", background.Summary)
+	}
+	if len(endpoint.Steps) != 2 {
+		t.Fatalf("steps = %+v", endpoint.Steps)
+	}
+	inbound, ok := endpoint.Steps[0].(*catalog.Step)
+	if !ok || inbound.Label != "POST /search" || inbound.Line != "app/main.go:10" {
+		t.Fatalf("inbound = %+v", endpoint.Steps[0])
+	}
+	providers, ok := endpoint.Steps[1].(*catalog.Alt)
+	if !ok || len(providers.Branches) != 3 {
+		t.Fatalf("providers = %+v", endpoint.Steps[1])
+	}
+	if providers.Branches[0].Title != `connector = "alpha"` || providers.Branches[1].Title != `connector = "beta"` || providers.Branches[2].Title != `connector = "opaque"` {
+		t.Fatalf("branches = %+v", providers.Branches)
+	}
+	alphaStep := providers.Branches[0].Steps[0].(*catalog.Step)
+	betaStep := providers.Branches[1].Steps[0].(*catalog.Step)
+	if alphaStep.Label != "GET /v1/search" || betaStep.Label != "GET /v2/offers" {
+		t.Fatalf("provider steps = %+v / %+v", alphaStep, betaStep)
+	}
+	if len(providers.Branches[0].Steps) != 2 || providers.Branches[0].Steps[1].(*catalog.Step).Label != "GET /v1/retrieve" {
+		t.Fatalf("constructor-wired call order = %+v", providers.Branches[0].Steps)
+	}
+	if !strings.Contains(alphaStep.Note, "Connector.Search → Client.Search → Client.SearchRequest") {
+		t.Fatalf("nested provider chain = %+v", alphaStep)
+	}
+	if !strings.Contains(betaStep.Note, "Connector.Search → Client.Search") {
+		t.Fatalf("concrete imported client chain = %+v", betaStep)
+	}
+	opaqueStep := providers.Branches[2].Steps[0].(*catalog.Step)
+	if opaqueStep.Kind != catalog.StepCall || opaqueStep.Label != "Opaque Search" || !strings.Contains(opaqueStep.Note, "outbound transport was not resolved") {
+		t.Fatalf("opaque step = %+v", opaqueStep)
+	}
+}
+
+func TestBuildsEndpointThroughMultiStageInterfaceDispatch(t *testing.T) {
+	root := t.TempDir()
+	writeHTTPFixture(t, root, "go.mod", "module example.com/typed\n\ngo 1.27.0\n")
+	writeHTTPFixture(t, root, "app/main.go", `package app
+import (
+  "example.com/typed/actions/rules"
+  "example.com/typed/connector"
+)
+type Router struct{}
+func (*Router) POST(string, func()) {}
+type Requester interface { ConnExec(connector.API) }
+func Start(r *Router) { r.POST("/rules", RulesAction) }
+func RulesAction() {
+  request := &rules.Request{}
+  Dispatch(request)
+}
+
+func Dispatch(request Requester) { Invoke(request) }
+func Invoke(request Requester) {
+  conn := connector.Build("runtime")
+  request.ConnExec(conn)
+}
+`)
+	writeHTTPFixture(t, root, "actions/rules/request.go", `package rules
+import "example.com/typed/connector"
+type Request struct{}
+func (*Request) ConnExec(conn connector.API) { conn.Rules() }
+`)
+	writeHTTPFixture(t, root, "connector/factory.go", `package connector
+import "example.com/typed/provider/alpha"
+type API interface { Rules() }
+func Build(name string) API {
+  switch name {
+  case "alpha": return alpha.New()
+  default: return nil
+  }
+}
+`)
+	writeHTTPFixture(t, root, "provider/alpha/connector.go", `package alpha
+import "example.com/typed/provider/alpha/client"
+type rulesClient interface { FetchRules() }
+type Connector struct { client rulesClient }
+func New() *Connector { return &Connector{client: &client.Client{}} }
+func (c *Connector) Rules() { c.client.FetchRules() }
+`)
+	writeHTTPFixture(t, root, "provider/alpha/client/client.go", `package client
+import "net/http"
+type Client struct{}
+func (c *Client) FetchRules() { c.fetchRules() }
+func (c *Client) fetchRules() { c.finishRules() }
+func (c *Client) finishRules() {
+  _, _ = http.Get("https://alpha.example/v1/rules")
+  if false { c.fetchRules() }
+}
+func (*Client) CheckRules() { _, _ = http.Get("https://alpha.example/v1/check-rules") }
+`)
+
+	analysis, err := gohttp.Analyze(root)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !analysis.TypedCallGraph || analysis.TypedCallGraphError != "" {
+		t.Fatalf("typed analysis = %v / %q", analysis.TypedCallGraph, analysis.TypedCallGraphError)
+	}
+	if len(analysis.EndpointFlows) != 1 || len(analysis.EndpointFlows[0].Branches) != 1 {
+		t.Fatalf("endpoint flows = %+v", analysis.EndpointFlows)
+	}
+	branch := analysis.EndpointFlows[0].Branches[0]
+	if branch.Operation != "Rules" || len(branch.Calls) != 1 || branch.Calls[0].Path != "/v1/rules" {
+		t.Fatalf("typed provider branch = %+v", branch)
+	}
+
+	resp, err := extract(plugin.Input{Root: root}, Options{Context: "travel", Service: "rules"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var got catalog.Catalog
+	if err := json.Unmarshal([]byte(resp.Files[0].Contents), &got); err != nil {
+		t.Fatal(err)
+	}
+	var endpoint, unused *catalog.Flow
+	for index := range got.Flows {
+		flow := &got.Flows[index]
+		if flow.Name == "POST /rules → provider APIs" {
+			endpoint = flow
+		}
+		if strings.Contains(flow.Name, "CheckRules") {
+			unused = flow
+		}
+		if strings.Contains(flow.Name, "Fetch Rules") {
+			t.Fatalf("covered typed fragment retained: %+v", flow)
+		}
+	}
+	if endpoint == nil || unused == nil {
+		t.Fatalf("endpoint = %+v, unused = %+v, flows = %+v", endpoint, unused, got.Flows)
+	}
+	step := endpoint.Steps[1].(*catalog.Step)
+	if step.Label != "GET /v1/rules" || !strings.Contains(step.Note, "Connector.Rules → Client.FetchRules") {
+		t.Fatalf("typed step = %+v", step)
+	}
+	if unused.Trigger == nil || unused.Trigger.Kind != "unproven" {
+		t.Fatalf("unused trigger = %+v", unused.Trigger)
+	}
+}
+
+func TestTypedAnalysisMapsPositionsFromAManifestRelativeRoot(t *testing.T) {
+	root := t.TempDir()
+	writeHTTPFixture(t, root, "go.mod", "module example.com/relative\n\ngo 1.27.0\n")
+	writeHTTPFixture(t, root, "app/main.go", `package app
+import (
+  "example.com/relative/actions/rules"
+  "example.com/relative/connector"
+)
+type Router struct{}
+func (*Router) POST(string, func()) {}
+type Requester interface { ConnExec(connector.API) }
+func Start(r *Router) { r.POST("/rules", RulesAction) }
+func RulesAction() { request := &rules.Request{}; Dispatch(request) }
+func Dispatch(request Requester) { Invoke(request) }
+func Invoke(request Requester) { request.ConnExec(connector.Build()) }
+`)
+	writeHTTPFixture(t, root, "actions/rules/request.go", `package rules
+import "example.com/relative/connector"
+type Request struct{}
+func (*Request) ConnExec(conn connector.API) { conn.Rules() }
+`)
+	writeHTTPFixture(t, root, "connector/factory.go", `package connector
+import "example.com/relative/provider/alpha"
+type API interface { Rules() }
+func Build() API { return alpha.New() }
+`)
+	writeHTTPFixture(t, root, "provider/alpha/client.go", `package alpha
+import "net/http"
+type Client struct{}
+func New() *Client { return &Client{} }
+func (*Client) Rules() { _, _ = http.Get("https://alpha.example/v1/rules") }
+`)
+
+	old, err := os.Getwd()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Chdir(root); err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { _ = os.Chdir(old) })
+
+	analysis, err := gohttp.Analyze(".")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !analysis.TypedCallGraph || analysis.TypedCallGraphError != "" {
+		t.Fatalf("typed analysis = %v / %q", analysis.TypedCallGraph, analysis.TypedCallGraphError)
+	}
+	if len(analysis.EndpointFlows) != 1 || len(analysis.EndpointFlows[0].Branches) != 1 {
+		t.Fatalf("endpoint flows = %+v", analysis.EndpointFlows)
+	}
+	branch := analysis.EndpointFlows[0].Branches[0]
+	if branch.Operation != "Rules" || len(branch.Calls) != 1 || branch.Calls[0].Path != "/v1/rules" {
+		t.Fatalf("typed provider branch = %+v", branch)
+	}
+}
+
+func TestPartialTypedAnalysisAndSyntaxFallback(t *testing.T) {
+	for _, dependent := range []bool{false, true} {
+		t.Run(fmt.Sprintf("broken_dependency_%v", dependent), func(t *testing.T) {
+			root := t.TempDir()
+			writeHTTPFixture(t, root, "go.mod", "module example.com/fallback\n\ngo 1.27.0\n")
+			writeHTTPFixture(t, root, "app/main.go", `package app
+import (
+  "net/http"
+  "example.com/fallback/connector"
+)
+type Router struct{}
+func (*Router) POST(string, func()) {}
+func Start(r *Router) { r.POST("/search", Search) }
+func Search() {
+  conn := connector.Build("runtime")
+  conn.Search()
+  _, _ = http.Get("https://fallback.example/search")
+}
+`)
+			writeHTTPFixture(t, root, "connector/factory.go", `package connector
+import "example.com/fallback/provider/alpha"
+type API interface { Search() }
+func Build(name string) API {
+  switch name { case "only": return alpha.New(); default: return nil }
+}
+`)
+			writeHTTPFixture(t, root, "provider/alpha/connector.go", `package alpha
+type Connector struct{}
+func New() *Connector { return &Connector{} }
+func (*Connector) Search() {}
+`)
+			writeHTTPFixture(t, root, "broken/broken.go", `package broken
+import _ "example.com/missing/private"
+`)
+
+			if dependent {
+				writeHTTPFixture(t, root, "provider/alpha/broken.go", `package alpha
+import _ "example.com/missing/private"
+`)
+			}
+			analysis, err := gohttp.Analyze(root)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if dependent {
+				if analysis.TypedCallGraph || analysis.TypedCallGraphError == "" {
+					t.Fatalf("typed fallback = %v / %q", analysis.TypedCallGraph, analysis.TypedCallGraphError)
+				}
+			} else {
+				if !analysis.TypedCallGraph || analysis.TypedCallGraphError != "" {
+					t.Fatalf("independent typed facts lost: %v / %q", analysis.TypedCallGraph, analysis.TypedCallGraphError)
+				}
+				if !strings.Contains(strings.Join(analysis.Warnings, "\n"), "typed call graph is partial") {
+					t.Fatalf("missing partial diagnostic: %v", analysis.Warnings)
+				}
+			}
+			if len(analysis.Calls) != 1 || analysis.Calls[0].Path != "/search" {
+				t.Fatalf("syntax calls = %+v", analysis.Calls)
+			}
+		})
+	}
+}
+
+func TestBuildsEndpointThroughFixedFactorySetterAndWrapper(t *testing.T) {
+	root := t.TempDir()
+	writeHTTPFixture(t, root, "go.mod", "module example.com/wired\n")
+	writeHTTPFixture(t, root, "app/main.go", `package app
+import "example.com/wired/connector"
+type Router struct{}
+func (*Router) POST(string, func()) {}
+func Start(r *Router) { r.POST("/cancel", Cancel) }
+func Cancel() {
+  conn := connector.Build()
+  conn.Cancel()
+}
+`)
+	writeHTTPFixture(t, root, "connector/factory.go", `package connector
+import (
+  "example.com/wired/provider/alpha"
+  "example.com/wired/provider/wrapper"
+)
+type API interface{ Cancel() }
+func Build() API {
+  conn := wrapper.New()
+  client := alpha.New()
+  conn.SetClient(client)
+  return conn
+}
+`)
+	writeHTTPFixture(t, root, "provider/port/api.go", `package port
+type API interface{ Cancel() }
+`)
+	writeHTTPFixture(t, root, "provider/wrapper/connector.go", `package wrapper
+import "example.com/wired/provider/port"
+type Connector struct{ client port.API }
+func New() *Connector { return &Connector{} }
+func (c *Connector) SetClient(client port.API) { c.client = client }
+func (c *Connector) Cancel() { c.client.Cancel() }
+`)
+	writeHTTPFixture(t, root, "provider/alpha/client.go", `package alpha
+import "net/http"
+type Client struct{}
+func New() *Client { return &Client{} }
+func (*Client) Cancel() { _, _ = http.Get("https://alpha.example/v1/cancel") }
+`)
+
+	resp, err := extract(plugin.Input{Root: root}, Options{Context: "travel", Service: "cancel"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var got catalog.Catalog
+	if err := json.Unmarshal([]byte(resp.Files[0].Contents), &got); err != nil {
+		t.Fatal(err)
+	}
+	if len(got.Flows) != 1 {
+		t.Fatalf("flows = %+v", got.Flows)
+	}
+	flow := got.Flows[0]
+	if flow.Name != "POST /cancel → provider APIs" || len(flow.Steps) != 2 {
+		t.Fatalf("endpoint = %+v", flow)
+	}
+	step, ok := flow.Steps[1].(*catalog.Step)
+	if !ok || step.Label != "GET /v1/cancel" {
+		t.Fatalf("provider step = %+v", flow.Steps[1])
+	}
+	if !strings.Contains(step.Note, "Connector.Cancel → Client.Cancel") {
+		t.Fatalf("setter-wired wrapper chain = %q", step.Note)
+	}
+}
+
+func TestBuildsEndpointThroughCapabilityAssertion(t *testing.T) {
+	root := t.TempDir()
+	writeHTTPFixture(t, root, "go.mod", "module example.com/capability\n")
+	writeHTTPFixture(t, root, "app/main.go", `package app
+import (
+  "example.com/capability/actions/documents"
+  "example.com/capability/connector"
+)
+type Router struct{}
+func (*Router) POST(string, func()) {}
+type Requester interface{ ConnExec(connector.API) }
+func Start(r *Router) { r.POST("/documents", DocumentsAction) }
+func DocumentsAction() {
+  request := documents.Request{}
+  ActionFlow(&request)
+}
+func ActionFlow(request Requester) {
+  conn := connector.Build("runtime")
+  request.ConnExec(conn)
+}
+`)
+	writeHTTPFixture(t, root, "actions/documents/request.go", `package documents
+import "example.com/capability/connector"
+type Request struct{}
+func (*Request) ConnExec(conn connector.API) {
+  getter, ok := conn.(interface{ GetDocuments() })
+  if ok { getter.GetDocuments() }
+}
+`)
+	writeHTTPFixture(t, root, "connector/factory.go", `package connector
+import (
+  "example.com/capability/provider/alpha"
+  "example.com/capability/provider/beta"
+)
+type API interface{}
+func Build(name string) API {
+  switch name {
+  case "alpha": return alpha.New()
+  case "beta": return beta.New()
+  default: return nil
+  }
+}
+`)
+	writeHTTPFixture(t, root, "provider/alpha/client.go", `package alpha
+import "net/http"
+type Client struct{}
+func New() *Client { return &Client{} }
+func (*Client) GetDocuments() { _, _ = http.Get("https://alpha.example/v1/documents") }
+`)
+	writeHTTPFixture(t, root, "provider/beta/client.go", `package beta
+type Client struct{}
+func New() *Client { return &Client{} }
+`)
+
+	resp, err := extract(plugin.Input{Root: root}, Options{Context: "travel", Service: "documents"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var got catalog.Catalog
+	if err := json.Unmarshal([]byte(resp.Files[0].Contents), &got); err != nil {
+		t.Fatal(err)
+	}
+	if len(got.Flows) != 1 {
+		t.Fatalf("flows = %+v", got.Flows)
+	}
+	flow := got.Flows[0]
+	if flow.Name != "POST /documents → provider APIs" || len(flow.Steps) != 2 {
+		t.Fatalf("endpoint = %+v", flow)
+	}
+	step, ok := flow.Steps[1].(*catalog.Step)
+	if !ok || step.Label != "GET /v1/documents" {
+		t.Fatalf("capability step = %+v", flow.Steps[1])
+	}
+}
+
+func TestBuildsProviderBranchesFromConstructorMap(t *testing.T) {
+	root := t.TempDir()
+	writeHTTPFixture(t, root, "go.mod", "module example.com/registry\n")
+	writeHTTPFixture(t, root, "app/main.go", `package app
+import "example.com/registry/connector"
+type Router struct{}
+func (*Router) POST(string, func()) {}
+func Start(r *Router) { r.POST("/search", Search) }
+func Search() {
+  conn := connector.Build("runtime")
+  conn.Search()
+}
+`)
+	writeHTTPFixture(t, root, "connector/factory.go", `package connector
+import (
+  "example.com/registry/provider/alpha"
+  "example.com/registry/provider/beta"
+)
+type API interface{ Search() }
+var providers = map[string]func() API{
+  "alpha": func() API { return alpha.New() },
+  "beta": beta.New,
+}
+func Build(name string) API { return providers[name]() }
+`)
+	writeHTTPFixture(t, root, "provider/alpha/client.go", `package alpha
+import "net/http"
+type Client struct{}
+func New() *Client { return &Client{} }
+func (*Client) Search() { _, _ = http.Get("https://alpha.example/search") }
+`)
+	writeHTTPFixture(t, root, "provider/beta/client.go", `package beta
+import "net/http"
+type Client struct{}
+func New() *Client { return &Client{} }
+func (*Client) Search() { _, _ = http.Get("https://beta.example/search") }
+`)
+
+	resp, err := extract(plugin.Input{Root: root}, Options{Context: "travel", Service: "search"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var got catalog.Catalog
+	if err := json.Unmarshal([]byte(resp.Files[0].Contents), &got); err != nil {
+		t.Fatal(err)
+	}
+	if len(got.Flows) != 1 {
+		t.Fatalf("flows = %+v", got.Flows)
+	}
+	flow := got.Flows[0]
+	providers, ok := flow.Steps[1].(*catalog.Alt)
+	if !ok || len(providers.Branches) != 2 {
+		t.Fatalf("provider map branches = %+v", flow.Steps)
+	}
+	if providers.Branches[0].Title != `connector = "alpha"` || providers.Branches[1].Title != `connector = "beta"` {
+		t.Fatalf("provider map titles = %+v", providers.Branches)
+	}
+	for _, branch := range providers.Branches {
+		step := branch.Steps[len(branch.Steps)-1].(*catalog.Step)
+		if len(step.Reaches) != 1 || !strings.HasSuffix(step.Reaches[0], ":Client.Search") {
+			t.Fatalf("provider reachability = %+v", step.Reaches)
+		}
+	}
+}
+
+func TestBuildsDirectHTTPRootThroughClosureAndLocalVariable(t *testing.T) {
+	root := t.TempDir()
+	writeHTTPFixture(t, root, "go.mod", "module example.com/refresh\n")
+	writeHTTPFixture(t, root, "app/routes.go", `package app
+import "example.com/refresh/cache"
+type Router struct{}
+func (*Router) POST(string, func()) {}
+func Routes(r *Router) {
+  state := cache.New()
+  r.POST("/debug/refresh", func() { _ = state.Update() })
+}
+`)
+	writeHTTPFixture(t, root, "cache/cache.go", `package cache
+import "net/http"
+type Cache struct{}
+func New() *Cache { return &Cache{} }
+func (*Cache) Update() error {
+  _, err := http.Get("https://geo.example/v1/airports")
+  return err
+}
+`)
+
+	resp, err := extract(plugin.Input{Root: root}, Options{Context: "ops", Service: "catalog"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var got catalog.Catalog
+	if err := json.Unmarshal([]byte(resp.Files[0].Contents), &got); err != nil {
+		t.Fatal(err)
+	}
+	if len(got.Flows) != 1 {
+		t.Fatalf("flows = %+v", got.Flows)
+	}
+	flow := got.Flows[0]
+	if flow.Name != "POST /debug/refresh → outbound APIs" || len(flow.Steps) != 2 {
+		t.Fatalf("rooted flow = %+v", flow)
+	}
+	if flow.Trigger == nil || flow.Trigger.Kind != "http" || flow.Trigger.Confidence != "high" {
+		t.Fatalf("trigger = %+v", flow.Trigger)
+	}
+	if step := flow.Steps[1].(*catalog.Step); step.Label != "GET /v1/airports" || len(step.Reaches) != 1 || step.Reaches[0] != "cache:Cache.Update" {
+		t.Fatalf("outbound step = %+v", step)
+	}
+}
+
+func TestBuildsAnnotatedCallbackRootAndCoversNestedHelper(t *testing.T) {
+	root := t.TempDir()
+	writeHTTPFixture(t, root, "go.mod", "module example.com/callback\n")
+	writeHTTPFixture(t, root, "callbacks/callback.go", `package callbacks
+import "net/http"
+type Registry struct{}
+func (*Registry) Register(string, string, func()) {}
+func Mount(registry *Registry) {
+  registry.Register("provider", "completed", Completed())
+}
+// Completed receives the provider webhook.
+// @Router /callbacks/provider/completed [post]
+func Completed() func() {
+  return func() { notifyCore() }
+}
+func notifyCore() { _, _ = http.Post("https://core.example/protected/update", "application/json", nil) }
+`)
+
+	resp, err := extract(plugin.Input{Root: root}, Options{Context: "travel", Service: "callbacks"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var got catalog.Catalog
+	if err := json.Unmarshal([]byte(resp.Files[0].Contents), &got); err != nil {
+		t.Fatal(err)
+	}
+	if len(got.Flows) != 1 {
+		t.Fatalf("flows = %+v", got.Flows)
+	}
+	flow := got.Flows[0]
+	if flow.Name != "POST /callbacks/provider/completed → outbound APIs" || len(flow.Steps) != 2 {
+		t.Fatalf("callback flow = %+v", flow)
+	}
+	if flow.Trigger == nil || flow.Trigger.Kind != "callback" || flow.Trigger.Confidence != "high" {
+		t.Fatalf("trigger = %+v", flow.Trigger)
+	}
+	if flow.Source != "callbacks/callback.go:6" {
+		t.Fatalf("registration source = %q", flow.Source)
+	}
+	step := flow.Steps[1].(*catalog.Step)
+	if step.Label != "POST /protected/update" || !strings.Contains(step.Note, "Completed → notifyCore") {
+		t.Fatalf("callback continuation = %+v", step)
+	}
+}
+
+func TestBuildsStartupRootFromMainAssembly(t *testing.T) {
+	root := t.TempDir()
+	writeHTTPFixture(t, root, "go.mod", "module example.com/startup\n")
+	writeHTTPFixture(t, root, "cmd/catalog/main.go", `package main
+import app "example.com/startup/internal/app/catalog"
+func main() { app.Run() }
+`)
+	writeHTTPFixture(t, root, "internal/app/catalog/run.go", `package catalog
+import "example.com/startup/cache"
+func Run() {
+	state := cache.New()
+	if err := state.Warm(); err != nil { panic(err) }
+}
+`)
+	writeHTTPFixture(t, root, "cache/cache.go", `package cache
+import "net/http"
+type Cache struct{}
+func New() *Cache { return &Cache{} }
+func (*Cache) Warm() error {
+  _, err := http.Get("https://geo.example/v1/bootstrap")
+  return err
+}
+`)
+
+	resp, err := extract(plugin.Input{Root: root}, Options{Context: "ops", Service: "catalog"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var got catalog.Catalog
+	if err := json.Unmarshal([]byte(resp.Files[0].Contents), &got); err != nil {
+		t.Fatal(err)
+	}
+	if len(got.Flows) != 1 {
+		t.Fatalf("flows = %+v", got.Flows)
+	}
+	flow := got.Flows[0]
+	if flow.Trigger == nil || flow.Trigger.Kind != "startup" || flow.Trigger.Confidence != "high" {
+		t.Fatalf("trigger = %+v", flow.Trigger)
+	}
+	if flow.Name != "Startup → Cache.Warm → outbound APIs" || flow.Source != "internal/app/catalog/run.go:5" {
+		t.Fatalf("startup flow = %+v", flow)
+	}
+}
+
+func TestBuildsScheduledRootFromTimerRegistration(t *testing.T) {
+	root := t.TempDir()
+	writeHTTPFixture(t, root, "go.mod", "module example.com/scheduled\n")
+	writeHTTPFixture(t, root, "jobs/refresh.go", `package jobs
+import (
+  "net/http"
+  "time"
+)
+func Register() {
+  time.AfterFunc(5*time.Minute, func() { Refresh() })
+}
+func Refresh() { _, _ = http.Get("https://catalog.example/v1/refresh") }
+`)
+
+	resp, err := extract(plugin.Input{Root: root}, Options{Context: "ops", Service: "catalog"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var got catalog.Catalog
+	if err := json.Unmarshal([]byte(resp.Files[0].Contents), &got); err != nil {
+		t.Fatal(err)
+	}
+	if len(got.Flows) != 1 {
+		t.Fatalf("flows = %+v", got.Flows)
+	}
+	flow := got.Flows[0]
+	if flow.Trigger == nil || flow.Trigger.Kind != "scheduled" || flow.Trigger.Confidence != "high" {
+		t.Fatalf("trigger = %+v", flow.Trigger)
+	}
+	if !strings.Contains(flow.Name, "Schedule 5 * time.Minute → Refresh") || len(flow.Steps) != 2 {
+		t.Fatalf("scheduled flow = %+v", flow)
+	}
+}
+
+func TestProviderInitIsBusinessOperationAndIncludesNestedHelper(t *testing.T) {
+	root := t.TempDir()
+	writeHTTPFixture(t, root, "go.mod", "module example.com/providerinit\n")
+	writeHTTPFixture(t, root, "app/routes.go", `package app
+import "example.com/providerinit/connector"
+type Router struct{}
+func (*Router) POST(string, func()) {}
+func Routes(r *Router) { r.POST("/initialize", Initialize) }
+func Initialize() {
+  conn := connector.Build()
+  conn.Init()
+}
+`)
+	writeHTTPFixture(t, root, "connector/factory.go", `package connector
+import "example.com/providerinit/provider"
+type API interface{ Init() }
+func Build() API { return provider.New() }
+`)
+	writeHTTPFixture(t, root, "provider/provider.go", `package provider
+import "net/http"
+type Connector struct{}
+func New() *Connector { return &Connector{} }
+func (c *Connector) Init() { c.waitUntilReady() }
+func (*Connector) waitUntilReady() { _, _ = http.Get("https://provider.example/v1/status") }
+`)
+
+	resp, err := extract(plugin.Input{Root: root}, Options{Context: "travel", Service: "booking"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var got catalog.Catalog
+	if err := json.Unmarshal([]byte(resp.Files[0].Contents), &got); err != nil {
+		t.Fatal(err)
+	}
+	if len(got.Flows) != 1 {
+		t.Fatalf("flows = %+v", got.Flows)
+	}
+	flow := got.Flows[0]
+	if flow.Name != "POST /initialize → provider APIs" || len(flow.Steps) != 2 {
+		t.Fatalf("endpoint flow = %+v", flow)
+	}
+	step := flow.Steps[1].(*catalog.Step)
+	if step.Label != "GET /v1/status" || !strings.Contains(step.Note, "Connector.Init → Connector.waitUntilReady") {
+		t.Fatalf("nested Init flow = %+v", step)
+	}
+}
+
+func TestDoesNotGuessBetweenMultipleConstructorWiredImplementations(t *testing.T) {
+	root := t.TempDir()
+	writeHTTPFixture(t, root, "go.mod", "module example.com/ambiguous\n")
+	writeHTTPFixture(t, root, "port/api.go", `package port
+type API interface{ Cancel() }
+`)
+	writeHTTPFixture(t, root, "connector/connector.go", `package connector
+import (
+  "example.com/ambiguous/port"
+  "example.com/ambiguous/provider/alpha"
+  "example.com/ambiguous/provider/beta"
+)
+type Connector struct{ client port.API }
+func NewAlpha() *Connector { return &Connector{client: &alpha.Client{}} }
+func NewBeta() *Connector { return &Connector{client: &beta.Client{}} }
+func (c *Connector) Cancel() { c.client.Cancel() }
+`)
+	writeHTTPFixture(t, root, "provider/alpha/client.go", `package alpha
+import "net/http"
+type Client struct{}
+func (*Client) Cancel() { _, _ = http.Get("https://alpha.example/cancel") }
+`)
+	writeHTTPFixture(t, root, "provider/beta/client.go", `package beta
+import "net/http"
+type Client struct{}
+func (*Client) Cancel() { _, _ = http.Get("https://beta.example/cancel") }
+`)
+
+	resp, err := extract(plugin.Input{Root: root}, Options{Context: "travel", Service: "cancel"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var got catalog.Catalog
+	if err := json.Unmarshal([]byte(resp.Files[0].Contents), &got); err != nil {
+		t.Fatal(err)
+	}
+	if len(got.Flows) != 2 {
+		t.Fatalf("ambiguous wiring created a composed flow: %+v", got.Flows)
+	}
+	for _, flow := range got.Flows {
+		if flow.Name == "Connector Cancel → outbound APIs" {
+			t.Fatalf("ambiguous receiver was guessed: %+v", flow)
+		}
+	}
+}
+
+func TestCoveredEndpointCallRemovesWrapperWithoutAChainName(t *testing.T) {
+	call := gohttp.Call{
+		Function: "provider:Client.Send",
+		ID:       "http-client/POST /send",
+		Source:   gohttp.Source{File: "provider/client.go", Line: 42},
+	}
+	groups := []gohttp.FlowGroup{{Function: "provider:Connector.Publish", Calls: []gohttp.Call{call}}}
+	endpoints := []gohttp.EndpointFlow{{Branches: []gohttp.EndpointBranch{{
+		Function: "provider:Client.Send",
+		Calls:    []gohttp.Call{call},
+	}}}}
+	covered := map[string]bool{}
+
+	coverEndpointDescendants(covered, endpoints, groups)
+
+	if !covered["provider:Connector.Publish"] {
+		t.Fatalf("exact source-backed wrapper was not covered: %+v", covered)
+	}
+}
+
+func TestOnlySourceBackedComplementsBecomeAnAlt(t *testing.T) {
+	context := "edge"
+	calls := []gohttp.Call{
+		{Function: "choose", ID: "http-client/GET /one", Method: "GET", Path: "/one", Conditions: []string{"ready"}},
+		{Function: "choose", ID: "http-client/GET /two", Method: "GET", Path: "/two", Conditions: []string{"not (ready)"}},
+	}
+	flows := flowsOf("edge.gateway", context, calls, Options{})
+	if len(flows) != 1 || len(flows[0].Steps) != 1 {
+		t.Fatalf("flows = %+v", flows)
+	}
+	alt, ok := flows[0].Steps[0].(*catalog.Alt)
+	if !ok || alt.Branches[0].Title != "ready" || alt.Branches[1].Title != "not (ready)" {
+		t.Fatalf("alt = %+v", flows[0].Steps[0])
+	}
+
+	calls[1].Conditions = nil
+	flows = flowsOf("edge.gateway", context, calls, Options{})
+	if _, ok := flows[0].Steps[0].(*catalog.Alt); ok {
+		t.Fatal("unrelated calls became an alternative")
+	}
+}
+
+func TestLearnsHandWrittenSOAPWrapperArgumentPositions(t *testing.T) {
+	root := t.TempDir()
+	writeHTTPFixture(t, root, "go.mod", "module example.com/checkout\n")
+	writeHTTPFixture(t, root, "soap/booking.wsdl", `
+<definitions xmlns="http://schemas.xmlsoap.org/wsdl/" xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:tns="urn:booking" targetNamespace="urn:booking" name="Booking">
+  <message name="CancelRequest"/><message name="CancelResponse"/>
+  <portType name="BookingPortType"><operation name="Cancel"><input message="tns:CancelRequest"/><output message="tns:CancelResponse"/></operation></portType>
+  <binding name="BookingBinding" type="tns:BookingPortType"><soap:binding style="document"/><operation name="Cancel"><soap:operation soapAction="urn:booking:cancel"/></operation></binding>
+  <service name="BookingService"><port name="BookingPort" binding="tns:BookingBinding"><soap:address location="https://booking.example/soap"/></port></service>
+</definitions>`)
+	writeHTTPFixture(t, root, "soap/transport.go", `package soap
+import "net/http"
+type Transport struct{}
+func (t *Transport) Call(actionBase, operation string, messageID string, query, reply any) error {
+  req, err := http.NewRequest(http.MethodPost, "https://booking.example/soap", nil)
+  if err != nil { return err }
+  req.Header.Add("SOAPAction", actionBase+operation)
+  return nil
+}
+
+type Service struct{ transport *Transport }
+func (s *Service) Call(actionBase, operation string, query, reply any, stage string, options ...func()) error {
+  return s.transport.Call(actionBase, operation, "message-id", query, reply)
+}`)
+	writeHTTPFixture(t, root, "checkout/cancel.go", `package checkout
+import soapclient "example.com/checkout/soap"
+const actionBase = "urn:booking:"
+func CancelBooking(client *soapclient.Service, request, response any) error {
+  return client.Call(actionBase, "cancel", request, response, "checkout")
+}`)
+
+	resp, err := extract(plugin.Input{Root: root}, Options{Context: "checkout", Service: "gateway"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var got catalog.Catalog
+	if err := json.Unmarshal([]byte(resp.Files[0].Contents), &got); err != nil {
+		t.Fatal(err)
+	}
+	service := got.Contexts[0].Services[0]
+	if len(service.Consumes) != 1 {
+		t.Fatalf("consumes = %+v", service.Consumes)
+	}
+	call := service.Consumes[0]
+	if call.ID != "bookingservice.soap.BookingPort/Cancel" || call.Status != catalog.StatusDeclared || call.Source != "soap/booking.wsdl" {
+		t.Fatalf("call = %+v", call)
+	}
+	if !strings.Contains(call.Note, "request 'request'") || !strings.Contains(call.Note, "response 'response'") {
+		t.Fatalf("note = %q", call.Note)
+	}
+	if len(got.Flows) != 1 || got.Flows[0].Source != "checkout/cancel.go:4" {
+		t.Fatalf("flows = %+v", got.Flows)
+	}
+}
+
+func TestReadsSOAP12ActionFromContentType(t *testing.T) {
+	root := t.TempDir()
+	writeHTTPFixture(t, root, "go.mod", "module example.com/soap12\n")
+	writeHTTPFixture(t, root, "contract.wsdl", `
+<definitions xmlns="http://schemas.xmlsoap.org/wsdl/" xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:soap12="http://schemas.xmlsoap.org/wsdl/soap12/" xmlns:tns="urn:status" targetNamespace="urn:status" name="Status">
+  <portType name="StatusPortType"><operation name="Check"/></portType>
+	<binding name="Status11Binding" type="tns:StatusPortType"><soap:binding style="document"/><operation name="Check"><soap:operation soapAction="urn:status:check"/></operation></binding>
+	<binding name="Status12Binding" type="tns:StatusPortType"><soap12:binding style="document"/><operation name="Check"><soap12:operation soapAction="urn:status:check"/></operation></binding>
+	<service name="StatusService">
+	  <port name="Status11Port" binding="tns:Status11Binding"><soap:address location="https://status.example/soap11"/></port>
+	  <port name="Status12Port" binding="tns:Status12Binding"><soap12:address location="https://status.example/soap12"/></port>
+	</service>
+</definitions>`)
+	writeHTTPFixture(t, root, "transport.go", `package soap12
+import "net/http"
+type Client struct{}
+func (c *Client) Send(action string, request, response any) error {
+  req, err := http.NewRequest(http.MethodPost, "https://status.example/soap", nil)
+  if err != nil { return err }
+  req.Header.Set("Content-Type", "application/soap+xml; charset=utf-8; action=\""+action+"\"")
+  return nil
+}
+func Check(client *Client, request, response any) error {
+  return client.Send("urn:status:check", request, response)
+}`)
+
+	resp, err := extract(plugin.Input{Root: root}, Options{Context: "monitoring", Service: "probe"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var got catalog.Catalog
+	if err := json.Unmarshal([]byte(resp.Files[0].Contents), &got); err != nil {
+		t.Fatal(err)
+	}
+	calls := got.Contexts[0].Services[0].Consumes
+	if len(calls) != 1 || calls[0].ID != "statusservice.soap.Status12Port/Check" || calls[0].Status != catalog.StatusDeclared {
+		t.Fatalf("calls = %+v", calls)
+	}
+	method := got.Externals[0].Provides[0].Methods[0]
+	if method.SOAP == nil || method.SOAP.Version != "1.2" || method.SOAP.Action != "urn:status:check" {
+		t.Fatalf("method = %+v", method)
+	}
+}
+
+func TestDestinationThroughFunctionalOption(t *testing.T) {
+	for _, ambiguous := range []bool{false, true} {
+		t.Run(fmt.Sprint(ambiguous), func(t *testing.T) {
+			root := t.TempDir()
+			writeHTTPFixture(t, root, "go.mod", "module example.com/destination\n")
+			writeHTTPFixture(t, root, "client.go", `package destination
+import "net/http"
+type Config struct { SettingAddr string `+"`envconfig:\"SETTINGS_ADDR\" default:\"http://localhost:8000/settings\"`"+` }
+type Client struct { baseURL string }
+type Option func(*Client)
+func WithBaseURL(value string) Option { return func(c *Client) { c.baseURL = value } }
+func NewClient(options ...Option) *Client {
+ c := &Client{}
+ for _, opt := range options { opt(c) }
+ return c
+}
+func runtimeURL(path string) string { return path }
+func (c *Client) request(method, path string) { path = c.baseURL + path; path = runtimeURL(path); http.NewRequest(method, path, nil) }
+func (c *Client) POST(path string) { c.request(http.MethodPost, path) }
+type Manager struct { client *Client }
+func New(client *Client) *Manager { return &Manager{client: client} }
+func Build(cfg Config) *Manager { return New(NewClient(WithBaseURL(cfg.SettingAddr))) }
+func (m *Manager) Settings() { m.client.POST("/get-admin-settings") }
+type Other struct { client *Client }
+func NewOther(client *Client) *Other { return &Other{client: client} }
+func BuildOther() *Other { return NewOther(NewClient(WithBaseURL("http://other/billing"))) }
+func (m *Other) Settings() { m.client.POST("/get-admin-settings") }
+`)
+			if ambiguous {
+				writeHTTPFixture(t, root, "other.go", `package destination
+func Unknown(value string) *Manager { return New(NewClient(WithBaseURL(value))) }
+`)
+			}
+			resp, err := extract(plugin.Input{Root: root}, Options{Context: "avia", Service: "aviacore"})
+			if err != nil {
+				t.Fatal(err)
+			}
+			var got catalog.Catalog
+			if err := json.Unmarshal([]byte(resp.Files[0].Contents), &got); err != nil {
+				t.Fatal(err)
+			}
+			found := false
+			for _, flow := range got.Flows {
+				if flow.EntryPoint == "Other.Settings" {
+					step := flow.Steps[0].(*catalog.Step)
+					if d := step.Destination; d == nil || d.FullPath != "/billing/get-admin-settings" || d.ServiceDiscoveryAlias != "other" {
+						t.Fatalf("other client destination = %+v", d)
+					}
+				}
+				if flow.EntryPoint != "Manager.Settings" {
+					continue
+				}
+				for _, node := range flow.Steps {
+					step, ok := node.(*catalog.Step)
+					if !ok || step.Kind != catalog.StepRPC {
+						continue
+					}
+					found = true
+					d := step.Destination
+					if d == nil {
+						t.Fatalf("missing destination: %+v", step)
+					}
+					if ambiguous {
+						if d.FullPath != "" {
+							t.Fatalf("ambiguous destination resolved: %+v", d)
+						}
+						continue
+					}
+					if d.FullPath != "/settings/get-admin-settings" || d.LocalPath != "/get-admin-settings" || d.BaseURL == nil || d.BaseURL.ConfigField != "Config.SettingAddr" || d.BaseURL.EnvironmentVariable != "SETTINGS_ADDR" || d.BaseURL.Kind != "config-default" || d.Join == nil || d.Join.Expression != "c.baseURL + path" || len(d.Transforms) != 1 || d.Transforms[0].Expression != "runtimeURL(path)" {
+						t.Fatalf("destination = %+v; base = %+v", d, d.BaseURL)
+					}
+				}
+			}
+			if !found {
+				t.Fatalf("no Manager.Settings flow: %+v", got.Flows)
+			}
+		})
+	}
+}
+
+// PORTOLAN-19: the verb and path are not a call identity. One shared request
+// helper addressed to two hosts is two dependencies, and neither the analyzer's
+// call-site deduplication nor the consumer list may glue them together.
+func TestSameRouteToDifferentHostsStaysTwoCalls(t *testing.T) {
+	root := t.TempDir()
+	writeHTTPFixture(t, root, "go.mod", "module example.com/clients\n")
+	writeHTTPFixture(t, root, "client.go", `package clients
+import "net/http"
+type Client struct { baseURL string }
+type Option func(*Client)
+func WithBaseURL(value string) Option { return func(c *Client) { c.baseURL = value } }
+func NewClient(options ...Option) *Client {
+ c := &Client{}
+ for _, opt := range options { opt(c) }
+ return c
+}
+func (c *Client) request(method, path string) { path = c.baseURL + path; http.NewRequest(method, path, nil) }
+func (c *Client) post(path string) { c.request(http.MethodPost, path) }
+type Payments struct { client *Client }
+func NewPayments(client *Client) *Payments { return &Payments{client: client} }
+func BuildPayments() *Payments { return NewPayments(NewClient(WithBaseURL("https://payments.internal"))) }
+func (p *Payments) Settle() { p.client.post("/foo") }
+type Ledger struct { client *Client }
+func NewLedger(client *Client) *Ledger { return &Ledger{client: client} }
+func BuildLedger() *Ledger { return NewLedger(NewClient(WithBaseURL("https://ledger.internal"))) }
+func (l *Ledger) Record() { l.client.post("/foo") }
+`)
+	resp, err := extract(plugin.Input{Root: root}, Options{Context: "shop", Service: "checkout"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var got catalog.Catalog
+	if err := json.Unmarshal([]byte(resp.Files[0].Contents), &got); err != nil {
+		t.Fatal(err)
+	}
+	consumes := got.Contexts[0].Services[0].Consumes
+	if len(consumes) != 2 {
+		t.Fatalf("consumes = %+v", consumes)
+	}
+	byID := map[string]catalog.RpcCall{}
+	for _, call := range consumes {
+		byID[call.ID] = call
+	}
+	for host, peer := range map[string]string{"ledger.internal": "ledger-internal", "payments.internal": "payments-internal"} {
+		call, ok := byID["http-client/POST /foo @ "+host]
+		if !ok {
+			t.Fatalf("no consume for %s in %+v", host, consumes)
+		}
+		if call.Peer != peer || call.Status != catalog.StatusUnresolved || call.Destination == nil || call.Destination.ServiceDiscoveryAlias != host || call.Destination.FullPath != "/foo" {
+			t.Fatalf("%s = %+v (destination %+v)", host, call, call.Destination)
+		}
+	}
+	refs := map[string]string{}
+	for _, flow := range got.Flows {
+		for _, node := range flow.Steps {
+			if step, ok := node.(*catalog.Step); ok && step.Kind == catalog.StepRPC {
+				refs[flow.EntryPoint] = step.Ref
+			}
+		}
+	}
+	if refs["Payments.Settle"] != "http-client/POST /foo @ payments.internal" || refs["Ledger.Record"] != "http-client/POST /foo @ ledger.internal" {
+		t.Fatalf("flow refs = %+v", refs)
+	}
+}
+
+// Several call sites addressed to one destination are one dependency: the entry
+// keeps the first site in source order and every site as evidence, and the
+// order files are visited in cannot change which entries exist.
+func TestCallSitesToOneDestinationAggregateWithProvenance(t *testing.T) {
+	settle := `package clients
+import "net/http"
+func Settle() { http.Post("https://payments.internal/foo", "application/json", nil) }
+`
+	retry := `package clients
+import "net/http"
+func Retry() { http.Post("https://payments.internal/foo", "application/json", nil) }
+`
+	record := `package clients
+import "net/http"
+func Record() { http.Post("https://ledger.internal/foo", "application/json", nil) }
+`
+	run := func(files map[string]string) []catalog.RpcCall {
+		root := t.TempDir()
+		writeHTTPFixture(t, root, "go.mod", "module example.com/clients\n")
+		for name, contents := range files {
+			writeHTTPFixture(t, root, name, contents)
+		}
+		resp, err := extract(plugin.Input{Root: root}, Options{Context: "shop", Service: "checkout"})
+		if err != nil {
+			t.Fatal(err)
+		}
+		var got catalog.Catalog
+		if err := json.Unmarshal([]byte(resp.Files[0].Contents), &got); err != nil {
+			t.Fatal(err)
+		}
+		return got.Contexts[0].Services[0].Consumes
+	}
+	consumes := run(map[string]string{"a_settle.go": settle, "b_retry.go": retry, "c_record.go": record})
+	if len(consumes) != 2 {
+		t.Fatalf("consumes = %+v", consumes)
+	}
+	var payments *catalog.RpcCall
+	for i := range consumes {
+		if consumes[i].ID == "http-client/POST /foo @ payments.internal" {
+			payments = &consumes[i]
+		}
+	}
+	if payments == nil || payments.Source != "a_settle.go:3" {
+		t.Fatalf("payments = %+v", payments)
+	}
+	var sites []string
+	for _, item := range payments.Evidence {
+		if item.Kind == "call-site" {
+			sites = append(sites, item.Source)
+		}
+	}
+	if strings.Join(sites, ",") != "a_settle.go:3,b_retry.go:3" {
+		t.Fatalf("call sites = %v", sites)
+	}
+
+	// Reverse the file order: the same identities come out, only the first
+	// site (and with it the entry's source) follows the new order.
+	reversed := run(map[string]string{"c_settle.go": settle, "b_retry.go": retry, "a_record.go": record})
+	ids := func(calls []catalog.RpcCall) []string {
+		var out []string
+		for _, call := range calls {
+			out = append(out, call.ID+" -> "+call.Peer)
+		}
+		return out
+	}
+	if strings.Join(ids(consumes), "\n") != strings.Join(ids(reversed), "\n") {
+		t.Fatalf("file order changed the result:\n%v\n%v", ids(consumes), ids(reversed))
+	}
+	for _, call := range reversed {
+		if call.ID == "http-client/POST /foo @ payments.internal" && call.Source != "b_retry.go:3" {
+			t.Fatalf("reversed payments source = %q", call.Source)
+		}
+	}
+}