Getting started with spiDE

spiDE

spiDE finds neighbourhood-dependent differential expression in spatial transcriptomics. Cells of one type do not behave the same everywhere in a tissue. A tumour cell sitting among fibroblasts may express a different set of genes from a tumour cell surrounded by other tumour cells, and the way it responds may differ between patients who respond to a treatment and patients who do not. spiDE asks, for a chosen index cell type, whether the expression of a gene changes with the local density of another cell type, which we call the niche, and whether that change differs between two conditions.

Doing this well is harder than it sounds. The cells of one patient share their genetics, their treatment and the way their sample was handled, and neighbouring cells share their local tissue environment. If every cell is treated as an independent observation, the more cells are measured the more certain a result looks, even when the patients disagree with each other. A condition such as response to treatment is a property of a patient, not of a cell, so the patient is the right unit of replication. spiDE builds this into every test: the evidence for a result is how consistently the niche slope behaves between patients, never how many cells were measured.

One hypothesis in spiDE is one (gene, index type, niche type) combination, which we call a triplet. Each triplet gets up to two tests:

  1. The pooled test asks whether, within patients, the gene’s expression in the index type changes with the density of the niche type, consistently across patients.
  2. The condition-specific test asks whether that dependence differs between two conditions, such as responders and non-responders.

The analysis runs in three steps, and each has its own function:

  1. buildNiches() measures the density of every cell type around every cell.
  2. fitSpiDE() fits a negative binomial regression for every gene in every index type, with a separate baseline for every patient, so that the niche coefficients are slopes within patients.
  3. testSpiDE() tests those slopes across patients.

spiDE() runs all three in one call. This article walks through the whole pipeline on a small example, and then through the gene-set test, the between-patient test of niche abundance, the plots and a few practical points. The statistics are explained in vignette("spiDE-model"), how well the tests hold up in vignette("spiDE-calibration"), and how many patients and cells a study needs in vignette("spiDE-design").

The package can be installed as follows:

if (!requireNamespace("BiocManager", quietly = TRUE))
    install.packages("BiocManager")

BiocManager::install("BhuvaLab/spiDE")

Load the data

We begin by loading a small simulated data set that ships with the package. It holds 16 patients, eight responders and eight non-responders, with 150 cells each, three cell types (A, B and C) and 20 genes. We planted exactly one effect in it: gene G1 is up-regulated in index type A, in responders only, in proportion to the local density of niche type B. Because we know the answer, we can check that spiDE finds it.

library(spiDE)
library(SpatialExperiment)
data(toySpiDE)
toySpiDE
#> class: SpatialExperiment 
#> dim: 20 2400 
#> metadata(0):
#> assays(1): counts
#> rownames(20): G1 G2 ... G19 G20
#> rowData names(0):
#> colnames(2400): cell1 cell2 ... cell2399 cell2400
#> colData names(9): sample_id condition ... Area nCount
#> reducedDimNames(0):
#> mainExpName: NULL
#> altExpNames(0):
#> spatialCoords names(2) : x y
#> imgData names(0):
patients <- unique(as.data.frame(colData(toySpiDE))[, c("sample_id", "condition")])
table(patients$condition)
#> 
#> Non-responder     Responder 
#>             8             8
table(toySpiDE$cell_type)
#> 
#>   A   B   C 
#> 813 726 861

spiDE needs a SpatialExperiment with the following:

  • Raw integer counts in the counts assay. Normalised or back-transformed values are refused, because the model needs the counting noise of real counts.
  • A cell type for every cell, in cell_type.
  • A patient for every cell, in sample_id. There should be one sample per patient. If a patient has several sections, put the patient in sample_id and the section in section, so that spatial variation is estimated for each section separately.
  • For the condition-specific test, a two-level condition that is constant within each patient, here the condition column. If the condition is partly confounded with slide or batch, a patient-level column of slides can be given as strata.

Build the niches

For each cell, buildNiches() places a smooth bump, a Gaussian kernel, on every cell of a given type and adds the bumps up. The result is a density of each cell type at every cell, which says how much of that type there is nearby. The width of the bump, sigma, is the bandwidth and is in the units of the spatial coordinates. Each density is stored as a column of a reducedDim named after the bandwidth.

spe <- buildNiches(toySpiDE, sigma = 30, verbose = FALSE)
head(reducedDim(spe, "Niche30"), 3)
#>               A            B         C
#> cell1 0.6569450 1.4712172285 0.2947218
#> cell2 1.4124748 0.0003534644 1.2449427
#> cell3 0.7352794 0.0000000000 1.4184528

