reader-workbench 1.0.0__py3-none-any.whl

reader_workbench/plugins/ingest/synergy_h1.py

@@ -0,0 +1,234 @@
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from pathlib import Path
+from typing import Literal, Self
+
+import pandas as pd
+from pydantic import Field, field_validator, model_validator
+
+from reader_workbench.domains.plate_reader.io.synergy_h1 import (
+    parse_kinetic_only,
+    parse_snapshot_and_timeseries,
+    probe_synergy_workbook,
+)
+from reader_workbench.errors import ParseError
+from reader_workbench.plugins.ingest._discovery import discover_auto_input_files
+from reader_workbench.plugins.ingest.discovery_policy import DEFAULT_EXCLUDE, DEFAULT_INCLUDE
+from reader_workbench.workbench.ports import dataframe_output, file_path_input
+from reader_workbench.workbench.registry import Plugin, PluginConfig, PreflightIssue
+
+
+class SynergyH1UnifiedCfg(PluginConfig):
+    # What kind of ingest are we doing?
+    mode: Literal["snapshot_only", "kinetic_only", "mixed"] = "mixed"
+
+    # parsing knobs
+    channels: list[str] | None = None
+    channel_map: Mapping[str, str] | None = None
+    sheet_names: Sequence[str] | None = None
+
+    # time normalization
+    time_round_decimals: int | None = 12
+    time_step_h: float | None = None
+    time_offset_h: float = Field(
+        default=0.0,
+        ge=0.0,
+        allow_inf_nan=False,
+        description="Hours added to parsed measurement times when assay age is known outside the workbook.",
+    )
+
+    # auto-discovery knobs
+    auto_roots: list[str] | None = None
+    auto_include: list[str] = Field(default_factory=lambda: list(DEFAULT_INCLUDE))
+    auto_exclude: list[str] = Field(default_factory=lambda: list(DEFAULT_EXCLUDE))
+    auto_pick: Literal["single", "latest"] = "single"
+    auto_recursive: bool = False
+
+    # logging
+    print_summary: bool = True
+
+    @field_validator("time_offset_h", mode="before")
+    @classmethod
+    def reject_boolean_time_offset(cls, value: object) -> object:
+        if isinstance(value, bool):
+            raise ValueError("time_offset_h must be a non-negative finite number, not a boolean")
+        return value
+
+    @model_validator(mode="after")
+    def require_channel_contract(self) -> Self:
+        if self.mode in {"snapshot_only", "mixed"} and not self.channel_map:
+            raise ValueError(f"Synergy H1 mode {self.mode!r} requires an explicit channel_map")
+        if not self.channels and not self.channel_map:
+            raise ValueError("Synergy H1 ingest requires channels or channel_map")
+        return self
+
+
+class SynergyH1(Plugin):
+    """Unified Synergy H1 ingest (snapshot-only, kinetic-only, or mixed)."""
+
+    ConfigModel = SynergyH1UnifiedCfg
+
+    @classmethod
+    def input_ports(cls):
+        return {"raw": file_path_input("raw", optional=True)}
+
+    @classmethod
+    def output_ports(cls):
+        return {"df": dataframe_output("df", "tidy.v1")}
+
+    @classmethod
+    def _selected_workbooks(
+        cls,
+        *,
+        exp_dir: Path,
+        cfg: SynergyH1UnifiedCfg,
+        inputs: Mapping[str, object],
+    ) -> list[Path]:
+        if "raw" in inputs:
+            raw_value = inputs["raw"]
+            raw_path = raw_value if isinstance(raw_value, Path) else getattr(raw_value, "path", None)
+            if raw_path is None:
+                raise ParseError("Synergy H1 raw input must select a workbook file")
+            path = Path(raw_path)
+            return [path if path.is_absolute() else exp_dir / path]
+        return discover_auto_input_files(
+            exp_dir=exp_dir,
+            auto_roots=cfg.auto_roots,
+            auto_include=cfg.auto_include,
+            auto_exclude=cfg.auto_exclude,
+            auto_recursive=cfg.auto_recursive,
+            auto_pick=cfg.auto_pick,
+            discovery_label="raw .xlsx files",
+            singular_label="workbook",
+        )
+
+    @classmethod
+    def resolve_missing_file_inputs(cls, *, exp_dir, cfg: SynergyH1UnifiedCfg, inputs):
+        if "raw" in inputs:
+            return {}
+        selected = cls._selected_workbooks(exp_dir=exp_dir, cfg=cfg, inputs=inputs)
+        return {"raw": selected[0]}
+
+    @classmethod
+    def preflight_readiness(cls, *, exp_dir, cfg: SynergyH1UnifiedCfg, reads):
+        try:
+            selected = cls._selected_workbooks(exp_dir=exp_dir, cfg=cfg, inputs=reads)
+        except ParseError as err:
+            return (PreflightIssue(kind="file", message=str(err)),)
+
+        issues: list[PreflightIssue] = []
+        for path in selected:
+            try:
+                probe_synergy_workbook(path)
+            except Exception as err:
+                issues.append(
+                    PreflightIssue(
+                        kind="file",
+                        message=f"Synergy H1 workbook {path} could not be opened: {err}",
+                    )
+                )
+        return tuple(issues)
+
+    def _log_df_summary(self, ctx, df: pd.DataFrame, files_count: int, mode: str):
+        try:
+            n_rows = len(df)
+            n_pos = df["position"].nunique()
+            chans = sorted(df["channel"].astype(str).unique().tolist())
+            tmin = float(pd.to_numeric(df["time"]).min()) if n_rows else 0.0
+            tmax = float(pd.to_numeric(df["time"]).max()) if n_rows else 0.0
+            src_counts = df["source"].value_counts().to_dict() if "source" in df.columns else {}
+            sheets = int(df["sheet_name"].nunique()) if "sheet_name" in df.columns else 0
+            ctx.logger.info(
+                "Synergy H1 ingest • files=%d • mode=[bold]%s[/bold] • rows=%d • positions=%d • channels=%d "
+                "• time=[%.2f, %.2f] h • sheets=%d • parts=%s",
+                files_count,
+                mode,
+                n_rows,
+                n_pos,
+                len(chans),
+                tmin,
+                tmax,
+                sheets,
+                src_counts or "{}",
+            )
+            if chans:
+                preview = ", ".join(chans[:8]) + (" …" if len(chans) > 8 else "")
+                ctx.logger.debug("channels: %s", preview)
+
+            # Block presence line (unambiguous snapshot/kinetic summary)
+            snap_n = int(src_counts.get("snapshot", 0))
+            kin_n = int(src_counts.get("kinetic", 0))
+            snap_flag = "YES" if snap_n > 0 else "NO"
+            kin_flag = "YES" if kin_n > 0 else "NO"
+            ctx.logger.debug(
+                "parsed blocks • snapshot=%s (%d rows) • kinetic=%s (%d rows)", snap_flag, snap_n, kin_flag, kin_n
+            )
+
+        except Exception:
+            # Logging should never break the pipeline
+            pass
+
+    # ---------- run ----------
+
+    def run(self, ctx, inputs, cfg: SynergyH1UnifiedCfg):
+        effective_mode = cfg.mode
+
+        try:
+            raw_path = inputs.get("raw")
+            if not isinstance(raw_path, Path):
+                raise ParseError("Synergy H1 runtime requires one resolved raw workbook path")
+
+            if cfg.print_summary:
+                ctx.logger.info(
+                    "[muted]Synergy H1 ingest • workbook selected[/muted] • %s",
+                    raw_path.name,
+                )
+            if effective_mode == "kinetic_only":
+                out = parse_kinetic_only(
+                    raw_path,
+                    channels=cfg.channels,
+                    channel_map=cfg.channel_map,
+                    sheet_names=cfg.sheet_names,
+                    time_round_decimals=cfg.time_round_decimals,
+                    time_step_h=cfg.time_step_h,
+                    time_offset_h=cfg.time_offset_h,
+                )
+            elif effective_mode == "snapshot_only":
+                out = parse_snapshot_and_timeseries(
+                    raw_path,
+                    channels=cfg.channels,
+                    channel_map=cfg.channel_map,
+                    sheet_names=cfg.sheet_names,
+                    time_round_decimals=cfg.time_round_decimals,
+                    time_step_h=cfg.time_step_h,
+                    time_offset_h=cfg.time_offset_h,
+                    include_snapshot=True,
+                    include_kinetic=False,
+                )
+            elif effective_mode == "mixed":
+                out = parse_snapshot_and_timeseries(
+                    raw_path,
+                    channels=cfg.channels,
+                    channel_map=cfg.channel_map,
+                    sheet_names=cfg.sheet_names,
+                    time_round_decimals=cfg.time_round_decimals,
+                    time_step_h=cfg.time_step_h,
+                    time_offset_h=cfg.time_offset_h,
+                    include_snapshot=True,
+                    include_kinetic=True,
+                )
+            else:
+                raise ParseError(
+                    f"Unsupported Synergy H1 mode {effective_mode!r}; expected snapshot_only, kinetic_only, or mixed"
+                )
+
+            if cfg.print_summary:
+                self._log_df_summary(ctx, out, files_count=1, mode=effective_mode)
+
+        except ParseError:
+            raise
+        except Exception as e:
+            raise ParseError(f"Synergy H1 ingest failed: {e}") from e
+
+        return {"df": out}

