package gudusoft.gsqlparser.dlineage.dynamicsql;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.TStatementList;
import gudusoft.gsqlparser.dlineage.dynamicsql.RoutineSummaryEdge.Endpoint;
import gudusoft.gsqlparser.dlineage.dynamicsql.RoutineSummaryEdge.EndpointKind;
import gudusoft.gsqlparser.nodes.TObjectName;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;

/**
 * B3 (design {@code routine-summary-scc-design.md} §2.3/§2.6): SHADOW-mode
 * summary composition into an ISOLATED observation model. Nothing here touches the
 * LEGACY analysis — the applier runs its own per-definition extractions,
 * binds call sites through the {@link CatalogRoutineCallBinder}, and emits
 * the composed cross-routine edges as a standalone edge set tagged
 * {@code origin=SUMMARY_COMPOSED}. The {@link ShadowLeafEdgeComparator}
 * classifies that set against the LEGACY run's leaf projection.
 *
 * <p>Composition rules (the G1 capability):
 * <ul>
 * <li><b>IN</b>: callee edge {@code formal_p → B} composes with the caller's
 *     boundary sources feeding the actual bound to {@code p} — the fan-in of
 *     the actual expression's leaves, resolved through the caller's OWN
 *     closure (locals are quotiented out of summaries; the per-call-site
 *     reach on {@link CallSiteRef} is exactly what composition needs).</li>
 * <li><b>OUT</b>: callee edge {@code X → formal_p(OUT)} composes onto the
 *     caller boundary endpoints reachable FROM the bound writable lvalue.
 *     When {@code X} is itself an IN formal of the callee, it chains through
 *     the caller sources of ITS actual (IN→OUT pass-through).</li>
 * <li><b>RESULT SET</b>: callee edge {@code X → resultset column} maps
 *     positionally onto INSERT…EXEC target columns (§2.3 rule 3), using the
 *     callee summary's recorded result-set shape.</li>
 * <li>Relation flavors compose as the closure does: a chain is {@code fdd}
 *     only when every leg is; any {@code fdr} leg makes it {@code fdr}.</li>
 * <li>AMBIGUOUS / UNRESOLVED / duplicate-identity callees bind nothing —
 *     a diagnostic records each skip (never guessed).</li>
 * </ul>
 */
public final class ShadowSummaryApplier {

    /** Stable reason attached to every composed observation until call
     *  validity, type compatibility, actual mutability, and execution context
     *  are exhaustively proven. */
    public static final String APPLICATION_DEFERRED_CALL_VALIDITY_NOT_PROVEN =
            "APPLICATION_DEFERRED_CALL_VALIDITY_NOT_PROVEN";

    /** Publication gate attached to every composed edge. No dataflow model
     *  is mutated by this class. Current output is observation-only;
     *  REPLACEMENT_ELIGIBLE is reserved and unreachable. */
    public enum ApplicationGate {
        /** Reserved for a future exhaustively-preflighted projection path.
         *  Current public results never emit this verdict. */
        REPLACEMENT_ELIGIBLE,
        /** Candidate edge for evaluation; not authorized for merging. */
        OBSERVATION_ONLY
    }

    public enum EdgeOrigin {
        SUMMARY_COMPOSED
    }

    /** One composed cross-routine edge of the isolated SHADOW side model. */
    public static final class ComposedEdge {
        private final Endpoint source;
        private final Endpoint target;
        private final String relationType;
        private final RoutineIdentity callerIdentity;
        private final RoutineIdentity calleeIdentity;
        private final int callSiteOrdinal;
        private final Set<String> observedFunctions;
        private final RoutineSummary.Completeness calleeCompleteness;
        private final ApplicationGate applicationGate;
        private final String applicationDeferralReason;

        public ComposedEdge(Endpoint source, Endpoint target, String relationType,
                RoutineIdentity callerIdentity, RoutineIdentity calleeIdentity,
                int callSiteOrdinal) {
            this(source, target, relationType, callerIdentity, calleeIdentity,
                    callSiteOrdinal, null, RoutineSummary.Completeness.PARTIAL);
        }

        ComposedEdge(Endpoint source, Endpoint target, String relationType,
                RoutineIdentity callerIdentity, RoutineIdentity calleeIdentity,
                int callSiteOrdinal, Set<String> observedFunctions,
                RoutineSummary.Completeness calleeCompleteness) {
            this.source = source;
            this.target = target;
            this.relationType = relationType;
            this.callerIdentity = callerIdentity;
            this.calleeIdentity = calleeIdentity;
            this.callSiteOrdinal = callSiteOrdinal;
            this.observedFunctions = observedFunctions == null
                    ? Collections.<String>emptySet()
                    : Collections.unmodifiableSet(
                            new TreeSet<String>(observedFunctions));
            this.calleeCompleteness = calleeCompleteness == null
                    ? RoutineSummary.Completeness.PARTIAL : calleeCompleteness;
            this.applicationGate = ApplicationGate.OBSERVATION_ONLY;
            this.applicationDeferralReason =
                    APPLICATION_DEFERRED_CALL_VALIDITY_NOT_PROVEN;
        }

        public Endpoint getSource() { return source; }
        public Endpoint getTarget() { return target; }
        public String getRelationType() { return relationType; }
        /** Composing caller routine (occurrence identity component). */
        public RoutineIdentity getCallerIdentity() { return callerIdentity; }
        /** Composed callee routine (occurrence identity component). */
        public RoutineIdentity getCalleeIdentity() { return calleeIdentity; }
        /** Display rendering of the caller identity. */
        public String getCallerName() { return String.valueOf(callerIdentity); }
        /** Display rendering of the callee identity. */
        public String getCalleeName() { return String.valueOf(calleeIdentity); }
        /** Position of the composing call site in the caller's call-site
         *  list (occurrence identity component). */
        public int getCallSiteOrdinal() { return callSiteOrdinal; }
        /** Unordered advisory names observed on contributing paths. */
        public Set<String> getObservedFunctions() { return observedFunctions; }
        /** @deprecated use {@link #getObservedFunctions()}. */
        @Deprecated
        public Set<String> getTransforms() { return observedFunctions; }
        public RoutineSummary.Completeness getCalleeCompleteness() {
            return calleeCompleteness;
        }
        public ApplicationGate getApplicationGate() { return applicationGate; }
        /** Stable reason this observation is not an applicable addition. */
        public String getApplicationDeferralReason() {
            return applicationDeferralReason;
        }
        public EdgeOrigin getOrigin() { return EdgeOrigin.SUMMARY_COMPOSED; }

        ComposedEdge withMetadata(Set<String> joined,
                RoutineSummary.Completeness joinedCompleteness) {
            return new ComposedEdge(source, target, relationType,
                    callerIdentity, calleeIdentity, callSiteOrdinal, joined,
                    joinedCompleteness);
        }

        /** OCCURRENCE identity (codex-B3-r2 finding 8 ruling, tightened per
         *  r3 finding 3): FULL RoutineIdentity equality for caller and
         *  callee — never a rendering, which omits signature fields and
         *  collapsed distinct same-name/same-arity identities. */
        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (!(o instanceof ComposedEdge)) {
                return false;
            }
            ComposedEdge e = (ComposedEdge) o;
            // non-identifier-compare: relationType is a fixed enum-like token;
            // identities compare via RoutineIdentity.equals (canonical fields)
            return source.equals(e.source) && target.equals(e.target)
                    && relationType.equals(e.relationType)
                    && callerIdentity.equals(e.callerIdentity)
                    && calleeIdentity.equals(e.calleeIdentity)
                    && callSiteOrdinal == e.callSiteOrdinal;
        }

        @Override
        public int hashCode() {
            int h = (source.hashCode() * 31 + target.hashCode()) * 31
                    + relationType.hashCode();
            h = h * 31 + callerIdentity.hashCode();
            h = h * 31 + calleeIdentity.hashCode();
            h = h * 31 + callSiteOrdinal;
            return h;
        }