Choose a bandwidth

The bandwidth sets what we mean by a neighbourhood. A small bandwidth looks at the immediate neighbours of a cell, and a large one at the tissue around it. A good bandwidth gives a niche map that is neither speckled nor flat. We can look at the density of niche type B in one sample at two bandwidths and judge by eye:

spe2 <- buildNiches(spe, sigma = 10, verbose = FALSE)
plotNicheMap(spe2, niche = "B", sample = "S1", index = "A", sigma = 10)

plotNicheMap(spe2, niche = "B", sample = "S1", index = "A", sigma = 30)

At the smaller bandwidth most cells have no niche cell of type B within reach and the density is zero, so the map is speckled by the position of single cells. At the larger one the density varies smoothly across the section, and we can see where B cells are concentrated. We use 30 for the rest of this article. For real data, choose the bandwidth from what you know about the biology, such as the distance over which cells signal to one another, and from maps like these. mergeNiches() can pool several cell types into one niche group (all lymphocytes, say) before fitting. spiDE never tests an index type against its own niche, merged or not.

Fit the model

fitSpiDE() takes the object with its niches, the bandwidth to use and, if we want to test a condition, the name of the condition column.

fit <- fitSpiDE(spe, condition = "condition", sigma = 30, verbose = FALSE)
fit
#> SpiDEFit (slopes engine), bandwidth 30
#>   16 patients; condition: condition
#>   index A: 20 genes x 2 niches (B, C)
#>   index B: 20 genes x 2 niches (A, C)
#>   index C: 20 genes x 2 niches (A, B)

By default every cell type with at least min.cells cells in at least min.patients patients is an index type, and every other cell type is tested as its niche. The index and niche arguments restrict this; niche types that are not tested stay in the model as adjustments. Genes detected in fewer than min.detect of an index type’s cells are not tested in it. The model adjusts for sequencing depth with the centred log library size of each cell, and further cell-level measurements such as cell area can be added with covariates.

The engine argument chooses how the error between patients is estimated. The default, "slopes", fits the model once without the condition and then estimates every patient’s own slope for every niche. Because the fit never sees the condition, any patient-level condition can be tested afterwards, and permuting the condition reruns only the test. The alternative, "sandwich", fits the condition-specific model directly and needs the condition at fit time. The slopes engine is the more powerful of the two when effects vary between patients, and it is needed for spiGSEA(). vignette("spiDE-model") explains both engines.

Test the slopes

testSpiDE() combines the patients’ slopes. It always runs the pooled test, and it runs the condition-specific test when a condition is available, here the one recorded by fitSpiDE(). A condition can also be given to testSpiDE() directly.

res <- testSpiDE(fit)
res
#> SpiDEResults (slopes engine)
#>   pooled across patients: 120 tests, 2 at FDR 0.05
#>   condition-specific (Responder - Non-responder; pooled_or_heterogeneity family): 2 tests, 1 at FDR 0.05

The pooled test

The pooled results are a table with one row per triplet. estimate is the average within-patient slope on the natural-log scale per unit of the log1p niche density, t and p are the test statistic and its p-value, and q is the q-value after a Benjamini-Hochberg correction over every triplet.

head(results(res, test = "pooled"))
#>   gene index niche   test   estimate         se         t        df
#> 1   G1     A     B pooled  0.3881372 0.05679598  6.833884 238.20066
#> 2   G9     A     B pooled -0.4108065 0.09640727 -4.261157 275.75177
#> 3   G8     B     C pooled -1.0110568 0.31374706 -3.222522 278.86095
#> 4  G18     A     B pooled -0.4598285 0.17245172 -2.666419 260.58333
#> 5   G2     A     B pooled -0.3746952 0.15673331 -2.390654 273.31470
#> 6   G4     C     A pooled -0.2958241 0.13034836 -2.269488  26.38717
#>              p n_patients p.heterogeneity            q in_family
#> 1 6.861903e-11         16       0.5545574 8.234284e-09      TRUE
#> 2 2.794132e-05         16       0.2540271 1.676479e-03      TRUE
#> 3 1.421456e-03         16       0.1036774 5.685822e-02      TRUE
#> 4 8.145921e-03         16       0.8849338 2.443776e-01      TRUE
#> 5 1.749550e-02         16       0.2596331 4.198921e-01      TRUE
#> 6 3.163711e-02         16       0.5791366 6.071471e-01      TRUE

