LogicComm 0.13.3

LogicComm 0.13.3

Fixes

• permute_celltype_communication(adaptive = TRUE) now runs the adaptive
  refinement batch in parallel across n_cores, like the preliminary batch.
  Previously the adaptive loop was serial and ignored n_cores, so the bulk of
  the work (e.g. 990 of 1000 permutations) crawled on a single core even with
  n_cores > 1, and the run looked stuck. The parallel path also now reports
  incremental progress in chunks (instead of only a start/done line), and the
  L'Ecuyer-CMRG seed is set once so the preliminary and adaptive batches draw
  different -- but reproducible -- permutations.

Documentation

• Clarified permute_celltype_communication(): with adaptive = TRUE the run
  costs roughly adaptive_n_perm permutations regardless of n_perm (so
  n_perm = 10 with the default adaptive_n_perm = 1000 runs ~1000). For a quick
  test, keep adaptive = FALSE or lower adaptive_n_perm. n_cores now
  documents that it speeds up both batches.

LogicComm 0.13.2

LogicComm 0.13.2

Usability

• LogicCommREOResult (the calc_REO_matrix(..., return_rank = TRUE) object) now
  behaves like the underlying genes x cells matrix for inspection and subsetting:
  dim(), nrow(), ncol(), rownames(), colnames(), and x[genes, cells]
  all work, and subsetting returns a LogicCommREOResult with both the logic and
  rank matrices subset consistently. Previously these returned NULL /
  "incorrect number of dimensions" because the object is a list, forcing users to
  reach into x$logic for every matrix-like operation. The internal list
  structure (x$logic, x$rank) is unchanged and every LogicComm function still
  accepts the object directly.

LogicComm 0.13.1

LogicComm 0.13.1

Fixes

• score_lr_activity() no longer fails with Error in rep(FALSE, ncol(logic_mat)) : invalid 'times' argument when given anything other than a
  plain 2D matrix. It was the only scoring entry point that did not unwrap a
  LogicCommREOResult (the output of calc_REO_matrix(..., return_rank = TRUE)),
  so passing that object -- or a single-row/column slice that had dropped to a
  vector (subset without drop = FALSE), or a 1-D array -- reached an empty or
  unmatched gene set and tried rep(FALSE, ncol(x)) on an object with no valid
  column count. score_lr_activity() now unwraps a LogicCommREOResult to its
  $logic matrix (so that common case just works) and otherwise validates that
  reo_mat is a 2D genes x cells matrix with row/column names, raising a clear,
  actionable error instead. Regression test added.

LogicComm 0.13.0

LogicComm 0.13.0

Breaking change: removed the transitional neighborhood / spatial-range output

The inert neighborhood/local/distal/range fields that v0.12 kept as
back-compatible stubs are now removed, so the output schema matches what the
cell-type co-expression method actually computes. This resolves a direct
contradiction in which the method documentation disavowed spatial
juxtacrine/paracrine claims while the output still carried n_juxtacrine,
n_paracrine, n_distal, communication_range, and "local vs global graph
support" labels referencing a per-cell graph that no longer exists.

• summarize_celltype_communication() lr_table no longer contains
  lcs_neighborhood, lcs_primary_mode, communication_range,
  n_active_neighborhood, active_edge_weight_sum, local_active,
  distal_candidate, global_candidate_active, or candidate_active. The
  honest cell-type columns remain (lcs, lcs_global, lcs_unweighted,
  n_edges/edge_weight_sum = the sender x receiver opportunity universe,
  n_active_edges = co-expression support, the per-side active counts/fractions,
  and active).
• pair_summary and pathway_summary drop communication_support_label,
  local_support_fraction_active, n_local_active, n_distal_candidate,
  n_global_candidate_active, n_juxtacrine, n_paracrine, n_distal,
  dominant_communication_range, sum_active_edge_weight, and
  active_edge_weight_sum.
• summarize_spatial_communication() is removed. After the v0.12 neighborhood
  removal it was a placeholder that built coordinates, warned, and returned
  ordinary cell-type co-expression -- it never used a spatial graph and produced
  no spatially resolved result. The spatial utilities build_spatial_graph()
  (kNN/radius graph construction) and plot_spatial_logic() (per-spot REO
  visualization) remain; use summarize_celltype_communication() /
  discover_celltype_communication() for communication scores. A genuine spatial
  edge scorer would require physical-distance edges and a spatial permutation
  null, and is intentionally out of scope rather than faked by a wrapper.