reader_workbench/plugins/manifests/__init__.py

@@ -0,0 +1 @@
+"""Category-owned manifests for Reader's built-in plugins."""

reader_workbench/plugins/manifests/export.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from reader_workbench.plugins.export.csv import ExportCsv
+from reader_workbench.plugins.export.xlsx import ExportXlsx
+from reader_workbench.workbench.assets import AssetDescriptor, build_plugin_asset
+from reader_workbench.workbench.ontology import PluginSemantics
+
+BUILTIN_PLUGIN_DESCRIPTORS: tuple[AssetDescriptor, ...] = (
+    build_plugin_asset(
+        plugin_id="export/csv",
+        semantics=PluginSemantics(
+            domain="generic",
+            family="table_export",
+            summary="Write dataframe records to CSV files.",
+            tags=("csv", "files"),
+        ),
+        plugin_cls=ExportCsv,
+    ),
+    build_plugin_asset(
+        plugin_id="export/xlsx",
+        semantics=PluginSemantics(
+            domain="generic",
+            family="table_export",
+            summary="Write dataframe records to XLSX workbooks.",
+            tags=("xlsx", "files"),
+        ),
+        plugin_cls=ExportXlsx,
+    ),
+)

reader_workbench/plugins/manifests/ingest.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from reader_workbench.plugins.ingest.flow_cytometer import FlowCytometerIngest
+from reader_workbench.plugins.ingest.synergy_h1 import SynergyH1
+from reader_workbench.workbench.assets import AssetDescriptor, build_plugin_asset
+from reader_workbench.workbench.ontology import PluginSemantics
+
+BUILTIN_PLUGIN_DESCRIPTORS: tuple[AssetDescriptor, ...] = (
+    build_plugin_asset(
+        plugin_id="ingest/flow_cytometer",
+        semantics=PluginSemantics(
+            domain="cytometry",
+            family="fcs_ingest",
+            summary="Parse FCS cytometry files into tidy event tables and channel metadata.",
+            tags=("fcs", "events", "channels"),
+        ),
+        plugin_cls=FlowCytometerIngest,
+    ),
+    build_plugin_asset(
+        plugin_id="ingest/synergy_h1",
+        semantics=PluginSemantics(
+            domain="plate_reader",
+            family="workbook_ingest",
+            summary="Parse Synergy H1 workbooks into tidy plate-reader traces.",
+            tags=("xlsx", "kinetic", "snapshot"),
+        ),
+        plugin_cls=SynergyH1,
+    ),
+)