The planted triplet, G1 in A against B, comes out as the strongest pooled association, with a t of 6.83. Remember that a pooled call says that, within a patient, index cells with more of the niche type around them express more (or less) of the gene, consistently across patients.

The condition-specific test

The condition-specific table has the same layout. Its estimate is the difference between the conditions in the average slope, the second level minus the first, and res$contrast says which two levels were compared.

res$contrast
#> [1] "Responder - Non-responder"
cond <- results(res, test = "condition")
cond[cond$in_family, ]
#>    gene index niche      test   estimate         se         t       df
#> 2    G1     A     B condition  0.2731141 0.08851382  3.085553 11.31285
#> 34   G9     A     B condition -0.2408824 0.21006634 -1.146697 12.84478
#>             p n_patients p.heterogeneity          q in_family
#> 2  0.01005585         16       0.5545574 0.02011171      TRUE
#> 34 0.27241928         16       0.2540271 0.27241928      TRUE

By default the condition-specific test is carried out only among the triplets that pass the pooled test, or whose slopes vary between patients more than their sampling noise allows (p.heterogeneity, corrected at the same fdr). Neither filter looks at the condition, so the correction for multiple testing is spent on triplets that have something for the condition to explain, and the result is valid under any relabelling of the patients. Rows outside this family have q = NA. Other families are available through the procedure argument: "heterogeneity" and "filtered" use one filter each, and "all" tests every triplet.

In the table, the planted slope is larger in responders than in non-responders by 0.27 log units per unit of log1p density (q = 0.02), which is the effect we planted. The whole pipeline can also be run in one call:

res <- spiDE(toySpiDE, condition = "condition", sigma = 30)

Look at the patients behind a result

A call is only as good as the patients behind it. With the slopes engine, every patient has its own slope for every triplet, and these slopes are the evidence that the tests weigh. patientSlopes() returns them as a table, with the slope’s variance and the number of cells that went into it.

ps <- patientSlopes(fit, gene = "G1", index = "A", niche = "B")
head(ps[, c("patient", "condition", "slope", "var_spatial", "ncells")])
#>   patient     condition      slope var_spatial ncells
#> 1      S1     Responder 0.46507215 0.008293659     49
#> 2     S10 Non-responder 0.17666906 0.059603450     61
#> 3     S11     Responder 0.40042779 0.010850030     60
#> 4     S12 Non-responder 0.20442830 0.084545395     41
#> 5     S13     Responder 0.40137955 0.021370670     54
#> 6     S14 Non-responder 0.09021844 0.095534715     45

plotPatientSlopes() draws them. Each point is a patient’s slope with its interval, sized by the weight the patient carries in the tests. The weighted average of each condition is marked, and the pooled estimate is shown as a band.

plotPatientSlopes(res, gene = c("G1", "G2"), index = "A", niche = "B")

For G1, the slopes of the patients lie mostly above zero in both conditions, which gives the pooled call, and the slopes of the responders sit further to the right than those of the non-responders, which is what the condition-specific test picks up. The panel title reports its difference and q-value. For G2, which has no planted effect, the slopes are spread widely on both sides of zero, their intervals are wide, and the two conditions overlap.

The model also gives each patient a baseline level of every gene, its intercept. These baselines absorb everything that differs between patients as a whole, so they are not tested, but they are worth a look. patientIntercepts() returns them with the patient-level covariates, and plotPatientEffects() summarises them by principal components of the intercepts, showing how much of each component each covariate explains.

intercepts <- patientIntercepts(fit, gene = "G1", index = "A")
head(intercepts)
#>   gene index patient intercept ncells sample_id     condition        Age
#> 1   G1     A      S1  2.185319     49        S1     Responder  0.5252615
#> 2   G1     A     S10  1.782854     61       S10 Non-responder -2.5667462
#> 3   G1     A     S11  2.157735     60       S11     Responder  1.2134123
#> 4   G1     A     S12  1.627117     41       S12 Non-responder  0.3624176
#> 5   G1     A     S13  2.223423     54       S13     Responder -1.8538037
#> 6   G1     A     S14  1.707590     45       S14 Non-responder  0.8369687
plotPatientEffects(res, index = "A")

In this example the first component of the intercepts lines up almost entirely with the condition, which is what we expect: the baselines absorb the difference in level between responders and non-responders, so that this difference cannot be mistaken for a difference in slope. Other covariates, such as the number of cells and the depth of a patient, explain smaller parts of the other components. If a slide or batch column lined up with a component of the slopes instead, the condition would be partly confounded with it, and that column should go into strata. Setting niche in plotPatientEffects() draws the same plot for the slopes, which is the check to make before trusting a condition-specific call.

