def dcon_edge_comparison(full: Mapping[str, Any], truncated: Mapping[str, Any]) -> dict[str, Any]:
    """Full-edge minus peak-dW-truncated least-stable W_t of one case (#792, #940).

    Parameters
    ----------
    full : mapping
        The full-edge row of
        :func:`vaft.machine_mapping.mhd_linear.extract_dcon_stability` [-].
    truncated : mapping
        The peak-dW-truncated row of the same case and n [-].

    Returns
    -------
    result : dict
        ``n_tor`` [-]; ``W_t_full``, ``W_t_truncated`` and ``delta_W_edge`` =
        ``Re W_t_full - Re W_t_truncated`` [normalized, not Joules];
        ``sign_agreement``: whether both real parts have the same strict sign
        [-]; ``psilim_full``, ``psilim_truncated`` [-].

    Convention
    ----------
    The difference is of two separate solutions, each with its own boundary:
    DCON's full re-run after truncation discards the full-edge eigenvectors, so
    nothing here is a mode-by-mode comparison. Both energies share DCON's
    normalization only because they come from the same equilibrium and n.

    Applicability
    -------------
    Machine-independent.

    Limitations
    -----------
    The rows must be the same case: same ``n_tor`` and treatments
    ``full_edge``/``peak_dw_truncated``; anything else raises. Same equilibrium
    is the caller's to ensure (the payload has no equilibrium hash).

    Provenance
    ----------
    .. [792] Issue #792, the full-edge vs truncated comparison.
    .. [940] Issue #940, ``DconEdgeAnalysis`` follow-up.
    """
    if full.get("edge_treatment") != "full_edge" or truncated.get("edge_treatment") != "peak_dw_truncated":
        raise ValueError("expected one full_edge and one peak_dw_truncated row, got "
                         f"{full.get('edge_treatment')!r} and {truncated.get('edge_treatment')!r}")
    if full.get("n_tor") != truncated.get("n_tor"):
        raise ValueError(f"rows are for different n: {full.get('n_tor')} vs {truncated.get('n_tor')}")
    a, b = full.get("W_t"), truncated.get("W_t")
    delta = None if a is None or b is None else float(np.real(a) - np.real(b))
    agree = None if delta is None else bool(np.real(a) * np.real(b) > 0)
    return {
        "n_tor": full.get("n_tor"),
        "W_t_full": a,
        "W_t_truncated": b,
        "delta_W_edge": delta,
        "sign_agreement": agree,
        "psilim_full": full.get("psilim"),
        "psilim_truncated": truncated.get("psilim"),
    }

def dcon_local_stability(row: Mapping[str, Any]) -> dict[str, Optional[dict[str, Any]]]:
    """DCON's three local criteria, located: Mercier, resistive interchange, ballooning.

    Parameters
    ----------
    row : mapping
        One row of :func:`vaft.machine_mapping.mhd_linear.extract_dcon_stability`
        (``psi_n``, ``D_I``, ``D_R``, ``C_A``, ``mercier_evaluated``,
        ``ballooning_evaluated``) [-].

    Returns
    -------
    result : dict
        One located criterion per DCON local criterion, keyed as below [-].

        ``{"mercier": ..., "resistive_interchange": ..., "ballooning": ...}``, each
        the :func:`criterion_intervals` result for ``D_I`` (unstable > 0),
        ``D_R`` (unstable > 0) and ``C_A`` (unstable < 0) [-], plus
        ``criterion`` and ``unstable_side``. ``None`` for a criterion the run
        did not evaluate or whose profile is absent.

    Convention
    ----------
    DCON's signs (``mercier.f``, ``bal.f``): ``D_I > 0`` Mercier unstable,
    ``D_R > 0`` resistive-interchange criterion unstable, ``C_A < 0`` high-n
    ideal ballooning unstable. ``C_A`` is read only where the payload marks it
    evaluated (``C_A_evaluated``), so an unevaluated surface is skipped, not a
    marginal zero. DCON leaves an unevaluated surface at exactly 0, its marginal
    value, so the mask is required: a ``C_A`` profile without a mask of its
    length is refused (``ValueError``), never read as if every surface were
    evaluated.

    Applicability
    -------------
    Machine-independent.

    Limitations
    -----------
    The payload carries no per-surface mask for ``D_I``/``D_R``; ``mer_flag``
    evaluates all of them, so the flag alone decides. A profile whose length
    differs from ``psi_n`` is ``None``, as the payload's own summaries treat it.
    Every payload :func:`vaft.machine_mapping.mhd_linear.extract_dcon_stability`
    reads carries the mask (``read_dcon_output`` sets it whenever ``C_A`` is
    present); only a hand-built row can lack it.

    Provenance
    ----------
    .. [940] Issue #940, section 8 (local-stability post-processing).
    """
    psi = row.get("psi_n")
    flags = {"D_I": row.get("mercier_evaluated"), "D_R": row.get("mercier_evaluated"),
             "C_A": row.get("ballooning_evaluated")}
    names = {"D_I": "mercier", "D_R": "resistive_interchange", "C_A": "ballooning"}
    masks = {"C_A": row.get("C_A_evaluated")}
    out: dict[str, Optional[dict[str, Any]]] = {}
    for criterion, name in names.items():
        values = row.get(criterion)
        if flags[criterion] is not True or values is None or psi is None or np.size(values) != np.size(psi):
            out[name] = None
            continue
        mask = masks.get(criterion)
        if criterion in masks and (mask is None or np.size(mask) != np.size(values)):
            raise ValueError(f"{criterion} without a {criterion}_evaluated mask of its length: a stored zero "
                             "cannot be told from a marginal surface")
        side = DCON_UNSTABLE_SIDE[criterion]
        out[name] = {"criterion": criterion, "unstable_side": side,
                     **criterion_intervals(psi, values, unstable_side=side, evaluated=mask)}
    return out

def load_stability_atlas(directory) -> tuple[Any, Any]:
    """Read the Tier A stability atlas tables from their directory.

    Parameters
    ----------
    directory : str or Path
        The atlas directory holding ``atlas_n.csv`` and ``atlas_surfaces.csv``
        (on vestserver ``~/runs/campaign/atlas/stability``) [-].

    Returns
    -------
    atlas_n : pandas.DataFrame
        One row per (slice, n) [table].
    atlas_surfaces : pandas.DataFrame
        One row per (slice, n, solver, rational surface) [table].

    Raises
    ------
    FileNotFoundError
        Either table is missing.

    Applicability
    -------------
    VEST-specific. The atlas is the VEST Tier A campaign product of
    ``workflow/stability_atlas/build_atlas.py``.

    Limitations
    -----------
    Reads the CSV form; no schema check beyond the columns
    :func:`stability_atlas_populations` uses.
    """
    import pandas as pd

    root = Path(directory).expanduser()
    tables = []
    for name in ("atlas_n.csv", "atlas_surfaces.csv"):
        path = root / name
        if not path.is_file():
            raise FileNotFoundError(f"stability atlas table {path} not found")
        tables.append(pd.read_csv(path))
    return tables[0], tables[1]