• plot_communication_range_summary() is removed; it visualized a signaling
  "range" the method no longer resolves. plot_celltype_network() drops its
  color_edges_by = "range" mode and distal/global edge styling and now colours
  edges by top pathway. plot_lr_bubble_advanced() and
  plot_lr_activity_balance() colour by LCS instead of range.
• summarize_communication_findings() drops distal_candidate_pairs and the
  graph-support guide rows; write_communication_report() drops the
  distal-candidate section and the KNN/neighborhood cautions.
• logic_grade_evidence() now grades on the evidence the cell-type model
  produces -- an active co-expression call, optionally corroborated by attached
  orthogonal validation -- rather than the removed local/distal/global graph
  distinction (grade A = active + validation, B = active, otherwise
  insufficient).
• diagnose_celltype_communication() no longer reports n_distal_candidates.

Documentation

• Aligned every prose description of the method with the actual cell-type
  co-expression model. The manuscript (inst/manuscript) no longer presents the
  removed per-cell KNN/SNN neighborhood scoring as a current feature (abstract,
  introduction, methods, and figure captions were corrected, the stale test
  count updated, and the PBMC empirical sections flagged for regeneration against
  the v0.13 scorer); the README dropped the "KNN/SNN graph: optional but
  recommended" claim; and the LogicComm-intro overview no longer describes a
  "neighboring receiver cell".
• DESCRIPTION no longer advertises "weighted graph scoring" or spatial
  communication "modules"; it describes cell-type REO co-expression scoring, the
  discovery workflow, and the spatial graph/visualization utilities.

Fixes

• Fixed logic_summarize_celltypes() emitting a spurious "knn_mat, graph_name,
  remove_self_edges are deprecated and ignored" warning on every call. The
  wrapper still declared and unconditionally forwarded those (now removed)
  neighborhood parameters, and the deprecation shim warns on argument
  presence, so even a default call with no neighborhood intent warned. The dead
  parameters (knn_mat, graph_name, mode, remove_self_edges) were dropped
  from the wrapper; scoring options now flow through ..., and an explicitly
  supplied legacy argument still warns (correctly) at
  summarize_celltype_communication().
• Fixed score_receiver_response() (and therefore
  add_receiver_response_score()), which errored with "subscript out of bounds"
  in the standard workflow. It indexed ct_comm$cell_labels by
  colnames(reo_mat), so any reo_mat cell absent from the labels (the normal
  case once summarize_celltype_communication() has filtered cells with
  missing/empty labels and the original reo_mat is passed back) produced NA
  labels and NA cell names that leaked into the receiver-cell selection. Labels
  and reo_mat are now aligned to their shared cells first. Regression test added.
• Fixed calc_rank_shift() to rank each gene within the cell's full
  transcriptome, as its documentation describes (and as calc_REO_matrix()
  anchors), instead of within the small L-R panel. The matrix was being subset to
  the ~120 L-R genes before ranking, so a transcriptome-dominant ligand was
  scored as mid-ranked among the panel and the transcriptome-wide rank shift the
  method is designed to detect was lost (on a 200-gene example the normalized rank
  of a dominant gene differed ~37-fold between the two definitions). The fix ranks
  over all expressed genes per cell while storing only the target genes' ranks, so
  memory stays bounded. Also corrected mean_expr_*/log2fc_expr to average each
  gene over the samples that contain it rather than the full sample count.
  Regression test added.
• Fixed cell-type role assignment so that Mediator and Influencer can actually
  be dominant roles. dominant_role (and secondary_role / role separation)
  are now derived from the four role scores rescaled to a common [0, 1] scale
  across cell types, matching plot_celltype_role_radar(). Previously the raw
  scores were compared directly even though they live on incomparable scales
  (Sender/Receiver are summed LCS, mediator betweenness is normalized to [0, 1],
  and the PageRank influencer score sums to 1 over cell types, ~1/n each), so
  almost every cell type collapsed to Sender or Receiver and a textbook bridge
  cell type was mislabelled. The raw sender_role_score, receiver_role_score,
  mediator_role_score, and influencer_role_score columns are unchanged; only
  the derived role labels improve. Regression test added.
• run_multisample() no longer takes the dead neighborhood parameters
  (knn_list, graph_name, remove_self_edges, graph_symmetrize,
  edge_weight_mode). They had no effect since the v0.12 neighborhood removal --
  IdentifyLogicConsensus() scores from global REO co-expression -- yet were
  silently accepted and match.arg-validated. They are now accepted via ...
  and ignored with a deprecation warning, consistent with
  IdentifyLogicConsensus() and summarize_celltype_communication().