reader_workbench/plugins/manifests/plot.py

@@ -0,0 +1,161 @@
+from __future__ import annotations
+
+from reader_workbench.plugins.plot.cytometry_diagnostic import CytometryDiagnosticPlot
+from reader_workbench.plugins.plot.distributions import DistributionsPlot
+from reader_workbench.plugins.plot.dual_reporter_triptych import DualReporterTriptychPlot
+from reader_workbench.plugins.plot.four_state_event_window_diagnostic import FourStateEventWindowDiagnosticPlot
+from reader_workbench.plugins.plot.four_state_event_window_summary import FourStateEventWindowSummaryPlot
+from reader_workbench.plugins.plot.four_state_vector_collection import FourStateVectorCollectionHeatmapPlot
+from reader_workbench.plugins.plot.four_state_vector_diagnostic import FourStateVectorDiagnosticPlot
+from reader_workbench.plugins.plot.four_state_vector_heatmap import FourStateVectorHeatmapPlot
+from reader_workbench.plugins.plot.logic_symmetry import LogicSymmetryPlot
+from reader_workbench.plugins.plot.single_reporter_diagnostic import SingleReporterDiagnosticPlot
+from reader_workbench.plugins.plot.snapshot_barplot import SnapshotBarplot
+from reader_workbench.plugins.plot.snapshot_heatmap import SnapshotHeatmapPlot
+from reader_workbench.plugins.plot.time_series import TimeSeriesPlot
+from reader_workbench.plugins.plot.ts_and_snap import TSAndSnapPlot
+from reader_workbench.workbench.assets import AssetDescriptor, build_plugin_asset
+from reader_workbench.workbench.ontology import PluginSemantics
+
+BUILTIN_PLUGIN_DESCRIPTORS: tuple[AssetDescriptor, ...] = (
+    build_plugin_asset(
+        plugin_id="plot/cytometry_diagnostic",
+        semantics=PluginSemantics(
+            domain="cytometry",
+            family="gating_diagnostic",
+            summary="Render configured cells, singlets, fluorescence, and retention diagnostics.",
+            tags=("gating", "fluorescence", "qc", "records"),
+        ),
+        plugin_cls=CytometryDiagnosticPlot,
+    ),
+    build_plugin_asset(
+        plugin_id="plot/dual_reporter_triptych",
+        semantics=PluginSemantics(
+            domain="plate_reader",
+            family="composite_plot",
+            summary="Render per-design growth, reporter-ratio, and endpoint panels.",
+            tags=("dual_reporter", "kinetics", "snapshot"),
+        ),
+        plugin_cls=DualReporterTriptychPlot,
+    ),
+    build_plugin_asset(
+        plugin_id="plot/single_reporter_diagnostic",
+        semantics=PluginSemantics(
+            domain="plate_reader",
+            family="composite_plot",
+            summary="Render single-reporter kinetics, an explicit reduction, and normalizer QC in one row.",
+            tags=("single_reporter", "kinetics", "reduction", "qc"),
+        ),
+        plugin_cls=SingleReporterDiagnosticPlot,
+    ),
+    build_plugin_asset(
+        plugin_id="plot/four_state_event_window_diagnostic",
+        semantics=PluginSemantics(
+            domain="plate_reader",
+            family="event_relative_diagnostic",
+            summary="Render trajectories and reduced components for one explicitly identified source design.",
+            tags=("event", "window", "diagnostic", "reduction"),
+        ),
+        plugin_cls=FourStateEventWindowDiagnosticPlot,
+    ),
+    build_plugin_asset(
+        plugin_id="plot/four_state_event_window_summary",
+        semantics=PluginSemantics(
+            domain="plate_reader",
+            family="event_relative_summary",
+            summary="Render primary event-relative components across source records.",
+            tags=("event", "window", "aggregate", "summary"),
+        ),
+        plugin_cls=FourStateEventWindowSummaryPlot,
+    ),
+    build_plugin_asset(
+        plugin_id="plot/logic_symmetry",
+        semantics=PluginSemantics(
+            domain="logic",
+            family="geometry_plot",
+            summary="Render logic symmetry geometry from a persisted summary record.",
+            tags=("logic", "geometry"),
+        ),
+        plugin_cls=LogicSymmetryPlot,
+    ),
+    build_plugin_asset(
+        plugin_id="plot/four_state_vector_diagnostic",
+        semantics=PluginSemantics(
+            domain="logic",
+            family="four_state_vector_diagnostic",
+            summary="Render per-design trajectories beside persisted four-state vector components.",
+            tags=("logic", "four_state_vector", "diagnostic", "records"),
+        ),
+        plugin_cls=FourStateVectorDiagnosticPlot,
+    ),
+    build_plugin_asset(
+        plugin_id="plot/four_state_vector_heatmap",
+        semantics=PluginSemantics(
+            domain="logic",
+            family="four_state_vector_heatmap",
+            summary="Render a heatmap over one experiment's four-state vector logic-shape and reference-normalized intensity channels.",
+            tags=("logic", "four_state_vector", "vector", "heatmap"),
+        ),
+        plugin_cls=FourStateVectorHeatmapPlot,
+    ),
+    build_plugin_asset(
+        plugin_id="plot/four_state_vector_collection",
+        semantics=PluginSemantics(
+            domain="logic",
+            family="four_state_vector_heatmap",
+            summary="Render a four-state vector heatmap over a provenance-bound record collection.",
+            tags=("logic", "four_state_vector", "collection", "heatmap"),
+        ),
+        plugin_cls=FourStateVectorCollectionHeatmapPlot,
+    ),
+    build_plugin_asset(
+        plugin_id="plot/ts_and_snap",
+        semantics=PluginSemantics(
+            domain="plate_reader",
+            family="composite_plot",
+            summary="Render paired time-series and snapshot summary panels.",
+            tags=("time_series", "snapshot"),
+        ),
+        plugin_cls=TSAndSnapPlot,
+    ),
+    build_plugin_asset(
+        plugin_id="plot/distributions",
+        semantics=PluginSemantics(
+            domain="plate_reader",
+            family="distribution",
+            summary="Render channel-wise distribution plots from tidy measurements.",
+            tags=("density", "qc"),
+        ),
+        plugin_cls=DistributionsPlot,
+    ),
+    build_plugin_asset(
+        plugin_id="plot/snapshot_barplot",
+        semantics=PluginSemantics(
+            domain="plate_reader",
+            family="snapshot_bar",
+            summary="Render grouped snapshot barplots at a selected timepoint.",
+            tags=("snapshot", "bars"),
+        ),
+        plugin_cls=SnapshotBarplot,
+    ),
+    build_plugin_asset(
+        plugin_id="plot/snapshot_heatmap",
+        semantics=PluginSemantics(
+            domain="plate_reader",
+            family="snapshot_heatmap",
+            summary="Render heatmaps for snapshot or fold-change plate-reader summaries.",
+            tags=("snapshot", "heatmap"),
+        ),
+        plugin_cls=SnapshotHeatmapPlot,
+    ),
+    build_plugin_asset(
+        plugin_id="plot/time_series",
+        semantics=PluginSemantics(
+            domain="plate_reader",
+            family="time_series",
+            summary="Render grouped time-series plots from tidy plate-reader traces.",
+            tags=("kinetics", "channels"),
+        ),
+        plugin_cls=TimeSeriesPlot,
+    ),
+)

