def __enter__(self) -> MeasurementSession:  # noqa: D401
    """Synchronous context manager entry."""
    return self

def __exit__(self, exc_type, exc, tb) -> Literal[False]:  # noqa: D401
    """Synchronous context manager exit."""
    # Directly call the synchronous disconnect method
    try:
        self._disconnect_all_instruments()
    except Exception:  # noqa: BLE001
        pass  # Keep original error handling behavior
    return False

def acquire(self, func: T_MeasFunc | None = None, /, *, name: str | None = None):
    if func is None:  # decorator usage
        return lambda f: self.acquire(f, name=name)

    reg_name = name or func.__name__
    if any(n == reg_name for n, _ in self._meas_funcs):
        raise ValueError(f"Measurement '{reg_name}' already registered.")
    self._meas_funcs.append((reg_name, func))
    return func

def instrument(self, alias: str, config_key: str, /, **kw) -> Any:
    if alias in self._instruments:
        record = self._instruments[alias]
        if not record.resource.startswith("bench:"):
            raise ValueError(f"Instrument alias '{alias}' already in use.")
        return record.instance
    if self._bench:
        raise ValueError(
            f"Instrument '{alias}' not found on the bench. "
            "When using a bench, all instruments must be defined in the bench configuration."
        )
    from ..instruments import AutoInstrument as _AutoInstrument

    inst = _AutoInstrument.from_config(config_key, **kw)
    self._instruments[alias] = _InstrumentRecord(alias, config_key, inst)
    return inst

def parameter(
    self, name: str, values: T_ParamIterable, /, *, unit: str | None = None, notes: str = ""
) -> None:
    if name in self._parameters:
        raise ValueError(f"Parameter '{name}' already exists.")
    if isinstance(values, StepSpec):
        resolved = values.values()
    elif callable(values) and not isinstance(values, list | tuple | np.ndarray):
        resolved = list(values())
    else:
        resolved = list(values)
    self._parameters[name] = _Parameter(name, resolved, unit, notes)

def plot(self, spec: PlotSpec | None = None, **kwargs):
    """
    Plot the current session data (if any). Typically called after run().

    Args:
        spec: Optional PlotSpec. If not provided, one is created from kwargs.
        **kwargs: Fields for PlotSpec (kind, x, y, title, xlabel, ylabel, legend, grid).

    Returns:
        A matplotlib Figure object.
    """
    from ..plotting import PlotSpec  # local import to keep plotting optional
    from ..plotting import plot_dataframe  # local import to keep plotting optional

    df = self.data
    if df.is_empty():
        raise ValueError(
            "Session has no data yet. Call run() first or ensure measurements produced rows."
        )

    spec_to_use = spec or (PlotSpec(**kwargs) if kwargs else PlotSpec())
    return plot_dataframe(df, spec_to_use)

def run(
    self,
    duration: float | None = None,
    interval: float = 0.1,
    show_progress: bool = True,
) -> Experiment:
    """Execute the measurement session.

    If background tasks have been registered with @session.task, this will run in
    parallel mode. Otherwise, it will perform a sequential sweep over the defined
    parameters.

    Args:
        duration: Total time in seconds to run (only for parallel mode).
        interval: Time in seconds between acquisitions (only for parallel mode).
        show_progress: Whether to display a progress bar.
    """
    if self._tasks:
        return self._run_parallel(duration, interval, show_progress)
    else:
        return self._run_sweep(show_progress)

def task(self, func: T_TaskFunc | None = None, /, *, name: str | None = None):
    """Decorator to register a function as a background task for parallel execution."""
    if func is None:  # decorator usage
        return lambda f: self.task(f, name=name)

    if not callable(func):
        raise TypeError("Only callable functions can be registered as tasks.")
    reg_name = name or func.__name__
    self._tasks.append((reg_name, func))
    return func