tnfr 6.0.0__py3-none-any.whl → 7.0.0__py3-none-any.whl

tnfr/structural.py

@@ -1,36 +1,72 @@
-"""Structural analysis."""
+"""Maintain TNFR structural coherence for nodes and operator sequences.
+
+This module exposes the canonical entry points used by the engine to
+instantiate coherent TNFR nodes and to orchestrate structural operator
+pipelines while keeping the nodal equation
+``∂EPI/∂t = νf · ΔNFR(t)`` balanced.
+
+Public API
+----------
+create_nfr
+    Initialise a node with canonical EPI, νf and phase attributes plus a
+    ΔNFR hook that propagates reorganisations through the graph.
+run_sequence
+    Validate and execute operator trajectories so that ΔNFR hooks can
+    update EPI, νf and phase coherently after each step.
+OPERATORS
+    Registry of canonical structural operators ready to be composed into
+    validated sequences.
+validate_sequence
+    Grammar guard that ensures operator trajectories stay within TNFR
+    closure rules before execution.
+"""
 
 from __future__ import annotations
 
-from typing import Iterable
+from copy import deepcopy
+from typing import Iterable, Mapping, Sequence
 
 import networkx as nx
 
-from .constants import EPI_PRIMARY, VF_PRIMARY, THETA_PRIMARY
+from .constants import EPI_PRIMARY, THETA_PRIMARY, VF_PRIMARY
 from .dynamics import (
-    set_delta_nfr_hook,
     dnfr_epi_vf_mixed,
+    set_delta_nfr_hook,
 )
-from .types import DeltaNFRHook, NodeId, TNFRGraph
+from .mathematics import (
+    BasicStateProjector,
+    CoherenceOperator,
+    FrequencyOperator,
+    HilbertSpace,
+    MathematicalDynamicsEngine,
+    NFRValidator,
+    make_coherence_operator,
+    make_frequency_operator,
+)
+from .validation import validate_sequence
 from .operators.definitions import (
-    Operator,
-    Emission,
-    Reception,
     Coherence,
-    Dissonance,
+    Contraction,
     Coupling,
-    Resonance,
-    Silence,
+    Dissonance,
+    Emission,
     Expansion,
-    Contraction,
-    SelfOrganization,
     Mutation,
-    Transition,
+    Operator,
+    Reception,
     Recursivity,
+    Resonance,
+    SelfOrganization,
+    Silence,
+    Transition,
 )
 from .operators.registry import OPERATORS
-from .validation import validate_sequence
+from .types import DeltaNFRHook, NodeId, TNFRGraph
 
+try:  # pragma: no cover - optional dependency path exercised in CI extras
+    import numpy as np
+except ImportError:  # pragma: no cover - optional dependency path exercised in CI extras
+    np = None  # type: ignore[assignment]
 
 # ---------------------------------------------------------------------------
 # 1) NFR factory
@@ -46,10 +82,82 @@ def create_nfr(
     graph: TNFRGraph | None = None,
     dnfr_hook: DeltaNFRHook = dnfr_epi_vf_mixed,
 ) -> tuple[TNFRGraph, str]:
-    """Create a graph with an initialised NFR node.
+    """Anchor a TNFR node by seeding EPI, νf, phase and ΔNFR coupling.
+
+    The factory secures the structural state of a node: it stores canonical
+    values for the Primary Information Structure (EPI), structural frequency
+    (νf) and phase, then installs a ΔNFR hook so that later operator
+    sequences can reorganise the node without breaking the nodal equation.
+
+    Parameters
+    ----------
+    name : str
+        Identifier for the new node. The identifier is stored as the node key
+        and must remain hashable by :mod:`networkx`.
+    epi : float, optional
+        Initial Primary Information Structure (EPI) assigned to the node. The
+        value provides the baseline form that subsequent ΔNFR hooks reorganise
+        through the nodal equation.
+    vf : float, optional
+        Structural frequency (νf, expressed in Hz_str) used as the starting
+        reorganisation rate for the node.
+    theta : float, optional
+        Initial phase of the node in radians, used to keep phase alignment with
+        neighbouring coherence structures.
+    graph : TNFRGraph, optional
+        Existing graph where the node will be registered. When omitted a new
+        :class:`networkx.Graph` instance is created.
+    dnfr_hook : DeltaNFRHook, optional
+        Callable responsible for computing ΔNFR and updating EPI/νf after each
+        operator application. By default the canonical ``dnfr_epi_vf_mixed``
+        hook is installed, which keeps the nodal equation coherent with TNFR
+        invariants.
+
+    Returns
+    -------
+    tuple[TNFRGraph, str]
+        The graph that stores the node together with the node identifier. The
+        tuple form allows immediate reuse with :func:`run_sequence`.
 