Test gene sets

Genes do not act alone, and a set of genes with a shared function often shows an effect that no single gene shows clearly. spiGSEA() tests gene sets in the way testSpiDE() tests genes. It takes the results and any named list of gene symbols, such as the collections of the msigdb package. Each patient gets a slope for the set, which averages its genes’ slopes after putting them on a common scale, and these set slopes go through the same pooled and condition-specific tests. By default (type = "competitive") the average over the other tested genes is subtracted, so a set is called when it moves more than the typical gene. spiGSEA() needs the slopes engine.

sets <- list(planted = c("G1", "G2", "G3"), other = paste0("G", 4:8),
             rest = paste0("G", 9:20))
gs <- spiGSEA(res, sets, min.size = 3)
head(gs[, c("set", "index", "niche", "test", "size", "estimate", "p", "q", "q.global")])
#>       set index niche   test size   estimate            p            q
#> 1 planted     A     B pooled    3  0.5786725 1.062184e-05 3.186553e-05
#> 2 planted     C     A pooled    3  0.2375498 4.530821e-02 1.359246e-01
#> 3   other     B     C pooled    5 -0.2151709 4.837164e-02 1.451149e-01
#> 4 planted     B     A pooled    3  0.2700726 5.189186e-02 1.556756e-01
#> 5    rest     A     B pooled   12 -0.1955425 9.496954e-02 1.424543e-01
#> 6    rest     C     A pooled   12 -0.1856722 1.141085e-01 1.711627e-01
#>       q.global
#> 1 0.0001911932
#> 2 0.2335133889
#> 3 0.2335133889
#> 4 0.2335133889
#> 5 0.3418903349
#> 6 0.3423253865

There are two q-values. q adjusts within each (index, niche, test) column, and q.global over every set, index and niche of a test. When there are many sets and many columns, q.global is the one to read. plotTripletHeatmap() shows the t statistic of every set in every (index, niche) column, with a dot where q.global passes.

plotTripletHeatmap(gs, test = "pooled")

The set holding the planted gene stands out in the column of A against B, where it is called, and no other set is called.

A different question: niche abundance

The tests above use only the slopes within patients. A patient whose index cells sit among many niche cells may also express a gene differently as a whole from a patient whose index cells do not. This is a real association, but it is a different claim. It says that patients with more of a niche type differ, not that a cell responds to its neighbours, and the patient intercepts absorb it so that testSpiDE() never sees it. testNicheAbundance() asks it directly. For each patient and index type it forms a pseudobulk profile and compares it with the patient’s average niche density, across patients.

ab <- testNicheAbundance(spe, condition = "condition", sigma = 30, verbose = FALSE)
head(ab)
#>   gene index niche  term   estimate          t          p n_patients leverage
#> 1   G1     A     B niche -0.7027035 -0.7670751 0.45395614         16 3.140745
#> 2   G2     A     B niche  1.6965338  0.9949125 0.33458847         16 3.140745
#> 3   G3     A     B niche -4.4677351 -2.2039072 0.04252324         16 3.140745
#> 4   G4     A     B niche  1.6759925  1.0894772 0.29208148         16 3.140745
#> 5   G5     A     B niche -2.3093092 -1.5048814 0.15183925         16 3.140745
#> 6   G6     A     B niche -1.6818163 -1.0171063 0.32423758         16 3.140745
#>   downweighted         q  q.global
#> 1            1 0.7704611 0.9454957
#> 2            1 0.7704611 0.9075984
#> 3            1 0.7704611 0.6623751
#> 4            1 0.7704611 0.9075984
#> 5            1 0.7704611 0.7377807
#> 6            1 0.7704611 0.9075984

With a condition, the rows with term "niche" give the association averaged over the two conditions, and the rows with "condition:niche" test whether it differs between them, again the second level minus the first. Each term is its own family for multiple testing, with its own q.global. A patient who alone carries most of a niche type’s spread is down-weighted (max.leverage), so that one patient cannot make a call on its own. Gene sets go through the same test with testNicheAbundance(genesets = ).

The two kinds of result must not be mixed up. A result of testSpiDE() says that, within a patient, cells with more of this niche differ, and a result of testNicheAbundance() says that patients with more of this niche differ. plotNicheResponse() shows both on one gene. With adjust = FALSE it draws the raw data: each segment is one patient’s slope, the quantity spiDE tests, and the dashed line through the patients’ means is the between-patient association that testNicheAbundance() tests.