• Removed a duplicate internal .resolve_complex_rank(). Two definitions
  existed; because R sources package files in the C locale, the canonical
  modulators.R version (NA for missing subunits, conservative "min"
  aggregation) always shadowed the celltype_communication.R copy, which was
  therefore dead code whose survival depended on file collation order. Cell-type
  rank weighting only reads ranks where the complex logic is active (all subunits
  present, hence finite), so results are unchanged.
• R CMD check is clean: regenerated stale man/ pages (codoc mismatches for
  summarize_celltype_communication(), permute_celltype_communication(),
  IdentifyLogicConsensus(), and logic_score_lr()), documented
  discover_celltype_communication(), added the missing @param entries on the
  volcano and discovery plots, removed orphan internal Rd files, and registered
  the significance ggplot aesthetic as a global variable.

LogicComm 0.12.3

LogicComm 0.12.3

Major change: cell-type co-expression scoring (neighborhood removal, stage 1)

LogicComm is pivoting to a pure cell-type-level cell-cell communication method,
positioned as an interpretable, sample-comparable alternative to CellChat. The
per-cell KNN/SNN neighborhood scoring is being removed because, for
dissociated scRNA-seq, that graph lives in expression space (transcriptomic
similarity), not physical space, and therefore cannot license spatial
juxtacrine/paracrine distance claims.

• summarize_celltype_communication() now scores communication only at the
  cell-type level: for each sender -> receiver pair, the LCS is the fraction of
  the pair's opportunity universe (sender x receiver cell-count product) in which
  the ligand is active in the sender and the receptor is active in the receiver.
  The KNN/SNN neighborhood branch, edge construction, and graph helpers have been
  removed.
• The legacy neighborhood arguments (knn_mat, graph_name, mode,
  remove_self_edges, graph_symmetrize, edge_weight_mode) are accepted via
  ... for backward compatibility but are deprecated and ignored with a
  warning. They will be removed in a later release.
• The former neighborhood/local/distal/range output fields
  (lcs_neighborhood, local_active, distal_candidate, communication_range,
  ...) are retained as inert transitional stubs and will be removed once readers
  are migrated.

Stage 3: per-cell scoring engines de-neighborhooded

The standalone scoring engines turned out to be dual-mode (neighborhood +
global), and the flagship multi-sample pipeline run_multisample() is built on
IdentifyLogicConsensus(). Rather than hard-deleting and breaking the flagship,
their KNN/neighborhood paths were stripped and their global co-expression
cores retained:

• IdentifyLogicConsensus() is now global co-expression only (LCS = fraction of
  cells co-expressing the complete ligand and receptor logic). KNN graph
  resolution, symmetrization, edge construction, and weighted-edge scoring
  removed.
• logic_score_lr() drops its mode/seurat_obj/knn_mat/graph arguments and
  scores globally (gate-aware path unchanged).
• run_multisample() computes per-sample LCS by global co-expression; it no
  longer passes a per-sample KNN graph.
• Legacy neighborhood arguments remain accepted via ... and ignored with a
  warning.

Stage 5: trustworthy statistics for selecting real communications

• Axis-level permutation null. permute_celltype_communication() now
  defaults to an axis-level null (metric = "lcs"): every sender -> receiver ->
  L-R axis gets its own empirical p-value and BH FDR, instead of one
  cell-type-pair-level p-value being broadcast onto all of its L-R pairs. The
  output gains an lr_pair column; rank_communication_axes() joins the
  permutation evidence per axis and exposes permutation_fdr. Pair-level nulls
  (metric = "sum_lcs") remain available for backward compatibility. The
  cell-type co-expression pivot makes per-axis nulls cheap (no graph to rescan).
• Per-cell bootstrap. bootstrap_celltype_communication() now resamples on
  the independent unit (cells) rather than the sender x receiver cell-count
  product. Co-expression LCS = (ligand-active fraction of sender cells) x
  (receptor-active fraction of receiver cells), so each fraction is bootstrapped
  as a binomial proportion over its own cell count. The previous approach used
  n_edges (the product) as the trial size and produced anticonservative,
  far-too-narrow intervals.

Standard discovery pipeline (footgun-free)