-    Returns the tuple ``(G, name)`` for convenience.
+    Notes
+    -----
+    The factory does not introduce additional TNFR-specific errors. Any
+    exceptions raised by :mod:`networkx` when adding nodes propagate unchanged.
+
+    Examples
+    --------
+    Create a node, connect a ΔNFR hook and launch a coherent operator
+    trajectory while tracking the evolving metrics.
+
+    >>> from tnfr.constants import DNFR_PRIMARY, EPI_PRIMARY, THETA_PRIMARY, VF_PRIMARY
+    >>> from tnfr.dynamics import set_delta_nfr_hook
+    >>> from tnfr.structural import (
+    ...     Coherence,
+    ...     Emission,
+    ...     Reception,
+    ...     Resonance,
+    ...     Silence,
+    ...     create_nfr,
+    ...     run_sequence,
+    ... )
+    >>> G, node = create_nfr("seed", epi=1.0, vf=2.0, theta=0.1)
+    >>> def synchronise_delta(graph):
+    ...     delta = graph.nodes[node][VF_PRIMARY] * 0.2
+    ...     graph.nodes[node][DNFR_PRIMARY] = delta
+    ...     graph.nodes[node][EPI_PRIMARY] += delta
+    ...     graph.nodes[node][VF_PRIMARY] += delta * 0.05
+    ...     graph.nodes[node][THETA_PRIMARY] += 0.01
+    >>> set_delta_nfr_hook(G, synchronise_delta)
+    >>> run_sequence(G, node, [Emission(), Reception(), Coherence(), Resonance(), Silence()])  # doctest: +SKIP
+    >>> (
+    ...     G.nodes[node][EPI_PRIMARY],
+    ...     G.nodes[node][VF_PRIMARY],
+    ...     G.nodes[node][THETA_PRIMARY],
+    ...     G.nodes[node][DNFR_PRIMARY],
+    ... )  # doctest: +SKIP
+    (..., ..., ..., ...)
     """
+
     G = graph if graph is not None else nx.Graph()
     G.add_node(
         name,
@@ -63,8 +171,318 @@ def create_nfr(
     return G, name
 
 
+def _resolve_dimension(
+    G: TNFRGraph,
+    *,
+    dimension: int | None,
+    hilbert_space: HilbertSpace | None,
+    existing_cfg: Mapping[str, object] | None,
+) -> int:
+    if hilbert_space is not None:
+        resolved = int(getattr(hilbert_space, "dimension", 0) or 0)
+        if resolved <= 0:
+            raise ValueError("Hilbert space dimension must be positive.")
+        return resolved
+
+    if dimension is None and existing_cfg:
+        candidate = existing_cfg.get("dimension")
+        if isinstance(candidate, int) and candidate > 0:
+            dimension = candidate
+
+    if dimension is None:
+        if hasattr(G, "number_of_nodes"):
+            count = int(G.number_of_nodes())
+        else:
+            count = len(tuple(G.nodes))
+        dimension = max(1, count)
+
+    resolved = int(dimension)
+    if resolved <= 0:
+        raise ValueError("Hilbert space dimension must be positive.")
+    return resolved
+
+
+def _ensure_coherence_operator(
+    *,
+    operator: CoherenceOperator | None,
+    dimension: int,
+    spectrum: Sequence[float] | None,
+    c_min: float | None,
+) -> CoherenceOperator:
+    if operator is not None:
+        return operator
+
+    kwargs: dict[str, object] = {}
+    if spectrum is not None:
+        spectrum_array = np.asarray(spectrum, dtype=np.complex128)
+        if spectrum_array.ndim != 1:
+            raise ValueError("Coherence spectrum must be one-dimensional.")
+        kwargs["spectrum"] = spectrum_array
+    if c_min is not None:
+        kwargs["c_min"] = float(c_min)
+    return make_coherence_operator(dimension, **kwargs)
+
+
+def _ensure_frequency_operator(
+    *,
+    operator: FrequencyOperator | None,
+    dimension: int,
+    diagonal: Sequence[float] | None,
+) -> FrequencyOperator:
+    if operator is not None:
+        return operator
+
+    if diagonal is None:
+        matrix = np.eye(dimension, dtype=float)
+    else:
+        diag_array = np.asarray(diagonal, dtype=float)
+        if diag_array.ndim != 1:
+            raise ValueError("Frequency diagonal must be one-dimensional.")
+        if diag_array.shape[0] != int(dimension):
+            raise ValueError("Frequency diagonal size must match Hilbert dimension.")
+        matrix = np.diag(diag_array)
+    return make_frequency_operator(np.asarray(matrix, dtype=np.complex128))
+
+
+def _ensure_generator_matrix(
+    *,
+    dimension: int,
+    diagonal: Sequence[float] | None,
+) -> "np.ndarray":
+    if diagonal is None:
+        return np.zeros((dimension, dimension), dtype=np.complex128)
+    diag_array = np.asarray(diagonal, dtype=np.complex128)
+    if diag_array.ndim != 1:
+        raise ValueError("Generator diagonal must be one-dimensional.")
+    if diag_array.shape[0] != int(dimension):
+        raise ValueError("Generator diagonal size must match Hilbert dimension.")
+    return np.diag(diag_array)
+
+
+def create_math_nfr(
+    name: str,
+    *,
+    epi: float = 0.0,
+    vf: float = 1.0,
+    theta: float = 0.0,
+    graph: TNFRGraph | None = None,
+    dnfr_hook: DeltaNFRHook = dnfr_epi_vf_mixed,
+    dimension: int | None = None,
+    hilbert_space: HilbertSpace | None = None,
+    coherence_operator: CoherenceOperator | None = None,
+    coherence_spectrum: Sequence[float] | None = None,
+    coherence_c_min: float | None = None,
+    coherence_threshold: float | None = None,
+    frequency_operator: FrequencyOperator | None = None,
+    frequency_diagonal: Sequence[float] | None = None,
+    generator_diagonal: Sequence[float] | None = None,
+    state_projector: BasicStateProjector | None = None,
+    dynamics_engine: MathematicalDynamicsEngine | None = None,
+    validator: NFRValidator | None = None,
+) -> tuple[TNFRGraph, str]:
+    """Create a TNFR node with canonical mathematical validation attached.
+
+    The helper wraps :func:`create_nfr` while projecting the structural state
+    into a Hilbert space so coherence, νf and norm invariants can be tracked via
+    the mathematical runtime.  It installs operators and validation metadata on
+    both the node and the hosting graph so that the
+    :class:`~tnfr.mathematics.MathematicalDynamicsEngine` can consume them
+    directly.
+
+    Parameters
+    ----------
+    name : str
+        Identifier for the new node.
+    epi, vf, theta : float, optional
+        Canonical TNFR scalars forwarded to :func:`create_nfr`.
+    dimension : int, optional
+        Hilbert space dimension. When omitted it is inferred from the graph size
+        (at least one).
+    hilbert_space : HilbertSpace, optional
+        Pre-built Hilbert space to reuse. Its dimension supersedes ``dimension``.
+    coherence_operator, frequency_operator : optional
+        Custom operators to install. When omitted they are derived from
+        ``coherence_spectrum``/``coherence_c_min`` and
+        ``frequency_diagonal`` respectively.
+    coherence_threshold : float, optional
+        Validation floor. Defaults to ``coherence_operator.c_min``.
+    generator_diagonal : sequence of float, optional
+        Diagonal entries for the unitary generator used by the mathematical
+        dynamics engine. Defaults to a null generator.
+    state_projector : BasicStateProjector, optional
+        Projector used to build the canonical spectral state for validation.
+
+    Returns
+    -------
+    tuple[TNFRGraph, str]
+        The graph and node identifier, mirroring :func:`create_nfr`.
+
+    Examples
+    --------
+    >>> G, node = create_math_nfr("math-seed", epi=0.4, vf=1.2, theta=0.05, dimension=3)
+    >>> metrics = G.nodes[node]["math_metrics"]
+    >>> round(metrics["norm"], 6)
+    1.0
+    >>> metrics["coherence_passed"], metrics["frequency_passed"]
+    (True, True)
+    >>> metrics["coherence_value"] >= metrics["coherence_threshold"]
+    True
+
+    Notes
+    -----
+    The helper mutates/extends ``G.graph['MATH_ENGINE']`` so subsequent calls to
+    :mod:`tnfr.dynamics.runtime` can advance the mathematical engine without
+    further configuration.
+    """
+
+    if np is None:
+        raise ImportError("create_math_nfr requires NumPy; install the 'tnfr[math]' extras.")
+
+    G, node = create_nfr(
+        name,
+        epi=epi,
+        vf=vf,
+        theta=theta,
+        graph=graph,
+        dnfr_hook=dnfr_hook,
+    )
+
+    existing_cfg = G.graph.get("MATH_ENGINE")
+    mapping_cfg: Mapping[str, object] | None
+    if isinstance(existing_cfg, Mapping):
+        mapping_cfg = existing_cfg
+    else:
+        mapping_cfg = None
+
+    resolved_dimension = _resolve_dimension(
+        G,
+        dimension=dimension,
+        hilbert_space=hilbert_space,
+        existing_cfg=mapping_cfg,
+    )
+
+    hilbert = hilbert_space or HilbertSpace(resolved_dimension)
+    resolved_dimension = int(getattr(hilbert, "dimension", resolved_dimension))
+
+    coherence = _ensure_coherence_operator(
+        operator=coherence_operator,
+        dimension=resolved_dimension,
+        spectrum=coherence_spectrum,
+        c_min=coherence_c_min,
+    )
+    threshold = float(
+        coherence_threshold if coherence_threshold is not None else coherence.c_min
+    )
+
+    frequency = _ensure_frequency_operator(
+        operator=frequency_operator,
+        dimension=resolved_dimension,
+        diagonal=frequency_diagonal,
+    )
+
+    projector = state_projector or BasicStateProjector()
+
+    generator_matrix = _ensure_generator_matrix(
+        dimension=resolved_dimension,
+        diagonal=generator_diagonal,
+    )
+    engine = dynamics_engine or MathematicalDynamicsEngine(
+        generator_matrix,
+        hilbert_space=hilbert,
+    )
+
+    enforce_frequency = frequency is not None
+    spectral_validator = validator or NFRValidator(
+        hilbert,
+        coherence,
+        threshold,
+        frequency_operator=frequency if enforce_frequency else None,
+    )
+
+    state = projector(
+        epi=float(epi),
+        nu_f=float(vf),
+        theta=float(theta),
+        dim=resolved_dimension,
+    )
+    norm_value = float(hilbert.norm(state))
+    outcome = spectral_validator.validate(
+        state,
+        enforce_frequency_positivity=enforce_frequency,
+    )
+    summary_raw = outcome.summary
+    summary = {key: deepcopy(value) for key, value in summary_raw.items()}
+
+    coherence_summary = summary.get("coherence")
+    frequency_summary = summary.get("frequency")
+
+    math_metrics = {
+        "norm": norm_value,
+        "normalized": bool(summary.get("normalized", False)),
+        "coherence_value": float(coherence_summary.get("value", 0.0))
+        if isinstance(coherence_summary, Mapping)
+        else 0.0,
+        "coherence_threshold": float(
+            coherence_summary.get("threshold", threshold)
+        )
+        if isinstance(coherence_summary, Mapping)
+        else threshold,
+        "coherence_passed": bool(coherence_summary.get("passed", False))
+        if isinstance(coherence_summary, Mapping)
+        else False,
+        "frequency_value": float(frequency_summary.get("value", 0.0))
+        if isinstance(frequency_summary, Mapping)
+        else 0.0,
+        "frequency_passed": bool(frequency_summary.get("passed", False))
+        if isinstance(frequency_summary, Mapping)
+        else True,
+        "frequency_spectrum_min": float(
+            frequency_summary.get("spectrum_min", 0.0)
+        )
+        if isinstance(frequency_summary, Mapping)
+        and "spectrum_min" in frequency_summary
+        else None,
+        "unitary_passed": bool(
+            summary.get("unitary_stability", {}).get("passed", False)
+        ),
+    }
+
+    node_context = {
+        "hilbert_space": hilbert,
+        "coherence_operator": coherence,
+        "frequency_operator": frequency,
+        "coherence_threshold": threshold,
+        "dimension": resolved_dimension,
+    }
+
+    node_data = G.nodes[node]
+    node_data["math_metrics"] = math_metrics
+    node_data["math_summary"] = summary
+    node_data["math_context"] = node_context
+
+    cfg = dict(mapping_cfg) if mapping_cfg is not None else {}
+    cfg.update(
+        {
+            "enabled": True,
+            "dimension": resolved_dimension,
+            "hilbert_space": hilbert,
+            "coherence_operator": coherence,
+            "coherence_threshold": threshold,
+            "frequency_operator": frequency,
+            "state_projector": projector,
+            "validator": spectral_validator,
+            "generator_matrix": generator_matrix,
+            "dynamics_engine": engine,
+        }
+    )
+    G.graph["MATH_ENGINE"] = cfg
+
+    return G, node
+
+
 __all__ = (
     "create_nfr",
+    "create_math_nfr",
     "Operator",
     "Emission",
     "Reception",
@@ -86,15 +504,80 @@ __all__ = (
 
 
 def run_sequence(G: TNFRGraph, node: NodeId, ops: Iterable[Operator]) -> None:
-    """Execute a sequence of operators on ``node`` after validation."""
+    """Drive structural sequences that rebalance EPI, νf, phase and ΔNFR.
+
+    The function enforces the canonical operator grammar, then executes each
+    operator so that the configured ΔNFR hook can update the nodal equation in
+    place. Each step is expected to express the structural effect of the
+    operator, while the hook keeps EPI, νf and phase consistent with the
+    resulting ΔNFR variations.
+
+    Parameters
+    ----------
+    G : TNFRGraph
+        Graph that stores the node and its ΔNFR orchestration hook. The hook is
+        read from ``G.graph['compute_delta_nfr']`` and is responsible for
+        keeping the nodal equation up to date after each operator.
+    node : NodeId
+        Identifier of the node that will receive the operators. The node must
+        already contain the canonical attributes ``EPI``, ``νf`` and ``θ``.
+    ops : Iterable[Operator]
+        Iterable of canonical structural operators to apply. Their
+        concatenation must respect the validated TNFR grammar.
+
+    Returns
+    -------
+    None
+        The function mutates ``G`` in-place by updating the node attributes.
+
+    Raises
+    ------
+    ValueError
+        Raised when the provided operator names do not satisfy the canonical
+        sequence validation rules.
+
+    Examples
+    --------
+    Run a validated trajectory that highlights the ΔNFR-driven evolution of the
+    node metrics.
+
+    >>> from tnfr.constants import DNFR_PRIMARY, EPI_PRIMARY, THETA_PRIMARY, VF_PRIMARY
+    >>> from tnfr.dynamics import set_delta_nfr_hook
+    >>> from tnfr.structural import (
+    ...     Coherence,
+    ...     Emission,
+    ...     Reception,
+    ...     Resonance,
+    ...     Silence,
+    ...     create_nfr,
+    ...     run_sequence,
+    ... )
+    >>> G, node = create_nfr("seed", epi=0.8, vf=1.5, theta=0.0)
+    >>> def amplify_delta(graph):
+    ...     delta = graph.nodes[node][VF_PRIMARY] * 0.15
+    ...     graph.nodes[node][DNFR_PRIMARY] = delta
+    ...     graph.nodes[node][EPI_PRIMARY] += delta * 0.8
+    ...     graph.nodes[node][VF_PRIMARY] += delta * 0.1
+    ...     graph.nodes[node][THETA_PRIMARY] += 0.02
+    >>> set_delta_nfr_hook(G, amplify_delta)
+    >>> run_sequence(G, node, [Emission(), Reception(), Coherence(), Resonance(), Silence()])  # doctest: +SKIP
+    >>> (
+    ...     G.nodes[node][EPI_PRIMARY],
+    ...     G.nodes[node][VF_PRIMARY],
+    ...     G.nodes[node][THETA_PRIMARY],
+    ...     G.nodes[node][DNFR_PRIMARY],
+    ... )  # doctest: +SKIP
+    (..., ..., ..., ...)
+    """
 
     compute = G.graph.get("compute_delta_nfr")
     ops_list = list(ops)
     names = [op.name for op in ops_list]
 
-    ok, msg = validate_sequence(names)
-    if not ok:
-        raise ValueError(f"Invalid sequence: {msg}")
+    outcome = validate_sequence(names)
+    if not outcome.passed:
+        summary_message = outcome.summary.get("message", "validation failed")
+        raise ValueError(f"Invalid sequence: {summary_message}")
 
     for op in ops_list:
         op(G, node)

tnfr/structural.pyi

@@ -1,31 +1,37 @@
-from typing import TYPE_CHECKING, Any, Callable, Hashable, Iterable
+from typing import TYPE_CHECKING, Any, Callable, Hashable, Iterable, Sequence
 
+from .validation import SequenceValidationResult
 from .operators.definitions import (
-    Operator,
-    Emission,
-    Reception,
     Coherence,
-    Dissonance,
+    Contraction,
     Coupling,
-    Resonance,
-    Silence,
+    Dissonance,
+    Emission,
     Expansion,
-    Contraction,
-    SelfOrganization,
     Mutation,
-    Transition,
+    Operator,
+    Reception,
     Recursivity,
+    Resonance,
+    SelfOrganization,
+    Silence,
+    Transition,
 )
 
 if TYPE_CHECKING:
     import networkx as nx
+    from .mathematics import (
+        BasicStateProjector,
+        CoherenceOperator,
+        FrequencyOperator,
+        HilbertSpace,
+        MathematicalDynamicsEngine,
+        NFRValidator,
+    )
 
 __all__: tuple[str, ...]
 
-
 def __getattr__(name: str) -> Any: ...
-
-
 def create_nfr(
     name: str,
     *,
@@ -35,12 +41,29 @@ def create_nfr(
     graph: "nx.Graph" | None = ...,
     dnfr_hook: Callable[..., None] = ...,
 ) -> tuple["nx.Graph", str]: ...
-
+def create_math_nfr(
+    name: str,
+    *,
+    epi: float = ...,
+    vf: float = ...,
+    theta: float = ...,
+    graph: "nx.Graph" | None = ...,
+    dnfr_hook: Callable[..., None] = ...,
+    dimension: int | None = ...,
+    hilbert_space: "HilbertSpace" | None = ...,
+    coherence_operator: "CoherenceOperator" | None = ...,
+    coherence_spectrum: Sequence[float] | None = ...,
+    coherence_c_min: float | None = ...,
+    coherence_threshold: float | None = ...,
+    frequency_operator: "FrequencyOperator" | None = ...,
+    frequency_diagonal: Sequence[float] | None = ...,
+    generator_diagonal: Sequence[float] | None = ...,
+    state_projector: "BasicStateProjector" | None = ...,
+    dynamics_engine: "MathematicalDynamicsEngine" | None = ...,
+    validator: "NFRValidator" | None = ...,
+) -> tuple["nx.Graph", str]: ...
 
 OPERATORS: dict[str, Operator]
 
-
-def validate_sequence(names: Iterable[str]) -> tuple[bool, str]: ...
-
-
+def validate_sequence(names: Iterable[str]) -> SequenceValidationResult: ...
 def run_sequence(G: "nx.Graph", node: Hashable, ops: Iterable[Operator]) -> None: ...

tnfr/telemetry/__init__.py

@@ -1,12 +1,34 @@
 """Telemetry helpers for shared observability settings."""
 
+from .cache_metrics import (
+    CacheMetricsSnapshot,
+    CacheTelemetryPublisher,
+    ensure_cache_metrics_publisher,
+    publish_graph_cache_metrics,
+)
+from .nu_f import (
+    NuFSnapshot,
+    NuFTelemetryAccumulator,
+    NuFWindow,
+    ensure_nu_f_telemetry,
+    record_nu_f_window,
+)
 from .verbosity import (
-    TelemetryVerbosity,
     TELEMETRY_VERBOSITY_DEFAULT,
     TELEMETRY_VERBOSITY_LEVELS,
+    TelemetryVerbosity,
 )
 
 __all__ = [
+    "CacheMetricsSnapshot",
+    "CacheTelemetryPublisher",
+    "ensure_cache_metrics_publisher",
+    "publish_graph_cache_metrics",
+    "NuFWindow",
+    "NuFSnapshot",
+    "NuFTelemetryAccumulator",
+    "ensure_nu_f_telemetry",
+    "record_nu_f_window",
     "TelemetryVerbosity",
     "TELEMETRY_VERBOSITY_DEFAULT",
     "TELEMETRY_VERBOSITY_LEVELS",