plotNicheResponse(spe, res, gene = "G1", index = "A", niche = "B", adjust = FALSE)

Plots

All the plots are ggplot2 objects in one house style (theme_spiDE()), with one colour-blind-safe palette (spiDEColours()) that uses one pair of colours for slopes that rise or fall with the niche and another pair for the two levels of the condition. Each plot returns its data in p$data, so a plot is changed by adding layers or a theme, and any two plots can be combined with patchwork.

Where the calls are

plotCallMap() counts, for each (index, niche) column, how many triplets pass, separately for slopes that rise and slopes that fall with the niche’s density, and plotTopTriplets() shows the strongest ones. When we give it the SpatialExperiment, a triangle marks a gene that is several-fold higher in the niche type than in the index type, which we come back to below.

plotCallMap(res, test = "pooled")

plotTopTriplets(res, test = "pooled", n = 12, spe = spe)

The cells behind a slope

plotNicheResponse() shows the cells themselves. By default, each patient’s fitted intercept is divided out, so the patients share one level and the slopes that the tests compare are easy to see.

plotNicheResponse(spe, res, gene = c("G1", "G2"), index = "A", niche = "B")

For G1, the expression of the responders’ cells rises with the density of B while that of the non-responders is nearly flat. For G2, there is no clear trend in either group.

Check for spillover

Cell segmentation is never perfect, and transcripts of a neighbouring niche cell can be assigned to an index cell. These transcripts rise with the niche’s density and look like a response of the index cell. plotSpillover() plots every triplet by its signed z statistic against how much higher the gene is in the niche type than in the index type, and marks the region of genes that are several-fold higher in the niche type. If the calls fell mostly in that region, they would be the niche type’s own markers and spillover the likely explanation.

plotSpillover(res, spe)

In this example the plot reports that none of the two calls lies in that region, so spillover does not explain them. In real data, report the niche type’s fold change together with every call.

Diagnostics

plotPValues() shows the distribution of the p-values by expression band. It is a sanity check on the data at hand and is not a replacement for the calibration checks of vignette("spiDE-calibration").

plotPValues(res)

Figures combine with patchwork, for example to put a patient-level and a cell-level view of the same triplet side by side:

library(patchwork)
plotPatientSlopes(res, gene = "G1", index = "A", niche = "B") +
  plotNicheResponse(spe, res, gene = "G1", index = "A", niche = "B") +
  plot_annotation(tag_levels = "A")

Practicalities

Runtime. The fit is the expensive step. Every gene is fitted separately in every index type, so the time grows with the number of index types, the number of genes and the number of cells, but it hardly depends on the number of patients, because the patient baselines are handled algebraically. The example above takes a few seconds. Testing is fast, and a permutation of the condition under the slopes engine reruns only the test.

Parallelism. Genes are fitted independently within an index type, so the BPPARAM argument spreads the genes over workers:

library(BiocParallel)
fit <- fitSpiDE(spe, condition = "condition", sigma = 30,
                BPPARAM = MulticoreParam(4))

Forked workers run one BLAS thread each when the RhpcBLASctl package is installed. Otherwise, set OMP_NUM_THREADS=1 in the job, because workers that each use many threads compete with one another and run much slower.

Several bandwidths. One fit uses one bandwidth. We can build the niches at several bandwidths and fit each one, but the results are a sensitivity analysis and not a search: each bandwidth is its own set of tests, and picking the best of them after looking would not be valid. Calls that hold at both bandwidths are the more convincing.

Below we refit index type A at the smaller bandwidth and count the pooled calls at each bandwidth.

fit10 <- fitSpiDE(spe2, condition = "condition", sigma = 10, index = "A",
                  verbose = FALSE)
res10 <- testSpiDE(fit10)
r10 <- results(res10, test = "pooled")
r30 <- results(res, test = "pooled")
r30 <- r30[r30$index == "A", ]
c(sigma10 = sum(r10$q < 0.05, na.rm = TRUE), sigma30 = sum(r30$q < 0.05, na.rm = TRUE))
#> sigma10 sigma30 
#>       3       2

Both bandwidths call a handful of triplets in A, including the planted one, so the conclusion does not hinge on the choice here.

Objects from older versions. Objects saved by spiDE 0.99.22 and earlier came from a different model and are refused by this version, with a message that names the archive that reads them.

Session information