        @Override
        public String toString() {
            return source + " -" + relationType + "-> " + target
                    + " [SUMMARY_COMPOSED " + callerIdentity + " -> "
                    // Keep the pre-B6 debug rendering stable. Consumers that
                    // need the trust verdict use getApplicationGate().
                    + calleeIdentity + "]";
        }
    }

    /** The isolated SHADOW observation output. */
    public static final class ShadowResult {
        private final Set<ComposedEdge> additions;
        private final List<String> diagnostics;
        private final Map<RoutineIdentity, RoutineSummary> summaries;
        private final Map<RoutineIdentity, Integer> fixedPointIterations;

        ShadowResult(Set<ComposedEdge> additions, List<String> diagnostics,
                Map<RoutineIdentity, RoutineSummary> summaries) {
            this(additions, diagnostics, summaries,
                    Collections.<RoutineIdentity, Integer>emptyMap());
        }

        ShadowResult(Set<ComposedEdge> additions, List<String> diagnostics,
                Map<RoutineIdentity, RoutineSummary> summaries,
                Map<RoutineIdentity, Integer> fixedPointIterations) {
            this.additions = Collections.unmodifiableSet(
                    new LinkedHashSet<ComposedEdge>(additions));
            this.diagnostics = Collections.unmodifiableList(
                    new ArrayList<String>(diagnostics));
            this.summaries = Collections.unmodifiableMap(
                    new LinkedHashMap<RoutineIdentity, RoutineSummary>(summaries));
            this.fixedPointIterations = Collections.unmodifiableMap(
                    new LinkedHashMap<RoutineIdentity, Integer>(
                            fixedPointIterations));
        }

        public Set<ComposedEdge> getAdditions() { return additions; }
        public List<String> getDiagnostics() { return diagnostics; }
        public Map<RoutineIdentity, RoutineSummary> getSummaries() { return summaries; }
        /** Number of synchronous fixed-point rounds run for each routine's
         *  SCC; zero means no summary evaluation (LEGACY). */
        public Map<RoutineIdentity, Integer> getFixedPointIterations() {
            return fixedPointIterations;
        }
    }

    private final EDbVendor vendor;
    private final ProceduralLineageOptions options;

    public ShadowSummaryApplier(EDbVendor vendor) {
        this(vendor, ProceduralLineageOptions.shadow());
    }

    public ShadowSummaryApplier(EDbVendor vendor,
            ProceduralLineageOptions options) {
        this.vendor = vendor;
        this.options = options == null
                ? ProceduralLineageOptions.legacy() : options;
    }

    /**
     * Run the full SHADOW pipeline over a multi-file unit: catalog, base
     * summaries, call-site binding (identity-first: the resolved
     * {@link RoutineIdentity} is the summary lookup key), composition.
     */
    public ShadowResult apply(List<String> unitTexts) {
        if (options.getMode() == ProceduralLineageOptions.Mode.LEGACY) {
            return new ShadowResult(Collections.<ComposedEdge>emptySet(),
                    Collections.<String>emptyList(),
                    Collections.<RoutineIdentity, RoutineSummary>emptyMap(),
                    Collections.<RoutineIdentity, Integer>emptyMap());
        }
        List<String> diagnostics = new ArrayList<String>();
        diagnostics.add(APPLICATION_DEFERRED_CALL_VALIDITY_NOT_PROVEN
                + ": composed procedure lineage is observation-only");
        RoutineCatalog catalog = new RoutineCatalog(vendor, unitTexts,
                new HashMap<String, TStatementList>());
        CatalogRoutineCallBinder binder = new CatalogRoutineCallBinder(vendor, catalog);
        RoutineSummaryExtractor extractor = new RoutineSummaryExtractor(vendor);

        // Identity-keyed summary index. Duplicate definitions of one identity
        // stay AMBIGUOUS: they bind nothing and are removed (codex-C5).
        Map<RoutineIdentity, RoutineSummary> summaries =
                new LinkedHashMap<RoutineIdentity, RoutineSummary>();
        Set<RoutineIdentity> duplicates = new LinkedHashSet<RoutineIdentity>();
        int unitOrdinal = -1;
        for (String unitText : unitTexts) {
            unitOrdinal++;
            for (RoutineSummary summary : extractor.extractAll(unitText)) {
                RoutineIdentity id = summary.getIdentity();
                if (id == null) {
                    String code = summary.getCompletenessReasons().contains(
                            "PARSE_FAILED")
                            ? "OPAQUE_UNIT_PARSE_FAILED"
                            : "OPAQUE_UNIT_IDENTITY_UNAVAILABLE";
                    diagnostics.add(code + ": unit=" + unitOrdinal
                            + " reasons=" + summary.getCompletenessReasons());
                    continue;
                }
                if (summaries.containsKey(id)) {
                    duplicates.add(id);
                } else {
                    summaries.put(id, summary);
                }
            }
        }
        for (RoutineIdentity dup : duplicates) {
            summaries.remove(dup);
            diagnostics.add("DUPLICATE_DEFINITION: " + dup);
        }

        // Caller effective database (mssql USE context) per definition.
        Map<RoutineIdentity, String> callerDb = new HashMap<RoutineIdentity, String>();
        for (String unitText : unitTexts) {
            RoutineCatalog.UnitIndex index = catalog.indexOf(unitText);
            if (index == null) {
                continue;
            }
            for (RoutineCatalog.Definition def : index.definitions) {
                if (def.identity != null) {
                    callerDb.put(def.identity, def.db);
                }
            }
        }

        // Freeze every call target ONCE before fixed-point evaluation. No
        // summary-derived type/effect information is ever fed back into the
        // binder (§2.5 frozen-graph invariant).
        Map<RoutineIdentity, List<SiteBinding>> frozenCalls =
                new LinkedHashMap<RoutineIdentity, List<SiteBinding>>();
        Map<RoutineIdentity, List<String>> localReasons =
                new LinkedHashMap<RoutineIdentity, List<String>>();
        for (RoutineIdentity callerId : orderedIdentities(summaries.keySet())) {
            RoutineSummary caller = summaries.get(callerId);
            String callerName = callerId.toString();
            Set<String> reasons = new TreeSet<String>();
            // The extractor's call inventory and every callee-edge projection
            // are not yet exhaustively preflighted. Until that proof exists,
            // no evaluated public summary can authorize replacement.
            reasons.add("CALL_INVENTORY_NOT_PROVEN");
            for (String reason : caller.getCompletenessReasons()) {
                // Base extraction marks every observed call unresolved. The
                // frozen binder verdict below replaces that provisional gate.
                if (!"CALLS_UNRESOLVED".equals(reason)) { // non-identifier-compare: completeness reason token
                    reasons.add(reason);
                }
            }
            List<SiteBinding> resolved = new ArrayList<SiteBinding>();
            int callSiteOrdinal = -1;
            for (CallSiteRef site : caller.getCallSites()) {
                callSiteOrdinal++;
                CatalogRoutineCallBinder.BoundCall bound =
                        binder.bind(site, callerDb.get(caller.getIdentity()),
                                callerId);
                RoutineCallBinder.BindingResult result = bound.getResult();
                if (result.getStatus() != RoutineCallBinder.BindingStatus.RESOLVED) {
                    reasons.add("CALLS_UNRESOLVED");
                    diagnostics.add(result.getStatus() + ": "
                            + site.getRaw().getRawName() + " in " + callerName);
                    addBindingDiagnostics(result, diagnostics);
                    continue;
                }
                boolean invalidOutTarget = hasBindingDiagnostic(result,
                        RoutineCallBinder.BindingDiagnosticCode
                                .PROC_CALL_OUT_TARGET_NOT_WRITABLE);
                boolean outputModeMismatch = hasBindingDiagnostic(result,
                        RoutineCallBinder.BindingDiagnosticCode
                                .PROC_CALL_OUTPUT_MODE_MISMATCH);
                if (invalidOutTarget || outputModeMismatch) {
                    // Invalid OUT/OUTPUT binding makes the call non-executable.
                    // Quarantine the complete site: even an otherwise
                    // independent callee table effect cannot occur.
                    if (invalidOutTarget) {
                        reasons.add("PROC_CALL_OUT_TARGET_NOT_WRITABLE");
                    }
                    if (outputModeMismatch) {
                        reasons.add("PROC_CALL_OUTPUT_MODE_MISMATCH");
                    }
                    reasons.add("CALL_BINDING_PARTIAL");
                    addBindingDiagnostics(result, diagnostics);
                    continue;
                }
                RoutineSummary callee = summaries.get(result.getResolved());
                if (callee == null) {
                    reasons.add("CALLEE_SUMMARY_UNAVAILABLE");
                    diagnostics.add("CALLEE_SUMMARY_UNAVAILABLE: "
                            + site.getRaw().getRawName() + " in " + callerName);
                    continue;
                }
                if (callee.getCompleteness() == RoutineSummary.Completeness.OPAQUE) {
                    reasons.add("CALLEE_OPAQUE");
                    diagnostics.add("CALLEE_OPAQUE: "
                            + site.getRaw().getRawName() + " in " + callerName);
                    continue;
                }
                boolean resultProjectionProven = true;
                if (result.getResultSets() != null) {
                    int targetCount = result.getResultSets()
                            .getPositionalTargets().size();
                    List<String> arityMismatches = resultSetArityMismatches(
                            callee, targetCount);
                    List<String> duplicateAliases = duplicateAliasShapes(callee);
                    List<String> unresolvedProjections =
                            unresolvedResultSetProjections(callee);
                    List<String> duplicateTargets =
                            duplicateInsertTargets(result.getResultSets()
                                    .getPositionalTargets());
                    resultProjectionProven = arityMismatches.isEmpty()
                            && duplicateAliases.isEmpty()
                            && unresolvedProjections.isEmpty()
                            && duplicateTargets.isEmpty()
                            && !callee.getResultSetShapes().isEmpty();
                    for (String mismatch : arityMismatches) {
                        reasons.add("RESULT_SET_MAPPING_ARITY_MISMATCH");
                        diagnostics.add("RESULT_SET_MAPPING_ARITY_MISMATCH: "
                                + site.getRaw().getRawName() + " in "
                                + callerName + " " + mismatch);
                    }
                    for (String shapeName : duplicateAliases) {
                        reasons.add("RESULT_SET_MAPPING_AMBIGUOUS");
                        diagnostics.add("RESULT_SET_MAPPING_AMBIGUOUS: "
                                + site.getRaw().getRawName() + " in "
                                + callerName + " shape=" + shapeName);
                    }
                    for (String projection : unresolvedProjections) {
                        reasons.add("RESULT_SET_MAPPING_UNRESOLVED");
                        diagnostics.add("RESULT_SET_MAPPING_UNRESOLVED: "
                                + site.getRaw().getRawName() + " in "
                                + callerName + " projection=" + projection);
                    }
                    for (String duplicate : duplicateTargets) {
                        reasons.add("RESULT_SET_MAPPING_TARGET_DUPLICATE");
                        diagnostics.add(
                                "RESULT_SET_MAPPING_TARGET_DUPLICATE: "
                                + site.getRaw().getRawName() + " in "
                                + callerName + " " + duplicate);
                    }
                }
                if (result.getCompleteness()
                        == RoutineCallBinder.BindingCompleteness.PARTIAL) {
                    reasons.add("CALL_BINDING_PARTIAL");
                }
                addBindingDiagnostics(result, diagnostics);
                resolved.add(new SiteBinding(site, bound, callee,
                        callSiteOrdinal, resultProjectionProven));
            }
            if (caller.getCalls().size() > caller.getCallSites().size()) {
                reasons.add("CALLS_UNRESOLVED");
            }
            frozenCalls.put(callerId, resolved);
            localReasons.put(callerId, new ArrayList<String>(reasons));
        }

        Evaluation evaluation = evaluateFixedPoint(summaries, frozenCalls,
                localReasons, diagnostics);

        // Project each frozen call against the evaluated callee. This remains
        // an isolated observation side model; even ENHANCED never mutates the
        // legacy dataflow object or exposes applicable additions.
        Map<ComposedEdge, ComposedEdge> additions =
                new LinkedHashMap<ComposedEdge, ComposedEdge>();
        for (RoutineIdentity callerId
                : orderedIdentities(evaluation.summaries.keySet())) {
            List<SiteBinding> evaluatedCalls = callsWithEvaluatedCallees(
                    frozenCalls.get(callerId), evaluation.summaries);
            for (SiteBinding call : evaluatedCalls) {
                composeCallSite(call.site, call.bound, call.callee, callerId,
                        call.ordinal, call.resultProjectionProven, additions);
            }
            composeBridges(callerId, evaluatedCalls, additions);
        }
        Set<ComposedEdge> orderedAdditionSet = orderedAdditions(additions);
        Collections.sort(diagnostics);
        return new ShadowResult(orderedAdditionSet, diagnostics,
                evaluation.summaries,
                evaluation.iterations);
    }

    private List<String> duplicateAliasShapes(RoutineSummary callee) {
        List<String> ambiguous = new ArrayList<String>();
        for (Map.Entry<String, List<String>> entry
                : callee.getResultSetShapes().entrySet()) {
            List<String> shape = entry.getValue();
            if (hasAmbiguousShapeAliases(shape)) {
                ambiguous.add(entry.getKey());
            }
        }
        Collections.sort(ambiguous);
        return ambiguous;
    }

    private static List<String> resultSetArityMismatches(
            RoutineSummary callee, int targetCount) {
        List<String> mismatches = new ArrayList<String>();
        for (Map.Entry<String, List<String>> entry
                : callee.getResultSetShapes().entrySet()) {
            int outputCount = entry.getValue().size();
            if (outputCount != targetCount) {
                mismatches.add("shape=" + entry.getKey()
                        + " outputs=" + outputCount
                        + " targets=" + targetCount);
            }
        }
        Collections.sort(mismatches);
        return mismatches;
    }

    private List<String> unresolvedResultSetProjections(
            RoutineSummary callee) {
        Set<String> unresolved = new TreeSet<String>();
        if (callee.getResultSetShapes().isEmpty()) {
            unresolved.add("NO_RESULT_SHAPE");
        }
        for (RoutineSummaryEdge edge : callee.getEdges()) {
            Endpoint target = edge.getTarget();
            if (target.getKind() != EndpointKind.RESULT_SET_COLUMN) {
                continue;
            }
            List<String> shape = callee.getResultSetShapes().get(
                    target.getParent());
            // Duplicate shapes have their more specific diagnostic above.
            if (shape != null && hasAmbiguousShapeAliases(shape)) {
                continue;
            }
            if (shape == null
                    || uniqueShapeOrdinal(shape, target.getColumn()) < 0) {
                unresolved.add(target.getParent() + "." + target.getColumn());
            }
        }
        return new ArrayList<String>(unresolved);
    }

    /** Duplicate explicit INSERT targets make INSERT...EXEC invalid in SQL
     *  Server. Compare with the vendor identifier facade; spelling/case must
     *  not decide whether a target list is accepted. */
    private List<String> duplicateInsertTargets(List<TObjectName> targets) {
        List<String> duplicates = new ArrayList<String>();
        if (targets == null) {
            return duplicates;
        }
        for (int i = 0; i < targets.size(); i++) {
            for (int j = i + 1; j < targets.size(); j++) {
                String left = targets.get(i).toString();
                String right = targets.get(j).toString();
                if (sameShapeColumn(left, right)) {
                    duplicates.add("target=" + left + " positions="
                            + (i + 1) + "," + (j + 1));
                }
            }
        }
        Collections.sort(duplicates);
        return duplicates;
    }

    private static void addBindingDiagnostics(
            RoutineCallBinder.BindingResult result, List<String> diagnostics) {
        for (RoutineCallBinder.BindingDiagnostic d : result.getDiagnostics()) {
            diagnostics.add(d.getCode() + ": " + d.getDetail());
        }
    }

    private static boolean hasBindingDiagnostic(
            RoutineCallBinder.BindingResult result,
            RoutineCallBinder.BindingDiagnosticCode code) {
        for (RoutineCallBinder.BindingDiagnostic diagnostic
                : result.getDiagnostics()) {
            if (diagnostic.getCode() == code) {
                return true;
            }
        }
        return false;
    }

    /** One RESOLVED call site with its binding and callee summary. */
    private static final class SiteBinding {
        final CallSiteRef site;
        final CatalogRoutineCallBinder.BoundCall bound;
        final RoutineSummary callee;
        final int ordinal;
        /** All result shapes at this call site passed cardinality, alias, and
         *  endpoint-to-shape preflight. False suppresses every result-set
         *  projection while preserving OUT and table-side-effect edges. */
        final boolean resultProjectionProven;

        SiteBinding(CallSiteRef site, CatalogRoutineCallBinder.BoundCall bound,
                RoutineSummary callee, int ordinal,
                boolean resultProjectionProven) {
            this.site = site;
            this.bound = bound;
            this.callee = callee;
            this.ordinal = ordinal;
            this.resultProjectionProven = resultProjectionProven;
        }

        SiteBinding withCallee(RoutineSummary evaluated) {
            return new SiteBinding(site, bound, evaluated, ordinal,
                    resultProjectionProven);
        }
    }

    private static final class Evaluation {
        final Map<RoutineIdentity, RoutineSummary> summaries;
        final Map<RoutineIdentity, Integer> iterations;

        Evaluation(Map<RoutineIdentity, RoutineSummary> summaries,
                Map<RoutineIdentity, Integer> iterations) {
            this.summaries = summaries;
            this.iterations = iterations;
        }
    }

    /**
     * B5: evaluate the frozen routine-call graph one SCC at a time, callees
     * before callers. Within a recursive component updates are synchronous
     * monotone joins over a finite edge/advisory-function lattice. A cap preserves
     * the accumulated under-approximation and changes only completeness.
     */
    private Evaluation evaluateFixedPoint(
            Map<RoutineIdentity, RoutineSummary> baseSummaries,
            Map<RoutineIdentity, List<SiteBinding>> frozenCalls,
            Map<RoutineIdentity, List<String>> localReasons,
            List<String> diagnostics) {
        Map<RoutineIdentity, RoutineSummary> evaluated =
                new LinkedHashMap<RoutineIdentity, RoutineSummary>();
        Map<RoutineIdentity, Integer> iterations =
                new LinkedHashMap<RoutineIdentity, Integer>();
        List<List<RoutineIdentity>> components = calleeFirstComponents(
                baseSummaries.keySet(), frozenCalls);
        for (List<RoutineIdentity> component : components) {
            Set<RoutineIdentity> members =
                    new HashSet<RoutineIdentity>(component);
            Map<RoutineIdentity, Set<String>> reasons =
                    componentReasons(component, members, frozenCalls,
                            localReasons, evaluated);
            Map<RoutineIdentity, RoutineSummary> current =
                    new LinkedHashMap<RoutineIdentity, RoutineSummary>();
            for (RoutineIdentity id : component) {
                RoutineSummary base = baseSummaries.get(id);
                current.put(id, base.evaluated(base.getEdges(),
                        completenessOf(base, reasons.get(id)),
                        new ArrayList<String>(reasons.get(id))));
            }

            int cap = options.iterationCapForScc(component.size());
            int rounds = 0;
            boolean converged = false;
            boolean recursive = isRecursiveComponent(component, frozenCalls);
            while (rounds < cap) {
                rounds++;
                Map<RoutineIdentity, RoutineSummary> next =
                        new LinkedHashMap<RoutineIdentity, RoutineSummary>();
                for (RoutineIdentity id : component) {
                    RoutineSummary base = baseSummaries.get(id);
                    if (base.getCompleteness() == RoutineSummary.Completeness.OPAQUE) {
                        next.put(id, current.get(id));
                        continue;
                    }
                    List<SiteBinding> calls = callsForEvaluation(
                            frozenCalls.get(id), current, evaluated);
                    Set<RoutineSummaryEdge> edges = composeSummaryEdges(
                            base, id, calls);
                    next.put(id, base.evaluated(edges,
                            completenessOf(base, reasons.get(id)),
                            new ArrayList<String>(reasons.get(id))));
                }
                if (sameSummaryValues(current, next)) {
                    current = next;
                    converged = true;
                    break;
                }
                current = next;
                // A singleton with no self-edge depends only on already-final
                // external callees. Its first recomputation is the exact
                // result; a second no-change probe is unnecessary and an
                // explicit cap=1 must not fabricate a recursion diagnostic.
                if (!recursive) {
                    converged = true;
                    break;
                }
            }

            if (!converged) {
                String componentKey = componentKey(component);
                diagnostics.add("PROC_RECURSION_LIMIT: cap=" + cap
                        + ", component=" + componentKey);
                for (RoutineIdentity id : component) {
                    RoutineSummary summary = current.get(id);
                    Set<String> cappedReasons = new TreeSet<String>(
                            summary.getCompletenessReasons());
                    cappedReasons.add("PROC_RECURSION_LIMIT");
                    current.put(id, summary.evaluated(summary.getEdges(),
                            RoutineSummary.Completeness.PARTIAL,
                            new ArrayList<String>(cappedReasons)));
                }
            }
            for (RoutineIdentity id : component) {
                evaluated.put(id, current.get(id));
                iterations.put(id, Integer.valueOf(rounds));
            }
        }
        // Re-key in canonical identity order so result iteration and JSON
        // serialization are independent of file/hash-map order.
        Map<RoutineIdentity, RoutineSummary> ordered =
                new LinkedHashMap<RoutineIdentity, RoutineSummary>();
        Map<RoutineIdentity, Integer> orderedIterations =
                new LinkedHashMap<RoutineIdentity, Integer>();
        for (RoutineIdentity id : orderedIdentities(evaluated.keySet())) {
            RoutineSummary summary = evaluated.get(id);
            ordered.put(id, summary);
            orderedIterations.put(id, iterations.get(id));
            if (summary.getCompleteness() != RoutineSummary.Completeness.COMPLETE) {
                diagnostics.add("SUMMARY_" + summary.getCompleteness() + ": "
                        + id.signatureKey() + " reasons="
                        + summary.getCompletenessReasons());
            }
        }
        return new Evaluation(ordered, orderedIterations);
    }

    private static boolean isRecursiveComponent(List<RoutineIdentity> component,
            Map<RoutineIdentity, List<SiteBinding>> frozenCalls) {
        if (component.size() > 1) {
            return true;
        }
        RoutineIdentity only = component.get(0);
        List<SiteBinding> calls = frozenCalls.get(only);
        if (calls != null) {
            for (SiteBinding call : calls) {
                if (only.equals(call.bound.getResult().getResolved())) {
                    return true;
                }
            }
        }
        return false;
    }

    private RoutineSummary.Completeness completenessOf(RoutineSummary base,
            Set<String> reasons) {
        if (base.getCompleteness() == RoutineSummary.Completeness.OPAQUE) {
            return RoutineSummary.Completeness.OPAQUE;
        }
        return reasons == null || reasons.isEmpty()
                ? RoutineSummary.Completeness.COMPLETE
                : RoutineSummary.Completeness.PARTIAL;
    }

    /** Local reasons plus monotone partialness propagation through the frozen
     *  component. Only a bounded callee marker propagates, never recursively
     *  nested reason text. */
    private Map<RoutineIdentity, Set<String>> componentReasons(
            List<RoutineIdentity> component, Set<RoutineIdentity> members,
            Map<RoutineIdentity, List<SiteBinding>> frozenCalls,
            Map<RoutineIdentity, List<String>> localReasons,
            Map<RoutineIdentity, RoutineSummary> evaluated) {
        Map<RoutineIdentity, Set<String>> reasons =
                new LinkedHashMap<RoutineIdentity, Set<String>>();
        for (RoutineIdentity id : component) {
            Set<String> own = new TreeSet<String>();
            List<String> local = localReasons.get(id);
            if (local != null) {
                own.addAll(local);
            }
            List<SiteBinding> calls = frozenCalls.get(id);
            if (calls != null) {
                for (SiteBinding call : calls) {
                    RoutineIdentity callee = call.bound.getResult().getResolved();
                    if (!members.contains(callee)) {
                        RoutineSummary done = evaluated.get(callee);
                        if (done != null && done.getCompleteness()
                                != RoutineSummary.Completeness.COMPLETE) {
                            own.add("CALLEE_PARTIAL:" + callee.signatureKey());
                        }
                    }
                }
            }
            reasons.put(id, own);
        }
        boolean changed;
        do {
            changed = false;
            for (RoutineIdentity id : component) {
                List<SiteBinding> calls = frozenCalls.get(id);
                if (calls == null) {
                    continue;
                }
                for (SiteBinding call : calls) {
                    RoutineIdentity callee = call.bound.getResult().getResolved();
                    if (members.contains(callee)
                            && !reasons.get(callee).isEmpty()) {
                        changed |= reasons.get(id).add(
                                "CALLEE_PARTIAL:" + callee.signatureKey());
                    }
                }
            }
        } while (changed);
        return reasons;
    }

    private Set<RoutineSummaryEdge> composeSummaryEdges(RoutineSummary base,
            RoutineIdentity callerId, List<SiteBinding> calls) {
        Map<ComposedEdge, ComposedEdge> composed =
                new LinkedHashMap<ComposedEdge, ComposedEdge>();
        for (SiteBinding call : calls) {
            composeCallSite(call.site, call.bound, call.callee, callerId,
                    call.ordinal, call.resultProjectionProven, composed);
        }
        composeBridges(callerId, calls, composed);
        Map<RoutineSummaryEdge, RoutineSummaryEdge> joined =
                new LinkedHashMap<RoutineSummaryEdge, RoutineSummaryEdge>();
        for (RoutineSummaryEdge edge : base.getEdges()) {
            joinSummaryEdge(joined, edge);
        }
        for (ComposedEdge edge : composed.values()) {
            joinSummaryEdge(joined, new RoutineSummaryEdge(edge.getSource(),
                    edge.getTarget(), edge.getRelationType(),
                    edge.getObservedFunctions()));
        }
        List<RoutineSummaryEdge> ordered =
                new ArrayList<RoutineSummaryEdge>(joined.values());
        Collections.sort(ordered, SUMMARY_EDGE_ORDER);
        return new LinkedHashSet<RoutineSummaryEdge>(ordered);
    }

    private void joinSummaryEdge(
            Map<RoutineSummaryEdge, RoutineSummaryEdge> joined,
            RoutineSummaryEdge candidate) {
        RoutineSummaryEdge bounded = boundObservedFunctions(candidate);
        RoutineSummaryEdge prior = joined.get(bounded);
        joined.put(bounded, prior == null ? bounded
                : prior.joinMetadata(bounded,
                        options.getMaxObservedFunctions()));
    }

    private RoutineSummaryEdge boundObservedFunctions(
            RoutineSummaryEdge edge) {
        if (edge.isObservedFunctionsTop()
                || edge.getObservedFunctions().size()
                        <= options.getMaxObservedFunctions()) {
            return edge;
        }
        return new RoutineSummaryEdge(edge.getSource(), edge.getTarget(),
                edge.getRelationType(), Collections.singleton(
                        RoutineSummaryEdge.OBSERVED_FUNCTIONS_TOP));
    }

    private static boolean sameSummaryValues(
            Map<RoutineIdentity, RoutineSummary> a,
            Map<RoutineIdentity, RoutineSummary> b) {
        if (!a.keySet().equals(b.keySet())) {
            return false;
        }
        for (RoutineIdentity id : a.keySet()) {
            RoutineSummary left = a.get(id);
            RoutineSummary right = b.get(id);
            if (left.getCompleteness() != right.getCompleteness()
                    || !left.getCompletenessReasons().equals(
                            right.getCompletenessReasons())
                    || !sameEdgeValues(left.getEdges(), right.getEdges())) {
                return false;
            }
        }
        return true;
    }

    private static boolean sameEdgeValues(Set<RoutineSummaryEdge> a,
            Set<RoutineSummaryEdge> b) {
        if (a.size() != b.size()) {
            return false;
        }
        Map<RoutineSummaryEdge, Set<String>> rightValues =
                new HashMap<RoutineSummaryEdge, Set<String>>();
        for (RoutineSummaryEdge edge : b) {
            rightValues.put(edge, edge.getObservedFunctions());
        }
        for (RoutineSummaryEdge edge : a) {
            Set<String> right = rightValues.get(edge);
            if (right == null
                    || !edge.getObservedFunctions().equals(right)) {
                return false;
            }
        }
        return true;
    }

    private static List<SiteBinding> callsForEvaluation(
            List<SiteBinding> frozen, Map<RoutineIdentity, RoutineSummary> current,
            Map<RoutineIdentity, RoutineSummary> evaluated) {
        List<SiteBinding> result = new ArrayList<SiteBinding>();
        if (frozen == null) {
            return result;
        }
        for (SiteBinding call : frozen) {
            RoutineIdentity calleeId = call.bound.getResult().getResolved();
            RoutineSummary callee = current.get(calleeId);
            if (callee == null) {
                callee = evaluated.get(calleeId);
            }
            if (callee != null) {
                result.add(call.withCallee(callee));
            }
        }
        return result;
    }

    private static List<SiteBinding> callsWithEvaluatedCallees(
            List<SiteBinding> frozen,
            Map<RoutineIdentity, RoutineSummary> evaluated) {
        return callsForEvaluation(frozen,
                Collections.<RoutineIdentity, RoutineSummary>emptyMap(), evaluated);
    }

    // ------------------------------------------------------------------
    // Deterministic non-recursive SCC discovery and callee-first ordering.
    // ------------------------------------------------------------------

    private static final Comparator<RoutineIdentity> IDENTITY_ORDER =
            new Comparator<RoutineIdentity>() {
                @Override
                public int compare(RoutineIdentity a, RoutineIdentity b) {
                    return a.signatureKey().compareTo(b.signatureKey());
                }
            };

    private static final Comparator<RoutineSummaryEdge> SUMMARY_EDGE_ORDER =
            new Comparator<RoutineSummaryEdge>() {
                @Override
                public int compare(RoutineSummaryEdge a, RoutineSummaryEdge b) {
                    int c = a.getSource().compareTo(b.getSource());
                    if (c != 0) return c;
                    c = a.getTarget().compareTo(b.getTarget());
                    if (c != 0) return c;
                    return a.getRelationType().compareTo(b.getRelationType());
                }
            };

    private static List<RoutineIdentity> orderedIdentities(
            Set<RoutineIdentity> identities) {
        List<RoutineIdentity> ordered = new ArrayList<RoutineIdentity>(identities);
        Collections.sort(ordered, IDENTITY_ORDER);
        return ordered;
    }

    private static final class DfsFrame {
        final RoutineIdentity node;
        final List<RoutineIdentity> neighbors;
        int next;

        DfsFrame(RoutineIdentity node, List<RoutineIdentity> neighbors) {
            this.node = node;
            this.neighbors = neighbors;
        }
    }

    private static List<List<RoutineIdentity>> calleeFirstComponents(
            Set<RoutineIdentity> nodes,
            Map<RoutineIdentity, List<SiteBinding>> calls) {
        Map<RoutineIdentity, List<RoutineIdentity>> graph =
                adjacency(nodes, calls, false);
        Map<RoutineIdentity, List<RoutineIdentity>> reverse =
                adjacency(nodes, calls, true);
        Set<RoutineIdentity> visited = new HashSet<RoutineIdentity>();
        List<RoutineIdentity> finish = new ArrayList<RoutineIdentity>();
        for (RoutineIdentity start : orderedIdentities(nodes)) {
            if (!visited.add(start)) {
                continue;
            }
            Deque<DfsFrame> stack = new ArrayDeque<DfsFrame>();
            stack.push(new DfsFrame(start, graph.get(start)));
            while (!stack.isEmpty()) {
                DfsFrame frame = stack.peek();
                if (frame.next < frame.neighbors.size()) {
                    RoutineIdentity next = frame.neighbors.get(frame.next++);
                    if (visited.add(next)) {
                        stack.push(new DfsFrame(next, graph.get(next)));
                    }
                } else {
                    finish.add(frame.node);
                    stack.pop();
                }
            }
        }
        List<List<RoutineIdentity>> components =
                new ArrayList<List<RoutineIdentity>>();
        visited.clear();
        for (int i = finish.size() - 1; i >= 0; i--) {
            RoutineIdentity start = finish.get(i);
            if (!visited.add(start)) {
                continue;
            }
            List<RoutineIdentity> component = new ArrayList<RoutineIdentity>();
            Deque<RoutineIdentity> stack = new ArrayDeque<RoutineIdentity>();
            stack.push(start);
            while (!stack.isEmpty()) {
                RoutineIdentity node = stack.pop();
                component.add(node);
                List<RoutineIdentity> neighbors = reverse.get(node);
                for (int n = neighbors.size() - 1; n >= 0; n--) {
                    if (visited.add(neighbors.get(n))) {
                        stack.push(neighbors.get(n));
                    }
                }
            }
            Collections.sort(component, IDENTITY_ORDER);
            components.add(component);
        }
        return orderComponentsByDependencies(components, graph);
    }

    private static Map<RoutineIdentity, List<RoutineIdentity>> adjacency(
            Set<RoutineIdentity> nodes,
            Map<RoutineIdentity, List<SiteBinding>> calls, boolean reverse) {
        Map<RoutineIdentity, Set<RoutineIdentity>> sets =
                new LinkedHashMap<RoutineIdentity, Set<RoutineIdentity>>();
        for (RoutineIdentity id : orderedIdentities(nodes)) {
            sets.put(id, new TreeSet<RoutineIdentity>(IDENTITY_ORDER));
        }
        for (RoutineIdentity caller : orderedIdentities(nodes)) {
            List<SiteBinding> sites = calls.get(caller);
            if (sites == null) {
                continue;
            }
            for (SiteBinding site : sites) {
                RoutineIdentity callee = site.bound.getResult().getResolved();
                if (!sets.containsKey(callee)) {
                    continue;
                }
                if (reverse) {
                    sets.get(callee).add(caller);
                } else {
                    sets.get(caller).add(callee);
                }
            }
        }
        Map<RoutineIdentity, List<RoutineIdentity>> result =
                new LinkedHashMap<RoutineIdentity, List<RoutineIdentity>>();
        for (RoutineIdentity id : orderedIdentities(nodes)) {
            result.put(id, new ArrayList<RoutineIdentity>(sets.get(id)));
        }
        return result;
    }

    private static List<List<RoutineIdentity>> orderComponentsByDependencies(
            List<List<RoutineIdentity>> components,
            Map<RoutineIdentity, List<RoutineIdentity>> graph) {
        Map<RoutineIdentity, Integer> componentOf =
                new HashMap<RoutineIdentity, Integer>();
        for (int i = 0; i < components.size(); i++) {
            for (RoutineIdentity id : components.get(i)) {
                componentOf.put(id, Integer.valueOf(i));
            }
        }
        Map<Integer, Set<Integer>> dependencies =
                new LinkedHashMap<Integer, Set<Integer>>();
        for (int i = 0; i < components.size(); i++) {
            dependencies.put(Integer.valueOf(i), new LinkedHashSet<Integer>());
        }
        for (Map.Entry<RoutineIdentity, List<RoutineIdentity>> entry
                : graph.entrySet()) {
            int caller = componentOf.get(entry.getKey()).intValue();
            for (RoutineIdentity calleeId : entry.getValue()) {
                int callee = componentOf.get(calleeId).intValue();
                if (caller != callee) {
                    dependencies.get(Integer.valueOf(caller)).add(
                            Integer.valueOf(callee));
                }
            }
        }
        List<List<RoutineIdentity>> ordered =
                new ArrayList<List<RoutineIdentity>>();
        Set<Integer> emitted = new HashSet<Integer>();
        while (ordered.size() < components.size()) {
            int winner = -1;
            String winnerKey = null;
            for (int i = 0; i < components.size(); i++) {
                if (emitted.contains(Integer.valueOf(i))
                        || !emitted.containsAll(dependencies.get(Integer.valueOf(i)))) {
                    continue;
                }
                String key = componentKey(components.get(i));
                if (winner < 0 || key.compareTo(winnerKey) < 0) {
                    winner = i;
                    winnerKey = key;
                }
            }
            if (winner < 0) {
                throw new IllegalStateException("SCC condensation graph is cyclic");
            }
            emitted.add(Integer.valueOf(winner));
            ordered.add(components.get(winner));
        }
        return ordered;
    }

    private static String componentKey(List<RoutineIdentity> component) {
        StringBuilder key = new StringBuilder();
        for (RoutineIdentity id : component) {
            if (key.length() > 0) {
                key.append(',');
            }
            key.append(id.signatureKey());
        }
        return key.toString();
    }

    private static Set<ComposedEdge> orderedAdditions(
            Map<ComposedEdge, ComposedEdge> additions) {
        List<ComposedEdge> ordered =
                new ArrayList<ComposedEdge>(additions.values());
        Collections.sort(ordered, new Comparator<ComposedEdge>() {
            @Override
            public int compare(ComposedEdge a, ComposedEdge b) {
                int c = a.getSource().compareTo(b.getSource());
                if (c != 0) return c;
                c = a.getTarget().compareTo(b.getTarget());
                if (c != 0) return c;
                c = a.getRelationType().compareTo(b.getRelationType());
                if (c != 0) return c;
                c = IDENTITY_ORDER.compare(a.getCallerIdentity(),
                        b.getCallerIdentity());
                if (c != 0) return c;
                c = IDENTITY_ORDER.compare(a.getCalleeIdentity(),
                        b.getCalleeIdentity());
                if (c != 0) return c;
                return a.getCallSiteOrdinal() - b.getCallSiteOrdinal();
            }
        });
        return new LinkedHashSet<ComposedEdge>(ordered);
    }

    /**
     * Intra-caller call-to-call bridge (codex-B3-r1 finding 5, generalized
     * to a FIXED POINT per codex-B3-r2 finding 5): for
     * {@code A(@v OUTPUT); B(@v)} the local {@code @v} is interior on both
     * sides, so neither call site's BOUNDARY reach carries the flow — the
     * node-level maps do. The inline engine's shared variable node merges
     * all reads/writes flow-INsensitively, so no statement-order check
     * belongs here, and the SAME call site may bridge to itself
     * ({@code P(@v, @v OUTPUT)}).
     *
     * <p>Mechanics: seed node-level FACTS (external sources written by a
     * callee OUT projection onto every model node the lvalue forward-
     * reaches), then propagate: an IN actual whose node carries facts feeds
     * its callee's formal-sourced edges — table/temp targets emit
     * additions, result-set targets map through INSERT…EXEC, and OUT-formal
     * targets seed NEW facts (the chain hop). Facts are monotone bit-joins
     * ⇒ the loop converges; the guard is a safety valve only.
     */
    private void composeBridges(RoutineIdentity callerIdentity,
            List<SiteBinding> resolved,
            Map<ComposedEdge, ComposedEdge> additions) {
        // model node -> external source endpoint -> flavor bits
        // (1 = an all-fdd chain reaches this node, 2 = an fdr-bearing one)
        Map<String, Map<Endpoint, Integer>> nodeFacts =
                new LinkedHashMap<String, Map<Endpoint, Integer>>();
        // GENUINE convergence, no iteration cap (codex-B3-r3 finding 1: a
        // sites-based cap cut long value/filter cycles short and silently
        // dropped fdr edges). Termination is structural: every state change
        // is a monotone join into a finite space — fact flavor bits per
        // (node, source) and the additions set — so a full sweep with no
        // change is reached in finitely many sweeps.
        boolean changed = seedOutFacts(callerIdentity, resolved, nodeFacts);
        while (changed) {
            changed = false;
            for (SiteBinding in : resolved) {
                RoutineIdentity inCallee = in.bound.getResult().getResolved();
                for (Map.Entry<Integer, Set<String>> inEntry
                        : in.site.getInNodes().entrySet()) {
                    int inActual = inEntry.getKey();
                    Map<Endpoint, Integer> facts = factsAt(nodeFacts,
                            inEntry.getValue());
                    if (facts.isEmpty()) {
                        continue;
                    }
                    int inFormal = formalOfActual(
                            in.bound.getActualPositionByFormal(), inActual);
                    if (inFormal < 0 || !in.bound.getResult().getInputs()
                            .containsKey(inFormal)) {
                        continue; // binder refused the input (literal, pure OUT)
                    }
                    for (RoutineSummaryEdge edge : in.callee.getEdges()) {
                        if (edge.getSource().getKind() != EndpointKind.FORMAL
                                || formalPositionOf(edge.getSource(), inCallee)
                                        != inFormal) {
                            continue;
                        }
                        boolean edgeFdr = "fdr".equals(edge.getRelationType()); // non-identifier-compare: relation type token
                        changed |= emitOrChain(in, edge, edgeFdr, facts,
                                callerIdentity, inCallee, additions, nodeFacts);
                    }
                }
            }
        }
    }

    /** Seed facts: each validated OUT projection writes its callee-side
     *  sources onto every node the bound lvalue forward-reaches. Returns
     *  true when anything was seeded. */
    private boolean seedOutFacts(RoutineIdentity callerIdentity,
            List<SiteBinding> resolved,
            Map<String, Map<Endpoint, Integer>> nodeFacts) {
        boolean seeded = false;
        for (SiteBinding out : resolved) {
            RoutineIdentity outCallee = out.bound.getResult().getResolved();
            for (Map.Entry<Integer, RoutineCallBinder.WritableTarget> o
                    : out.bound.getResult().getOutputs().entrySet()) {
                int outFormal = o.getKey();
                Integer outActual = out.bound.getActualPositionByFormal().get(outFormal);
                if (outActual == null) {
                    continue;
                }
                Map<String, Integer> reachNodes =
                        out.site.getOutReachNodes().get(outActual);
                if (reachNodes == null || reachNodes.isEmpty()) {
                    continue;
                }
                for (RoutineSummaryEdge edge : out.callee.getEdges()) {
                    if (edge.getTarget().getKind() != EndpointKind.FORMAL
                            || formalPositionOf(edge.getTarget(), outCallee)
                                    != outFormal) {
                        continue;
                    }
                    boolean edgeFdr = "fdr".equals(edge.getRelationType()); // non-identifier-compare: relation type token
                    for (Attributed s : resolveCalleeSource(edge.getSource(),
                            outCallee, out.bound.getActualPositionByFormal(),
                            out.site, out.bound.getResult(), callerIdentity)) {
                        for (Map.Entry<String, Integer> node : reachNodes.entrySet()) {
                            int bits = flavorOf(s.fdr || edgeFdr, node.getValue());
                            seeded |= joinFact(nodeFacts, node.getKey(),
                                    s.endpoint, bits);
                        }
                    }
                }
            }
        }
        return seeded;
    }

    /** Emit additions for one fact-fed callee edge, or seed chained facts
     *  when the edge lands on a further OUT projection. */
    private boolean emitOrChain(SiteBinding in, RoutineSummaryEdge edge,
            boolean edgeFdr, Map<Endpoint, Integer> facts,
            RoutineIdentity callerIdentity, RoutineIdentity inCallee,
            Map<ComposedEdge, ComposedEdge> additions,
            Map<String, Map<Endpoint, Integer>> nodeFacts) {
        boolean changed = false;
        Endpoint target = edge.getTarget();
        if (target.getKind() == EndpointKind.TABLE_COLUMN
                || target.getKind() == EndpointKind.TEMP_COLUMN
                || target.getKind() == EndpointKind.RESULT_SET_COLUMN) {
            List<Attributed> resolvedTargets = resolveCalleeTarget(target,
                    inCallee, in.bound.getActualPositionByFormal(), in.site,
                    in.bound, in.callee, in.resultProjectionProven);
            for (Attributed t : resolvedTargets) {
                for (Map.Entry<Endpoint, Integer> fact : facts.entrySet()) {
                    boolean legsFdd = !edgeFdr && !t.fdr;
                    if (legsFdd && (fact.getValue() & 1) != 0) {
                        changed |= addComposedEdge(additions, fact.getKey(),
                                t.endpoint, "fdd", callerIdentity, inCallee,
                                in.ordinal, edge.getObservedFunctions(),
                                // A node bridge may already contain effects
                                // from another callee whose completeness is
                                // not represented in the legacy bitset. Keep
                                // the gate conservative until bridge facts
                                // carry full provenance.
                                RoutineSummary.Completeness.PARTIAL);
                    }
                    if (!legsFdd || (fact.getValue() & 2) != 0) {
                        changed |= addComposedEdge(additions, fact.getKey(),
                                t.endpoint, "fdr", callerIdentity, inCallee,
                                in.ordinal, edge.getObservedFunctions(),
                                RoutineSummary.Completeness.PARTIAL);
                    }
                }
            }
            return changed;
        }
        if (target.getKind() == EndpointKind.FORMAL) {
            // chain hop: IN formal -> OUT formal of the same callee, whose
            // lvalue seeds facts further downstream
            int chainedFormal = formalPositionOf(target, inCallee);
            if (chainedFormal < 0 || !in.bound.getResult().getOutputs()
                    .containsKey(chainedFormal)) {
                return false;
            }
            Integer chainedActual = in.bound.getActualPositionByFormal()
                    .get(chainedFormal);
            if (chainedActual == null) {
                return false;
            }
            Map<String, Integer> reachNodes =
                    in.site.getOutReachNodes().get(chainedActual);
            if (reachNodes == null) {
                return false;
            }
            for (Map.Entry<Endpoint, Integer> fact : facts.entrySet()) {
                for (Map.Entry<String, Integer> node : reachNodes.entrySet()) {
                    boolean fdrChain = edgeFdr || (fact.getValue() & 1) == 0;
                    int bits = flavorOf(fdrChain, node.getValue());
                    // an fdr-bearing incoming fact also carries fdr onward
                    if ((fact.getValue() & 2) != 0) {
                        bits |= 2;
                    }
                    changed |= joinFact(nodeFacts, node.getKey(),
                            fact.getKey(), bits);
                }
            }
        }
        return changed;
    }

    /** Compose one leg's fdr-ness with a bridge segment's flavor bits. */
    private static int flavorOf(boolean legFdr, int pathBits) {
        int bits = 0;
        if (!legFdr && (pathBits & 1) != 0) {
            bits |= 1;
        }
        if (legFdr || (pathBits & 2) != 0) {
            bits |= 2;
        }
        return bits;
    }

    private static boolean joinFact(Map<String, Map<Endpoint, Integer>> nodeFacts,
            String node, Endpoint source, int bits) {
        if (bits == 0) {
            return false;
        }
        Map<Endpoint, Integer> facts = nodeFacts.get(node);
        if (facts == null) {
            facts = new LinkedHashMap<Endpoint, Integer>();
            nodeFacts.put(node, facts);
        }
        Integer prior = facts.get(source);
        int joined = prior == null ? bits : (prior | bits);
        if (prior != null && joined == prior) {
            return false;
        }
        facts.put(source, joined);
        return true;
    }

    /** Union of facts across an actual's own model nodes. */
    private static Map<Endpoint, Integer> factsAt(
            Map<String, Map<Endpoint, Integer>> nodeFacts, Set<String> nodes) {
        Map<Endpoint, Integer> union = new LinkedHashMap<Endpoint, Integer>();
        for (String node : nodes) {
            Map<Endpoint, Integer> facts = nodeFacts.get(node);
            if (facts == null) {
                continue;
            }
            for (Map.Entry<Endpoint, Integer> e : facts.entrySet()) {
                Integer prior = union.get(e.getKey());
                union.put(e.getKey(), prior == null
                        ? e.getValue() : (prior | e.getValue()));
            }
        }
        return union;
    }

    /** Formal position bound to a given actual position; -1 when none. */
    private static int formalOfActual(Map<Integer, Integer> actualByFormal,
            int actualPos) {
        for (Map.Entry<Integer, Integer> e : actualByFormal.entrySet()) {
            if (e.getValue() == actualPos) {
                return e.getKey();
            }
        }
        return -1;
    }

    /** Compose one RESOLVED call site: callee summary edges × caller reach. */
    private void composeCallSite(CallSiteRef site,
            CatalogRoutineCallBinder.BoundCall bound, RoutineSummary callee,
            RoutineIdentity callerIdentity, int callSiteOrdinal,
            boolean resultProjectionProven,
            Map<ComposedEdge, ComposedEdge> additions) {
        RoutineIdentity calleeId = bound.getResult().getResolved();
        // Public B6 is observation-only until call validity, type/mutability,
        // context, inventory, and every projection shape are exhaustively
        // preflighted. Completeness cannot authorize application here.
        RoutineSummary.Completeness effectiveCompleteness =
                RoutineSummary.Completeness.PARTIAL;
        Map<Integer, Integer> actualByFormal = bound.getActualPositionByFormal();
        for (RoutineSummaryEdge edge : callee.getEdges()) {
            boolean edgeFdr = "fdr".equals(edge.getRelationType()); // non-identifier-compare: relation type token
            // Resolve the callee edge's SOURCE into caller space.
            List<Attributed> sources = resolveCalleeSource(edge.getSource(),
                    calleeId, actualByFormal, site, bound.getResult(),
                    callerIdentity);
            if (sources.isEmpty()) {
                continue;
            }
            // Resolve the callee edge's TARGET into caller space.
            List<Attributed> targets = resolveCalleeTarget(edge.getTarget(),
                    calleeId, actualByFormal, site, bound, callee,
                    resultProjectionProven);

            for (Attributed s : sources) {
                for (Attributed t : targets) {
                    boolean anyFdr = edgeFdr || s.fdr || t.fdr;
                    boolean allFdd = !edgeFdr && !s.fdr && !t.fdr;
                    if (allFdd) {
                        addComposedEdge(additions, s.endpoint, t.endpoint,
                                "fdd", callerIdentity, calleeId, callSiteOrdinal,
                                edge.getObservedFunctions(), effectiveCompleteness);
                    } else if (anyFdr) {
                        addComposedEdge(additions, s.endpoint, t.endpoint,
                                "fdr", callerIdentity, calleeId, callSiteOrdinal,
                                edge.getObservedFunctions(), effectiveCompleteness);
                    }
                }
            }
        }
    }

    /** Add one occurrence edge, joining bounded observed-function metadata when the
     *  same occurrence is reached through more than one summary path. */
    private boolean addComposedEdge(
            Map<ComposedEdge, ComposedEdge> additions,
            Endpoint source, Endpoint target, String relationType,
            RoutineIdentity callerIdentity, RoutineIdentity calleeIdentity,
            int callSiteOrdinal, Set<String> observedFunctions,
            RoutineSummary.Completeness completeness) {
        ComposedEdge candidate = new ComposedEdge(source, target, relationType,
                callerIdentity, calleeIdentity, callSiteOrdinal,
                joinObservedFunctions(Collections.<String>emptySet(),
                        observedFunctions),
                completeness);
        ComposedEdge prior = additions.get(candidate);
        if (prior == null) {
            additions.put(candidate, candidate);
            return true;
        }
        Set<String> joined = joinObservedFunctions(
                prior.getObservedFunctions(), observedFunctions);
        RoutineSummary.Completeness joinedCompleteness =
                prior.getCalleeCompleteness() == RoutineSummary.Completeness.COMPLETE
                        && completeness == RoutineSummary.Completeness.COMPLETE
                        ? RoutineSummary.Completeness.COMPLETE
                        : RoutineSummary.Completeness.PARTIAL;
        if (joined.equals(prior.getObservedFunctions())
                && joinedCompleteness == prior.getCalleeCompleteness()) {
            return false;
        }
        additions.put(candidate,
                prior.withMetadata(joined, joinedCompleteness));
        return true;
    }

    private Set<String> joinObservedFunctions(Set<String> left,
            Set<String> right) {
        if (left.contains(RoutineSummaryEdge.OBSERVED_FUNCTIONS_TOP)
                || (right != null
                        && right.contains(
                                RoutineSummaryEdge.OBSERVED_FUNCTIONS_TOP))) {
            return Collections.singleton(
                    RoutineSummaryEdge.OBSERVED_FUNCTIONS_TOP);
        }
        Set<String> joined = new TreeSet<String>(left);
        if (right != null) {
            joined.addAll(right);
        }
        if (joined.size() > options.getMaxObservedFunctions()) {
            return Collections.singleton(
                    RoutineSummaryEdge.OBSERVED_FUNCTIONS_TOP);
        }
        return joined;
    }

    /** A caller-space endpoint plus the relation flavor of the leg that
     *  produced it (fdr=true when the leg passed through an fdr hop). */
    private static final class Attributed {
        final Endpoint endpoint;
        final boolean fdr;

        Attributed(Endpoint endpoint, boolean fdr) {
            this.endpoint = endpoint;
            this.fdr = fdr;
        }
    }

    /**
     * Callee edge SOURCE in caller space: a formal chains through the caller
     * sources of its bound actual; global endpoints (tables, temps) pass
     * through unchanged. Result-set sources never compose (a callee cannot
     * read its own output shape).
     */
    private List<Attributed> resolveCalleeSource(Endpoint source,
            RoutineIdentity calleeId, Map<Integer, Integer> actualByFormal,
            CallSiteRef site, RoutineCallBinder.BindingResult binding,
            RoutineIdentity callerId) {
        List<Attributed> result = new ArrayList<Attributed>();
        if (source.getKind() == EndpointKind.FORMAL) {
            int formal = formalPositionOf(source, calleeId);
            Integer actualPos = formal < 0 ? null : actualByFormal.get(formal);
            if (actualPos == null) {
                return result; // defaulted formal: no caller-side source
            }
            // The binder's INPUT map is the authority: a formal it refused
            // to bind (Oracle pure OUT, literal) contributes no IN leg —
            // composing the raw reach anyway would fabricate flow
            // (codex-B3-r2 finding 3).
            if (!binding.getInputs().containsKey(formal)) {
                return result;
            }
            addAll(result, site.getInSourcesFdd().get(actualPos), false);
            addAll(result, site.getInSourcesFdr().get(actualPos), true);
            if (result.isEmpty()) {
                Endpoint callerFormal = callerFormalEndpoint(site, actualPos,
                        callerId);
                if (callerFormal != null) {
                    result.add(new Attributed(callerFormal, false));
                }
            }
            return result;
        }
        if (source.getKind() == EndpointKind.TABLE_COLUMN
                || source.getKind() == EndpointKind.TEMP_COLUMN) {
            result.add(new Attributed(source, false));
        }
        return result;
    }

    /**
     * Identity-backed fallback for a bare actual that is itself one of the
     * caller's formals. Some dlineage models contain two variable nodes for
     * that spelling and the call-site reach collector can select the interior
     * one, leaving its boundary map empty. The declaration identity proves
     * this exact formal endpoint; no heuristic first-variable link is used.
     */
    private Endpoint callerFormalEndpoint(CallSiteRef site, int actualPos,
            RoutineIdentity callerId) {
        if (callerId == null || actualPos < 0
                || actualPos >= site.getActuals().size()) {
            return null;
        }
        CallSiteRef.Actual actual = site.getActuals().get(actualPos);
        if (actual.getBareReference() == null) {
            return null;
        }
        String actualName = actual.getBareReference().toString();
        List<String> segments = gudusoft.gsqlparser.util.SQLUtil.parseNames(actualName);
        // This fallback has no symbol identity, so it is safe only for an
        // unqualified spelling. A record field such as rec.p_in must use the
        // model reach collected for that exact object; suffix-matching it to
        // formal p_in would fabricate a caller-formal source.
        if (segments.size() != 1) {
            return null;
        }
        actualName = segments.get(0);
        for (String declared : callerId.getRawParamNames()) {
            String actualCompare = actualName.startsWith("@")
                    ? actualName.substring(1) : actualName;
            String declaredCompare = declared.startsWith("@")
                    ? declared.substring(1) : declared;
            if (gudusoft.gsqlparser.util.SQLUtil.sameName(vendor,
                    gudusoft.gsqlparser.sqlenv.ESQLDataObjectType.dotColumn,
                    actualCompare, declaredCompare)) {
                return new Endpoint(EndpointKind.FORMAL, declared, declared);
            }
        }
        return null;
    }

    /**
     * Callee edge TARGET in caller space: an OUT formal projects onto the
     * caller boundary reachable from its bound lvalue; a result-set column
     * maps positionally onto INSERT…EXEC targets; global endpoints pass
     * through unchanged.
     */
    private List<Attributed> resolveCalleeTarget(Endpoint target,
            RoutineIdentity calleeId, Map<Integer, Integer> actualByFormal,
            CallSiteRef site, CatalogRoutineCallBinder.BoundCall bound,
            RoutineSummary callee, boolean resultProjectionProven) {
        List<Attributed> result = new ArrayList<Attributed>();
        if (target.getKind() == EndpointKind.FORMAL) {
            int formal = formalPositionOf(target, calleeId);
            if (formal < 0
                    || !bound.getResult().getOutputs().containsKey(formal)) {
                return result; // not a validated OUT projection — nothing composes
            }
            Integer actualPos = actualByFormal.get(formal);
            if (actualPos == null) {
                return result;
            }
            addAll(result, site.getOutTargetsFdd().get(actualPos), false);
            addAll(result, site.getOutTargetsFdr().get(actualPos), true);
            return result;
        }
        if (target.getKind() == EndpointKind.RESULT_SET_COLUMN) {
            if (!resultProjectionProven) {
                return result;
            }
            if (site.getInsertTargets() == null) {
                return result;
            }
            List<String> shape = callee.getResultSetShapes().get(target.getParent());
            if (shape == null) {
                return result;
            }
            // SQL Server rejects INSERT...EXEC when result and target
            // cardinalities differ. Mapping a matching prefix would publish
            // lineage for a statement that cannot produce that write.
            if (shape.size() != site.getInsertTargets().size()) {
                return result;
            }
            int ordinal = uniqueShapeOrdinal(shape, target.getColumn());
            if (ordinal < 0 || ordinal >= site.getInsertTargets().size()) {
                return result;
            }
            result.add(new Attributed(site.getInsertTargets().get(ordinal), false));
            return result;
        }
        if (target.getKind() == EndpointKind.TABLE_COLUMN
                || target.getKind() == EndpointKind.TEMP_COLUMN) {
            result.add(new Attributed(target, false));
        }
        return result;
    }

    /** Exact positional lookup only when the output alias occurs once under
     *  the vendor's identifier equality. Zero or duplicate matches are
     *  deferred; selecting the first duplicate would fabricate an ordinal. */
    private int uniqueShapeOrdinal(List<String> shape, String columnName) {
        if (hasAmbiguousShapeAliases(shape)) {
            return -1;
        }
        int found = -1;
        for (int i = 0; i < shape.size(); i++) {
            if (gudusoft.gsqlparser.util.SQLUtil.sameName(vendor,
                    gudusoft.gsqlparser.sqlenv.ESQLDataObjectType.dotColumn,
                    shape.get(i), columnName)) {
                if (found >= 0) {
                    return -1;
                }
                found = i;
            }
        }
        return found;
    }

    /** dlineage occurrence-disambiguates duplicate result aliases as
     *  {@code name(1)}, {@code name(2)}, ... . Treat both literal duplicates
     *  and that generated suffix form as ambiguous. A conservative false
     *  deferral of a deliberately parenthesized alias is safer than selecting
     *  a fabricated ordinal. */
    private boolean hasAmbiguousShapeAliases(List<String> shape) {
        for (int i = 0; i < shape.size(); i++) {
            for (int j = i + 1; j < shape.size(); j++) {
                if (sameShapeColumn(shape.get(i), shape.get(j))) {
                    return true;
                }
            }
            String base = syntheticDuplicateBase(shape.get(i));
            if (base != null) {
                for (int j = 0; j < shape.size(); j++) {
                    if (j != i && sameShapeColumn(base, shape.get(j))) {
                        return true;
                    }
                }
            }
        }
        return false;
    }

    private boolean sameShapeColumn(String a, String b) {
        return gudusoft.gsqlparser.util.SQLUtil.sameName(vendor,
                gudusoft.gsqlparser.sqlenv.ESQLDataObjectType.dotColumn, a, b);
    }

    private static String syntheticDuplicateBase(String name) {
        if (name == null || !name.endsWith(")")) { // non-identifier-compare: generated display suffix punctuation
            return null;
        }
        int open = name.lastIndexOf('(');
        if (open <= 0 || open == name.length() - 2) {
            return null;
        }
        for (int i = open + 1; i < name.length() - 1; i++) {
            if (!Character.isDigit(name.charAt(i))) {
                return null;
            }
        }
        return name.substring(0, open);
    }

    private static void addAll(List<Attributed> result, Set<Endpoint> endpoints,
            boolean fdr) {
        if (endpoints == null) {
            return;
        }
        for (Endpoint e : endpoints) {
            result.add(new Attributed(e, fdr));
        }
    }

    /** Declaration position of a callee formal endpoint, matched over the
     *  identity's RAW declared spellings via the equality facade —
     *  re-keying stored canonical text double-folds quoted names
     *  (codex-B3-r2 finding 12). */
    private int formalPositionOf(Endpoint formal, RoutineIdentity calleeId) {
        String name = formal.getColumn().length() > 0
                ? formal.getColumn() : formal.getParent();
        // Endpoint parents can carry USE-qualification — match last segment.
        List<String> segments = gudusoft.gsqlparser.util.SQLUtil.parseNames(name);
        if (!segments.isEmpty()) {
            name = segments.get(segments.size() - 1);
        }
        if (name.startsWith("@")) {
            name = name.substring(1);
        }
        List<String> rawNames = calleeId.getRawParamNames();
        for (int i = 0; i < rawNames.size(); i++) {
            String declared = rawNames.get(i);
            if (declared.startsWith("@")) {
                declared = declared.substring(1);
            }
            if (gudusoft.gsqlparser.util.SQLUtil.sameName(vendor,
                    gudusoft.gsqlparser.sqlenv.ESQLDataObjectType.dotColumn,
                    name, declared)) {
                return i;
            }
        }
        return -1;
    }
}