• New discover_celltype_communication() wires the whole workflow in one call
  with the correct defaults: cell-type co-expression scoring, specificity +
  proliferation-confound annotation, an axis-level permutation null
  (metric = "lcs", so it is impossible to accidentally request a pair-level
  null via metric = "sum_lcs"), evidence ranking, a confound-filtered
  discovery view, and an FDR-passing shortlist. Pass expr = the counts matrix
  to enable the proliferation/breadth filter (cycling clusters otherwise dominate
  the ranking). A copy-paste template lives in
  inst/workflows/standard_discovery.R.

Stage 4: REO rank-weighted LCS (opt-in)

• summarize_celltype_communication(lcs_weighting = "rank") scores by REO
  intensity instead of the binary co-expression fraction: the prevalence-weighted
  within-cell rank of the ligand in the sender type (fraction expressing times
  mean rank among expressers) times the same for the receptor. This restores
  dynamic range that binarizing discards (a ligand at the 99th within-cell
  percentile separates from one at the 51st) while keeping the prevalence signal
  that separates specific from ubiquitous axes, addressing the compressed,
  near-floor LCS values seen on real data. On the benchmark it edges out the
  binary score (AUPRC/sens@k); averaging rank among expressers only -- an earlier
  formulation the benchmark flagged -- discards prevalence and hurts precision.
  Requires the rank matrix from calc_REO_matrix(..., return_rank = TRUE). The
  default remains "binary", so existing results are unchanged.
• The active call still uses the binary co-expression fraction, so the active
  axis set is identical under either weighting -- only the reported lcs differs.
• permute_celltype_communication() inherits lcs_weighting from the scored
  object and carries the rank matrix through, so a rank-weighted observed score is
  tested against a rank-weighted null (coherent significance). It also flows
  through discover_celltype_communication(..., lcs_weighting = "rank") when the
  input is built with return_rank = TRUE.

Stage 6 (started): benchmark harness vs. baselines

• inst/benchmark/benchmark_vs_baselines.R: a sandbox-runnable harness that
  simulates data with a known ground truth and the confounds that break naive
  scores -- ubiquitous/housekeeping pairs, a broad moderate-abundance pair, a
  CYCLING / transcriptional-breadth hub cell type that co-expresses many L-R
  genes, uneven cell-type sizes incl. a rare type, and true axes at three signal
  strengths. It scores every sender -> receiver -> L-R axis with LogicComm
  (binary, rank, and +proliferation-filter) and with re-implemented baselines
  (CellPhoneDB/CellChat-style mean-expression product; naive co-detection), and
  reports AUROC / AUPRC / sensitivity-at-k (random tie-breaking, averaged over
  sims). Real, runnable score_cellchat() and score_liana() adapters (and a
  note on CellPhoneDB via LIANA) are included for use where those packages exist.
• Result (mean over sims; 1188 axes, 12 true positives): LogicComm with the
  proliferation filter reaches AUROC 0.995 / AUPRC 0.80, LogicComm (rank) 0.97 /
  0.63 and (binary) 0.99 / 0.58, while the mean-expression-product and naive
  baselines collapse to AUPRC ~0.04 -- ubiquitous, abundance and cycling-breadth
  confounds saturate their scores. The proliferation filter is the single biggest
  contributor to precision.

Still pending (non-blocking; the package is functional and green without them):
removal of the inert transitional stub columns (lcs_neighborhood,
communication_range, local_active, distal_candidate, ...) that the
cell-type path still emits as dead weight -- a cross-cutting refactor of the
downstream readers; and a possible re-architecture of IdentifyRankLogicConsensus()
to cell-type level (its graph-free mode is autocrine-only, so it keeps an optional
neighborhood mode for now). The gate-aware consensus and the spatial module retain
a cell-level graph by design. Also pending: real-package (CellChat/LIANA) and
real-data benchmark runs.

LogicComm 0.12.1

LogicComm 0.12.1

Documentation

• All user-facing docs were rewritten to the v0.12 cell-type co-expression API:
  the README and the LogicComm-intro, Seurat_demo, and
  PBMC_multisample_demo vignettes. The neighborhood/KNN-as-default workflow is
  removed, discover_celltype_communication() is presented as the recommended
  one-call entry point, permutation examples use the axis-level null, and the
  deprecated graph arguments (knn_mat, mode, graph_name,
  graph_symmetrize, edge_weight_mode, remove_self_edges) are dropped from
  all examples.

Fixes

• summarize_spatial_communication() no longer silently ignores its spatial
  graph. The v0.12 rewrite removed the per-cell graph scorer it relied on, so it
  was returning non-spatial cell-type co-expression without notice; it now warns
  that graph-based spatial scoring is pending a dedicated re-implementation and
  returns cell-type co-expression. build_spatial_graph() and
  plot_spatial_logic() are unaffected.