reader_workbench/plugins/manifests/transform.py

@@ -0,0 +1,172 @@
+from __future__ import annotations
+
+from reader_workbench.plugins.transform.alias import AliasTransform
+from reader_workbench.plugins.transform.assay_labels import AnnotationLabelsTransform
+from reader_workbench.plugins.transform.blank import BlankCorrection
+from reader_workbench.plugins.transform.crosstalk_pairs import CrosstalkPairs
+from reader_workbench.plugins.transform.cytometry_gating import CytometryGatingTransform
+from reader_workbench.plugins.transform.fold_change import FoldChange
+from reader_workbench.plugins.transform.four_state_event_window import FourStateEventWindowTransform
+from reader_workbench.plugins.transform.four_state_vector import FourStateVectorTransform
+from reader_workbench.plugins.transform.four_state_vector_collection import FourStateVectorCollectionTransform
+from reader_workbench.plugins.transform.logic_symmetry import LogicSymmetryTransform
+from reader_workbench.plugins.transform.outlier_filter import OutlierFilter
+from reader_workbench.plugins.transform.overflow import OverflowHandling
+from reader_workbench.plugins.transform.ratio import RatioTransform
+from reader_workbench.plugins.transform.sample_map import SampleMapMerge
+from reader_workbench.plugins.transform.sample_metadata import SampleMetadataMerge
+from reader_workbench.workbench.assets import AssetDescriptor, build_plugin_asset
+from reader_workbench.workbench.ontology import PluginSemantics
+
+BUILTIN_PLUGIN_DESCRIPTORS: tuple[AssetDescriptor, ...] = (
+    build_plugin_asset(
+        plugin_id="transform/alias",
+        semantics=PluginSemantics(
+            domain="generic",
+            family="label_enrichment",
+            summary="Add alias columns for configured categorical metadata.",
+            tags=("aliases", "annotation"),
+        ),
+        plugin_cls=AliasTransform,
+    ),
+    build_plugin_asset(
+        plugin_id="transform/assay_labels",
+        semantics=PluginSemantics(
+            domain="generic",
+            family="label_enrichment",
+            summary="Materialize configured annotations.labels into dataframe columns.",
+            tags=("annotations", "labels", "annotation"),
+        ),
+        plugin_cls=AnnotationLabelsTransform,
+    ),
+    build_plugin_asset(
+        plugin_id="transform/outlier_filter",
+        semantics=PluginSemantics(
+            domain="generic",
+            family="quality_filter",
+            summary="Drop outlier tidy rows using per-channel and per-time z-scores.",
+            tags=("qc", "filtering"),
+        ),
+        plugin_cls=OutlierFilter,
+    ),
+    build_plugin_asset(
+        plugin_id="transform/crosstalk_pairs",
+        semantics=PluginSemantics(
+            domain="logic",
+            family="summary_transform",
+            summary="Derive pairwise logic crosstalk rankings from fold-change tables.",
+            tags=("logic", "pairs", "summary"),
+        ),
+        plugin_cls=CrosstalkPairs,
+    ),
+    build_plugin_asset(
+        plugin_id="transform/cytometry_gating",
+        semantics=PluginSemantics(
+            domain="cytometry",
+            family="gating",
+            summary="Apply an explicit cytometry gating, threshold, grouping, and QC policy.",
+            tags=("gating", "threshold", "qc"),
+        ),
+        plugin_cls=CytometryGatingTransform,
+    ),
+    build_plugin_asset(
+        plugin_id="transform/logic_symmetry",
+        semantics=PluginSemantics(
+            domain="logic",
+            family="summary_transform",
+            summary="Compute logic-symmetry metrics over an explicit four-state mapping.",
+            tags=("logic", "geometry", "summary"),
+        ),
+        plugin_cls=LogicSymmetryTransform,
+    ),
+    build_plugin_asset(
+        plugin_id="transform/four_state_vector",
+        semantics=PluginSemantics(
+            domain="logic",
+            family="summary_transform",
+            summary="Compute four-state vector logic summaries from annotated plate-reader traces.",
+            tags=("logic", "summary", "four_state_vector"),
+        ),
+        plugin_cls=FourStateVectorTransform,
+    ),
+    build_plugin_asset(
+        plugin_id="transform/four_state_vector_collection",
+        semantics=PluginSemantics(
+            domain="logic",
+            family="record_collection",
+            summary="Collect exact four-state vector record revisions from multiple Reader experiments.",
+            tags=("logic", "collection", "provenance"),
+        ),
+        plugin_cls=FourStateVectorCollectionTransform,
+    ),
+    build_plugin_asset(
+        plugin_id="transform/ratio",
+        semantics=PluginSemantics(
+            domain="plate_reader",
+            family="derived_channel",
+            summary="Create derived ratio channels from aligned tidy measurements.",
+            tags=("ratios", "derived_signal"),
+        ),
+        plugin_cls=RatioTransform,
+    ),
+    build_plugin_asset(
+        plugin_id="transform/four_state_event_window",
+        semantics=PluginSemantics(
+            domain="plate_reader",
+            family="event_relative_summary",
+            summary="Materialize event-relative summaries from provenance-bound source records.",
+            tags=("event", "window", "aggregate", "provenance"),
+        ),
+        plugin_cls=FourStateEventWindowTransform,
+    ),
+    build_plugin_asset(
+        plugin_id="transform/sample_map",
+        semantics=PluginSemantics(
+            domain="plate_reader",
+            family="metadata_merge",
+            summary="Attach well-position sample maps to tidy plate-reader traces.",
+            tags=("well_map", "annotation"),
+        ),
+        plugin_cls=SampleMapMerge,
+    ),
+    build_plugin_asset(
+        plugin_id="transform/sample_metadata",
+        semantics=PluginSemantics(
+            domain="generic",
+            family="metadata_merge",
+            summary="Attach sample-keyed metadata tables to tidy measurement rows.",
+            tags=("annotation", "table_join"),
+        ),
+        plugin_cls=SampleMetadataMerge,
+    ),
+    build_plugin_asset(
+        plugin_id="transform/overflow_handling",
+        semantics=PluginSemantics(
+            domain="plate_reader",
+            family="quality_filter",
+            summary="Mask, drop, or cap overflowed plate-reader measurements.",
+            tags=("overflow", "qc"),
+        ),
+        plugin_cls=OverflowHandling,
+    ),
+    build_plugin_asset(
+        plugin_id="transform/blank_correction",
+        semantics=PluginSemantics(
+            domain="plate_reader",
+            family="signal_correction",
+            summary="Detect and optionally subtract blank control wells.",
+            tags=("blanks", "normalization"),
+        ),
+        plugin_cls=BlankCorrection,
+    ),
+    build_plugin_asset(
+        plugin_id="transform/fold_change",
+        semantics=PluginSemantics(
+            domain="plate_reader",
+            family="summary_transform",
+            summary="Summarize nearest-time fold-change tables from tidy signals.",
+            tags=("fold_change", "snapshot_summary"),
+        ),
+        plugin_cls=FoldChange,
+    ),
+)

reader_workbench/plugins/manifests/validator.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from reader_workbench.plugins.validator.to_tidy_plus_map import PromoteToTidyPlusMap
+from reader_workbench.workbench.assets import AssetDescriptor, build_plugin_asset
+from reader_workbench.workbench.ontology import PluginSemantics
+
+BUILTIN_PLUGIN_DESCRIPTORS: tuple[AssetDescriptor, ...] = (
+    build_plugin_asset(
+        plugin_id="validator/to_tidy_plus_map",
+        semantics=PluginSemantics(
+            domain="plate_reader",
+            family="contract_promotion",
+            summary="Promote tidy tables to annotated plate-reader contracts when metadata is present.",
+            tags=("contract", "annotation"),
+        ),
+        plugin_cls=PromoteToTidyPlusMap,
+    ),
+)