def recent(self, n: int = 10) -> list[RunSummary]:
    """Return the n most recently started runs.

    Parameters
    ----------
    n : int, optional
        Maximum number of runs to return. Defaults to 10.

    Returns
    -------
    list[RunSummary]
        Run summaries ordered newest-first.
    """
    rows = self._conn.execute(_SQL_RECENT, (n,)).fetchall()
    return [_row_to_run_summary(r) for r in rows]

def by_sample(self, name: str) -> list[RunSummary]:
    """Return all runs associated with a sample by name.

    Parameters
    ----------
    name : str
        Exact sample name as stored in the ``samples`` table.

    Returns
    -------
    list[RunSummary]
        Run summaries for the given sample, ordered newest-first.
    """
    rows = self._conn.execute(_SQL_BY_SAMPLE, (name,)).fetchall()
    return [_row_to_run_summary(r) for r in rows]

def __getitem__(self, uid: str) -> Run:
    """Return the full Run object for the given UID.

    Parameters
    ----------
    uid : str
        Hex UUID of the run.

    Returns
    -------
    Run
        Fully-featured run accessor backed by the open connection.

    Raises
    ------
    KeyError
        If no run with the given UID exists in the database.
    """
    row = self._conn.execute(_SQL_RUN_BY_UID, (uid,)).fetchone()
    if row is None:
        raise KeyError(uid)
    return Run(self._conn, dict(row), zarr_path=self._zarr_path)

def close(self) -> None:
    """Close the underlying database connection."""
    self._conn.close()

def table(self, stream: str = "primary") -> pd.DataFrame:
    """Load scalar event data from a named stream as a DataFrame.

    Parameters
    ----------
    stream : str, optional
        Name of the stream to load. Defaults to "primary".

    Returns
    -------
    pd.DataFrame
        Columns are ``seq_num``, ``time``, followed by all scalar fields
        present in the event ``data`` JSON. Returns an empty DataFrame
        with columns ``["seq_num", "time"]`` if the stream has no events.
    """
    rows = self._conn.execute(_SQL_EVENTS, (self._row["uid"], stream)).fetchall()
    if not rows:
        return pd.DataFrame(columns=pd.Index(["seq_num", "time"]))
    records: list[dict[str, Any]] = []
    for row in rows:
        record: dict[str, Any] = {"seq_num": row["seq_num"], "time": row["time"]}
        record.update(json.loads(row["data"]))
        records.append(record)
    df = pd.DataFrame(records)
    leading = ["seq_num", "time"]
    remaining = [c for c in df.columns if c not in leading]
    return pd.DataFrame(df[leading + remaining])

def images(self, field: str = "detector_image") -> LazyImageSequence:
    """Return a lazy accessor for detector images in this run.

    Images are not loaded until explicitly indexed. Each frame is stored
    as a slice of a Zarr array on the filesystem.

    Parameters
    ----------
    field : str, optional
        The image field name to load (default: "detector_image").

    Returns
    -------
    LazyImageSequence
        Lazy accessor with length equal to the number of images in this run.

    Notes
    -----
    Returns an empty LazyImageSequence if no images are stored for the given
    field or if the Zarr store does not exist.
    """
    rows = self._conn.execute(_SQL_IMAGE_REFS, (self._row["uid"], field)).fetchall()
    refs = [dict(r) for r in rows]
    return LazyImageSequence(self._conn, refs, zarr_store_path=self._zarr_path)

def __getitem__(self, idx: int | slice) -> np.ndarray:
    """Load one or more detector images from the Zarr store.

    Parameters
    ----------
    idx : int or slice
        Frame index or slice.

    Returns
    -------
    np.ndarray
        A single (shape_x, shape_y) array for int index, or a stacked
        (n, shape_x, shape_y) array for slice index.

    Raises
    ------
    IndexError
        If idx is out of range.
    TypeError
        If idx is not int or slice.
    """
    if isinstance(idx, int):
        if idx < -len(self._refs) or idx >= len(self._refs):
            raise IndexError(
                f"index {idx} out of range for LazyImageSequence of length {len(self._refs)}"
            )
        ref = self._refs[idx] if idx >= 0 else self._refs[len(self._refs) + idx]
        store = zarr.open_group(str(self._zarr_store_path), mode="r")
        arr = store[ref["zarr_group"]]
        return np.asarray(arr[ref["index_in_stack"]])
    if isinstance(idx, slice):
        indices = range(*idx.indices(len(self._refs)))
        return (
            np.stack([self[i] for i in indices])
            if indices
            else np.empty((0,), dtype=np.int32)
        )
    raise TypeError(f"indices must be int or slice, not {type(idx).__name__}")