LogicComm 0.12.0

LogicComm 0.12.0

Major change: cell-type co-expression scoring (neighborhood removal, stage 1)

LogicComm is pivoting to a pure cell-type-level cell-cell communication method,
positioned as an interpretable, sample-comparable alternative to CellChat. The
per-cell KNN/SNN neighborhood scoring is being removed because, for
dissociated scRNA-seq, that graph lives in expression space (transcriptomic
similarity), not physical space, and therefore cannot license spatial
juxtacrine/paracrine distance claims.

• summarize_celltype_communication() now scores communication only at the
  cell-type level: for each sender -> receiver pair, the LCS is the fraction of
  the pair's opportunity universe (sender x receiver cell-count product) in which
  the ligand is active in the sender and the receptor is active in the receiver.
  The KNN/SNN neighborhood branch, edge construction, and graph helpers have been
  removed.
• The legacy neighborhood arguments (knn_mat, graph_name, mode,
  remove_self_edges, graph_symmetrize, edge_weight_mode) are accepted via
  ... for backward compatibility but are deprecated and ignored with a
  warning. They will be removed in a later release.
• The former neighborhood/local/distal/range output fields
  (lcs_neighborhood, local_active, distal_candidate, communication_range,
  ...) are retained as inert transitional stubs and will be removed once readers
  are migrated.

Stage 3: per-cell scoring engines de-neighborhooded

The standalone scoring engines turned out to be dual-mode (neighborhood +
global), and the flagship multi-sample pipeline run_multisample() is built on
IdentifyLogicConsensus(). Rather than hard-deleting and breaking the flagship,
their KNN/neighborhood paths were stripped and their global co-expression
cores retained:

• IdentifyLogicConsensus() is now global co-expression only (LCS = fraction of
  cells co-expressing the complete ligand and receptor logic). KNN graph
  resolution, symmetrization, edge construction, and weighted-edge scoring
  removed.
• logic_score_lr() drops its mode/seurat_obj/knn_mat/graph arguments and
  scores globally (gate-aware path unchanged).
• run_multisample() computes per-sample LCS by global co-expression; it no
  longer passes a per-sample KNN graph.
• Legacy neighborhood arguments remain accepted via ... and ignored with a
  warning.

Stage 5: trustworthy statistics for selecting real communications

• Axis-level permutation null. permute_celltype_communication() now
  defaults to an axis-level null (metric = "lcs"): every sender -> receiver ->
  L-R axis gets its own empirical p-value and BH FDR, instead of one
  cell-type-pair-level p-value being broadcast onto all of its L-R pairs. The
  output gains an lr_pair column; rank_communication_axes() joins the
  permutation evidence per axis and exposes permutation_fdr. Pair-level nulls
  (metric = "sum_lcs") remain available for backward compatibility. The
  cell-type co-expression pivot makes per-axis nulls cheap (no graph to rescan).
• Per-cell bootstrap. bootstrap_celltype_communication() now resamples on
  the independent unit (cells) rather than the sender x receiver cell-count
  product. Co-expression LCS = (ligand-active fraction of sender cells) x
  (receptor-active fraction of receiver cells), so each fraction is bootstrapped
  as a binomial proportion over its own cell count. The previous approach used
  n_edges (the product) as the trial size and produced anticonservative,
  far-too-narrow intervals.

Standard discovery pipeline (footgun-free)

• New discover_celltype_communication() wires the whole workflow in one call
  with the correct defaults: cell-type co-expression scoring, specificity +
  proliferation-confound annotation, an axis-level permutation null
  (metric = "lcs", so it is impossible to accidentally request a pair-level
  null via metric = "sum_lcs"), evidence ranking, a confound-filtered
  discovery view, and an FDR-passing shortlist. Pass expr = the counts matrix
  to enable the proliferation/breadth filter (cycling clusters otherwise dominate
  the ranking). A copy-paste template lives in
  inst/workflows/standard_discovery.R.

Stage 4: REO rank-weighted LCS (opt-in)

• summarize_celltype_communication(lcs_weighting = "rank") scores by REO
  intensity instead of the binary co-expression fraction: the prevalence-weighted
  within-cell rank of the ligand in the sender type (fraction expressing times
  mean rank among expressers) times the same for the receptor. This restores
  dynamic range that binarizing discards (a ligand at the 99th within-cell
  percentile separates from one at the 51st) while keeping the prevalence signal
  that separates specific from ubiquitous axes, addressing the compressed,
  near-floor LCS values seen on real data. On the benchmark it edges out the
  binary score (AUPRC/sens@k); averaging rank among expressers only -- an earlier
  formulation the benchmark flagged -- discards prevalence and hurts precision.
  Requires the rank matrix from calc_REO_matrix(..., return_rank = TRUE). The
  default remains "binary", so existing results are unchanged.