sessionInfo()
#> R version 4.6.2 (2026-10-29)
#> Platform: x86_64-pc-linux-gnu
#> Running under: Ubuntu 26.04.1 LTS
#> 
#> Matrix products: default
#> BLAS:   /usr/lib/x86_64-linux-gnu/openblas-pthread/libblas.so.3 
#> LAPACK: /usr/lib/x86_64-linux-gnu/openblas-pthread/libopenblasp-r0.3.32.so;  LAPACK version 3.12.0
#> 
#> locale:
#>  [1] LC_CTYPE=en_US.UTF-8       LC_NUMERIC=C              
#>  [3] LC_TIME=en_US.UTF-8        LC_COLLATE=en_US.UTF-8    
#>  [5] LC_MONETARY=en_US.UTF-8    LC_MESSAGES=en_US.UTF-8   
#>  [7] LC_PAPER=en_US.UTF-8       LC_NAME=C                 
#>  [9] LC_ADDRESS=C               LC_TELEPHONE=C            
#> [11] LC_MEASUREMENT=en_US.UTF-8 LC_IDENTIFICATION=C       
#> 
#> time zone: Etc/UTC
#> tzcode source: system (glibc)
#> 
#> attached base packages:
#> [1] stats4    stats     graphics  grDevices utils     datasets  methods  
#> [8] base     
#> 
#> other attached packages:
#>  [1] patchwork_1.3.2             SpatialExperiment_1.23.0   
#>  [3] SingleCellExperiment_1.35.2 SummarizedExperiment_1.43.0
#>  [5] Biobase_2.73.2              GenomicRanges_1.65.4       
#>  [7] Seqinfo_1.3.2               IRanges_2.47.5             
#>  [9] S4Vectors_0.51.10           BiocGenerics_0.59.12       
#> [11] generics_0.1.4              MatrixGenerics_1.25.0      
#> [13] matrixStats_1.5.0           ggplot2_4.0.3              
#> [15] spiDE_0.99.38               BiocStyle_2.41.0           
#> 
#> loaded via a namespace (and not attached):
#>  [1] tidyselect_1.2.1       dplyr_1.2.1            farver_2.1.2          
#>  [4] S7_0.2.2               fastmap_1.2.0          spatstat.geom_3.8-3   
#>  [7] spatstat.explore_3.8-3 digest_0.6.39          rsvd_2.0.0            
#> [10] lifecycle_1.0.5        statmod_1.5.2          spatstat.data_3.1-9   
#> [13] magrittr_2.0.5         compiler_4.6.2         rlang_1.3.0           
#> [16] sass_0.4.10            tools_4.6.2            yaml_2.3.12           
#> [19] knitr_1.52             S4Arrays_1.13.2        labeling_0.4.3        
#> [22] DelayedArray_0.39.8    RColorBrewer_1.1-3     abind_1.4-8           
#> [25] BiocParallel_1.47.0    withr_3.0.3            sys_3.4.3             
#> [28] grid_4.6.2             polyclip_1.10-7        beachmat_2.29.3       
#> [31] scales_1.4.0           spatstat.utils_3.2-6   cli_3.6.6             
#> [34] rmarkdown_2.32         otel_0.3.0             rjson_0.2.23          
#> [37] cachem_1.1.0           splines_4.6.2          parallel_4.6.2        
#> [40] BiocManager_1.30.27    XVector_0.53.0         vctrs_0.7.3           
#> [43] Matrix_1.7-6           jsonlite_2.0.0         BiocSingular_1.29.2   
#> [46] ggrepel_0.9.8          irlba_2.4.1            SpaNorm_1.7.17        
#> [49] tensor_1.5.1           maketools_1.3.2        magick_2.9.1          
#> [52] limma_3.99.4           spatstat.univar_3.2-0  jquerylib_0.1.4       
#> [55] goftest_1.2-3          glue_1.8.1             spatstat.random_3.5-2 
#> [58] codetools_0.2-20       gtable_0.3.6           deldir_2.0-4          
#> [61] ScaledMatrix_1.21.0    tibble_3.3.1           pillar_1.11.1         
#> [64] htmltools_0.5.9        R6_2.6.1               evaluate_1.0.5        
#> [67] lattice_0.23-1         RhpcBLASctl_0.23-42    bslib_0.12.0          
#> [70] Rcpp_1.1.2             SparseArray_1.13.4     nlme_3.1-172          
#> [73] spatstat.sparse_3.2-0  mgcv_1.9-5             xfun_0.62             
#> [76] buildtools_1.0.0       pkgconfig_2.0.3