• The active call still uses the binary co-expression fraction, so the active
  axis set is identical under either weighting -- only the reported lcs differs.
• permute_celltype_communication() inherits lcs_weighting from the scored
  object and carries the rank matrix through, so a rank-weighted observed score is
  tested against a rank-weighted null (coherent significance). It also flows
  through discover_celltype_communication(..., lcs_weighting = "rank") when the
  input is built with return_rank = TRUE.

Stage 6 (started): benchmark harness vs. baselines

• inst/benchmark/benchmark_vs_baselines.R: a sandbox-runnable harness that
  simulates data with a known ground truth and the confounds that break naive
  scores -- ubiquitous/housekeeping pairs, a broad moderate-abundance pair, a
  CYCLING / transcriptional-breadth hub cell type that co-expresses many L-R
  genes, uneven cell-type sizes incl. a rare type, and true axes at three signal
  strengths. It scores every sender -> receiver -> L-R axis with LogicComm
  (binary, rank, and +proliferation-filter) and with re-implemented baselines
  (CellPhoneDB/CellChat-style mean-expression product; naive co-detection), and
  reports AUROC / AUPRC / sensitivity-at-k (random tie-breaking, averaged over
  sims). Real, runnable score_cellchat() and score_liana() adapters (and a
  note on CellPhoneDB via LIANA) are included for use where those packages exist.
• Result (mean over sims; 1188 axes, 12 true positives): LogicComm with the
  proliferation filter reaches AUROC 0.995 / AUPRC 0.80, LogicComm (rank) 0.97 /
  0.63 and (binary) 0.99 / 0.58, while the mean-expression-product and naive
  baselines collapse to AUPRC ~0.04 -- ubiquitous, abundance and cycling-breadth
  confounds saturate their scores. The proliferation filter is the single biggest
  contributor to precision.

Still pending (non-blocking; the package is functional and green without them):
removal of the inert transitional stub columns (lcs_neighborhood,
communication_range, local_active, distal_candidate, ...) that the
cell-type path still emits as dead weight -- a cross-cutting refactor of the
downstream readers; and a possible re-architecture of IdentifyRankLogicConsensus()
to cell-type level (its graph-free mode is autocrine-only, so it keeps an optional
neighborhood mode for now). The gate-aware consensus and the spatial module retain
a cell-level graph by design. Also pending: real-package (CellChat/LIANA) and
real-data benchmark runs.

LogicComm 0.11.1

LogicComm 0.11.1

Documentation

• Seurat tutorial: the permutation-null step now demonstrates n_cores
  (fork-parallel) and explains the 1 / (n_perm + 1) empirical p-value floor and
  how to pick n_perm; the discovery-view step notes that
  communication_discovery_view() accepts a ct_comm object directly.

LogicComm 0.11.0

LogicComm 0.11.0

Faster permutation null + discovery-view ergonomics

• permute_celltype_communication() gains an n_cores argument: the permutation
  loop now runs on forked workers (Unix/macOS) for a near-linear speedup, so a
  publication-grade n_perm (e.g. 200-1000) is affordable. Results are
  reproducible across core counts when seed is set; the serial path
  (n_cores = 1, default) is unchanged. Note: with too few permutations the
  empirical p-value floor is 1 / (n_perm + 1), which caps null_support and
  prevents any Tier 1 -- use enough permutations to resolve p < 0.05.
• permute_celltype_communication() now fails early with a clear message when
  knn_mat is missing for neighborhood mode (previously a cryptic
  .extract_knn error).
• communication_discovery_view() now accepts a LogicCommCellTypeComm object
  directly (it ranks the axes on the fly), in addition to a ranked data.frame
  from rank_communication_axes().

LogicComm 0.10.4

LogicComm 0.10.4

Documentation

• Expanded the Seurat tutorial's publication-figures section (9.12) with the
  brand scale reference and the per-figure publication controls added across
  0.10.x (volcano fdr_cutoff / lfc_threshold, network layout, bubble
  top_n_pathways, discovery/roles subtitle, heatmap clustering).
• README documents the figure system and save_logiccomm_figure(); refreshed
  stale install-version strings in the README and intro vignette.