diff --git a/.agents/GUIDELINES.md b/.agents/GUIDELINES.md
new file mode 100644
index 0000000..efd3b51
--- /dev/null
+++ b/.agents/GUIDELINES.md
@@ -0,0 +1,10 @@
+# Agent Notes
+
+- Prefer explanatory comments in numerical kernels, coordinate math, and callback boundaries.
+- Target roughly one meaningful comment for every 5-10 lines in dense array code.
+- Comment the reason for a layout transform, cached constant, broadcast shape, or numerical safeguard.
+- Do not add filler comments that simply restate the next line.
+- Write tests, follow red green TDD.
+- Ensure all methods, functions, modules, and classes have a docstring. Private objects can have a single line, public objects should have a full numpy docstring with examples (following doctest).
+- All lines must be covered by tests; delete unreachable edge case code or test it using public API and minimal monkey patching.
+- Keep Markdown prose unwrapped. Do not hard-wrap paragraphs or list items in `.md` files; let editors soft-wrap them. Code blocks and formats that require line breaks are exceptions.
diff --git a/.agents/README.md b/.agents/README.md
deleted file mode 100644
index 958e217..0000000
--- a/.agents/README.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# Agent Notes
-
-- Prefer explanatory comments in numerical kernels, coordinate math, and callback boundaries.
-- Target roughly one meaningful comment for every 5-10 lines in dense array code.
-- Comment the reason for a layout transform, cached constant, broadcast shape, or numerical safeguard.
-- Do not add filler comments that simply restate the next line.
-- When splitting modules, keep package-level re-exports stable unless the task explicitly narrows the public API.
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
new file mode 100644
index 0000000..4d10d65
--- /dev/null
+++ b/.github/workflows/docs.yml
@@ -0,0 +1,67 @@
+name: Documentation
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: pages-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pages: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-tags: "true"
+          fetch-depth: "0"
+
+      - if: github.event_name != 'pull_request'
+        uses: actions/configure-pages@v5
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install documentation dependencies
+        run: python -m pip install -e ".[docs]"
+
+      - name: Generate API reference
+        run: python scripts/build_api_docs.py
+
+      - name: Generate benchmark reference
+        run: python scripts/build_benchmark_docs.py
+
+      - name: Build documentation
+        run: zensical build --clean
+
+      - name: Upload Pages artifact
+        if: github.event_name != 'pull_request'
+        uses: actions/upload-pages-artifact@v4
+        with:
+          path: site
+
+  deploy:
+    if: github.event_name != 'pull_request'
+    needs: build
+    runs-on: ubuntu-latest
+    permissions:
+      pages: write
+      id-token: write
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4
diff --git a/.gitignore b/.gitignore
index 697dbf2..9428243 100644
--- a/.gitignore
+++ b/.gitignore
@@ -74,6 +74,9 @@ target/
 
 # docs
 docs/api/*
+docs/benchmarks/*
+site/
+.benchmarks/
 _autosummary
 .quarto/
 docs/site_libs
diff --git a/README.md b/README.md
index 987e175..8f76153 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,8 @@
 # dasjax
 
-An experimental package for accelerating [DASCore](dascore.org) with [JAX](https://github.com/jax-ml/jax).
+![dasjax logo](https://raw.githubusercontent.com/dasdae/dasjax/main/docs/static/dasjax_logo.png)
+
+An experimental package for accelerating [DASCore](https://dascore.org) with [JAX](https://github.com/jax-ml/jax).
 
 ## Installation
 
@@ -10,11 +12,11 @@ python -m pip install -e ".[dev]"
 
 ## Usage
 
-`dasjax`'s main feature is the ability to create compiled DAS pipelines that can run on CPU, GPU, or TPU. These also perform kernel fusions for increased efficiency.
+`dasjax`'s main feature is the ability to create compiled DAS pipelines that can run on CPU, GPU, or TPU. These pipelines fuse adjacent JAX-backed operations where possible and cache metadata planning for repeated calls with the same static patch boundary.
 
 ### Compiled pipeline
 
-Use `JaxPatchPipeline` when you want to compile a reusable sequence once and run it across many compatible patches.
+Use `JaxPatchPipeline` when you want to build a reusable callable once and run it across many compatible patches.
 
 ```python
 import dascore as dc
@@ -38,62 +40,60 @@ print(out.shape)
 
 ## Development
 
-### Three-Tier Architecture
+### Architecture
 
-`dasjax` is organized as a small three-tier stack:
+`dasjax` is organized around one core operation model:
 
-1. Pipeline layer:
-   `src/dasjax/pipeline.py` records operation chains and compiles reusable patch transforms. This is the main user-facing API.
-2. Operation layer:
-   `src/dasjax/operations/` defines the operation registry, execution policies, validation rules, eager patch implementations, and compiled leaf transforms.
-3. Kernel layer:
-   `src/dasjax/kernels/` contains the array-level JAX and callback-backed kernels that actually do the numerical work, grouped by domain (`basic`, `signal`, `filters`, `spectral`).
+1. Pipeline layer: `src/dasjax/pipeline.py` records operation chains, plans metadata boundaries, and compiles reusable patch transforms. This is the main user-facing API.
+2. Operation layer: `src/dasjax/core.py` defines `PatchOperation`, `PatchBoundary`, `PatchPyTree`, and registry helpers. Registered operation classes live under `src/dasjax/operations/`, grouped by DASCore-style domains.
+3. Kernel layer: `src/dasjax/kernels/` contains the array-level JAX kernels that actually do the numerical work, grouped by domain (`basic`, `signal`, `filters`, `spectral`).
 
-This split keeps the package easier to extend: add or update numerical behavior in the kernel layer, describe how it plugs into compiled execution in the operation layer, and expose it through the pipeline layer.
+Operation authors use `bind(boundary)` for Python-side metadata planning, `kernel(patch_tree)` for JAX-side data transforms, and `update_boundary(boundary)` for static metadata changes.
 
 
-### Roadmap
+### Operation Coverage
 
-The table below tracks what is missing and roughly how much effort each addition requires.
+`dasjax` currently registers 72 pipeline operations. Most operations use native JAX kernels; a smaller set of DASCore-compatible numeric transforms still use host callbacks where a fully static JAX kernel is not practical yet. The current operation set includes:
 
-#### Near-term — straightforward pure-JAX array ops
+- Elementwise math and masks: `abs`, `clip`, `real`, `imag`, `angle`, `conj`, `exp`, `log`, `log10`, `log2`, `is_finite`, `isinf`, `isnan`, `fillna`, `where`, and scalar arithmetic operations.
+- Reductions and aggregation: `aggregate`, `all`, `any`, `max`, `mean`, `median`, `min`, `std`, and `sum`.
+- Coordinate-aware array transforms: `flip`, `roll`, `pad`, `taper`, `taper_range`, `detrend`, `standardize`, `differentiate`, and `integrate`.
+- Spectral and signal operations: `dft`, `idft`, `stft`, `istft`, `hilbert`, `envelope`, `phase_weighted_stack`, `whiten`, `fbe`, and `correlate_shift`.
+- Filters, mutes, and DAS-domain operations: `pass_filter`, `gaussian_filter`, `hampel_filter`, `median_filter`, `notch_filter`, `savgol_filter`, `sobel_filter`, `slope_filter`, `wiener_filter`, `line_mute`, `slope_mute`, `correlate`, `decimate`, `interpolate`, `resample`, `dispersion_phase_shift`, `tau_p`, `velocity_to_strain_rate`, `velocity_to_strain_rate_edgeless`, and `radians_to_strain`.
 
-Implemented in the current package:
+Remaining DASCore patch methods are mostly metadata, selection, convenience, or data-dependent shape operations. `rolling` returns a roller object rather than a patch, and `dropna` has data-dependent output shape, so neither fits the current static compiled-pipeline model directly.
 
-- `real`, `imag`, `angle`, `conj`
-- `flip`, `roll`, `pad`
-- `standardize`, `differentiate`, `integrate`
-- `dft`, `idft`
-- `hilbert`, `envelope`
-- `taper`, `taper_range`
-- `whiten`
+## Performance Notes
 
-#### Medium-term — moderate effort or shape-changing
+- The intended fast path is to build a `JaxPatchPipeline`, call `.compile()` once, and reuse the returned callable. Patch-specific metadata binding and JIT segment creation happen lazily on the first call for a static boundary, then cached plans and segment runners are reused for subsequent calls with matching dims, dynamic coordinate values, coordinate units, and attrs.
+- Equivalent pipeline definitions reuse cached compiled callables automatically.
+- Callback-backed operations preserve DASCore compatibility but execute their operation body on the host, so they generally do not benefit as much from JAX fusion as native kernels.
+- Benchmarks live under `benchmarks/` and compare compiled `dasjax` pipelines against equivalent DASCore operation chains.
 
-These need either more work in the kernel layer or are shape-changing (segmented pipeline execution, same mechanism as `fbe`).
+## Documentation
 
-| Method | Implementation notes |
-|---|---|
-| `notch_filter` | SOS filter; same pattern as `pass_filter` |
-| `savgol_filter` | polynomial fitting per frame; JAX-doable |
-| `rolling` | rolling-window reductions (mean, std, …); needs strided views |
-| `correlate` | cross-correlation via `jnp.fft` |
-| `stft` / `istft` | expose the STFT kernel already used by `fbe` |
-| `decimate` | anti-aliased downsampling; shape-changing |
-| `aggregate` / `mean` / `std` / `sum` | axis reductions; shape-changing |
+Documentation is built with Zensical. The public API reference is generated at build time from the installed `dasjax` package, so run the API generation script before building or serving the site.
 
-## Performance Notes
+```bash
+uv run python scripts/build_api_docs.py
+uv run --extra docs zensical build --clean
+```
 
-- The intended fast path is to build a `JaxPatchPipeline`, call `.compile()` once, and reuse the returned callable across many patches of compatible shape and dtype.
-- Equivalent pipeline definitions reuse cached compiled callables automatically.
-- Benchmarks live under `benchmarks/` and compare compiled `dasjax` pipelines against equivalent DASCore operation chains.
+For local preview, run:
+
+```bash
+uv run python scripts/build_api_docs.py
+uv run --extra docs zensical serve
+```
+
+Generated files under `docs/api/` and `site/` are ignored by version control. GitHub Pages builds the same generated API docs and static site on pushes to `main`, then deploys the `site/` artifact through the `github-pages` environment.
 
 ## Development Guidelines
 
-- Add new JAX patch methods by defining an array kernel in `src/dasjax/kernels/` and one operation spec in the relevant `src/dasjax/operations/` family module.
-- The operation spec is the single source of truth for pipeline support, validation, and shared parity test cases.
+- Add new JAX patch methods by defining an array kernel in `src/dasjax/kernels/` and one `PatchOperation` subclass in the appropriate `src/dasjax/operations/` module.
+- The `PatchOperation` subclass is the single source of truth for pipeline support, metadata binding, and boundary updates.
 - Every new patch method must be tested against a DASCore baseline across the shared mixed-patch fixture in `tests/conftest.py`.
 - Prefer comparing internal operation behavior and compiled pipeline outputs against the closest native DASCore method or operator. If DASCore has no direct method, compare against an equivalent `Patch.update(...)` baseline.
 - Method-equivalence assertions should check data closeness with `equal_nan=True` when needed and should also verify coordinate preservation.
-- Compiled pipeline parity should come from the same declared operation cases rather than a separate hand-maintained test matrix.
+- Compiled pipeline parity should compare `JaxPatchPipeline` output against DASCore baselines for each registered operation.
 - Install Git hooks locally with `prek install`.
diff --git a/agents.md b/agents.md
index ba777d7..ea04ae3 100644
--- a/agents.md
+++ b/agents.md
@@ -2,7 +2,7 @@
 
 This file gives AI/code agents a practical checklist for contributing safely to dasjax.
 
-Keep Markdown prose unwrapped. Do not hard-wrap paragraphs in `.md` files unless a specific format requires it.
+Keep Markdown prose unwrapped. Do not hard-wrap paragraphs or list items in `.md` files; let editors soft-wrap them. Code blocks and formats that require line breaks are exceptions.
 
 ## Scope and priorities
 
diff --git a/benchmarks/readme.md b/benchmarks/readme.md
index 85efcd4..d131ac6 100644
--- a/benchmarks/readme.md
+++ b/benchmarks/readme.md
@@ -17,12 +17,14 @@ pytest benchmarks/test_pipeline_benchmarks.py
 
 ## Benchmark Structure
 
-The first benchmark suite focuses on side-by-side comparisons between:
+The benchmark suite focuses on side-by-side comparisons between:
 
 - compiled `dasjax` pipelines
 - equivalent DASCore-native operation chains
+- individual compiled `dasjax` operations
+- equivalent individual DASCore operations
 
-Each comparison is exposed as a separate benchmark test per engine so CodSpeed output is easy to read.
+Each comparison is exposed as a separate benchmark test per engine so CodSpeed output is easy to read. Pipeline benchmark groups use names like `scale_fbe`; individual operation benchmark groups use names like `operation_fbe`.
 
 To export benchmark results for ratio comparisons, use:
 
diff --git a/benchmarks/results/current.json b/benchmarks/results/current.json
new file mode 100644
index 0000000..043f592
--- /dev/null
+++ b/benchmarks/results/current.json
@@ -0,0 +1,521 @@
+{
+  "command": "/home/derrick/Gits/dasjax/.venv/bin/python3 -m pytest benchmarks/test_pipeline_benchmarks.py --benchmark-json=.benchmarks/current.json",
+  "environment": {
+    "dascore": "0.1.16",
+    "dasjax": "0.0.2.post6+git.fdb52b38.dirty",
+    "jax": "0.9.2",
+    "machine": "x86_64",
+    "platform": "Linux-6.8.0-110-generic-x86_64-with-glibc2.39",
+    "processor": "x86_64",
+    "python": "3.14.0"
+  },
+  "generated_at": "2026-04-25T14:27:13+00:00",
+  "rows": [
+    {
+      "case": "large-f32",
+      "dascore_mean_s": 0.007935926129023082,
+      "dasjax_mean_s": 0.017582151127201292,
+      "group": "operation_abs",
+      "speedup": 0.45136263882668115
+    },
+    {
+      "case": "large-f64",
+      "dascore_mean_s": 0.015053255730610825,
+      "dasjax_mean_s": 0.034838203482900884,
+      "group": "operation_abs",
+      "speedup": 0.43209047039406584
+    },
+    {
+      "case": "medium-f32",
+      "dascore_mean_s": 0.0016216116442719372,
+      "dasjax_mean_s": 0.002737910963199475,
+      "group": "operation_abs",
+      "speedup": 0.5922806351514623
+    },
+    {
+      "case": "medium-f64",
+      "dascore_mean_s": 0.0029411434471127837,
+      "dasjax_mean_s": 0.0039036083065406677,
+      "group": "operation_abs",
+      "speedup": 0.753442255511335
+    },
+    {
+      "case": "large-f32",
+      "dascore_mean_s": 0.007861990409571157,
+      "dasjax_mean_s": 0.017857173290923872,
+      "group": "operation_add",
+      "speedup": 0.4402707125862474
+    },
+    {
+      "case": "large-f64",
+      "dascore_mean_s": 0.014968957292976797,
+      "dasjax_mean_s": 0.03530251717828443,
+      "group": "operation_add",
+      "speedup": 0.42401954561428906
+    },
+    {
+      "case": "medium-f32",
+      "dascore_mean_s": 0.0013730891043464352,
+      "dasjax_mean_s": 0.00273294466455809,
+      "group": "operation_add",
+      "speedup": 0.5024211145411025
+    },
+    {
+      "case": "medium-f64",
+      "dascore_mean_s": 0.002872821541935874,
+      "dasjax_mean_s": 0.003951023883951072,
+      "group": "operation_add",
+      "speedup": 0.7271081183804482
+    },
+    {
+      "case": "large-f32",
+      "dascore_mean_s": 0.007773525349543112,
+      "dasjax_mean_s": 0.017493574536813498,
+      "group": "operation_clip",
+      "speedup": 0.4443646055975865
+    },
+    {
+      "case": "large-f64",
+      "dascore_mean_s": 0.014837235603408772,
+      "dasjax_mean_s": 0.03473483007420092,
+      "group": "operation_clip",
+      "speedup": 0.42715728194763897
+    },
+    {
+      "case": "medium-f32",
+      "dascore_mean_s": 0.0015795147206869437,
+      "dasjax_mean_s": 0.002797094222745197,
+      "group": "operation_clip",
+      "speedup": 0.5646984316233492
+    },
+    {
+      "case": "medium-f64",
+      "dascore_mean_s": 0.002816467924502995,
+      "dasjax_mean_s": 0.003984043106562846,
+      "group": "operation_clip",
+      "speedup": 0.7069371111631487
+    },
+    {
+      "case": "large-f32",
+      "dascore_mean_s": 0.010819450778073565,
+      "dasjax_mean_s": 0.02165447399992055,
+      "group": "operation_detrend",
+      "speedup": 0.49964043357106075
+    },
+    {
+      "case": "large-f64",
+      "dascore_mean_s": 0.019358336065045518,
+      "dasjax_mean_s": 0.03907591064346759,
+      "group": "operation_detrend",
+      "speedup": 0.4954033251245981
+    },
+    {
+      "case": "medium-f32",
+      "dascore_mean_s": 0.002359406132353501,
+      "dasjax_mean_s": 0.004217029320276005,
+      "group": "operation_detrend",
+      "speedup": 0.5594948370430295
+    },
+    {
+      "case": "medium-f64",
+      "dascore_mean_s": 0.004759153708495725,
+      "dasjax_mean_s": 0.005132301489444065,
+      "group": "operation_detrend",
+      "speedup": 0.9272942593657413
+    },
+    {
+      "case": "large-f32",
+      "dascore_mean_s": 0.0329788664482827,
+      "dasjax_mean_s": 0.02926682580786851,
+      "group": "operation_differentiate",
+      "speedup": 1.1268344119305274
+    },
+    {
+      "case": "large-f64",
+      "dascore_mean_s": 0.04246424634984578,
+      "dasjax_mean_s": 0.05601835818742984,
+      "group": "operation_differentiate",
+      "speedup": 0.7580416085699292
+    },
+    {
+      "case": "medium-f32",
+      "dascore_mean_s": 0.006672640640317695,
+      "dasjax_mean_s": 0.004160485464541186,
+      "group": "operation_differentiate",
+      "speedup": 1.6038129918219886
+    },
+    {
+      "case": "medium-f64",
+      "dascore_mean_s": 0.012786168552802919,
+      "dasjax_mean_s": 0.007639906760496704,
+      "group": "operation_differentiate",
+      "speedup": 1.673602696163223
+    },
+    {
+      "case": "large-f32",
+      "dascore_mean_s": 0.20849201119999633,
+      "dasjax_mean_s": 0.067468552866679,
+      "group": "operation_fbe",
+      "speedup": 3.0902102141124366
+    },
+    {
+      "case": "large-f64",
+      "dascore_mean_s": 0.21955316859966842,
+      "dasjax_mean_s": 0.11780996044439639,
+      "group": "operation_fbe",
+      "speedup": 1.8636214439889613
+    },
+    {
+      "case": "medium-f32",
+      "dascore_mean_s": 0.05749154618706598,
+      "dasjax_mean_s": 0.011731497455548379,
+      "group": "operation_fbe",
+      "speedup": 4.9006144701395735
+    },
+    {
+      "case": "medium-f64",
+      "dascore_mean_s": 0.05919101474978561,
+      "dasjax_mean_s": 0.025517563621228014,
+      "group": "operation_fbe",
+      "speedup": 2.3196185822593467
+    },
+    {
+      "case": "large-f32",
+      "dascore_mean_s": 0.06394093606650131,
+      "dasjax_mean_s": 0.033948521290092744,
+      "group": "operation_integrate",
+      "speedup": 1.8834674865547474
+    },
+    {
+      "case": "large-f64",
+      "dascore_mean_s": 0.07652714800077284,
+      "dasjax_mean_s": 0.06064815950069007,
+      "group": "operation_integrate",
+      "speedup": 1.2618214407628
+    },
+    {
+      "case": "medium-f32",
+      "dascore_mean_s": 0.01654486007932324,
+      "dasjax_mean_s": 0.005963402924941606,
+      "group": "operation_integrate",
+      "speedup": 2.7743991622845523
+    },
+    {
+      "case": "medium-f64",
+      "dascore_mean_s": 0.01953043829625703,
+      "dasjax_mean_s": 0.009111122707663354,
+      "group": "operation_integrate",
+      "speedup": 2.143581962717943
+    },
+    {
+      "case": "large-f32",
+      "dascore_mean_s": 0.016861063919932348,
+      "dasjax_mean_s": 0.017541805865361172,
+      "group": "operation_mean",
+      "speedup": 0.961193166162382
+    },
+    {
+      "case": "large-f64",
+      "dascore_mean_s": 0.02815186759403332,
+      "dasjax_mean_s": 0.029849777181935322,
+      "group": "operation_mean",
+      "speedup": 0.9431181821709023
+    },
+    {
+      "case": "medium-f32",
+      "dascore_mean_s": 0.0045291220615997,
+      "dasjax_mean_s": 0.0031456233550736638,
+      "group": "operation_mean",
+      "speedup": 1.4398170252311209
+    },
+    {
+      "case": "medium-f64",
+      "dascore_mean_s": 0.006446509749821416,
+      "dasjax_mean_s": 0.002789384320467339,
+      "group": "operation_mean",
+      "speedup": 2.31108696729942
+    },
+    {
+      "case": "large-f32",
+      "dascore_mean_s": 0.022142910000597607,
+      "dasjax_mean_s": 0.02258763956830411,
+      "group": "operation_normalize",
+      "speedup": 0.9803109321643965
+    },
+    {
+      "case": "large-f64",
+      "dascore_mean_s": 0.03985147412489217,
+      "dasjax_mean_s": 0.04604641334757933,
+      "group": "operation_normalize",
+      "speedup": 0.8654631539719515
+    },
+    {
+      "case": "medium-f32",
+      "dascore_mean_s": 0.003866081424726048,
+      "dasjax_mean_s": 0.003445870612513223,
+      "group": "operation_normalize",
+      "speedup": 1.1219461957413273
+    },
+    {
+      "case": "medium-f64",
+      "dascore_mean_s": 0.0076487489297601555,
+      "dasjax_mean_s": 0.006458191331293379,
+      "group": "operation_normalize",
+      "speedup": 1.184348455688807
+    },
+    {
+      "case": "large-f32",
+      "dascore_mean_s": 0.0076031236100588704,
+      "dasjax_mean_s": 0.017752565218424107,
+      "group": "operation_pad",
+      "speedup": 0.4282830969221359
+    },
+    {
+      "case": "large-f64",
+      "dascore_mean_s": 0.01408750785177054,
+      "dasjax_mean_s": 0.035332438148880436,
+      "group": "operation_pad",
+      "speedup": 0.39871315396944734
+    },
+    {
+      "case": "medium-f32",
+      "dascore_mean_s": 0.002024273651784072,
+      "dasjax_mean_s": 0.002737090742528947,
+      "group": "operation_pad",
+      "speedup": 0.739571260949038
+    },
+    {
+      "case": "medium-f64",
+      "dascore_mean_s": 0.0029554693321760857,
+      "dasjax_mean_s": 0.0038526478810573758,
+      "group": "operation_pad",
+      "speedup": 0.7671267718774611
+    },
+    {
+      "case": "large-f32",
+      "dascore_mean_s": 0.13081185362625547,
+      "dasjax_mean_s": 0.2346832335999352,
+      "group": "operation_pass_filter",
+      "speedup": 0.5573975252499316
+    },
+    {
+      "case": "large-f64",
+      "dascore_mean_s": 0.1514530785001019,
+      "dasjax_mean_s": 0.2844445848008036,
+      "group": "operation_pass_filter",
+      "speedup": 0.5324519663686493
+    },
+    {
+      "case": "medium-f32",
+      "dascore_mean_s": 0.032527580249864387,
+      "dasjax_mean_s": 0.052176482400136594,
+      "group": "operation_pass_filter",
+      "speedup": 0.6234145874459952
+    },
+    {
+      "case": "medium-f64",
+      "dascore_mean_s": 0.04164246772081242,
+      "dasjax_mean_s": 0.07034695579956557,
+      "group": "operation_pass_filter",
+      "speedup": 0.5919583476996682
+    },
+    {
+      "case": "large-f32",
+      "dascore_mean_s": 0.007709398385319686,
+      "dasjax_mean_s": 0.01771389471709109,
+      "group": "operation_scale",
+      "speedup": 0.435217579671022
+    },
+    {
+      "case": "large-f64",
+      "dascore_mean_s": 0.014517987178805924,
+      "dasjax_mean_s": 0.036403064703470725,
+      "group": "operation_scale",
+      "speedup": 0.3988122235604454
+    },
+    {
+      "case": "medium-f32",
+      "dascore_mean_s": 0.0014040707887125262,
+      "dasjax_mean_s": 0.0026716843637301637,
+      "group": "operation_scale",
+      "speedup": 0.5255376749490664
+    },
+    {
+      "case": "medium-f64",
+      "dascore_mean_s": 0.0027331539843771678,
+      "dasjax_mean_s": 0.004020802098549036,
+      "group": "operation_scale",
+      "speedup": 0.6797534216775966
+    },
+    {
+      "case": "large-f32",
+      "dascore_mean_s": 0.03271859779325213,
+      "dasjax_mean_s": 0.02677430021631645,
+      "group": "operation_standardize",
+      "speedup": 1.2220150490922332
+    },
+    {
+      "case": "large-f64",
+      "dascore_mean_s": 0.06161480506658942,
+      "dasjax_mean_s": 0.047110426545424904,
+      "group": "operation_standardize",
+      "speedup": 1.3078804329478757
+    },
+    {
+      "case": "medium-f32",
+      "dascore_mean_s": 0.006401470681010033,
+      "dasjax_mean_s": 0.005071113542843734,
+      "group": "operation_standardize",
+      "speedup": 1.2623402388699572
+    },
+    {
+      "case": "medium-f64",
+      "dascore_mean_s": 0.013299871999966949,
+      "dasjax_mean_s": 0.007162377103119821,
+      "group": "operation_standardize",
+      "speedup": 1.8569075334184415
+    },
+    {
+      "case": "large-f32",
+      "dascore_mean_s": 0.009185174989084693,
+      "dasjax_mean_s": 0.01774878547171884,
+      "group": "operation_taper",
+      "speedup": 0.5175100574470561
+    },
+    {
+      "case": "large-f64",
+      "dascore_mean_s": 0.015738343254567803,
+      "dasjax_mean_s": 0.0372611652959744,
+      "group": "operation_taper",
+      "speedup": 0.4223792554407345
+    },
+    {
+      "case": "medium-f32",
+      "dascore_mean_s": 0.002441625380864328,
+      "dasjax_mean_s": 0.0025713899945996347,
+      "group": "operation_taper",
+      "speedup": 0.9495352264697946
+    },
+    {
+      "case": "medium-f64",
+      "dascore_mean_s": 0.0031923615308187435,
+      "dasjax_mean_s": 0.004030060436244411,
+      "group": "operation_taper",
+      "speedup": 0.7921373838735
+    },
+    {
+      "case": "large-f32",
+      "dascore_mean_s": 0.0497878854001101,
+      "dasjax_mean_s": 0.03216135399959187,
+      "group": "scale_add_detrend_normalize",
+      "speedup": 1.5480655883064474
+    },
+    {
+      "case": "large-f64",
+      "dascore_mean_s": 0.089915300092054,
+      "dasjax_mean_s": 0.05392152589430273,
+      "group": "scale_add_detrend_normalize",
+      "speedup": 1.6675214323182632
+    },
+    {
+      "case": "medium-f32",
+      "dascore_mean_s": 0.010027643979318176,
+      "dasjax_mean_s": 0.005617196311436172,
+      "group": "scale_add_detrend_normalize",
+      "speedup": 1.7851688677681923
+    },
+    {
+      "case": "medium-f64",
+      "dascore_mean_s": 0.02164517268201135,
+      "dasjax_mean_s": 0.00887979291158391,
+      "group": "scale_add_detrend_normalize",
+      "speedup": 2.4375762923226154
+    },
+    {
+      "case": "large-f32",
+      "dascore_mean_s": 0.217333702200267,
+      "dasjax_mean_s": 0.06826758373354096,
+      "group": "scale_fbe",
+      "speedup": 3.183556386711362
+    },
+    {
+      "case": "large-f64",
+      "dascore_mean_s": 0.23468941240134883,
+      "dasjax_mean_s": 0.12220381800014163,
+      "group": "scale_fbe",
+      "speedup": 1.920475286632017
+    },
+    {
+      "case": "medium-f32",
+      "dascore_mean_s": 0.059396552500629696,
+      "dasjax_mean_s": 0.016094810917775995,
+      "group": "scale_fbe",
+      "speedup": 3.6904162965362253
+    },
+    {
+      "case": "medium-f64",
+      "dascore_mean_s": 0.062460162599988205,
+      "dasjax_mean_s": 0.025890661076958237,
+      "group": "scale_fbe",
+      "speedup": 2.4124591648830287
+    },
+    {
+      "case": "large-f32",
+      "dascore_mean_s": 0.22368254179964425,
+      "dasjax_mean_s": 0.06857853256269664,
+      "group": "scale_fbe_normalize",
+      "speedup": 3.2616991562942337
+    },
+    {
+      "case": "large-f64",
+      "dascore_mean_s": 0.23593561480010977,
+      "dasjax_mean_s": 0.11862296349954704,
+      "group": "scale_fbe_normalize",
+      "speedup": 1.9889539751804521
+    },
+    {
+      "case": "medium-f32",
+      "dascore_mean_s": 0.062028346937268,
+      "dasjax_mean_s": 0.015839042776019257,
+      "group": "scale_fbe_normalize",
+      "speedup": 3.9161676506853436
+    },
+    {
+      "case": "medium-f64",
+      "dascore_mean_s": 0.06444275512512831,
+      "dasjax_mean_s": 0.025173454000185124,
+      "group": "scale_fbe_normalize",
+      "speedup": 2.559948870133372
+    },
+    {
+      "case": "large-f32",
+      "dascore_mean_s": 0.14785859057051962,
+      "dasjax_mean_s": 0.23864778060087702,
+      "group": "scale_pass_filter_abs",
+      "speedup": 0.6195682616374445
+    },
+    {
+      "case": "large-f64",
+      "dascore_mean_s": 0.182844042000094,
+      "dasjax_mean_s": 0.28871820400017895,
+      "group": "scale_pass_filter_abs",
+      "speedup": 0.6332958554978427
+    },
+    {
+      "case": "medium-f32",
+      "dascore_mean_s": 0.03665519632020733,
+      "dasjax_mean_s": 0.05447101847312297,
+      "group": "scale_pass_filter_abs",
+      "speedup": 0.6729302544305041
+    },
+    {
+      "case": "medium-f64",
+      "dascore_mean_s": 0.04954743119978957,
+      "dasjax_mean_s": 0.07087507012533933,
+      "group": "scale_pass_filter_abs",
+      "speedup": 0.6990812300032606
+    }
+  ],
+  "schema_version": 1,
+  "source": "local"
+}
diff --git a/benchmarks/test_pipeline_benchmarks.py b/benchmarks/test_pipeline_benchmarks.py
index c8af98c..50764d5 100644
--- a/benchmarks/test_pipeline_benchmarks.py
+++ b/benchmarks/test_pipeline_benchmarks.py
@@ -5,6 +5,7 @@
 from collections.abc import Callable
 
 import dascore as dc
+import numpy as np
 import pytest
 
 from dasjax import JaxPatchPipeline
@@ -81,6 +82,213 @@ def dascore_scale_add_detrend_normalize(example_patch) -> Callable[[], object]:
     )
 
 
+@pytest.fixture(scope="module")
+def dasjax_scale(example_patch) -> Callable[[], object]:
+    """Return a warmed compiled dasjax scale operation."""
+    compiled = JaxPatchPipeline().scale(2.0).compile()
+    compiled(example_patch)
+    return lambda: compiled(example_patch)
+
+
+@pytest.fixture(scope="module")
+def dascore_scale(example_patch) -> Callable[[], object]:
+    """Return the equivalent DASCore scale operation."""
+    return lambda: _scale_patch(example_patch, 2.0)
+
+
+@pytest.fixture(scope="module")
+def dasjax_add(example_patch) -> Callable[[], object]:
+    """Return a warmed compiled dasjax add operation."""
+    compiled = JaxPatchPipeline().add(1.0).compile()
+    compiled(example_patch)
+    return lambda: compiled(example_patch)
+
+
+@pytest.fixture(scope="module")
+def dascore_add(example_patch) -> Callable[[], object]:
+    """Return the equivalent DASCore add operation."""
+    return lambda: _add_patch(example_patch, 1.0)
+
+
+@pytest.fixture(scope="module")
+def dasjax_abs(example_patch) -> Callable[[], object]:
+    """Return a warmed compiled dasjax abs operation."""
+    compiled = JaxPatchPipeline().abs().compile()
+    compiled(example_patch)
+    return lambda: compiled(example_patch)
+
+
+@pytest.fixture(scope="module")
+def dascore_abs(example_patch) -> Callable[[], object]:
+    """Return the equivalent DASCore abs operation."""
+    return lambda: example_patch.abs()
+
+
+@pytest.fixture(scope="module")
+def dasjax_clip(example_patch) -> Callable[[], object]:
+    """Return a warmed compiled dasjax clip operation."""
+    compiled = JaxPatchPipeline().clip(-0.25, 0.25).compile()
+    compiled(example_patch)
+    return lambda: compiled(example_patch)
+
+
+@pytest.fixture(scope="module")
+def dascore_clip(example_patch) -> Callable[[], object]:
+    """Return the equivalent DASCore clip operation."""
+    return lambda: example_patch.update(data=np.clip(example_patch.data, -0.25, 0.25))
+
+
+@pytest.fixture(scope="module")
+def dasjax_detrend(example_patch) -> Callable[[], object]:
+    """Return a warmed compiled dasjax detrend operation."""
+    compiled = JaxPatchPipeline().detrend(dim="time", type="constant").compile()
+    compiled(example_patch)
+    return lambda: compiled(example_patch)
+
+
+@pytest.fixture(scope="module")
+def dascore_detrend(example_patch) -> Callable[[], object]:
+    """Return the equivalent DASCore detrend operation."""
+    return lambda: example_patch.detrend(dim="time", type="constant")
+
+
+@pytest.fixture(scope="module")
+def dasjax_normalize(example_patch) -> Callable[[], object]:
+    """Return a warmed compiled dasjax normalize operation."""
+    compiled = JaxPatchPipeline().normalize(dim="time").compile()
+    compiled(example_patch)
+    return lambda: compiled(example_patch)
+
+
+@pytest.fixture(scope="module")
+def dascore_normalize(example_patch) -> Callable[[], object]:
+    """Return the equivalent DASCore normalize operation."""
+    return lambda: example_patch.normalize(dim="time")
+
+
+@pytest.fixture(scope="module")
+def dasjax_standardize(example_patch) -> Callable[[], object]:
+    """Return a warmed compiled dasjax standardize operation."""
+    compiled = JaxPatchPipeline().standardize(dim="time").compile()
+    compiled(example_patch)
+    return lambda: compiled(example_patch)
+
+
+@pytest.fixture(scope="module")
+def dascore_standardize(example_patch) -> Callable[[], object]:
+    """Return the equivalent DASCore standardize operation."""
+    return lambda: example_patch.standardize(dim="time")
+
+
+@pytest.fixture(scope="module")
+def dasjax_differentiate(example_patch) -> Callable[[], object]:
+    """Return a warmed compiled dasjax differentiate operation."""
+    compiled = JaxPatchPipeline().differentiate(dim="time").compile()
+    compiled(example_patch)
+    return lambda: compiled(example_patch)
+
+
+@pytest.fixture(scope="module")
+def dascore_differentiate(example_patch) -> Callable[[], object]:
+    """Return the equivalent DASCore differentiate operation."""
+    return lambda: example_patch.differentiate(dim="time")
+
+
+@pytest.fixture(scope="module")
+def dasjax_integrate(example_patch) -> Callable[[], object]:
+    """Return a warmed compiled dasjax integrate operation."""
+    compiled = JaxPatchPipeline().integrate(dim="time").compile()
+    compiled(example_patch)
+    return lambda: compiled(example_patch)
+
+
+@pytest.fixture(scope="module")
+def dascore_integrate(example_patch) -> Callable[[], object]:
+    """Return the equivalent DASCore integrate operation."""
+    return lambda: example_patch.integrate(dim="time")
+
+
+@pytest.fixture(scope="module")
+def dasjax_taper(example_patch) -> Callable[[], object]:
+    """Return a warmed compiled dasjax taper operation."""
+    compiled = JaxPatchPipeline().taper(time=0.05, window_type="hann").compile()
+    compiled(example_patch)
+    return lambda: compiled(example_patch)
+
+
+@pytest.fixture(scope="module")
+def dascore_taper(example_patch) -> Callable[[], object]:
+    """Return the equivalent DASCore taper operation."""
+    return lambda: example_patch.taper(time=0.05, window_type="hann")
+
+
+@pytest.fixture(scope="module")
+def dasjax_pad(example_patch) -> Callable[[], object]:
+    """Return a warmed compiled dasjax pad operation."""
+    compiled = JaxPatchPipeline().pad(time=(16, 16), samples=True).compile()
+    compiled(example_patch)
+    return lambda: compiled(example_patch)
+
+
+@pytest.fixture(scope="module")
+def dascore_pad(example_patch) -> Callable[[], object]:
+    """Return the equivalent DASCore pad operation."""
+    return lambda: example_patch.pad(time=(16, 16), samples=True)
+
+
+@pytest.fixture(scope="module")
+def dasjax_mean(example_patch) -> Callable[[], object]:
+    """Return a warmed compiled dasjax mean reduction."""
+    compiled = JaxPatchPipeline().mean(dim="time").compile()
+    compiled(example_patch)
+    return lambda: compiled(example_patch)
+
+
+@pytest.fixture(scope="module")
+def dascore_mean(example_patch) -> Callable[[], object]:
+    """Return the equivalent DASCore mean reduction."""
+    return lambda: example_patch.mean(dim="time")
+
+
+@pytest.fixture(scope="module")
+def dasjax_pass_filter(example_patch) -> Callable[[], object]:
+    """Return a warmed compiled dasjax pass_filter operation."""
+    compiled = JaxPatchPipeline().pass_filter(time=(2.0, 10.0)).compile()
+    compiled(example_patch)
+    return lambda: compiled(example_patch)
+
+
+@pytest.fixture(scope="module")
+def dascore_pass_filter(example_patch) -> Callable[[], object]:
+    """Return the equivalent DASCore pass_filter operation."""
+    return lambda: example_patch.pass_filter(time=(2.0, 10.0))
+
+
+@pytest.fixture(scope="module")
+def dasjax_fbe(example_patch) -> Callable[[], object]:
+    """Return a warmed compiled dasjax fbe operation."""
+    compiled = (
+        JaxPatchPipeline()
+        .fbe(time=64, samples=True, overlap=32, fmin=2.0, fmax=10.0)
+        .compile()
+    )
+    compiled(example_patch)
+    return lambda: compiled(example_patch)
+
+
+@pytest.fixture(scope="module")
+def dascore_fbe(example_patch) -> Callable[[], object]:
+    """Return the equivalent DASCore fbe baseline operation."""
+    return lambda: _run_dascore_fbe(
+        example_patch,
+        time=64,
+        overlap=32,
+        samples=True,
+        fmin=2.0,
+        fmax=10.0,
+    )
+
+
 @pytest.fixture(scope="module")
 def dasjax_scale_pass_filter_abs(example_patch) -> Callable[[], object]:
     """Return a warmed compiled dasjax filtering pipeline."""
@@ -203,3 +411,163 @@ def test_dascore_scale_fbe_normalize(
     ) -> None:
         """Benchmark DASCore fbe+normalize chain execution."""
         benchmark(dascore_scale_fbe_normalize)
+
+
+class TestIndividualOperationBenchmarks:
+    """Benchmarks for individual dasjax operations and DASCore baselines."""
+
+    @pytest.mark.benchmark(group="operation_scale")
+    def test_dasjax_compiled_operation_scale(self, benchmark, dasjax_scale) -> None:
+        """Benchmark warmed compiled dasjax scale execution."""
+        benchmark(dasjax_scale)
+
+    @pytest.mark.benchmark(group="operation_scale")
+    def test_dascore_operation_scale(self, benchmark, dascore_scale) -> None:
+        """Benchmark DASCore scale execution."""
+        benchmark(dascore_scale)
+
+    @pytest.mark.benchmark(group="operation_add")
+    def test_dasjax_compiled_operation_add(self, benchmark, dasjax_add) -> None:
+        """Benchmark warmed compiled dasjax add execution."""
+        benchmark(dasjax_add)
+
+    @pytest.mark.benchmark(group="operation_add")
+    def test_dascore_operation_add(self, benchmark, dascore_add) -> None:
+        """Benchmark DASCore add execution."""
+        benchmark(dascore_add)
+
+    @pytest.mark.benchmark(group="operation_abs")
+    def test_dasjax_compiled_operation_abs(self, benchmark, dasjax_abs) -> None:
+        """Benchmark warmed compiled dasjax abs execution."""
+        benchmark(dasjax_abs)
+
+    @pytest.mark.benchmark(group="operation_abs")
+    def test_dascore_operation_abs(self, benchmark, dascore_abs) -> None:
+        """Benchmark DASCore abs execution."""
+        benchmark(dascore_abs)
+
+    @pytest.mark.benchmark(group="operation_clip")
+    def test_dasjax_compiled_operation_clip(self, benchmark, dasjax_clip) -> None:
+        """Benchmark warmed compiled dasjax clip execution."""
+        benchmark(dasjax_clip)
+
+    @pytest.mark.benchmark(group="operation_clip")
+    def test_dascore_operation_clip(self, benchmark, dascore_clip) -> None:
+        """Benchmark DASCore-equivalent clip execution."""
+        benchmark(dascore_clip)
+
+    @pytest.mark.benchmark(group="operation_detrend")
+    def test_dasjax_compiled_operation_detrend(self, benchmark, dasjax_detrend) -> None:
+        """Benchmark warmed compiled dasjax detrend execution."""
+        benchmark(dasjax_detrend)
+
+    @pytest.mark.benchmark(group="operation_detrend")
+    def test_dascore_operation_detrend(self, benchmark, dascore_detrend) -> None:
+        """Benchmark DASCore detrend execution."""
+        benchmark(dascore_detrend)
+
+    @pytest.mark.benchmark(group="operation_normalize")
+    def test_dasjax_compiled_operation_normalize(
+        self, benchmark, dasjax_normalize
+    ) -> None:
+        """Benchmark warmed compiled dasjax normalize execution."""
+        benchmark(dasjax_normalize)
+
+    @pytest.mark.benchmark(group="operation_normalize")
+    def test_dascore_operation_normalize(self, benchmark, dascore_normalize) -> None:
+        """Benchmark DASCore normalize execution."""
+        benchmark(dascore_normalize)
+
+    @pytest.mark.benchmark(group="operation_standardize")
+    def test_dasjax_compiled_operation_standardize(
+        self, benchmark, dasjax_standardize
+    ) -> None:
+        """Benchmark warmed compiled dasjax standardize execution."""
+        benchmark(dasjax_standardize)
+
+    @pytest.mark.benchmark(group="operation_standardize")
+    def test_dascore_operation_standardize(
+        self, benchmark, dascore_standardize
+    ) -> None:
+        """Benchmark DASCore standardize execution."""
+        benchmark(dascore_standardize)
+
+    @pytest.mark.benchmark(group="operation_differentiate")
+    def test_dasjax_compiled_operation_differentiate(
+        self, benchmark, dasjax_differentiate
+    ) -> None:
+        """Benchmark warmed compiled dasjax differentiate execution."""
+        benchmark(dasjax_differentiate)
+
+    @pytest.mark.benchmark(group="operation_differentiate")
+    def test_dascore_operation_differentiate(
+        self, benchmark, dascore_differentiate
+    ) -> None:
+        """Benchmark DASCore differentiate execution."""
+        benchmark(dascore_differentiate)
+
+    @pytest.mark.benchmark(group="operation_integrate")
+    def test_dasjax_compiled_operation_integrate(
+        self, benchmark, dasjax_integrate
+    ) -> None:
+        """Benchmark warmed compiled dasjax integrate execution."""
+        benchmark(dasjax_integrate)
+
+    @pytest.mark.benchmark(group="operation_integrate")
+    def test_dascore_operation_integrate(self, benchmark, dascore_integrate) -> None:
+        """Benchmark DASCore integrate execution."""
+        benchmark(dascore_integrate)
+
+    @pytest.mark.benchmark(group="operation_taper")
+    def test_dasjax_compiled_operation_taper(self, benchmark, dasjax_taper) -> None:
+        """Benchmark warmed compiled dasjax taper execution."""
+        benchmark(dasjax_taper)
+
+    @pytest.mark.benchmark(group="operation_taper")
+    def test_dascore_operation_taper(self, benchmark, dascore_taper) -> None:
+        """Benchmark DASCore taper execution."""
+        benchmark(dascore_taper)
+
+    @pytest.mark.benchmark(group="operation_pad")
+    def test_dasjax_compiled_operation_pad(self, benchmark, dasjax_pad) -> None:
+        """Benchmark warmed compiled dasjax pad execution."""
+        benchmark(dasjax_pad)
+
+    @pytest.mark.benchmark(group="operation_pad")
+    def test_dascore_operation_pad(self, benchmark, dascore_pad) -> None:
+        """Benchmark DASCore pad execution."""
+        benchmark(dascore_pad)
+
+    @pytest.mark.benchmark(group="operation_mean")
+    def test_dasjax_compiled_operation_mean(self, benchmark, dasjax_mean) -> None:
+        """Benchmark warmed compiled dasjax mean reduction execution."""
+        benchmark(dasjax_mean)
+
+    @pytest.mark.benchmark(group="operation_mean")
+    def test_dascore_operation_mean(self, benchmark, dascore_mean) -> None:
+        """Benchmark DASCore mean reduction execution."""
+        benchmark(dascore_mean)
+
+    @pytest.mark.benchmark(group="operation_pass_filter")
+    def test_dasjax_compiled_operation_pass_filter(
+        self, benchmark, dasjax_pass_filter
+    ) -> None:
+        """Benchmark warmed compiled dasjax pass_filter execution."""
+        benchmark(dasjax_pass_filter)
+
+    @pytest.mark.benchmark(group="operation_pass_filter")
+    def test_dascore_operation_pass_filter(
+        self, benchmark, dascore_pass_filter
+    ) -> None:
+        """Benchmark DASCore pass_filter execution."""
+        benchmark(dascore_pass_filter)
+
+    @pytest.mark.benchmark(group="operation_fbe")
+    def test_dasjax_compiled_operation_fbe(self, benchmark, dasjax_fbe) -> None:
+        """Benchmark warmed compiled dasjax fbe execution."""
+        benchmark(dasjax_fbe)
+
+    @pytest.mark.benchmark(group="operation_fbe")
+    def test_dascore_operation_fbe(self, benchmark, dascore_fbe) -> None:
+        """Benchmark DASCore fbe-equivalent execution."""
+        benchmark(dascore_fbe)
diff --git a/docs/development/architecture.md b/docs/development/architecture.md
new file mode 100644
index 0000000..7e3bca7
--- /dev/null
+++ b/docs/development/architecture.md
@@ -0,0 +1,17 @@
+# Architecture
+
+`dasjax` is organized around one core operation model.
+
+## Pipeline Layer
+
+`src/dasjax/pipeline.py` records operation chains, plans metadata boundaries, and compiles reusable patch transforms. This is the main user-facing API. Compiled callables cache both JIT segment runners and bound metadata plans for repeated calls with the same static boundary.
+
+## Operation Layer
+
+`src/dasjax/core.py` defines `PatchOperation`, `PatchBoundary`, `PatchPyTree`, and registry helpers. Registered operation classes live under `src/dasjax/operations/`, grouped by DASCore-style domains.
+
+Operation authors use `bind(boundary)` for Python-side metadata planning, `kernel(patch_tree)` for JAX-side data transforms, and `update_boundary(boundary)` for static metadata changes.
+
+## Kernel Layer
+
+`src/dasjax/kernels/` contains the array-level JAX kernels that do the numerical work, grouped by domain.
diff --git a/docs/development/documentation.md b/docs/development/documentation.md
new file mode 100644
index 0000000..46751ef
--- /dev/null
+++ b/docs/development/documentation.md
@@ -0,0 +1,34 @@
+# Documentation
+
+Documentation is built with Zensical. The API reference page is generated from the public `dasjax` package API immediately before the site build. Benchmark documentation is generated from the checked-in benchmark snapshot.
+
+```bash
+uv run python scripts/build_api_docs.py
+uv run python scripts/build_benchmark_docs.py
+uv run --extra docs zensical build --clean
+```
+
+Preview the site locally with:
+
+```bash
+uv run python scripts/build_api_docs.py
+uv run python scripts/build_benchmark_docs.py
+uv run --extra docs zensical serve
+```
+
+Generated API reference pages are written under `docs/api/`, generated benchmark docs are written under `docs/benchmarks/`, and the static site is written to `site/`. These outputs are ignored by version control.
+
+Refresh the benchmark snapshot before building benchmark docs with:
+
+```bash
+uv run dasjax-benchmark refresh
+```
+
+## Local Checks
+
+```bash
+uv run python scripts/build_api_docs.py
+uv run python scripts/build_benchmark_docs.py
+uv run --extra docs zensical build --clean
+uv run pytest
+```
diff --git a/docs/development/index.md b/docs/development/index.md
new file mode 100644
index 0000000..22f679e
--- /dev/null
+++ b/docs/development/index.md
@@ -0,0 +1,9 @@
+# Development
+
+Use this section when you are changing `dasjax` internals or extending the operation surface.
+
+## Pages
+
+- [Architecture](architecture.md) explains the pipeline, operation, and kernel layers.
+- [Operation Coverage](operation-coverage.md) summarizes the registered operation surface.
+- [Documentation](documentation.md) describes local docs builds and checks.
diff --git a/docs/development/operation-coverage.md b/docs/development/operation-coverage.md
new file mode 100644
index 0000000..3a41fa0
--- /dev/null
+++ b/docs/development/operation-coverage.md
@@ -0,0 +1,7 @@
+# Operation Coverage
+
+The package currently registers 72 pipeline operations. Most are implemented as JAX-backed kernels with static metadata planning; heavier DASCore-compatible numeric transforms can use host callbacks when a full static JAX kernel is not yet practical. Callback-backed operations are compatibility paths and generally offer less fusion benefit than native kernels.
+
+Remaining DASCore patch methods are mostly metadata, selection, convenience, or data-dependent shape operations. In particular, `rolling` returns a roller object and `dropna` has data-dependent output shape, so they do not map directly to the current compiled `Patch -> Patch` pipeline model.
+
+The generated [API Reference](../api/index.md) lists the current operation registry.
diff --git a/docs/index.md b/docs/index.md
new file mode 100644
index 0000000..612c7a5
--- /dev/null
+++ b/docs/index.md
@@ -0,0 +1 @@
+--8<-- "README.md"
diff --git a/docs/static/dasjax_logo.png b/docs/static/dasjax_logo.png
new file mode 100644
index 0000000..23d140c
Binary files /dev/null and b/docs/static/dasjax_logo.png differ
diff --git a/docs/static/favicon.ico b/docs/static/favicon.ico
new file mode 100644
index 0000000..5b119e8
Binary files /dev/null and b/docs/static/favicon.ico differ
diff --git a/docs/tutorial/compiled-pipelines.md b/docs/tutorial/compiled-pipelines.md
new file mode 100644
index 0000000..aeb0889
--- /dev/null
+++ b/docs/tutorial/compiled-pipelines.md
@@ -0,0 +1,34 @@
+# Compiled Pipelines
+
+Use `JaxPatchPipeline` when you want to build a reusable callable once and run it across many compatible patches.
+
+```python
+import dascore as dc
+from dasjax import JaxPatchPipeline
+
+patch = dc.get_example_patch("example_event_1")
+
+pipeline = (
+    JaxPatchPipeline()
+    .scale(2.0)
+    .add(1.0)
+    .detrend(dim="time", type="constant")
+    .normalize(dim="time")
+)
+compiled = pipeline.compile()
+
+out = patch.pipe(compiled)
+
+print(out.shape)
+```
+
+## Workflow
+
+1. Create a `JaxPatchPipeline`.
+2. Add DASCore-style patch operations.
+3. Call `.compile()` once.
+4. Reuse the compiled callable with `patch.pipe(compiled)` or `compiled(patch)`.
+
+## Compatibility
+
+The compiled callable can be reused for patches with matching static metadata: dims, dynamic coordinate values, coordinate units, and attrs. When those metadata inputs change, `dasjax` plans and caches a new compatible execution path.
diff --git a/docs/tutorial/index.md b/docs/tutorial/index.md
new file mode 100644
index 0000000..b08c3d4
--- /dev/null
+++ b/docs/tutorial/index.md
@@ -0,0 +1,10 @@
+# Tutorial
+
+Use this section when you want to learn the user-facing workflow first.
+
+`dasjax` centers on `JaxPatchPipeline`: build a DASCore-style operation chain, compile it once, and reuse the returned callable for compatible patches.
+
+## Pages
+
+- [Compiled Pipelines](compiled-pipelines.md) shows the main workflow.
+- [Performance](performance.md) explains what is cached and what still runs on the host.
diff --git a/docs/tutorial/performance.md b/docs/tutorial/performance.md
new file mode 100644
index 0000000..4921e45
--- /dev/null
+++ b/docs/tutorial/performance.md
@@ -0,0 +1,15 @@
+# Performance
+
+The intended fast path is to call `.compile()` once and reuse the returned callable.
+
+## Caching
+
+Patch-specific metadata binding and JIT segment creation happen lazily on the first call for a static patch boundary. Cached plans and segment runners are reused for later calls with matching dims, dynamic coordinate values, coordinate units, and attrs.
+
+Equivalent pipeline definitions reuse cached compiled callables automatically.
+
+## Native Kernels And Callbacks
+
+Native JAX-backed operations can be fused into compiled segments. Some heavier DASCore-compatible numeric transforms still use host callbacks; those operations are useful for compatibility, but they do not usually benefit as much from JAX fusion as native kernels.
+
+Benchmarks live under `benchmarks/` and compare compiled `dasjax` pipelines against equivalent DASCore operation chains.
diff --git a/pyproject.toml b/pyproject.toml
index 589869a..c50077b 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -35,6 +35,12 @@ dev = [
   "prek>=0.3.8",
   "ruff>=0.14.5",
 ]
+docs = [
+  "zensical",
+]
+
+[project.scripts]
+dasjax-benchmark = "dasjax.benchmark_cli:main"
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
diff --git a/scripts/build_api_docs.py b/scripts/build_api_docs.py
new file mode 100644
index 0000000..936ed6b
--- /dev/null
+++ b/scripts/build_api_docs.py
@@ -0,0 +1,484 @@
+"""Generate Markdown API reference pages for the Zensical docs build."""
+
+from __future__ import annotations
+
+import inspect
+import os
+import re
+import shutil
+import sys
+from dataclasses import dataclass
+from inspect import Signature
+from pathlib import Path
+from textwrap import dedent
+from types import ModuleType
+from typing import Any
+
+
+ROOT = Path(__file__).resolve().parents[1]
+SRC = ROOT / "src"
+OUT_DIR = ROOT / "docs" / "api"
+
+if str(SRC) not in sys.path:
+    sys.path.insert(0, str(SRC))
+
+import dasjax  # noqa: E402
+
+
+@dataclass(frozen=True)
+class ApiEntry:
+    """One generated API documentation page."""
+
+    name: str
+    display_name: str
+    obj: Any
+    kind: str
+    path: Path
+    owner: "ApiEntry | None" = None
+
+
+def _doc(obj: Any) -> str:
+    """Return a cleaned docstring or fallback text."""
+    return inspect.getdoc(obj) or "No public docstring is available."
+
+
+def _summary(obj: Any) -> str:
+    """Return a compact one-line summary from a docstring."""
+    lines = [line.strip() for line in _doc(obj).splitlines() if line.strip()]
+    return lines[0] if lines else ""
+
+
+def _signature(obj: Any) -> str:
+    """Return a readable signature for functions, methods, and classes."""
+    target = obj.__init__ if inspect.isclass(obj) else obj
+    try:
+        signature = inspect.signature(target)
+    except (TypeError, ValueError):
+        return "()"
+    params = [
+        parameter
+        for name, parameter in signature.parameters.items()
+        if name not in {"self", "cls"}
+    ]
+    return str(signature.replace(parameters=params, return_annotation=Signature.empty))
+
+
+def _slug(value: str) -> str:
+    """Return a filesystem-safe, deterministic slug."""
+    value = value.replace("__", "-")
+    value = re.sub(r"[^A-Za-z0-9_.-]+", "-", value)
+    return value.strip("-").replace(".", "-").lower()
+
+
+def _table_cell(value: str) -> str:
+    """Escape Markdown table cell separators."""
+    return value.replace("|", "\\|").replace("\n", " ")
+
+
+def _page_link(from_page: Path, entry: ApiEntry) -> str:
+    """Return a relative Markdown link from one generated page to another."""
+    return Path(os.path.relpath(entry.path, from_page.parent)).as_posix()
+
+
+def _xref_map(entries: tuple[ApiEntry, ...]) -> dict[str, ApiEntry]:
+    """Return local reference aliases mapped to generated API pages."""
+    refs: dict[str, ApiEntry] = {}
+    for entry in entries:
+        aliases = {
+            entry.name,
+            entry.display_name,
+            entry.name.removeprefix("dasjax."),
+            entry.display_name.rsplit(".", 1)[-1],
+        }
+        module_name = getattr(entry.obj, "__module__", None)
+        object_name = getattr(entry.obj, "__name__", None)
+        if module_name and object_name:
+            aliases.add(f"{module_name}.{object_name}")
+            aliases.add(object_name)
+        if entry.kind == "method" and entry.owner is not None:
+            method_name = entry.display_name.rsplit(".", 1)[-1]
+            aliases.add(f"{entry.owner.display_name}.{method_name}")
+            aliases.add(f"{entry.owner.name}.{method_name}")
+        for alias in aliases:
+            if alias and alias not in refs:
+                refs[alias] = entry
+    return refs
+
+
+def _link_ref(token: str, *, page: Path, refs: dict[str, ApiEntry]) -> str | None:
+    """Return a Markdown link for a reference token if it can be resolved."""
+    clean = token.strip()
+    suffix = ""
+    while clean.endswith("()"):
+        clean = clean[:-2]
+        suffix += "()"
+    entry = refs.get(clean)
+    if entry is None:
+        return None
+    return f"[`{token}`]({_page_link(page, entry)})"
+
+
+def _link_docstring(text: str, *, page: Path, refs: dict[str, ApiEntry]) -> str:
+    """Convert common Python docstring references into Markdown links."""
+
+    def _replace_role(match: re.Match[str]) -> str:
+        label = match.group("label") or match.group("target")
+        target = match.group("target")
+        link = _link_ref(target, page=page, refs=refs)
+        if link is None:
+            return match.group(0)
+        href = link.rsplit("](", 1)[1][:-1]
+        return f"[`{label}`]({href})"
+
+    def _replace_double_backtick(match: re.Match[str]) -> str:
+        token = match.group("token")
+        return _link_ref(token, page=page, refs=refs) or f"`{token}`"
+
+    def _replace_backtick(match: re.Match[str]) -> str:
+        token = match.group("token")
+        return _link_ref(token, page=page, refs=refs) or match.group(0)
+
+    text = re.sub(
+        r":(?:class|func|meth|mod|obj|py:class|py:func|py:meth|py:mod):"
+        r"`(?:(?P<label>[^`<>]+)\s*<)?(?P<target>[^`<>]+)>?`",
+        _replace_role,
+        text,
+    )
+    text = re.sub(r"``(?P<token>[^`]+)``", _replace_double_backtick, text)
+    return re.sub(
+        r"(?<!\[)`(?P<token>[A-Za-z_][A-Za-z0-9_.]*(?:\(\))?)`",
+        _replace_backtick,
+        text,
+    )
+
+
+def _kind(obj: Any) -> str:
+    """Classify a documented Python object."""
+    if inspect.ismodule(obj):
+        return "module"
+    if inspect.isclass(obj):
+        return "class"
+    if inspect.ismethod(obj):
+        return "method"
+    if inspect.isfunction(obj):
+        return "function"
+    return "object"
+
+
+def _is_owned_method(cls: type, name: str, obj: Any) -> bool:
+    """Return True for public methods defined directly on a class."""
+    if name.startswith("_"):
+        return False
+    raw = cls.__dict__.get(name)
+    if isinstance(raw, (staticmethod, classmethod)):
+        raw = raw.__func__
+    return inspect.isfunction(raw)
+
+
+def _owned_methods(entry: ApiEntry, method_entries: dict[tuple[type, str], ApiEntry]):
+    """Yield generated pages for public methods owned by a class entry."""
+    if not inspect.isclass(entry.obj):
+        return ()
+    rows = []
+    for name, obj in sorted(entry.obj.__dict__.items()):
+        if _is_owned_method(entry.obj, name, obj):
+            rows.append(method_entries[(entry.obj, name)])
+    return tuple(rows)
+
+
+def _module_members(
+    module: ModuleType,
+    entries_by_obj: dict[int, ApiEntry],
+    entries: tuple[ApiEntry, ...],
+):
+    """Yield documented public members owned by a module."""
+    if module is dasjax:
+        members = []
+        for name in getattr(module, "__all__", ()):
+            obj = getattr(module, name)
+            entry = entries_by_obj.get(id(obj))
+            if entry is not None:
+                members.append(entry)
+        return tuple(members)
+
+    members: list[ApiEntry] = []
+    module_name = module.__name__
+    for entry in entries:
+        if entry.kind == "module" or entry.owner is not None:
+            continue
+        if getattr(entry.obj, "__module__", None) == module_name:
+            members.append(entry)
+    return tuple(members)
+
+
+def _index_rows(entries: tuple[ApiEntry, ...], index_page: Path) -> list[str]:
+    """Render the single compact API index table."""
+    rows = ["| Name | Description |", "|---|---|"]
+    for entry in _index_entries(entries):
+        href = _page_link(index_page, entry)
+        rows.append(
+            f"| [`{entry.display_name}`]({href}) | {_table_cell(_summary(entry.obj))} |"
+        )
+    return rows
+
+
+def _index_entries(entries: tuple[ApiEntry, ...]) -> tuple[ApiEntry, ...]:
+    """Return entries shown in the top-level API index table."""
+    return tuple(entry for entry in entries if entry.kind != "method")
+
+
+def _entry_counts(entries: tuple[ApiEntry, ...]) -> dict[str, int]:
+    """Return generated entry counts by kind."""
+    kinds = {"module": 0, "class": 0, "function": 0, "method": 0, "object": 0}
+    for entry in entries:
+        kinds[entry.kind] = kinds.get(entry.kind, 0) + 1
+    return kinds
+
+
+def _owned_label(entry: ApiEntry) -> str:
+    """Return a short label for owned-object tables."""
+    if entry.kind == "method" and entry.owner is not None:
+        return entry.display_name.rsplit(".", 1)[-1]
+    return entry.display_name
+
+
+def _owned_table(
+    *,
+    title: str,
+    entries: tuple[ApiEntry, ...],
+    page: Path,
+    empty_text: str,
+) -> list[str]:
+    """Render a linked table for objects owned by this API object."""
+    lines = [f"## {title}", ""]
+    if not entries:
+        lines.extend([empty_text, ""])
+        return lines
+    lines.extend(["| Name | Description |", "|---|---|"])
+    for entry in entries:
+        href = _page_link(page, entry)
+        lines.append(
+            f"| [`{_owned_label(entry)}`]({href}) | "
+            f"{_table_cell(_summary(entry.obj))} |"
+        )
+    lines.append("")
+    return lines
+
+
+def _render_page(
+    entry: ApiEntry,
+    *,
+    entries: tuple[ApiEntry, ...],
+    entries_by_obj: dict[int, ApiEntry],
+    method_entries: dict[tuple[type, str], ApiEntry],
+    refs: dict[str, ApiEntry],
+) -> str:
+    """Render one formatted API detail page."""
+    owner_link = (
+        f"[`{entry.owner.display_name}`]({_page_link(entry.path, entry.owner)})"
+        if entry.owner is not None
+        else "None"
+    )
+    lines = [
+        f"# {entry.display_name}",
+        "",
+        "<!-- This file is generated by scripts/build_api_docs.py. -->",
+        "",
+        '<div class="grid cards" markdown>',
+        "",
+        f"- __Kind__  \n  `{entry.kind}`",
+        f"- __Owner__  \n  {owner_link}",
+        "",
+        "</div>",
+        "",
+    ]
+    if callable(entry.obj) and not inspect.ismodule(entry.obj):
+        lines.extend(
+            [
+                "## Signature",
+                "",
+                f"```python\n{entry.display_name}{_signature(entry.obj)}\n```",
+                "",
+            ]
+        )
+    doc = _link_docstring(dedent(_doc(entry.obj)), page=entry.path, refs=refs)
+    lines.extend(['!!! abstract "Description"', ""])
+    lines.extend(f"    {line}" if line else "" for line in doc.splitlines())
+    lines.append("")
+
+    if inspect.ismodule(entry.obj):
+        lines.extend(
+            _owned_table(
+                title="Owned Public API",
+                entries=_module_members(entry.obj, entries_by_obj, entries),
+                page=entry.path,
+                empty_text="This module has no documented owned public API entries.",
+            )
+        )
+    elif inspect.isclass(entry.obj):
+        owned_methods = _owned_methods(entry, method_entries)
+        if owned_methods:
+            lines.extend(
+                _owned_table(
+                    title="Owned Methods",
+                    entries=owned_methods,
+                    page=entry.path,
+                    empty_text="",
+                )
+            )
+
+    return "\n".join(lines)
+
+
+def _collect_entries() -> tuple[
+    tuple[ApiEntry, ...],
+    dict[int, ApiEntry],
+    dict[tuple[type, str], ApiEntry],
+]:
+    """Collect root, public symbol, operation, and method API pages."""
+    root_module = ApiEntry(
+        name="dasjax",
+        display_name="dasjax",
+        obj=dasjax,
+        kind="module",
+        path=OUT_DIR / "dasjax.md",
+    )
+    module_objects: dict[str, ModuleType] = {"dasjax": dasjax}
+    entries: list[ApiEntry] = [root_module]
+
+    for name in dasjax.__all__:
+        obj = getattr(dasjax, name)
+        module_name = getattr(obj, "__module__", None)
+        if module_name:
+            module = sys.modules.get(module_name)
+            if isinstance(module, ModuleType):
+                module_objects[module_name] = module
+        entries.append(
+            ApiEntry(
+                name=f"dasjax.{name}",
+                display_name=name,
+                obj=obj,
+                kind=_kind(obj),
+                path=OUT_DIR / f"{_slug(name)}.md",
+            )
+        )
+
+    seen_operation_classes: set[type] = set()
+    for operation_name in dasjax.list_patch_operations():
+        cls = dasjax.get_patch_operation(operation_name)
+        module = sys.modules.get(cls.__module__)
+        if isinstance(module, ModuleType):
+            module_objects[cls.__module__] = module
+        if cls in seen_operation_classes:
+            continue
+        seen_operation_classes.add(cls)
+        entries.append(
+            ApiEntry(
+                name=f"{cls.__module__}.{cls.__name__}",
+                display_name=operation_name,
+                obj=cls,
+                kind="class",
+                path=OUT_DIR / "operations" / f"{_slug(operation_name)}.md",
+            )
+        )
+
+    module_entries = [
+        ApiEntry(
+            name=module_name,
+            display_name=module_name,
+            obj=module,
+            kind="module",
+            path=OUT_DIR / "modules" / f"{_slug(module_name)}.md",
+        )
+        for module_name, module in sorted(module_objects.items())
+        if module_name != "dasjax"
+    ]
+    entries[1:1] = module_entries
+
+    method_entries: dict[tuple[type, str], ApiEntry] = {}
+    for owner in tuple(entries):
+        if not inspect.isclass(owner.obj):
+            continue
+        for method_name, method_obj in sorted(owner.obj.__dict__.items()):
+            if not _is_owned_method(owner.obj, method_name, method_obj):
+                continue
+            entry = ApiEntry(
+                name=f"{owner.name}.{method_name}",
+                display_name=f"{owner.display_name}.{method_name}",
+                obj=method_obj,
+                kind="method",
+                path=OUT_DIR
+                / "methods"
+                / f"{_slug(owner.name)}-{_slug(method_name)}.md",
+                owner=owner,
+            )
+            method_entries[(owner.obj, method_name)] = entry
+            entries.append(entry)
+
+    entries_by_obj = {id(entry.obj): entry for entry in entries}
+    return tuple(entries), entries_by_obj, method_entries
+
+
+def _render_index(entries: tuple[ApiEntry, ...]) -> str:
+    """Render the compact linked API index."""
+    index_page = OUT_DIR / "index.md"
+    counts = _entry_counts(entries)
+    lines = [
+        "# API Reference",
+        "",
+        "<!-- This file is generated by scripts/build_api_docs.py. -->",
+        "",
+        "This page is generated from the public `dasjax` Python API and the "
+        "registered pipeline operation surface at build time.",
+        "",
+        '<div class="grid cards" markdown>',
+        "",
+        f"- __Modules__  \n  {counts['module']} generated module pages",
+        f"- __Classes__  \n  {counts['class']} generated class pages",
+        f"- __Functions__  \n  {counts['function']} public helper functions",
+        f"- __Methods__  \n  {counts['method']} method pages linked from owners",
+        "",
+        "</div>",
+        "",
+        '!!! tip "How to use this reference"',
+        "",
+        "    Use the table below for public entry points, modules, and pipeline "
+        "operations. Method pages are linked from each owning class page so the "
+        "top-level index stays scannable.",
+        "",
+        *_index_rows(entries, index_page),
+        "",
+    ]
+    return "\n".join(lines)
+
+
+def _clean_output() -> None:
+    """Remove old generated API pages before writing a fresh set."""
+    if OUT_DIR.exists():
+        shutil.rmtree(OUT_DIR)
+    OUT_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def main() -> None:
+    """Write generated API docs to the docs tree."""
+    entries, entries_by_obj, method_entries = _collect_entries()
+    refs = _xref_map(entries)
+    _clean_output()
+    (OUT_DIR / "index.md").write_text(_render_index(entries), encoding="utf-8")
+    for entry in entries:
+        entry.path.parent.mkdir(parents=True, exist_ok=True)
+        entry.path.write_text(
+            _render_page(
+                entry,
+                entries=entries,
+                entries_by_obj=entries_by_obj,
+                method_entries=method_entries,
+                refs=refs,
+            ),
+            encoding="utf-8",
+        )
+    print(f"Wrote {len(entries) + 1} API documentation pages")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/build_benchmark_docs.py b/scripts/build_benchmark_docs.py
new file mode 100644
index 0000000..8ef590f
--- /dev/null
+++ b/scripts/build_benchmark_docs.py
@@ -0,0 +1,29 @@
+"""Generate benchmark documentation from the tracked benchmark snapshot."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[1]
+SRC = ROOT / "src"
+
+if str(SRC) not in sys.path:
+    sys.path.insert(0, str(SRC))
+
+from dasjax.benchmark_cli import DEFAULT_DOCS_OUTPUT, DEFAULT_SNAPSHOT, docs_command  # noqa: E402
+
+
+def main() -> int:
+    """Render the benchmark docs page."""
+    args = type(
+        "Args",
+        (),
+        {"snapshot": DEFAULT_SNAPSHOT, "output": DEFAULT_DOCS_OUTPUT},
+    )()
+    return docs_command(args)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/src/dasjax/__init__.py b/src/dasjax/__init__.py
index d01e789..e853ed3 100644
--- a/src/dasjax/__init__.py
+++ b/src/dasjax/__init__.py
@@ -10,11 +10,27 @@
 
 jax.config.update("jax_enable_x64", True)
 
-from . import pytree as pytree
-from .operations import list_operations
+from .core import (
+    PatchBoundary,
+    PatchOperation,
+    PatchPyTree,
+    get_patch_operation,
+    iter_patch_operations,
+    list_patch_operations,
+)
+from . import operations as operations
+from . import core_ops as core_ops
 from .pipeline import JaxPatchPipeline
 
-__all__ = ["JaxPatchPipeline", "list_operations"]
+__all__ = [
+    "JaxPatchPipeline",
+    "PatchBoundary",
+    "PatchOperation",
+    "PatchPyTree",
+    "get_patch_operation",
+    "iter_patch_operations",
+    "list_patch_operations",
+]
 
 try:
     __version__ = version("dasjax")
diff --git a/src/dasjax/benchmark_cli.py b/src/dasjax/benchmark_cli.py
new file mode 100644
index 0000000..ca521f9
--- /dev/null
+++ b/src/dasjax/benchmark_cli.py
@@ -0,0 +1,640 @@
+"""Command line helpers for running and publishing dasjax benchmarks."""
+
+from __future__ import annotations
+
+import argparse
+import html
+import json
+import math
+import platform
+import re
+import subprocess
+import sys
+from collections import defaultdict
+from collections.abc import Sequence
+from datetime import UTC, datetime
+from importlib import metadata
+from pathlib import Path
+from typing import Any
+
+DEFAULT_BENCHMARK_FILE = Path("benchmarks/test_pipeline_benchmarks.py")
+DEFAULT_RAW_OUTPUT = Path(".benchmarks/current.json")
+DEFAULT_SNAPSHOT = Path("benchmarks/results/current.json")
+DEFAULT_DOCS_OUTPUT = Path("docs/benchmarks/index.md")
+DEFAULT_DOCS_DIR = Path("docs/benchmarks")
+
+
+def _version(package: str) -> str:
+    """Return an installed package version or a fallback label."""
+    try:
+        return metadata.version(package)
+    except metadata.PackageNotFoundError:
+        return "unknown"
+
+
+def _now_iso() -> str:
+    """Return the current UTC timestamp as an ISO string."""
+    return datetime.now(tz=UTC).replace(microsecond=0).isoformat()
+
+
+def build_pytest_command(args: argparse.Namespace) -> list[str]:
+    """Build the pytest-benchmark command from parsed CLI args."""
+    command = [
+        sys.executable,
+        "-m",
+        "pytest",
+        str(args.benchmark_file),
+        f"--benchmark-json={args.output}",
+    ]
+    filters = []
+    if args.benchmark:
+        filters.append("(" + " or ".join(args.benchmark) + ")")
+    if args.case:
+        filters.append("(" + " or ".join(args.case) + ")")
+    if filters:
+        command.extend(["-k", " and ".join(filters)])
+    command.extend(args.pytest_arg or ())
+    return command
+
+
+def run_benchmarks(args: argparse.Namespace) -> int:
+    """Run pytest-benchmark and write raw benchmark JSON."""
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    command = build_pytest_command(args)
+    print("Running:", " ".join(command))
+    return subprocess.run(command, check=False).returncode
+
+
+def _benchmark_group(benchmark: dict[str, Any]) -> str:
+    """Return a benchmark group name from pytest-benchmark data."""
+    if group := benchmark.get("group"):
+        return str(group)
+    name = str(benchmark.get("name") or benchmark.get("fullname") or "")
+    name = re.sub(r"\[.*\]$", "", name)
+    for prefix in ("test_dasjax_compiled_", "test_dascore_"):
+        if prefix in name:
+            return name.rsplit(prefix, 1)[1]
+    return name.removeprefix("test_")
+
+
+def _benchmark_engine(benchmark: dict[str, Any]) -> str | None:
+    """Return dasjax/dascore for known benchmark functions."""
+    text = " ".join(
+        str(benchmark.get(key, "")) for key in ("name", "fullname", "fullname")
+    )
+    if "dasjax" in text:
+        return "dasjax"
+    if "dascore" in text:
+        return "dascore"
+    return None
+
+
+def _case_label(value: Any) -> str:
+    """Return a readable label for a pytest benchmark parameter."""
+    if isinstance(value, str):
+        return value
+    if isinstance(value, (list, tuple)) and len(value) == 2:
+        shape, dtype = value
+        if isinstance(shape, (list, tuple)) and len(shape) == 2:
+            shape_label = {
+                (600, 4000): "medium",
+                (1200, 8000): "large",
+            }.get(
+                tuple(int(axis) for axis in shape),
+                "x".join(str(axis) for axis in shape),
+            )
+            dtype_label = str(dtype).removeprefix("float")
+            return f"{shape_label}-f{dtype_label}"
+    return str(value)
+
+
+def _benchmark_case(benchmark: dict[str, Any]) -> str:
+    """Return the parametrized patch case label."""
+    params = benchmark.get("params") or {}
+    if isinstance(params, dict):
+        for key in ("example_patch", "patch", "case"):
+            if key in params:
+                return _case_label(params[key])
+    text = str(benchmark.get("name") or benchmark.get("fullname") or "")
+    match = re.search(r"\[([^\]]+)\]", text)
+    return match.group(1) if match else "default"
+
+
+def _mean_seconds(benchmark: dict[str, Any]) -> float | None:
+    """Return benchmark mean in seconds."""
+    stats = benchmark.get("stats") or {}
+    mean = stats.get("mean") if isinstance(stats, dict) else None
+    return float(mean) if mean is not None else None
+
+
+def _environment(raw: dict[str, Any]) -> dict[str, Any]:
+    """Build environment metadata for a normalized snapshot."""
+    machine = raw.get("machine_info") or {}
+    return {
+        "python": platform.python_version(),
+        "platform": platform.platform(),
+        "processor": platform.processor() or machine.get("processor") or "unknown",
+        "machine": platform.machine(),
+        "jax": _version("jax"),
+        "dascore": _version("dascore"),
+        "dasjax": _version("dasjax"),
+    }
+
+
+def normalize_benchmark_json(
+    raw: dict[str, Any],
+    *,
+    command: str,
+    source: str = "local",
+) -> dict[str, Any]:
+    """Normalize pytest-benchmark JSON into a docs-friendly snapshot."""
+    grouped: dict[tuple[str, str], dict[str, float]] = defaultdict(dict)
+    for benchmark in raw.get("benchmarks", ()):
+        engine = _benchmark_engine(benchmark)
+        mean = _mean_seconds(benchmark)
+        if engine is None or mean is None:
+            continue
+        key = (_benchmark_group(benchmark), _benchmark_case(benchmark))
+        grouped[key][engine] = mean
+
+    rows = []
+    for (group, case), values in sorted(grouped.items()):
+        dascore = values.get("dascore")
+        dasjax = values.get("dasjax")
+        speedup = dascore / dasjax if dascore and dasjax else None
+        rows.append(
+            {
+                "group": group,
+                "case": case,
+                "dascore_mean_s": dascore,
+                "dasjax_mean_s": dasjax,
+                "speedup": speedup,
+            }
+        )
+
+    return {
+        "schema_version": 1,
+        "generated_at": _now_iso(),
+        "source": source,
+        "command": command,
+        "environment": _environment(raw),
+        "rows": rows,
+    }
+
+
+def load_json(path: Path) -> dict[str, Any]:
+    """Load JSON from a path."""
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def write_json(path: Path, payload: dict[str, Any]) -> None:
+    """Write stable, pretty JSON to a path."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(
+        json.dumps(payload, indent=2, sort_keys=True) + "\n", encoding="utf-8"
+    )
+
+
+def _format_ms(value: float | None) -> str:
+    """Format seconds as milliseconds."""
+    if value is None or not math.isfinite(value):
+        return "n/a"
+    return f"{value * 1000:.3f}"
+
+
+def _format_speedup(value: float | None) -> str:
+    """Format a speedup ratio."""
+    if value is None or not math.isfinite(value):
+        return "n/a"
+    return f"{value:.2f}x"
+
+
+def _sort_value(value: float | None) -> str:
+    """Return a stable table sort value for optional numeric cells."""
+    if value is None or not math.isfinite(value):
+        return ""
+    return f"{value:.12g}"
+
+
+def _benchmark_category(group: str) -> str:
+    """Return a human category for a benchmark group."""
+    return "Method" if group.startswith("operation_") else "Pipeline"
+
+
+def _split_rows(
+    snapshot: dict[str, Any],
+) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
+    """Return pipeline rows and method rows from a benchmark snapshot."""
+    rows = snapshot.get("rows") or []
+    pipelines = [
+        row for row in rows if not str(row.get("group", "")).startswith("operation_")
+    ]
+    methods = [
+        row for row in rows if str(row.get("group", "")).startswith("operation_")
+    ]
+    return pipelines, methods
+
+
+def render_benchmark_index(snapshot: dict[str, Any]) -> str:
+    """Render the benchmark section overview page."""
+    env = snapshot.get("environment") or {}
+    pipelines, methods = _split_rows(snapshot)
+    lines = [
+        "# Benchmarks",
+        "",
+        "<!-- This file is generated by dasjax.benchmark_cli. -->",
+        "",
+        "Published benchmark results compare warmed compiled `dasjax` pipelines and "
+        "methods against equivalent DASCore operation chains.",
+        "",
+        '<div class="grid cards" markdown>',
+        "",
+        f"- __Source__  \n  {snapshot.get('source', 'unknown')}",
+        f"- __Generated__  \n  {snapshot.get('generated_at', 'unknown')}",
+        f"- __Python__  \n  {env.get('python', 'unknown')}",
+        f"- __Platform__  \n  {env.get('platform', 'unknown')}",
+        f"- __Pipeline results__  \n  [{len(pipelines)} rows](pipelines.md)",
+        f"- __Method results__  \n  [{len(methods)} rows](methods.md)",
+        "",
+        "</div>",
+        "",
+        '!!! warning "Benchmark numbers are environment-specific"',
+        "",
+        "    Treat these numbers as a snapshot for this machine and dependency "
+        "set, not as universal performance guarantees.",
+        "",
+        "## Result Tables",
+        "",
+        "- [Pipelines](pipelines.md)",
+        "- [Methods](methods.md)",
+        "",
+        "## Environment",
+        "",
+        "| Key | Value |",
+        "|---|---|",
+    ]
+    for key, value in env.items():
+        lines.append(f"| `{key}` | `{value}` |")
+    lines.extend(
+        [
+            "",
+            "## Refreshing Results",
+            "",
+            "```bash",
+            "dasjax-benchmark refresh",
+            "```",
+            "",
+            "To run the steps separately:",
+            "",
+            "```bash",
+            "dasjax-benchmark run --output .benchmarks/current.json",
+            "dasjax-benchmark normalize --input .benchmarks/current.json --output benchmarks/results/current.json",
+            "dasjax-benchmark docs --snapshot benchmarks/results/current.json --output docs/benchmarks/index.md",
+            "```",
+            "",
+            "Raw pytest-benchmark command:",
+            "",
+            "```bash",
+            f"{snapshot.get('command', 'pytest benchmarks/test_pipeline_benchmarks.py')}",
+            "```",
+            "",
+        ]
+    )
+    return "\n".join(lines)
+
+
+def _benchmark_display_name(group: str) -> str:
+    """Return a display name for a benchmark group."""
+    return group.removeprefix("operation_")
+
+
+def _render_filter_script() -> str:
+    """Return client-side table filtering and sorting script."""
+    return """
+<script>
+(() => {
+  for (const table of document.querySelectorAll("[data-benchmark-table]")) {
+    const input = table.querySelector("[data-benchmark-filter]");
+    const tbody = table.querySelector("tbody");
+    const rows = Array.from(tbody.querySelectorAll("tr"));
+    const count = table.querySelector("[data-benchmark-count]");
+    const headers = Array.from(table.querySelectorAll("th[data-sort-index]"));
+    let sortState = { index: null, direction: "asc", type: "text" };
+    const cellValue = (row, index, type) => {
+      const cell = row.children[index];
+      const raw = cell?.dataset.sortValue || cell?.textContent || "";
+      if (type === "number") {
+        const value = Number.parseFloat(raw);
+        return Number.isFinite(value) ? value : Number.NEGATIVE_INFINITY;
+      }
+      return raw.trim().toLowerCase();
+    };
+    const applySort = () => {
+      if (sortState.index === null) return;
+      const direction = sortState.direction === "asc" ? 1 : -1;
+      const sorted = [...rows].sort((left, right) => {
+        const leftValue = cellValue(left, sortState.index, sortState.type);
+        const rightValue = cellValue(right, sortState.index, sortState.type);
+        if (leftValue < rightValue) return -1 * direction;
+        if (leftValue > rightValue) return 1 * direction;
+        return 0;
+      });
+      for (const row of sorted) tbody.appendChild(row);
+    };
+    const update = () => {
+      const query = input.value.trim().toLowerCase();
+      let visible = 0;
+      for (const row of rows) {
+        const match = row.textContent.toLowerCase().includes(query);
+        row.hidden = !match;
+        if (match) visible += 1;
+      }
+      if (count) count.textContent = `${visible} of ${rows.length} rows`;
+    };
+    for (const header of headers) {
+      const button = header.querySelector("button");
+      button.addEventListener("click", () => {
+        const index = Number.parseInt(header.dataset.sortIndex, 10);
+        const sameColumn = sortState.index === index;
+        sortState = {
+          index,
+          direction: sameColumn && sortState.direction === "asc" ? "desc" : "asc",
+          type: header.dataset.sortType || "text",
+        };
+        for (const item of headers) {
+          item.setAttribute("aria-sort", "none");
+          item.querySelector("[data-sort-indicator]").textContent = "";
+        }
+        header.setAttribute(
+          "aria-sort",
+          sortState.direction === "asc" ? "ascending" : "descending",
+        );
+        header.querySelector("[data-sort-indicator]").textContent =
+          sortState.direction === "asc" ? "▲" : "▼";
+        applySort();
+        update();
+      });
+    }
+    input.addEventListener("input", update);
+    update();
+  }
+})();
+</script>
+""".strip()
+
+
+def _render_table_style() -> str:
+    """Return page-local styles for benchmark tables."""
+    return """
+<style>
+.dasjax-benchmark-table {
+  margin-top: 1rem;
+}
+.dasjax-benchmark-table input[type="search"] {
+  width: min(100%, 32rem);
+  margin-bottom: 0.75rem;
+  padding: 0.55rem 0.7rem;
+  border: 1px solid var(--md-default-fg-color--lighter);
+  border-radius: 0.2rem;
+  background: var(--md-default-bg-color);
+  color: var(--md-default-fg-color);
+}
+.dasjax-benchmark-count {
+  margin: 0 0 0.5rem;
+  color: var(--md-default-fg-color--light);
+  font-size: 0.8rem;
+}
+.dasjax-benchmark-table table {
+  display: table;
+  width: 100%;
+}
+.dasjax-benchmark-table tbody tr:hover {
+  background: var(--md-code-bg-color);
+}
+.dasjax-benchmark-table th button {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.25rem;
+  padding: 0;
+  border: 0;
+  background: transparent;
+  color: inherit;
+  font: inherit;
+  font-weight: 700;
+  cursor: pointer;
+}
+.dasjax-benchmark-sort-indicator {
+  display: inline-block;
+  width: 0.75rem;
+  color: var(--md-default-fg-color--light);
+  font-size: 0.7rem;
+}
+</style>
+""".strip()
+
+
+def _sortable_header(
+    label: str,
+    index: int,
+    *,
+    sort_type: str = "text",
+    align: str | None = None,
+) -> str:
+    """Return a sortable table header cell."""
+    style = ' style="text-align: right;"' if align == "right" else ""
+    escaped = html.escape(label)
+    return (
+        f'<th{style} data-sort-index="{index}" data-sort-type="{sort_type}" '
+        'aria-sort="none">'
+        f'<button type="button">{escaped}'
+        '<span class="dasjax-benchmark-sort-indicator" '
+        "data-sort-indicator></span></button></th>"
+    )
+
+
+def render_benchmark_table_page(
+    snapshot: dict[str, Any],
+    *,
+    title: str,
+    rows: Sequence[dict[str, Any]],
+) -> str:
+    """Render a filterable benchmark table page."""
+    generated = html.escape(str(snapshot.get("generated_at", "unknown")))
+    placeholder = html.escape(f"Filter {title.lower()}...")
+    lines = [
+        f"# {title}",
+        "",
+        "<!-- This file is generated by dasjax.benchmark_cli. -->",
+        "",
+        f"Generated from the benchmark snapshot at `{generated}`.",
+        "",
+        _render_table_style(),
+        "",
+        '<div class="dasjax-benchmark-table" data-benchmark-table>',
+        f'<input data-benchmark-filter type="search" placeholder="{placeholder}" aria-label="{placeholder}">',
+        '<p class="dasjax-benchmark-count" data-benchmark-count></p>',
+        "<table>",
+        "<thead>",
+        "<tr>",
+        _sortable_header("Benchmark", 0),
+        _sortable_header("Case", 1),
+        _sortable_header("DASCore mean (ms)", 2, sort_type="number", align="right"),
+        _sortable_header("dasjax mean (ms)", 3, sort_type="number", align="right"),
+        _sortable_header("Speedup", 4, sort_type="number", align="right"),
+        "</tr>",
+        "</thead>",
+        "<tbody>",
+    ]
+    for row in rows:
+        group = html.escape(_benchmark_display_name(str(row.get("group", "unknown"))))
+        case = html.escape(str(row.get("case", "default")))
+        lines.extend(
+            [
+                "<tr>",
+                f"<td><code>{group}</code></td>",
+                f"<td><code>{case}</code></td>",
+                '<td style="text-align: right;" '
+                f'data-sort-value="{_sort_value(row.get("dascore_mean_s"))}">'
+                f"{html.escape(_format_ms(row.get('dascore_mean_s')))}</td>",
+                '<td style="text-align: right;" '
+                f'data-sort-value="{_sort_value(row.get("dasjax_mean_s"))}">'
+                f"{html.escape(_format_ms(row.get('dasjax_mean_s')))}</td>",
+                '<td style="text-align: right;" '
+                f'data-sort-value="{_sort_value(row.get("speedup"))}">'
+                f"{html.escape(_format_speedup(row.get('speedup')))}</td>",
+                "</tr>",
+            ]
+        )
+    lines.extend(
+        [
+            "</tbody>",
+            "</table>",
+            "</div>",
+            "",
+            _render_filter_script(),
+            "",
+        ]
+    )
+    return "\n".join(lines)
+
+
+def render_benchmark_docs(snapshot: dict[str, Any]) -> str:
+    """Render benchmark docs Markdown from a normalized snapshot."""
+    return render_benchmark_index(snapshot)
+
+
+def normalize_command(args: argparse.Namespace) -> int:
+    """Normalize a raw pytest-benchmark JSON file."""
+    raw = load_json(args.input)
+    command = (
+        args.command or f"pytest {DEFAULT_BENCHMARK_FILE} --benchmark-json={args.input}"
+    )
+    snapshot = normalize_benchmark_json(raw, command=command, source=args.source)
+    write_json(args.output, snapshot)
+    print(f"Wrote {args.output}")
+    return 0
+
+
+def docs_command(args: argparse.Namespace) -> int:
+    """Render benchmark docs from a normalized snapshot."""
+    snapshot = load_json(args.snapshot)
+    docs_dir = args.output.parent
+    docs_dir.mkdir(parents=True, exist_ok=True)
+    pipelines, methods = _split_rows(snapshot)
+    pages = {
+        args.output: render_benchmark_index(snapshot),
+        docs_dir / "pipelines.md": render_benchmark_table_page(
+            snapshot, title="Pipelines", rows=pipelines
+        ),
+        docs_dir / "methods.md": render_benchmark_table_page(
+            snapshot, title="Methods", rows=methods
+        ),
+    }
+    for path, text in pages.items():
+        path.write_text(text, encoding="utf-8")
+        print(f"Wrote {path}")
+    return 0
+
+
+def refresh_command(args: argparse.Namespace) -> int:
+    """Run benchmarks, normalize results, and render docs."""
+    run_args = argparse.Namespace(
+        benchmark_file=args.benchmark_file,
+        output=args.raw_output,
+        benchmark=args.benchmark,
+        case=args.case,
+        pytest_arg=args.pytest_arg,
+    )
+    code = run_benchmarks(run_args)
+    if code:
+        return code
+    command = " ".join(build_pytest_command(run_args))
+    normalize_args = argparse.Namespace(
+        input=args.raw_output,
+        output=args.snapshot,
+        source=args.source,
+        command=command,
+    )
+    normalize_command(normalize_args)
+    docs_args = argparse.Namespace(snapshot=args.snapshot, output=args.docs_output)
+    return docs_command(docs_args)
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Build the benchmark CLI parser."""
+    parser = argparse.ArgumentParser(prog="dasjax-benchmark")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    run = subparsers.add_parser("run", help="run pytest-benchmark suite")
+    run.add_argument("--benchmark-file", type=Path, default=DEFAULT_BENCHMARK_FILE)
+    run.add_argument("--output", type=Path, default=DEFAULT_RAW_OUTPUT)
+    run.add_argument("--benchmark", action="append", help="filter benchmark group/name")
+    run.add_argument("--case", action="append", help="filter fixture case label")
+    run.add_argument(
+        "--pytest-arg", action="append", default=[], help="extra pytest arg"
+    )
+    run.set_defaults(func=run_benchmarks)
+
+    normalize = subparsers.add_parser("normalize", help="normalize raw JSON")
+    normalize.add_argument("--input", type=Path, required=True)
+    normalize.add_argument("--output", type=Path, default=DEFAULT_SNAPSHOT)
+    normalize.add_argument("--source", default="local")
+    normalize.add_argument("--command")
+    normalize.set_defaults(func=normalize_command)
+
+    docs = subparsers.add_parser("docs", help="render benchmark docs")
+    docs.add_argument("--snapshot", type=Path, default=DEFAULT_SNAPSHOT)
+    docs.add_argument("--output", type=Path, default=DEFAULT_DOCS_OUTPUT)
+    docs.set_defaults(func=docs_command)
+
+    refresh = subparsers.add_parser("refresh", help="run, normalize, and render docs")
+    refresh.add_argument("--benchmark-file", type=Path, default=DEFAULT_BENCHMARK_FILE)
+    refresh.add_argument("--raw-output", type=Path, default=DEFAULT_RAW_OUTPUT)
+    refresh.add_argument("--snapshot", type=Path, default=DEFAULT_SNAPSHOT)
+    refresh.add_argument("--docs-output", type=Path, default=DEFAULT_DOCS_OUTPUT)
+    refresh.add_argument("--source", default="local")
+    refresh.add_argument(
+        "--benchmark", action="append", help="filter benchmark group/name"
+    )
+    refresh.add_argument("--case", action="append", help="filter fixture case label")
+    refresh.add_argument(
+        "--pytest-arg", action="append", default=[], help="extra pytest arg"
+    )
+    refresh.set_defaults(func=refresh_command)
+
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    """Run the benchmark CLI."""
+    if argv is None:
+        argv = sys.argv[1:]
+    if not argv:
+        argv = ["refresh"]
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    return int(args.func(args))
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/src/dasjax/core.py b/src/dasjax/core.py
new file mode 100644
index 0000000..b2bd2a3
--- /dev/null
+++ b/src/dasjax/core.py
@@ -0,0 +1,351 @@
+"""Core authoring API for JAX-backed DASCore patch operations."""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Iterator
+from dataclasses import dataclass, replace
+from typing import Any, ClassVar, Self
+
+import dascore as dc
+import jax
+import numpy as np
+
+_DTYPE_TO_CODE = {
+    np.dtype("bool").str: 1,
+    np.dtype("int32").str: 2,
+    np.dtype("int64").str: 3,
+    np.dtype("float32").str: 4,
+    np.dtype("float64").str: 5,
+    np.dtype("complex64").str: 6,
+    np.dtype("complex128").str: 7,
+    np.dtype("datetime64[ns]").str: 8,
+    np.dtype("timedelta64[ns]").str: 9,
+}
+_CODE_TO_DTYPE = {value: np.dtype(key) for key, value in _DTYPE_TO_CODE.items()}
+TIME_DTYPES = (np.dtype("datetime64[ns]"), np.dtype("timedelta64[ns]"))
+SUPPORTED_DTYPES = tuple(
+    np.dtype(key) for key in _DTYPE_TO_CODE if np.dtype(key) not in TIME_DTYPES
+)
+_PatchTreeChildren = tuple[Any, tuple[Any, ...], tuple[Any, ...], tuple[Any, ...]]
+
+
+def _camel_to_snake(name: str) -> str:
+    """Convert class names into default pipeline method names."""
+    name = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", name)
+    return re.sub("([a-z0-9])([A-Z])", r"\1_\2", name).lower()
+
+
+def _matches_dtype(dtype: np.dtype, candidates: tuple[np.dtype, ...]) -> bool:
+    return any(np.dtype(dtype) == candidate for candidate in candidates)
+
+
+def _encode_leaf(array: Any) -> tuple[Any, np.ndarray]:
+    arr = np.asarray(array)
+    if np.issubdtype(arr.dtype, np.datetime64):
+        arr = arr.astype("datetime64[ns]")
+    elif np.issubdtype(arr.dtype, np.timedelta64):
+        arr = arr.astype("timedelta64[ns]")
+    dtype_code = _DTYPE_TO_CODE.get(arr.dtype.str)
+    if dtype_code is None:
+        msg = f"Unsupported coordinate dtype for JAX patch conversion: {arr.dtype}"
+        raise TypeError(msg)
+    if _matches_dtype(arr.dtype, SUPPORTED_DTYPES):
+        return arr, np.asarray(dtype_code, dtype=np.int32)
+    if _matches_dtype(arr.dtype, TIME_DTYPES):
+        return arr.view(np.int64), np.asarray(dtype_code, dtype=np.int32)
+
+
+def _decode_leaf(array: Any, dtype_code: Any) -> np.ndarray:
+    out = np.asarray(array)
+    dtype = _CODE_TO_DTYPE[int(np.asarray(dtype_code).item())]
+    if _matches_dtype(dtype, TIME_DTYPES):
+        return out.astype(np.int64, copy=False).view(dtype)
+    return out.astype(dtype, copy=False)
+
+
+def _coord_values_match(left: Any, right: Any) -> bool:
+    """Return True when decoded coord values match existing coord values."""
+    left_arr = np.asarray(left)
+    right_arr = np.asarray(right)
+    if left_arr.shape != right_arr.shape:
+        return False
+    if np.issubdtype(left_arr.dtype, np.datetime64):
+        left_i = left_arr.astype("datetime64[ns]", copy=False).view(np.int64)
+        right_i = right_arr.astype("datetime64[ns]", copy=False).view(np.int64)
+        return bool(np.array_equal(left_i, right_i))
+    if np.issubdtype(left_arr.dtype, np.timedelta64):
+        left_i = left_arr.astype("timedelta64[ns]", copy=False).view(np.int64)
+        right_i = right_arr.astype("timedelta64[ns]", copy=False).view(np.int64)
+        return bool(np.array_equal(left_i, right_i))
+    return bool(np.array_equal(left_arr, right_arr))
+
+
+@dataclass(frozen=True)
+class PatchBoundary:
+    """DASCore-native metadata owned by pipeline boundaries."""
+
+    attrs: Any
+    coords: Any
+    coord_names: tuple[str, ...]
+
+    @property
+    def dims(self) -> tuple[str, ...]:
+        """Return ordered data dimension names."""
+        return tuple(self.coords.dims)
+
+    def axis(self, dim: str) -> int:
+        """Return the data axis for a named dimension."""
+        return self.dims.index(dim)
+
+    def coord(self, name: str) -> Any:
+        """Return a DASCore coordinate by name."""
+        return self.coords.coord_map[name]
+
+    def coord_dims(self, name: str) -> tuple[str, ...]:
+        """Return the dimensions associated with a coordinate."""
+        return tuple(self.coords.dim_map[name])
+
+    def coord_index(self, name: str) -> int:
+        """Return the ordered dynamic coordinate slot for a coordinate name."""
+        return self.coord_names.index(name)
+
+    def to_patch(
+        self,
+        patch_tree: "PatchPyTree",
+        *,
+        coerce_numpy: bool = True,
+    ) -> dc.Patch:
+        """Rebuild a DASCore patch by swapping dynamic values into metadata."""
+        coord_values = {
+            name: _decode_leaf(value, dtype_code)
+            for name, value, dtype_code in zip(
+                self.coord_names,
+                patch_tree.coord_values,
+                patch_tree.coord_dtype_codes,
+                strict=True,
+            )
+        }
+        coords: dict[str, Any] = {}
+        for name, coord in self.coords.coord_map.items():
+            out_coord = coord
+            if name in coord_values:
+                if _coord_values_match(coord_values[name], coord.values):
+                    out_coord = coord
+                else:
+                    out_coord = coord.update_data(data=coord_values[name])
+                if out_coord is not coord and coord.units is not None:
+                    out_coord = out_coord.set_units(coord.units)
+            dims = tuple(self.coords.dim_map[name])
+            coords[name] = (
+                out_coord if len(dims) == 1 and dims[0] == name else (dims, out_coord)
+            )
+        return dc.Patch(
+            data=np.asarray(patch_tree.data) if coerce_numpy else patch_tree.data,
+            coords=coords,
+            dims=patch_tree.dims,
+            attrs=self.attrs,
+        )
+
+    def new(
+        self,
+        *,
+        attrs: Any | None = None,
+        coords: Any | None = None,
+        coord_names: tuple[str, ...] | None = None,
+    ) -> "PatchBoundary":
+        """Return a copy with updated DASCore metadata."""
+        return replace(
+            self,
+            attrs=self.attrs if attrs is None else attrs,
+            coords=self.coords if coords is None else coords,
+            coord_names=self.coord_names if coord_names is None else coord_names,
+        )
+
+    def with_metadata(
+        self,
+        *,
+        attrs: Any | None = None,
+        coords: Any | None = None,
+    ) -> "PatchBoundary":
+        """Return a copy with updated DASCore metadata."""
+        return self.new(
+            attrs=attrs,
+            coords=coords,
+        )
+
+
+@jax.tree_util.register_pytree_node_class
+@dataclass(frozen=True)
+class PatchPyTree:
+    """JAX-friendly dynamic patch state with only dims as static metadata."""
+
+    data: Any
+    coord_values: tuple[Any, ...]
+    coord_dtype_codes: tuple[Any, ...]
+    dims: tuple[str, ...]
+    attrs: tuple[Any, ...] = ()
+
+    @classmethod
+    def from_patch(cls, patch: dc.Patch) -> tuple[Self, PatchBoundary]:
+        """Convert a DASCore patch into a tree plus boundary metadata."""
+        coord_names = tuple(patch.coords.coord_map)
+        coord_values = []
+        coord_dtype_codes = []
+        for name, coord in patch.coords.coord_map.items():
+            values, dtype_code = _encode_leaf(coord.values)
+            coord_values.append(values)
+            coord_dtype_codes.append(dtype_code)
+        return (
+            cls(
+                data=patch.data,
+                coord_values=tuple(coord_values),
+                coord_dtype_codes=tuple(coord_dtype_codes),
+                dims=tuple(patch.dims),
+            ),
+            PatchBoundary(
+                attrs=patch.attrs,
+                coords=patch.coords,
+                coord_names=coord_names,
+            ),
+        )
+
+    def to_patch(self, *, coerce_numpy: bool = True) -> dc.Patch:
+        """Reject reconstruction without boundary metadata."""
+        _ = coerce_numpy
+        msg = "PatchPyTree.to_patch() requires PatchBoundary.to_patch(patch_tree)."
+        raise RuntimeError(msg)
+
+    def tree_flatten(
+        self,
+    ) -> tuple[_PatchTreeChildren, dict[str, Any]]:
+        """Split dynamic JAX leaves from static dims."""
+        return (
+            (self.data, self.coord_values, self.coord_dtype_codes, self.attrs),
+            {"dims": self.dims},
+        )
+
+    @classmethod
+    def tree_unflatten(
+        cls,
+        aux_data: dict[str, Any],
+        children: _PatchTreeChildren,
+    ) -> Self:
+        data, coord_values, coord_dtype_codes, attrs = children
+        return cls(
+            data=data,
+            coord_values=coord_values,
+            coord_dtype_codes=coord_dtype_codes,
+            dims=aux_data["dims"],
+            attrs=attrs,
+        )
+
+    def coord(self, index: int) -> Any:
+        """Return one ordered coordinate-value slot."""
+        return self.coord_values[index]
+
+    def replace_coord(self, index: int, value: Any) -> tuple[Any, ...]:
+        """Return ordered coordinate-value slots with one value replaced."""
+        coords = list(self.coord_values)
+        coords[index] = value
+        return tuple(coords)
+
+    def new(
+        self,
+        data: Any | None = None,
+        coords: tuple[Any, ...] | None = None,
+        *,
+        dims: tuple[str, ...] | None = None,
+        coord_dtype_codes: tuple[Any, ...] | None = None,
+    ) -> Self:
+        """Return a copy with updated JAX leaves, matching Patch.new style.
+
+        ``coords`` are the ordered coordinate-value slots carried by this tree.
+        Coordinate names and DASCore coordinate objects live in ``PatchBoundary``.
+        """
+        return replace(
+            self,
+            data=self.data if data is None else data,
+            coord_values=self.coord_values if coords is None else coords,
+            coord_dtype_codes=(
+                self.coord_dtype_codes
+                if coord_dtype_codes is None
+                else coord_dtype_codes
+            ),
+            dims=self.dims if dims is None else dims,
+        )
+
+
+class PatchOperation:
+    """Base class for clean, class-authored patch operations."""
+
+    method_name: ClassVar[str | None] = None
+    register: ClassVar[bool] = True
+
+    _registry: ClassVar[dict[str, type["PatchOperation"]]] = {}
+
+    def __init_subclass__(cls, **kwargs: Any) -> None:
+        super().__init_subclass__(**kwargs)
+        if not cls.__dict__.get("register", True):
+            return
+        name = cls.operation_name()
+        if name in PatchOperation._registry:
+            msg = f"Duplicate patch operation method name {name!r}."
+            raise ValueError(msg)
+        PatchOperation._registry[name] = cls
+
+    @classmethod
+    def operation_name(cls) -> str:
+        """Return the public pipeline method name for this operation."""
+        name = cls.method_name
+        if name is not None:
+            return name
+        class_name = cls.__name__
+        if class_name.endswith("Operation"):
+            class_name = class_name.removesuffix("Operation")
+        return _camel_to_snake(class_name)
+
+    def bind(self, boundary: PatchBoundary) -> Self:
+        """Resolve DASCore metadata into static kernel parameters."""
+        _ = boundary
+        return self
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        """Apply the JAX-compatible dynamic transform."""
+        return patch_tree
+
+    def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary:
+        """Plan DASCore metadata changes without reading computed array values."""
+        return boundary
+
+    def update_boundary_from_result(
+        self,
+        patch_tree: PatchPyTree,
+        boundary: PatchBoundary,
+    ) -> PatchBoundary:
+        """Update metadata from computed results, forcing a segment boundary."""
+        _ = patch_tree
+        return boundary
+
+    @classmethod
+    def overrides(cls, method_name: str) -> bool:
+        """Return True if a subclass overrides one base hook."""
+        return getattr(cls, method_name) is not getattr(PatchOperation, method_name)
+
+
+def get_patch_operation(name: str) -> type[PatchOperation]:
+    """Return a class-authored patch operation by public method name."""
+    try:
+        return PatchOperation._registry[name]
+    except KeyError as exc:
+        raise AttributeError(f"Unknown jax patch operation {name!r}.") from exc
+
+
+def iter_patch_operations() -> Iterator[type[PatchOperation]]:
+    """Iterate over class-authored patch operations in registration order."""
+    return iter(PatchOperation._registry.values())
+
+
+def list_patch_operations() -> tuple[str, ...]:
+    """List class-authored operation names in registration order."""
+    return tuple(PatchOperation._registry)
diff --git a/src/dasjax/core_ops.py b/src/dasjax/core_ops.py
new file mode 100644
index 0000000..b55a29e
--- /dev/null
+++ b/src/dasjax/core_ops.py
@@ -0,0 +1,9 @@
+"""Compatibility exports for operation classes.
+
+New operation implementations live under :mod:`dasjax.operations`, grouped by
+the corresponding DASCore operation domain.
+"""
+
+from __future__ import annotations
+
+from .operations import *  # noqa: F403
diff --git a/src/dasjax/kernels/__init__.py b/src/dasjax/kernels/__init__.py
index c7423de..216c57a 100644
--- a/src/dasjax/kernels/__init__.py
+++ b/src/dasjax/kernels/__init__.py
@@ -15,15 +15,30 @@
     scale_kernel,
     standardize_kernel,
 )
+from .domain import (
+    apply_mask_kernel,
+    dispersion_phase_shift_kernel,
+    phase_weighted_stack_kernel,
+    radians_to_strain_kernel,
+    slope_filter_kernel,
+    tau_p_kernel,
+    velocity_to_strain_rate_edgeless_kernel,
+)
 from .filters import (
+    design_notch_filter,
     design_pass_filter_sos,
     gaussian_filter_kernel,
-    hampel_filter_callback_kernel,
     hampel_filter_kernel,
     is_finite_array,
+    median_filter_kernel,
+    notch_filter_kernel,
     pass_filter_default_padlen,
     pass_filter_initial_state,
     pass_filter_kernel,
+    savgol_coefficients,
+    savgol_filter_kernel,
+    sobel_filter_kernel,
+    wiener_filter_kernel,
 )
 from .signal import (
     detrend_kernel,
@@ -34,10 +49,12 @@
 )
 from .spectral import (
     banded_stft_kernel,
+    correlate_shift_kernel,
     dft_kernel,
     envelope_kernel,
     hilbert_kernel,
     idft_kernel,
+    whiten_spectrum_kernel,
     whiten_kernel,
 )
 
@@ -46,17 +63,20 @@
     "add_kernel",
     "angle_kernel",
     "apply_1d_weight_kernel",
+    "apply_mask_kernel",
     "banded_stft_kernel",
     "clip_kernel",
     "conj_kernel",
+    "correlate_shift_kernel",
+    "design_notch_filter",
     "design_pass_filter_sos",
     "detrend_kernel",
     "differentiate_kernel",
     "dft_kernel",
+    "dispersion_phase_shift_kernel",
     "envelope_kernel",
     "flip_kernel",
     "gaussian_filter_kernel",
-    "hampel_filter_callback_kernel",
     "hampel_filter_kernel",
     "hilbert_kernel",
     "identity_kernel",
@@ -64,14 +84,26 @@
     "imag_kernel",
     "integrate_kernel",
     "is_finite_array",
+    "median_filter_kernel",
+    "notch_filter_kernel",
     "normalize_kernel",
     "pass_filter_default_padlen",
     "pass_filter_initial_state",
     "pass_filter_kernel",
+    "phase_weighted_stack_kernel",
+    "radians_to_strain_kernel",
     "real_kernel",
     "roll_kernel",
     "scale_kernel",
+    "savgol_coefficients",
+    "savgol_filter_kernel",
+    "slope_filter_kernel",
+    "sobel_filter_kernel",
     "standardize_kernel",
+    "tau_p_kernel",
     "validate_detrend_type",
+    "velocity_to_strain_rate_edgeless_kernel",
     "whiten_kernel",
+    "whiten_spectrum_kernel",
+    "wiener_filter_kernel",
 ]
diff --git a/src/dasjax/kernels/domain.py b/src/dasjax/kernels/domain.py
new file mode 100644
index 0000000..125cd66
--- /dev/null
+++ b/src/dasjax/kernels/domain.py
@@ -0,0 +1,150 @@
+"""Domain-specific transform kernels."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import jax
+import jax.numpy as jnp
+
+from .spectral import dft_kernel, hilbert_kernel, idft_kernel
+
+
+def apply_mask_kernel(data: Any, mask: Any) -> Any:
+    """Apply a static broadcastable mask to data."""
+    return jnp.asarray(data) * jnp.asarray(mask, dtype=jnp.asarray(data).dtype)
+
+
+def slope_filter_kernel(
+    data: Any,
+    *,
+    axes: tuple[int, int],
+    dxs: tuple[float, float],
+    mask: Any,
+    steps: tuple[float, float],
+    sizes: tuple[int, int],
+    pad_width: tuple[tuple[int, int], ...] = (),
+) -> Any:
+    """Apply a 2-D slope/FK filter and return to the input domain."""
+    arr = jnp.asarray(data)
+    orig_shape = arr.shape
+    if pad_width:
+        arr = jnp.pad(arr, pad_width)
+    spectrum = dft_kernel(arr, axes=axes, dxs=dxs, real_axis=None)
+    filtered = spectrum * jnp.asarray(mask, dtype=spectrum.dtype)
+    out = idft_kernel(filtered, axes=axes, new_steps=steps, sizes=sizes, real=False)
+    if pad_width:
+        slices = tuple(slice(0, size) for size in orig_shape)
+        out = out[slices]
+    return jnp.real(out)
+
+
+def phase_weighted_stack_kernel(
+    data: Any,
+    *,
+    stack_axis: int,
+    transform_axis: int,
+    power: float,
+    squeeze: bool,
+) -> Any:
+    """Apply phase-weighted stacking over one axis."""
+    arr = jnp.asarray(data)
+    analytic = hilbert_kernel(arr, axis=transform_axis)
+    eps = jnp.finfo(analytic.real.dtype).eps
+    amp = jnp.maximum(jnp.abs(analytic), eps)
+    unit_phasors = analytic / amp
+    mean_phasor = jnp.mean(unit_phasors, axis=stack_axis, keepdims=True)
+    weights = jnp.abs(mean_phasor) ** power
+    out = jnp.mean(arr, axis=stack_axis, keepdims=True) * weights
+    return jnp.squeeze(out, axis=stack_axis) if squeeze else out
+
+
+def velocity_to_strain_rate_edgeless_kernel(
+    data: Any,
+    *,
+    axis: int,
+    step_multiple: int,
+    gauge_length: float,
+) -> Any:
+    """Estimate edgeless strain rate with central differences."""
+    arr = jnp.asarray(data)
+    moved = jnp.moveaxis(arr, axis, 0)
+    out = (moved[step_multiple:] - moved[:-step_multiple]) / gauge_length
+    return jnp.moveaxis(out, 0, axis)
+
+
+def radians_to_strain_kernel(data: Any, factor: float) -> Any:
+    """Scale radians data into strain units."""
+    return jnp.asarray(data) * factor
+
+
+def _interp_along_time(row: jnp.ndarray, sample: jnp.ndarray) -> jnp.ndarray:
+    """Linearly interpolate one trace at fractional sample positions."""
+    nt = row.shape[0]
+    idx = jnp.floor(sample).astype(jnp.int32)
+    valid = (idx >= 0) & (idx + 1 < nt)
+    idx_clip = jnp.clip(idx, 0, max(nt - 2, 0))
+    frac = sample - idx
+    vals = (1.0 - frac) * row[idx_clip] + frac * row[idx_clip + 1]
+    return jnp.where(valid, vals, 0)
+
+
+def tau_p_kernel(
+    data: Any,
+    *,
+    distances: Any,
+    dt: float,
+    p_values: Any,
+) -> Any:
+    """Compute a linear tau-p transform using JAX interpolation."""
+    arr = jnp.asarray(data)
+    distances = jnp.asarray(distances, dtype=arr.real.dtype)
+    distances = distances - distances[0]
+    p_vals = jnp.asarray(p_values, dtype=arr.real.dtype)
+    nt = arr.shape[1]
+    taus = jnp.arange(nt, dtype=arr.real.dtype)
+
+    def _positive(p):
+        samples = taus[None, :] + (p * distances[:, None] / dt)
+        vals = jax.vmap(_interp_along_time)(arr, samples)
+        return jnp.sum(vals, axis=0)
+
+    def _negative(p):
+        rev_arr = arr[::-1]
+        rev_dist = distances[-1] - distances[::-1]
+        samples = taus[None, :] + (p * rev_dist[:, None] / dt)
+        vals = jax.vmap(_interp_along_time)(rev_arr, samples)
+        return jnp.sum(vals, axis=0)
+
+    pos = jax.vmap(_positive)(p_vals)
+    neg = jax.vmap(_negative)(p_vals)[::-1]
+    return jnp.concatenate([neg, pos], axis=0)
+
+
+def dispersion_phase_shift_kernel(
+    data: Any,
+    *,
+    distances: Any,
+    velocities: Any,
+    nf: int,
+    first_live_f: int,
+    last_live_f: int,
+    fs: float,
+) -> Any:
+    """Compute a phase-shift dispersion image."""
+    arr = jnp.asarray(data)
+    dist = jnp.asarray(distances, dtype=arr.real.dtype)
+    velocities = jnp.asarray(velocities, dtype=arr.real.dtype)
+    freqs = jnp.arange(nf, dtype=arr.real.dtype) * fs / (nf - 1)
+    omega = 2 * jnp.pi * freqs
+    fft_d = jnp.fft.fft(arr, n=nf, axis=1)
+    amp = jnp.abs(fft_d)
+    fft_d = jnp.where(amp != 0, fft_d / amp, 0)
+    omega_live = omega[first_live_f:last_live_f]
+    fft_live = fft_d[:, first_live_f:last_live_f]
+    preamb = 1j * dist[:, None] * omega_live[None, :]
+
+    def _velocity_row(velocity):
+        return jnp.abs(jnp.sum(jnp.exp(preamb / velocity) * fft_live, axis=0))
+
+    return jax.vmap(_velocity_row)(velocities) / arr.shape[0]
diff --git a/src/dasjax/kernels/filters.py b/src/dasjax/kernels/filters.py
index 58fe0a6..b671a46 100644
--- a/src/dasjax/kernels/filters.py
+++ b/src/dasjax/kernels/filters.py
@@ -1,4 +1,4 @@
-"""Filter kernels and callback-backed helpers."""
+"""Filter kernels."""
 
 from __future__ import annotations
 
@@ -10,9 +10,14 @@
 import numpy as np
 import pandas as pd
 from dascore.exceptions import FilterValueError
-from scipy import ndimage
-from scipy.ndimage import median_filter as scipy_median_filter
-from scipy.signal import iirfilter, sosfilt_zi, zpk2sos
+from scipy.signal import (
+    iirfilter,
+    iirnotch,
+    lfilter_zi,
+    savgol_coeffs,
+    sosfilt_zi,
+    zpk2sos,
+)
 
 
 def is_finite_array(data: Any) -> bool:
@@ -29,25 +34,110 @@ def gaussian_filter_kernel(
     cval: float = 0.0,
     truncate: float = 4.0,
 ) -> Any:
-    """Apply a Gaussian filter with SciPy-compatible semantics."""
-    # Gaussian filtering still relies on SciPy's exact implementation semantics.
+    """Apply a separable Gaussian filter with JAX-native operations."""
     arr = jnp.asarray(data)
-    # The callback result shape/dtype is identical to the source array.
-    shape_dtype = jax.ShapeDtypeStruct(arr.shape, arr.dtype)
-    return jax.pure_callback(
-        lambda x: ndimage.gaussian_filter(
-            # Force a private NumPy copy so SciPy can mutate internally if needed.
-            np.array(x, copy=True),
-            sigma=sigma,
+    if not sigma or not axes:
+        return arr
+    out = arr
+    for axis, sigma_value in zip(axes, sigma, strict=True):
+        out = _gaussian_filter_axis(
+            out,
+            sigma=float(sigma_value),
+            axis=int(axis),
             mode=mode,
             cval=cval,
             truncate=truncate,
-            axes=axes,
-        ),
-        shape_dtype,
-        arr,
-        vmap_method="sequential",
-    )
+        )
+    return out
+
+
+def _gaussian_filter_axis(
+    data: jnp.ndarray,
+    *,
+    sigma: float,
+    axis: int,
+    mode: str,
+    cval: float,
+    truncate: float,
+) -> jnp.ndarray:
+    """Apply one static 1D Gaussian pass along an axis."""
+    if sigma <= 0:
+        return data
+    radius = int(truncate * sigma + 0.5)
+    if radius == 0:
+        return data
+    x = jnp.arange(-radius, radius + 1, dtype=data.real.dtype)
+    weights = jnp.exp(-0.5 / (sigma * sigma) * x * x)
+    weights = weights / jnp.sum(weights)
+    moved = jnp.moveaxis(data, axis, -1)
+    flat = moved.reshape(-1, moved.shape[-1])
+    padded = _pad_gaussian_axis(flat, radius=radius, mode=mode, cval=cval)
+
+    def _convolve(row: jnp.ndarray) -> jnp.ndarray:
+        return jnp.convolve(row, weights, mode="valid")
+
+    filtered = jax.vmap(_convolve)(padded)
+    return jnp.moveaxis(filtered.reshape(moved.shape), -1, axis)
+
+
+def _pad_gaussian_axis(
+    data: jnp.ndarray,
+    *,
+    radius: int,
+    mode: str,
+    cval: float,
+) -> jnp.ndarray:
+    """Pad flattened rows with SciPy ndimage-compatible mode names."""
+    pad_width = ((0, 0), (radius, radius))
+    if mode == "reflect":
+        return jnp.pad(data, pad_width, mode="symmetric")
+    if mode == "nearest":
+        return jnp.pad(data, pad_width, mode="edge")
+    if mode == "constant":
+        return jnp.pad(data, pad_width, mode="constant", constant_values=cval)
+    if mode == "wrap":
+        return jnp.pad(data, pad_width, mode="wrap")
+    if mode == "mirror":
+        return jnp.pad(data, pad_width, mode="reflect")
+    msg = f"Unsupported gaussian_filter mode {mode!r}."
+    raise ValueError(msg)
+
+
+def _normalize_filter_mode(mode: str) -> str:
+    """Normalize SciPy ndimage-style mode aliases."""
+    aliases = {
+        "grid-constant": "constant",
+        "grid-mirror": "reflect",
+        "grid-wrap": "wrap",
+    }
+    return aliases.get(mode, mode)
+
+
+def _pad_axis(
+    data: jnp.ndarray,
+    *,
+    axis: int,
+    before: int,
+    after: int,
+    mode: str,
+    cval: float = 0.0,
+) -> jnp.ndarray:
+    """Pad one axis with SciPy ndimage-compatible mode names."""
+    pad_width = [(0, 0)] * data.ndim
+    pad_width[axis] = (before, after)
+    mode = _normalize_filter_mode(mode)
+    if mode == "reflect":
+        return jnp.pad(data, tuple(pad_width), mode="symmetric")
+    if mode == "nearest":
+        return jnp.pad(data, tuple(pad_width), mode="edge")
+    if mode == "constant":
+        return jnp.pad(data, tuple(pad_width), mode="constant", constant_values=cval)
+    if mode == "wrap":
+        return jnp.pad(data, tuple(pad_width), mode="wrap")
+    if mode == "mirror":
+        return jnp.pad(data, tuple(pad_width), mode="reflect")
+    msg = f"Unsupported filter mode {mode!r}."
+    raise ValueError(msg)
 
 
 def _sliding_windows_last_axis(data: jnp.ndarray, window: int) -> jnp.ndarray:
@@ -69,88 +159,90 @@ def _slice_at(idx: jnp.ndarray) -> jnp.ndarray:
     return jnp.swapaxes(windows, 0, 1)
 
 
-def _median_filter_axis(data: jnp.ndarray, axis: int, window: int) -> jnp.ndarray:
-    # Reduce the target axis to the last position so the window helper can be reused.
-    moved = jnp.moveaxis(data, axis, -1)
-    flat = moved.reshape(-1, moved.shape[-1])
-    windows = _sliding_windows_last_axis(flat, window)
-    # Sorting the small window and taking the center reproduces a median.
-    med = jnp.sort(windows, axis=-1)[..., window // 2]
-    restored = med.reshape(moved.shape)
-    return jnp.moveaxis(restored, -1, axis)
+def _sliding_windows_nd(
+    data: jnp.ndarray,
+    size: tuple[int, ...],
+    out_shape: tuple[int, ...],
+) -> jnp.ndarray:
+    """Return flattened N-D windows for every unpadded output element."""
+    out_size = int(np.prod(out_shape))
+    starts = jnp.stack(jnp.unravel_index(jnp.arange(out_size), out_shape), axis=1)
 
+    def _slice_at(start: jnp.ndarray) -> jnp.ndarray:
+        return lax.dynamic_slice(data, tuple(start), size).reshape(-1)
 
-def _median_filter_exact_callback(
-    data: np.ndarray, size: tuple[int, ...]
-) -> np.ndarray:
-    return scipy_median_filter(data, size=size, mode="reflect")
+    return jax.vmap(_slice_at)(starts).reshape(*out_shape, int(np.prod(size)))
 
 
-def _median_filter_exact(data: jnp.ndarray, size: tuple[int, ...]) -> jnp.ndarray:
-    # The exact multidimensional SciPy median is still callback-backed.
-    shape_dtype = jax.ShapeDtypeStruct(data.shape, data.dtype)
-    return jax.pure_callback(
-        lambda x: _median_filter_exact_callback(x, size),
-        shape_dtype,
+def _window_sum_kernel(data: jnp.ndarray, size: tuple[int, ...]) -> jnp.ndarray:
+    """Sum zero-padded local windows in SciPy signal-correlate style."""
+    before = tuple(window // 2 for window in size)
+    after = tuple(window - 1 - pad for window, pad in zip(size, before, strict=True))
+    return lax.reduce_window(
         data,
-        vmap_method="sequential",
+        jnp.asarray(0, dtype=data.dtype),
+        lax.add,
+        window_dimensions=tuple(int(x) for x in size),
+        window_strides=(1,) * data.ndim,
+        padding=tuple(zip(before, after, strict=True)),
     )
 
 
-def hampel_filter_callback_kernel(
+def median_filter_kernel(
     data: Any,
     size: tuple[int, ...],
-    threshold: float,
-    approximate: bool = True,
+    mode: str = "reflect",
+    cval: float = 0.0,
 ) -> Any:
-    """Apply Hampel filtering via SciPy-compatible host callback."""
-    source = jnp.asarray(data)
-    # The callback preserves both shape and dtype of the incoming array.
-    shape_dtype = jax.ShapeDtypeStruct(source.shape, source.dtype)
-
-    def _callback(x: np.ndarray) -> np.ndarray:
-        original = np.asarray(x)
-        is_int = original.dtype.kind in {"i", "u"}
-        # Integer inputs are promoted for robust MAD math, then cast back on exit.
-        work = original.copy() if not is_int else original.astype(np.float32)
-        if approximate:
-            # Approximate mode applies separable 1D median filters per axis.
-            med = np.empty_like(work)
-            np.copyto(med, work)
-            for axis, window in enumerate(size):
-                if window > 1:
-                    filtered = scipy_median_filter(
-                        med,
-                        size=tuple(1 if i != axis else window for i in range(med.ndim)),
-                        mode="reflect",
-                    )
-                    np.copyto(med, filtered)
-            abs_diff = np.abs(work - med)
-            # Reuse the same separable strategy for the MAD estimate.
-            mad = np.empty_like(abs_diff)
-            np.copyto(mad, abs_diff)
-            for axis, window in enumerate(size):
-                if window > 1:
-                    filtered = scipy_median_filter(
-                        mad,
-                        size=tuple(1 if i != axis else window for i in range(mad.ndim)),
-                        mode="reflect",
-                    )
-                    np.copyto(mad, filtered)
-        else:
-            # Exact mode delegates the full multidimensional median to SciPy.
-            med = scipy_median_filter(work, size=size, mode="reflect")
-            abs_diff = np.abs(work - med)
-            mad = scipy_median_filter(abs_diff, size=size, mode="reflect")
-        # Replace zeros to avoid divide-by-zero when a local window is constant.
-        mad_safe = np.where(mad == 0.0, np.finfo(work.dtype).eps, mad)
-        out = np.where(abs_diff / mad_safe > threshold, med, work)
-        if is_int:
-            # Integer inputs round back to the nearest representable sample value.
-            out = np.rint(out)
-        return out.astype(original.dtype, copy=False)
-
-    return jax.pure_callback(_callback, shape_dtype, source, vmap_method="sequential")
+    """Apply an exact N-D median filter with JAX-native windows."""
+    arr = jnp.asarray(data)
+    if all(window == 1 for window in size):
+        return arr
+    before = tuple(window // 2 for window in size)
+    after = tuple(window - 1 - pad for window, pad in zip(size, before, strict=True))
+    padded = arr
+    for axis, (left, right) in enumerate(zip(before, after, strict=True)):
+        if left or right:
+            padded = _pad_axis(
+                padded,
+                axis=axis,
+                before=left,
+                after=right,
+                mode=mode,
+                cval=cval,
+            )
+    windows = _sliding_windows_nd(padded, tuple(int(x) for x in size), tuple(arr.shape))
+    return jnp.sort(windows, axis=-1)[..., windows.shape[-1] // 2]
+
+
+def wiener_filter_kernel(
+    data: Any,
+    size: tuple[int, ...],
+    noise: float | None = None,
+) -> Any:
+    """Apply an N-D Wiener filter matching SciPy's local-statistic formula."""
+    arr = jnp.asarray(data)
+    window_size = float(np.prod(size))
+    local_mean = _window_sum_kernel(arr, size) / window_size
+    local_var = (
+        _window_sum_kernel(arr * arr, size) / window_size - local_mean * local_mean
+    )
+    noise_value = (
+        jnp.mean(local_var) if noise is None else jnp.asarray(noise, dtype=arr.dtype)
+    )
+    res = (arr - local_mean) * (1 - noise_value / local_var) + local_mean
+    return jnp.where(local_var < noise_value, local_mean, res)
+
+
+def _median_filter_axis(data: jnp.ndarray, axis: int, window: int) -> jnp.ndarray:
+    # Reduce the target axis to the last position so the window helper can be reused.
+    moved = jnp.moveaxis(data, axis, -1)
+    flat = moved.reshape(-1, moved.shape[-1])
+    windows = _sliding_windows_last_axis(flat, window)
+    # Sorting the small window and taking the center reproduces a median.
+    med = jnp.sort(windows, axis=-1)[..., window // 2]
+    restored = med.reshape(moved.shape)
+    return jnp.moveaxis(restored, -1, axis)
 
 
 def hampel_filter_kernel(
@@ -160,28 +252,25 @@ def hampel_filter_kernel(
     approximate: bool = True,
 ) -> Any:
     """Apply a Hampel filter with a native JAX approximate path."""
+    if not approximate:
+        msg = "Exact Hampel median filtering is not implemented in pure JAX."
+        raise NotImplementedError(msg)
     source = jnp.asarray(data)
     is_int = jnp.issubdtype(source.dtype, jnp.integer)
-    # Mirror the callback path by promoting integers before the MAD computation.
+    # Promote integers before robust MAD math, then cast back on exit.
     compute_dtype = jnp.float32 if is_int else source.dtype
     work = source.astype(compute_dtype)
-    if approximate:
-        # Separable medians keep the kernel JAX-native and reasonably cheap.
-        med = work
-        for axis, window in enumerate(size):
-            if window > 1:
-                med = _median_filter_axis(med, axis, window)
-        abs_diff = jnp.abs(work - med)
-        mad = abs_diff
-        # Apply the same separable median strategy to absolute deviations.
-        for axis, window in enumerate(size):
-            if window > 1:
-                mad = _median_filter_axis(mad, axis, window)
-    else:
-        # The exact path falls back to the SciPy callback helper above.
-        med = _median_filter_exact(work, size)
-        abs_diff = jnp.abs(work - med)
-        mad = _median_filter_exact(abs_diff, size)
+    # Separable medians keep the kernel JAX-native and reasonably cheap.
+    med = work
+    for axis, window in enumerate(size):
+        if window > 1:
+            med = _median_filter_axis(med, axis, window)
+    abs_diff = jnp.abs(work - med)
+    mad = abs_diff
+    # Apply the same separable median strategy to absolute deviations.
+    for axis, window in enumerate(size):
+        if window > 1:
+            mad = _median_filter_axis(mad, axis, window)
     # Protect constant windows from generating infinities.
     mad_safe = jnp.where(mad == 0.0, jnp.finfo(work.dtype).eps, mad)
     out = jnp.where(abs_diff / mad_safe > threshold, med, work)
@@ -191,6 +280,235 @@ def hampel_filter_kernel(
     return out
 
 
+def sobel_filter_kernel(
+    data: Any,
+    axis: int,
+    mode: str = "reflect",
+    cval: float = 0.0,
+) -> Any:
+    """Apply a SciPy-compatible Sobel filter along one axis."""
+    arr = jnp.asarray(data)
+    out = arr
+    for dim_axis in range(arr.ndim):
+        weights = (
+            jnp.asarray([-1.0, 0.0, 1.0], dtype=arr.dtype)
+            if dim_axis == axis
+            else jnp.asarray([1.0, 2.0, 1.0], dtype=arr.dtype)
+        )
+        out = _correlate1d_kernel(out, weights, axis=dim_axis, mode=mode, cval=cval)
+    return out
+
+
+def _correlate1d_kernel(
+    data: jnp.ndarray,
+    weights: jnp.ndarray,
+    *,
+    axis: int,
+    mode: str,
+    cval: float,
+) -> jnp.ndarray:
+    """Apply 1-D correlation over one axis."""
+    radius = weights.shape[0] // 2
+    padded = _pad_axis(
+        data,
+        axis=axis,
+        before=radius,
+        after=radius,
+        mode=mode,
+        cval=cval,
+    )
+    moved = jnp.moveaxis(padded, axis, -1)
+    flat = moved.reshape(-1, moved.shape[-1])
+
+    def _correlate(row: jnp.ndarray) -> jnp.ndarray:
+        return jnp.convolve(row, weights[::-1], mode="valid")
+
+    filtered = jax.vmap(_correlate)(flat)
+    out_shape = (*moved.shape[:-1], data.shape[axis])
+    return jnp.moveaxis(filtered.reshape(out_shape), -1, axis)
+
+
+def _savgol_filter_axis(
+    data: jnp.ndarray,
+    *,
+    axis: int,
+    coeffs: Any,
+    left_coeffs: Any,
+    right_coeffs: Any,
+    mode: str,
+    cval: float,
+) -> jnp.ndarray:
+    """Apply one Savitzky-Golay filter pass along an axis."""
+    coeff_arr = jnp.asarray(coeffs, dtype=data.dtype)
+    window = int(coeff_arr.shape[0])
+    half = window // 2
+    moved = jnp.moveaxis(data, axis, -1)
+    flat = moved.reshape(-1, moved.shape[-1])
+    if flat.shape[1] < window:
+        msg = "savgol_filter window_length must be less than or equal to axis length."
+        raise ValueError(msg)
+
+    def _valid_convolve(row: jnp.ndarray) -> jnp.ndarray:
+        return jnp.convolve(row, coeff_arr, mode="valid")
+
+    middle = jax.vmap(_valid_convolve)(flat)
+    if mode == "interp":
+        left = jnp.einsum(
+            "hw,rw->rh", jnp.asarray(left_coeffs, dtype=data.dtype), flat[:, :window]
+        )
+        right = jnp.einsum(
+            "hw,rw->rh", jnp.asarray(right_coeffs, dtype=data.dtype), flat[:, -window:]
+        )
+        out_flat = jnp.concatenate([left, middle, right], axis=1)
+    else:
+        padded = _pad_axis(
+            flat,
+            axis=1,
+            before=half,
+            after=half,
+            mode=mode,
+            cval=cval,
+        )
+        out_flat = jax.vmap(_valid_convolve)(padded)
+    return jnp.moveaxis(out_flat.reshape(moved.shape), -1, axis)
+
+
+def savgol_filter_kernel(
+    data: Any,
+    size: tuple[int, ...],
+    axes: tuple[int, ...],
+    coeffs: tuple[Any, ...],
+    left_coeffs: tuple[Any, ...],
+    right_coeffs: tuple[Any, ...],
+    mode: str = "interp",
+    cval: float = 0.0,
+) -> Any:
+    """Apply Savitzky-Golay filters sequentially along requested axes."""
+    out = jnp.asarray(data)
+    for axis, coeff, left, right in zip(
+        axes, coeffs, left_coeffs, right_coeffs, strict=True
+    ):
+        _ = size
+        out = _savgol_filter_axis(
+            out,
+            axis=axis,
+            coeffs=coeff,
+            left_coeffs=left,
+            right_coeffs=right,
+            mode=mode,
+            cval=cval,
+        )
+    return out
+
+
+def savgol_coefficients(
+    window_length: int, polyorder: int
+) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """Return center and interp-edge Savitzky-Golay coefficients."""
+    coeff = np.asarray(
+        savgol_coeffs(window_length, polyorder, use="conv"), dtype=np.float64
+    )
+    half = window_length // 2
+    left = np.asarray(
+        [
+            savgol_coeffs(window_length, polyorder, pos=idx, use="dot")
+            for idx in range(half)
+        ],
+        dtype=np.float64,
+    )
+    right = np.asarray(
+        [
+            savgol_coeffs(window_length, polyorder, pos=idx, use="dot")
+            for idx in range(window_length - half, window_length)
+        ],
+        dtype=np.float64,
+    )
+    return coeff, left, right
+
+
+def design_notch_filter(
+    sr: float,
+    w0: float,
+    q: float,
+) -> tuple[np.ndarray, np.ndarray, np.ndarray, int]:
+    """Design a second-order notch filter and return filtfilt parameters."""
+    nyquist = 0.5 * sr
+    if w0 > nyquist:
+        msg = f"possible filter values are in [0, {nyquist}] you passed {w0}"
+        raise FilterValueError(msg)
+    b, a = iirnotch(w0, Q=q, fs=sr)
+    zi = lfilter_zi(b, a)
+    padlen = 3 * max(len(a), len(b))
+    return (
+        np.asarray(b, dtype=np.float64),
+        np.asarray(a, dtype=np.float64),
+        np.asarray(zi, dtype=np.float64),
+        padlen,
+    )
+
+
+def _iirfilt_rows(
+    flat: jnp.ndarray,
+    b: jnp.ndarray,
+    a: jnp.ndarray,
+    zi_rows: jnp.ndarray | None = None,
+) -> tuple[jnp.ndarray, jnp.ndarray]:
+    """Apply one direct-form II IIR filter to flattened rows."""
+    b = b / a[0]
+    a = a / a[0]
+    if zi_rows is None:
+        states = jnp.zeros((flat.shape[0], b.shape[0] - 1), dtype=flat.dtype)
+    else:
+        states = zi_rows
+
+    def _sample_step(carry: jnp.ndarray, x_t: jnp.ndarray):
+        y = b[0] * x_t + carry[:, 0]
+        new_states = []
+        for idx in range(1, b.shape[0] - 1):
+            new_states.append(b[idx] * x_t - a[idx] * y + carry[:, idx])
+        new_states.append(b[-1] * x_t - a[-1] * y)
+        return jnp.stack(new_states, axis=1), y
+
+    final_states, ys = lax.scan(_sample_step, states, flat.T)
+    return ys.T, final_states
+
+
+def notch_filter_kernel(
+    data: Any,
+    b: Any,
+    a: Any,
+    zi: Any,
+    padlen: int,
+    axis: int,
+) -> Any:
+    """Apply a zero-phase second-order notch filter."""
+    arr = jnp.asarray(data)
+    moved = jnp.moveaxis(arr, axis, -1)
+    flat = moved.reshape(-1, moved.shape[-1])
+    edge = int(padlen)
+    if edge > 0 and flat.shape[1] <= edge:
+        msg = (
+            f"The length of the input vector x must be greater than padlen, "
+            f"which is {edge}."
+        )
+        raise ValueError(msg)
+    ext = _odd_ext_last_axis(flat, edge)
+    b_arr = jnp.asarray(b, dtype=arr.dtype)
+    a_arr = jnp.asarray(a, dtype=arr.dtype)
+    zi_arr = jnp.asarray(zi, dtype=arr.dtype)
+    zi_rows = jnp.broadcast_to(zi_arr[None, :], (ext.shape[0], zi_arr.shape[0]))
+    x0 = ext[:, :1]
+    y_flat, _ = _iirfilt_rows(ext, b_arr, a_arr, zi_rows=zi_rows * x0)
+    y0 = y_flat[:, -1:]
+    y_rev = jnp.flip(y_flat, axis=1)
+    y2_flat, _ = _iirfilt_rows(y_rev, b_arr, a_arr, zi_rows=zi_rows * y0)
+    out_flat = jnp.flip(y2_flat, axis=1)
+    if edge > 0:
+        out_flat = out_flat[:, edge:-edge]
+    out = out_flat.reshape(moved.shape)
+    return jnp.moveaxis(out, -1, axis)
+
+
 def design_pass_filter_sos(
     sr: float,
     filt_min: float | None,
diff --git a/src/dasjax/kernels/signal.py b/src/dasjax/kernels/signal.py
index ee6acd3..8104fb0 100644
--- a/src/dasjax/kernels/signal.py
+++ b/src/dasjax/kernels/signal.py
@@ -31,7 +31,8 @@ def detrend_kernel(data: Any, axis: int, type: str) -> Any:
     detrend_type = validate_detrend_type(type)
     # Constant detrending is just mean subtraction along the selected axis.
     if detrend_type == "constant":
-        return data - jnp.mean(data, axis=axis, keepdims=True)
+        mean = jnp.sum(data, axis=axis, keepdims=True) / data.shape[axis]
+        return data - mean
 
     # Move the target axis to the front so the regression math is 1D in layout.
     moved = jnp.moveaxis(data, axis, 0)
diff --git a/src/dasjax/kernels/spectral.py b/src/dasjax/kernels/spectral.py
index e15bb0d..47e06cd 100644
--- a/src/dasjax/kernels/spectral.py
+++ b/src/dasjax/kernels/spectral.py
@@ -56,7 +56,7 @@ def dft_kernel(
     """Apply a scaled DFT over one or more axes."""
     arr = jnp.asarray(data)
     # Multiply by sample spacing so forward and inverse transforms stay consistent.
-    scale_factor = np.prod(dxs)
+    scale_factor = jnp.asarray(np.prod(dxs), dtype=arr.real.dtype)
     if real_axis is None:
         fft_data = jnp.fft.fftn(arr, axes=axes) * scale_factor
         # Shift zero frequency to the center on fully complex transforms.
@@ -78,7 +78,7 @@ def idft_kernel(
     """Apply a scaled inverse DFT over one or more axes."""
     arr = jnp.asarray(data)
     # Undo the forward scaling using the frequency-domain step sizes.
-    scale_factor = np.prod(new_steps)
+    scale_factor = jnp.asarray(np.prod(new_steps), dtype=arr.real.dtype)
     if real:
         real_axis = axes[-1]
         # Only the non-rfft axes were shifted in the forward real transform.
@@ -127,6 +127,29 @@ def whiten_kernel(
         fft_data = jnp.fft.rfft(moved, axis=-1)
     else:
         fft_data = jnp.fft.fft(moved, axis=-1)
+    phase_only = whiten_spectrum_kernel(
+        fft_data,
+        axis=-1,
+        window_len=window_len,
+        water_level=water_level,
+        freq_weight=freq_weight,
+    )
+    if is_real:
+        out = jnp.fft.irfft(phase_only, n=moved.shape[-1], axis=-1)
+    else:
+        out = jnp.fft.ifft(phase_only, axis=-1)
+    return jnp.moveaxis(out, -1, axis)
+
+
+def whiten_spectrum_kernel(
+    data: Any,
+    axis: int,
+    window_len: int | None = None,
+    water_level: float | None = None,
+    freq_weight: Any | None = None,
+) -> Any:
+    """Whiten already transformed frequency-domain data."""
+    fft_data = jnp.moveaxis(jnp.asarray(data), axis, -1)
     amp = jnp.abs(fft_data)
     if window_len is None:
         # The unsmoothed case is straight phase-only whitening.
@@ -136,7 +159,7 @@ def whiten_kernel(
         env = _uniform_wrap_kernel(amp, window_len)
         if water_level is not None:
             # Water-level clipping prevents deep spectral notches from exploding.
-            min_level = water_level * jnp.max(env, axis=-1, keepdims=True)
+            min_level = water_level * jnp.max(env)
             env = jnp.maximum(env, min_level)
         norm_amp = jnp.where(env != 0, env, 1)
     phase_only = fft_data / norm_amp
@@ -145,11 +168,18 @@ def whiten_kernel(
         phase_only = apply_1d_weight_kernel(
             phase_only, axis=phase_only.ndim - 1, weight=freq_weight
         )
-    if is_real:
-        out = jnp.fft.irfft(phase_only, n=moved.shape[-1], axis=-1)
-    else:
-        out = jnp.fft.ifft(phase_only, axis=-1)
-    return jnp.moveaxis(out, -1, axis)
+    return jnp.moveaxis(phase_only, -1, axis)
+
+
+def correlate_shift_kernel(
+    data: Any,
+    axis: int,
+    step: float,
+    undo_weighting: bool = True,
+) -> Any:
+    """Shift correlation lags back to centered order."""
+    out = jnp.fft.fftshift(jnp.asarray(data), axes=axis)
+    return out / step if undo_weighting else out
 
 
 def _extract_zero_padded_frames(
diff --git a/src/dasjax/operations/__init__.py b/src/dasjax/operations/__init__.py
index 1733457..b485f77 100644
--- a/src/dasjax/operations/__init__.py
+++ b/src/dasjax/operations/__init__.py
@@ -1,23 +1,154 @@
-"""Operation registry package."""
+"""Registered patch operations grouped by DASCore operation domain."""
 
-from .patch_ops import EagerPatchOp, OpResult, PatchOp, PatchSpec, PatchState
-from .registry import (
-    get_operation,
-    iter_operations,
-    list_operations,
+from __future__ import annotations
+
+from .basic import (
+    Abs,
+    Add,
+    Aggregate,
+    Angle,
+    All,
+    AnyOp,
+    Clip,
+    Conj,
+    Divide,
+    Exp,
+    FillNa,
+    Flip,
+    Identity,
+    Imag,
+    IsFinite,
+    IsInf,
+    IsNan,
+    Log,
+    Log10,
+    Log2,
+    Max,
+    Maximum,
+    Mean,
+    Median,
+    Min,
+    Minimum,
+    Multiply,
+    Real,
+    Roll,
+    Scale,
+    Standardize,
+    Std,
+    Subtract,
+    Sum,
+    Where,
+)
+from .detrend import Detrend
+from .correlate import CorrelateShift
+from .dispersion import DispersionPhaseShift
+from .normalize import Normalize
+from .differentiate import Differentiate
+from .integrate import Integrate
+from .taper import Taper, TaperRange
+from .filter import (
+    GaussianFilter,
+    HampelFilter,
+    MedianFilter,
+    NotchFilter,
+    PassFilter,
+    SavgolFilter,
+    SobelFilter,
+    SlopeFilter,
+    WienerFilter,
+)
+from .mute import LineMute, SlopeMute
+from .pad import Pad
+from .hilbert import Envelope, Hilbert, PhaseWeightedStack
+from .fourier import Dft, Idft
+from .whiten import Whiten
+from .spectro import Fbe
+from .strain import (
+    RadiansToStrain,
+    VelocityToStrainRate,
+    VelocityToStrainRateEdgeless,
+)
+from .taup import TauP
+from .numeric import (
+    Correlate,
+    Decimate,
+    Interpolate,
+    Istft,
+    Resample,
+    Stft,
 )
-from .types import ExecutionPolicy, OperationCase, OperationSpec
 
 __all__ = [
-    "ExecutionPolicy",
-    "EagerPatchOp",
-    "OpResult",
-    "OperationCase",
-    "OperationSpec",
-    "PatchOp",
-    "PatchSpec",
-    "PatchState",
-    "get_operation",
-    "iter_operations",
-    "list_operations",
+    "Abs",
+    "Add",
+    "Aggregate",
+    "All",
+    "Angle",
+    "AnyOp",
+    "Clip",
+    "Conj",
+    "Correlate",
+    "CorrelateShift",
+    "Decimate",
+    "Detrend",
+    "DispersionPhaseShift",
+    "Divide",
+    "Dft",
+    "Differentiate",
+    "Envelope",
+    "Exp",
+    "Fbe",
+    "FillNa",
+    "Flip",
+    "GaussianFilter",
+    "HampelFilter",
+    "Hilbert",
+    "Identity",
+    "Idft",
+    "Imag",
+    "Integrate",
+    "Interpolate",
+    "IsFinite",
+    "IsInf",
+    "IsNan",
+    "Istft",
+    "LineMute",
+    "Log",
+    "Log10",
+    "Log2",
+    "Max",
+    "Maximum",
+    "Mean",
+    "Median",
+    "MedianFilter",
+    "Min",
+    "Minimum",
+    "Multiply",
+    "NotchFilter",
+    "Normalize",
+    "Pad",
+    "PassFilter",
+    "PhaseWeightedStack",
+    "RadiansToStrain",
+    "Real",
+    "Resample",
+    "Roll",
+    "Scale",
+    "SavgolFilter",
+    "SobelFilter",
+    "SlopeFilter",
+    "SlopeMute",
+    "Standardize",
+    "Std",
+    "Stft",
+    "Subtract",
+    "Sum",
+    "Taper",
+    "TaperRange",
+    "TauP",
+    "VelocityToStrainRate",
+    "Where",
+    "VelocityToStrainRateEdgeless",
+    "Whiten",
+    "WienerFilter",
 ]
diff --git a/src/dasjax/operations/basic.py b/src/dasjax/operations/basic.py
new file mode 100644
index 0000000..5662fc7
--- /dev/null
+++ b/src/dasjax/operations/basic.py
@@ -0,0 +1,505 @@
+"""Basic DASCore-style patch operations."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, ClassVar, Self
+
+import jax.numpy as jnp
+from dascore.utils.misc import iterate
+
+from dasjax.core import PatchBoundary, PatchOperation, PatchPyTree
+
+from .. import kernels
+from .common import dummy_patch, replace, tree_boundary_from_patch
+
+
+@dataclass(frozen=True)
+class Identity(PatchOperation):
+    """Return a patch unchanged."""
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        return patch_tree.new(data=kernels.identity_kernel(patch_tree.data))
+
+
+@dataclass(frozen=True)
+class Scale(PatchOperation):
+    """Scale patch data by a constant factor."""
+
+    factor: float
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        return patch_tree.new(data=kernels.scale_kernel(patch_tree.data, self.factor))
+
+
+@dataclass(frozen=True)
+class Add(PatchOperation):
+    """Add a constant value to patch data."""
+
+    value: float
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        return patch_tree.new(data=kernels.add_kernel(patch_tree.data, self.value))
+
+
+@dataclass(frozen=True)
+class Subtract(PatchOperation):
+    """Subtract a value from patch data."""
+
+    other: Any
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        return patch_tree.new(data=jnp.asarray(patch_tree.data) - self.other)
+
+
+@dataclass(frozen=True)
+class Multiply(PatchOperation):
+    """Multiply patch data by a value."""
+
+    other: Any
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        return patch_tree.new(data=jnp.asarray(patch_tree.data) * self.other)
+
+
+@dataclass(frozen=True)
+class Divide(PatchOperation):
+    """Divide patch data by a value."""
+
+    other: Any
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        return patch_tree.new(data=jnp.asarray(patch_tree.data) / self.other)
+
+
+@dataclass(frozen=True)
+class Maximum(PatchOperation):
+    """Return elementwise maximum of patch data and a value."""
+
+    other: Any
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        return patch_tree.new(
+            data=jnp.maximum(jnp.asarray(patch_tree.data), self.other)
+        )
+
+
+@dataclass(frozen=True)
+class Minimum(PatchOperation):
+    """Return elementwise minimum of patch data and a value."""
+
+    other: Any
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        return patch_tree.new(
+            data=jnp.minimum(jnp.asarray(patch_tree.data), self.other)
+        )
+
+
+@dataclass(frozen=True)
+class Abs(PatchOperation):
+    """Take absolute value of patch data."""
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        return patch_tree.new(data=kernels.abs_kernel(patch_tree.data))
+
+
+@dataclass(frozen=True)
+class Clip(PatchOperation):
+    """Clip patch data to a fixed range."""
+
+    min_value: float
+    max_value: float
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        return patch_tree.new(
+            data=kernels.clip_kernel(patch_tree.data, self.min_value, self.max_value)
+        )
+
+
+@dataclass(frozen=True)
+class Real(PatchOperation):
+    """Return the real component of patch data."""
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        return patch_tree.new(data=kernels.real_kernel(patch_tree.data))
+
+
+@dataclass(frozen=True)
+class Imag(PatchOperation):
+    """Return the imaginary component of patch data."""
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        return patch_tree.new(data=kernels.imag_kernel(patch_tree.data))
+
+
+@dataclass(frozen=True)
+class Angle(PatchOperation):
+    """Return the phase angle of patch data."""
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        return patch_tree.new(data=kernels.angle_kernel(patch_tree.data))
+
+
+@dataclass(frozen=True)
+class Conj(PatchOperation):
+    """Return the complex conjugate of patch data."""
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        return patch_tree.new(data=kernels.conj_kernel(patch_tree.data))
+
+
+@dataclass(frozen=True)
+class Exp(PatchOperation):
+    """Apply exponential to patch data."""
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        return patch_tree.new(data=jnp.exp(jnp.asarray(patch_tree.data)))
+
+
+@dataclass(frozen=True)
+class Log(PatchOperation):
+    """Apply natural logarithm to patch data."""
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        return patch_tree.new(data=jnp.log(jnp.asarray(patch_tree.data)))
+
+
+@dataclass(frozen=True)
+class Log10(PatchOperation):
+    """Apply base-10 logarithm to patch data."""
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        return patch_tree.new(data=jnp.log10(jnp.asarray(patch_tree.data)))
+
+
+@dataclass(frozen=True)
+class Log2(PatchOperation):
+    """Apply base-2 logarithm to patch data."""
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        return patch_tree.new(data=jnp.log2(jnp.asarray(patch_tree.data)))
+
+
+@dataclass(frozen=True)
+class IsFinite(PatchOperation):
+    """Return a finite-value mask for patch data."""
+
+    method_name: ClassVar[str | None] = "is_finite"
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        return patch_tree.new(data=jnp.isfinite(jnp.asarray(patch_tree.data)))
+
+
+@dataclass(frozen=True)
+class IsInf(PatchOperation):
+    """Return an infinite-value mask for patch data."""
+
+    method_name: ClassVar[str | None] = "isinf"
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        return patch_tree.new(data=jnp.isinf(jnp.asarray(patch_tree.data)))
+
+
+@dataclass(frozen=True)
+class IsNan(PatchOperation):
+    """Return a NaN-value mask for patch data."""
+
+    method_name: ClassVar[str | None] = "isnan"
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        return patch_tree.new(data=jnp.isnan(jnp.asarray(patch_tree.data)))
+
+
+@dataclass(frozen=True)
+class FillNa(PatchOperation):
+    """Fill NaN, and optionally infinite, values in patch data."""
+
+    method_name: ClassVar[str | None] = "fillna"
+    value: Any
+    include_inf: bool = True
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        data = jnp.asarray(patch_tree.data)
+        mask = jnp.isnan(data)
+        if self.include_inf:
+            mask = mask | jnp.isinf(data)
+        return patch_tree.new(data=jnp.where(mask, self.value, data))
+
+
+@dataclass(frozen=True)
+class Where(PatchOperation):
+    """Select patch data where a condition is true, otherwise use another value."""
+
+    cond: Any
+    other: Any = jnp.nan
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        cond = self.cond.data if hasattr(self.cond, "coords") else self.cond
+        other = self.other.data if hasattr(self.other, "coords") else self.other
+        return patch_tree.new(data=jnp.where(cond, patch_tree.data, other))
+
+
+@dataclass(frozen=True)
+class Flip(PatchOperation):
+    """Flip data and, optionally, associated coordinate values."""
+
+    dims: tuple[str, ...] = ()
+    flip_coords: bool = True
+    axes: tuple[int, ...] = ()
+    coord_axes: tuple[tuple[int, tuple[int, ...]], ...] = ()
+
+    def __init__(self, *dims: str, flip_coords: bool = True):
+        object.__setattr__(self, "dims", tuple(dims))
+        object.__setattr__(self, "flip_coords", flip_coords)
+        object.__setattr__(self, "axes", ())
+        object.__setattr__(self, "coord_axes", ())
+
+    def bind(self, boundary: PatchBoundary) -> Self:
+        dims = self.dims or boundary.dims
+        axes = tuple(boundary.axis(dim) for dim in dims)
+        coord_axes = []
+        if self.flip_coords:
+            for name in boundary.coord_names:
+                axes_for_coord = tuple(
+                    idx
+                    for idx, coord_dim in enumerate(boundary.coord_dims(name))
+                    if coord_dim in dims
+                )
+                if axes_for_coord:
+                    coord_axes.append((boundary.coord_index(name), axes_for_coord))
+        return replace(self, dims=dims, axes=axes, coord_axes=tuple(coord_axes))
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        data = kernels.flip_kernel(patch_tree.data, self.axes)
+        coords = patch_tree.coord_values
+        if self.flip_coords:
+            for index, axes in self.coord_axes:
+                coords = tuple(
+                    jnp.flip(value, axis=axes) if idx == index else value
+                    for idx, value in enumerate(coords)
+                )
+        return patch_tree.new(data=data, coords=coords)
+
+
+@dataclass(frozen=True)
+class Roll(PatchOperation):
+    """Roll data along one dimension."""
+
+    samples: bool = False
+    update_coord: bool = False
+    kwargs: dict[str, Any] | None = None
+    axis: int | None = None
+    shift: int | None = None
+
+    def __init__(
+        self,
+        samples: bool = False,
+        update_coord: bool = False,
+        **kwargs,
+    ):
+        object.__setattr__(self, "samples", samples)
+        object.__setattr__(self, "update_coord", update_coord)
+        object.__setattr__(self, "kwargs", dict(kwargs))
+        object.__setattr__(self, "axis", None)
+        object.__setattr__(self, "shift", None)
+
+    def bind(self, boundary: PatchBoundary) -> Self:
+        if self.update_coord:
+            raise NotImplementedError(
+                "Compiled roll currently requires update_coord=False."
+            )
+        kwargs = self.kwargs or {}
+        dim = next(key for key in kwargs if key in boundary.dims)
+        coord = boundary.coord(dim)
+        return replace(
+            self,
+            axis=boundary.axis(dim),
+            shift=int(coord.get_sample_count(kwargs[dim], samples=self.samples)),
+        )
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        assert self.axis is not None and self.shift is not None
+        return patch_tree.new(
+            data=kernels.roll_kernel(patch_tree.data, self.shift, self.axis)
+        )
+
+
+@dataclass(frozen=True)
+class Standardize(PatchOperation):
+    """Standardize patch data along one dimension."""
+
+    dim: str
+    axis: int | None = None
+
+    def bind(self, boundary: PatchBoundary) -> Self:
+        return replace(self, axis=boundary.axis(self.dim))
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        assert self.axis is not None
+        return patch_tree.new(
+            data=kernels.standardize_kernel(patch_tree.data, self.axis)
+        )
+
+
+_REDUCTIONS = {
+    "all": jnp.all,
+    "any": jnp.any,
+    "max": jnp.max,
+    "mean": jnp.mean,
+    "median": jnp.median,
+    "min": jnp.min,
+    "std": jnp.std,
+    "sum": jnp.sum,
+}
+
+
+@dataclass(frozen=True)
+class Aggregate(PatchOperation):
+    """Aggregate values along one or more dimensions."""
+
+    dim: str | tuple[str, ...] | None = None
+    method: str | Any = "mean"
+    dim_reduce: str | Any = "empty"
+    axes: tuple[int, ...] = ()
+    keepdims: bool = True
+    out_boundary: PatchBoundary | None = None
+    out_coords: tuple[Any, ...] | None = None
+    out_dtype_codes: tuple[Any, ...] | None = None
+    out_dims: tuple[str, ...] | None = None
+
+    def bind(self, boundary: PatchBoundary) -> Self:
+        if not isinstance(self.method, str) or self.method not in _REDUCTIONS:
+            msg = f"Unsupported aggregate method {self.method!r}."
+            raise NotImplementedError(msg)
+        if self.dim_reduce not in {"empty", "squeeze"}:
+            msg = "Compiled aggregate supports dim_reduce='empty' or 'squeeze'."
+            raise NotImplementedError(msg)
+        dims = tuple(iterate(self.dim if self.dim is not None else boundary.dims))
+        axes = tuple(boundary.axis(dim) for dim in dims)
+        patch = dummy_patch(boundary)
+        if self.method in {"all", "any"}:
+            out = getattr(patch, self.method)(dim=dims, dim_reduce=self.dim_reduce)
+        else:
+            out = patch.aggregate(
+                dim=dims,
+                method=self.method,
+                dim_reduce=self.dim_reduce,
+            )
+        out_tree, out_boundary = tree_boundary_from_patch(out)
+        return replace(
+            self,
+            axes=axes,
+            keepdims=self.dim_reduce == "empty",
+            out_boundary=out_boundary,
+            out_coords=out_tree.coord_values,
+            out_dtype_codes=out_tree.coord_dtype_codes,
+            out_dims=out_tree.dims,
+        )
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        data = _REDUCTIONS[self.method](
+            jnp.asarray(patch_tree.data),
+            axis=self.axes,
+            keepdims=self.keepdims,
+        )
+        return patch_tree.new(
+            data=data,
+            coords=self.out_coords,
+            coord_dtype_codes=self.out_dtype_codes,
+            dims=self.out_dims,
+        )
+
+    def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary:
+        _ = boundary
+        assert self.out_boundary is not None
+        return self.out_boundary
+
+
+@dataclass(frozen=True)
+class _Reduction(Aggregate):
+    """Base class for named reduction methods."""
+
+    register: ClassVar[bool] = False
+    method_name: ClassVar[str | None] = None
+
+    def __init__(
+        self,
+        dim: str | tuple[str, ...] | None = None,
+        dim_reduce: str | Any = "empty",
+    ):
+        object.__setattr__(self, "dim", dim)
+        object.__setattr__(self, "method", type(self).operation_name())
+        object.__setattr__(self, "dim_reduce", dim_reduce)
+        object.__setattr__(self, "axes", ())
+        object.__setattr__(self, "keepdims", True)
+        object.__setattr__(self, "out_boundary", None)
+        object.__setattr__(self, "out_coords", None)
+        object.__setattr__(self, "out_dtype_codes", None)
+        object.__setattr__(self, "out_dims", None)
+
+
+@dataclass(frozen=True)
+class All(_Reduction):
+    """Perform boolean all reduction."""
+
+    def __init__(self, dim=None, dim_reduce="empty"):
+        _Reduction.__init__(self, dim=dim, dim_reduce=dim_reduce)
+
+
+@dataclass(frozen=True)
+class AnyOp(_Reduction):
+    """Perform boolean any reduction."""
+
+    method_name: ClassVar[str | None] = "any"
+
+    def __init__(self, dim=None, dim_reduce="empty"):
+        _Reduction.__init__(self, dim=dim, dim_reduce=dim_reduce)
+
+
+@dataclass(frozen=True)
+class Max(_Reduction):
+    """Calculate maximum along one or more dimensions."""
+
+    def __init__(self, dim=None, dim_reduce="empty"):
+        _Reduction.__init__(self, dim=dim, dim_reduce=dim_reduce)
+
+
+@dataclass(frozen=True)
+class Mean(_Reduction):
+    """Calculate mean along one or more dimensions."""
+
+    def __init__(self, dim=None, dim_reduce="empty"):
+        _Reduction.__init__(self, dim=dim, dim_reduce=dim_reduce)
+
+
+@dataclass(frozen=True)
+class Median(_Reduction):
+    """Calculate median along one or more dimensions."""
+
+    def __init__(self, dim=None, dim_reduce="empty"):
+        _Reduction.__init__(self, dim=dim, dim_reduce=dim_reduce)
+
+
+@dataclass(frozen=True)
+class Min(_Reduction):
+    """Calculate minimum along one or more dimensions."""
+
+    def __init__(self, dim=None, dim_reduce="empty"):
+        _Reduction.__init__(self, dim=dim, dim_reduce=dim_reduce)
+
+
+@dataclass(frozen=True)
+class Std(_Reduction):
+    """Calculate standard deviation along one or more dimensions."""
+
+    def __init__(self, dim=None, dim_reduce="empty"):
+        _Reduction.__init__(self, dim=dim, dim_reduce=dim_reduce)
+
+
+@dataclass(frozen=True)
+class Sum(_Reduction):
+    """Calculate sum along one or more dimensions."""
+
+    def __init__(self, dim=None, dim_reduce="empty"):
+        _Reduction.__init__(self, dim=dim, dim_reduce=dim_reduce)
diff --git a/src/dasjax/operations/basic/__init__.py b/src/dasjax/operations/basic/__init__.py
deleted file mode 100644
index 6969b8a..0000000
--- a/src/dasjax/operations/basic/__init__.py
+++ /dev/null
@@ -1,5 +0,0 @@
-"""Basic operation family."""
-
-from .specs import OPERATIONS
-
-__all__ = ["OPERATIONS"]
diff --git a/src/dasjax/operations/basic/impl.py b/src/dasjax/operations/basic/impl.py
deleted file mode 100644
index ba9e72b..0000000
--- a/src/dasjax/operations/basic/impl.py
+++ /dev/null
@@ -1,404 +0,0 @@
-"""Executable implementations for basic operations."""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Any
-
-import jax.numpy as jnp
-from dascore.constants import PatchType
-from dascore.proc.basic import flip as dc_flip
-from dascore.proc.basic import roll as dc_roll
-from dascore.proc.basic import standardize as dc_standardize
-
-from dasjax import kernels
-
-from ..common import get_axis_from_dims, update_patch
-from ..patch_ops import EagerPatchOp, PatchOp
-
-
-@dataclass(frozen=True)
-class IdentityOp(PatchOp):
-    """Compiled identity operation."""
-
-    def kernel(self, data):
-        return {"data": kernels.identity_kernel(data)}
-
-
-@dataclass(frozen=True)
-class ScaleOp(PatchOp):
-    """Compiled scale operation with signature-inferred state binding."""
-
-    factor: float
-
-    def kernel(self, data):
-        return {"data": kernels.scale_kernel(data, self.factor)}
-
-
-@dataclass(frozen=True)
-class AddOp(PatchOp):
-    """Compiled add operation."""
-
-    value: float
-
-    def kernel(self, data):
-        return {"data": kernels.add_kernel(data, self.value)}
-
-
-@dataclass(frozen=True)
-class AbsOp(PatchOp):
-    """Compiled abs operation."""
-
-    def kernel(self, data):
-        return {"data": kernels.abs_kernel(data)}
-
-
-@dataclass(frozen=True)
-class ClipOp(PatchOp):
-    """Compiled clip operation."""
-
-    min_value: float
-    max_value: float
-
-    def kernel(self, data):
-        return {"data": kernels.clip_kernel(data, self.min_value, self.max_value)}
-
-
-@dataclass(frozen=True)
-class RealOp(PatchOp):
-    """Compiled real operation."""
-
-    def kernel(self, data):
-        return {"data": kernels.real_kernel(data)}
-
-
-@dataclass(frozen=True)
-class ImagOp(PatchOp):
-    """Compiled imag operation."""
-
-    def kernel(self, data):
-        return {"data": kernels.imag_kernel(data)}
-
-
-@dataclass(frozen=True)
-class AngleOp(PatchOp):
-    """Compiled angle operation."""
-
-    def kernel(self, data):
-        return {"data": kernels.angle_kernel(data)}
-
-
-@dataclass(frozen=True)
-class ConjOp(PatchOp):
-    """Compiled conj operation."""
-
-    def kernel(self, data):
-        return {"data": kernels.conj_kernel(data)}
-
-
-@dataclass(frozen=True)
-class FlipOp(PatchOp):
-    """Compiled flip operation over patch state."""
-
-    dims: tuple[str, ...]
-    data_axes: tuple[int, ...]
-    coord_axes: dict[str, tuple[int, ...]]
-    flip_coords: bool = True
-    mutates_spec = False
-
-    @classmethod
-    def prepare(
-        cls,
-        patch: PatchType,
-        *dims: str,
-        flip_coords: bool = True,
-    ) -> "FlipOp":
-        resolved_dims = tuple(dims) if dims else tuple(patch.dims)
-        data_axes = tuple(patch.get_axis(dim) for dim in resolved_dims)
-        coord_axes: dict[str, tuple[int, ...]] = {}
-        if flip_coords:
-            for name, coord_dims in patch.coords.dim_map.items():
-                axes = tuple(
-                    idx
-                    for idx, coord_dim in enumerate(coord_dims)
-                    if coord_dim in resolved_dims
-                )
-                if axes:
-                    coord_axes[name] = axes
-        return cls(
-            dims=resolved_dims,
-            data_axes=data_axes,
-            coord_axes=coord_axes,
-            flip_coords=flip_coords,
-        )
-
-    def kernel(self, state):
-        coords = state.coords
-        out = {"data": jnp.flip(state.data, axis=self.data_axes)}
-        if self.flip_coords:
-            new_coords = {}
-            for name, axes in self.coord_axes.items():
-                new_coords[name] = jnp.flip(coords[name], axis=axes)
-            if new_coords:
-                out["coords"] = new_coords
-        return out
-
-
-@dataclass(frozen=True)
-class RollOp(PatchOp):
-    """Compiled roll operation using selected-axis inference."""
-
-    shift: int
-    selected_dim: str
-    requires_materialized_patch_for_prepare = False
-
-    @classmethod
-    def prepare(
-        cls,
-        patch: PatchType,
-        samples: bool = False,
-        update_coord: bool = False,
-        **kwargs,
-    ) -> "RollOp":
-        if update_coord:
-            raise NotImplementedError(
-                "Compiled roll currently requires update_coord=False."
-            )
-        selected_dim, _, coord = cls._resolve_selected_context(patch, (), kwargs)
-        shift = int(coord.get_sample_count(kwargs[selected_dim], samples=samples))
-        op = cls(shift=shift, selected_dim=selected_dim)
-        object.__setattr__(op, "_prepared_attrs", {})
-        object.__setattr__(
-            op,
-            "_prepared_selected",
-            cls._prepare_selected(patch, (), {"dim": selected_dim}, op),
-        )
-        cls._validate_kernel_bindings(patch, op)
-        return op
-
-    def kernel(self, data, selected_axis):
-        return {"data": kernels.roll_kernel(data, shift=self.shift, axis=selected_axis)}
-
-
-@dataclass(frozen=True)
-class StandardizeOp(EagerPatchOp):
-    """Unified eager-backed standardize operation."""
-
-    patch_impl_fn = staticmethod(dc_standardize.func)
-
-
-def identity_patch(patch: PatchType) -> PatchType:
-    return patch
-
-
-def identity_leaves(
-    data: Any,
-    coord_leaves: tuple[Any, ...],
-    *,
-    dims: tuple[str, ...],
-) -> tuple[Any, tuple[Any, ...]]:
-    _ = dims
-    return kernels.identity_kernel(data), coord_leaves
-
-
-def scale_patch(patch: PatchType, factor: float) -> PatchType:
-    return update_patch(patch, kernels.scale_kernel(patch.data, factor))
-
-
-def scale_leaves(
-    data: Any,
-    coord_leaves: tuple[Any, ...],
-    factor: float,
-    *,
-    dims: tuple[str, ...],
-) -> tuple[Any, tuple[Any, ...]]:
-    _ = dims
-    return kernels.scale_kernel(data, factor), coord_leaves
-
-
-def add_patch(patch: PatchType, value: float) -> PatchType:
-    return update_patch(patch, kernels.add_kernel(patch.data, value))
-
-
-def add_leaves(
-    data: Any,
-    coord_leaves: tuple[Any, ...],
-    value: float,
-    *,
-    dims: tuple[str, ...],
-) -> tuple[Any, tuple[Any, ...]]:
-    _ = dims
-    return kernels.add_kernel(data, value), coord_leaves
-
-
-def abs_patch(patch: PatchType) -> PatchType:
-    return update_patch(patch, kernels.abs_kernel(patch.data))
-
-
-def abs_leaves(
-    data: Any,
-    coord_leaves: tuple[Any, ...],
-    *,
-    dims: tuple[str, ...],
-) -> tuple[Any, tuple[Any, ...]]:
-    _ = dims
-    return kernels.abs_kernel(data), coord_leaves
-
-
-def clip_patch(patch: PatchType, min_value: float, max_value: float) -> PatchType:
-    return update_patch(patch, kernels.clip_kernel(patch.data, min_value, max_value))
-
-
-def clip_leaves(
-    data: Any,
-    coord_leaves: tuple[Any, ...],
-    min_value: float,
-    max_value: float,
-    *,
-    dims: tuple[str, ...],
-) -> tuple[Any, tuple[Any, ...]]:
-    _ = dims
-    return kernels.clip_kernel(data, min_value, max_value), coord_leaves
-
-
-def real_patch(patch: PatchType) -> PatchType:
-    return update_patch(patch, kernels.real_kernel(patch.data))
-
-
-def real_leaves(
-    data: Any,
-    coord_leaves: tuple[Any, ...],
-    *,
-    dims: tuple[str, ...],
-) -> tuple[Any, tuple[Any, ...]]:
-    _ = dims
-    return kernels.real_kernel(data), coord_leaves
-
-
-def imag_patch(patch: PatchType) -> PatchType:
-    return update_patch(patch, kernels.imag_kernel(patch.data))
-
-
-def imag_leaves(
-    data: Any,
-    coord_leaves: tuple[Any, ...],
-    *,
-    dims: tuple[str, ...],
-) -> tuple[Any, tuple[Any, ...]]:
-    _ = dims
-    return kernels.imag_kernel(data), coord_leaves
-
-
-def angle_patch(patch: PatchType) -> PatchType:
-    return update_patch(patch, kernels.angle_kernel(patch.data))
-
-
-def angle_leaves(
-    data: Any,
-    coord_leaves: tuple[Any, ...],
-    *,
-    dims: tuple[str, ...],
-) -> tuple[Any, tuple[Any, ...]]:
-    _ = dims
-    return kernels.angle_kernel(data), coord_leaves
-
-
-def conj_patch(patch: PatchType) -> PatchType:
-    return update_patch(patch, kernels.conj_kernel(patch.data))
-
-
-def conj_leaves(
-    data: Any,
-    coord_leaves: tuple[Any, ...],
-    *,
-    dims: tuple[str, ...],
-) -> tuple[Any, tuple[Any, ...]]:
-    _ = dims
-    return kernels.conj_kernel(data), coord_leaves
-
-
-def flip_patch(
-    patch: PatchType,
-    *dims: str,
-    flip_coords: bool = True,
-) -> PatchType:
-    return dc_flip.func(patch, *dims, flip_coords=flip_coords)
-
-
-def prepare_roll_call(
-    patch: PatchType,
-    args: tuple[Any, ...],
-    kwargs: dict[str, Any],
-) -> tuple[tuple[Any, ...], dict[str, Any]]:
-    _ = args
-    call_kwargs = dict(kwargs)
-    samples = bool(call_kwargs.pop("samples", False))
-    update_coord = bool(call_kwargs.pop("update_coord", False))
-    dim = next(key for key in call_kwargs if key in patch.dims)
-    axis = patch.get_axis(dim)
-    coord = patch.get_coord(dim)
-    shift = int(coord.get_sample_count(call_kwargs[dim], samples=samples))
-    return (), {"axis": axis, "shift": shift, "update_coord": update_coord}
-
-
-def validate_roll_compiled_input(
-    patch: PatchType,
-    args: tuple[Any, ...],
-    kwargs: dict[str, Any],
-) -> None:
-    _ = patch, args
-    if kwargs.get("update_coord", False):
-        raise NotImplementedError(
-            "Compiled roll currently requires update_coord=False."
-        )
-
-
-def guard_compiled_roll_case(
-    patch: PatchType,
-    args: tuple[Any, ...],
-    kwargs: dict[str, Any],
-) -> tuple[type[Exception], str] | None:
-    _ = patch, args
-    if kwargs.get("update_coord", False):
-        return (
-            NotImplementedError,
-            "Compiled roll currently requires update_coord=False.",
-        )
-    return None
-
-
-def roll_patch(
-    patch: PatchType,
-    samples: bool = False,
-    update_coord: bool = False,
-    **kwargs,
-) -> PatchType:
-    return dc_roll.func(patch, samples=samples, update_coord=update_coord, **kwargs)
-
-
-def roll_leaves(
-    data: Any,
-    coord_leaves: tuple[Any, ...],
-    *,
-    dims: tuple[str, ...],
-    axis: int,
-    shift: int,
-    update_coord: bool = False,
-) -> tuple[Any, tuple[Any, ...]]:
-    _ = dims, update_coord
-    return kernels.roll_kernel(data, shift=shift, axis=axis), coord_leaves
-
-
-def standardize_patch(patch: PatchType, dim: str) -> PatchType:
-    return dc_standardize.func(patch, dim=dim)
-
-
-def standardize_leaves(
-    data: Any,
-    coord_leaves: tuple[Any, ...],
-    *,
-    dims: tuple[str, ...],
-    dim: str,
-) -> tuple[Any, tuple[Any, ...]]:
-    axis = get_axis_from_dims(dims, dim)
-    return kernels.standardize_kernel(data, axis=axis), coord_leaves
diff --git a/src/dasjax/operations/basic/specs.py b/src/dasjax/operations/basic/specs.py
deleted file mode 100644
index 63d95a7..0000000
--- a/src/dasjax/operations/basic/specs.py
+++ /dev/null
@@ -1,224 +0,0 @@
-"""Registry specs for basic operations."""
-
-from __future__ import annotations
-
-import dascore as dc
-from dascore.proc.basic import angle as dc_angle
-from dascore.proc.basic import conj as dc_conj
-from dascore.proc.basic import flip as dc_flip
-from dascore.proc.basic import imag as dc_imag
-from dascore.proc.basic import real as dc_real
-from dascore.proc.basic import roll as dc_roll
-from dascore.proc.basic import standardize as dc_standardize
-
-from dasjax import kernels
-
-from ..common import prepare_complex_patch
-from ..types import ExecutionPolicy, OperationCase, OperationSpec, empty_call
-from . import impl
-
-OPERATIONS: tuple[OperationSpec, ...] = (
-    OperationSpec(
-        name="identity",
-        execution_policy=ExecutionPolicy.LEAF,
-        patch_impl=dc.patch_function(history=None)(impl.identity_patch),
-        patch_op_cls=impl.IdentityOp,
-        leaf_transform=impl.identity_leaves,
-        test_cases=(
-            OperationCase(
-                case_id="identity",
-                resolve_call=empty_call,
-                baseline=lambda patch, args, kwargs: patch,
-            ),
-        ),
-    ),
-    OperationSpec(
-        name="scale",
-        execution_policy=ExecutionPolicy.LEAF,
-        patch_impl=dc.patch_function(history="method_name")(impl.scale_patch),
-        patch_op_cls=impl.ScaleOp,
-        leaf_transform=impl.scale_leaves,
-        test_cases=tuple(
-            OperationCase(
-                case_id=f"scale-{value}",
-                resolve_call=lambda patch, value=value: ((value,), {}),
-                baseline=lambda patch, args, kwargs: patch * args[0],
-            )
-            for value in (2.0, -0.75)
-        ),
-    ),
-    OperationSpec(
-        name="add",
-        execution_policy=ExecutionPolicy.LEAF,
-        patch_impl=dc.patch_function(history="method_name")(impl.add_patch),
-        patch_op_cls=impl.AddOp,
-        leaf_transform=impl.add_leaves,
-        test_cases=tuple(
-            OperationCase(
-                case_id=f"add-{value}",
-                resolve_call=lambda patch, value=value: ((value,), {}),
-                baseline=lambda patch, args, kwargs: patch + args[0],
-            )
-            for value in (2.0, -0.75)
-        ),
-    ),
-    OperationSpec(
-        name="abs",
-        execution_policy=ExecutionPolicy.LEAF,
-        patch_impl=dc.patch_function(history="method_name")(impl.abs_patch),
-        patch_op_cls=impl.AbsOp,
-        leaf_transform=impl.abs_leaves,
-        test_cases=(
-            OperationCase(
-                case_id="abs",
-                resolve_call=empty_call,
-                prepare_patch=prepare_complex_patch,
-                baseline=lambda patch, args, kwargs: patch.abs(),
-            ),
-        ),
-    ),
-    OperationSpec(
-        name="clip",
-        execution_policy=ExecutionPolicy.LEAF,
-        patch_impl=dc.patch_function(history="method_name")(impl.clip_patch),
-        patch_op_cls=impl.ClipOp,
-        leaf_transform=impl.clip_leaves,
-        test_cases=tuple(
-            OperationCase(
-                case_id=f"clip-{low}-{high}",
-                resolve_call=lambda patch, low=low, high=high: ((low, high), {}),
-                baseline=lambda patch, args, kwargs, low=low, high=high: patch.update(
-                    data=kernels.clip_kernel(patch.data, low, high)
-                ),
-            )
-            for low, high in ((-0.25, 0.25), (-1.0, 1.5))
-        ),
-    ),
-    OperationSpec(
-        name="real",
-        execution_policy=ExecutionPolicy.LEAF,
-        patch_impl=dc.patch_function(history="method_name")(impl.real_patch),
-        patch_op_cls=impl.RealOp,
-        leaf_transform=impl.real_leaves,
-        test_cases=(
-            OperationCase(
-                case_id="real",
-                resolve_call=empty_call,
-                prepare_patch=prepare_complex_patch,
-                baseline=lambda patch, args, kwargs: dc_real.func(patch),
-            ),
-        ),
-    ),
-    OperationSpec(
-        name="imag",
-        execution_policy=ExecutionPolicy.LEAF,
-        patch_impl=dc.patch_function(history="method_name")(impl.imag_patch),
-        patch_op_cls=impl.ImagOp,
-        leaf_transform=impl.imag_leaves,
-        test_cases=(
-            OperationCase(
-                case_id="imag",
-                resolve_call=empty_call,
-                prepare_patch=prepare_complex_patch,
-                baseline=lambda patch, args, kwargs: dc_imag.func(patch),
-            ),
-        ),
-    ),
-    OperationSpec(
-        name="angle",
-        execution_policy=ExecutionPolicy.LEAF,
-        patch_impl=dc.patch_function(history="method_name")(impl.angle_patch),
-        patch_op_cls=impl.AngleOp,
-        leaf_transform=impl.angle_leaves,
-        test_cases=(
-            OperationCase(
-                case_id="angle",
-                resolve_call=empty_call,
-                prepare_patch=prepare_complex_patch,
-                baseline=lambda patch, args, kwargs: dc_angle.func(patch),
-            ),
-        ),
-    ),
-    OperationSpec(
-        name="conj",
-        execution_policy=ExecutionPolicy.LEAF,
-        patch_impl=dc.patch_function(history="method_name")(impl.conj_patch),
-        patch_op_cls=impl.ConjOp,
-        leaf_transform=impl.conj_leaves,
-        test_cases=(
-            OperationCase(
-                case_id="conj",
-                resolve_call=empty_call,
-                prepare_patch=prepare_complex_patch,
-                baseline=lambda patch, args, kwargs: dc_conj.func(patch),
-            ),
-        ),
-    ),
-    OperationSpec(
-        name="flip",
-        execution_policy=ExecutionPolicy.PATCH,
-        patch_impl=dc.patch_function(history="method_name")(impl.flip_patch),
-        patch_op_cls=impl.FlipOp,
-        test_cases=(
-            OperationCase(
-                case_id="flip-time",
-                resolve_call=lambda patch: ((patch.dims[-1],), {"flip_coords": True}),
-                baseline=lambda patch, args, kwargs: dc_flip.func(
-                    patch, *args, **kwargs
-                ),
-            ),
-            OperationCase(
-                case_id="flip-all-no-coords",
-                resolve_call=lambda patch: (tuple(patch.dims), {"flip_coords": False}),
-                baseline=lambda patch, args, kwargs: dc_flip.func(
-                    patch, *args, **kwargs
-                ),
-            ),
-        ),
-    ),
-    OperationSpec(
-        name="roll",
-        execution_policy=ExecutionPolicy.LEAF,
-        patch_impl=dc.patch_function(history="method_name")(impl.roll_patch),
-        patch_op_cls=impl.RollOp,
-        leaf_transform=impl.roll_leaves,
-        prepare_call=impl.prepare_roll_call,
-        validate_compiled_patch=impl.validate_roll_compiled_input,
-        test_cases=(
-            OperationCase(
-                case_id="roll-samples",
-                resolve_call=lambda patch: ((), {"samples": True, patch.dims[-1]: 5}),
-                baseline=lambda patch, args, kwargs: dc_roll.func(
-                    patch, *args, **kwargs
-                ),
-                compiled_guard=impl.guard_compiled_roll_case,
-            ),
-            OperationCase(
-                case_id="roll-coord-update",
-                resolve_call=lambda patch: (
-                    (),
-                    {"samples": True, "update_coord": True, patch.dims[-1]: 3},
-                ),
-                baseline=lambda patch, args, kwargs: dc_roll.func(
-                    patch, *args, **kwargs
-                ),
-                compiled_guard=impl.guard_compiled_roll_case,
-            ),
-        ),
-    ),
-    OperationSpec(
-        name="standardize",
-        execution_policy=ExecutionPolicy.PATCH,
-        patch_impl=dc.patch_function(history="method_name")(impl.standardize_patch),
-        patch_op_cls=impl.StandardizeOp,
-        test_cases=(
-            OperationCase(
-                case_id="standardize-time",
-                resolve_call=lambda patch: ((), {"dim": patch.dims[-1]}),
-                baseline=lambda patch, args, kwargs: dc_standardize.func(
-                    patch, *args, **kwargs
-                ),
-            ),
-        ),
-    ),
-)
diff --git a/src/dasjax/operations/common.py b/src/dasjax/operations/common.py
index c571e4b..0f86d8a 100644
--- a/src/dasjax/operations/common.py
+++ b/src/dasjax/operations/common.py
@@ -1,139 +1,54 @@
-"""Shared helpers used by operation-family modules."""
+"""Shared helpers for patch operation implementations."""
 
 from __future__ import annotations
 
-from collections.abc import Callable
+from dataclasses import fields
 from typing import Any
 
 import dascore as dc
 import numpy as np
-from dascore.constants import PatchType
-from dascore.exceptions import ParameterError
+from dascore.units import get_quantity
 
-from .types import OperationSpec
+from dasjax.core import PatchBoundary, PatchPyTree
 
 
-def get_axis(patch: PatchType, dim: str | None) -> int | None:
-    if dim is None:
-        return None
-    try:
-        return patch.dims.index(dim)
-    except ValueError as exc:
-        msg = f"Patch does not contain dimension {dim!r}."
-        raise ValueError(msg) from exc
-
-
-def get_axis_from_dims(dims: tuple[str, ...], dim: str | None) -> int | None:
-    if dim is None:
-        return None
-    try:
-        return dims.index(dim)
-    except ValueError as exc:
-        msg = f"Patch does not contain dimension {dim!r}."
-        raise ValueError(msg) from exc
-
-
-def update_patch(patch: PatchType, data: Any) -> PatchType:
-    return patch.update(data=np.asarray(data))
-
-
-def prepare_operation_call(
-    operation: OperationSpec,
-    patch: PatchType,
-    args: tuple[Any, ...],
-    kwargs: dict[str, Any],
-) -> tuple[tuple[Any, ...], dict[str, Any]]:
-    if operation.prepare_call is None:
-        return args, kwargs
-    return operation.prepare_call(patch, args, kwargs)
-
-
-def offset_patch(patch: PatchType, offset: float) -> PatchType:
-    return patch.update(data=patch.data + offset)
-
-
-def baseline_update(
-    patch: PatchType,
-    args: tuple[Any, ...],
-    kwargs: dict[str, Any],
-    fn: Callable[..., Any],
-) -> PatchType:
-    return patch.update(data=np.asarray(fn(patch.data, *args, **kwargs)))
+def replace(obj: Any, **changes: Any) -> Any:
+    """Copy frozen operation instances without calling custom constructors."""
+    out = object.__new__(type(obj))
+    for field in fields(obj):
+        object.__setattr__(
+            out, field.name, changes.get(field.name, getattr(obj, field.name))
+        )
+    return out
 
 
-def baseline_patch_method(
-    patch: PatchType,
-    args: tuple[Any, ...],
-    kwargs: dict[str, Any],
-    method_name: str,
-) -> PatchType:
-    return getattr(patch, method_name)(*args, **kwargs)
+def dummy_patch(boundary: PatchBoundary, dtype=np.float64) -> dc.Patch:
+    """Create a zero-data patch with metadata from a pipeline boundary."""
+    return dc.Patch(
+        data=np.zeros(boundary.coords.shape, dtype=dtype),
+        coords=boundary.coords,
+        dims=boundary.dims,
+        attrs=boundary.attrs,
+    )
 
 
-def get_evenly_sampled_dim(patch: PatchType) -> str:
-    for dim in reversed(patch.dims):
-        if patch.get_coord(dim).step is not None:
-            return dim
-    msg = f"Patch does not contain an evenly sampled dimension: {patch.dims}"
-    raise ParameterError(msg)
+def tree_boundary_from_patch(patch: dc.Patch) -> tuple[PatchPyTree, PatchBoundary]:
+    """Convert a DASCore patch into pipeline tree and boundary objects."""
+    return PatchPyTree.from_patch(patch)
 
 
-def get_preferred_transform_dim(patch: PatchType) -> str:
-    for dim in reversed(patch.dims):
-        if patch.get_coord(dim).step is not None:
-            return dim
-    return patch.dims[-1]
-
-
-def resolve_even_dim_call(
-    patch: PatchType,
-    **kwargs: Any,
-) -> tuple[tuple[Any, ...], dict[str, Any]]:
-    out = dict(kwargs)
-    out["dim"] = get_preferred_transform_dim(patch)
-    return (), out
-
-
-def prepare_complex_patch(patch: PatchType) -> PatchType:
-    data = np.asarray(patch.data, dtype=np.complex128)
-    return patch.update(data=data + 1j * data)
-
-
-def prepare_fourier_patch(patch: PatchType) -> PatchType:
-    from dascore.transform.fourier import dft as dc_dft
-
-    dim = get_preferred_transform_dim(patch)
-    try:
-        return dc_dft.func(patch, dim=dim, real=True, pad=False)
-    except Exception:
-        return patch
-
-
-def prepare_even_patch_for_dim(patch: PatchType) -> PatchType:
-    dim = get_preferred_transform_dim(patch)
-    coord = patch.get_coord(dim)
-    if coord.step is not None:
-        return patch
-    new_coord = dc.get_coord(start=0, stop=len(coord), step=1, units=coord.units)
-    return patch.update(coords=patch.coords.update(**{dim: new_coord}))
-
-
-def validate_registry(operations: tuple[OperationSpec, ...]) -> None:
-    seen: set[str] = set()
-    for operation in operations:
-        if operation.name in seen:
-            msg = f"Duplicate jax patch operation {operation.name!r}."
-            raise ValueError(msg)
-        seen.add(operation.name)
-        if (
-            operation.execution_policy.value == "leaf"
-            and operation.leaf_transform is None
-        ):
-            msg = f"Leaf operation {operation.name!r} must define leaf_transform."
-            raise ValueError(msg)
-        if (
-            operation.execution_policy.value == "patch"
-            and operation.leaf_transform is not None
-        ):
-            msg = f"Patch operation {operation.name!r} must not define leaf_transform."
-            raise ValueError(msg)
+def get_data_units_from_dims(
+    boundary: PatchBoundary,
+    dims: tuple[str, ...],
+    operator,
+) -> Any:
+    """Apply a unit operator between data units and dimension units."""
+    if (data_units := get_quantity(boundary.attrs.data_units)) is None:
+        return None
+    dim_units = None
+    for dim_name in dims:
+        dim_unit = get_quantity(boundary.coord(dim_name).units)
+        if dim_unit is None:
+            continue
+        dim_units = dim_unit if dim_units is None else dim_unit * dim_units
+    return operator(data_units, dim_units) if dim_units is not None else data_units
diff --git a/src/dasjax/operations/correlate.py b/src/dasjax/operations/correlate.py
new file mode 100644
index 0000000..ef5eba8
--- /dev/null
+++ b/src/dasjax/operations/correlate.py
@@ -0,0 +1,64 @@
+"""Correlation patch operations."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Self
+
+import dascore as dc
+from dascore.proc.correlate import correlate_shift as dc_correlate_shift
+
+from dasjax.core import PatchBoundary, PatchOperation, PatchPyTree
+
+from .. import kernels
+from .common import dummy_patch, replace, tree_boundary_from_patch
+
+
+@dataclass(frozen=True)
+class CorrelateShift(PatchOperation):
+    """Apply the lag shift after frequency-domain correlation."""
+
+    dim: str
+    undo_weighting: bool = True
+    axis: int | None = None
+    step: float = 1.0
+    out_boundary: PatchBoundary | None = None
+    out_coords: tuple[Any, ...] | None = None
+    out_dtype_codes: tuple[Any, ...] | None = None
+    out_dims: tuple[str, ...] | None = None
+
+    def bind(self, boundary: PatchBoundary) -> Self:
+        patch = dummy_patch(boundary)
+        coord = boundary.coord(self.dim)
+        out = dc_correlate_shift.func(
+            patch, dim=self.dim, undo_weighting=self.undo_weighting
+        )
+        out_tree, out_boundary = tree_boundary_from_patch(out)
+        return replace(
+            self,
+            axis=boundary.axis(self.dim),
+            step=float(dc.to_float(coord.step)),
+            out_boundary=out_boundary,
+            out_coords=out_tree.coord_values,
+            out_dtype_codes=out_tree.coord_dtype_codes,
+            out_dims=out_tree.dims,
+        )
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        assert self.axis is not None
+        return patch_tree.new(
+            data=kernels.correlate_shift_kernel(
+                patch_tree.data,
+                axis=self.axis,
+                step=self.step,
+                undo_weighting=self.undo_weighting,
+            ),
+            coords=self.out_coords,
+            coord_dtype_codes=self.out_dtype_codes,
+            dims=self.out_dims,
+        )
+
+    def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary:
+        _ = boundary
+        assert self.out_boundary is not None
+        return self.out_boundary
diff --git a/src/dasjax/operations/detrend.py b/src/dasjax/operations/detrend.py
new file mode 100644
index 0000000..1a05a34
--- /dev/null
+++ b/src/dasjax/operations/detrend.py
@@ -0,0 +1,30 @@
+"""Detrend patch operation."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Self
+
+from dasjax.core import PatchBoundary, PatchOperation, PatchPyTree
+
+from .. import kernels
+from .common import replace
+
+
+@dataclass(frozen=True)
+class Detrend(PatchOperation):
+    """Remove a linear or constant trend along one dimension."""
+
+    dim: str
+    type: str = "linear"
+    axis: int | None = None
+
+    def bind(self, boundary: PatchBoundary) -> Self:
+        kernels.validate_detrend_type(self.type)
+        return replace(self, axis=boundary.axis(self.dim))
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        assert self.axis is not None
+        return patch_tree.new(
+            data=kernels.detrend_kernel(patch_tree.data, axis=self.axis, type=self.type)
+        )
diff --git a/src/dasjax/operations/differentiate.py b/src/dasjax/operations/differentiate.py
new file mode 100644
index 0000000..e872103
--- /dev/null
+++ b/src/dasjax/operations/differentiate.py
@@ -0,0 +1,57 @@
+"""Differentiate patch operation."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from operator import truediv
+from typing import Any, Self
+
+import dascore as dc
+from dascore.exceptions import ParameterError
+from dascore.utils.misc import iterate
+
+from dasjax.core import PatchBoundary, PatchOperation, PatchPyTree
+
+from .. import kernels
+from .common import dummy_patch, get_data_units_from_dims, replace
+
+
+@dataclass(frozen=True)
+class Differentiate(PatchOperation):
+    """Differentiate patch data along one or more dimensions."""
+
+    dim: str | tuple[str, ...] | None
+    order: int = 2
+    step: int = 1
+    axes: tuple[int, ...] = ()
+    dxs_or_spacing: tuple[Any, ...] = ()
+    attrs: Any = None
+
+    def bind(self, boundary: PatchBoundary) -> Self:
+        dims = tuple(iterate(self.dim if self.dim is not None else boundary.dims))
+        if self.step > 1 and len(dims) > 1:
+            raise ParameterError(
+                "Step in patch.differentiate can only be used along one axis."
+            )
+        axes = []
+        dxs = []
+        for dim in dims:
+            coord = dummy_patch(boundary).get_coord(dim, require_sorted=True)
+            val = coord.step if coord.evenly_sampled else coord.data
+            dxs.append(dc.to_float(val))
+            axes.append(boundary.axis(dim))
+        attrs = boundary.attrs.update(
+            data_units=get_data_units_from_dims(boundary, dims, truediv)
+        )
+        return replace(self, axes=tuple(axes), dxs_or_spacing=tuple(dxs), attrs=attrs)
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        data = patch_tree.data
+        for axis, spacing in zip(self.axes, self.dxs_or_spacing, strict=True):
+            data = kernels.differentiate_kernel(
+                data, axis=axis, dx_or_spacing=spacing, order=self.order, step=self.step
+            )
+        return patch_tree.new(data=data)
+
+    def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary:
+        return boundary.new(attrs=self.attrs)
diff --git a/src/dasjax/operations/dispersion.py b/src/dasjax/operations/dispersion.py
new file mode 100644
index 0000000..f3f2a92
--- /dev/null
+++ b/src/dasjax/operations/dispersion.py
@@ -0,0 +1,121 @@
+"""Dispersion transform operation."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Self
+
+import numpy as np
+from dascore.exceptions import ParameterError
+
+from dasjax.core import PatchBoundary, PatchOperation, PatchPyTree
+
+from .. import kernels
+from .common import dummy_patch, replace, tree_boundary_from_patch
+
+
+@dataclass(frozen=True)
+class DispersionPhaseShift(PatchOperation):
+    """Compute a phase-shift dispersion image."""
+
+    phase_velocities: Any
+    approx_resolution: float | None = None
+    approx_freq: tuple[float, float] | None = None
+    distances: Any = None
+    velocities: Any = None
+    nf: int = 0
+    first_live_f: int = 0
+    last_live_f: int = 0
+    fs: float = 1.0
+    out_boundary: PatchBoundary | None = None
+    out_coords: tuple[Any, ...] | None = None
+    out_dtype_codes: tuple[Any, ...] | None = None
+    out_dims: tuple[str, ...] | None = None
+
+    def bind(self, boundary: PatchBoundary) -> Self:
+        velocities = np.asarray(self.phase_velocities, dtype=np.float64)
+        if not np.all(np.diff(velocities) > 0):
+            raise ParameterError(
+                "Velocities for dispersion must be monotonically increasing"
+            )
+        if np.amin(velocities) <= 0:
+            raise ParameterError("Velocities must be positive.")
+        if self.approx_resolution is not None and self.approx_resolution <= 0:
+            raise ParameterError("Frequency resolution has to be positive")
+        patch = (
+            dummy_patch(boundary)
+            .convert_units(distance="m")
+            .transpose("distance", "time")
+        )
+        time = patch.coords.get_array("time")
+        dt = (time[1] - time[0]) / np.timedelta64(1, "s")
+        fs = 1 / dt
+        if not self.approx_freq:
+            approx_min_freq = 0
+            approx_max_freq = 0.5 / dt
+        else:
+            approx_min_freq, approx_max_freq = self.approx_freq
+            if approx_min_freq <= 0 or approx_max_freq <= 0:
+                raise ParameterError(
+                    "Minimal and maximal frequencies have to be positive"
+                )
+            if approx_min_freq >= approx_max_freq:
+                raise ParameterError(
+                    "Maximal frequency needs to be larger than minimal frequency"
+                )
+            if approx_min_freq >= 0.5 / dt or approx_max_freq >= 0.5 / dt:
+                raise ParameterError("Frequency range cannot exceed Nyquist")
+        nt = len(time)
+        if self.approx_resolution is not None:
+            nf = int(nt * (fs / nt) / self.approx_resolution)
+        else:
+            nf = nt
+        freq = np.arange(nf) * fs / (nf - 1)
+        omega = 2 * np.pi * freq
+        first_live_f = int(np.argmax(omega >= 2 * np.pi * approx_min_freq))
+        last_live_f = int(np.argmax(omega >= 2 * np.pi * approx_max_freq))
+        if last_live_f - first_live_f < 1:
+            raise ParameterError(
+                "Combination of frequency resolution and range is not an array"
+            )
+        out_patch = patch.dispersion_phase_shift(
+            velocities,
+            approx_resolution=self.approx_resolution,
+            approx_freq=self.approx_freq,
+        )
+        out_tree, out_boundary = tree_boundary_from_patch(out_patch)
+        return replace(
+            self,
+            velocities=velocities,
+            distances=np.asarray(patch.coords.get_array("distance"), dtype=np.float64),
+            nf=nf,
+            first_live_f=first_live_f,
+            last_live_f=last_live_f,
+            fs=float(fs),
+            out_boundary=out_boundary,
+            out_coords=out_tree.coord_values,
+            out_dtype_codes=out_tree.coord_dtype_codes,
+            out_dims=out_tree.dims,
+        )
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        data = kernels.dispersion_phase_shift_kernel(
+            patch_tree.data,
+            distances=self.distances,
+            velocities=self.velocities,
+            nf=self.nf,
+            first_live_f=self.first_live_f,
+            last_live_f=self.last_live_f,
+            fs=self.fs,
+        )
+        return patch_tree.new(
+            data=data,
+            coords=self.out_coords,
+            coord_dtype_codes=self.out_dtype_codes,
+            dims=self.out_dims,
+        )
+
+    def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary:
+        _ = boundary
+        assert self.out_boundary is not None
+        return self.out_boundary
diff --git a/src/dasjax/operations/filter.py b/src/dasjax/operations/filter.py
new file mode 100644
index 0000000..e9cbf76
--- /dev/null
+++ b/src/dasjax/operations/filter.py
@@ -0,0 +1,497 @@
+"""Filter patch operations."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Self
+
+import numpy as np
+import dascore as dc
+from dascore.exceptions import FilterValueError, ParameterError
+from dascore.proc.filter import get_inverted_quant
+from dascore.units import get_filter_units
+from dascore.utils.patch import (
+    get_dim_axis_value,
+    get_dim_sampling_rate,
+    get_patch_window_size,
+)
+from scipy.fft import next_fast_len
+
+from dasjax.core import PatchBoundary, PatchOperation, PatchPyTree
+
+from .. import kernels
+from .common import dummy_patch, replace
+
+
+def _size_and_axes(
+    boundary: PatchBoundary,
+    kwargs: dict[str, Any],
+    samples: bool,
+) -> tuple[tuple[int, ...], tuple[int, ...]]:
+    """Resolve DASCore dimension window kwargs into static size and axes."""
+    dimfo = get_dim_axis_value(
+        dummy_patch(boundary), kwargs=kwargs, allow_multiple=True
+    )
+    axes = [axis for _dim, axis, _value in dimfo]
+    size = [1] * len(boundary.dims)
+    for dim, axis, value in dimfo:
+        size[axis] = boundary.coord(dim).get_sample_count(value, samples=samples)
+    return tuple(int(x) for x in size), tuple(int(x) for x in axes)
+
+
+@dataclass(frozen=True)
+class GaussianFilter(PatchOperation):
+    """Apply a Gaussian smoothing filter to patch data."""
+
+    samples: bool = False
+    mode: str = "reflect"
+    cval: float = 0.0
+    truncate: float = 4.0
+    kwargs: dict[str, Any] | None = None
+    sigma: tuple[float, ...] = ()
+    axes: tuple[int, ...] = ()
+
+    def __init__(self, samples=False, mode="reflect", cval=0.0, truncate=4.0, **kwargs):
+        object.__setattr__(self, "samples", samples)
+        object.__setattr__(self, "mode", mode)
+        object.__setattr__(self, "cval", float(cval))
+        object.__setattr__(self, "truncate", float(truncate))
+        object.__setattr__(self, "kwargs", dict(kwargs))
+        object.__setattr__(self, "sigma", ())
+        object.__setattr__(self, "axes", ())
+
+    def bind(self, boundary: PatchBoundary) -> Self:
+        dimfo = get_dim_axis_value(
+            dummy_patch(boundary), kwargs=self.kwargs or {}, allow_multiple=True
+        )
+        axes = []
+        sigma = []
+        for dim, axis, value in dimfo:
+            sigma.append(
+                float(boundary.coord(dim).get_sample_count(value, samples=self.samples))
+            )
+            axes.append(axis)
+        return replace(self, axes=tuple(axes), sigma=tuple(sigma))
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        return patch_tree.new(
+            data=kernels.gaussian_filter_kernel(
+                patch_tree.data,
+                sigma=self.sigma,
+                axes=self.axes,
+                mode=self.mode,
+                cval=self.cval,
+                truncate=self.truncate,
+            )
+        )
+
+
+@dataclass(frozen=True)
+class HampelFilter(PatchOperation):
+    """Replace outliers with a Hampel filter."""
+
+    threshold: float = 10.0
+    samples: bool = False
+    approximate: bool = True
+    kwargs: dict[str, Any] | None = None
+    size: tuple[int, ...] = ()
+
+    def __init__(self, *, threshold=10.0, samples=False, approximate=True, **kwargs):
+        if not approximate:
+            msg = "Exact Hampel median filtering is not implemented in pure JAX."
+            raise NotImplementedError(msg)
+        object.__setattr__(self, "threshold", float(threshold))
+        object.__setattr__(self, "samples", samples)
+        object.__setattr__(self, "approximate", approximate)
+        object.__setattr__(self, "kwargs", dict(kwargs))
+        object.__setattr__(self, "size", ())
+
+    def bind(self, boundary: PatchBoundary) -> Self:
+        if self.threshold <= 0 or not np.isfinite(self.threshold):
+            raise ParameterError(
+                "hampel_filter threshold must be finite and greater than zero"
+            )
+        size = get_patch_window_size(
+            dummy_patch(boundary),
+            self.kwargs or {},
+            self.samples,
+            require_odd=True,
+            warn_above=10,
+            min_samples=3,
+        )
+        return replace(self, size=tuple(int(x) for x in size))
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        return patch_tree.new(
+            data=kernels.hampel_filter_kernel(
+                patch_tree.data,
+                size=self.size,
+                threshold=self.threshold,
+                approximate=self.approximate,
+            )
+        )
+
+
+@dataclass(frozen=True)
+class MedianFilter(PatchOperation):
+    """Apply an exact median filter to patch data."""
+
+    samples: bool = False
+    mode: str = "reflect"
+    cval: float = 0.0
+    kwargs: dict[str, Any] | None = None
+    size: tuple[int, ...] = ()
+
+    def __init__(self, samples=False, mode="reflect", cval=0.0, **kwargs):
+        object.__setattr__(self, "samples", samples)
+        object.__setattr__(self, "mode", mode)
+        object.__setattr__(self, "cval", float(cval))
+        object.__setattr__(self, "kwargs", dict(kwargs))
+        object.__setattr__(self, "size", ())
+
+    def bind(self, boundary: PatchBoundary) -> Self:
+        size, _axes = _size_and_axes(boundary, self.kwargs or {}, self.samples)
+        return replace(self, size=size)
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        return patch_tree.new(
+            data=kernels.median_filter_kernel(
+                patch_tree.data,
+                size=self.size,
+                mode=self.mode,
+                cval=self.cval,
+            )
+        )
+
+
+@dataclass(frozen=True)
+class SobelFilter(PatchOperation):
+    """Apply a Sobel filter along one dimension."""
+
+    dim: str
+    mode: str = "reflect"
+    cval: float = 0.0
+    axis: int | None = None
+
+    def bind(self, boundary: PatchBoundary) -> Self:
+        if not isinstance(self.dim, str):
+            msg = "dim parameter should be a string."
+            raise FilterValueError(msg)
+        return replace(self, axis=boundary.axis(self.dim))
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        assert self.axis is not None
+        return patch_tree.new(
+            data=kernels.sobel_filter_kernel(
+                patch_tree.data,
+                axis=self.axis,
+                mode=self.mode,
+                cval=self.cval,
+            )
+        )
+
+
+@dataclass(frozen=True)
+class SavgolFilter(PatchOperation):
+    """Apply Savitzky-Golay filtering along one or more dimensions."""
+
+    polyorder: int
+    samples: bool = False
+    mode: str = "interp"
+    cval: float = 0.0
+    kwargs: dict[str, Any] | None = None
+    size: tuple[int, ...] = ()
+    axes: tuple[int, ...] = ()
+    coeffs: tuple[Any, ...] = ()
+    left_coeffs: tuple[Any, ...] = ()
+    right_coeffs: tuple[Any, ...] = ()
+
+    def __init__(self, polyorder, samples=False, mode="interp", cval=0.0, **kwargs):
+        object.__setattr__(self, "polyorder", int(polyorder))
+        object.__setattr__(self, "samples", samples)
+        object.__setattr__(self, "mode", mode)
+        object.__setattr__(self, "cval", float(cval))
+        object.__setattr__(self, "kwargs", dict(kwargs))
+        object.__setattr__(self, "size", ())
+        object.__setattr__(self, "axes", ())
+        object.__setattr__(self, "coeffs", ())
+        object.__setattr__(self, "left_coeffs", ())
+        object.__setattr__(self, "right_coeffs", ())
+
+    def bind(self, boundary: PatchBoundary) -> Self:
+        size, axes = _size_and_axes(boundary, self.kwargs or {}, self.samples)
+        coeffs = []
+        left_coeffs = []
+        right_coeffs = []
+        for axis in axes:
+            window = size[axis]
+            coeff, left, right = kernels.savgol_coefficients(window, self.polyorder)
+            coeffs.append(coeff)
+            left_coeffs.append(left)
+            right_coeffs.append(right)
+        return replace(
+            self,
+            size=size,
+            axes=axes,
+            coeffs=tuple(coeffs),
+            left_coeffs=tuple(left_coeffs),
+            right_coeffs=tuple(right_coeffs),
+        )
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        return patch_tree.new(
+            data=kernels.savgol_filter_kernel(
+                patch_tree.data,
+                size=self.size,
+                axes=self.axes,
+                coeffs=self.coeffs,
+                left_coeffs=self.left_coeffs,
+                right_coeffs=self.right_coeffs,
+                mode=self.mode,
+                cval=self.cval,
+            )
+        )
+
+
+@dataclass(frozen=True)
+class NotchFilter(PatchOperation):
+    """Apply one or more narrow notch filters."""
+
+    q: float
+    kwargs: dict[str, Any] | None = None
+    axes: tuple[int, ...] = ()
+    b: tuple[Any, ...] = ()
+    a: tuple[Any, ...] = ()
+    zi: tuple[Any, ...] = ()
+    padlen: tuple[int, ...] = ()
+
+    def __init__(self, q, **kwargs):
+        object.__setattr__(self, "q", float(q))
+        object.__setattr__(self, "kwargs", dict(kwargs))
+        object.__setattr__(self, "axes", ())
+        object.__setattr__(self, "b", ())
+        object.__setattr__(self, "a", ())
+        object.__setattr__(self, "zi", ())
+        object.__setattr__(self, "padlen", ())
+
+    def bind(self, boundary: PatchBoundary) -> Self:
+        dimfo = get_dim_axis_value(
+            dummy_patch(boundary), kwargs=self.kwargs or {}, allow_multiple=True
+        )
+        axes = []
+        b_values = []
+        a_values = []
+        zi_values = []
+        padlens = []
+        for dim, axis, value in dimfo:
+            coord = boundary.coord(dim)
+            if isinstance(value, dc.units.Quantity) and coord.units is not None:
+                value, _ = get_inverted_quant(value, coord.units)
+            w0 = float(dc.to_float(value))
+            sr = get_dim_sampling_rate(dummy_patch(boundary), dim)
+            b, a, zi, padlen = kernels.design_notch_filter(sr, w0, self.q)
+            axes.append(axis)
+            b_values.append(b)
+            a_values.append(a)
+            zi_values.append(zi)
+            padlens.append(padlen)
+        return replace(
+            self,
+            axes=tuple(int(x) for x in axes),
+            b=tuple(b_values),
+            a=tuple(a_values),
+            zi=tuple(zi_values),
+            padlen=tuple(int(x) for x in padlens),
+        )
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        data = patch_tree.data
+        for axis, b, a, zi, padlen in zip(
+            self.axes, self.b, self.a, self.zi, self.padlen, strict=True
+        ):
+            data = kernels.notch_filter_kernel(
+                data,
+                b=b,
+                a=a,
+                zi=zi,
+                padlen=padlen,
+                axis=axis,
+            )
+        return patch_tree.new(data=data)
+
+
+@dataclass(frozen=True)
+class WienerFilter(PatchOperation):
+    """Apply a local-statistics Wiener filter."""
+
+    noise: float | None = None
+    samples: bool = False
+    kwargs: dict[str, Any] | None = None
+    size: tuple[int, ...] = ()
+
+    def __init__(self, *, noise=None, samples=False, **kwargs):
+        object.__setattr__(self, "noise", noise)
+        object.__setattr__(self, "samples", samples)
+        object.__setattr__(self, "kwargs", dict(kwargs))
+        object.__setattr__(self, "size", ())
+
+    def bind(self, boundary: PatchBoundary) -> Self:
+        if not self.kwargs:
+            msg = (
+                "To use wiener_filter you must specify dimension-specific window "
+                "sizes via kwargs (e.g., time=5, distance=3)"
+            )
+            raise ParameterError(msg)
+        size = get_patch_window_size(
+            dummy_patch(boundary), self.kwargs or {}, self.samples, min_samples=1
+        )
+        return replace(self, size=tuple(int(x) for x in size))
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        return patch_tree.new(
+            data=kernels.wiener_filter_kernel(
+                patch_tree.data, size=self.size, noise=self.noise
+            )
+        )
+
+
+@dataclass(frozen=True)
+class SlopeFilter(PatchOperation):
+    """Filter over slopes in the 2-D Fourier domain."""
+
+    filt: Any
+    dims: tuple[str, str] = ("distance", "time")
+    directional: bool = False
+    notch: bool | None = None
+    invert: bool = False
+    axes: tuple[int, int] = ()
+    dxs: tuple[float, float] = ()
+    mask: Any = None
+    steps: tuple[float, float] = ()
+    sizes: tuple[int, int] = ()
+    pad_width: tuple[tuple[int, int], ...] = ()
+    attrs: Any = None
+
+    def bind(self, boundary: PatchBoundary) -> Self:
+        filt = np.asarray(self.filt, dtype=np.float64)
+        if not (len(filt) == 4 and np.all(filt[:-1] <= filt[1:])):
+            msg = f"filt must be a sorted length 4 sequence. You passed {self.filt}"
+            raise ParameterError(msg)
+        patch = dummy_patch(boundary)
+        pad_width = [(0, 0)] * len(boundary.dims)
+        for dim in self.dims:
+            axis = patch.get_axis(dim)
+            target = next_fast_len(len(patch.get_coord(dim)))
+            pad_width[axis] = (0, target - len(patch.get_coord(dim)))
+        work_patch = patch.pad.func(patch, **{dim: "fft" for dim in self.dims})
+        dft_patch = work_patch.dft.func(work_patch, self.dims, pad=False)
+        freq_dims = tuple(f"ft_{x}" for x in self.dims)
+        dim1, dim2 = freq_dims[-1], freq_dims[-2]
+        coord1 = dft_patch.get_array(dim1)
+        coord2 = dft_patch.get_array(dim2) + np.finfo(float).eps
+        ax1 = dft_patch.dims.index(dim1)
+        ax2 = dft_patch.dims.index(dim2)
+        shape_1 = [None] * dft_patch.ndim
+        shape_2 = [None] * dft_patch.ndim
+        shape_1[ax1] = slice(None)
+        shape_2[ax2] = slice(None)
+        slope = coord1[tuple(shape_1)] / coord2[tuple(shape_2)]
+        if not self.directional:
+            slope = np.abs(slope)
+        invert = self.invert if self.notch is None else self.notch
+        fac = np.where(
+            (slope >= filt[0]) & (slope <= filt[1]),
+            1.0 - np.sin(0.5 * np.pi * (slope - filt[0]) / (filt[1] - filt[0])),
+            1.0,
+        )
+        fac = np.where((slope >= filt[1]) & (slope <= filt[2]), 0.0, fac)
+        fac = np.where(
+            (slope >= filt[2]) & (slope <= filt[3]),
+            np.sin(0.5 * np.pi * (slope - filt[2]) / (filt[3] - filt[2])),
+            fac,
+        )
+        mask = fac if invert else 1.0 - fac
+        axes = tuple(work_patch.get_axis(dim) for dim in self.dims)
+        dxs = tuple(
+            float(dc.to_float(work_patch.get_coord(dim).step)) for dim in self.dims
+        )
+        return replace(
+            self,
+            axes=axes,
+            dxs=dxs,
+            mask=np.asarray(mask),
+            steps=dxs,
+            sizes=tuple(len(work_patch.get_coord(dim)) for dim in self.dims),
+            pad_width=tuple(pad_width),
+            attrs=boundary.attrs,
+        )
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        return patch_tree.new(
+            data=kernels.slope_filter_kernel(
+                patch_tree.data,
+                axes=self.axes,
+                dxs=self.dxs,
+                mask=self.mask,
+                steps=self.steps,
+                sizes=self.sizes,
+                pad_width=self.pad_width,
+            )
+        )
+
+    def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary:
+        return boundary.new(attrs=self.attrs)
+
+
+@dataclass(frozen=True)
+class PassFilter(PatchOperation):
+    """Apply a band, low, or high pass filter along one dimension."""
+
+    corners: int = 4
+    zerophase: bool = True
+    kwargs: dict[str, Any] | None = None
+    sos: Any = None
+    zi: Any = None
+    padlen: int | None = None
+    axis: int | None = None
+
+    def __init__(self, corners=4, zerophase=True, **kwargs):
+        object.__setattr__(self, "corners", int(corners))
+        object.__setattr__(self, "zerophase", bool(zerophase))
+        object.__setattr__(self, "kwargs", dict(kwargs))
+        object.__setattr__(self, "sos", None)
+        object.__setattr__(self, "zi", None)
+        object.__setattr__(self, "padlen", None)
+        object.__setattr__(self, "axis", None)
+
+    def bind(self, boundary: PatchBoundary) -> Self:
+        from dascore.utils.misc import check_filter_kwargs
+
+        dim, (arg1, arg2) = check_filter_kwargs(self.kwargs or {})
+        filt_min, filt_max = get_filter_units(
+            arg1, arg2, to_unit=boundary.coord(dim).units, dim=dim
+        )
+        sr = get_dim_sampling_rate(dummy_patch(boundary), dim)
+        sos = np.asarray(
+            kernels.design_pass_filter_sos(sr, filt_min, filt_max, self.corners)
+        )
+        return replace(
+            self,
+            sos=sos,
+            zi=kernels.pass_filter_initial_state(sos),
+            padlen=kernels.pass_filter_default_padlen(sos),
+            axis=boundary.axis(dim),
+        )
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        assert self.axis is not None and self.padlen is not None
+        return patch_tree.new(
+            data=kernels.pass_filter_kernel(
+                patch_tree.data,
+                sos=self.sos,
+                zi=self.zi,
+                padlen=self.padlen,
+                axis=self.axis,
+                zerophase=self.zerophase,
+            )
+        )
diff --git a/src/dasjax/operations/filters/__init__.py b/src/dasjax/operations/filters/__init__.py
deleted file mode 100644
index 06db4fb..0000000
--- a/src/dasjax/operations/filters/__init__.py
+++ /dev/null
@@ -1,5 +0,0 @@
-"""Filter operation family."""
-
-from .specs import OPERATIONS
-
-__all__ = ["OPERATIONS"]
diff --git a/src/dasjax/operations/filters/impl.py b/src/dasjax/operations/filters/impl.py
deleted file mode 100644
index e11184c..0000000
--- a/src/dasjax/operations/filters/impl.py
+++ /dev/null
@@ -1,415 +0,0 @@
-"""Executable implementations for filter operations."""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Any
-
-import numpy as np
-from dascore.constants import PatchType
-from dascore.exceptions import ParameterError
-from dascore.units import get_filter_units
-from dascore.utils.misc import check_filter_kwargs
-from dascore.utils.patch import (
-    get_dim_axis_value,
-    get_dim_sampling_rate,
-    get_patch_window_size,
-)
-
-from dasjax import kernels
-
-from ..common import update_patch
-from ..patch_ops import PatchOp
-
-
-@dataclass(frozen=True)
-class GaussianFilterOp(PatchOp):
-    """Compiled gaussian_filter operation."""
-
-    sigma: tuple[float, ...]
-    axes: tuple[int, ...]
-    mode: str = "reflect"
-    cval: float = 0.0
-    truncate: float = 4.0
-    requires_materialized_patch_for_prepare = True
-
-    @classmethod
-    def prepare(
-        cls,
-        patch: PatchType,
-        samples: bool = False,
-        mode: str = "reflect",
-        cval: float = 0.0,
-        truncate: float = 4.0,
-        **kwargs,
-    ) -> "GaussianFilterOp":
-        _, prepared = prepare_gaussian_call(
-            patch,
-            (),
-            {
-                "samples": samples,
-                "mode": mode,
-                "cval": cval,
-                "truncate": truncate,
-                **kwargs,
-            },
-        )
-        return cls(**prepared)
-
-    def kernel(self, data):
-        return {
-            "data": kernels.gaussian_filter_kernel(
-                data,
-                sigma=self.sigma,
-                axes=self.axes,
-                mode=self.mode,
-                cval=self.cval,
-                truncate=self.truncate,
-            )
-        }
-
-
-@dataclass(frozen=True)
-class HampelFilterOp(PatchOp):
-    """Compiled hampel_filter operation."""
-
-    size: tuple[int, ...]
-    threshold: float
-    approximate: bool = True
-    requires_materialized_patch_for_prepare = True
-
-    @classmethod
-    def prepare(
-        cls,
-        patch: PatchType,
-        *,
-        threshold: float = 10.0,
-        samples: bool = False,
-        approximate: bool = True,
-        **kwargs,
-    ) -> "HampelFilterOp":
-        validate_hampel_filter_patch_input(patch, threshold=threshold)
-        validate_hampel_filter_compiled_input(
-            patch,
-            (),
-            {
-                "threshold": threshold,
-                "samples": samples,
-                "approximate": approximate,
-                **kwargs,
-            },
-        )
-        _, prepared = prepare_hampel_call(
-            patch,
-            (),
-            {
-                "threshold": threshold,
-                "samples": samples,
-                "approximate": approximate,
-                **kwargs,
-            },
-        )
-        return cls(**prepared)
-
-    def kernel(self, data):
-        return {
-            "data": kernels.hampel_filter_kernel(
-                data,
-                size=self.size,
-                threshold=self.threshold,
-                approximate=self.approximate,
-            )
-        }
-
-
-@dataclass(frozen=True)
-class PassFilterOp(PatchOp):
-    """Compiled pass_filter operation."""
-
-    sos: Any
-    zi: Any
-    padlen: int
-    axis: int
-    zerophase: bool = True
-    requires_materialized_patch_for_prepare = True
-
-    @classmethod
-    def prepare(
-        cls,
-        patch: PatchType,
-        corners: int = 4,
-        zerophase: bool = True,
-        **kwargs,
-    ) -> "PassFilterOp":
-        _, prepared = prepare_pass_filter_call(
-            patch,
-            (),
-            {"corners": corners, "zerophase": zerophase, **kwargs},
-        )
-        return cls(**prepared)
-
-    def kernel(self, data):
-        return {
-            "data": kernels.pass_filter_kernel(
-                data,
-                sos=self.sos,
-                zi=self.zi,
-                padlen=self.padlen,
-                axis=self.axis,
-                zerophase=self.zerophase,
-            )
-        }
-
-
-def prepare_gaussian_call(
-    patch: PatchType,
-    args: tuple[Any, ...],
-    kwargs: dict[str, Any],
-) -> tuple[tuple[Any, ...], dict[str, Any]]:
-    _ = args
-    call_kwargs = dict(kwargs)
-    samples = call_kwargs.pop("samples", False)
-    mode = call_kwargs.pop("mode", "reflect")
-    cval = float(call_kwargs.pop("cval", 0.0))
-    truncate = float(call_kwargs.pop("truncate", 4.0))
-    dimfo = get_dim_axis_value(patch, kwargs=call_kwargs, allow_multiple=True)
-    axes = []
-    sigma = []
-    for dim, axis, value in dimfo:
-        coord = patch.get_coord(dim)
-        sigma.append(float(coord.get_sample_count(value, samples=samples)))
-        axes.append(axis)
-    return (), {
-        "sigma": tuple(sigma),
-        "axes": tuple(axes),
-        "mode": mode,
-        "cval": cval,
-        "truncate": truncate,
-    }
-
-
-def gaussian_filter_patch(
-    patch: PatchType,
-    samples: bool = False,
-    mode: str = "reflect",
-    cval: float = 0.0,
-    truncate: float = 4.0,
-    **kwargs,
-) -> PatchType:
-    _, prepared = prepare_gaussian_call(
-        patch,
-        (),
-        {
-            "samples": samples,
-            "mode": mode,
-            "cval": cval,
-            "truncate": truncate,
-            **kwargs,
-        },
-    )
-    return update_patch(patch, kernels.gaussian_filter_kernel(patch.data, **prepared))
-
-
-def gaussian_filter_leaves(
-    data: Any,
-    coord_leaves: tuple[Any, ...],
-    *,
-    dims: tuple[str, ...],
-    sigma: tuple[float, ...],
-    axes: tuple[int, ...],
-    mode: str = "reflect",
-    cval: float = 0.0,
-    truncate: float = 4.0,
-) -> tuple[Any, tuple[Any, ...]]:
-    _ = dims
-    return kernels.gaussian_filter_kernel(
-        data, sigma=sigma, axes=axes, mode=mode, cval=cval, truncate=truncate
-    ), coord_leaves
-
-
-def validate_hampel_filter_patch_input(
-    patch: PatchType,
-    threshold: float = 10.0,
-    **kwargs,
-) -> None:
-    _ = patch, kwargs
-    if threshold <= 0 or not np.isfinite(threshold):
-        raise ParameterError(
-            "hampel_filter threshold must be finite and greater than zero"
-        )
-
-
-def validate_hampel_filter_compiled_input(
-    patch: PatchType,
-    args: tuple[Any, ...],
-    kwargs: dict[str, Any],
-) -> None:
-    validate_hampel_filter_patch_input(patch, **kwargs)
-    if not kwargs.get("approximate", True):
-        raise NotImplementedError(
-            "Compiled hampel_filter currently requires approximate=True."
-        )
-    if not kernels.is_finite_array(patch.data):
-        raise NotImplementedError(
-            "Compiled hampel_filter currently requires finite input data."
-        )
-
-
-def fallback_gaussian_filter_reason(
-    patch: PatchType,
-    args: tuple[Any, ...],
-    kwargs: dict[str, Any],
-) -> str | None:
-    _ = patch, args, kwargs
-    return "gaussian_filter uses a host callback in compiled pipelines."
-
-
-def fallback_hampel_filter_reason(
-    patch: PatchType,
-    args: tuple[Any, ...],
-    kwargs: dict[str, Any],
-) -> str | None:
-    _ = args
-    if not kwargs.get("approximate", True):
-        return "hampel_filter(approximate=False) is not natively compiled."
-    if not kernels.is_finite_array(patch.data):
-        return "hampel_filter with non-finite input data is not natively compiled."
-    return None
-
-
-def guard_compiled_hampel_case(
-    patch: PatchType,
-    args: tuple[Any, ...],
-    kwargs: dict[str, Any],
-) -> tuple[type[Exception], str] | None:
-    _ = args
-    if not kwargs.get("approximate", True):
-        return (
-            NotImplementedError,
-            "Compiled hampel_filter currently requires approximate=True.",
-        )
-    if not kernels.is_finite_array(patch.data):
-        return (
-            NotImplementedError,
-            "Compiled hampel_filter currently requires finite input data.",
-        )
-    return None
-
-
-def prepare_hampel_call(
-    patch: PatchType,
-    args: tuple[Any, ...],
-    kwargs: dict[str, Any],
-) -> tuple[tuple[Any, ...], dict[str, Any]]:
-    _ = args
-    call_kwargs = dict(kwargs)
-    threshold = float(call_kwargs.pop("threshold", 10.0))
-    samples = call_kwargs.pop("samples", False)
-    approximate = bool(call_kwargs.pop("approximate", True))
-    size = get_patch_window_size(
-        patch, call_kwargs, samples, require_odd=True, warn_above=10, min_samples=3
-    )
-    return (), {
-        "size": tuple(int(x) for x in size),
-        "threshold": threshold,
-        "approximate": approximate,
-    }
-
-
-def hampel_filter_patch(
-    patch: PatchType,
-    *,
-    threshold: float = 10.0,
-    samples: bool = False,
-    approximate: bool = True,
-    **kwargs,
-) -> PatchType:
-    validate_hampel_filter_patch_input(patch, threshold=threshold)
-    _, prepared = prepare_hampel_call(
-        patch,
-        (),
-        {
-            "threshold": threshold,
-            "samples": samples,
-            "approximate": approximate,
-            **kwargs,
-        },
-    )
-    if approximate and kernels.is_finite_array(patch.data):
-        return update_patch(patch, kernels.hampel_filter_kernel(patch.data, **prepared))
-    return update_patch(
-        patch, kernels.hampel_filter_callback_kernel(patch.data, **prepared)
-    )
-
-
-def hampel_filter_leaves(
-    data: Any,
-    coord_leaves: tuple[Any, ...],
-    *,
-    dims: tuple[str, ...],
-    size: tuple[int, ...],
-    threshold: float,
-    approximate: bool = True,
-) -> tuple[Any, tuple[Any, ...]]:
-    _ = dims
-    return kernels.hampel_filter_kernel(
-        data, size=size, threshold=threshold, approximate=approximate
-    ), coord_leaves
-
-
-def prepare_pass_filter_call(
-    patch: PatchType,
-    args: tuple[Any, ...],
-    kwargs: dict[str, Any],
-) -> tuple[tuple[Any, ...], dict[str, Any]]:
-    _ = args
-    call_kwargs = dict(kwargs)
-    corners = int(call_kwargs.pop("corners", 4))
-    zerophase = bool(call_kwargs.pop("zerophase", True))
-    dim, (arg1, arg2) = check_filter_kwargs(call_kwargs)
-    coord_units = patch.coords.coord_map[dim].units
-    filt_min, filt_max = get_filter_units(arg1, arg2, to_unit=coord_units, dim=dim)
-
-    def pass_filter() -> float:
-        return get_dim_sampling_rate(patch, dim)
-
-    sr = pass_filter()
-    sos = kernels.design_pass_filter_sos(sr, filt_min, filt_max, corners)
-    return (), {
-        "sos": np.asarray(sos),
-        "zi": kernels.pass_filter_initial_state(np.asarray(sos)),
-        "padlen": kernels.pass_filter_default_padlen(np.asarray(sos)),
-        "axis": patch.get_axis(dim),
-        "zerophase": zerophase,
-    }
-
-
-def pass_filter_patch(
-    patch: PatchType,
-    corners: int = 4,
-    zerophase: bool = True,
-    **kwargs,
-) -> PatchType:
-    _, prepared = prepare_pass_filter_call(
-        patch,
-        (),
-        {"corners": corners, "zerophase": zerophase, **kwargs},
-    )
-    return update_patch(patch, kernels.pass_filter_kernel(patch.data, **prepared))
-
-
-def pass_filter_leaves(
-    data: Any,
-    coord_leaves: tuple[Any, ...],
-    *,
-    dims: tuple[str, ...],
-    sos: Any,
-    zi: Any,
-    padlen: int,
-    axis: int,
-    zerophase: bool = True,
-) -> tuple[Any, tuple[Any, ...]]:
-    _ = dims
-    return kernels.pass_filter_kernel(
-        data, sos=sos, zi=zi, padlen=padlen, axis=axis, zerophase=zerophase
-    ), coord_leaves
diff --git a/src/dasjax/operations/filters/specs.py b/src/dasjax/operations/filters/specs.py
deleted file mode 100644
index 66f771d..0000000
--- a/src/dasjax/operations/filters/specs.py
+++ /dev/null
@@ -1,122 +0,0 @@
-"""Registry specs for filter operations."""
-
-from __future__ import annotations
-
-import dascore as dc
-
-from ..common import baseline_patch_method, prepare_even_patch_for_dim
-from ..types import ExecutionPolicy, OperationCase, OperationSpec
-from . import impl
-
-OPERATIONS: tuple[OperationSpec, ...] = (
-    OperationSpec(
-        name="gaussian_filter",
-        execution_policy=ExecutionPolicy.LEAF,
-        patch_impl=dc.patch_function(history="method_name")(impl.gaussian_filter_patch),
-        patch_op_cls=impl.GaussianFilterOp,
-        leaf_transform=impl.gaussian_filter_leaves,
-        prepare_call=impl.prepare_gaussian_call,
-        compiled_fallback_reason=impl.fallback_gaussian_filter_reason,
-        test_cases=(
-            OperationCase(
-                case_id="gaussian-filter-default",
-                resolve_call=lambda patch: ((), {patch.dims[-1]: 3, "samples": True}),
-                baseline=lambda patch, args, kwargs: baseline_patch_method(
-                    patch, args, kwargs, "gaussian_filter"
-                ),
-            ),
-            OperationCase(
-                case_id="gaussian-filter-constant",
-                resolve_call=lambda patch: (
-                    (),
-                    {
-                        patch.dims[0]: 3,
-                        "samples": True,
-                        "mode": "constant",
-                        "cval": 0.25,
-                    },
-                ),
-                baseline=lambda patch, args, kwargs: baseline_patch_method(
-                    patch, args, kwargs, "gaussian_filter"
-                ),
-            ),
-        ),
-    ),
-    OperationSpec(
-        name="hampel_filter",
-        execution_policy=ExecutionPolicy.LEAF,
-        patch_impl=dc.patch_function(history="method_name")(impl.hampel_filter_patch),
-        patch_op_cls=impl.HampelFilterOp,
-        leaf_transform=impl.hampel_filter_leaves,
-        prepare_call=impl.prepare_hampel_call,
-        validate_patch=impl.validate_hampel_filter_patch_input,
-        validate_compiled_patch=impl.validate_hampel_filter_compiled_input,
-        compiled_fallback_reason=impl.fallback_hampel_filter_reason,
-        test_cases=(
-            OperationCase(
-                case_id="hampel-filter-approximate",
-                resolve_call=lambda patch: (
-                    (),
-                    {
-                        patch.dims[-1]: 3,
-                        "samples": True,
-                        "threshold": 3.5,
-                        "approximate": True,
-                    },
-                ),
-                baseline=lambda patch, args, kwargs: baseline_patch_method(
-                    patch, args, kwargs, "hampel_filter"
-                ),
-                compiled_guard=impl.guard_compiled_hampel_case,
-            ),
-            OperationCase(
-                case_id="hampel-filter-exact",
-                resolve_call=lambda patch: (
-                    (),
-                    {
-                        patch.dims[-1]: 3,
-                        "samples": True,
-                        "threshold": 3.5,
-                        "approximate": False,
-                    },
-                ),
-                baseline=lambda patch, args, kwargs: baseline_patch_method(
-                    patch, args, kwargs, "hampel_filter"
-                ),
-                compiled_guard=impl.guard_compiled_hampel_case,
-            ),
-        ),
-    ),
-    OperationSpec(
-        name="pass_filter",
-        execution_policy=ExecutionPolicy.LEAF,
-        patch_impl=dc.patch_function(history="method_name")(impl.pass_filter_patch),
-        patch_op_cls=impl.PassFilterOp,
-        leaf_transform=impl.pass_filter_leaves,
-        prepare_call=impl.prepare_pass_filter_call,
-        test_cases=(
-            OperationCase(
-                case_id="pass-filter-bandpass",
-                resolve_call=lambda patch: (
-                    (),
-                    {patch.dims[-1]: (1.0, 10.0), "corners": 4, "zerophase": True},
-                ),
-                prepare_patch=prepare_even_patch_for_dim,
-                baseline=lambda patch, args, kwargs: baseline_patch_method(
-                    patch, args, kwargs, "pass_filter"
-                ),
-            ),
-            OperationCase(
-                case_id="pass-filter-lowpass",
-                resolve_call=lambda patch: (
-                    (),
-                    {patch.dims[-1]: (None, 12.0), "corners": 2, "zerophase": False},
-                ),
-                prepare_patch=prepare_even_patch_for_dim,
-                baseline=lambda patch, args, kwargs: baseline_patch_method(
-                    patch, args, kwargs, "pass_filter"
-                ),
-            ),
-        ),
-    ),
-)
diff --git a/src/dasjax/operations/fourier.py b/src/dasjax/operations/fourier.py
new file mode 100644
index 0000000..a05693a
--- /dev/null
+++ b/src/dasjax/operations/fourier.py
@@ -0,0 +1,151 @@
+"""Fourier transform patch operations."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, ClassVar, Self
+
+import dascore as dc
+import jax.numpy as jnp
+import numpy as np
+from dascore.proc.basic import pad as dc_pad
+from dascore.transform.fourier import (
+    _get_idft_dims_steps_axis,
+    dft as dc_dft,
+    idft as dc_idft,
+)
+from dascore.utils.misc import iterate
+from dascore.utils.transformatter import FourierTransformatter
+from scipy.fft import next_fast_len
+
+from dasjax.core import PatchBoundary, PatchOperation, PatchPyTree
+
+from .. import kernels
+from .common import dummy_patch, replace, tree_boundary_from_patch
+
+
+@dataclass(frozen=True)
+class Dft(PatchOperation):
+    """Transform patch data into the frequency domain."""
+
+    method_name: ClassVar[str | None] = "dft"
+    dim: str | None | tuple[str, ...]
+    real: str | bool | None = None
+    pad: bool = True
+    axes: tuple[int, ...] = ()
+    dxs: tuple[float, ...] = ()
+    real_axis: int | None = None
+    pad_width: tuple[tuple[int, int], ...] = ()
+    out_boundary: PatchBoundary | None = None
+    out_coords: tuple[Any, ...] | None = None
+    out_dtype_codes: tuple[Any, ...] | None = None
+    out_dims: tuple[str, ...] | None = None
+
+    def bind(self, boundary: PatchBoundary) -> Self:
+        patch = dummy_patch(boundary)
+        dims = list(iterate(self.dim if self.dim is not None else boundary.dims))
+        real = dims[-1] if self.real is True else self.real
+        if isinstance(real, str) and real in dims:
+            dims.append(dims.pop(dims.index(real)))
+        pad_width = [(0, 0)] * len(boundary.dims)
+        work_patch = patch
+        if self.pad:
+            for dim in dims:
+                axis = work_patch.get_axis(dim)
+                target = next_fast_len(len(work_patch.get_coord(dim)))
+                pad_width[axis] = (0, target - len(work_patch.get_coord(dim)))
+            work_patch = dc_pad.func(work_patch, **{dim: "fft" for dim in dims})
+        axes = tuple(work_patch.get_axis(dim) for dim in dims)
+        dxs = tuple(float(dc.to_float(work_patch.get_coord(dim).step)) for dim in dims)
+        out = dc_dft.func(patch, dim=self.dim, real=self.real, pad=self.pad)
+        out_tree, out_boundary = tree_boundary_from_patch(out)
+        return replace(
+            self,
+            axes=axes,
+            dxs=dxs,
+            real_axis=work_patch.get_axis(real)
+            if isinstance(real, str) and real in dims
+            else None,
+            pad_width=tuple(pad_width),
+            out_boundary=out_boundary,
+            out_coords=out_tree.coord_values,
+            out_dtype_codes=out_tree.coord_dtype_codes,
+            out_dims=out_tree.dims,
+        )
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        data = patch_tree.data
+        if any(before or after for before, after in self.pad_width):
+            data = jnp.pad(data, self.pad_width)
+        data = kernels.dft_kernel(
+            data, axes=self.axes, dxs=self.dxs, real_axis=self.real_axis
+        )
+        return patch_tree.new(
+            data=data,
+            coords=self.out_coords,
+            coord_dtype_codes=self.out_dtype_codes,
+            dims=self.out_dims,
+        )
+
+    def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary:
+        _ = boundary
+        assert self.out_boundary is not None
+        return self.out_boundary
+
+
+@dataclass(frozen=True)
+class Idft(PatchOperation):
+    """Transform patch data from the frequency domain."""
+
+    method_name: ClassVar[str | None] = "idft"
+    dim: str | None | tuple[str, ...] = None
+    axes: tuple[int, ...] = ()
+    steps: tuple[float, ...] = ()
+    sizes: tuple[int, ...] | None = None
+    real: bool = False
+    out_boundary: PatchBoundary | None = None
+    out_coords: tuple[Any, ...] | None = None
+    out_dtype_codes: tuple[Any, ...] | None = None
+    out_dims: tuple[str, ...] | None = None
+
+    def bind(self, boundary: PatchBoundary) -> Self:
+        patch = dummy_patch(boundary, dtype=np.complex128)
+        dims, _steps, axes, real = _get_idft_dims_steps_axis(patch, self.dim)
+        out = dc_idft.func(patch, dim=self.dim)
+        out_tree, out_boundary = tree_boundary_from_patch(out)
+        sizes = tuple(out.shape[axis] for axis in axes)
+        new_dims = FourierTransformatter().rename_dims(dims, forward=False)
+        out_steps = tuple(
+            float(dc.to_float(out.get_coord(dim).step)) for dim in new_dims
+        )
+        return replace(
+            self,
+            axes=tuple(axes),
+            steps=out_steps,
+            sizes=sizes,
+            real=real,
+            out_boundary=out_boundary,
+            out_coords=out_tree.coord_values,
+            out_dtype_codes=out_tree.coord_dtype_codes,
+            out_dims=out_tree.dims,
+        )
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        data = kernels.idft_kernel(
+            patch_tree.data,
+            axes=self.axes,
+            new_steps=self.steps,
+            sizes=self.sizes,
+            real=self.real,
+        )
+        return patch_tree.new(
+            data=data,
+            coords=self.out_coords,
+            coord_dtype_codes=self.out_dtype_codes,
+            dims=self.out_dims,
+        )
+
+    def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary:
+        _ = boundary
+        assert self.out_boundary is not None
+        return self.out_boundary
diff --git a/src/dasjax/operations/hilbert.py b/src/dasjax/operations/hilbert.py
new file mode 100644
index 0000000..234379c
--- /dev/null
+++ b/src/dasjax/operations/hilbert.py
@@ -0,0 +1,128 @@
+"""Hilbert transform patch operations."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Self
+
+import dascore as dc
+from dascore.exceptions import ParameterError
+
+from dasjax.core import PatchBoundary, PatchOperation, PatchPyTree
+
+from .. import kernels
+from .common import dummy_patch, replace, tree_boundary_from_patch
+
+
+@dataclass(frozen=True)
+class Hilbert(PatchOperation):
+    """Compute the analytic signal along one dimension."""
+
+    dim: str
+    axis: int | None = None
+
+    def bind(self, boundary: PatchBoundary) -> Self:
+        if boundary.coord(self.dim).step is None:
+            raise dc.exceptions.CoordError(
+                f"Coordinate {self.dim} is not evenly sampled as required by hilbert"
+            )
+        return replace(self, axis=boundary.axis(self.dim))
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        assert self.axis is not None
+        return patch_tree.new(
+            data=kernels.hilbert_kernel(patch_tree.data, axis=self.axis)
+        )
+
+
+@dataclass(frozen=True)
+class Envelope(Hilbert):
+    """Compute the signal envelope along one dimension."""
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        assert self.axis is not None
+        return patch_tree.new(
+            data=kernels.envelope_kernel(patch_tree.data, axis=self.axis)
+        )
+
+
+@dataclass(frozen=True)
+class PhaseWeightedStack(PatchOperation):
+    """Apply phase-weighted stacking over one dimension."""
+
+    stack_dim: str
+    transform_dim: str | None = None
+    power: float = 2.0
+    dim_reduce: str = "empty"
+    stack_axis: int | None = None
+    transform_axis: int | None = None
+    out_boundary: PatchBoundary | None = None
+    out_coords: tuple[Any, ...] | None = None
+    out_dtype_codes: tuple[Any, ...] | None = None
+    out_dims: tuple[str, ...] | None = None
+
+    def bind(self, boundary: PatchBoundary) -> Self:
+        transform_dim = self.transform_dim
+        if transform_dim is None:
+            other_dims = tuple(dim for dim in boundary.dims if dim != self.stack_dim)
+            if len(other_dims) != 1:
+                msg = "transform_dim must be provided for patches that are not 2D."
+                raise ParameterError(msg)
+            transform_dim = other_dims[0]
+        if boundary.coord(transform_dim).step is None:
+            raise dc.exceptions.CoordError(
+                f"Coordinate {transform_dim} is not evenly sampled as required by hilbert"
+            )
+        out_patch = dummy_patch(boundary).phase_weighted_stack(
+            self.stack_dim,
+            transform_dim=transform_dim,
+            power=self.power,
+            dim_reduce=self.dim_reduce,
+        )
+        out_tree, out_boundary = tree_boundary_from_patch(out_patch)
+        out_coords = out_tree.coord_values
+        out_dtype_codes = out_tree.coord_dtype_codes
+        if self.dim_reduce != "squeeze" and self.stack_dim in out_boundary.coord_names:
+            coord_index = out_boundary.coord_index(self.stack_dim)
+            out_boundary = out_boundary.new(
+                coord_names=tuple(
+                    name for name in out_boundary.coord_names if name != self.stack_dim
+                )
+            )
+            out_coords = tuple(
+                value for idx, value in enumerate(out_coords) if idx != coord_index
+            )
+            out_dtype_codes = tuple(
+                value for idx, value in enumerate(out_dtype_codes) if idx != coord_index
+            )
+        return replace(
+            self,
+            transform_dim=transform_dim,
+            stack_axis=boundary.axis(self.stack_dim),
+            transform_axis=boundary.axis(transform_dim),
+            out_boundary=out_boundary,
+            out_coords=out_coords,
+            out_dtype_codes=out_dtype_codes,
+            out_dims=out_tree.dims,
+        )
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        assert self.stack_axis is not None and self.transform_axis is not None
+        data = kernels.phase_weighted_stack_kernel(
+            patch_tree.data,
+            stack_axis=self.stack_axis,
+            transform_axis=self.transform_axis,
+            power=self.power,
+            squeeze=self.dim_reduce == "squeeze",
+        )
+        return patch_tree.new(
+            data=data,
+            coords=self.out_coords,
+            coord_dtype_codes=self.out_dtype_codes,
+            dims=self.out_dims,
+        )
+
+    def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary:
+        _ = boundary
+        assert self.out_boundary is not None
+        return self.out_boundary
diff --git a/src/dasjax/operations/integrate.py b/src/dasjax/operations/integrate.py
new file mode 100644
index 0000000..6a23905
--- /dev/null
+++ b/src/dasjax/operations/integrate.py
@@ -0,0 +1,89 @@
+"""Integrate patch operation."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from operator import mul
+from typing import Any, Self
+
+import dascore as dc
+from dascore.utils.misc import iterate
+
+from dasjax.core import PatchBoundary, PatchOperation, PatchPyTree
+
+from .. import compat, kernels
+from .common import (
+    dummy_patch,
+    get_data_units_from_dims,
+    replace,
+    tree_boundary_from_patch,
+)
+
+
+@dataclass(frozen=True)
+class Integrate(PatchOperation):
+    """Integrate patch data along one or more dimensions."""
+
+    dim: str | tuple[str, ...] | None
+    definite: bool = False
+    axes: tuple[int, ...] = ()
+    dxs_or_spacing: tuple[Any, ...] = ()
+    attrs: Any = None
+    out_boundary: PatchBoundary | None = None
+    out_coords: tuple[Any, ...] | None = None
+    out_dtype_codes: tuple[Any, ...] | None = None
+    out_dims: tuple[str, ...] | None = None
+
+    def bind(self, boundary: PatchBoundary) -> Self:
+        dims = tuple(iterate(self.dim if self.dim is not None else boundary.dims))
+        axes = []
+        dxs = []
+        for dim in dims:
+            coord = dummy_patch(boundary).get_coord(dim, require_sorted=True)
+            val = coord.step if coord.evenly_sampled else coord.data
+            dxs.append(dc.to_float(val))
+            axes.append(boundary.axis(dim))
+        updates = {"data_units": get_data_units_from_dims(boundary, dims, mul)}
+        # A definite integral reduces the dims away, so any coordinate
+        # metadata the attributes still describe has to go with them. On
+        # DASCore's dev branch the attributes no longer carry coordinates at
+        # all, and there is nothing left to clear.
+        if self.definite and compat.attrs_carry_coords(boundary.attrs):
+            updates["coords"] = {}
+        attrs = boundary.attrs.update(**updates)
+        if self.definite:
+            out_patch = dummy_patch(boundary).integrate(dim=dims, definite=True)
+            out_tree, out_boundary = tree_boundary_from_patch(out_patch)
+            return replace(
+                self,
+                axes=tuple(axes),
+                dxs_or_spacing=tuple(dxs),
+                attrs=attrs,
+                out_boundary=out_boundary,
+                out_coords=out_tree.coord_values,
+                out_dtype_codes=out_tree.coord_dtype_codes,
+                out_dims=out_tree.dims,
+            )
+        return replace(self, axes=tuple(axes), dxs_or_spacing=tuple(dxs), attrs=attrs)
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        data = patch_tree.data
+        for axis, spacing in zip(self.axes, self.dxs_or_spacing, strict=True):
+            data = kernels.integrate_kernel(
+                data, axis=axis, dx_or_spacing=spacing, definite=self.definite
+            )
+        if self.definite:
+            return patch_tree.new(
+                data=data,
+                coords=self.out_coords,
+                dims=self.out_dims,
+                coord_dtype_codes=self.out_dtype_codes,
+            )
+        return patch_tree.new(data=data)
+
+    def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary:
+        return (
+            self.out_boundary
+            if self.definite and self.out_boundary
+            else boundary.new(attrs=self.attrs)
+        )
diff --git a/src/dasjax/operations/mute.py b/src/dasjax/operations/mute.py
new file mode 100644
index 0000000..d1f55f6
--- /dev/null
+++ b/src/dasjax/operations/mute.py
@@ -0,0 +1,106 @@
+"""Mute patch operations."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Self
+
+import numpy as np
+import dascore as dc
+from dascore.exceptions import ParameterError
+from dascore.proc.mute import line_mute as dc_line_mute
+
+from dasjax.core import PatchBoundary, PatchOperation, PatchPyTree
+
+from .. import kernels
+from .common import dummy_patch, replace
+
+
+def _ones_patch(boundary: PatchBoundary):
+    """Create a metadata-only patch with ones for mask construction."""
+    patch = dummy_patch(boundary)
+    return patch.update(data=np.ones(patch.shape, dtype=np.float64))
+
+
+@dataclass(frozen=True)
+class LineMute(PatchOperation):
+    """Mute data in a region bounded by one or two lines."""
+
+    smooth: Any = None
+    invert: bool = False
+    relative: bool = True
+    kwargs: dict[str, Any] | None = None
+    mask: Any = None
+
+    def __init__(self, *, smooth=None, invert=False, relative=True, **kwargs):
+        object.__setattr__(self, "smooth", smooth)
+        object.__setattr__(self, "invert", bool(invert))
+        object.__setattr__(self, "relative", bool(relative))
+        object.__setattr__(self, "kwargs", dict(kwargs))
+        object.__setattr__(self, "mask", None)
+
+    def bind(self, boundary: PatchBoundary) -> Self:
+        mask_patch = dc_line_mute.func(
+            _ones_patch(boundary),
+            smooth=self.smooth,
+            invert=self.invert,
+            relative=self.relative,
+            **(self.kwargs or {}),
+        )
+        return replace(self, mask=np.asarray(mask_patch.data))
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        return patch_tree.new(
+            data=kernels.apply_mask_kernel(patch_tree.data, self.mask)
+        )
+
+
+@dataclass(frozen=True)
+class SlopeMute(PatchOperation):
+    """Mute data between two slope boundaries."""
+
+    slopes: Any
+    dims: tuple[str, str] = ("distance", "time")
+    smooth: Any = None
+    invert: bool = False
+    mask: Any = None
+
+    def bind(self, boundary: PatchBoundary) -> Self:
+        slopes = np.asarray(self.slopes)
+        if slopes.shape != (2,):
+            msg = "slopes must be a sequence of length 2"
+            raise ParameterError(msg)
+        if np.any(slopes < 0):
+            msg = "slopes must be positive."
+            raise ParameterError(msg)
+        patch = _ones_patch(boundary)
+        coord_x, coord_y = (patch.get_coord(x, require_sorted=True) for x in self.dims)
+        origin = (float(dc.to_float(coord_x[0])), float(dc.to_float(coord_y[0])))
+        range_x = float(dc.to_float(coord_x[-1] - coord_x[0]))
+        dim0_vals = [[origin[0], origin[0] + range_x], [origin[0], origin[0] + range_x]]
+        dim1_vals = [[origin[1], None], [origin[1], None]]
+        for num, slope in enumerate(slopes):
+            if np.isclose(slope, 0):
+                dim0_vals[num][1] = origin[0]
+                dim1_vals[num][1] = origin[1] + 1
+            elif np.isinf(slope):
+                dim0_vals[num][1] = origin[0] + 1
+                dim1_vals[num][1] = origin[1]
+            else:
+                dim1_vals[num][1] = origin[1] + range_x / slope
+        mask_patch = dc_line_mute.func(
+            patch,
+            **{
+                self.dims[0]: dim0_vals,
+                self.dims[1]: dim1_vals,
+                "smooth": self.smooth,
+                "invert": self.invert,
+                "relative": False,
+            },
+        )
+        return replace(self, mask=np.asarray(mask_patch.data))
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        return patch_tree.new(
+            data=kernels.apply_mask_kernel(patch_tree.data, self.mask)
+        )
diff --git a/src/dasjax/operations/normalize.py b/src/dasjax/operations/normalize.py
new file mode 100644
index 0000000..848e04e
--- /dev/null
+++ b/src/dasjax/operations/normalize.py
@@ -0,0 +1,31 @@
+"""Normalize patch operation."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Self
+
+from dasjax.core import PatchBoundary, PatchOperation, PatchPyTree
+
+from .. import kernels
+from .common import replace
+
+
+@dataclass(frozen=True)
+class Normalize(PatchOperation):
+    """Normalize patch data along one dimension."""
+
+    dim: str
+    norm: str = "l2"
+    axis: int | None = None
+
+    def bind(self, boundary: PatchBoundary) -> Self:
+        return replace(self, axis=boundary.axis(self.dim))
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        assert self.axis is not None
+        return patch_tree.new(
+            data=kernels.normalize_kernel(
+                patch_tree.data, axis=self.axis, norm=self.norm
+            )
+        )
diff --git a/src/dasjax/operations/numeric.py b/src/dasjax/operations/numeric.py
new file mode 100644
index 0000000..eaa3ba8
--- /dev/null
+++ b/src/dasjax/operations/numeric.py
@@ -0,0 +1,184 @@
+"""Numeric DASCore patch operations backed by host callbacks."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, ClassVar, Self
+
+import jax
+import numpy as np
+
+from dasjax.core import PatchBoundary, PatchOperation, PatchPyTree
+
+from .common import dummy_patch, replace, tree_boundary_from_patch
+
+
+def _init_callback(obj: Any, args: tuple[Any, ...], kwargs: dict[str, Any]) -> None:
+    object.__setattr__(obj, "args", args)
+    object.__setattr__(obj, "kwargs", kwargs)
+    object.__setattr__(obj, "boundary", None)
+    object.__setattr__(obj, "out_shape", None)
+    object.__setattr__(obj, "out_dtype", None)
+    object.__setattr__(obj, "out_boundary", None)
+    object.__setattr__(obj, "out_coords", None)
+    object.__setattr__(obj, "out_dtype_codes", None)
+    object.__setattr__(obj, "out_dims", None)
+
+
+@dataclass(frozen=True)
+class _DascoreCallbackOperation(PatchOperation):
+    """Run DASCore numeric transforms whose full kernels are not yet ported."""
+
+    register: ClassVar[bool] = False
+    args: tuple[Any, ...] = ()
+    kwargs: dict[str, Any] | None = None
+    boundary: PatchBoundary | None = None
+    out_shape: tuple[int, ...] | None = None
+    out_dtype: Any = None
+    out_boundary: PatchBoundary | None = None
+    out_coords: tuple[Any, ...] | None = None
+    out_dtype_codes: tuple[Any, ...] | None = None
+    out_dims: tuple[str, ...] | None = None
+
+    def _call(self, patch):
+        return getattr(patch, type(self).operation_name())(
+            *self.args,
+            **(self.kwargs or {}),
+        )
+
+    def bind(self, boundary: PatchBoundary) -> Self:
+        out = self._call(dummy_patch(boundary))
+        out_tree, out_boundary = tree_boundary_from_patch(out)
+        return replace(
+            self,
+            boundary=boundary,
+            out_shape=out.shape,
+            out_dtype=np.asarray(out.data).dtype,
+            out_boundary=out_boundary,
+            out_coords=out_tree.coord_values,
+            out_dtype_codes=out_tree.coord_dtype_codes,
+            out_dims=out_tree.dims,
+        )
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        assert self.boundary is not None
+        assert self.out_shape is not None and self.out_dtype is not None
+
+        def _callback(data, *coord_leaves):
+            coord_count = len(coord_leaves) // 2
+            coords = tuple(coord_leaves[:coord_count])
+            dtype_codes = tuple(coord_leaves[coord_count:])
+            tree = PatchPyTree(
+                data=data,
+                coord_values=coords,
+                coord_dtype_codes=dtype_codes,
+                dims=self.boundary.dims,
+            )
+            patch = self.boundary.to_patch(tree)
+            return np.asarray(self._call(patch).data)
+
+        result = jax.pure_callback(
+            _callback,
+            jax.ShapeDtypeStruct(self.out_shape, self.out_dtype),
+            patch_tree.data,
+            *patch_tree.coord_values,
+            *patch_tree.coord_dtype_codes,
+            vmap_method="sequential",
+        )
+        return patch_tree.new(
+            data=result,
+            coords=self.out_coords,
+            coord_dtype_codes=self.out_dtype_codes,
+            dims=self.out_dims,
+        )
+
+    def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary:
+        _ = boundary
+        assert self.out_boundary is not None
+        return self.out_boundary
+
+
+@dataclass(frozen=True)
+class Correlate(_DascoreCallbackOperation):
+    """Correlate source rows or columns with all other rows or columns."""
+
+    def __init__(self, samples: bool = False, **kwargs):
+        # `lag` is deliberately not defaulted into the call. DASCore's dev
+        # branch removed the parameter and rejects it outright, `lag=None`
+        # included, asking callers to select on the lag coordinate instead.
+        # Forwarding it only when it is given keeps the release's behaviour
+        # and lets dev's own error reach anyone who really passes one.
+        _init_callback(self, (), {"samples": samples, **kwargs})
+
+
+@dataclass(frozen=True)
+class Decimate(_DascoreCallbackOperation):
+    """Decimate a patch along a dimension."""
+
+    def __init__(self, filter_type: str | None = "iir", copy: bool = True, **kwargs):
+        _init_callback(self, (), {"filter_type": filter_type, "copy": copy, **kwargs})
+
+
+@dataclass(frozen=True)
+class Interpolate(_DascoreCallbackOperation):
+    """Interpolate along one dimension."""
+
+    def __init__(self, kind: str | int = "linear", **kwargs):
+        _init_callback(self, (), {"kind": kind, **kwargs})
+
+
+@dataclass(frozen=True)
+class Istft(_DascoreCallbackOperation):
+    """Invert a short-time Fourier transform."""
+
+    method_name: ClassVar[str | None] = "istft"
+
+
+@dataclass(frozen=True)
+class Resample(_DascoreCallbackOperation):
+    """Resample along one dimension."""
+
+    def __init__(
+        self,
+        window=None,
+        interp_kind: str = "linear",
+        samples: bool = False,
+        **kwargs,
+    ):
+        _init_callback(
+            self,
+            (),
+            {
+                "window": window,
+                "interp_kind": interp_kind,
+                "samples": samples,
+                **kwargs,
+            },
+        )
+
+
+@dataclass(frozen=True)
+class Stft(_DascoreCallbackOperation):
+    """Perform a short-time Fourier transform."""
+
+    method_name: ClassVar[str | None] = "stft"
+
+    def __init__(
+        self,
+        taper_window: str | np.ndarray | tuple[str, Any, ...] = "hann",
+        overlap=None,
+        samples: bool = False,
+        detrend: bool = False,
+        **kwargs,
+    ):
+        _init_callback(
+            self,
+            (),
+            {
+                "taper_window": taper_window,
+                "overlap": overlap,
+                "samples": samples,
+                "detrend": detrend,
+                **kwargs,
+            },
+        )
diff --git a/src/dasjax/operations/pad.py b/src/dasjax/operations/pad.py
new file mode 100644
index 0000000..cf92752
--- /dev/null
+++ b/src/dasjax/operations/pad.py
@@ -0,0 +1,104 @@
+"""Pad patch operation."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Self
+
+import jax.numpy as jnp
+from dascore.proc.basic import pad as dc_pad
+from dascore.utils.patch import get_dim_axis_value
+from scipy.fft import next_fast_len
+
+from dasjax.core import PatchBoundary, PatchOperation, PatchPyTree
+
+from .common import dummy_patch, replace, tree_boundary_from_patch
+
+
+@dataclass(frozen=True)
+class Pad(PatchOperation):
+    """Pad patch data and optionally expand coordinates."""
+
+    mode: str = "constant"
+    constant_values: Any = 0
+    expand_coords: bool = True
+    samples: bool = False
+    kwargs: dict[str, Any] | None = None
+    data_pad_width: tuple[tuple[int, int], ...] = ()
+    out_boundary: PatchBoundary | None = None
+    out_coords: tuple[Any, ...] | None = None
+    out_dtype_codes: tuple[Any, ...] | None = None
+    out_dims: tuple[str, ...] | None = None
+
+    def __init__(
+        self,
+        mode="constant",
+        constant_values=0,
+        expand_coords=True,
+        samples=False,
+        **kwargs,
+    ):
+        object.__setattr__(self, "mode", mode)
+        object.__setattr__(self, "constant_values", constant_values)
+        object.__setattr__(self, "expand_coords", expand_coords)
+        object.__setattr__(self, "samples", samples)
+        object.__setattr__(self, "kwargs", dict(kwargs))
+        object.__setattr__(self, "data_pad_width", ())
+        object.__setattr__(self, "out_boundary", None)
+        object.__setattr__(self, "out_coords", None)
+        object.__setattr__(self, "out_dtype_codes", None)
+        object.__setattr__(self, "out_dims", None)
+
+    def bind(self, boundary: PatchBoundary) -> Self:
+        patch = dummy_patch(boundary)
+        pad_width = [(0, 0)] * len(patch.shape)
+        dimfo = get_dim_axis_value(patch, kwargs=self.kwargs or {}, allow_multiple=True)
+        for dim, axis, value in dimfo:
+            coord = patch.get_coord(dim, require_evenly_sampled=False)
+            if value in {"fft", "correlate"}:
+                target_length = len(coord) if value == "fft" else 2 * len(coord) - 1
+                pad_tuple = (0, next_fast_len(target_length) - len(coord))
+            else:
+                if not isinstance(value, (tuple, list)):
+                    value = (value, value)
+                pad_tuple = (
+                    tuple(int(coord.get_sample_count(x)) for x in value)
+                    if not self.samples
+                    else tuple(int(x) for x in value)
+                )
+            pad_width[axis] = tuple(pad_tuple)
+        out = dc_pad.func(
+            patch,
+            mode=self.mode,
+            constant_values=self.constant_values,
+            expand_coords=self.expand_coords,
+            samples=self.samples,
+            **(self.kwargs or {}),
+        )
+        out_tree, out_boundary = tree_boundary_from_patch(out)
+        return replace(
+            self,
+            data_pad_width=tuple(pad_width),
+            out_boundary=out_boundary,
+            out_coords=out_tree.coord_values,
+            out_dtype_codes=out_tree.coord_dtype_codes,
+            out_dims=out_tree.dims,
+        )
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        return patch_tree.new(
+            data=jnp.pad(
+                patch_tree.data,
+                self.data_pad_width,
+                mode=self.mode,
+                constant_values=self.constant_values,
+            ),
+            coords=self.out_coords,
+            coord_dtype_codes=self.out_dtype_codes,
+            dims=self.out_dims,
+        )
+
+    def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary:
+        _ = boundary
+        assert self.out_boundary is not None
+        return self.out_boundary
diff --git a/src/dasjax/operations/patch_ops.py b/src/dasjax/operations/patch_ops.py
deleted file mode 100644
index 86b1851..0000000
--- a/src/dasjax/operations/patch_ops.py
+++ /dev/null
@@ -1,424 +0,0 @@
-"""Unified PatchOp runtime for compiled patch-state execution."""
-
-from __future__ import annotations
-
-import inspect
-from collections.abc import Callable
-from dataclasses import dataclass, field
-from typing import Any
-
-import dascore as dc
-import jax
-import numpy as np
-
-from ..pytree import _decode_leaf, _encode_leaf
-
-
-@jax.tree_util.register_pytree_node_class
-@dataclass(frozen=True)
-class PatchState:
-    """JAX-friendly dynamic patch state."""
-
-    data: Any
-    coords: dict[str, Any]
-
-    def tree_flatten(self):
-        return ((self.data, self.coords), None)
-
-    @classmethod
-    def tree_unflatten(cls, aux_data, children):
-        _ = aux_data
-        data, coords = children
-        return cls(data=data, coords=coords)
-
-    def with_updates(
-        self,
-        *,
-        data: Any | None = None,
-        coords: dict[str, Any] | None = None,
-    ) -> "PatchState":
-        return PatchState(
-            data=self.data if data is None else data,
-            coords=self.coords if coords is None else coords,
-        )
-
-
-@dataclass(frozen=True)
-class CoordSpec:
-    """Static reconstruction metadata for one coordinate."""
-
-    name: str
-    dims: tuple[str, ...]
-    dtype: str
-    coord: Any
-
-
-@dataclass(frozen=True)
-class PatchSpec:
-    """Static reconstruction metadata for one patch state."""
-
-    dims: tuple[str, ...]
-    attrs: Any
-    coord_specs: tuple[CoordSpec, ...]
-
-    def apply_meta(self, meta: "MetaDelta | None") -> "PatchSpec":
-        """Return a new spec with a metadata delta applied."""
-        if meta is None:
-            return self
-        return PatchSpec(
-            dims=self.dims if meta.dims is None else meta.dims,
-            attrs=self.attrs if meta.attrs is None else meta.attrs,
-            coord_specs=self.coord_specs
-            if meta.coord_specs is None
-            else meta.coord_specs,
-        )
-
-
-@dataclass(frozen=True)
-class MetaDelta:
-    """Static metadata changes produced by a PatchOp."""
-
-    dims: tuple[str, ...] | None = None
-    attrs: Any | None = None
-    coord_specs: tuple[CoordSpec, ...] | None = None
-
-
-@dataclass(frozen=True)
-class OpResult:
-    """Normalized output of one compiled patch op."""
-
-    data: Any | None = None
-    coords: dict[str, Any] | None = None
-    meta: MetaDelta | None = None
-
-
-def patch_to_state_spec(patch: dc.Patch) -> tuple[PatchState, PatchSpec]:
-    """Convert a DASCore patch into dynamic state plus static spec."""
-    coord_specs = []
-    coord_values: dict[str, Any] = {}
-    for name, coord in patch.coords.coord_map.items():
-        encoded_values, dtype_token = _encode_leaf(coord.values)
-        coord_values[name] = encoded_values
-        coord_specs.append(
-            CoordSpec(
-                name=name,
-                dims=tuple(patch.coords.dim_map[name]),
-                dtype=dtype_token,
-                coord=coord,
-            )
-        )
-    return PatchState(
-        data=patch.data,
-        coords=coord_values,
-    ), PatchSpec(
-        dims=tuple(patch.dims),
-        attrs=patch.attrs,
-        coord_specs=tuple(coord_specs),
-    )
-
-
-def patch_from_state_spec(
-    state: PatchState,
-    spec: PatchSpec,
-    *,
-    coerce_numpy: bool = True,
-) -> dc.Patch:
-    """Rebuild a DASCore patch from dynamic state and static spec."""
-    coords: dict[str, Any] = {}
-    for coord_spec in spec.coord_specs:
-        values = _decode_leaf(state.coords[coord_spec.name], coord_spec.dtype)
-        coord = coord_spec.coord.update_data(data=values)
-        dims = tuple(coord_spec.dims)
-        coords[coord_spec.name] = (
-            coord if len(dims) == 1 and dims[0] == coord_spec.name else (dims, coord)
-        )
-    return dc.Patch(
-        data=np.asarray(state.data) if coerce_numpy else state.data,
-        coords=coords,
-        dims=spec.dims,
-        attrs=spec.attrs,
-    )
-
-
-class PatchOp:
-    """Base class for unified compiled patch operations."""
-
-    _subclasses: list[type["PatchOp"]] = []
-    _register_subclass = True
-    mutates_spec = False
-    requires_materialized_patch_after = False
-    requires_materialized_patch_for_prepare = False
-    compile_category = "kernel_fusible"
-
-    def __init_subclass__(cls, **kwargs: Any) -> None:
-        super().__init_subclass__(**kwargs)
-        if cls is PatchOp:
-            return
-        if cls.__dict__.get("_register_subclass", True):
-            PatchOp._subclasses.append(cls)
-
-    @classmethod
-    def iter_subclasses(cls) -> tuple[type["PatchOp"], ...]:
-        """Return registered PatchOp subclasses."""
-        return tuple(cls._subclasses)
-
-    @classmethod
-    def compile_category_table(cls) -> dict[str, tuple[str, ...]]:
-        """Group registered PatchOp subclasses by compile category."""
-        categories: dict[str, list[str]] = {}
-        for subclass in cls._subclasses:
-            categories.setdefault(subclass.compile_category, []).append(
-                subclass.__name__
-            )
-        return {key: tuple(sorted(value)) for key, value in sorted(categories.items())}
-
-    @classmethod
-    def prepare(cls, patch: dc.Patch, *args: Any, **kwargs: Any) -> "PatchOp":
-        """Default prepare: instantiate and bind inferred patch attrs."""
-        op = cls(*args, **kwargs)
-        object.__setattr__(op, "_prepared_attrs", cls._prepare_attrs(patch, op))
-        object.__setattr__(
-            op,
-            "_prepared_selected",
-            cls._prepare_selected(patch, args, kwargs, op),
-        )
-        cls._validate_kernel_bindings(patch, op)
-        return op
-
-    @staticmethod
-    def _kernel_parameters(op: "PatchOp") -> tuple[str, ...]:
-        params = inspect.signature(op.kernel).parameters
-        return tuple(name for name in params if name != "self")
-
-    @classmethod
-    def _prepare_attrs(cls, patch: dc.Patch, op: "PatchOp") -> dict[str, Any]:
-        prepared: dict[str, Any] = {}
-        for name in cls._kernel_parameters(op):
-            if name.startswith("attr_"):
-                attr_name = name[5:]
-                prepared[attr_name] = patch.attrs[attr_name]
-        return prepared
-
-    @staticmethod
-    def _requires_selected(op: "PatchOp") -> bool:
-        return any(
-            name.startswith("selected_") for name in PatchOp._kernel_parameters(op)
-        )
-
-    @staticmethod
-    def _encode_bound_value(value: Any) -> Any:
-        encoded, _ = _encode_leaf(np.asarray(value))
-        if np.asarray(encoded).shape == ():
-            return np.asarray(encoded).item()
-        return encoded
-
-    @classmethod
-    def _resolve_selected_context(
-        cls,
-        patch: dc.Patch,
-        args: tuple[Any, ...],
-        kwargs: dict[str, Any],
-    ) -> tuple[str, int, Any]:
-        _ = args
-        selected_dim = kwargs.get("dim")
-        if selected_dim is not None:
-            if selected_dim not in patch.dims:
-                msg = f"Selected dim {selected_dim!r} is not in patch dims {patch.dims!r}."
-                raise ValueError(msg)
-            return (
-                selected_dim,
-                patch.get_axis(selected_dim),
-                patch.get_coord(selected_dim),
-            )
-        dim_keys = tuple(key for key in kwargs if key in patch.dims)
-        if not dim_keys:
-            msg = (
-                "Kernel requested selected_* binding but no selected dim was provided."
-            )
-            raise ValueError(msg)
-        if len(dim_keys) > 1:
-            msg = (
-                "Kernel requested selected_* binding but the call matches multiple dims: "
-                f"{dim_keys!r}."
-            )
-            raise ValueError(msg)
-        selected_dim = dim_keys[0]
-        return selected_dim, patch.get_axis(selected_dim), patch.get_coord(selected_dim)
-
-    @classmethod
-    def _prepare_selected(
-        cls,
-        patch: dc.Patch,
-        args: tuple[Any, ...],
-        kwargs: dict[str, Any],
-        op: "PatchOp",
-    ) -> dict[str, Any]:
-        if not cls._requires_selected(op):
-            return {}
-        selected_dim, selected_axis, selected_coord = cls._resolve_selected_context(
-            patch, args, kwargs
-        )
-        prepared = {
-            "selected_dim": selected_dim,
-            "selected_axis": selected_axis,
-            "selected_size": len(selected_coord),
-            "selected_coord": selected_dim,
-            "selected_start": cls._encode_bound_value(selected_coord.min()),
-            "selected_stop": cls._encode_bound_value(selected_coord.max()),
-        }
-        if selected_coord.step is not None:
-            prepared["selected_step"] = cls._encode_bound_value(selected_coord.step)
-        return prepared
-
-    @classmethod
-    def _validate_kernel_bindings(cls, patch: dc.Patch, op: "PatchOp") -> None:
-        for name in cls._kernel_parameters(op):
-            if name.startswith("coord_"):
-                coord_name = name[6:]
-                if coord_name not in patch.coords.coord_map:
-                    msg = f"Kernel requested unknown coordinate {coord_name!r}."
-                    raise ValueError(msg)
-            elif name.startswith("selected_"):
-                prepared = getattr(op, "_prepared_selected", {})
-                if name == "selected_step" and "selected_step" not in prepared:
-                    msg = (
-                        "Kernel requested selected_step but the selected coordinate "
-                        "is not evenly sampled."
-                    )
-                    raise ValueError(msg)
-                if name not in {
-                    "selected_axis",
-                    "selected_coord",
-                    "selected_step",
-                    "selected_size",
-                    "selected_start",
-                    "selected_stop",
-                }:
-                    msg = f"Unsupported selected binding {name!r}."
-                    raise TypeError(msg)
-
-    def _normalize_result(self, raw: Any) -> OpResult:
-        if isinstance(raw, OpResult):
-            return raw
-        if isinstance(raw, dict):
-            unknown = set(raw) - {"data", "coords", "meta"}
-            if unknown:
-                msg = f"Unsupported OpResult keys: {sorted(unknown)!r}"
-                raise TypeError(msg)
-            return OpResult(
-                data=raw.get("data"),
-                coords=raw.get("coords"),
-                meta=raw.get("meta"),
-            )
-        msg = f"Kernel {type(self).__name__}.kernel must return OpResult or dict."
-        raise TypeError(msg)
-
-    def _bind_kernel_inputs(self, state: PatchState) -> dict[str, Any]:
-        bound: dict[str, Any] = {}
-        prepared_attrs = getattr(self, "_prepared_attrs", {})
-        prepared_selected = getattr(self, "_prepared_selected", {})
-        for name in self._kernel_parameters(self):
-            if name == "state":
-                bound[name] = state
-            elif name == "data":
-                bound[name] = state.data
-            elif name == "coords":
-                bound[name] = state.coords
-            elif name.startswith("coord_"):
-                bound[name] = state.coords[name[6:]]
-            elif name.startswith("attr_"):
-                bound[name] = prepared_attrs[name[5:]]
-            elif name == "selected_coord":
-                bound[name] = state.coords[prepared_selected["selected_coord"]]
-            elif name.startswith("selected_"):
-                bound[name] = prepared_selected[name]
-            else:
-                msg = f"Unsupported kernel parameter {name!r}."
-                raise TypeError(msg)
-        return bound
-
-    def apply(self, state: PatchState) -> PatchState:
-        """Apply one op to patch state and return updated state."""
-        result = self._normalize_result(self.kernel(**self._bind_kernel_inputs(state)))
-        next_data = state.data if result.data is None else result.data
-        next_coords = state.coords
-        if result.coords:
-            next_coords = dict(state.coords)
-            next_coords.update(result.coords)
-        return state.with_updates(data=next_data, coords=next_coords)
-
-    def reconstruct(
-        self,
-        previous_patch: dc.Patch,
-        spec: PatchSpec,
-        state: PatchState,
-    ) -> dc.Patch:
-        """Rebuild a DASCore patch from state after one compiled segment."""
-        _ = previous_patch
-        return patch_from_state_spec(state, spec)
-
-    def meta_delta(self, spec: PatchSpec) -> MetaDelta | None:
-        """Return static spec changes implied by this prepared op."""
-        _ = spec
-        return None
-
-    def compile_key(self) -> tuple[Any, ...]:
-        """Return a stable cache-key component for this prepared op."""
-        entries = []
-        for key, value in vars(self).items():
-            entries.append((key, _freeze_value(value)))
-        return (type(self).__name__, tuple(sorted(entries)))
-
-
-@dataclass(frozen=True)
-class EagerPatchOp(PatchOp):
-    """PatchOp wrapper that materializes state and delegates to patch_impl."""
-
-    _register_subclass = False
-    args: tuple[Any, ...] = ()
-    kwargs: dict[str, Any] = field(default_factory=dict)
-    mutates_spec = True
-    requires_materialized_patch_after = True
-    requires_materialized_patch_for_prepare = True
-    compile_category = "eager_boundary"
-    patch_impl_fn: Callable[..., dc.Patch] | None = None
-
-    @classmethod
-    def prepare(cls, patch: dc.Patch, *args: Any, **kwargs: Any) -> "EagerPatchOp":
-        _ = patch
-        return cls(args=args, kwargs=dict(kwargs))
-
-    def kernel(self, state):
-        return {}
-
-    def reconstruct(
-        self,
-        previous_patch: dc.Patch,
-        spec: PatchSpec,
-        state: PatchState,
-    ) -> dc.Patch:
-        current_patch = patch_from_state_spec(state, spec)
-        patch_impl = type(self).patch_impl_fn
-        assert patch_impl is not None
-        _ = previous_patch
-        return patch_impl(current_patch, *self.args, **self.kwargs)
-
-
-def _freeze_value(value: Any) -> Any:
-    if isinstance(value, np.ndarray):
-        return (
-            "ndarray",
-            str(value.dtype),
-            value.shape,
-            tuple(np.asarray(value).reshape(-1).tolist()),
-        )
-    if isinstance(value, dict):
-        return tuple((key, _freeze_value(val)) for key, val in sorted(value.items()))
-    if isinstance(value, (tuple, list)):
-        return tuple(_freeze_value(item) for item in value)
-    try:
-        hash(value)
-    except TypeError as exc:
-        msg = f"Unhashable prepared value {value!r} cannot be compiled."
-        raise TypeError(msg) from exc
-    return value
diff --git a/src/dasjax/operations/registry.py b/src/dasjax/operations/registry.py
deleted file mode 100644
index 8827b50..0000000
--- a/src/dasjax/operations/registry.py
+++ /dev/null
@@ -1,40 +0,0 @@
-"""Assembled operation registry."""
-
-from __future__ import annotations
-
-from collections.abc import Iterator
-
-from .basic import OPERATIONS as BASIC_OPERATIONS
-from .common import validate_registry
-from .filters import OPERATIONS as FILTER_OPERATIONS
-from .signal import OPERATIONS as SIGNAL_OPERATIONS
-from .spectral import OPERATIONS as SPECTRAL_OPERATIONS
-from .types import OperationSpec
-
-OPERATIONS: tuple[OperationSpec, ...] = (
-    *BASIC_OPERATIONS,
-    *SIGNAL_OPERATIONS,
-    *FILTER_OPERATIONS,
-    *SPECTRAL_OPERATIONS,
-)
-
-validate_registry(OPERATIONS)
-
-_OPERATIONS_BY_NAME: dict[str, OperationSpec] = {
-    operation.name: operation for operation in OPERATIONS
-}
-
-
-def get_operation(name: str) -> OperationSpec:
-    try:
-        return _OPERATIONS_BY_NAME[name]
-    except KeyError as exc:
-        raise AttributeError(f"Unknown jax patch operation {name!r}.") from exc
-
-
-def iter_operations() -> Iterator[OperationSpec]:
-    return iter(OPERATIONS)
-
-
-def list_operations() -> tuple[str, ...]:
-    return tuple(operation.name for operation in OPERATIONS)
diff --git a/src/dasjax/operations/signal/__init__.py b/src/dasjax/operations/signal/__init__.py
deleted file mode 100644
index 4abcfd9..0000000
--- a/src/dasjax/operations/signal/__init__.py
+++ /dev/null
@@ -1,5 +0,0 @@
-"""Signal operation family."""
-
-from .specs import OPERATIONS
-
-__all__ = ["OPERATIONS"]
diff --git a/src/dasjax/operations/signal/impl.py b/src/dasjax/operations/signal/impl.py
deleted file mode 100644
index 25ce38c..0000000
--- a/src/dasjax/operations/signal/impl.py
+++ /dev/null
@@ -1,521 +0,0 @@
-"""Executable implementations for signal operations."""
-
-from __future__ import annotations
-
-from collections.abc import Sequence
-from dataclasses import dataclass
-from functools import reduce
-from operator import add
-from typing import Any
-from operator import mul, truediv
-
-import dascore as dc
-import numpy as np
-from dascore.constants import PatchType
-from dascore.exceptions import ParameterError
-from dascore.proc.taper import taper as dc_taper
-from dascore.proc.taper import taper_range as dc_taper_range
-from dascore.transform.differentiate import differentiate as dc_differentiate
-from dascore.transform.integrate import integrate as dc_integrate
-from dascore.units import get_quantity
-from dascore.units import Quantity
-from dascore.utils.misc import iterate
-from scipy.signal import get_window
-
-from dasjax import compat, kernels
-
-from ..common import get_axis, get_axis_from_dims, update_patch
-from ..patch_ops import MetaDelta, PatchOp, PatchSpec
-
-
-@dataclass(frozen=True)
-class DetrendOp(PatchOp):
-    """Compiled detrend operation using selected-axis inference."""
-
-    dim: str
-    type: str = "linear"
-
-    def kernel(self, data, selected_axis):
-        return {
-            "data": kernels.detrend_kernel(data, axis=selected_axis, type=self.type)
-        }
-
-
-@dataclass(frozen=True)
-class NormalizeOp(PatchOp):
-    """Compiled normalize operation using selected-axis inference."""
-
-    dim: str
-    norm: str = "l2"
-
-    def kernel(self, data, selected_axis):
-        return {
-            "data": kernels.normalize_kernel(data, axis=selected_axis, norm=self.norm)
-        }
-
-
-@dataclass(frozen=True)
-class DifferentiateOp(PatchOp):
-    """Compiled differentiate operation with metadata updates."""
-
-    axes: tuple[int, ...]
-    dxs_or_spacing: tuple[Any, ...]
-    order: int = 2
-    step: int = 1
-    dims: tuple[str, ...] = ()
-    new_attrs: Any = None
-
-    @classmethod
-    def prepare(
-        cls,
-        patch: PatchType,
-        dim: str | tuple[str, ...] | None,
-        order: int = 2,
-        step: int = 1,
-    ) -> "DifferentiateOp":
-        dims = tuple(iterate(dim if dim is not None else patch.dims))
-        dxs_or_spacing = []
-        axes = []
-        for dim_name in dims:
-            coord = patch.get_coord(dim_name, require_sorted=True)
-            val = coord.step if coord.evenly_sampled else coord.data
-            dxs_or_spacing.append(dc.to_float(val))
-            axes.append(patch.get_axis(dim_name))
-        if step > 1 and len(axes) > 1:
-            msg = "Step in patch.differentiate can only be used along one axis."
-            raise ParameterError(msg)
-        new_attrs = patch.attrs.update(
-            data_units=_get_data_units_from_dims_local(patch, dims, truediv)
-        )
-        return cls(
-            axes=tuple(axes),
-            dxs_or_spacing=tuple(dxs_or_spacing),
-            order=order,
-            step=step,
-            dims=dims,
-            new_attrs=new_attrs,
-        )
-
-    def kernel(self, data):
-        out = data
-        for axis, dx_or_spacing in zip(self.axes, self.dxs_or_spacing, strict=True):
-            out = kernels.differentiate_kernel(
-                out,
-                axis=axis,
-                dx_or_spacing=dx_or_spacing,
-                order=self.order,
-                step=self.step,
-            )
-        return {"data": out}
-
-    def meta_delta(self, spec: PatchSpec) -> MetaDelta | None:
-        _ = spec
-        return MetaDelta(attrs=self.new_attrs)
-
-
-@dataclass(frozen=True)
-class IntegrateOp(PatchOp):
-    """Compiled integrate operation with eager fallback for definite integrals."""
-
-    axes: tuple[int, ...]
-    dxs_or_spacing: tuple[Any, ...]
-    definite: bool = False
-    dims: tuple[str, ...] = ()
-    new_attrs: Any = None
-    mutates_spec = True
-    requires_materialized_patch_after = True
-    compile_category = "compiled_boundary"
-
-    @classmethod
-    def prepare(
-        cls,
-        patch: PatchType,
-        dim: tuple[str, ...] | str | None,
-        definite: bool = False,
-    ) -> "IntegrateOp":
-        dims = tuple(iterate(dim if dim is not None else patch.dims))
-        dxs_or_spacing = []
-        axes = []
-        for dim_name in dims:
-            coord = patch.get_coord(dim_name, require_sorted=True)
-            val = coord.step if coord.evenly_sampled else coord.data
-            dxs_or_spacing.append(dc.to_float(val))
-            axes.append(patch.get_axis(dim_name))
-        updates = {"data_units": _get_data_units_from_dims_local(patch, dims, mul)}
-        # A definite integral reduces the dims away, so any coordinate
-        # metadata the attributes still describe has to go with them. On
-        # DASCore's dev branch the attributes no longer carry coordinates at
-        # all, and there is nothing left to clear.
-        if definite and compat.attrs_carry_coords(patch.attrs):
-            updates["coords"] = {}
-        new_attrs = patch.attrs.update(**updates)
-        return cls(
-            axes=tuple(axes),
-            dxs_or_spacing=tuple(dxs_or_spacing),
-            definite=definite,
-            dims=dims,
-            new_attrs=new_attrs,
-        )
-
-    def kernel(self, data):
-        out = data
-        for axis, dx_or_spacing in zip(self.axes, self.dxs_or_spacing, strict=True):
-            out = kernels.integrate_kernel(
-                out,
-                axis=axis,
-                dx_or_spacing=dx_or_spacing,
-                definite=self.definite,
-            )
-        return {"data": out}
-
-    def meta_delta(self, spec: PatchSpec) -> MetaDelta | None:
-        if self.definite:
-            _ = spec
-            return None
-        return MetaDelta(attrs=self.new_attrs)
-
-    def reconstruct(
-        self,
-        previous_patch: PatchType,
-        spec: PatchSpec,
-        state,
-    ) -> PatchType:
-        if self.definite:
-            return dc_integrate.func(previous_patch, dim=self.dims, definite=True)
-        return super().reconstruct(previous_patch, spec, state)
-
-
-@dataclass(frozen=True)
-class TaperOp(PatchOp):
-    """Compiled taper operation."""
-
-    axis: int
-    weight: np.ndarray
-    requires_materialized_patch_for_prepare = True
-
-    @classmethod
-    def prepare(
-        cls,
-        patch: PatchType,
-        window_type: str = "hann",
-        **kwargs,
-    ) -> "TaperOp":
-        _, prepared = prepare_taper_call(
-            patch,
-            (),
-            {"window_type": window_type, **kwargs},
-        )
-        return cls(axis=prepared["axis"], weight=prepared["weight"])
-
-    def kernel(self, data):
-        return {
-            "data": kernels.apply_1d_weight_kernel(
-                data, axis=self.axis, weight=self.weight
-            )
-        }
-
-
-@dataclass(frozen=True)
-class TaperRangeOp(PatchOp):
-    """Compiled taper_range operation."""
-
-    axis: int
-    weight: np.ndarray
-    requires_materialized_patch_for_prepare = True
-
-    @classmethod
-    def prepare(
-        cls,
-        patch: PatchType,
-        window_type: str = "hann",
-        invert: bool = False,
-        relative: bool = False,
-        samples: bool = False,
-        **kwargs,
-    ) -> "TaperRangeOp":
-        _, prepared = prepare_taper_range_call(
-            patch,
-            (),
-            {
-                "window_type": window_type,
-                "invert": invert,
-                "relative": relative,
-                "samples": samples,
-                **kwargs,
-            },
-        )
-        return cls(axis=prepared["axis"], weight=prepared["weight"])
-
-    def kernel(self, data):
-        return {
-            "data": kernels.apply_1d_weight_kernel(
-                data, axis=self.axis, weight=self.weight
-            )
-        }
-
-
-def window_function(window_type: str, size: int) -> np.ndarray:
-    return np.asarray(get_window(window_type, size, fftbins=False), dtype=np.float64)
-
-
-def _get_data_units_from_dims_local(
-    patch: PatchType,
-    dims: tuple[str, ...],
-    operator,
-):
-    """Derive data units for dimension-wise math without eager patch execution."""
-    if (data_units := get_quantity(patch.attrs.data_units)) is None:
-        return None
-    dim_units = None
-    for dim_name in dims:
-        dim_unit = get_quantity(patch.get_coord(dim_name).units)
-        if dim_unit is None:
-            continue
-        dim_units = dim_unit if dim_units is None else dim_unit * dim_units
-    if dim_units is not None:
-        data_units = operator(data_units, dim_units)
-    return data_units
-
-
-def get_taper_slices_local(patch: PatchType, kwargs: dict[str, Any]):
-    dim = next(key for key in kwargs if key in patch.dims)
-    axis = patch.get_axis(dim)
-    value = kwargs[dim]
-    coord = patch.coords.coord_map[dim]
-    if isinstance(value, Sequence | np.ndarray):
-        if len(value) != 2:
-            raise AssertionError("Length 2 sequence required.")
-        start, stop = value[0], value[1]
-    else:
-        start, stop = value, value
-    dur = coord.coord_range(extend=False)
-    clses = (Quantity, np.timedelta64)
-    start = start if isinstance(start, clses) or start is None else start * dur
-    stop = stop if isinstance(stop, clses) or stop is None else stop * dur
-    stop = -stop if stop is not None else stop
-    _, inds_1 = coord.select((None, start), relative=True)
-    _, inds_2 = coord.select((stop, None), relative=True)
-    return axis, (start, stop), inds_1, inds_2
-
-
-def validate_windows_local(samps, start_slice, end_slice, shape, axis):
-    max_len = shape[axis]
-    start_ind = start_slice.stop
-    end_ind = end_slice.start
-    bad_start = samps[0] is not None and (start_ind is None or start_ind < 0)
-    bad_end = samps[1] is not None and (end_ind is None or end_ind > max_len)
-    if bad_start or bad_end:
-        raise ParameterError("Total taper lengths exceed total dim length")
-    if start_ind is None or end_ind is None:
-        return
-    if start_ind > end_ind:
-        raise ParameterError("Taper windows cannot overlap")
-
-
-def get_taper_coord_inds_local(coord, values, relative, samples):
-    error_msg = "A len 2 or 4 sequence is required for taper values"
-    if not isinstance(values, (Sequence | np.ndarray)) or not len(values):
-        raise ParameterError(error_msg)
-    if isinstance(values[0], (Sequence | np.ndarray)):
-        out = [
-            get_taper_coord_inds_local(coord, item, relative, samples)
-            for item in values
-        ]
-        return reduce(add, out)
-    if len(values) not in {2, 4}:
-        raise ParameterError(error_msg)
-    out = [None] * len(values)
-    for idx, value in enumerate(values):
-        if value is None or value == ...:
-            if len(values) == 2:
-                raise ParameterError(
-                    "Cannot use ... or None when only two values provided"
-                )
-            out[idx] = 0 if (idx / len(out)) < 0.5 else len(coord) - 1
-        else:
-            out[idx] = coord.get_next_index(value, samples=samples, relative=relative)
-    if len(out) == 2:
-        out = [0, *out, len(coord)]
-    return [out]
-
-
-def get_taper_curve_local(coord, ind_1, ind_2, window_type, reverse=False):
-    taper = window_function(window_type, (ind_2 - ind_1) * 2 + 1)[: ind_2 - ind_1]
-    if reverse:
-        taper = taper[::-1]
-    if not coord.evenly_sampled:
-        old_coord = coord.select((ind_1, ind_2), samples=True)[0]
-        new_coord = old_coord.snap().change_length(len(old_coord))
-        old_x = dc.to_float(old_coord.values)
-        new_x = dc.to_float(new_coord.values)
-        taper = np.interp(new_x, old_x, taper)
-    return taper
-
-
-def get_range_envelope_local(coord, inds, window_type, invert):
-    out = np.zeros(len(coord))
-    for ind_set in inds:
-        i1, i2, i3, i4 = ind_set
-        left_taper = get_taper_curve_local(coord, i1, i2, window_type)
-        right_taper = get_taper_curve_local(coord, i3, i4, window_type, reverse=True)
-        out[i1:i2] += left_taper
-        out[i3:i4] += right_taper
-        out[i2:i3] += 1
-    if invert:
-        out = np.abs(out - np.max(out))
-    return out
-
-
-def validate_detrend_patch_input(
-    patch: PatchType, dim: str, type: str = "linear"
-) -> None:
-    get_axis(patch, dim)
-    detrend_type = kernels.validate_detrend_type(type)
-    if detrend_type == "linear" and not kernels.is_finite_array(patch.data):
-        raise ValueError("array must not contain infs or NaNs")
-
-
-def detrend_patch(patch: PatchType, dim: str, type: str = "linear") -> PatchType:
-    validate_detrend_patch_input(patch, dim=dim, type=type)
-    axis = get_axis(patch, dim)
-    return update_patch(patch, kernels.detrend_kernel(patch.data, axis=axis, type=type))
-
-
-def detrend_leaves(
-    data: Any,
-    coord_leaves: tuple[Any, ...],
-    *,
-    dims: tuple[str, ...],
-    dim: str,
-    type: str = "linear",
-) -> tuple[Any, tuple[Any, ...]]:
-    axis = get_axis_from_dims(dims, dim)
-    return kernels.detrend_kernel(data, axis=axis, type=type), coord_leaves
-
-
-def normalize_patch(patch: PatchType, dim: str, norm: str = "l2") -> PatchType:
-    axis = get_axis(patch, dim)
-    return update_patch(
-        patch, kernels.normalize_kernel(patch.data, axis=axis, norm=norm)
-    )
-
-
-def normalize_leaves(
-    data: Any,
-    coord_leaves: tuple[Any, ...],
-    *,
-    dims: tuple[str, ...],
-    dim: str,
-    norm: str = "l2",
-) -> tuple[Any, tuple[Any, ...]]:
-    axis = get_axis_from_dims(dims, dim)
-    return kernels.normalize_kernel(data, axis=axis, norm=norm), coord_leaves
-
-
-def differentiate_patch(
-    patch: PatchType,
-    dim: str | tuple[str, ...] | None,
-    order: int = 2,
-    step: int = 1,
-) -> PatchType:
-    return dc_differentiate.func(patch, dim=dim, order=order, step=step)
-
-
-def integrate_patch(
-    patch: PatchType,
-    dim: tuple[str, ...] | str | None,
-    definite: bool = False,
-) -> PatchType:
-    return dc_integrate.func(patch, dim=dim, definite=definite)
-
-
-def prepare_taper_call(
-    patch: PatchType,
-    args: tuple[Any, ...],
-    kwargs: dict[str, Any],
-) -> tuple[tuple[Any, ...], dict[str, Any]]:
-    _ = args
-    call_kwargs = dict(kwargs)
-    window_type = call_kwargs.pop("window_type", "hann")
-    axis, _, start_slice, end_slice = get_taper_slices_local(patch, call_kwargs)
-    shape = patch.shape
-    validate_windows_local(
-        (start_slice.stop, shape[axis] - end_slice.start),
-        start_slice,
-        end_slice,
-        shape,
-        axis,
-    )
-    weight = np.ones(shape[axis], dtype=np.float64)
-    if start_slice.stop is not None and start_slice.stop > 0:
-        start_len = start_slice.stop
-        weight[:start_len] = window_function(window_type, 2 * start_len)[:start_len]
-    if end_slice.start is not None and end_slice.start < shape[axis]:
-        end_len = shape[axis] - end_slice.start
-        weight[end_slice.start :] = window_function(window_type, 2 * end_len)[end_len:]
-    return (), {"axis": axis, "weight": weight}
-
-
-def taper_patch(patch: PatchType, window_type: str = "hann", **kwargs) -> PatchType:
-    return dc_taper.func(patch, window_type=window_type, **kwargs)
-
-
-def taper_leaves(
-    data: Any,
-    coord_leaves: tuple[Any, ...],
-    *,
-    dims: tuple[str, ...],
-    axis: int,
-    weight: np.ndarray,
-) -> tuple[Any, tuple[Any, ...]]:
-    _ = dims
-    return kernels.apply_1d_weight_kernel(data, axis=axis, weight=weight), coord_leaves
-
-
-def prepare_taper_range_call(
-    patch: PatchType,
-    args: tuple[Any, ...],
-    kwargs: dict[str, Any],
-) -> tuple[tuple[Any, ...], dict[str, Any]]:
-    _ = args
-    call_kwargs = dict(kwargs)
-    window_type = call_kwargs.pop("window_type", "hann")
-    invert = bool(call_kwargs.pop("invert", False))
-    relative = bool(call_kwargs.pop("relative", False))
-    samples = bool(call_kwargs.pop("samples", False))
-    dim = next(key for key in call_kwargs if key in patch.dims)
-    axis = patch.get_axis(dim)
-    coord = patch.get_coord(dim, require_sorted=True)
-    inds = get_taper_coord_inds_local(coord, call_kwargs[dim], relative, samples)
-    weight = get_range_envelope_local(coord, inds, window_type, invert)
-    return (), {"axis": axis, "weight": np.asarray(weight)}
-
-
-def taper_range_patch(
-    patch: PatchType,
-    window_type: str = "hann",
-    invert: bool = False,
-    relative: bool = False,
-    samples: bool = False,
-    **kwargs,
-) -> PatchType:
-    return dc_taper_range.func(
-        patch,
-        window_type=window_type,
-        invert=invert,
-        relative=relative,
-        samples=samples,
-        **kwargs,
-    )
-
-
-def taper_range_leaves(
-    data: Any,
-    coord_leaves: tuple[Any, ...],
-    *,
-    dims: tuple[str, ...],
-    axis: int,
-    weight: np.ndarray,
-) -> tuple[Any, tuple[Any, ...]]:
-    _ = dims
-    return kernels.apply_1d_weight_kernel(data, axis=axis, weight=weight), coord_leaves
diff --git a/src/dasjax/operations/signal/specs.py b/src/dasjax/operations/signal/specs.py
deleted file mode 100644
index 82f8d3b..0000000
--- a/src/dasjax/operations/signal/specs.py
+++ /dev/null
@@ -1,144 +0,0 @@
-"""Registry specs for signal operations."""
-
-from __future__ import annotations
-
-import dascore as dc
-from dascore.proc.taper import taper as dc_taper
-from dascore.proc.taper import taper_range as dc_taper_range
-from dascore.transform.differentiate import differentiate as dc_differentiate
-from dascore.transform.integrate import integrate as dc_integrate
-
-from ..common import baseline_patch_method
-from ..types import ExecutionPolicy, OperationCase, OperationSpec
-from . import impl
-
-OPERATIONS: tuple[OperationSpec, ...] = (
-    OperationSpec(
-        name="detrend",
-        execution_policy=ExecutionPolicy.LEAF,
-        patch_impl=dc.patch_function(history="method_name")(impl.detrend_patch),
-        patch_op_cls=impl.DetrendOp,
-        leaf_transform=impl.detrend_leaves,
-        validate_patch=impl.validate_detrend_patch_input,
-        test_cases=tuple(
-            OperationCase(
-                case_id=f"detrend-{kind}",
-                resolve_call=lambda patch, kind=kind: (
-                    (),
-                    {"dim": patch.dims[-1], "type": kind},
-                ),
-                baseline=lambda patch, args, kwargs: baseline_patch_method(
-                    patch, args, kwargs, "detrend"
-                ),
-            )
-            for kind in ("constant", "linear")
-        ),
-    ),
-    OperationSpec(
-        name="normalize",
-        execution_policy=ExecutionPolicy.LEAF,
-        patch_impl=dc.patch_function(history="method_name")(impl.normalize_patch),
-        patch_op_cls=impl.NormalizeOp,
-        leaf_transform=impl.normalize_leaves,
-        test_cases=tuple(
-            OperationCase(
-                case_id=f"normalize-{norm}",
-                resolve_call=lambda patch, norm=norm: (
-                    (),
-                    {"dim": patch.dims[-1], "norm": norm},
-                ),
-                baseline=lambda patch, args, kwargs: baseline_patch_method(
-                    patch, args, kwargs, "normalize"
-                ),
-            )
-            for norm in ("l1", "l2", "max", "bit")
-        ),
-    ),
-    OperationSpec(
-        name="differentiate",
-        execution_policy=ExecutionPolicy.PATCH,
-        patch_impl=dc.patch_function(history="method_name")(impl.differentiate_patch),
-        patch_op_cls=impl.DifferentiateOp,
-        test_cases=(
-            OperationCase(
-                case_id="differentiate-default",
-                resolve_call=lambda patch: ((), {"dim": patch.dims[-1]}),
-                baseline=lambda patch, args, kwargs: dc_differentiate.func(
-                    patch, *args, **kwargs
-                ),
-            ),
-            OperationCase(
-                case_id="differentiate-step",
-                resolve_call=lambda patch: ((), {"dim": patch.dims[-1], "step": 2}),
-                baseline=lambda patch, args, kwargs: dc_differentiate.func(
-                    patch, *args, **kwargs
-                ),
-            ),
-        ),
-    ),
-    OperationSpec(
-        name="integrate",
-        execution_policy=ExecutionPolicy.PATCH,
-        patch_impl=dc.patch_function(history="method_name")(impl.integrate_patch),
-        patch_op_cls=impl.IntegrateOp,
-        test_cases=(
-            OperationCase(
-                case_id="integrate-indefinite",
-                resolve_call=lambda patch: ((), {"dim": patch.dims[-1]}),
-                baseline=lambda patch, args, kwargs: dc_integrate.func(
-                    patch, *args, **kwargs
-                ),
-            ),
-            OperationCase(
-                case_id="integrate-definite",
-                resolve_call=lambda patch: (
-                    (),
-                    {"dim": patch.dims[-1], "definite": True},
-                ),
-                baseline=lambda patch, args, kwargs: dc_integrate.func(
-                    patch, *args, **kwargs
-                ),
-            ),
-        ),
-    ),
-    OperationSpec(
-        name="taper",
-        execution_policy=ExecutionPolicy.LEAF,
-        patch_impl=dc.patch_function(history="method_name")(impl.taper_patch),
-        patch_op_cls=impl.TaperOp,
-        leaf_transform=impl.taper_leaves,
-        prepare_call=impl.prepare_taper_call,
-        test_cases=(
-            OperationCase(
-                case_id="taper-time",
-                resolve_call=lambda patch: (
-                    (),
-                    {"window_type": "hann", patch.dims[-1]: 0.05},
-                ),
-                baseline=lambda patch, args, kwargs: dc_taper.func(
-                    patch, *args, **kwargs
-                ),
-            ),
-        ),
-    ),
-    OperationSpec(
-        name="taper_range",
-        execution_policy=ExecutionPolicy.LEAF,
-        patch_impl=dc.patch_function(history="method_name")(impl.taper_range_patch),
-        patch_op_cls=impl.TaperRangeOp,
-        leaf_transform=impl.taper_range_leaves,
-        prepare_call=impl.prepare_taper_range_call,
-        test_cases=(
-            OperationCase(
-                case_id="taper-range",
-                resolve_call=lambda patch: (
-                    (),
-                    {"window_type": "hann", patch.dims[-1]: (10, 20), "samples": True},
-                ),
-                baseline=lambda patch, args, kwargs: dc_taper_range.func(
-                    patch, *args, **kwargs
-                ),
-            ),
-        ),
-    ),
-)
diff --git a/src/dasjax/operations/spectral/__init__.py b/src/dasjax/operations/spectral/__init__.py
deleted file mode 100644
index 8496948..0000000
--- a/src/dasjax/operations/spectral/__init__.py
+++ /dev/null
@@ -1,5 +0,0 @@
-"""Spectral operation family."""
-
-from .specs import OPERATIONS
-
-__all__ = ["OPERATIONS"]
diff --git a/src/dasjax/operations/spectral/impl.py b/src/dasjax/operations/spectral/impl.py
deleted file mode 100644
index db1ed5f..0000000
--- a/src/dasjax/operations/spectral/impl.py
+++ /dev/null
@@ -1,560 +0,0 @@
-"""Executable implementations for spectral operations."""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Any
-
-import dascore as dc
-import jax.numpy as jnp
-import numpy as np
-from dascore.constants import PatchType
-from dascore.exceptions import ParameterError
-from dascore.proc.basic import pad as dc_pad
-from dascore.proc.whiten import whiten as dc_whiten
-from dascore.transform.fourier import dft as dc_dft
-from dascore.transform.fourier import idft as dc_idft
-from dascore.transform.hilbert import envelope as dc_envelope
-from dascore.transform.hilbert import hilbert as dc_hilbert
-from dascore.units import invert_quantity
-from dascore.utils.patch import get_dim_axis_value
-from dascore.utils.time import is_datetime64, is_timedelta64
-from dascore.utils.transformatter import FourierTransformatter
-from scipy.fft import next_fast_len
-from scipy.signal import ShortTimeFFT, get_window
-
-from dasjax import kernels
-
-from ..common import get_axis_from_dims
-from ..patch_ops import EagerPatchOp, PatchOp
-
-
-def _pad_encoded_value(value: Any) -> tuple[Any, str]:
-    arr = np.asarray(value)
-    if is_datetime64(arr.dtype) or is_timedelta64(arr.dtype):
-        return arr.view(np.int64), "int64"
-    return arr, str(arr.dtype)
-
-
-@dataclass(frozen=True)
-class PadOp(PatchOp):
-    """Compiled pad operation over patch state."""
-
-    data_pad_width: tuple[tuple[int, int], ...]
-    coord_pad_widths: dict[str, tuple[int, int]]
-    coord_generators: dict[str, tuple[str, Any, Any, int]]
-    mode: str = "constant"
-    constant_values: float = 0.0
-    mutates_spec = True
-    requires_materialized_patch_for_prepare = True
-    compile_category = "compiled_boundary"
-
-    @classmethod
-    def prepare(
-        cls,
-        patch: PatchType,
-        mode: str = "constant",
-        constant_values: Any = 0,
-        expand_coords: bool = True,
-        samples: bool = False,
-        **kwargs,
-    ) -> "PadOp":
-        if isinstance(constant_values, tuple | list | np.ndarray):
-            raise ParameterError("constant_values must be a scalar, not a sequence.")
-        pad_width = [(0, 0)] * len(patch.shape)
-        coord_pad_widths: dict[str, tuple[int, int]] = {}
-        coord_generators: dict[str, tuple[str, Any, Any, int]] = {}
-        dimfo = get_dim_axis_value(patch, kwargs=kwargs, allow_multiple=True)
-        for dim, axis, value in dimfo:
-            if not samples and patch.get_coord(dim).step is None:
-                msg = f"Coordinate {dim} is not evenly sampled as required by pad"
-                raise dc.exceptions.CoordError(msg)
-            coord = patch.get_coord(dim, require_evenly_sampled=False)
-            if value in {"fft", "correlate"}:
-                target_length = len(coord) if value == "fft" else 2 * len(coord) - 1
-                pad_tuple = (0, next_fast_len(target_length) - len(coord))
-            else:
-                if not isinstance(value, tuple | list):
-                    value = (value, value)
-                pad_tuple = (
-                    tuple(int(coord.get_sample_count(x)) for x in value)
-                    if not samples
-                    else tuple(int(x) for x in value)
-                )
-            pad_width[axis] = pad_tuple
-            coord_pad_widths[dim] = pad_tuple
-            if expand_coords and coord.evenly_sampled:
-                start_value, _ = _pad_encoded_value(coord.min())
-                step_value, _ = _pad_encoded_value(coord.step)
-                coord_generators[dim] = (
-                    "range",
-                    np.asarray(start_value),
-                    np.asarray(step_value),
-                    len(coord) + sum(pad_tuple),
-                )
-            else:
-                coord_values, dtype_name = _pad_encoded_value(coord.values)
-                if np.issubdtype(np.asarray(coord_values).dtype, np.integer):
-                    coord_values = np.asarray(coord_values, dtype=np.float64)
-                    null_value = np.nan
-                else:
-                    null_value = np.nan
-                coord_generators[dim] = (
-                    "pad",
-                    np.asarray(coord_values),
-                    np.asarray(null_value, dtype=np.asarray(coord_values).dtype),
-                    0,
-                )
-        return cls(
-            data_pad_width=tuple(tuple(x) for x in pad_width),
-            coord_pad_widths=coord_pad_widths,
-            coord_generators=coord_generators,
-            mode=mode,
-            constant_values=float(constant_values),
-        )
-
-    def kernel(self, state):
-        out_coords = {}
-        for name, kind_data in self.coord_generators.items():
-            kind, arg1, arg2, size = kind_data
-            if kind == "range":
-                before, _ = self.coord_pad_widths[name]
-                out_coords[name] = (
-                    arg1
-                    - before * arg2
-                    + jnp.arange(size, dtype=jnp.asarray(arg1).dtype) * arg2
-                )
-            else:
-                out_coords[name] = jnp.pad(
-                    jnp.asarray(arg1),
-                    self.coord_pad_widths[name],
-                    mode="constant",
-                    constant_values=jnp.asarray(arg2),
-                )
-        return {
-            "data": jnp.pad(
-                state.data,
-                self.data_pad_width,
-                mode=self.mode,
-                constant_values=self.constant_values,
-            ),
-            "coords": out_coords,
-        }
-
-
-@dataclass(frozen=True)
-class DftOp(EagerPatchOp):
-    """Unified eager-backed dft operation."""
-
-    patch_impl_fn = staticmethod(dc_dft.func)
-
-
-@dataclass(frozen=True)
-class IdftOp(EagerPatchOp):
-    """Unified eager-backed idft operation."""
-
-    patch_impl_fn = staticmethod(dc_idft.func)
-
-
-@dataclass(frozen=True)
-class HilbertOp(PatchOp):
-    """Compiled hilbert operation using selected-axis inference."""
-
-    dim: str
-
-    @classmethod
-    def prepare(cls, patch: PatchType, dim: str) -> "HilbertOp":
-        if patch.get_coord(dim).step is None:
-            msg = f"Coordinate {dim} is not evenly sampled as required by hilbert"
-            raise dc.exceptions.CoordError(msg)
-        return super().prepare(patch, dim=dim)
-
-    def kernel(self, data, selected_axis):
-        return {"data": kernels.hilbert_kernel(data, axis=selected_axis)}
-
-
-@dataclass(frozen=True)
-class EnvelopeOp(PatchOp):
-    """Compiled envelope operation using selected-axis inference."""
-
-    dim: str
-
-    @classmethod
-    def prepare(cls, patch: PatchType, dim: str) -> "EnvelopeOp":
-        if patch.get_coord(dim).step is None:
-            msg = f"Coordinate {dim} is not evenly sampled as required by envelope"
-            raise dc.exceptions.CoordError(msg)
-        return super().prepare(patch, dim=dim)
-
-    def kernel(self, data, selected_axis):
-        return {"data": kernels.envelope_kernel(data, axis=selected_axis)}
-
-
-@dataclass(frozen=True)
-class WhitenOp(EagerPatchOp):
-    """Unified eager-backed whiten operation."""
-
-    patch_impl_fn = staticmethod(dc_whiten.func)
-
-
-def get_dim_freq_range_from_kwargs_local(
-    patch: PatchType,
-    kwargs: dict[str, Any],
-) -> tuple[str, Any]:
-    dim_set = set(patch.dims)
-    if not kwargs:
-        expected = {"time", "ft_time"} & dim_set
-        if not expected:
-            raise ParameterError(
-                "No dim name provided in kwargs and patch has no time dimension."
-            )
-        return "time", None
-    if len(kwargs) == 1:
-        dim, freq_range = next(iter(kwargs.items()))
-        fft_dim = FourierTransformatter().rename_dims(dim)[0]
-        if dim not in dim_set and fft_dim not in dim_set:
-            raise ParameterError(
-                f"passed dim of {dim} to whiten but it is not in patch dimensions."
-            )
-        return dim, freq_range
-    raise ParameterError(
-        f"Whiten kwargs must specify a single patch dimension. You passed {kwargs}."
-    )
-
-
-def check_smooth_local(fft_coord, smooth_size, water_level):
-    if water_level is not None:
-        if not isinstance(water_level, float) or water_level < 0 or water_level > 1:
-            raise ParameterError("water_level must be a float between 0 and 1.")
-    if smooth_size <= 0:
-        raise ParameterError("Frequency smoothing size must be positive")
-    if smooth_size >= fft_coord.max():
-        raise ParameterError("Frequency smoothing size is larger than Nyquist")
-
-
-def check_freq_range_local(fft_coord, freq_range):
-    frange = np.asarray(freq_range)
-    diffs = frange[1:] - frange[:-1]
-    min_size = fft_coord.step * 2
-    if np.any(diffs < min_size):
-        raise ParameterError("Frequency range is too narrow")
-
-
-def get_stft_coords_local(patch, dim, axis, coord, stft, window):
-    ft = FourierTransformatter()
-    time = stft.t(len(coord))
-    if is_datetime64(coord.dtype) or is_timedelta64(coord.dtype):
-        time = dc.to_timedelta64(time)
-    new_dims = list(ft.rename_dims(patch.dims, index=axis, forward=True))
-    new_dims.append(dim)
-    coord_map = patch.coords.disassociate_coord(dim).get_coord_tuple_map()
-    new_units = invert_quantity(coord.units)
-    coord_map.update(
-        {
-            dim: dc.get_coord(values=time + coord.min(), units=coord.units),
-            new_dims[axis]: dc.get_coord(values=stft.f, units=new_units),
-            "_stft_window": (None, window),
-            "_stft_old_coord": (None, patch.get_coord(dim)),
-        }
-    )
-    return dc.get_coord_manager(coords=coord_map, dims=tuple(new_dims))
-
-
-def pad_patch(
-    patch: PatchType,
-    mode: str = "constant",
-    constant_values: Any = 0,
-    expand_coords: bool = True,
-    samples: bool = False,
-    **kwargs,
-) -> PatchType:
-    return dc_pad.func(
-        patch,
-        mode=mode,
-        constant_values=constant_values,
-        expand_coords=expand_coords,
-        samples=samples,
-        **kwargs,
-    )
-
-
-def dft_patch(
-    patch: PatchType,
-    dim: str | None | tuple[str, ...],
-    *,
-    real: str | bool | None = None,
-    pad: bool = True,
-) -> PatchType:
-    return dc_dft.func(patch, dim=dim, real=real, pad=pad)
-
-
-def idft_patch(
-    patch: PatchType,
-    dim: str | None | tuple[str, ...] = None,
-) -> PatchType:
-    return dc_idft.func(patch, dim=dim)
-
-
-def hilbert_patch(patch: PatchType, dim: str) -> PatchType:
-    return dc_hilbert.func(patch, dim=dim)
-
-
-def hilbert_leaves(
-    data: Any,
-    coord_leaves: tuple[Any, ...],
-    *,
-    dims: tuple[str, ...],
-    dim: str,
-) -> tuple[Any, tuple[Any, ...]]:
-    axis = get_axis_from_dims(dims, dim)
-    return kernels.hilbert_kernel(data, axis=axis), coord_leaves
-
-
-def envelope_patch(patch: PatchType, dim: str) -> PatchType:
-    return dc_envelope.func(patch, dim=dim)
-
-
-def envelope_leaves(
-    data: Any,
-    coord_leaves: tuple[Any, ...],
-    *,
-    dims: tuple[str, ...],
-    dim: str,
-) -> tuple[Any, tuple[Any, ...]]:
-    axis = get_axis_from_dims(dims, dim)
-    return kernels.envelope_kernel(data, axis=axis), coord_leaves
-
-
-def whiten_patch(
-    patch: PatchType,
-    smooth_size: float | None = None,
-    water_level: float | None = None,
-    **kwargs,
-) -> PatchType:
-    return dc_whiten.func(
-        patch, smooth_size=smooth_size, water_level=water_level, **kwargs
-    )
-
-
-def prepare_fbe_call(
-    patch: PatchType,
-    args: tuple[Any, ...],
-    kwargs: dict[str, Any],
-) -> tuple[tuple[Any, ...], dict[str, Any]]:
-    _ = args
-    call_kwargs = dict(kwargs)
-    samples = bool(call_kwargs.pop("samples", False))
-    detrend = bool(call_kwargs.pop("detrend", False))
-    taper_window = call_kwargs.pop("taper_window", "hann")
-    overlap = call_kwargs.pop("overlap", 0)
-    fmin = call_kwargs.pop("fmin", None)
-    fmax = call_kwargs.pop("fmax", None)
-    (dim, axis, val) = get_dim_axis_value(patch, kwargs=call_kwargs)[0]
-
-    def stft():
-        return patch.get_coord(dim, require_evenly_sampled=True)
-
-    coord = stft()
-    window_samples = coord.get_sample_count(val, samples=samples, enforce_lt_coord=True)
-    step = dc.to_float(coord.step)
-    sampling_rate = 1 / abs(step)
-    window = (
-        taper_window
-        if isinstance(taper_window, np.ndarray)
-        else get_window(taper_window, window_samples, fftbins=False)
-    )
-    if overlap is not None:
-        overlap = coord[:window_samples].get_sample_count(
-            overlap, samples=samples, enforce_lt_coord=True
-        )
-    else:
-        overlap = 0
-    hop = window_samples - overlap
-    stft = ShortTimeFFT(
-        win=window, hop=hop, fs=sampling_rate, fft_mode="onesided", mfft=window_samples
-    )
-    frame_times = np.asarray(stft.t(len(coord)))
-    frame_starts = (
-        np.rint(frame_times * sampling_rate).astype(np.int64) - stft.m_num_mid
-    )
-    frequencies = np.asarray(stft.f, dtype=np.float64)
-    mask = np.ones(len(frequencies), dtype=bool)
-    if fmin is not None:
-        mask &= frequencies >= fmin
-    if fmax is not None:
-        mask &= frequencies <= fmax
-    selected_bins = np.flatnonzero(mask).astype(np.int64)
-    return (), {
-        "axis": axis,
-        "window": np.asarray(window),
-        "hop": hop,
-        "frame_starts": frame_starts,
-        "frame_times": frame_times,
-        "selected_bins": selected_bins,
-        "sample_step": step,
-        "detrend": detrend,
-        "dim": dim,
-        "window_samples": window_samples,
-        "sampling_rate": sampling_rate,
-        "stft_obj": stft,
-    }
-
-
-@dataclass(frozen=True)
-class FbeOp(PatchOp):
-    """Compiled fbe operation with custom reconstruction."""
-
-    axis: int
-    window: np.ndarray
-    hop: int
-    frame_starts: np.ndarray
-    frame_times: np.ndarray
-    selected_bins: np.ndarray
-    sample_step: float
-    detrend: bool
-    dim: str
-    window_samples: int
-    sampling_rate: float
-    stft_obj: Any
-    mutates_spec = True
-    requires_materialized_patch_after = True
-    requires_materialized_patch_for_prepare = True
-    compile_category = "compiled_boundary"
-
-    @classmethod
-    def prepare(
-        cls,
-        patch: PatchType,
-        overlap: Any = 0,
-        samples: bool = False,
-        detrend: bool = False,
-        taper_window: str | np.ndarray | tuple = "hann",
-        fmin: float | None = None,
-        fmax: float | None = None,
-        **kwargs,
-    ) -> "FbeOp":
-        _, prepared = prepare_fbe_call(
-            patch,
-            (),
-            {
-                "overlap": overlap,
-                "samples": samples,
-                "detrend": detrend,
-                "taper_window": taper_window,
-                "fmin": fmin,
-                "fmax": fmax,
-                **kwargs,
-            },
-        )
-        return cls(**prepared)
-
-    def kernel(self, data):
-        return {
-            "data": kernels.banded_stft_kernel(
-                data,
-                axis=self.axis,
-                window=self.window,
-                frame_starts=self.frame_starts,
-                selected_bins=self.selected_bins,
-                sample_step=self.sample_step,
-                detrend=self.detrend,
-            )
-        }
-
-    def reconstruct(
-        self,
-        previous_patch: PatchType,
-        spec,
-        state,
-    ) -> PatchType:
-        _ = spec
-        coord = previous_patch.get_coord(self.dim, require_evenly_sampled=True)
-        stft_cm = get_stft_coords_local(
-            previous_patch,
-            self.dim,
-            self.axis,
-            coord,
-            self.stft_obj,
-            self.window,
-        )
-        ft_dim = stft_cm.dims[self.axis]
-        coord_map = {
-            name: value
-            for name, value in stft_cm.get_coord_tuple_map().items()
-            if name != ft_dim
-        }
-        dims = tuple(dim for dim in stft_cm.dims if dim != ft_dim)
-        return dc.Patch(
-            data=np.asarray(state.data),
-            coords=coord_map,
-            dims=dims,
-            attrs=previous_patch.attrs,
-        )
-
-
-def fbe_patch(
-    patch: PatchType,
-    overlap: Any = 0,
-    samples: bool = False,
-    detrend: bool = False,
-    taper_window: str | np.ndarray | tuple = "hann",
-    fmin: float | None = None,
-    fmax: float | None = None,
-    **kwargs,
-) -> PatchType:
-    _, prepared = prepare_fbe_call(
-        patch,
-        (),
-        {
-            "overlap": overlap,
-            "samples": samples,
-            "detrend": detrend,
-            "taper_window": taper_window,
-            "fmin": fmin,
-            "fmax": fmax,
-            **kwargs,
-        },
-    )
-    reduced = kernels.banded_stft_kernel(
-        patch.data,
-        axis=prepared["axis"],
-        window=prepared["window"],
-        frame_starts=prepared["frame_starts"],
-        selected_bins=prepared["selected_bins"],
-        sample_step=prepared["sample_step"],
-        detrend=prepared["detrend"],
-    )
-    coord = patch.get_coord(prepared["dim"], require_evenly_sampled=True)
-    stft_cm = get_stft_coords_local(
-        patch,
-        prepared["dim"],
-        prepared["axis"],
-        coord,
-        prepared["stft_obj"],
-        prepared["window"],
-    )
-    ft_dim = stft_cm.dims[prepared["axis"]]
-    coord_map = {
-        name: value
-        for name, value in stft_cm.get_coord_tuple_map().items()
-        if name != ft_dim
-    }
-    dims = tuple(dim for dim in stft_cm.dims if dim != ft_dim)
-    return dc.Patch(
-        data=np.asarray(reduced), coords=coord_map, dims=dims, attrs=patch.attrs
-    )
-
-
-def baseline_fbe_patch(
-    patch: PatchType,
-    args: tuple[Any, ...],
-    kwargs: dict[str, Any],
-) -> PatchType:
-    call_kwargs = dict(kwargs)
-    fmin = call_kwargs.pop("fmin", None)
-    fmax = call_kwargs.pop("fmax", None)
-    out = patch.stft(**call_kwargs).abs()
-    ft_dim = next(dim for dim in out.dims if dim.startswith("ft_"))
-    if fmin is not None or fmax is not None:
-        out = out.select(**{ft_dim: (fmin, fmax)})
-    return out.sum(dim=ft_dim, dim_reduce="squeeze")
diff --git a/src/dasjax/operations/spectral/specs.py b/src/dasjax/operations/spectral/specs.py
deleted file mode 100644
index fbb90dd..0000000
--- a/src/dasjax/operations/spectral/specs.py
+++ /dev/null
@@ -1,182 +0,0 @@
-"""Registry specs for spectral operations."""
-
-from __future__ import annotations
-
-import dascore as dc
-from dascore.proc.basic import pad as dc_pad
-from dascore.proc.whiten import whiten as dc_whiten
-from dascore.transform.fourier import dft as dc_dft
-from dascore.transform.fourier import idft as dc_idft
-from dascore.transform.hilbert import envelope as dc_envelope
-from dascore.transform.hilbert import hilbert as dc_hilbert
-
-from ..common import (
-    get_preferred_transform_dim,
-    prepare_even_patch_for_dim,
-    prepare_fourier_patch,
-    resolve_even_dim_call,
-)
-from ..types import ExecutionPolicy, OperationCase, OperationSpec
-from . import impl
-
-OPERATIONS: tuple[OperationSpec, ...] = (
-    OperationSpec(
-        name="pad",
-        execution_policy=ExecutionPolicy.PATCH,
-        patch_impl=dc.patch_function(history="method_name")(impl.pad_patch),
-        patch_op_cls=impl.PadOp,
-        test_cases=(
-            OperationCase(
-                case_id="pad-constant",
-                resolve_call=lambda patch: (
-                    (),
-                    {
-                        "mode": "constant",
-                        "samples": True,
-                        get_preferred_transform_dim(patch): (2, 3),
-                    },
-                ),
-                prepare_patch=prepare_even_patch_for_dim,
-                baseline=lambda patch, args, kwargs: impl.pad_patch(
-                    patch, *args, **kwargs
-                ),
-            ),
-            OperationCase(
-                case_id="pad-fft",
-                resolve_call=lambda patch: (
-                    (),
-                    {get_preferred_transform_dim(patch): "fft"},
-                ),
-                baseline=lambda patch, args, kwargs: dc_pad.func(
-                    patch, *args, **kwargs
-                ),
-            ),
-        ),
-    ),
-    OperationSpec(
-        name="dft",
-        execution_policy=ExecutionPolicy.PATCH,
-        patch_impl=dc.patch_function(history="method_name")(impl.dft_patch),
-        patch_op_cls=impl.DftOp,
-        test_cases=(
-            OperationCase(
-                case_id="dft-real",
-                resolve_call=lambda patch: ((), {"dim": patch.dims[-1], "real": True}),
-                baseline=lambda patch, args, kwargs: dc_dft.func(
-                    patch, *args, **kwargs
-                ),
-            ),
-            OperationCase(
-                case_id="dft-full",
-                resolve_call=lambda patch: (
-                    (),
-                    {"dim": patch.dims[-1], "real": None, "pad": False},
-                ),
-                baseline=lambda patch, args, kwargs: dc_dft.func(
-                    patch, *args, **kwargs
-                ),
-            ),
-        ),
-    ),
-    OperationSpec(
-        name="idft",
-        execution_policy=ExecutionPolicy.PATCH,
-        patch_impl=dc.patch_function(history="method_name")(impl.idft_patch),
-        patch_op_cls=impl.IdftOp,
-        test_cases=(
-            OperationCase(
-                case_id="idft-real",
-                resolve_call=lambda patch: ((), {}),
-                prepare_patch=prepare_fourier_patch,
-                baseline=lambda patch, args, kwargs: dc_idft.func(
-                    patch, *args, **kwargs
-                ),
-            ),
-        ),
-    ),
-    OperationSpec(
-        name="hilbert",
-        execution_policy=ExecutionPolicy.PATCH,
-        patch_impl=dc.patch_function(history="method_name")(impl.hilbert_patch),
-        patch_op_cls=impl.HilbertOp,
-        test_cases=(
-            OperationCase(
-                case_id="hilbert-time",
-                resolve_call=lambda patch: resolve_even_dim_call(patch),
-                baseline=lambda patch, args, kwargs: dc_hilbert.func(
-                    patch, *args, **kwargs
-                ),
-            ),
-        ),
-    ),
-    OperationSpec(
-        name="envelope",
-        execution_policy=ExecutionPolicy.PATCH,
-        patch_impl=dc.patch_function(history="method_name")(impl.envelope_patch),
-        patch_op_cls=impl.EnvelopeOp,
-        test_cases=(
-            OperationCase(
-                case_id="envelope-time",
-                resolve_call=lambda patch: resolve_even_dim_call(patch),
-                baseline=lambda patch, args, kwargs: dc_envelope.func(
-                    patch, *args, **kwargs
-                ),
-            ),
-        ),
-    ),
-    OperationSpec(
-        name="whiten",
-        execution_policy=ExecutionPolicy.PATCH,
-        patch_impl=dc.patch_function(history="method_name")(impl.whiten_patch),
-        patch_op_cls=impl.WhitenOp,
-        test_cases=(
-            OperationCase(
-                case_id="whiten-default",
-                resolve_call=lambda patch: (
-                    (),
-                    {get_preferred_transform_dim(patch): None},
-                ),
-                baseline=lambda patch, args, kwargs: dc_whiten.func(
-                    patch, *args, **kwargs
-                ),
-            ),
-            OperationCase(
-                case_id="whiten-band-limited",
-                resolve_call=lambda patch: (
-                    (),
-                    {
-                        "smooth_size": 3.0,
-                        get_preferred_transform_dim(patch): (5.0, 10.0, 20.0, 25.0),
-                    },
-                ),
-                baseline=lambda patch, args, kwargs: dc_whiten.func(
-                    patch, *args, **kwargs
-                ),
-            ),
-        ),
-    ),
-    OperationSpec(
-        name="fbe",
-        execution_policy=ExecutionPolicy.PATCH,
-        patch_impl=dc.patch_function(history="method_name")(impl.fbe_patch),
-        patch_op_cls=impl.FbeOp,
-        prepare_call=impl.prepare_fbe_call,
-        test_cases=(
-            OperationCase(
-                case_id="fbe-default",
-                resolve_call=lambda patch: (
-                    (),
-                    {
-                        patch.dims[-1]: 64,
-                        "samples": True,
-                        "overlap": 32,
-                        "fmin": 2.0,
-                        "fmax": 10.0,
-                    },
-                ),
-                prepare_patch=prepare_even_patch_for_dim,
-                baseline=impl.baseline_fbe_patch,
-            ),
-        ),
-    ),
-)
diff --git a/src/dasjax/operations/spectro.py b/src/dasjax/operations/spectro.py
new file mode 100644
index 0000000..cfeb479
--- /dev/null
+++ b/src/dasjax/operations/spectro.py
@@ -0,0 +1,142 @@
+"""Spectral patch operations."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Self
+
+import dascore as dc
+import numpy as np
+from dascore.utils.patch import get_dim_axis_value
+from scipy.signal import ShortTimeFFT, get_window
+
+from dasjax.core import PatchBoundary, PatchOperation, PatchPyTree
+
+from .. import kernels
+from .common import dummy_patch, replace, tree_boundary_from_patch
+
+
+@dataclass(frozen=True)
+class Fbe(PatchOperation):
+    """Compute frequency-band energy with a short-time Fourier transform."""
+
+    overlap: Any = 0
+    samples: bool = False
+    detrend: bool = False
+    taper_window: str | np.ndarray | tuple = "hann"
+    fmin: float | None = None
+    fmax: float | None = None
+    kwargs: dict[str, Any] | None = None
+    prepared: dict[str, Any] | None = None
+    out_boundary: PatchBoundary | None = None
+    out_coords: tuple[Any, ...] | None = None
+    out_dtype_codes: tuple[Any, ...] | None = None
+    out_dims: tuple[str, ...] | None = None
+
+    def __init__(
+        self,
+        overlap=0,
+        samples=False,
+        detrend=False,
+        taper_window="hann",
+        fmin=None,
+        fmax=None,
+        **kwargs,
+    ):
+        object.__setattr__(self, "overlap", overlap)
+        object.__setattr__(self, "samples", samples)
+        object.__setattr__(self, "detrend", detrend)
+        object.__setattr__(self, "taper_window", taper_window)
+        object.__setattr__(self, "fmin", fmin)
+        object.__setattr__(self, "fmax", fmax)
+        object.__setattr__(self, "kwargs", dict(kwargs))
+        object.__setattr__(self, "prepared", None)
+        object.__setattr__(self, "out_boundary", None)
+        object.__setattr__(self, "out_coords", None)
+        object.__setattr__(self, "out_dtype_codes", None)
+        object.__setattr__(self, "out_dims", None)
+
+    def bind(self, boundary: PatchBoundary) -> Self:
+        patch = dummy_patch(boundary)
+        call_kwargs = dict(self.kwargs or {})
+        dim, axis, val = get_dim_axis_value(patch, kwargs=call_kwargs)[0]
+        coord = patch.get_coord(dim, require_evenly_sampled=True)
+        window_samples = coord.get_sample_count(
+            val, samples=self.samples, enforce_lt_coord=True
+        )
+        step = dc.to_float(coord.step)
+        sampling_rate = 1 / abs(step)
+        window = (
+            self.taper_window
+            if isinstance(self.taper_window, np.ndarray)
+            else get_window(self.taper_window, window_samples, fftbins=False)
+        )
+        overlap = (
+            coord[:window_samples].get_sample_count(
+                self.overlap, samples=self.samples, enforce_lt_coord=True
+            )
+            if self.overlap is not None
+            else 0
+        )
+        hop = window_samples - overlap
+        stft = ShortTimeFFT(
+            win=window,
+            hop=hop,
+            fs=sampling_rate,
+            fft_mode="onesided",
+            mfft=window_samples,
+        )
+        frame_times = np.asarray(stft.t(len(coord)))
+        frame_starts = (
+            np.rint(frame_times * sampling_rate).astype(np.int64) - stft.m_num_mid
+        )
+        frequencies = np.asarray(stft.f, dtype=np.float64)
+        mask = np.ones(len(frequencies), dtype=bool)
+        if self.fmin is not None:
+            mask &= frequencies >= self.fmin
+        if self.fmax is not None:
+            mask &= frequencies <= self.fmax
+        prepared = {
+            "axis": axis,
+            "window": np.asarray(window),
+            "frame_starts": frame_starts,
+            "selected_bins": np.flatnonzero(mask).astype(np.int64),
+            "sample_step": step,
+            "detrend": self.detrend,
+        }
+        # Reuse the existing DASCore STFT metadata construction by running on zeros.
+        out = patch.stft(
+            **{dim: val},
+            overlap=self.overlap,
+            samples=self.samples,
+            detrend=self.detrend,
+            taper_window=self.taper_window,
+        ).abs()
+        ft_dim = next(dim_name for dim_name in out.dims if dim_name.startswith("ft_"))
+        if self.fmin is not None or self.fmax is not None:
+            out = out.select(**{ft_dim: (self.fmin, self.fmax)})
+        out = out.sum(dim=ft_dim, dim_reduce="squeeze")
+        out_tree, out_boundary = tree_boundary_from_patch(out)
+        return replace(
+            self,
+            prepared=prepared,
+            out_boundary=out_boundary,
+            out_coords=out_tree.coord_values,
+            out_dtype_codes=out_tree.coord_dtype_codes,
+            out_dims=out_tree.dims,
+        )
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        assert self.prepared is not None
+        data = kernels.banded_stft_kernel(patch_tree.data, **self.prepared)
+        return patch_tree.new(
+            data=data,
+            coords=self.out_coords,
+            coord_dtype_codes=self.out_dtype_codes,
+            dims=self.out_dims,
+        )
+
+    def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary:
+        _ = boundary
+        assert self.out_boundary is not None
+        return self.out_boundary
diff --git a/src/dasjax/operations/strain.py b/src/dasjax/operations/strain.py
new file mode 100644
index 0000000..d41aca7
--- /dev/null
+++ b/src/dasjax/operations/strain.py
@@ -0,0 +1,174 @@
+"""Strain transform operations."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from operator import truediv
+from typing import Any, Self
+
+import dascore as dc
+import numpy as np
+from dascore.exceptions import ParameterError
+from dascore.units import convert_units, get_factor_and_unit, get_unit
+
+from dasjax.core import PatchBoundary, PatchOperation, PatchPyTree
+
+from .. import kernels
+from .common import (
+    dummy_patch,
+    get_data_units_from_dims,
+    replace,
+    tree_boundary_from_patch,
+)
+
+
+@dataclass(frozen=True)
+class VelocityToStrainRate(PatchOperation):
+    """Convert velocity DAS data to strain rate using central differences."""
+
+    step_multiple: int = 2
+    gauge_multiple: int | None = None
+    order: int = 2
+    axis: int | None = None
+    spacing: float = 1.0
+    attrs: Any = None
+
+    def bind(self, boundary: PatchBoundary) -> Self:
+        step_multiple = (
+            self.gauge_multiple * 2
+            if self.gauge_multiple is not None
+            else self.step_multiple
+        )
+        if step_multiple <= 0:
+            raise ParameterError("step_multiple must be positive.")
+        if step_multiple % 2 != 0:
+            msg = (
+                "Step_multiple must be even. Use velocity_to_strain_rate_edgeless "
+                "if odd step multiples are required."
+            )
+            raise ParameterError(msg)
+        coord = dummy_patch(boundary).get_coord("distance", require_evenly_sampled=True)
+        attrs = boundary.attrs.update(
+            data_type="strain_rate",
+            gauge_length=coord.step * step_multiple,
+            data_units=get_data_units_from_dims(boundary, ("distance",), truediv),
+        )
+        return replace(
+            self,
+            step_multiple=step_multiple,
+            axis=boundary.axis("distance"),
+            spacing=float(dc.to_float(coord.step)),
+            attrs=attrs,
+        )
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        assert self.axis is not None
+        data = kernels.differentiate_kernel(
+            patch_tree.data,
+            axis=self.axis,
+            dx_or_spacing=self.spacing,
+            order=self.order,
+            step=self.step_multiple // 2,
+        )
+        return patch_tree.new(data=data)
+
+    def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary:
+        return boundary.new(attrs=self.attrs)
+
+
+@dataclass(frozen=True)
+class VelocityToStrainRateEdgeless(PatchOperation):
+    """Estimate strain rate with central differences and dropped edges."""
+
+    step_multiple: int = 1
+    axis: int | None = None
+    gauge_length: float = 1.0
+    out_boundary: PatchBoundary | None = None
+    out_coords: tuple[Any, ...] | None = None
+    out_dtype_codes: tuple[Any, ...] | None = None
+    out_dims: tuple[str, ...] | None = None
+
+    def bind(self, boundary: PatchBoundary) -> Self:
+        if self.step_multiple <= 0:
+            raise ParameterError("step_multiple must be positive.")
+        out_patch = dummy_patch(boundary).velocity_to_strain_rate_edgeless(
+            step_multiple=self.step_multiple
+        )
+        out_tree, out_boundary = tree_boundary_from_patch(out_patch)
+        gauge_length = (
+            float(dc.to_float(boundary.coord("distance").step)) * self.step_multiple
+        )
+        return replace(
+            self,
+            axis=boundary.axis("distance"),
+            gauge_length=gauge_length,
+            out_boundary=out_boundary,
+            out_coords=out_tree.coord_values,
+            out_dtype_codes=out_tree.coord_dtype_codes,
+            out_dims=out_tree.dims,
+        )
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        assert self.axis is not None
+        data = kernels.velocity_to_strain_rate_edgeless_kernel(
+            patch_tree.data,
+            axis=self.axis,
+            step_multiple=self.step_multiple,
+            gauge_length=self.gauge_length,
+        )
+        return patch_tree.new(
+            data=data,
+            coords=self.out_coords,
+            coord_dtype_codes=self.out_dtype_codes,
+            dims=self.out_dims,
+        )
+
+    def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary:
+        _ = boundary
+        assert self.out_boundary is not None
+        return self.out_boundary
+
+
+@dataclass(frozen=True)
+class RadiansToStrain(PatchOperation):
+    """Convert radians data units to strain."""
+
+    gauge_length: Any = None
+    wave_length: float = 1550.0 * 10 ** (-9)
+    stress_constant: float = 0.79
+    refractive_index: float = 1.445
+    factor: float = 1.0
+    attrs: Any = None
+
+    def bind(self, boundary: PatchBoundary) -> Self:
+        gauge_source = (
+            self.gauge_length
+            if self.gauge_length is not None
+            else getattr(boundary.attrs, "gauge_length", None)
+        )
+        gauge = convert_units(gauge_source, "m")
+        if gauge is None or gauge <= 0:
+            msg = (
+                "Gauge length must be non-zero positive and provided "
+                "or defined in patch attrs."
+            )
+            raise ParameterError(msg)
+        quant = dc.get_quantity(boundary.attrs.data_units)
+        if str(dc.get_unit("radians")) not in str(quant):
+            return replace(self, factor=1.0, attrs=boundary.attrs)
+        const = self.wave_length / (
+            4 * np.pi * self.refractive_index * gauge * self.stress_constant
+        )
+        data_units = boundary.attrs.get("data_units", None)
+        data_factor, data_unit = get_factor_and_unit(data_units, simplify=True)
+        new_units = get_unit(data_unit) * get_unit("strain/radians")
+        attrs = boundary.attrs.update(data_units=new_units)
+        return replace(self, factor=float(const * data_factor), attrs=attrs)
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        return patch_tree.new(
+            data=kernels.radians_to_strain_kernel(patch_tree.data, self.factor)
+        )
+
+    def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary:
+        return boundary.new(attrs=self.attrs)
diff --git a/src/dasjax/operations/taper.py b/src/dasjax/operations/taper.py
new file mode 100644
index 0000000..c87d308
--- /dev/null
+++ b/src/dasjax/operations/taper.py
@@ -0,0 +1,163 @@
+"""Taper patch operations."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from functools import reduce
+from operator import add
+from typing import Any, Self
+
+import dascore as dc
+import numpy as np
+from dascore.exceptions import ParameterError
+from scipy.signal import get_window
+
+from dasjax.core import PatchBoundary, PatchOperation, PatchPyTree
+
+from .. import kernels
+from .common import dummy_patch, replace
+
+
+def _taper_window(window_type: str, size: int) -> np.ndarray:
+    return np.asarray(get_window(window_type, size, fftbins=False), dtype=np.float64)
+
+
+def _taper_slices(boundary: PatchBoundary, kwargs: dict[str, Any]):
+    dim = next(key for key in kwargs if key in boundary.dims)
+    axis = boundary.axis(dim)
+    value = kwargs[dim]
+    coord = boundary.coord(dim)
+    if isinstance(value, (tuple, list, np.ndarray)):
+        start, stop = value
+    else:
+        start, stop = value, value
+    dur = coord.coord_range(extend=False)
+    clses = (dc.units.Quantity, np.timedelta64)
+    start = start if isinstance(start, clses) or start is None else start * dur
+    stop = stop if isinstance(stop, clses) or stop is None else stop * dur
+    stop = -stop if stop is not None else stop
+    _, inds_1 = coord.select((None, start), relative=True)
+    _, inds_2 = coord.select((stop, None), relative=True)
+    return axis, inds_1, inds_2
+
+
+@dataclass(frozen=True)
+class Taper(PatchOperation):
+    """Apply edge tapers to patch data along one dimension."""
+
+    window_type: str = "hann"
+    kwargs: dict[str, Any] | None = None
+    axis: int | None = None
+    weight: Any = None
+
+    def __init__(self, window_type: str = "hann", **kwargs):
+        object.__setattr__(self, "window_type", window_type)
+        object.__setattr__(self, "kwargs", dict(kwargs))
+        object.__setattr__(self, "axis", None)
+        object.__setattr__(self, "weight", None)
+
+    def bind(self, boundary: PatchBoundary) -> Self:
+        axis, start_slice, end_slice = _taper_slices(boundary, self.kwargs or {})
+        length = boundary.coords.shape[axis]
+        start_len = start_slice.stop
+        end_len = length - end_slice.start
+        if (
+            start_len is not None
+            and end_len is not None
+            and start_len > end_slice.start
+        ):
+            raise ParameterError("Taper windows cannot overlap")
+        weight = np.ones(length, dtype=np.float64)
+        if start_len is not None and start_len > 0:
+            weight[:start_len] = _taper_window(self.window_type, 2 * start_len)[
+                :start_len
+            ]
+        if end_slice.start is not None and end_slice.start < length:
+            weight[end_slice.start :] = _taper_window(self.window_type, 2 * end_len)[
+                end_len:
+            ]
+        return replace(self, axis=axis, weight=weight)
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        assert self.axis is not None
+        return patch_tree.new(
+            data=kernels.apply_1d_weight_kernel(patch_tree.data, self.axis, self.weight)
+        )
+
+
+def _taper_coord_inds(coord, values, relative, samples):
+    error_msg = "A len 2 or 4 sequence is required for taper values"
+    if not isinstance(values, (tuple, list, np.ndarray)) or not len(values):
+        raise ParameterError(error_msg)
+    if isinstance(values[0], (tuple, list, np.ndarray)):
+        return reduce(
+            add, (_taper_coord_inds(coord, item, relative, samples) for item in values)
+        )
+    if len(values) not in {2, 4}:
+        raise ParameterError(error_msg)
+    out = [None] * len(values)
+    for idx, value in enumerate(values):
+        if value is None or value == ...:
+            if len(values) == 2:
+                raise ParameterError(
+                    "Cannot use ... or None when only two values provided"
+                )
+            out[idx] = 0 if (idx / len(out)) < 0.5 else len(coord) - 1
+        else:
+            out[idx] = coord.get_next_index(value, samples=samples, relative=relative)
+    return [[0, *out, len(coord)]] if len(out) == 2 else [out]
+
+
+def _taper_curve(coord, ind_1, ind_2, window_type, reverse=False):
+    taper = _taper_window(window_type, (ind_2 - ind_1) * 2 + 1)[: ind_2 - ind_1]
+    return taper[::-1] if reverse else taper
+
+
+@dataclass(frozen=True)
+class TaperRange(PatchOperation):
+    """Apply tapers around selected coordinate ranges."""
+
+    window_type: str = "hann"
+    invert: bool = False
+    relative: bool = False
+    samples: bool = False
+    kwargs: dict[str, Any] | None = None
+    axis: int | None = None
+    weight: Any = None
+
+    def __init__(
+        self,
+        window_type: str = "hann",
+        invert=False,
+        relative=False,
+        samples=False,
+        **kwargs,
+    ):
+        object.__setattr__(self, "window_type", window_type)
+        object.__setattr__(self, "invert", invert)
+        object.__setattr__(self, "relative", relative)
+        object.__setattr__(self, "samples", samples)
+        object.__setattr__(self, "kwargs", dict(kwargs))
+        object.__setattr__(self, "axis", None)
+        object.__setattr__(self, "weight", None)
+
+    def bind(self, boundary: PatchBoundary) -> Self:
+        kwargs = self.kwargs or {}
+        dim = next(key for key in kwargs if key in boundary.dims)
+        axis = boundary.axis(dim)
+        coord = dummy_patch(boundary).get_coord(dim, require_sorted=True)
+        inds = _taper_coord_inds(coord, kwargs[dim], self.relative, self.samples)
+        weight = np.zeros(len(coord))
+        for i1, i2, i3, i4 in inds:
+            weight[i1:i2] += _taper_curve(coord, i1, i2, self.window_type)
+            weight[i3:i4] += _taper_curve(coord, i3, i4, self.window_type, reverse=True)
+            weight[i2:i3] += 1
+        if self.invert:
+            weight = np.abs(weight - np.max(weight))
+        return replace(self, axis=axis, weight=np.asarray(weight))
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        assert self.axis is not None
+        return patch_tree.new(
+            data=kernels.apply_1d_weight_kernel(patch_tree.data, self.axis, self.weight)
+        )
diff --git a/src/dasjax/operations/taup.py b/src/dasjax/operations/taup.py
new file mode 100644
index 0000000..f6fa7e9
--- /dev/null
+++ b/src/dasjax/operations/taup.py
@@ -0,0 +1,82 @@
+"""Tau-p transform operation."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Self
+
+import dascore as dc
+import numpy as np
+from dascore.exceptions import ParameterError
+from dascore.units import convert_units
+
+from dasjax.core import PatchBoundary, PatchOperation, PatchPyTree
+
+from .. import kernels
+from .common import dummy_patch, replace, tree_boundary_from_patch
+
+
+@dataclass(frozen=True)
+class TauP(PatchOperation):
+    """Compute a linear tau-p transform."""
+
+    method_name = "tau_p"
+
+    velocities: Any
+    distances: Any = None
+    dt: float = 1.0
+    p_values: Any = None
+    out_boundary: PatchBoundary | None = None
+    out_coords: tuple[Any, ...] | None = None
+    out_dtype_codes: tuple[Any, ...] | None = None
+    out_dims: tuple[str, ...] | None = None
+
+    def bind(self, boundary: PatchBoundary) -> Self:
+        velocities = np.asarray(convert_units(self.velocities, to_units="m/s"))
+        if np.any(velocities <= 0):
+            raise ParameterError("Input velocities must be positive.")
+        if not np.all(np.diff(velocities) > 0):
+            raise ParameterError("Input velocities must be monotonically increasing.")
+        patch = (
+            dummy_patch(boundary)
+            .convert_units(distance="m", time="s")
+            .transpose("distance", "time")
+        )
+        out_patch = patch.tau_p(velocities)
+        out_tree, out_boundary = tree_boundary_from_patch(out_patch)
+        dist = patch.get_coord("distance")
+        distances = (
+            np.arange(len(dist), dtype=np.float64) * float(dc.to_float(dist.step))
+            if dist.evenly_sampled
+            else np.asarray(dc.to_float(dist.values), dtype=np.float64)
+        )
+        return replace(
+            self,
+            velocities=velocities,
+            distances=distances,
+            dt=float(dc.to_float(patch.get_coord("time").step)),
+            p_values=1.0 / velocities,
+            out_boundary=out_boundary,
+            out_coords=out_tree.coord_values,
+            out_dtype_codes=out_tree.coord_dtype_codes,
+            out_dims=out_tree.dims,
+        )
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        data = kernels.tau_p_kernel(
+            patch_tree.data,
+            distances=self.distances,
+            dt=self.dt,
+            p_values=self.p_values,
+        )
+        return patch_tree.new(
+            data=data,
+            coords=self.out_coords,
+            coord_dtype_codes=self.out_dtype_codes,
+            dims=self.out_dims,
+        )
+
+    def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary:
+        _ = boundary
+        assert self.out_boundary is not None
+        return self.out_boundary
diff --git a/src/dasjax/operations/types.py b/src/dasjax/operations/types.py
deleted file mode 100644
index d32724a..0000000
--- a/src/dasjax/operations/types.py
+++ /dev/null
@@ -1,75 +0,0 @@
-"""Shared types for operation specs and registry assembly."""
-
-from __future__ import annotations
-
-from collections.abc import Callable
-from dataclasses import dataclass, field
-from enum import Enum
-from typing import Any
-
-from dascore.constants import PatchType
-
-from .patch_ops import PatchOp
-
-LeafTransform = Callable[..., tuple[Any, tuple[Any, ...]]]
-PatchValidator = Callable[..., None]
-CompiledPatchValidator = Callable[[PatchType, tuple[Any, ...], dict[str, Any]], None]
-CompiledFallbackReason = Callable[
-    [PatchType, tuple[Any, ...], dict[str, Any]], str | None
-]
-CompiledCaseGuard = Callable[
-    [PatchType, tuple[Any, ...], dict[str, Any]],
-    tuple[type[Exception], str] | None,
-]
-CallResolver = Callable[[PatchType], tuple[tuple[Any, ...], dict[str, Any]]]
-Baseline = Callable[[PatchType, tuple[Any, ...], dict[str, Any]], PatchType]
-PatchPreparer = Callable[[PatchType], PatchType]
-CallPreparer = Callable[
-    [PatchType, tuple[Any, ...], dict[str, Any]],
-    tuple[tuple[Any, ...], dict[str, Any]],
-]
-
-
-class ExecutionPolicy(str, Enum):
-    """How one operation executes inside compiled pipelines."""
-
-    LEAF = "leaf"
-    PATCH = "patch"
-
-
-def _identity_prepare(patch: PatchType) -> PatchType:
-    return patch
-
-
-def empty_call(_: PatchType) -> tuple[tuple[Any, ...], dict[str, Any]]:
-    return (), {}
-
-
-@dataclass(frozen=True)
-class OperationCase:
-    """One shared test case for eager and compiled parity."""
-
-    case_id: str
-    resolve_call: CallResolver
-    baseline: Baseline
-    prepare_patch: PatchPreparer = _identity_prepare
-    compiled_baseline: Baseline | None = None
-    compiled_error: type[Exception] | None = None
-    compiled_error_message: str | None = None
-    compiled_guard: CompiledCaseGuard | None = None
-
-
-@dataclass(frozen=True)
-class OperationSpec:
-    """Read-only operation spec for patch namespace and pipeline support."""
-
-    name: str
-    execution_policy: ExecutionPolicy
-    patch_impl: Callable[..., PatchType]
-    patch_op_cls: type[PatchOp] | None = None
-    leaf_transform: LeafTransform | None = None
-    prepare_call: CallPreparer | None = None
-    validate_patch: PatchValidator | None = None
-    validate_compiled_patch: CompiledPatchValidator | None = None
-    compiled_fallback_reason: CompiledFallbackReason | None = None
-    test_cases: tuple[OperationCase, ...] = field(default_factory=tuple)
diff --git a/src/dasjax/operations/whiten.py b/src/dasjax/operations/whiten.py
new file mode 100644
index 0000000..938b258
--- /dev/null
+++ b/src/dasjax/operations/whiten.py
@@ -0,0 +1,101 @@
+"""Whiten patch operation."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Self
+
+import dascore as dc
+from dascore.transform.fourier import dft as dc_dft
+from dascore.utils.transformatter import FourierTransformatter
+import jax.numpy as jnp
+from scipy.fft import next_fast_len
+
+from dasjax.core import PatchBoundary, PatchOperation, PatchPyTree
+
+from .. import kernels
+from .common import dummy_patch, replace
+
+
+@dataclass(frozen=True)
+class Whiten(PatchOperation):
+    """Whiten patch data along a frequency-domain dimension."""
+
+    smooth_size: float | None = None
+    water_level: float | None = None
+    kwargs: dict[str, Any] | None = None
+    axis: int | None = None
+    window_len: int | None = None
+    pad_after: int = 0
+    sample_step: float = 1.0
+    input_is_fft: bool = False
+
+    def __init__(self, smooth_size=None, water_level=None, **kwargs):
+        object.__setattr__(self, "smooth_size", smooth_size)
+        object.__setattr__(self, "water_level", water_level)
+        object.__setattr__(self, "kwargs", dict(kwargs))
+        object.__setattr__(self, "axis", None)
+        object.__setattr__(self, "window_len", None)
+        object.__setattr__(self, "pad_after", 0)
+        object.__setattr__(self, "sample_step", 1.0)
+        object.__setattr__(self, "input_is_fft", False)
+
+    def bind(self, boundary: PatchBoundary) -> Self:
+        kwargs = self.kwargs or {}
+        dim = next(iter(kwargs), "time" if "time" in boundary.dims else "time")
+        fft_dim = FourierTransformatter().rename_dims(dim)[0]
+        input_is_fft = dim not in boundary.dims and fft_dim in boundary.dims
+        axis_dim = fft_dim if input_is_fft else dim
+        axis = boundary.axis(axis_dim)
+        sample_step = (
+            1.0 if input_is_fft else abs(float(dc.to_float(boundary.coord(dim).step)))
+        )
+        axis_len = len(boundary.coord(axis_dim))
+        pad_after = 0 if input_is_fft else next_fast_len(axis_len) - axis_len
+        window_len = None
+        if self.smooth_size is not None:
+            coord = boundary.coord(fft_dim) if input_is_fft else None
+            if coord is None:
+                fft_patch = dc_dft.func(dummy_patch(boundary), dim=dim, real=True)
+                coord = fft_patch.get_coord(fft_dim)
+            window_len = coord.get_sample_count(self.smooth_size, enforce_lt_coord=True)
+        return replace(
+            self,
+            axis=axis,
+            window_len=window_len,
+            pad_after=pad_after,
+            sample_step=sample_step,
+            input_is_fft=input_is_fft,
+        )
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        assert self.axis is not None
+        data = patch_tree.data
+        if self.input_is_fft:
+            data = kernels.whiten_spectrum_kernel(
+                data,
+                axis=self.axis,
+                window_len=self.window_len,
+                water_level=self.water_level,
+            )
+            return patch_tree.new(data=data)
+        if self.pad_after:
+            pad_width = [(0, 0)] * len(patch_tree.dims)
+            pad_width[self.axis] = (0, self.pad_after)
+            data = jnp.pad(data, tuple(pad_width))
+        data = (
+            kernels.whiten_kernel(
+                data,
+                axis=self.axis,
+                window_len=self.window_len,
+                water_level=self.water_level,
+            )
+            / self.sample_step
+        )
+        if self.pad_after:
+            slices = [slice(None)] * data.ndim
+            slices[self.axis] = slice(0, data.shape[self.axis] - self.pad_after)
+            data = data[tuple(slices)]
+        return patch_tree.new(
+            data=data,
+        )
diff --git a/src/dasjax/pipeline.py b/src/dasjax/pipeline.py
index baf8b35..0140556 100644
--- a/src/dasjax/pipeline.py
+++ b/src/dasjax/pipeline.py
@@ -2,21 +2,21 @@
 
 from __future__ import annotations
 
+import hashlib
+from collections.abc import Callable
 from collections import OrderedDict
-from dataclasses import dataclass
+from dataclasses import dataclass, fields, is_dataclass
 from typing import Any, ClassVar
 
+import dascore as dc
 import jax
 import numpy as np
 from jax import tree_util
 
-from .operations import ExecutionPolicy, get_operation
-from .operations.patch_ops import patch_to_state_spec
-from .pytree import patch_to_leaves, patch_from_leaves
+from .core import PatchPyTree, get_patch_operation
 
 _COMPILED_CACHE_MAXSIZE = 128
 _SEGMENT_CACHE_MAXSIZE = 128
-_VALIDATION_CACHE_MAXSIZE = 64
 
 
 @dataclass(frozen=True)
@@ -28,6 +28,32 @@ class PipelineStep:
     kwargs: dict[str, Any]
 
 
+@dataclass(frozen=True)
+class PipelinePlanSegment:
+    """One planned execution segment for a patch pipeline."""
+
+    kind: str
+    operations: tuple[str, ...]
+    fused: bool
+    jitted: bool
+    input_dims: tuple[str, ...] = ()
+    output_dims: tuple[str, ...] = ()
+    reason: str | None = None
+
+
+@dataclass(frozen=True)
+class PipelinePlan:
+    """Diagnostic execution plan for a patch pipeline."""
+
+    segments: tuple[PipelinePlanSegment, ...]
+    uses_core: bool
+
+    @property
+    def fused_kernel_count(self) -> int:
+        """Return the number of JIT-fused execution segments."""
+        return sum(segment.jitted for segment in self.segments)
+
+
 class _BoundedCache:
     """A small insertion-ordered cache with LRU eviction."""
 
@@ -62,11 +88,12 @@ def _freeze_device(device: jax.Device | None) -> Any:
     )
 
 
-def _resolve_target_device(
+def _resolve_compile_target(
     *,
     device: jax.Device | None = None,
     backend: str | None = None,
 ) -> jax.Device | None:
+    """Return the device on which compiled inputs should be placed."""
     if device is not None and backend is not None:
         msg = "Pass either device or backend to compile(), not both."
         raise ValueError(msg)
@@ -83,12 +110,13 @@ def _resolve_target_device(
 
 def _freeze_value(value: Any) -> Any:
     """Convert nested values into hashable cache-key components."""
-    if isinstance(value, np.ndarray):
+    if isinstance(value, np.ndarray | jax.Array):
+        contiguous = np.ascontiguousarray(np.asarray(value))
         return (
             "ndarray",
-            str(value.dtype),
-            value.shape,
-            tuple(np.asarray(value).reshape(-1).tolist()),
+            contiguous.dtype.str,
+            contiguous.shape,
+            hashlib.blake2b(contiguous.tobytes(), digest_size=16).hexdigest(),
         )
     if isinstance(value, dict):
         return tuple((key, _freeze_value(val)) for key, val in sorted(value.items()))
@@ -98,70 +126,48 @@ def _freeze_value(value: Any) -> Any:
         return tuple(sorted(_freeze_value(item) for item in value))
     try:
         hash(value)
-    except TypeError as exc:
-        msg = f"Unhashable pipeline argument {value!r} cannot be compiled."
-        raise TypeError(msg) from exc
+    except TypeError:
+        return repr(value)
     return value
 
 
-def _build_segments(
-    resolved_steps: tuple[tuple[Any, tuple[Any, ...], dict[str, Any]], ...],
-) -> list[tuple[str, Any]]:
-    """Split steps into compiled segments and eager patch-executed steps.
-
-    Returns a list of tagged tuples:
-      ("patchop", tuple_of_resolved_steps)      — compiled PatchOp segment
-      ("leaf",  tuple_of_resolved_steps)        — compiled legacy leaf segment
-      ("patch", (op, args, kwargs))             — eager patch_impl step
-    """
-    segments: list[tuple[str, Any]] = []
-    patchop_run: list[Any] = []
-    patchop_has_structural = False
-    leaf_run: list[Any] = []
-    for op, args, kwargs in resolved_steps:
-        if op.patch_op_cls is not None:
-            if leaf_run:
-                segments.append(("leaf", tuple(leaf_run)))
-                leaf_run = []
-            if (
-                patchop_run
-                and patchop_has_structural
-                and getattr(
-                    op.patch_op_cls, "requires_materialized_patch_for_prepare", False
-                )
-            ):
-                segments.append(("patchop", tuple(patchop_run)))
-                patchop_run = []
-                patchop_has_structural = False
-            patchop_run.append((op, args, kwargs))
-            patchop_has_structural = patchop_has_structural or getattr(
-                op.patch_op_cls, "mutates_spec", False
+def _operation_key(operation: Any) -> tuple[Any, ...]:
+    """Return a stable cache key for a bound core operation."""
+    if is_dataclass(operation):
+        entries = tuple(
+            (field.name, _freeze_value(getattr(operation, field.name)))
+            for field in fields(operation)
+        )
+    else:
+        entries = tuple(
+            (key, _freeze_value(value)) for key, value in vars(operation).items()
+        )
+    return type(operation).operation_name(), entries
+
+
+def _boundary_cache_key(
+    patch_tree: PatchPyTree,
+    boundary: Any,
+) -> tuple[Any, ...]:
+    """Return a cache key for static metadata used during operation binding."""
+    return (
+        patch_tree.dims,
+        tuple(
+            (
+                name,
+                _freeze_value(value),
+                int(np.asarray(dtype_code).item()),
+                repr(boundary.coord(name).units),
+            )
+            for name, value, dtype_code in zip(
+                boundary.coord_names,
+                patch_tree.coord_values,
+                patch_tree.coord_dtype_codes,
+                strict=True,
             )
-            if getattr(op.patch_op_cls, "requires_materialized_patch_after", False):
-                segments.append(("patchop", tuple(patchop_run)))
-                patchop_run = []
-                patchop_has_structural = False
-            continue
-        if op.execution_policy is ExecutionPolicy.PATCH:
-            if patchop_run:
-                segments.append(("patchop", tuple(patchop_run)))
-                patchop_run = []
-                patchop_has_structural = False
-            if leaf_run:
-                segments.append(("leaf", tuple(leaf_run)))
-                leaf_run = []
-            segments.append(("patch", (op, args, kwargs)))
-        else:
-            if patchop_run:
-                segments.append(("patchop", tuple(patchop_run)))
-                patchop_run = []
-                patchop_has_structural = False
-            leaf_run.append((op, args, kwargs))
-    if patchop_run:
-        segments.append(("patchop", tuple(patchop_run)))
-    if leaf_run:
-        segments.append(("leaf", tuple(leaf_run)))
-    return segments
+        ),
+        repr(boundary.attrs),
+    )
 
 
 class JaxPatchPipeline:
@@ -181,7 +187,7 @@ def steps(self) -> tuple[PipelineStep, ...]:
 
     def __getattr__(self, name: str):
         """Record only known JAX patch operations."""
-        get_operation(name)
+        get_patch_operation(name)
 
         def _record(*args: Any, **kwargs: Any) -> "JaxPatchPipeline":
             step = PipelineStep(name=name, args=args, kwargs=dict(kwargs))
@@ -194,9 +200,9 @@ def _compile_cache_key(
         *,
         device: jax.Device | None = None,
         backend: str | None = None,
-        assert_no_fallback: bool = False,
     ) -> tuple[Any, ...]:
         """Return a stable cache key for equivalent pipeline definitions."""
+        _ = backend
         return (
             tuple(
                 (
@@ -207,222 +213,221 @@ def _compile_cache_key(
                 for step in self._steps
             ),
             _freeze_device(device),
-            backend,
-            assert_no_fallback,
         )
 
-    @staticmethod
-    def _validation_signature(patch) -> tuple[Any, ...]:
-        data = np.asarray(patch.data)
-        coord_sig = tuple(
-            (
-                name,
-                tuple(patch.coords.dim_map[name]),
-                np.asarray(coord.values).dtype.str,
-                len(coord),
-                getattr(coord, "step", None),
-            )
-            for name, coord in patch.coords.coord_map.items()
-        )
-        return (
-            tuple(patch.dims),
-            tuple(patch.shape),
-            data.dtype.str,
-            bool(np.isfinite(data).all()),
-            coord_sig,
-        )
-
-    def _resolve_steps(self) -> tuple[tuple[Any, tuple[Any, ...], dict[str, Any]], ...]:
-        """Resolve operation names into operation specs once."""
+    def _resolve_operations(self) -> tuple[Any, ...]:
+        """Return class-authored operation instances."""
         return tuple(
-            (get_operation(step.name), step.args, step.kwargs) for step in self._steps
+            get_patch_operation(step.name)(*step.args, **step.kwargs)
+            for step in self._steps
         )
 
     @staticmethod
-    def _freeze_resolved_steps(
-        resolved_steps: tuple[tuple[Any, tuple[Any, ...], dict[str, Any]], ...],
-    ) -> tuple[Any, ...]:
-        return tuple(
-            (
-                op.name,
-                _freeze_value(args),
-                _freeze_value(kwargs),
-            )
-            for op, args, kwargs in resolved_steps
-        )
+    def _build_core_runner(operations: tuple[Any, ...]):
+        """Build a class-authored PatchPyTree operation segment."""
 
-    @staticmethod
-    def _compile_leaf_runner(
-        resolved_steps: tuple[tuple[Any, tuple[Any, ...], dict[str, Any]], ...],
-    ):
-        """Compile the leaf-native execution path once per pipeline definition."""
-
-        def _run(data, coord_leaves, dims):
-            for op, args, kwargs in resolved_steps:
-                assert op.leaf_transform is not None
-                data, coord_leaves = op.leaf_transform(
-                    data,
-                    coord_leaves,
-                    *args,
-                    dims=dims,
-                    **kwargs,
-                )
-            return data, coord_leaves
+        def _run(patch_tree):
+            current = patch_tree
+            for operation in operations:
+                current = operation.kernel(current)
+            return current
 
-        return jax.jit(_run, static_argnums=2)
+        return jax.jit(_run)
 
     @staticmethod
-    def _compile_patchop_runner(prepared_ops: tuple[Any, ...]):
-        """Compile one unified PatchOp segment."""
+    def _plan_core_segments(
+        operations: tuple[Any, ...],
+        boundary: Any,
+    ) -> tuple[tuple[tuple[Any, ...], Any, bool], ...]:
+        """Bind operations and statically advance boundaries for JAX segments."""
+        segments: list[tuple[tuple[Any, ...], Any, bool]] = []
+        start_index = 0
+        while start_index < len(operations):
+            bound_ops, boundary, needs_result_boundary, start_index = (
+                JaxPatchPipeline._plan_core_segment(
+                    operations,
+                    boundary,
+                    start_index,
+                )
+            )
+            segments.append((bound_ops, boundary, needs_result_boundary))
+            if needs_result_boundary:
+                break
+        return tuple(segments)
 
-        def _run(state):
-            current_state = state
-            for prepared_op in prepared_ops:
-                current_state = prepared_op.apply(current_state)
-            return current_state
+    @staticmethod
+    def _plan_core_segment(
+        operations: tuple[Any, ...],
+        boundary: Any,
+        start_index: int,
+    ) -> tuple[tuple[Any, ...], Any, bool, int]:
+        """Bind one executable segment, stopping at result-dependent metadata."""
+        segment_ops: list[Any] = []
+        current_boundary = boundary
+        op_index = start_index
+        while op_index < len(operations):
+            operation = operations[op_index]
+            bound_operation = operation.bind(current_boundary)
+            segment_ops.append(bound_operation)
+            if type(bound_operation).overrides("update_boundary"):
+                current_boundary = bound_operation.update_boundary(current_boundary)
+            needs_result_boundary = type(bound_operation).overrides(
+                "update_boundary_from_result"
+            )
+            stops_segment = needs_result_boundary
+            op_index += 1
+            if stops_segment:
+                return (
+                    tuple(segment_ops),
+                    current_boundary,
+                    needs_result_boundary,
+                    op_index,
+                )
+        return tuple(segment_ops), current_boundary, False, op_index
 
-        return jax.jit(_run)
+    def plan(self, patch: dc.Patch) -> PipelinePlan:
+        """Return a diagnostic execution plan for this pipeline and patch."""
+        return self._plan_core_execution(patch, self._resolve_operations())
 
-    def _get_compiled_fallback_reasons(self, patch) -> tuple[str, ...]:
-        resolved_steps = self._resolve_steps()
-        reasons = []
-        for op, args, kwargs in resolved_steps:
-            if op.compiled_fallback_reason is None:
-                continue
-            reason = op.compiled_fallback_reason(patch, args, kwargs)
-            if reason is not None:
-                reasons.append(f"{op.name}: {reason}")
-        return tuple(reasons)
-
-    def assert_no_fallback(self, patch) -> None:
-        """Raise if any step would use a host fallback for this patch."""
-        reasons = self._get_compiled_fallback_reasons(patch)
-        if reasons:
-            msg = "Compiled pipeline would use host fallbacks:\n" + "\n".join(reasons)
-            raise AssertionError(msg)
+    def _plan_core_execution(
+        self,
+        patch,
+        core_operations: tuple[Any, ...],
+    ) -> PipelinePlan:
+        """Plan class-authored core execution without running kernels."""
+        _, boundary = PatchPyTree.from_patch(patch)
+        segments: list[PipelinePlanSegment] = []
+        op_index = 0
+        while op_index < len(core_operations):
+            input_dims = boundary.dims
+            bound_ops, planned_boundary, needs_result_boundary, op_index = (
+                self._plan_core_segment(core_operations, boundary, op_index)
+            )
+            reason = (
+                "requires result-dependent boundary update"
+                if needs_result_boundary
+                else None
+            )
+            segments.append(
+                PipelinePlanSegment(
+                    kind="core",
+                    operations=tuple(type(op).operation_name() for op in bound_ops),
+                    fused=len(bound_ops) > 1,
+                    jitted=True,
+                    input_dims=input_dims,
+                    output_dims=planned_boundary.dims,
+                    reason=reason,
+                )
+            )
+            boundary = planned_boundary
+            if needs_result_boundary:
+                if op_index < len(core_operations):
+                    remaining = core_operations[op_index:]
+                    segments.append(
+                        PipelinePlanSegment(
+                            kind="unplanned",
+                            operations=tuple(
+                                type(op).operation_name() for op in remaining
+                            ),
+                            fused=False,
+                            jitted=False,
+                            input_dims=boundary.dims,
+                            output_dims=(),
+                            reason="requires executing previous segment first",
+                        )
+                    )
+                break
+        return PipelinePlan(segments=tuple(segments), uses_core=True)
 
     def compile(
         self,
         *,
         device: jax.Device | None = None,
         backend: str | None = None,
-        assert_no_fallback: bool = False,
-    ):
-        """Compile the recorded steps into a callable `Patch -> Patch`.
-
-        Leaf-native operations are fused into jax.jit-compiled segments.
-        Patch-native operations run eagerly via patch_impl between those
-        segments, so compiled pipelines can mix both execution modes.
+    ) -> Callable[[dc.Patch], dc.Patch]:
+        """Build a reusable callable `Patch -> Patch` from recorded steps.
+
+        Class-authored operations are bound against a patch boundary, grouped
+        into JIT segments, and reconstructed through the final boundary. Binding
+        and segment JIT creation are lazy: they happen on the first compatible
+        patch call, then reuse cached segment runners.
+
+        Parameters
+        ----------
+        device
+            Exact JAX device on which patch-tree inputs are placed before
+            running JIT segments. Mutually exclusive with ``backend``.
+        backend
+            JAX backend name, such as ``"cpu"`` or ``"gpu"``. The first local
+            device for the backend is selected as the input placement target.
         """
-        target_device = _resolve_target_device(device=device, backend=backend)
+        target_device = _resolve_compile_target(
+            device=device,
+            backend=backend,
+        )
+        operations = self._resolve_operations()
         cache_key = self._compile_cache_key(
             device=target_device,
-            backend=backend,
-            assert_no_fallback=assert_no_fallback,
         )
         cached = self._compiled_cache.get(cache_key)
         if cached is not None:
             return cached
 
-        resolved_steps = self._resolve_steps()
-        segments = _build_segments(resolved_steps)
-        # One inner cache dict per leaf segment (None for patch slots).
-        compiled_by_segment: list[_BoundedCache | None] = [
-            _BoundedCache(maxsize=_SEGMENT_CACHE_MAXSIZE)
-            if kind in {"leaf", "patchop"}
-            else None
-            for kind, _ in segments
-        ]
-        validated_signatures = _BoundedCache(maxsize=_VALIDATION_CACHE_MAXSIZE)
-        fallback_checked_signatures = _BoundedCache(maxsize=_VALIDATION_CACHE_MAXSIZE)
+        core_segment_cache = _BoundedCache(maxsize=_SEGMENT_CACHE_MAXSIZE)
+        plan_cache = _BoundedCache(maxsize=_SEGMENT_CACHE_MAXSIZE)
 
         def _compiled_patch_fn(patch):
-            patch_signature = self._validation_signature(patch)
-            if (
-                assert_no_fallback
-                and fallback_checked_signatures.get(patch_signature) is None
-            ):
-                self.assert_no_fallback(patch)
-                fallback_checked_signatures.add(patch_signature, True)
-            if validated_signatures.get(patch_signature) is None:
-                for op, args, kwargs in resolved_steps:
-                    if op.validate_patch is not None:
-                        op.validate_patch(patch, *args, **kwargs)
-                    if op.validate_compiled_patch is not None:
-                        op.validate_compiled_patch(patch, args, kwargs)
-                validated_signatures.add(patch_signature, True)
-
-            current_patch = patch
-            for seg_idx, (kind, seg_data) in enumerate(segments):
-                if kind == "patch":
-                    op, args, kwargs = seg_data
-                    current_patch = op.patch_impl(current_patch, *args, **kwargs)
-                elif kind == "patchop":
-                    prepared_ops = tuple(
-                        op.patch_op_cls.prepare(current_patch, *args, **kwargs)
-                        for op, args, kwargs in seg_data
-                    )
-                    prepared_key = tuple(
-                        prepared_op.compile_key() for prepared_op in prepared_ops
-                    )
-                    seg_cache = compiled_by_segment[seg_idx]
-                    compiled = seg_cache.get(prepared_key)
-                    if compiled is None:
-                        compiled = self._compile_patchop_runner(prepared_ops)
-                        seg_cache.add(prepared_key, compiled)
-                    state, spec = patch_to_state_spec(current_patch)
-                    if target_device is not None:
-                        state = tree_util.tree_map(
-                            lambda x: jax.device_put(x, device=target_device), state
+            patch_tree, boundary = PatchPyTree.from_patch(patch)
+            current_tree = patch_tree
+            if target_device is not None:
+                current_tree = tree_util.tree_map(
+                    lambda x: jax.device_put(x, device=target_device),
+                    current_tree,
+                )
+            current_boundary = boundary
+            op_index = 0
+            while op_index < len(operations):
+                boundary_key = _boundary_cache_key(current_tree, current_boundary)
+                plan_key = (op_index, boundary_key)
+                planned = plan_cache.get(plan_key)
+                if planned is None:
+                    bound_ops, planned_boundary, needs_result_boundary, next_index = (
+                        self._plan_core_segment(
+                            operations,
+                            current_boundary,
+                            op_index,
                         )
-                    out_state = compiled(state)
-                    out_spec = spec
-                    for prepared_op in prepared_ops:
-                        out_spec = out_spec.apply_meta(prepared_op.meta_delta(out_spec))
-                    current_patch = prepared_ops[-1].reconstruct(
-                        current_patch,
-                        out_spec,
-                        out_state,
                     )
-                else:
-                    leaf_steps = seg_data
-                    prepared_steps = tuple(
-                        (op, *op.prepare_call(current_patch, args, kwargs))
-                        if op.prepare_call is not None
-                        else (op, args, kwargs)
-                        for op, args, kwargs in leaf_steps
+                    segment_key = tuple(
+                        _operation_key(bound_operation) for bound_operation in bound_ops
                     )
-                    prepared_key = self._freeze_resolved_steps(prepared_steps)
-                    seg_cache = compiled_by_segment[seg_idx]
-                    compiled = seg_cache.get(prepared_key)
-                    if compiled is None:
-                        compiled = self._compile_leaf_runner(prepared_steps)
-                        seg_cache.add(prepared_key, compiled)
-                    data, coord_leaves, aux_data = patch_to_leaves(current_patch)
-                    if target_device is not None:
-                        data = jax.device_put(data, device=target_device)
-                        coord_leaves = tree_util.tree_map(
-                            lambda x: jax.device_put(x, device=target_device),
-                            coord_leaves,
-                        )
-                    out_data, out_coord_leaves = compiled(
-                        data,
-                        coord_leaves,
-                        aux_data["dims"],
+                    planned = (
+                        bound_ops,
+                        planned_boundary,
+                        needs_result_boundary,
+                        next_index,
+                        segment_key,
                     )
-                    next_kind = (
-                        segments[seg_idx + 1][0]
-                        if seg_idx + 1 < len(segments)
-                        else None
-                    )
-                    current_patch = patch_from_leaves(
-                        out_data,
-                        out_coord_leaves,
-                        aux_data,
-                        coerce_numpy=next_kind != "leaf",
+                    plan_cache.add(plan_key, planned)
+                (
+                    bound_ops,
+                    planned_boundary,
+                    needs_result_boundary,
+                    op_index,
+                    segment_key,
+                ) = planned
+                compiled = core_segment_cache.get(segment_key)
+                if compiled is None:
+                    compiled = self._build_core_runner(bound_ops)
+                    core_segment_cache.add(segment_key, compiled)
+                current_tree = compiled(current_tree)
+                current_boundary = planned_boundary
+                if needs_result_boundary:
+                    current_boundary = bound_ops[-1].update_boundary_from_result(
+                        current_tree,
+                        current_boundary,
                     )
-
-            return current_patch
+            return current_boundary.to_patch(current_tree)
 
         self._compiled_cache.add(cache_key, _compiled_patch_fn)
         return _compiled_patch_fn
diff --git a/src/dasjax/pytree.py b/src/dasjax/pytree.py
deleted file mode 100644
index 1a01c0a..0000000
--- a/src/dasjax/pytree.py
+++ /dev/null
@@ -1,102 +0,0 @@
-"""JAX pytree registration for DASCore patches."""
-
-from __future__ import annotations
-
-from typing import Any
-
-import dascore as dc
-import jax
-import numpy as np
-
-SUPPORTED_DTYPES = (np.bool_, np.integer, np.floating, np.complexfloating)
-TIME_DTYPES = (np.datetime64, np.timedelta64)
-
-
-def _matches_dtype(dtype: np.dtype, candidates: tuple[type[Any], ...]) -> bool:
-    """Return True if dtype is a subdtype of any candidate."""
-    return any(np.issubdtype(dtype, candidate) for candidate in candidates)
-
-
-def _encode_leaf(array: Any) -> tuple[Any, str]:
-    """Return a JAX-friendly leaf and a dtype token for reconstruction."""
-    arr = np.asarray(array)
-    dtype_token = arr.dtype.str
-    if _matches_dtype(arr.dtype, SUPPORTED_DTYPES):
-        return arr, dtype_token
-    if _matches_dtype(arr.dtype, TIME_DTYPES):
-        return arr.view(np.int64), dtype_token
-    msg = f"Unsupported coordinate dtype for JAX pytree registration: {arr.dtype}"
-    raise TypeError(msg)
-
-
-def _decode_leaf(array: Any, dtype_token: str) -> np.ndarray:
-    """Restore an encoded leaf to its original dtype."""
-    out = np.asarray(array)
-    dtype = np.dtype(dtype_token)
-    if _matches_dtype(dtype, TIME_DTYPES):
-        return out.astype(np.int64, copy=False).view(dtype)
-    return out.astype(dtype, copy=False)
-
-
-def patch_to_leaves(patch: dc.Patch) -> tuple[Any, tuple[Any, ...], dict[str, Any]]:
-    """Split a patch into dynamic leaves and static reconstruction metadata."""
-    coord_names = tuple(patch.coords.coord_map)
-    coord_leaves = []
-    coord_meta = []
-    for name in coord_names:
-        coord = patch.coords.coord_map[name]
-        encoded_values, dtype_token = _encode_leaf(coord.values)
-        coord_leaves.append(encoded_values)
-        coord_meta.append(
-            {
-                "name": name,
-                "dims": tuple(patch.coords.dim_map[name]),
-                "dtype": dtype_token,
-                "coord": coord,
-            }
-        )
-    aux_data = {
-        "dims": tuple(patch.dims),
-        "attrs": patch.attrs,
-        "coord_meta": tuple(coord_meta),
-    }
-    return patch.data, tuple(coord_leaves), aux_data
-
-
-def patch_from_leaves(
-    data: Any,
-    coord_leaves: tuple[Any, ...],
-    aux_data: dict[str, Any],
-    *,
-    coerce_numpy: bool = True,
-) -> dc.Patch:
-    """Rebuild a patch from pytree leaves and static metadata."""
-    coords: dict[str, Any] = {}
-    for meta, leaf in zip(aux_data["coord_meta"], coord_leaves, strict=True):
-        values = _decode_leaf(leaf, meta["dtype"])
-        coord = meta["coord"].update_data(data=values)
-        dims = tuple(meta["dims"])
-        coords[meta["name"]] = (
-            coord if len(dims) == 1 and dims[0] == meta["name"] else (dims, coord)
-        )
-    return dc.Patch(
-        data=np.asarray(data) if coerce_numpy else data,
-        coords=coords,
-        dims=aux_data["dims"],
-        attrs=aux_data["attrs"],
-    )
-
-
-def _flatten_patch(patch: dc.Patch) -> tuple[tuple[Any, ...], dict[str, Any]]:
-    """JAX pytree flatten hook."""
-    data, coord_leaves, aux_data = patch_to_leaves(patch)
-    return (data, *coord_leaves), aux_data
-
-
-def _unflatten_patch(aux_data: dict[str, Any], children: tuple[Any, ...]) -> dc.Patch:
-    """JAX pytree unflatten hook."""
-    data, *coord_leaves = children
-    return patch_from_leaves(data, tuple(coord_leaves), aux_data)
-
-
-jax.tree_util.register_pytree_node(dc.Patch, _flatten_patch, _unflatten_patch)
diff --git a/tests/operations/__init__.py b/tests/operations/__init__.py
new file mode 100644
index 0000000..6f3fe64
--- /dev/null
+++ b/tests/operations/__init__.py
@@ -0,0 +1 @@
+"""Operation parity tests."""
diff --git a/tests/operations/helpers.py b/tests/operations/helpers.py
new file mode 100644
index 0000000..465cfba
--- /dev/null
+++ b/tests/operations/helpers.py
@@ -0,0 +1,50 @@
+"""Shared helpers for operation parity tests."""
+
+from __future__ import annotations
+
+import dascore as dc
+import numpy as np
+
+from dasjax import JaxPatchPipeline
+
+
+def assert_patch_close(left, right) -> None:
+    """Assert data closeness and exact coordinate preservation."""
+    assert np.allclose(left.data, right.data, equal_nan=True, rtol=1e-5, atol=1e-6)
+    assert left.coords == right.coords
+
+
+def complex_patch(patch):
+    """Return a patch with complex-valued data."""
+    return patch.update(data=patch.data + 1j * patch.data)
+
+
+def even_patch(patch):
+    """Return a patch with an even number of time samples."""
+    return patch.select(time=(..., patch.get_coord("time").values[-2]))
+
+
+def fourier_patch(patch):
+    """Return a patch transformed along time."""
+    return patch.dft("time", real=True)
+
+
+def fbe_baseline(patch):
+    """Return the DASCore baseline for frequency-band energy."""
+    out = patch.stft(time=64, samples=True, overlap=32).abs()
+    ft_dim = next(dim for dim in out.dims if dim.startswith("ft_"))
+    out = out.select(**{ft_dim: (2.0, 10.0)})
+    return out.sum(dim=ft_dim, dim_reduce="squeeze")
+
+
+def assert_compiled_matches_dascore(case) -> None:
+    """Compile one pipeline case and compare it to the DASCore baseline."""
+    name, args, kwargs, baseline, *rest = case
+    example_patch = dc.get_example_patch()
+    patch = rest[0](example_patch) if rest else example_patch
+    pipeline = getattr(JaxPatchPipeline(), name)(*args, **kwargs)
+
+    out = pipeline.compile()(patch)
+    expected = baseline(patch)
+
+    assert_patch_close(out, expected)
diff --git a/tests/operations/test_basic.py b/tests/operations/test_basic.py
new file mode 100644
index 0000000..c1d0e87
--- /dev/null
+++ b/tests/operations/test_basic.py
@@ -0,0 +1,106 @@
+"""Parity tests for basic patch operations."""
+
+from __future__ import annotations
+
+import dascore as dc
+import numpy as np
+import pytest
+
+from dasjax import JaxPatchPipeline
+from dasjax.kernels import normalize_kernel
+
+from .helpers import assert_compiled_matches_dascore, assert_patch_close, complex_patch
+
+
+CASES = (
+    ("identity", (), {}, lambda p: p),
+    ("scale", (2.0,), {}, lambda p: p * 2.0),
+    ("add", (2.0,), {}, lambda p: p + 2.0),
+    ("abs", (), {}, lambda p: p.abs(), complex_patch),
+    ("clip", (-0.25, 0.25), {}, lambda p: p.update(data=np.clip(p.data, -0.25, 0.25))),
+    ("real", (), {}, lambda p: p.real(), complex_patch),
+    ("imag", (), {}, lambda p: p.imag(), complex_patch),
+    ("angle", (), {}, lambda p: p.angle(), complex_patch),
+    ("conj", (), {}, lambda p: p.conj(), complex_patch),
+    ("flip", ("time",), {}, lambda p: p.flip("time")),
+    ("roll", (), {"time": 5, "samples": True}, lambda p: p.roll(time=5, samples=True)),
+    ("standardize", (), {"dim": "time"}, lambda p: p.standardize(dim="time")),
+    (
+        "normalize",
+        (),
+        {"dim": "time", "norm": "l2"},
+        lambda p: p.normalize(dim="time", norm="l2"),
+    ),
+    (
+        "pad",
+        (),
+        {"time": (2, 3), "samples": True},
+        lambda p: p.pad(time=(2, 3), samples=True),
+    ),
+)
+
+
+@pytest.mark.parametrize("case", CASES, ids=lambda item: item[0])
+def test_compiled_basic_operation_matches_dascore(case) -> None:
+    """Match compiled basic operations against DASCore baselines."""
+    assert_compiled_matches_dascore(case)
+
+
+@pytest.mark.parametrize("norm", ["l1", "max", "bit"])
+def test_normalize_modes_match_dascore(norm: str) -> None:
+    """Cover non-default normalization modes."""
+    patch = dc.get_example_patch()
+    pipeline = JaxPatchPipeline().normalize(dim="time", norm=norm)
+
+    assert_patch_close(
+        pipeline.compile()(patch),
+        patch.normalize(dim="time", norm=norm),
+    )
+
+
+def test_normalize_zero_and_invalid_mode() -> None:
+    """Cover zero-norm handling and invalid normalization mode."""
+    data = np.zeros((2, 3))
+
+    assert np.array_equal(np.asarray(normalize_kernel(data, axis=1)), data)
+    with pytest.raises(ValueError, match="Unsupported normalization"):
+        normalize_kernel(data, axis=1, norm="bad")
+
+
+def test_pad_fft_correlate_and_coordinate_padding() -> None:
+    """Cover special and non-sample pad width branches."""
+    patch = dc.get_example_patch()
+    cases = (
+        ({"time": "fft"}, lambda p: p.pad(time="fft")),
+        ({"time": "correlate"}, lambda p: p.pad(time="correlate")),
+        (
+            {"time": np.timedelta64(1, "ms")},
+            lambda p: p.pad(time=np.timedelta64(1, "ms")),
+        ),
+    )
+    for kwargs, baseline in cases:
+        out = JaxPatchPipeline().pad(**kwargs).compile()(patch)
+        assert_patch_close(out, baseline(patch))
+
+
+def test_roll_update_coord_is_rejected() -> None:
+    """Cover unsupported roll coordinate updates."""
+    patch = dc.get_example_patch()
+    with pytest.raises(NotImplementedError, match="update_coord=False"):
+        JaxPatchPipeline().roll(time=1, samples=True, update_coord=True).compile()(
+            patch
+        )
+
+
+def test_aggregate_unsupported_options_are_rejected() -> None:
+    """Cover aggregate validation for unsupported methods and reductions."""
+    patch = dc.get_example_patch()
+
+    with pytest.raises(NotImplementedError, match="Unsupported aggregate method"):
+        JaxPatchPipeline().aggregate(dim="time", method=np.ptp).compile()(patch)
+    with pytest.raises(NotImplementedError, match="dim_reduce"):
+        JaxPatchPipeline().aggregate(
+            dim="time",
+            method="mean",
+            dim_reduce="bad",
+        ).compile()(patch)
diff --git a/tests/operations/test_detrend.py b/tests/operations/test_detrend.py
new file mode 100644
index 0000000..4713d6f
--- /dev/null
+++ b/tests/operations/test_detrend.py
@@ -0,0 +1,48 @@
+"""Parity tests for detrend operations."""
+
+from __future__ import annotations
+
+import dascore as dc
+import numpy as np
+import pytest
+
+from dasjax import JaxPatchPipeline
+from dasjax.kernels import detrend_kernel, validate_detrend_type
+
+from .helpers import assert_compiled_matches_dascore, assert_patch_close
+
+
+CASES = (
+    (
+        "detrend",
+        (),
+        {"dim": "time", "type": "constant"},
+        lambda p: p.detrend(dim="time", type="constant"),
+    ),
+)
+
+
+@pytest.mark.parametrize("case", CASES, ids=lambda item: item[0])
+def test_compiled_detrend_operation_matches_dascore(case) -> None:
+    """Match compiled detrend operations against DASCore baselines."""
+    assert_compiled_matches_dascore(case)
+
+
+@pytest.mark.parametrize("detrend_type", ["linear", "l", "c"])
+def test_detrend_aliases_match_dascore(detrend_type: str) -> None:
+    """Cover detrend aliases and the linear kernel path."""
+    patch = dc.get_example_patch()
+    pipeline = JaxPatchPipeline().detrend(dim="time", type=detrend_type)
+
+    assert_patch_close(
+        pipeline.compile()(patch),
+        patch.detrend(dim="time", type=detrend_type),
+    )
+
+
+def test_detrend_rejects_invalid_type() -> None:
+    """Cover invalid detrend validation."""
+    with pytest.raises(ValueError, match="Trend type"):
+        validate_detrend_type("curve")
+    with pytest.raises(ValueError, match="Trend type"):
+        detrend_kernel(np.arange(5.0), axis=0, type="curve")
diff --git a/tests/operations/test_differentiate.py b/tests/operations/test_differentiate.py
new file mode 100644
index 0000000..18223d4
--- /dev/null
+++ b/tests/operations/test_differentiate.py
@@ -0,0 +1,43 @@
+"""Parity tests for differentiate operations."""
+
+from __future__ import annotations
+
+import dascore as dc
+import numpy as np
+import pytest
+from dascore.exceptions import ParameterError
+
+from dasjax import JaxPatchPipeline
+from dasjax.kernels import differentiate_kernel
+
+from .helpers import assert_compiled_matches_dascore, assert_patch_close
+
+
+CASES = (("differentiate", (), {"dim": "time"}, lambda p: p.differentiate(dim="time")),)
+
+
+@pytest.mark.parametrize("case", CASES, ids=lambda item: item[0])
+def test_compiled_differentiate_operation_matches_dascore(case) -> None:
+    """Match compiled differentiate operations against DASCore baselines."""
+    assert_compiled_matches_dascore(case)
+
+
+def test_differentiate_step_and_uneven_spacing_paths() -> None:
+    """Cover stepped differentiation and uneven coordinate spacing."""
+    patch = dc.get_example_patch()
+    stepped = JaxPatchPipeline().differentiate(dim="time", step=2).compile()(patch)
+    assert_patch_close(stepped, patch.differentiate(dim="time", step=2))
+
+    data = np.arange(5.0) ** 2
+    spacing = np.asarray([0.0, 0.5, 1.5, 3.0, 5.0])
+    out = np.asarray(differentiate_kernel(data, axis=0, dx_or_spacing=spacing))
+    assert out.shape == data.shape
+
+    with pytest.raises(NotImplementedError, match="order=2"):
+        differentiate_kernel(data, axis=0, dx_or_spacing=1.0, order=1)
+    with pytest.raises(ValueError, match="too small"):
+        differentiate_kernel(np.arange(2.0), axis=0, dx_or_spacing=1.0)
+    with pytest.raises(ParameterError, match="only be used along one axis"):
+        JaxPatchPipeline().differentiate(dim=("time", "distance"), step=2).compile()(
+            patch
+        )
diff --git a/tests/operations/test_domain.py b/tests/operations/test_domain.py
new file mode 100644
index 0000000..cbb185c
--- /dev/null
+++ b/tests/operations/test_domain.py
@@ -0,0 +1,203 @@
+"""Parity tests for domain transform operations."""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+import dascore as dc
+from dascore.exceptions import ParameterError
+
+from dasjax import JaxPatchPipeline
+
+from .helpers import assert_patch_close
+
+
+def small_patch():
+    """Return a compact patch for domain transform parity tests."""
+    patch = dc.get_example_patch()
+    time = patch.get_coord("time").values
+    return patch.select(distance=(0, 20), time=(time[0], time[200]))
+
+
+CASES = (
+    (
+        "line_mute",
+        (),
+        {"time": (0, 0.1)},
+        lambda p: p.line_mute(time=(0, 0.1)),
+        small_patch,
+    ),
+    (
+        "slope_mute",
+        ((1000.0, 3000.0),),
+        {},
+        lambda p: p.slope_mute((1000.0, 3000.0)),
+        small_patch,
+    ),
+    (
+        "wiener_filter",
+        (),
+        {"time": 5, "samples": True},
+        lambda p: p.wiener_filter(time=5, samples=True),
+        small_patch,
+    ),
+    (
+        "phase_weighted_stack",
+        ("distance",),
+        {"transform_dim": "time"},
+        lambda p: p.phase_weighted_stack("distance", transform_dim="time"),
+        small_patch,
+    ),
+    (
+        "slope_filter",
+        ([100.0, 200.0, 500.0, 1000.0],),
+        {},
+        lambda p: p.slope_filter([100.0, 200.0, 500.0, 1000.0]),
+        small_patch,
+    ),
+    (
+        "tau_p",
+        (np.asarray([1000.0, 2000.0]),),
+        {},
+        lambda p: p.tau_p(np.asarray([1000.0, 2000.0])),
+        lambda: small_patch().set_units(distance="m", time="s"),
+    ),
+    (
+        "dispersion_phase_shift",
+        (np.asarray([100.0, 200.0]),),
+        {"approx_freq": (1.0, 10.0)},
+        lambda p: p.dispersion_phase_shift(
+            np.asarray([100.0, 200.0]), approx_freq=(1.0, 10.0)
+        ),
+        lambda: small_patch().set_units(distance="m", time="s"),
+    ),
+)
+
+
+@pytest.mark.parametrize("case", CASES, ids=lambda item: item[0])
+def test_compiled_domain_operation_matches_dascore(case) -> None:
+    """Match compiled domain operations against DASCore baselines."""
+    name, args, kwargs, baseline, patch_factory = case
+    patch = patch_factory()
+    pipeline = getattr(JaxPatchPipeline(), name)(*args, **kwargs)
+
+    assert_patch_close(pipeline.compile()(patch), baseline(patch))
+
+
+def test_compiled_strain_operations_match_dascore() -> None:
+    """Match compiled strain transforms against DASCore baselines."""
+    patch = dc.get_example_patch("deformation_rate_event_1")
+
+    cases = (
+        (
+            JaxPatchPipeline().velocity_to_strain_rate(),
+            patch.velocity_to_strain_rate(),
+            patch,
+        ),
+        (
+            JaxPatchPipeline().velocity_to_strain_rate_edgeless(step_multiple=2),
+            patch.velocity_to_strain_rate_edgeless(step_multiple=2),
+            patch,
+        ),
+    )
+    for pipeline, expected, source in cases:
+        assert_patch_close(pipeline.compile()(source), expected)
+
+    radians_patch = patch.update(
+        data=patch.data,
+        attrs=patch.attrs.update(data_units="rad", gauge_length=10.0),
+    )
+    assert_patch_close(
+        JaxPatchPipeline().radians_to_strain().compile()(radians_patch),
+        radians_patch.radians_to_strain(),
+    )
+
+    non_radian_patch = patch.update(
+        data=patch.data,
+        attrs=patch.attrs.update(data_units="m/s", gauge_length=10.0),
+    )
+    assert_patch_close(
+        JaxPatchPipeline().radians_to_strain().compile()(non_radian_patch),
+        non_radian_patch,
+    )
+
+
+def test_domain_operation_validation_edges() -> None:
+    """Cover validation paths for domain transforms."""
+    patch = small_patch().set_units(distance="m", time="s")
+
+    no_freq_out = (
+        JaxPatchPipeline()
+        .dispersion_phase_shift(np.asarray([100.0, 200.0]))
+        .compile()(patch)
+    )
+    assert (
+        no_freq_out.shape
+        == patch.dispersion_phase_shift(np.asarray([100.0, 200.0])).shape
+    )
+
+    for velocities, message in (
+        (np.asarray([200.0, 100.0]), "monotonically increasing"),
+        (np.asarray([-100.0, 200.0]), "positive"),
+    ):
+        with pytest.raises(ParameterError, match=message):
+            JaxPatchPipeline().dispersion_phase_shift(velocities).compile()(patch)
+
+    for kwargs, message in (
+        ({"approx_resolution": 0.0}, "Frequency resolution"),
+        ({"approx_freq": (0.0, 10.0)}, "Minimal and maximal"),
+        ({"approx_freq": (10.0, 1.0)}, "Maximal frequency"),
+        ({"approx_freq": (1.0, 1000.0)}, "Nyquist"),
+        (
+            {"approx_resolution": 100.0, "approx_freq": (1.0, 2.0)},
+            "not an array",
+        ),
+    ):
+        with pytest.raises(ParameterError, match=message):
+            JaxPatchPipeline().dispersion_phase_shift(
+                np.asarray([100.0, 200.0]), **kwargs
+            ).compile()(patch)
+
+    for velocities, message in (
+        (np.asarray([0.0, 1000.0]), "positive"),
+        (np.asarray([2000.0, 1000.0]), "monotonically increasing"),
+    ):
+        with pytest.raises(ParameterError, match=message):
+            JaxPatchPipeline().tau_p(velocities).compile()(patch)
+
+
+def test_mute_and_strain_validation_edges() -> None:
+    """Cover mute and strain transform edge paths."""
+    patch = small_patch().set_units(distance="m", time="s")
+    strain_patch = dc.get_example_patch("deformation_rate_event_1")
+
+    assert_patch_close(
+        JaxPatchPipeline().slope_mute((0.0, np.inf)).compile()(patch),
+        patch.slope_mute((0.0, np.inf)),
+    )
+    for slopes, message in (
+        ((1.0,), "length 2"),
+        ((-1.0, 1.0), "positive"),
+    ):
+        with pytest.raises(ParameterError, match=message):
+            JaxPatchPipeline().slope_mute(slopes).compile()(patch)
+
+    with pytest.raises(ParameterError, match="positive"):
+        JaxPatchPipeline().velocity_to_strain_rate(step_multiple=0).compile()(
+            strain_patch
+        )
+    with pytest.raises(ParameterError, match="even"):
+        JaxPatchPipeline().velocity_to_strain_rate(step_multiple=3).compile()(
+            strain_patch
+        )
+    with pytest.raises(ParameterError, match="positive"):
+        JaxPatchPipeline().velocity_to_strain_rate_edgeless(step_multiple=0).compile()(
+            strain_patch
+        )
+    # Clear the gauge length rather than trusting the example patch not to
+    # have one. It carries `gauge_length = "N."` on DASCore's dev branch,
+    # which is neither absent nor a length -- see DASDAE/dascore#1078.
+    with pytest.raises(ParameterError, match="Gauge length"):
+        JaxPatchPipeline().radians_to_strain().compile()(
+            strain_patch.update_attrs(gauge_length=None)
+        )
diff --git a/tests/operations/test_filter.py b/tests/operations/test_filter.py
new file mode 100644
index 0000000..9a1f454
--- /dev/null
+++ b/tests/operations/test_filter.py
@@ -0,0 +1,263 @@
+"""Parity tests for filter operations."""
+
+from __future__ import annotations
+
+import dascore as dc
+import jax.numpy as jnp
+import numpy as np
+import pytest
+from dascore.exceptions import FilterValueError, ParameterError
+from scipy.signal import wiener
+
+from dasjax import JaxPatchPipeline
+from dasjax.kernels import (
+    design_notch_filter,
+    design_pass_filter_sos,
+    gaussian_filter_kernel,
+    hampel_filter_kernel,
+    is_finite_array,
+    median_filter_kernel,
+    notch_filter_kernel,
+    pass_filter_default_padlen,
+    pass_filter_initial_state,
+    pass_filter_kernel,
+    savgol_coefficients,
+    savgol_filter_kernel,
+    sobel_filter_kernel,
+    wiener_filter_kernel,
+)
+from dasjax.kernels.filters import _iirfilt_rows
+
+from .helpers import assert_compiled_matches_dascore, even_patch
+
+
+CASES = (
+    (
+        "gaussian_filter",
+        (),
+        {"time": 3, "samples": True},
+        lambda p: p.gaussian_filter(time=3, samples=True),
+    ),
+    (
+        "hampel_filter",
+        (),
+        {"time": 3, "samples": True, "threshold": 3.5, "approximate": True},
+        lambda p: p.hampel_filter(
+            time=3, samples=True, threshold=3.5, approximate=True
+        ),
+    ),
+    (
+        "median_filter",
+        (),
+        {"time": 3, "samples": True},
+        lambda p: p.median_filter(time=3, samples=True),
+    ),
+    (
+        "notch_filter",
+        (),
+        {"time": 10.0, "q": 30.0},
+        lambda p: p.notch_filter(time=10.0, q=30.0),
+        even_patch,
+    ),
+    (
+        "pass_filter",
+        (),
+        {"time": (1.0, 10.0), "corners": 4, "zerophase": True},
+        lambda p: p.pass_filter(time=(1.0, 10.0), corners=4, zerophase=True),
+        even_patch,
+    ),
+    (
+        "savgol_filter",
+        (2,),
+        {"time": 5, "samples": True},
+        lambda p: p.savgol_filter(2, time=5, samples=True),
+    ),
+    (
+        "sobel_filter",
+        ("time",),
+        {},
+        lambda p: p.sobel_filter("time"),
+    ),
+)
+
+
+@pytest.mark.parametrize("case", CASES, ids=lambda item: item[0])
+def test_compiled_filter_operation_matches_dascore(case) -> None:
+    """Match compiled filter operations against DASCore baselines."""
+    assert_compiled_matches_dascore(case)
+
+
+def test_filter_kernel_and_design_edges() -> None:
+    """Cover pass-filter validation and lower-level kernel branches."""
+    data = np.sin(np.linspace(0, 1, 20))[None, :]
+    sos = design_pass_filter_sos(100.0, None, 10.0, 2)
+
+    assert is_finite_array(data)
+    assert not is_finite_array([1.0, np.nan])
+    assert design_pass_filter_sos(100.0, 10.0, None, 2).shape[1] == 6
+    assert design_pass_filter_sos(100.0, 5.0, 20.0, 2).shape[1] == 6
+    for args in (
+        (100.0, -1.0, None, 2),
+        (100.0, None, 60.0, 2),
+        (100.0, 20.0, 10.0, 2),
+        (100.0, None, None, 2),
+    ):
+        with pytest.raises(FilterValueError):
+            design_pass_filter_sos(*args)
+
+    zi = pass_filter_initial_state(sos)
+    assert pass_filter_default_padlen(sos) > 0
+    assert (
+        np.asarray(pass_filter_kernel(data, sos, axis=1, zi=zi, zerophase=False)).shape
+        == data.shape
+    )
+    assert (
+        np.asarray(pass_filter_kernel(data, sos, axis=1, zi=zi, padlen=0)).shape
+        == data.shape
+    )
+    assert (
+        np.asarray(pass_filter_kernel(data, sos, axis=1, zerophase=False)).shape
+        == data.shape
+    )
+    with pytest.raises(ValueError, match="requires zi"):
+        pass_filter_kernel(data, jnp.asarray(sos), axis=1, zi=None)
+    with pytest.raises(ValueError, match="greater than padlen"):
+        pass_filter_kernel(data[:, :2], sos, axis=1, zi=zi, padlen=3)
+
+    patch = even_patch(dc.get_example_patch())
+    with pytest.raises(ParameterError, match="greater than zero"):
+        JaxPatchPipeline().hampel_filter(time=3, samples=True, threshold=0).compile()(
+            patch
+        )
+
+
+def test_jax_filter_kernel_edge_modes_and_validation() -> None:
+    """Cover JAX-native filter modes and validation paths."""
+    data = np.arange(12.0).reshape(3, 4)
+
+    assert (
+        np.asarray(gaussian_filter_kernel(data, sigma=(), axes=())).shape == data.shape
+    )
+    assert (
+        np.asarray(
+            gaussian_filter_kernel(data, sigma=(-1.0,), axes=(1,), truncate=4.0)
+        ).shape
+        == data.shape
+    )
+    assert (
+        np.asarray(
+            gaussian_filter_kernel(data, sigma=(0.1,), axes=(1,), truncate=0.1)
+        ).shape
+        == data.shape
+    )
+    for mode in ("nearest", "constant", "wrap", "mirror"):
+        assert (
+            np.asarray(
+                gaussian_filter_kernel(data, sigma=(1.0,), axes=(1,), mode=mode)
+            ).shape
+            == data.shape
+        )
+    with pytest.raises(ValueError, match="Unsupported gaussian_filter mode"):
+        gaussian_filter_kernel(data, sigma=(1.0,), axes=(1,), mode="bad")
+
+    assert np.asarray(median_filter_kernel(data, size=(1, 1))).shape == data.shape
+    for mode in ("grid-constant", "grid-wrap", "mirror"):
+        assert np.asarray(median_filter_kernel(data, size=(1, 3), mode=mode)).shape == (
+            data.shape
+        )
+    with pytest.raises(ValueError, match="Unsupported filter mode"):
+        median_filter_kernel(data, size=(1, 3), mode="bad")
+
+    assert np.allclose(
+        np.asarray(wiener_filter_kernel(data, size=(1, 3), noise=0.1)),
+        wiener(data, mysize=(1, 3), noise=0.1),
+        equal_nan=True,
+    )
+    assert np.asarray(sobel_filter_kernel(data, axis=1, mode="nearest")).shape == (
+        data.shape
+    )
+
+
+def test_savgol_and_notch_kernel_edges() -> None:
+    """Cover Savitzky-Golay and notch kernel edge branches."""
+    data = np.arange(12.0).reshape(3, 4)
+    coeff, left, right = savgol_coefficients(3, 1)
+
+    assert (
+        np.asarray(
+            savgol_filter_kernel(
+                data,
+                size=(1, 3),
+                axes=(1,),
+                coeffs=(coeff,),
+                left_coeffs=(left,),
+                right_coeffs=(right,),
+                mode="nearest",
+            )
+        ).shape
+        == data.shape
+    )
+    with pytest.raises(ValueError, match="window_length"):
+        savgol_filter_kernel(
+            data[:, :2],
+            size=(1, 3),
+            axes=(1,),
+            coeffs=(coeff,),
+            left_coeffs=(left,),
+            right_coeffs=(right,),
+        )
+
+    with pytest.raises(FilterValueError):
+        design_notch_filter(100.0, 60.0, 30.0)
+    b, a, zi, padlen = design_notch_filter(100.0, 10.0, 30.0)
+    assert np.asarray(notch_filter_kernel(data, b, a, zi, padlen=0, axis=1)).shape == (
+        data.shape
+    )
+    with pytest.raises(ValueError, match="greater than padlen"):
+        notch_filter_kernel(data[:, :2], b, a, zi, padlen=padlen, axis=1)
+
+    filtered, states = _iirfilt_rows(
+        jnp.asarray(data[:1]),
+        jnp.asarray(b),
+        jnp.asarray(a),
+    )
+    assert filtered.shape == data[:1].shape
+    assert states.shape == (1, len(b) - 1)
+
+
+def test_hampel_integer_and_exact_rejection_paths() -> None:
+    """Cover Hampel integer round-trip and exact-mode rejection."""
+    data = np.asarray([[1, 100, 1, 1, 1]], dtype=np.int32)
+
+    native = np.asarray(hampel_filter_kernel(data, size=(1, 3), threshold=1.0))
+    approx = np.asarray(
+        hampel_filter_kernel(
+            data.astype(float), size=(1, 3), threshold=1.0, approximate=True
+        )
+    )
+
+    assert native.dtype == data.dtype
+    assert approx.shape == data.shape
+    with pytest.raises(NotImplementedError, match="pure JAX"):
+        hampel_filter_kernel(
+            data.astype(float), size=(1, 3), threshold=1.0, approximate=False
+        )
+    with pytest.raises(NotImplementedError, match="pure JAX"):
+        JaxPatchPipeline().hampel_filter(
+            time=3, samples=True, approximate=False
+        ).compile()
+
+
+def test_filter_operation_validation_edges() -> None:
+    """Cover operation-level validation branches."""
+    patch = even_patch(dc.get_example_patch())
+
+    with pytest.raises(FilterValueError, match="dim parameter"):
+        JaxPatchPipeline().sobel_filter(1).compile()(patch)
+    with pytest.raises(ParameterError, match="wiener_filter"):
+        JaxPatchPipeline().wiener_filter().compile()(patch)
+    with pytest.raises(ParameterError, match="sorted length 4"):
+        JaxPatchPipeline().slope_filter([1.0, 3.0, 2.0, 4.0]).compile()(patch)
+
+    out = JaxPatchPipeline().notch_filter(time=10.0 * dc.get_unit("Hz"), q=30.0)
+    assert out.compile()(patch).shape == patch.shape
diff --git a/tests/operations/test_fourier.py b/tests/operations/test_fourier.py
new file mode 100644
index 0000000..addca62
--- /dev/null
+++ b/tests/operations/test_fourier.py
@@ -0,0 +1,59 @@
+"""Parity tests for Fourier operations."""
+
+from __future__ import annotations
+
+import dascore as dc
+import numpy as np
+import pytest
+
+from dasjax import JaxPatchPipeline
+
+from .helpers import assert_compiled_matches_dascore, assert_patch_close, fourier_patch
+
+
+CASES = (
+    ("dft", (), {"dim": "time", "real": True}, lambda p: p.dft(dim="time", real=True)),
+    ("idft", (), {}, lambda p: p.idft(), fourier_patch),
+    (
+        "correlate_shift",
+        ("time",),
+        {},
+        lambda p: p.correlate_shift("time"),
+    ),
+)
+
+
+@pytest.mark.parametrize("case", CASES, ids=lambda item: item[0])
+def test_compiled_fourier_operation_matches_dascore(case) -> None:
+    """Match compiled Fourier operations against DASCore baselines."""
+    assert_compiled_matches_dascore(case)
+
+
+def test_fourier_complex_paths() -> None:
+    """Cover complex DFT and IDFT kernel branches."""
+    patch = dc.get_example_patch()
+    complex_patch = patch.update(data=patch.data + 1j * patch.data)
+    transformed = (
+        JaxPatchPipeline().dft(dim="time", real=False).compile()(complex_patch)
+    )
+    expected = complex_patch.dft(dim="time", real=False)
+    assert_patch_close(transformed, expected)
+
+    restored = JaxPatchPipeline().idft().compile()(transformed)
+    assert_patch_close(restored, expected.idft())
+
+    odd = patch.select(time=(..., patch.get_coord("time").values[-2]))
+    padded = JaxPatchPipeline().dft(dim="time", real=True).compile()(odd)
+    assert_patch_close(padded, odd.dft(dim="time", real=True))
+
+
+def test_fourier_preserves_float32_precision() -> None:
+    """Do not promote float32 Fourier data through float64 scale factors."""
+    patch = dc.get_example_patch()
+    patch = patch.update(data=np.asarray(patch.data, dtype=np.float32))
+
+    transformed = JaxPatchPipeline().dft(dim="time", real=True).compile()(patch)
+    restored = JaxPatchPipeline().idft().compile()(transformed)
+
+    assert transformed.data.dtype == np.dtype("complex64")
+    assert restored.data.dtype == np.dtype("float32")
diff --git a/tests/operations/test_hilbert.py b/tests/operations/test_hilbert.py
new file mode 100644
index 0000000..38ad5fe
--- /dev/null
+++ b/tests/operations/test_hilbert.py
@@ -0,0 +1,72 @@
+"""Parity tests for Hilbert operations."""
+
+from __future__ import annotations
+
+import dascore as dc
+import numpy as np
+import pytest
+
+from dasjax import JaxPatchPipeline
+from dasjax.kernels.spectral import _analytic_multiplier
+
+from .helpers import assert_compiled_matches_dascore, even_patch
+
+
+CASES = (
+    ("hilbert", (), {"dim": "time"}, lambda p: p.hilbert(dim="time"), even_patch),
+    ("envelope", (), {"dim": "time"}, lambda p: p.envelope(dim="time"), even_patch),
+)
+
+
+@pytest.mark.parametrize("case", CASES, ids=lambda item: item[0])
+def test_compiled_hilbert_operation_matches_dascore(case) -> None:
+    """Match compiled Hilbert operations against DASCore baselines."""
+    assert_compiled_matches_dascore(case)
+
+
+def test_hilbert_even_multiplier_and_error() -> None:
+    """Cover even analytic multiplier and uneven-coordinate Hilbert errors."""
+    assert _analytic_multiplier(4, "complex128").tolist() == [1, 2, 1, 0]
+
+    patch = dc.get_example_patch()
+    coord = patch.get_coord("time").values.astype("datetime64[ns]")
+    coord[1000:] += np.timedelta64(1, "ms")
+    uneven = patch.update(
+        coords={
+            "distance": patch.get_coord("distance").values,
+            "time": coord,
+        }
+    )
+    with pytest.raises(dc.exceptions.CoordError):
+        JaxPatchPipeline().hilbert(dim="time").compile()(uneven)
+
+
+def test_phase_weighted_stack_infers_transform_dim_and_errors() -> None:
+    """Cover transform-dimension inference and uneven-coordinate validation."""
+    patch = even_patch(dc.get_example_patch())
+
+    assert np.allclose(
+        JaxPatchPipeline().phase_weighted_stack("distance").compile()(patch).data,
+        patch.phase_weighted_stack("distance").data,
+        rtol=1e-5,
+        atol=1e-6,
+    )
+
+    coord = patch.get_coord("time").values.astype("datetime64[ns]")
+    coord[1000:] += np.timedelta64(1, "ms")
+    uneven = patch.update(
+        coords={
+            "distance": patch.get_coord("distance").values,
+            "time": coord,
+        }
+    )
+    with pytest.raises(dc.exceptions.CoordError):
+        JaxPatchPipeline().phase_weighted_stack("distance").compile()(uneven)
+
+    patch_3d = dc.Patch(
+        data=np.ones((2, 3, 4)),
+        coords={"x": np.arange(2), "y": np.arange(3), "z": np.arange(4)},
+        dims=("x", "y", "z"),
+    )
+    with pytest.raises(dc.exceptions.ParameterError, match="transform_dim"):
+        JaxPatchPipeline().phase_weighted_stack("x").compile()(patch_3d)
diff --git a/tests/operations/test_integrate.py b/tests/operations/test_integrate.py
new file mode 100644
index 0000000..ffea78f
--- /dev/null
+++ b/tests/operations/test_integrate.py
@@ -0,0 +1,40 @@
+"""Parity tests for integrate operations."""
+
+from __future__ import annotations
+
+import dascore as dc
+import numpy as np
+import pytest
+
+from dasjax import JaxPatchPipeline
+from dasjax.kernels import integrate_kernel
+
+from .helpers import assert_compiled_matches_dascore, assert_patch_close
+
+
+CASES = (("integrate", (), {"dim": "time"}, lambda p: p.integrate(dim="time")),)
+
+
+@pytest.mark.parametrize("case", CASES, ids=lambda item: item[0])
+def test_compiled_integrate_operation_matches_dascore(case) -> None:
+    """Match compiled integrate operations against DASCore baselines."""
+    assert_compiled_matches_dascore(case)
+
+
+def test_integrate_definite_path() -> None:
+    """Cover definite integration."""
+    patch = dc.get_example_patch()
+    pipeline = JaxPatchPipeline().integrate(dim="time", definite=True)
+
+    assert_patch_close(
+        pipeline.compile()(patch),
+        patch.integrate(dim="time", definite=True),
+    )
+
+
+def test_integrate_vector_spacing_kernel_path() -> None:
+    """Cover vector-spacing integration kernel branches."""
+    out = np.asarray(
+        integrate_kernel(np.arange(5.0), axis=0, dx_or_spacing=np.arange(5.0) ** 2)
+    )
+    assert out.shape == (5,)
diff --git a/tests/operations/test_numeric.py b/tests/operations/test_numeric.py
new file mode 100644
index 0000000..0f5c47e
--- /dev/null
+++ b/tests/operations/test_numeric.py
@@ -0,0 +1,128 @@
+"""Parity tests for additional numeric patch operations."""
+
+from __future__ import annotations
+
+import dascore as dc
+import numpy as np
+import pytest
+
+from dasjax import JaxPatchPipeline
+
+from .helpers import assert_patch_close
+
+
+ELEMENTWISE_CASES = (
+    ("subtract", (1.5,), {}, lambda p: p.subtract(1.5)),
+    ("multiply", (2.0,), {}, lambda p: p.multiply(2.0)),
+    ("divide", (2.0,), {}, lambda p: p.divide(2.0)),
+    ("maximum", (0.0,), {}, lambda p: p.maximum(0.0)),
+    ("minimum", (0.0,), {}, lambda p: p.minimum(0.0)),
+    ("exp", (), {}, lambda p: p.exp()),
+    ("log", (), {}, lambda p: p.log()),
+    ("log10", (), {}, lambda p: p.log10()),
+    ("log2", (), {}, lambda p: p.log2()),
+)
+
+
+@pytest.mark.parametrize("name,args,kwargs,baseline", ELEMENTWISE_CASES)
+def test_compiled_elementwise_numeric_operations_match_dascore(
+    name,
+    args,
+    kwargs,
+    baseline,
+) -> None:
+    """Match compiled elementwise numeric operations against DASCore."""
+    patch = dc.get_example_patch()
+    positive = patch.update(data=np.asarray(patch.data) + 1.0)
+    pipeline = getattr(JaxPatchPipeline(), name)(*args, **kwargs)
+
+    assert_patch_close(pipeline.compile()(positive), baseline(positive))
+
+
+def test_compiled_null_and_boolean_numeric_operations_match_dascore() -> None:
+    """Cover fill/mask numeric methods with NaN and infinite values."""
+    base = dc.get_example_patch()
+    data = np.asarray(base.data).copy()
+    data[0, :3] = [0.0, np.nan, np.inf]
+    patch = base.update(data=data)
+    cond = np.ones(patch.shape, dtype=bool)
+    cond[0, 1] = False
+
+    cases = (
+        (JaxPatchPipeline().fillna(-1.0), patch.fillna(-1.0)),
+        (JaxPatchPipeline().is_finite(), patch.is_finite()),
+        (JaxPatchPipeline().isinf(), patch.isinf()),
+        (JaxPatchPipeline().isnan(), patch.isnan()),
+        (
+            JaxPatchPipeline().where(cond, other=-2.0),
+            patch.where(cond, other=-2.0),
+        ),
+    )
+    for pipeline, expected in cases:
+        assert_patch_close(pipeline.compile()(patch), expected)
+
+
+@pytest.mark.parametrize(
+    "name",
+    ["all", "any", "max", "mean", "median", "min", "std", "sum"],
+)
+def test_compiled_reductions_match_dascore(name: str) -> None:
+    """Match named reductions along a dimension."""
+    patch = dc.get_example_patch()
+    if name in {"all", "any"}:
+        patch = patch > 0.5
+    pipeline = getattr(JaxPatchPipeline(), name)(dim="time")
+    expected = getattr(patch, name)(dim="time")
+
+    assert_patch_close(pipeline.compile()(patch), expected)
+
+
+def test_compiled_aggregate_and_squeeze_reduction_match_dascore() -> None:
+    """Cover aggregate and squeezed dimension metadata."""
+    patch = dc.get_example_patch()
+
+    assert_patch_close(
+        JaxPatchPipeline().aggregate(dim="time", method="mean").compile()(patch),
+        patch.aggregate(dim="time", method="mean"),
+    )
+    assert_patch_close(
+        JaxPatchPipeline().sum(dim="time", dim_reduce="squeeze").compile()(patch),
+        patch.sum(dim="time", dim_reduce="squeeze"),
+    )
+
+
+def test_compiled_callback_numeric_transforms_match_dascore() -> None:
+    """Cover heavier numeric transforms which delegate to DASCore callbacks."""
+    patch = dc.get_example_patch()
+    interp_coord = patch.get_coord("time").values[::4]
+    cases = (
+        (
+            JaxPatchPipeline().correlate(distance=10, samples=True),
+            patch.correlate(distance=10, samples=True),
+        ),
+        (
+            JaxPatchPipeline().decimate(time=2, filter_type=None),
+            patch.decimate(time=2, filter_type=None),
+        ),
+        (
+            JaxPatchPipeline().interpolate(time=interp_coord),
+            patch.interpolate(time=interp_coord),
+        ),
+        (
+            JaxPatchPipeline().resample(time=100, samples=True),
+            patch.resample(time=100, samples=True),
+        ),
+        (
+            JaxPatchPipeline().stft(time=64, samples=True, overlap=32),
+            patch.stft(time=64, samples=True, overlap=32),
+        ),
+    )
+    for pipeline, expected in cases:
+        assert_patch_close(pipeline.compile()(patch), expected)
+
+
+def test_compiled_istft_matches_dascore() -> None:
+    """Cover inverse short-time Fourier transform callback."""
+    patch = dc.get_example_patch().stft(time=64, samples=True, overlap=32)
+
+    assert_patch_close(JaxPatchPipeline().istft().compile()(patch), patch.istft())
diff --git a/tests/operations/test_spectro.py b/tests/operations/test_spectro.py
new file mode 100644
index 0000000..552d19d
--- /dev/null
+++ b/tests/operations/test_spectro.py
@@ -0,0 +1,89 @@
+"""Parity tests for spectral operations."""
+
+from __future__ import annotations
+
+import dascore as dc
+import jax.numpy as jnp
+import numpy as np
+import pytest
+
+from dasjax import JaxPatchPipeline
+from dasjax.kernels.spectral import (
+    _extract_zero_padded_frames,
+    _linear_detrend_frames,
+    banded_stft_kernel,
+)
+
+from .helpers import assert_compiled_matches_dascore, assert_patch_close, fbe_baseline
+
+
+CASES = (
+    (
+        "fbe",
+        (),
+        {"time": 64, "samples": True, "overlap": 32, "fmin": 2.0, "fmax": 10.0},
+        fbe_baseline,
+        lambda p: dc.get_example_patch("chirp"),
+    ),
+)
+
+
+@pytest.mark.parametrize("case", CASES, ids=lambda item: item[0])
+def test_compiled_spectral_operation_matches_dascore(case) -> None:
+    """Match compiled spectral operations against DASCore baselines."""
+    assert_compiled_matches_dascore(case)
+
+
+def test_banded_stft_edges() -> None:
+    """Cover STFT detrending, NaN frame handling, and one-sample frame helper."""
+    data = np.arange(8.0)[None, :]
+    data[0, 0] = np.nan
+    window = np.hanning(4)
+    frame_starts = np.asarray([-1, 1, 6])
+    out = np.asarray(
+        banded_stft_kernel(
+            data,
+            axis=1,
+            window=window,
+            frame_starts=frame_starts,
+            selected_bins=np.asarray([0, 1]),
+            sample_step=0.1,
+            detrend=True,
+        )
+    )
+
+    assert out.shape == (1, 3)
+    assert out[0, 0] == 0.0
+    assert np.array_equal(
+        np.asarray(_linear_detrend_frames(jnp.ones((1, 1)))),
+        np.ones((1, 1)),
+    )
+    frames = np.asarray(
+        _extract_zero_padded_frames(jnp.asarray([[1.0, 2.0]]), jnp.asarray([-1, 1]), 2)
+    )
+    assert frames.tolist() == [[[0.0, 1.0], [2.0, 0.0]]]
+
+
+def test_fbe_detrend_and_nan_paths_match_dascore() -> None:
+    """Cover FBE detrending and non-finite frame handling from the operation layer."""
+    patch = dc.get_example_patch("chirp")
+    pipeline = JaxPatchPipeline().fbe(
+        time=64,
+        samples=True,
+        overlap=32,
+        fmin=2.0,
+        fmax=10.0,
+        detrend=True,
+    )
+
+    expected = patch.stft(
+        time=64,
+        samples=True,
+        overlap=32,
+        detrend=True,
+    ).abs()
+    ft_dim = next(dim for dim in expected.dims if dim.startswith("ft_"))
+    expected = expected.select(**{ft_dim: (2.0, 10.0)})
+    expected = expected.sum(dim=ft_dim, dim_reduce="squeeze")
+
+    assert_patch_close(pipeline.compile()(patch), expected)
diff --git a/tests/operations/test_taper.py b/tests/operations/test_taper.py
new file mode 100644
index 0000000..1cc4665
--- /dev/null
+++ b/tests/operations/test_taper.py
@@ -0,0 +1,65 @@
+"""Parity tests for taper operations."""
+
+from __future__ import annotations
+
+import dascore as dc
+import pytest
+from dascore.exceptions import ParameterError
+
+from dasjax import JaxPatchPipeline
+from dasjax.operations.taper import _taper_coord_inds
+
+from .helpers import assert_compiled_matches_dascore, assert_patch_close
+
+
+CASES = (
+    (
+        "taper",
+        (),
+        {"time": 0.05, "window_type": "hann"},
+        lambda p: p.taper(time=0.05, window_type="hann"),
+    ),
+    (
+        "taper_range",
+        (),
+        {"time": (10, 20), "samples": True, "window_type": "hann"},
+        lambda p: p.taper_range(time=(10, 20), samples=True, window_type="hann"),
+    ),
+)
+
+
+@pytest.mark.parametrize("case", CASES, ids=lambda item: item[0])
+def test_compiled_taper_operation_matches_dascore(case) -> None:
+    """Match compiled taper operations against DASCore baselines."""
+    assert_compiled_matches_dascore(case)
+
+
+def test_taper_range_edges_and_errors() -> None:
+    """Cover nested ranges, invert mode, and invalid taper values."""
+    patch = dc.get_example_patch()
+    pipeline = JaxPatchPipeline().taper_range(
+        time=((10, 20), (30, 40)),
+        samples=True,
+        invert=True,
+        window_type="hann",
+    )
+    expected = patch.taper_range(
+        time=((10, 20), (30, 40)),
+        samples=True,
+        invert=True,
+        window_type="hann",
+    )
+
+    assert_patch_close(pipeline.compile()(patch), expected)
+
+    with pytest.raises(ParameterError, match="Cannot use"):
+        JaxPatchPipeline().taper_range(time=(None, 10), samples=True).compile()(patch)
+    with pytest.raises(ParameterError, match="len 2 or 4"):
+        JaxPatchPipeline().taper_range(time=(1, 2, 3), samples=True).compile()(patch)
+    with pytest.raises(ParameterError, match="len 2 or 4"):
+        _taper_coord_inds(patch.get_coord("time"), 1, False, True)
+    with pytest.raises(ParameterError, match="overlap"):
+        JaxPatchPipeline().taper(time=(0.6, 0.6)).compile()(patch)
+
+    coord = patch.get_coord("time")
+    assert _taper_coord_inds(coord, (None, 2, 4, ...), False, True)[0][0] == 0
diff --git a/tests/operations/test_whiten.py b/tests/operations/test_whiten.py
new file mode 100644
index 0000000..3e90825
--- /dev/null
+++ b/tests/operations/test_whiten.py
@@ -0,0 +1,49 @@
+"""Parity tests for whiten operations."""
+
+from __future__ import annotations
+
+import dascore as dc
+import numpy as np
+import pytest
+
+from dasjax import JaxPatchPipeline
+from dasjax.kernels import whiten_kernel
+
+from .helpers import assert_compiled_matches_dascore, assert_patch_close, even_patch
+
+
+CASES = (("whiten", (), {"time": None}, lambda p: p.whiten(time=None), even_patch),)
+
+
+@pytest.mark.parametrize("case", CASES, ids=lambda item: item[0])
+def test_compiled_whiten_operation_matches_dascore(case) -> None:
+    """Match compiled whiten operations against DASCore baselines."""
+    assert_compiled_matches_dascore(case)
+
+
+def test_whiten_kernel_and_operation_smooth_paths() -> None:
+    """Cover direct whitening branches and operation smooth-size binding."""
+    data = np.sin(np.linspace(0, 2 * np.pi, 16))[None, :]
+    complex_data = data.astype(np.complex128) + 1j * data.astype(np.complex128)
+    weight = np.linspace(1.0, 2.0, 9)
+
+    assert np.asarray(whiten_kernel(data, axis=1)).shape == data.shape
+    assert (
+        np.asarray(
+            whiten_kernel(
+                data, axis=1, window_len=3, water_level=0.1, freq_weight=weight
+            )
+        ).shape
+        == data.shape
+    )
+    assert (
+        np.asarray(whiten_kernel(complex_data, axis=1, window_len=1)).shape
+        == data.shape
+    )
+
+    patch = dc.get_example_patch()
+    pipeline = JaxPatchPipeline().whiten(time=None, smooth_size=1.0, water_level=0.1)
+    assert_patch_close(
+        pipeline.compile()(patch),
+        patch.whiten(time=None, smooth_size=1.0, water_level=0.1),
+    )
diff --git a/tests/test_benchmark_cli.py b/tests/test_benchmark_cli.py
new file mode 100644
index 0000000..8bb9874
--- /dev/null
+++ b/tests/test_benchmark_cli.py
@@ -0,0 +1,351 @@
+"""Tests for the dasjax benchmark CLI helpers."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from types import SimpleNamespace
+from pathlib import Path
+
+import pytest
+
+from dasjax.benchmark_cli import (
+    _benchmark_case,
+    _benchmark_category,
+    _benchmark_engine,
+    _benchmark_group,
+    _case_label,
+    _format_ms,
+    _format_speedup,
+    _mean_seconds,
+    _version,
+    build_parser,
+    build_pytest_command,
+    docs_command,
+    load_json,
+    main,
+    normalize_command,
+    normalize_benchmark_json,
+    render_benchmark_docs,
+    render_benchmark_table_page,
+    refresh_command,
+    run_benchmarks,
+    write_json,
+)
+
+
+def test_build_pytest_command_with_filters() -> None:
+    """Build a filtered pytest-benchmark command."""
+    benchmark_file = Path("benchmarks/test_pipeline_benchmarks.py")
+    output = Path(".benchmarks/current.json")
+    args = argparse.Namespace(
+        benchmark_file=benchmark_file,
+        output=output,
+        benchmark=["scale_fbe"],
+        case=["medium-f64"],
+        pytest_arg=["--benchmark-min-rounds=1"],
+    )
+
+    command = build_pytest_command(args)
+
+    assert command[:3] == [sys.executable, "-m", "pytest"]
+    # Interpolate the paths rather than spelling them out: Path renders a
+    # backslash separator on Windows, and a literal here fails there.
+    assert command[3] == str(benchmark_file)
+    assert f"--benchmark-json={output}" in command
+    assert command[command.index("-k") + 1] == "(scale_fbe) and (medium-f64)"
+    assert command[-1] == "--benchmark-min-rounds=1"
+
+
+def test_benchmark_parsing_fallbacks() -> None:
+    """Cover helper fallbacks used for raw pytest-benchmark data."""
+    assert _version("package-that-should-not-exist-for-dasjax-tests") == "unknown"
+    assert _benchmark_group({"name": "test_dasjax_compiled_operation_add[small]"}) == (
+        "operation_add"
+    )
+    assert _benchmark_group({"name": "test_custom_case"}) == "custom_case"
+    assert _benchmark_engine({"name": "unmatched"}) is None
+    assert _case_label("custom") == "custom"
+    assert _case_label(((3, 5), "float32")) == "3x5-f32"
+    assert _case_label(("bad", "float32")) == "('bad', 'float32')"
+    assert _benchmark_case({"name": "bench[medium-f32]"}) == "medium-f32"
+    assert _benchmark_case({"name": "bench"}) == "default"
+    assert _mean_seconds({"stats": {}}) is None
+    assert _format_ms(None) == "n/a"
+    assert _format_speedup(float("nan")) == "n/a"
+    assert _benchmark_category("operation_add") == "Method"
+    assert _benchmark_category("scale_add") == "Pipeline"
+
+
+def test_normalize_benchmark_json_pairs_dasjax_and_dascore() -> None:
+    """Normalize raw pytest-benchmark JSON into speedup rows."""
+    raw = {
+        "benchmarks": [
+            {
+                "name": "test_dasjax_compiled_scale_fbe[medium-f64]",
+                "group": "scale_fbe",
+                "params": {"example_patch": [[600, 4000], "float64"]},
+                "stats": {"mean": 0.25},
+            },
+            {
+                "name": "test_dascore_scale_fbe[medium-f64]",
+                "group": "scale_fbe",
+                "params": {"example_patch": [[600, 4000], "float64"]},
+                "stats": {"mean": 1.0},
+            },
+        ]
+    }
+
+    snapshot = normalize_benchmark_json(raw, command="pytest benchmarks", source="test")
+
+    assert snapshot["source"] == "test"
+    assert snapshot["rows"] == [
+        {
+            "group": "scale_fbe",
+            "case": "medium-f64",
+            "dascore_mean_s": 1.0,
+            "dasjax_mean_s": 0.25,
+            "speedup": 4.0,
+        }
+    ]
+
+
+def test_normalize_skips_unpaired_or_unusable_benchmarks() -> None:
+    """Ignore rows without a recognized engine or mean value."""
+    raw = {
+        "benchmarks": [
+            {"name": "test_unknown", "group": "unknown", "stats": {"mean": 1.0}},
+            {"name": "test_dasjax_compiled_add", "group": "add", "stats": {}},
+            {
+                "name": "test_dascore_add",
+                "group": "add",
+                "params": {"case": "custom"},
+                "stats": {"mean": 2.0},
+            },
+        ]
+    }
+
+    snapshot = normalize_benchmark_json(raw, command="pytest")
+
+    assert snapshot["rows"] == [
+        {
+            "group": "add",
+            "case": "custom",
+            "dascore_mean_s": 2.0,
+            "dasjax_mean_s": None,
+            "speedup": None,
+        }
+    ]
+
+
+def test_json_helpers_round_trip(tmp_path: Path) -> None:
+    """Write and load stable JSON payloads."""
+    path = tmp_path / "nested" / "payload.json"
+    payload = {"b": 2, "a": 1}
+
+    write_json(path, payload)
+
+    assert load_json(path) == payload
+    assert path.read_text(encoding="utf-8").startswith('{\n  "a"')
+
+
+def test_render_benchmark_docs_includes_results_table() -> None:
+    """Render benchmark docs overview from a normalized snapshot."""
+    snapshot = {
+        "generated_at": "2026-04-24T00:00:00+00:00",
+        "source": "test",
+        "command": "pytest benchmarks/test_pipeline_benchmarks.py",
+        "environment": {"python": "3.12", "platform": "linux"},
+        "rows": [
+            {
+                "group": "scale_fbe",
+                "case": "medium-f64",
+                "dascore_mean_s": 1.0,
+                "dasjax_mean_s": 0.25,
+                "speedup": 4.0,
+            }
+        ],
+    }
+
+    text = render_benchmark_docs(snapshot)
+
+    assert "# Benchmarks" in text
+    assert "[1 rows](pipelines.md)" in text
+    assert "[0 rows](methods.md)" in text
+
+
+def test_render_benchmark_table_page_includes_filterable_rows() -> None:
+    """Render a filterable rich table for benchmark rows."""
+    snapshot = {
+        "generated_at": "2026-04-24T00:00:00+00:00",
+        "rows": [],
+    }
+    rows = [
+        {
+            "group": "operation_fbe",
+            "case": "large-f32",
+            "dascore_mean_s": 1.0,
+            "dasjax_mean_s": 0.25,
+            "speedup": 4.0,
+        }
+    ]
+
+    text = render_benchmark_table_page(snapshot, title="Methods", rows=rows)
+
+    assert 'data-benchmark-filter type="search"' in text
+    assert 'data-sort-index="4" data-sort-type="number"' in text
+    assert 'data-sort-value="4"' in text
+    assert "<td><code>fbe</code></td>" in text
+    assert "<td><code>large-f32</code></td>" in text
+    assert "4.00x" in text
+
+
+def test_run_benchmarks_invokes_pytest(monkeypatch, tmp_path: Path) -> None:
+    """Run command creates the output directory and invokes subprocess."""
+    calls = []
+
+    def fake_run(command, check):
+        calls.append((command, check))
+        return SimpleNamespace(returncode=7)
+
+    monkeypatch.setattr("dasjax.benchmark_cli.subprocess.run", fake_run)
+    args = argparse.Namespace(
+        benchmark_file=Path("bench.py"),
+        output=tmp_path / "raw" / "bench.json",
+        benchmark=None,
+        case=None,
+        pytest_arg=[],
+    )
+
+    assert run_benchmarks(args) == 7
+    assert args.output.parent.exists()
+    assert calls[0][1] is False
+    assert str(args.output) in calls[0][0][-1]
+
+
+def test_normalize_and_docs_commands_write_outputs(tmp_path: Path) -> None:
+    """Exercise normalize and docs subcommands without invoking pytest."""
+    raw_path = tmp_path / "raw.json"
+    snapshot_path = tmp_path / "snapshot.json"
+    docs_path = tmp_path / "docs" / "index.md"
+    raw_path.write_text(
+        """
+        {
+          "benchmarks": [
+            {
+              "name": "test_dasjax_compiled_operation_add[case]",
+              "group": "operation_add",
+              "stats": {"mean": 0.5}
+            },
+            {
+              "name": "test_dascore_operation_add[case]",
+              "group": "operation_add",
+              "stats": {"mean": 1.0}
+            }
+          ]
+        }
+        """,
+        encoding="utf-8",
+    )
+
+    normalize_args = argparse.Namespace(
+        input=raw_path,
+        output=snapshot_path,
+        source="unit",
+        command=None,
+    )
+    assert normalize_command(normalize_args) == 0
+
+    docs_args = argparse.Namespace(snapshot=snapshot_path, output=docs_path)
+    assert docs_command(docs_args) == 0
+
+    assert "Benchmarks" in docs_path.read_text(encoding="utf-8")
+    assert (docs_path.parent / "methods.md").exists()
+    assert (docs_path.parent / "pipelines.md").exists()
+
+
+def test_refresh_command_stops_when_benchmark_run_fails(monkeypatch, tmp_path: Path):
+    """Refresh returns early when pytest-benchmark fails."""
+    monkeypatch.setattr("dasjax.benchmark_cli.run_benchmarks", lambda args: 3)
+    args = argparse.Namespace(
+        benchmark_file=Path("bench.py"),
+        raw_output=tmp_path / "raw.json",
+        snapshot=tmp_path / "snapshot.json",
+        docs_output=tmp_path / "docs" / "index.md",
+        source="unit",
+        benchmark=None,
+        case=None,
+        pytest_arg=[],
+    )
+
+    assert refresh_command(args) == 3
+
+
+def test_refresh_command_runs_all_steps(monkeypatch, tmp_path: Path) -> None:
+    """Refresh wires run, normalize, and docs commands together."""
+    calls = []
+
+    def fake_run(args):
+        calls.append(("run", args.output))
+        return 0
+
+    def fake_normalize(args):
+        calls.append(("normalize", args.input, args.output, args.command))
+        return 0
+
+    def fake_docs(args):
+        calls.append(("docs", args.snapshot, args.output))
+        return 0
+
+    monkeypatch.setattr("dasjax.benchmark_cli.run_benchmarks", fake_run)
+    monkeypatch.setattr("dasjax.benchmark_cli.normalize_command", fake_normalize)
+    monkeypatch.setattr("dasjax.benchmark_cli.docs_command", fake_docs)
+    args = argparse.Namespace(
+        benchmark_file=Path("bench.py"),
+        raw_output=tmp_path / "raw.json",
+        snapshot=tmp_path / "snapshot.json",
+        docs_output=tmp_path / "docs" / "index.md",
+        source="unit",
+        benchmark=["add"],
+        case=["medium"],
+        pytest_arg=["--quiet"],
+    )
+
+    assert refresh_command(args) == 0
+    assert [call[0] for call in calls] == ["run", "normalize", "docs"]
+    assert "-k" in calls[1][3]
+
+
+def test_parser_and_main_dispatch(monkeypatch, tmp_path: Path) -> None:
+    """Cover parser construction and main dispatch."""
+    parser = build_parser()
+    args = parser.parse_args(["docs", "--snapshot", str(tmp_path / "s.json")])
+    assert args.snapshot == tmp_path / "s.json"
+
+    def fake_run(args):
+        assert args.benchmark == ["add"]
+        return 4
+
+    monkeypatch.setattr("dasjax.benchmark_cli.run_benchmarks", fake_run)
+
+    assert main(["run", "--benchmark", "add"]) == 4
+
+
+def test_main_defaults_to_refresh(monkeypatch) -> None:
+    """Bare CLI invocation runs the full refresh workflow."""
+    calls = []
+
+    def fake_refresh(args):
+        calls.append(args.command)
+        return 0
+
+    monkeypatch.setattr("dasjax.benchmark_cli.refresh_command", fake_refresh)
+
+    assert main([]) == 0
+    assert calls == ["refresh"]
+
+
+def test_parser_requires_subcommand() -> None:
+    """Argparse exits when no subcommand is supplied."""
+    with pytest.raises(SystemExit):
+        build_parser().parse_args([])
diff --git a/tests/test_core_api.py b/tests/test_core_api.py
new file mode 100644
index 0000000..498278c
--- /dev/null
+++ b/tests/test_core_api.py
@@ -0,0 +1,370 @@
+"""Tests for the class-authored core operation API."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, replace
+from operator import mul
+from types import SimpleNamespace
+from typing import ClassVar
+
+import dascore as dc
+import jax
+import numpy as np
+import pytest
+
+from dasjax import JaxPatchPipeline, PatchBoundary, PatchOperation, PatchPyTree
+from dasjax.core import (
+    _coord_values_match,
+    _encode_leaf,
+    get_patch_operation,
+    list_patch_operations,
+)
+from dasjax.operations.common import get_data_units_from_dims
+
+
+@dataclass(frozen=True)
+class RenameTimeToFtForTest(PatchOperation):
+    """Test operation that statically changes the time dimension name."""
+
+    register = False
+    method_name: ClassVar[str | None] = "rename_time_to_ft_for_test"
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        dims = tuple("ft_time" if dim == "time" else dim for dim in patch_tree.dims)
+        return patch_tree.new(dims=dims)
+
+    def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary:
+        coords = boundary.coords.rename_coord(time="ft_time")
+        coord_names = tuple(
+            "ft_time" if name == "time" else name for name in boundary.coord_names
+        )
+        return boundary.new(coords=coords, coord_names=coord_names)
+
+
+@dataclass(frozen=True)
+class AddBoundAxisForTest(PatchOperation):
+    """Test operation that must bind against the current boundary."""
+
+    register = False
+    method_name: ClassVar[str | None] = "add_bound_axis_for_test"
+    dim: str
+    axis: int | None = None
+
+    def bind(self, boundary: PatchBoundary):
+        return replace(self, axis=boundary.axis(self.dim))
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        assert self.axis is not None
+        return patch_tree.new(data=patch_tree.data + self.axis)
+
+
+@dataclass(frozen=True)
+class ResultRenameTimeToFtForTest(PatchOperation):
+    """Test operation that only knows its boundary after execution."""
+
+    register = False
+    method_name: ClassVar[str | None] = "result_rename_time_to_ft_for_test"
+
+    def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+        dims = tuple("ft_time" if dim == "time" else dim for dim in patch_tree.dims)
+        return patch_tree.new(dims=dims)
+
+    def update_boundary_from_result(
+        self,
+        patch_tree: PatchPyTree,
+        boundary: PatchBoundary,
+    ) -> PatchBoundary:
+        _ = patch_tree
+        coords = boundary.coords.rename_coord(time="ft_time")
+        coord_names = tuple(
+            "ft_time" if name == "time" else name for name in boundary.coord_names
+        )
+        return boundary.new(coords=coords, coord_names=coord_names)
+
+
+def test_patch_pytree_roundtrip_restores_patch() -> None:
+    """Round-trip a DASCore patch through the new PatchPyTree model."""
+    patch = dc.get_example_patch()
+
+    patch_tree, boundary = PatchPyTree.from_patch(patch)
+    out = boundary.to_patch(patch_tree)
+
+    assert out.equals(patch)
+
+
+def test_patch_pytree_flattens_dynamic_coord_values_and_codes() -> None:
+    """Expose ordered coord values and dtype codes while keeping only dims static."""
+    patch = dc.get_example_patch()
+    patch_tree, _ = PatchPyTree.from_patch(patch)
+
+    leaves, tree = jax.tree_util.tree_flatten(patch_tree)
+    out = jax.tree_util.tree_unflatten(tree, leaves)
+    _, aux_data = patch_tree.tree_flatten()
+
+    assert len(leaves) == 1 + 2 * len(patch.coords.coord_map)
+    assert aux_data == {"dims": tuple(patch.dims)}
+    assert out.dims == tuple(patch.dims)
+
+
+def test_patch_pytree_restores_datetime_coords() -> None:
+    """Restore datetime coordinates after dynamic JAX conversion."""
+    patch = dc.get_example_patch()
+
+    patch_tree, boundary = PatchPyTree.from_patch(patch)
+    out = boundary.to_patch(patch_tree)
+
+    assert out.get_coord("time").dtype == patch.get_coord("time").dtype
+    assert np.array_equal(out.get_coord("time").values, patch.get_coord("time").values)
+
+
+def test_coord_values_match_rejects_shape_mismatch() -> None:
+    """Cover coordinate equality shape-mismatch rejection."""
+    assert not _coord_values_match(np.arange(2), np.arange(3))
+
+
+def test_encode_leaf_rejects_unsupported_dtype() -> None:
+    """Reject coordinate dtypes that cannot be represented in JAX patches."""
+    with pytest.raises(TypeError, match="Unsupported coordinate dtype"):
+        _encode_leaf(np.asarray(["x"], dtype=object))
+    with pytest.raises(TypeError, match="Unsupported coordinate dtype"):
+        _encode_leaf(np.asarray([1], dtype=np.uint32))
+
+
+def test_patch_boundary_swaps_dynamic_coord_values() -> None:
+    """Rebuild coords by replacing values while preserving coord metadata."""
+    patch = dc.get_example_patch()
+    patch_tree, boundary = PatchPyTree.from_patch(patch)
+    distance_idx = boundary.coord_names.index("distance")
+    coord_values = list(patch_tree.coord_values)
+    coord_values[distance_idx] = np.asarray(coord_values[distance_idx]) + 1
+
+    out = boundary.to_patch(patch_tree.new(coords=tuple(coord_values)))
+
+    assert np.array_equal(
+        out.get_coord("distance").values,
+        patch.get_coord("distance").values + 1,
+    )
+    assert out.get_coord("distance").units == patch.get_coord("distance").units
+
+
+def test_patch_boundary_exposes_author_metadata_helpers() -> None:
+    """Provide a compact metadata API for operation binding."""
+    patch = dc.get_example_patch()
+    _, boundary = PatchPyTree.from_patch(patch)
+
+    assert boundary.dims == tuple(patch.dims)
+    assert boundary.axis("time") == patch.get_axis("time")
+    assert boundary.coord("time") == patch.get_coord("time")
+    assert boundary.coord_dims("time") == ("time",)
+    assert boundary.coord_index("time") == boundary.coord_names.index("time")
+
+
+def test_patch_pytree_helpers_and_base_hooks() -> None:
+    """Cover direct tree helpers and default operation hook behavior."""
+    patch = dc.get_example_patch()
+    patch_tree, boundary = PatchPyTree.from_patch(patch)
+
+    with pytest.raises(RuntimeError, match="requires PatchBoundary"):
+        patch_tree.to_patch(coerce_numpy=False)
+
+    assert np.array_equal(patch_tree.coord(0), patch_tree.coord_values[0])
+    replaced = patch_tree.replace_coord(0, np.asarray(patch_tree.coord_values[0]) + 1)
+    assert np.array_equal(replaced[0], np.asarray(patch_tree.coord_values[0]) + 1)
+    assert boundary.with_metadata(attrs=patch.attrs).attrs == patch.attrs
+
+    op = PatchOperation()
+    assert op.bind(boundary) is op
+    assert op.kernel(patch_tree) is patch_tree
+    assert op.update_boundary(boundary) is boundary
+    assert op.update_boundary_from_result(patch_tree, boundary) is boundary
+
+
+def test_patch_pytree_new_updates_data_and_ordered_coord_values() -> None:
+    """Mirror Patch.new-style immutable updates for JAX patch trees."""
+    patch = dc.get_example_patch()
+    patch_tree, boundary = PatchPyTree.from_patch(patch)
+    distance_idx = boundary.coord_names.index("distance")
+    coord_values = list(patch_tree.coord_values)
+    coord_values[distance_idx] = np.asarray(coord_values[distance_idx]) + 2
+
+    out_tree = patch_tree.new(data=patch_tree.data + 1, coords=tuple(coord_values))
+    out = boundary.to_patch(out_tree)
+
+    assert np.array_equal(out.data, patch.data + 1)
+    assert np.array_equal(
+        out.get_coord("distance").values,
+        patch.get_coord("distance").values + 2,
+    )
+
+
+def test_operation_subclasses_register_pipeline_names() -> None:
+    """Register class-authored operations by snake-case class name."""
+    assert "scale" in list_patch_operations()
+    assert get_patch_operation("scale").operation_name() == "scale"
+
+
+def test_operation_registration_validation() -> None:
+    """Cover duplicate registration, suffix naming, and unknown lookups."""
+
+    @dataclass(frozen=True)
+    class ExampleOperation(PatchOperation):
+        register = False
+
+    assert ExampleOperation.operation_name() == "example"
+
+    with pytest.raises(ValueError, match="Duplicate"):
+
+        class Scale(PatchOperation):
+            pass
+
+    with pytest.raises(AttributeError, match="Unknown"):
+        get_patch_operation("does_not_exist")
+
+
+def test_unit_helper_handles_missing_and_multiple_units() -> None:
+    """Cover unit helper paths for no units, skipped dims, and multiplication."""
+    patch = dc.get_example_patch()
+    _, boundary = PatchPyTree.from_patch(patch)
+    attrs = boundary.attrs.update(data_units="m")
+    coords = boundary.coords.set_units(time="s")
+    unit_boundary = boundary.new(attrs=attrs, coords=coords)
+
+    assert get_data_units_from_dims(boundary, ("time",), mul) is None
+    assert (
+        get_data_units_from_dims(unit_boundary, ("time", "distance"), mul) is not None
+    )
+
+    fake_boundary = SimpleNamespace(
+        attrs=SimpleNamespace(data_units="m"),
+        coord=lambda name: SimpleNamespace(units=None if name == "x" else "s"),
+    )
+    assert get_data_units_from_dims(fake_boundary, ("x", "time"), mul) is not None
+
+
+def test_compiled_pipeline_uses_class_authored_basic_operations() -> None:
+    """Run a fully ported class-authored chain through JaxPatchPipeline."""
+    patch = dc.get_example_patch()
+    pipeline = JaxPatchPipeline().scale(2.0).add(1.0).clip(-1.0, 1.0)
+
+    out = pipeline.compile()(patch)
+    expected = patch.update(data=np.clip(patch.data * 2.0 + 1.0, -1.0, 1.0))
+
+    assert np.allclose(out.data, expected.data)
+    assert out.coords == expected.coords
+
+
+def test_core_planner_binds_against_static_boundary_updates() -> None:
+    """Bind later ops against planned boundaries before running a JIT segment."""
+    patch = dc.get_example_patch()
+    pipeline = JaxPatchPipeline().dft(dim="time", real=True).normalize("ft_time")
+
+    out = pipeline.compile()(patch)
+
+    assert out.dims == ("distance", "ft_time")
+
+
+def test_core_planner_keeps_static_boundary_updates_in_one_segment() -> None:
+    """Static boundary changes should not force a core segment boundary."""
+    patch = dc.get_example_patch()
+    _, boundary = PatchPyTree.from_patch(patch)
+    operations = (
+        RenameTimeToFtForTest(),
+        AddBoundAxisForTest("ft_time"),
+    )
+
+    segments = JaxPatchPipeline._plan_core_segments(operations, boundary)
+
+    assert len(segments) == 1
+    bound_ops, planned_boundary, needs_result_boundary = segments[0]
+    assert len(bound_ops) == 2
+    assert planned_boundary.dims == ("distance", "ft_time")
+    assert not needs_result_boundary
+    assert bound_ops[1].axis == 1
+
+
+def test_pipeline_plan_reports_core_fused_segments() -> None:
+    """Expose the planned core execution path without running kernels."""
+    patch = dc.get_example_patch()
+    pipeline = JaxPatchPipeline().dft(dim="time", real=True).normalize("ft_time")
+
+    plan = pipeline.plan(patch)
+
+    assert plan.uses_core
+    assert plan.fused_kernel_count == 1
+    assert len(plan.segments) == 1
+    segment = plan.segments[0]
+    assert segment.kind == "core"
+    assert segment.operations == ("dft", "normalize")
+    assert segment.fused
+    assert segment.jitted
+    assert segment.input_dims == ("distance", "time")
+    assert segment.output_dims == ("distance", "ft_time")
+
+
+def test_core_planner_restarts_after_result_boundary_updates() -> None:
+    """Result-dependent boundary changes stop planning until after execution."""
+    patch = dc.get_example_patch()
+    patch_tree, boundary = PatchPyTree.from_patch(patch)
+    op = ResultRenameTimeToFtForTest()
+    bound_ops, planned_boundary, needs_result_boundary, op_index = (
+        JaxPatchPipeline._plan_core_segment((op,), boundary, 0)
+    )
+    out_tree = bound_ops[0].kernel(patch_tree)
+    out_boundary = bound_ops[0].update_boundary_from_result(out_tree, planned_boundary)
+    out = out_boundary.to_patch(out_tree)
+
+    assert out.dims == ("distance", "ft_time")
+    assert needs_result_boundary
+    assert op_index == 1
+
+
+def test_pipeline_plan_reports_unplanned_result_boundary_tail() -> None:
+    """Show where planning must pause for result-dependent metadata."""
+    patch = dc.get_example_patch()
+    _, boundary = PatchPyTree.from_patch(patch)
+
+    segments = JaxPatchPipeline._plan_core_segments(
+        (ResultRenameTimeToFtForTest(), AddBoundAxisForTest("ft_time")),
+        boundary,
+    )
+
+    assert len(segments) == 1
+    assert segments[0][2]
+
+
+def test_pipeline_plan_reports_core_segments_for_all_operations() -> None:
+    """Expose core execution segments for formerly registry-backed operations."""
+    patch = dc.get_example_patch()
+    pipeline = JaxPatchPipeline().detrend("time").normalize("time")
+
+    plan = pipeline.plan(patch)
+
+    assert plan.uses_core
+    assert plan.fused_kernel_count == 1
+    assert len(plan.segments) == 1
+    assert plan.segments[0].kind == "core"
+    assert plan.segments[0].operations == ("detrend", "normalize")
+    assert plan.segments[0].fused
+    assert plan.segments[0].jitted
+
+
+def test_metadata_hook_uses_dascore_native_objects() -> None:
+    """Pass native DASCore attrs and coord manager into metadata hooks."""
+
+    @dataclass(frozen=True)
+    class _MetadataProbe(PatchOperation):
+        register = False
+
+        def update_boundary(self, boundary):
+            assert boundary.attrs.__class__.__name__ == "PatchAttrs"
+            assert hasattr(boundary.coords, "coord_map")
+            return boundary
+
+    patch = dc.get_example_patch()
+    patch_tree, boundary = PatchPyTree.from_patch(patch)
+    metadata_op = _MetadataProbe()
+
+    assert type(metadata_op).overrides("update_boundary")
+    out = metadata_op.update_boundary(boundary).to_patch(metadata_op.kernel(patch_tree))
+
+    assert out.equals(patch)
diff --git a/tests/test_dascore_compat.py b/tests/test_dascore_compat.py
index 29c29b3..b9c5a70 100644
--- a/tests/test_dascore_compat.py
+++ b/tests/test_dascore_compat.py
@@ -14,7 +14,6 @@
 import pytest
 
 from dasjax import JaxPatchPipeline
-from dasjax.operations import get_operation
 
 NORMS = ("l1", "l2", "max", "bit")
 DTYPES = ("float64", "float32", "int64", "int32", "int16", "uint8")
@@ -51,19 +50,17 @@ def null_patch() -> dc.Patch:
 
 
 def _assert_matches_dascore(patch: dc.Patch, norm: str) -> None:
-    """Both dasjax paths must agree with DASCore's own normalize."""
+    """The compiled pipeline must agree with DASCore's own normalize."""
     expected = patch.normalize("many", norm=norm).data
-    eager = get_operation("normalize").patch_impl(patch, dim="many", norm=norm)
     compiled = JaxPatchPipeline().normalize(dim="many", norm=norm).compile()(patch)
-    for name, out in (("eager", eager), ("compiled", compiled)):
-        np.testing.assert_allclose(
-            np.asarray(out.data),
-            np.asarray(expected),
-            rtol=1e-6,
-            atol=1e-8,
-            equal_nan=True,
-            err_msg=f"{name} normalize(norm={norm!r}) disagrees with DASCore",
-        )
+    np.testing.assert_allclose(
+        np.asarray(compiled.data),
+        np.asarray(expected),
+        rtol=1e-6,
+        atol=1e-8,
+        equal_nan=True,
+        err_msg=f"normalize(norm={norm!r}) disagrees with DASCore",
+    )
 
 
 @pytest.mark.parametrize("norm", NORMS)
diff --git a/tests/test_method_equivalence.py b/tests/test_method_equivalence.py
deleted file mode 100644
index 6da6305..0000000
--- a/tests/test_method_equivalence.py
+++ /dev/null
@@ -1,107 +0,0 @@
-"""Compare internal dasjax operations against DASCore baselines."""
-
-from __future__ import annotations
-
-import numpy as np
-import pytest
-
-from dasjax import JaxPatchPipeline, list_operations
-from dasjax.operations import get_operation, iter_operations
-
-
-def _assert_patch_data_close(left, right) -> None:
-    """Assert two patches have numerically close data and identical coords."""
-    assert np.allclose(left.data, right.data, equal_nan=True, rtol=1e-5, atol=1e-6)
-    assert left.coords == right.coords
-
-
-def _assert_same_exception(left_exc: Exception, right_exc: Exception) -> None:
-    """Assert two operations failed in the same way."""
-    assert type(left_exc) is type(right_exc)
-    assert str(left_exc) == str(right_exc)
-
-
-def _iter_operation_cases():
-    """Yield every public operation together with its declared test cases."""
-    for operation in iter_operations():
-        for case in operation.test_cases:
-            yield operation, case
-
-
-@pytest.mark.parametrize("operation_name", list_operations())
-def test_list_operations_matches_registry(operation_name: str) -> None:
-    """Expose every registered operation through list_operations."""
-    assert get_operation(operation_name).name == operation_name
-
-
-@pytest.mark.parametrize(
-    ("operation", "case"),
-    list(_iter_operation_cases()),
-    ids=lambda item: getattr(item, "case_id", getattr(item, "name", repr(item))),
-)
-def test_operation_patch_impl_matches_declared_baseline(
-    example_patch,
-    operation,
-    case,
-) -> None:
-    """Match each eager operation implementation to its declared baseline."""
-    patch = case.prepare_patch(example_patch)
-    args, kwargs = case.resolve_call(patch)
-
-    try:
-        expected = case.baseline(patch, args, kwargs)
-    except Exception as expected_exc:
-        try:
-            operation.patch_impl(patch, *args, **kwargs)
-        except Exception as out_exc:
-            _assert_same_exception(out_exc, expected_exc)
-            return
-        raise AssertionError("Expected internal patch operation to fail like DASCore.")
-
-    out = operation.patch_impl(patch, *args, **kwargs)
-    _assert_patch_data_close(out, expected)
-
-
-@pytest.mark.parametrize(
-    ("operation", "case"),
-    list(_iter_operation_cases()),
-    ids=lambda item: getattr(item, "case_id", getattr(item, "name", repr(item))),
-)
-def test_compiled_pipeline_matches_declared_baseline(
-    example_patch,
-    operation,
-    case,
-) -> None:
-    """Match each compiled pipeline operation to its declared baseline."""
-    patch = case.prepare_patch(example_patch)
-    args, kwargs = case.resolve_call(patch)
-    pipeline = getattr(JaxPatchPipeline(), operation.name)(*args, **kwargs)
-
-    if case.compiled_guard is not None:
-        guarded = case.compiled_guard(patch, args, kwargs)
-        if guarded is not None:
-            error_type, error_message = guarded
-            with pytest.raises(error_type, match=error_message):
-                pipeline.compile()(patch)
-            return
-
-    if case.compiled_error is not None:
-        with pytest.raises(
-            case.compiled_error, match=case.compiled_error_message or ""
-        ):
-            pipeline.compile()(patch)
-        return
-
-    try:
-        baseline = case.compiled_baseline or case.baseline
-        expected = baseline(patch, args, kwargs)
-    except Exception as expected_exc:
-        try:
-            pipeline.compile()(patch)
-        except Exception as out_exc:
-            _assert_same_exception(out_exc, expected_exc)
-            return
-        raise AssertionError("Expected compiled pipeline to fail like DASCore.")
-
-    out = pipeline.compile()(patch)
-    _assert_patch_data_close(out, expected)
diff --git a/tests/test_package.py b/tests/test_package.py
new file mode 100644
index 0000000..3354548
--- /dev/null
+++ b/tests/test_package.py
@@ -0,0 +1,20 @@
+"""Tests for package-level behavior."""
+
+from __future__ import annotations
+
+import importlib
+import importlib.metadata
+
+import dasjax
+
+
+def test_package_version_falls_back_when_metadata_missing(monkeypatch) -> None:
+    """Use the unknown version fallback when package metadata is absent."""
+
+    def _missing_version(name: str) -> str:
+        raise importlib.metadata.PackageNotFoundError(name)
+
+    monkeypatch.setattr(importlib.metadata, "version", _missing_version)
+    module = importlib.reload(dasjax)
+
+    assert module.__version__ == "0+unknown"
diff --git a/tests/test_patch_ops.py b/tests/test_patch_ops.py
deleted file mode 100644
index 45424fe..0000000
--- a/tests/test_patch_ops.py
+++ /dev/null
@@ -1,239 +0,0 @@
-"""Tests for the unified PatchOp compiled execution path."""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-import numpy as np
-import pytest
-
-import dascore as dc
-
-from dasjax import JaxPatchPipeline
-from dasjax.pipeline import _build_segments
-from dasjax.operations import get_operation
-from dasjax.operations.patch_ops import PatchOp, patch_to_state_spec
-
-
-@dataclass(frozen=True)
-class _SelectedAxisOp(PatchOp):
-    dim: str
-
-    def kernel(self, selected_axis):
-        return {"data": np.asarray([selected_axis])}
-
-
-@dataclass(frozen=True)
-class _SelectedCoordOp(PatchOp):
-    dim: str | None = None
-    time: object | None = None
-    distance: object | None = None
-
-    def kernel(self, selected_coord, selected_size, selected_start, selected_stop):
-        return {
-            "data": np.asarray(
-                [
-                    len(np.asarray(selected_coord)),
-                    selected_size,
-                    selected_start,
-                    selected_stop,
-                ]
-            )
-        }
-
-
-@dataclass(frozen=True)
-class _SelectedStepOp(PatchOp):
-    dim: str
-
-    def kernel(self, selected_step):
-        return {"data": np.asarray([selected_step])}
-
-
-def test_scale_patch_op_uses_signature_inference() -> None:
-    """Infer scale inputs directly from the PatchOp kernel signature."""
-    patch = dc.get_example_patch()
-    op = get_operation("scale").patch_op_cls.prepare(patch, 2.0)
-    state, _ = patch_to_state_spec(patch)
-
-    out = op.apply(state)
-
-    assert np.allclose(np.asarray(out.data), patch.data * 2.0)
-    assert out.coords.keys() == state.coords.keys()
-
-
-def test_selected_dim_inference_uses_dim_kwarg() -> None:
-    """Resolve selected bindings from an explicit dim kwarg."""
-    patch = dc.get_example_patch()
-    op = _SelectedAxisOp.prepare(patch, dim="time")
-    state, _ = patch_to_state_spec(patch)
-
-    out = op.apply(state)
-
-    assert np.asarray(out.data).item() == patch.get_axis("time")
-
-
-def test_selected_dim_inference_uses_single_dim_kwarg() -> None:
-    """Resolve selected bindings from a single dim-matching kwarg."""
-    patch = dc.get_example_patch()
-    op = _SelectedCoordOp.prepare(patch, time=(2, 3))
-    state, _ = patch_to_state_spec(patch)
-
-    out = op.apply(state)
-    time_coord = patch.get_coord("time")
-
-    assert np.asarray(out.data)[0] == len(time_coord)
-    assert np.asarray(out.data)[1] == len(time_coord)
-
-
-def test_selected_dim_inference_rejects_missing_selection() -> None:
-    """Reject selected bindings when no dimension can be inferred."""
-    patch = dc.get_example_patch()
-
-    with pytest.raises(ValueError, match="no selected dim"):
-        _SelectedAxisOp.prepare(patch, dim=None)
-
-
-def test_selected_dim_inference_rejects_ambiguous_selection() -> None:
-    """Reject selected bindings when multiple dimensions match the call."""
-    patch = dc.get_example_patch()
-
-    with pytest.raises(ValueError, match="multiple dims"):
-        _SelectedCoordOp.prepare(patch, time=1, distance=1)
-
-
-def test_selected_step_requires_even_sampling() -> None:
-    """Require evenly sampled coordinates for selected_step bindings."""
-    patch = dc.get_example_patch("wacky_dim_coords_patch")
-    dim = next(dim for dim in patch.dims if patch.get_coord(dim).step is None)
-
-    with pytest.raises(ValueError, match="selected_step"):
-        _SelectedStepOp.prepare(patch, dim=dim)
-
-
-def test_flip_patch_op_matches_patch_impl() -> None:
-    """Match the flip PatchOp path to the eager patch implementation."""
-    patch = dc.get_example_patch()
-
-    out = JaxPatchPipeline().flip("time").compile()(patch)
-    expected = get_operation("flip").patch_impl(patch, "time")
-
-    assert np.allclose(out.data, expected.data, equal_nan=True)
-    assert out.coords == expected.coords
-
-
-def test_pad_patch_op_matches_patch_impl() -> None:
-    """Match the pad PatchOp path to the eager patch implementation."""
-    patch = dc.get_example_patch()
-
-    out = JaxPatchPipeline().pad(time=(2, 3), samples=True).compile()(patch)
-    expected = get_operation("pad").patch_impl(patch, time=(2, 3), samples=True)
-
-    assert np.allclose(out.data, expected.data, equal_nan=True)
-    assert out.coords == expected.coords
-
-
-def test_patch_op_segment_chain_matches_eager() -> None:
-    """Match eager behavior for a mixed compiled PatchOp chain."""
-    patch = dc.get_example_patch()
-    pipeline = JaxPatchPipeline().scale(2.0).pad(time=(2, 3), samples=True).flip("time")
-
-    out = pipeline.compile()(patch)
-    expected = get_operation("flip").patch_impl(
-        get_operation("pad").patch_impl(
-            get_operation("scale").patch_impl(patch, 2.0),
-            time=(2, 3),
-            samples=True,
-        ),
-        "time",
-    )
-
-    assert np.allclose(out.data, expected.data, equal_nan=True)
-    assert out.coords == expected.coords
-
-
-def test_patchop_segment_builder_keeps_pad_with_axis_only_followups() -> None:
-    """Keep pad in the same PatchOp segment before simple axis-based ops."""
-    resolved_steps = tuple(
-        (
-            get_operation(step.name),
-            step.args,
-            step.kwargs,
-        )
-        for step in JaxPatchPipeline()
-        .scale(2.0)
-        .pad(time=(2, 3), samples=True)
-        .normalize(dim="time")
-        .steps
-    )
-
-    segments = _build_segments(resolved_steps)
-
-    assert [kind for kind, _ in segments] == ["patchop"]
-    assert [item[0].name for item in segments[0][1]] == ["scale", "pad", "normalize"]
-
-
-def test_detrend_patch_op_matches_patch_impl() -> None:
-    """Match the detrend PatchOp path to the eager patch implementation."""
-    patch = dc.get_example_patch()
-
-    out = JaxPatchPipeline().detrend(dim="time", type="constant").compile()(patch)
-    expected = get_operation("detrend").patch_impl(patch, dim="time", type="constant")
-
-    assert np.allclose(out.data, expected.data, equal_nan=True)
-    assert out.coords == expected.coords
-
-
-def test_standardize_patch_op_matches_patch_impl() -> None:
-    """Match the standardize PatchOp path to the eager patch implementation."""
-    patch = dc.get_example_patch()
-
-    out = JaxPatchPipeline().standardize(dim="time").compile()(patch)
-    expected = get_operation("standardize").patch_impl(patch, dim="time")
-
-    assert np.allclose(out.data, expected.data, equal_nan=True)
-    assert out.coords == expected.coords
-
-
-def test_differentiate_patch_op_matches_patch_impl() -> None:
-    """Match the differentiate PatchOp path to the eager patch implementation."""
-    patch = dc.get_example_patch()
-
-    out = JaxPatchPipeline().differentiate(dim="time", step=2).compile()(patch)
-    expected = get_operation("differentiate").patch_impl(patch, dim="time", step=2)
-
-    assert np.allclose(out.data, expected.data, equal_nan=True, rtol=1e-5, atol=1e-6)
-    assert out.coords == expected.coords
-
-
-def test_integrate_indefinite_patch_op_matches_patch_impl() -> None:
-    """Match indefinite integrate through the unified PatchOp runtime."""
-    patch = dc.get_example_patch()
-
-    out = JaxPatchPipeline().integrate(dim="time", definite=False).compile()(patch)
-    expected = get_operation("integrate").patch_impl(patch, dim="time", definite=False)
-
-    assert np.allclose(out.data, expected.data, equal_nan=True, rtol=1e-5, atol=1e-6)
-    assert out.coords == expected.coords
-
-
-def test_normalize_patch_op_matches_patch_impl() -> None:
-    """Match the normalize PatchOp path to the eager patch implementation."""
-    patch = dc.get_example_patch()
-
-    out = JaxPatchPipeline().normalize(dim="time", norm="l2").compile()(patch)
-    expected = get_operation("normalize").patch_impl(patch, dim="time", norm="l2")
-
-    assert np.allclose(out.data, expected.data, equal_nan=True)
-    assert out.coords == expected.coords
-
-
-def test_roll_patch_op_matches_patch_impl() -> None:
-    """Match the roll PatchOp path to the eager patch implementation."""
-    patch = dc.get_example_patch()
-
-    out = JaxPatchPipeline().roll(time=5, samples=True).compile()(patch)
-    expected = get_operation("roll").patch_impl(patch, time=5, samples=True)
-
-    assert np.allclose(out.data, expected.data, equal_nan=True)
-    assert out.coords == expected.coords
diff --git a/tests/test_pipeline_cache.py b/tests/test_pipeline_cache.py
index f96c95b..83bd9ff 100644
--- a/tests/test_pipeline_cache.py
+++ b/tests/test_pipeline_cache.py
@@ -2,18 +2,21 @@
 
 from __future__ import annotations
 
+from dataclasses import dataclass
+
 import dascore as dc
 import jax
 import numpy as np
 import pytest
 
-from dasjax import JaxPatchPipeline
-from dasjax.operations import get_operation
+from dasjax import JaxPatchPipeline, PatchBoundary, PatchOperation, PatchPyTree
 
 
-def _run_operation(patch, name: str, *args, **kwargs):
-    """Apply one internal operation through DASCore's pipe helper."""
-    return patch.pipe(get_operation(name).patch_impl, *args, **kwargs)
+def _fbe_baseline(patch):
+    out = patch.stft(time=64, samples=True, overlap=32).abs()
+    ft_dim = next(dim for dim in out.dims if dim.startswith("ft_"))
+    out = out.select(**{ft_dim: (2.0, 10.0)})
+    return out.sum(dim=ft_dim, dim_reduce="squeeze")
 
 
 def test_compile_reuses_cached_callable_for_same_pipeline() -> None:
@@ -45,16 +48,6 @@ def test_compile_separates_distinct_pipeline_definitions() -> None:
     assert pipeline_1.compile() is not pipeline_2.compile()
 
 
-def test_compile_separates_assert_no_fallback_flag() -> None:
-    """Separate cache entries when assert_no_fallback changes."""
-    pipeline = JaxPatchPipeline().scale(2.0)
-
-    compiled_default = pipeline.compile()
-    compiled_checked = pipeline.compile(assert_no_fallback=True)
-
-    assert compiled_default is not compiled_checked
-
-
 def test_compile_rejects_device_and_backend_together() -> None:
     """Reject compile calls that pass both device and backend."""
     pipeline = JaxPatchPipeline().scale(2.0)
@@ -63,8 +56,125 @@ def test_compile_rejects_device_and_backend_together() -> None:
         pipeline.compile(device=jax.devices()[0], backend="cpu")
 
 
-def test_assert_no_fallback_passes_for_native_pipeline() -> None:
-    """Allow fallback assertions for fully native compiled pipelines."""
+def test_pipeline_private_freezing_and_plan_edges() -> None:
+    """Cover cache-key freezing for unhashable values and plan tail reporting."""
+    patch = dc.get_example_patch()
+    pipeline = JaxPatchPipeline().scale(np.asarray([2.0])).add({"value": 1.0})
+    key = pipeline._compile_cache_key()
+    set_key = JaxPatchPipeline().add({"a", "b"})._compile_cache_key()
+
+    assert "ndarray" in repr(key)
+    assert "(2.0,)" not in repr(key)
+    assert "value" in repr(key)
+    assert "a" in repr(set_key)
+    assert JaxPatchPipeline().steps == ()
+
+    class PlainOperation:
+        value = []
+
+        @classmethod
+        def operation_name(cls):
+            return "plain"
+
+    from dasjax.pipeline import _operation_key
+
+    assert _operation_key(PlainOperation())[0] == "plain"
+    with pytest.raises(AttributeError, match="Unknown"):
+        JaxPatchPipeline().not_registered
+
+    plan = (
+        JaxPatchPipeline().dft(dim="time", real=True).normalize("ft_time").plan(patch)
+    )
+    assert plan.fused_kernel_count == 1
+
+
+@dataclass(frozen=True)
+class _TailResultBoundary(PatchOperation):
+    register = False
+
+    def update_boundary_from_result(
+        self,
+        patch_tree: PatchPyTree,
+        boundary: PatchBoundary,
+    ) -> PatchBoundary:
+        _ = patch_tree
+        return boundary
+
+
+def test_pipeline_plan_reports_unplanned_tail_from_execution_planner() -> None:
+    """Cover the unplanned tail path in the public execution planner."""
+    patch = dc.get_example_patch()
+    tail_plan = JaxPatchPipeline()._plan_core_execution(
+        patch,
+        (_TailResultBoundary(), _TailResultBoundary()),
+    )
+    assert tail_plan.segments[-1].kind == "unplanned"
+
+
+def test_pipeline_backend_and_result_boundary_compile_paths(monkeypatch) -> None:
+    """Cover backend resolution and result-dependent execution hooks."""
+    patch = dc.get_example_patch()
+
+    with pytest.raises(RuntimeError):
+        JaxPatchPipeline().scale(1.0).compile(backend="not-a-backend")
+    out = JaxPatchPipeline().scale(1.0).compile(backend="cpu")(patch)
+    assert out.equals(patch)
+    monkeypatch.setattr("dasjax.pipeline.jax.local_devices", lambda backend: [])
+    with pytest.raises(ValueError, match="No local JAX devices"):
+        JaxPatchPipeline().scale(1.0).compile(backend="cpu")
+
+    @dataclass(frozen=True)
+    class _ResultBoundaryForCoverage(PatchOperation):
+        register = False
+
+        def update_boundary_from_result(
+            self,
+            patch_tree: PatchPyTree,
+            boundary: PatchBoundary,
+        ) -> PatchBoundary:
+            _ = patch_tree
+            return boundary
+
+    PatchOperation._registry["result_boundary_for_coverage"] = (
+        _ResultBoundaryForCoverage
+    )
+    try:
+        out = JaxPatchPipeline().result_boundary_for_coverage().compile()(patch)
+    finally:
+        PatchOperation._registry.pop("result_boundary_for_coverage")
+    assert out.equals(patch)
+
+
+def test_compiled_pipeline_reuses_bound_plan_for_same_boundary() -> None:
+    """Avoid rebinding operations on repeated calls with the same metadata."""
+    patch = dc.get_example_patch()
+    bind_count = {"value": 0}
+
+    @dataclass(frozen=True)
+    class _CountingBind(PatchOperation):
+        register = False
+
+        def bind(self, boundary: PatchBoundary):
+            bind_count["value"] += 1
+            _ = boundary
+            return self
+
+        def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree:
+            return patch_tree
+
+    PatchOperation._registry["counting_bind_for_cache"] = _CountingBind
+    try:
+        compiled = JaxPatchPipeline().counting_bind_for_cache().compile()
+        compiled(patch)
+        compiled(patch)
+    finally:
+        PatchOperation._registry.pop("counting_bind_for_cache")
+
+    assert bind_count["value"] == 1
+
+
+def test_native_hampel_pipeline_compiles() -> None:
+    """Compile native approximate Hampel filtering."""
     patch = dc.get_example_patch("chirp")
     pipeline = (
         JaxPatchPipeline()
@@ -77,26 +187,54 @@ def test_assert_no_fallback_passes_for_native_pipeline() -> None:
         )
     )
 
-    pipeline.assert_no_fallback(patch)
+    out = pipeline.compile()(patch)
 
+    assert out.shape == patch.shape
 
-def test_assert_no_fallback_rejects_host_callback_pipeline() -> None:
-    """Reject fallback assertions for host-callback-backed pipelines."""
+
+def test_gaussian_filter_pipeline_compiles() -> None:
+    """Compile native Gaussian filtering."""
     patch = dc.get_example_patch("chirp")
-    pipeline = JaxPatchPipeline().gaussian_filter(**{patch.dims[-1]: 3}, samples=True)
+    dim = patch.dims[-1]
+    pipeline = JaxPatchPipeline().gaussian_filter(**{dim: 3}, samples=True)
+
+    out = pipeline.compile()(patch)
 
-    with pytest.raises(AssertionError, match="host fallbacks"):
-        pipeline.assert_no_fallback(patch)
+    assert np.allclose(out.data, patch.gaussian_filter(**{dim: 3}, samples=True).data)
+
+
+def test_exact_hampel_filter_is_not_implemented() -> None:
+    """Reject exact Hampel filtering because it is not implemented in pure JAX."""
+    patch = dc.get_example_patch("chirp")
+
+    with pytest.raises(NotImplementedError, match="pure JAX"):
+        JaxPatchPipeline().hampel_filter(
+            **{patch.dims[-1]: 3},
+            samples=True,
+            approximate=False,
+        ).compile()
 
 
-def test_assert_no_fallback_passes_for_fbe_pipeline() -> None:
-    """Allow fallback assertions for pure-JAX FBE pipelines."""
+def test_whiten_pipeline_compiles() -> None:
+    """Compile native whitening."""
+    patch = dc.get_example_patch("chirp")
+    pipeline = JaxPatchPipeline().dft(dim=patch.dims[-1], real=True).whiten()
+
+    out = pipeline.compile()(patch)
+    expected = patch.dft(dim=patch.dims[-1], real=True).whiten()
+
+    assert np.allclose(out.data, expected.data)
+
+
+def test_fbe_pipeline_compiles() -> None:
+    """Compile native FBE pipelines."""
     patch = dc.get_example_patch("chirp")
     pipeline = JaxPatchPipeline().fbe(
         time=64, samples=True, overlap=32, fmin=2.0, fmax=10.0
     )
-    # fbe uses pure JAX (no host callbacks) — assert_no_fallback should not raise.
-    pipeline.assert_no_fallback(patch)
+    out = pipeline.compile()(patch)
+
+    assert np.allclose(out.data, _fbe_baseline(patch).data)
 
 
 def test_cached_pipeline_callable_still_matches_expected_output() -> None:
@@ -114,20 +252,7 @@ def test_cached_pipeline_callable_still_matches_expected_output() -> None:
 
     compiled = pipeline.compile()
     out = compiled(patch)
-    expected = _run_operation(
-        _run_operation(
-            _run_operation(
-                patch,
-                "scale",
-                2.0,
-            ),
-            "add",
-            1.0,
-        ),
-        "detrend",
-        dim=patch.dims[-1],
-        type="constant",
-    )
+    expected = ((patch * 2.0) + 1.0).detrend(dim=patch.dims[-1], type="constant")
 
     assert out.equals(expected)
 
@@ -141,15 +266,7 @@ def test_compiled_pipeline_with_fbe_matches_eager() -> None:
         .fbe(time=64, samples=True, overlap=32, fmin=2.0, fmax=10.0)
     )
     out = pipeline.compile()(patch)
-    expected = _run_operation(
-        _run_operation(patch, "scale", 2.0),
-        "fbe",
-        time=64,
-        samples=True,
-        overlap=32,
-        fmin=2.0,
-        fmax=10.0,
-    )
+    expected = _fbe_baseline(patch * 2.0)
     assert np.allclose(out.data, expected.data, equal_nan=True, rtol=1e-5, atol=1e-6)
     assert out.coords == expected.coords
 
@@ -164,18 +281,7 @@ def test_compiled_pipeline_with_fbe_in_middle() -> None:
         .abs()
     )
     out = pipeline.compile()(patch)
-    expected = _run_operation(
-        _run_operation(
-            _run_operation(patch, "scale", 2.0),
-            "fbe",
-            time=64,
-            samples=True,
-            overlap=32,
-            fmin=2.0,
-            fmax=10.0,
-        ),
-        "abs",
-    )
+    expected = _fbe_baseline(patch * 2.0).abs()
     assert np.allclose(out.data, expected.data, equal_nan=True, rtol=1e-5, atol=1e-6)
     assert out.coords == expected.coords
 
@@ -188,7 +294,7 @@ def test_compile_accepts_explicit_device() -> None:
     compiled = pipeline.compile(device=jax.devices()[0])
     out = compiled(patch)
 
-    assert out.equals(_run_operation(patch, "scale", 2.0))
+    assert out.equals(patch * 2.0)
 
 
 def test_compile_cache_is_bounded() -> None:
diff --git a/tests/test_pytree.py b/tests/test_pytree.py
deleted file mode 100644
index e698143..0000000
--- a/tests/test_pytree.py
+++ /dev/null
@@ -1,121 +0,0 @@
-"""Tests for JAX pytree registration and pipelines."""
-
-import dascore as dc
-import jax
-import numpy as np
-import pytest
-
-from dasjax import JaxPatchPipeline, list_operations
-from dasjax.operations import get_operation
-
-
-def _run_operation(patch, name: str, *args, **kwargs):
-    """Apply one internal operation through DASCore's pipe helper."""
-    return patch.pipe(get_operation(name).patch_impl, *args, **kwargs)
-
-
-def test_patch_pytree_roundtrip() -> None:
-    """Round-trip a patch through the registered pytree hooks."""
-    patch = dc.get_example_patch()
-
-    leaves, tree = jax.tree_util.tree_flatten(patch)
-    out = jax.tree_util.tree_unflatten(tree, leaves)
-
-    assert out.equals(patch)
-
-
-def test_patch_pytree_restores_datetime_coords() -> None:
-    """Restore datetime coordinates after pytree reconstruction."""
-    patch = dc.get_example_patch()
-
-    leaves, tree = jax.tree_util.tree_flatten(patch)
-    out = jax.tree_util.tree_unflatten(tree, leaves)
-
-    out_time = out.coords.coord_map["time"]
-    in_time = patch.coords.coord_map["time"]
-
-    assert out_time.dtype == in_time.dtype
-    assert np.array_equal(out_time.values, in_time.values)
-
-
-def test_patch_tree_map_updates_data_and_coords() -> None:
-    """Apply tree_map updates to both data and coordinate leaves."""
-    patch = dc.get_example_patch()
-
-    out = jax.tree_util.tree_map(lambda x: x + 1, patch)
-    out_distance = out.coords.coord_map["distance"]
-    in_distance = patch.coords.coord_map["distance"]
-    out_time = out.coords.coord_map["time"]
-    in_time = patch.coords.coord_map["time"]
-
-    assert np.array_equal(out.data, patch.data + 1)
-    assert np.array_equal(out_distance.values, in_distance.values + 1)
-    assert np.array_equal(
-        out_time.values,
-        in_time.values + np.timedelta64(1, "ns"),
-    )
-
-
-def test_pipeline_compile_returns_callable_patch_transform() -> None:
-    """Compile pipelines into callables that transform patches."""
-    patch = dc.get_example_patch()
-    pipeline = JaxPatchPipeline().identity().scale(2.0).scale(3.0)
-
-    compiled = pipeline.compile()
-    out = compiled(patch)
-
-    assert callable(compiled)
-    assert np.allclose(out.data, patch.data * 6.0)
-    assert out.coords == patch.coords
-
-
-@pytest.mark.parametrize("operation_name", list_operations())
-def test_pipeline_accepts_registered_operations(operation_name: str) -> None:
-    """Expose every registered operation as a pipeline method."""
-    pipeline = getattr(JaxPatchPipeline(), operation_name)
-
-    assert callable(pipeline)
-
-
-def test_pipeline_chains_multiple_operations() -> None:
-    """Match eager behavior when chaining multiple pipeline operations."""
-    patch = dc.get_example_patch()
-    pipeline = (
-        JaxPatchPipeline()
-        .add(1.5)
-        .scale(2.0)
-        .clip(-0.25, 0.25)
-        .detrend(dim="time", type="constant")
-    )
-
-    out = pipeline.compile()(patch)
-    expected = _run_operation(
-        _run_operation(
-            _run_operation(
-                _run_operation(patch, "add", 1.5),
-                "scale",
-                2.0,
-            ),
-            "clip",
-            -0.25,
-            0.25,
-        ),
-        "detrend",
-        dim="time",
-        type="constant",
-    )
-
-    assert np.allclose(out.data, expected.data)
-    assert out.coords == expected.coords
-
-
-def test_pipeline_rejects_unknown_operations() -> None:
-    """Reject attempts to call unknown pipeline operations."""
-    pipeline = JaxPatchPipeline()
-
-    try:
-        pipeline.mean()
-    except AttributeError as exc:
-        assert "Unknown jax patch operation" in str(exc)
-    else:
-        raise AssertionError("Expected an unknown pipeline operation to fail.")
diff --git a/tests/test_registry_architecture.py b/tests/test_registry_architecture.py
index a23aaf0..ba46207 100644
--- a/tests/test_registry_architecture.py
+++ b/tests/test_registry_architecture.py
@@ -1,83 +1,199 @@
-"""Architecture-level checks for the operation registry rewrite."""
+"""Architecture-level checks for the core operation registry."""
 
 from __future__ import annotations
 
-import inspect
-
 import dasjax
-
-from dasjax.operations.basic import impl as basic_impl
-from dasjax.operations.filters import impl as filters_impl
-from dasjax.operations import ExecutionPolicy, PatchOp, iter_operations
-from dasjax.operations import basic, filters, signal, spectral
-from dasjax.operations.signal import impl as signal_impl
-from dasjax.operations.registry import OPERATIONS, list_operations
-from dasjax.operations.spectral import impl as spectral_impl
-
-
-def test_registry_operation_names_are_unique() -> None:
-    """Keep registered operation names unique."""
-    names = [operation.name for operation in iter_operations()]
+from dasjax import PatchOperation, get_patch_operation, iter_patch_operations
+
+
+EXPECTED_OPERATIONS = (
+    "identity",
+    "scale",
+    "add",
+    "subtract",
+    "multiply",
+    "divide",
+    "maximum",
+    "minimum",
+    "abs",
+    "clip",
+    "real",
+    "imag",
+    "angle",
+    "conj",
+    "exp",
+    "log",
+    "log10",
+    "log2",
+    "is_finite",
+    "isinf",
+    "isnan",
+    "fillna",
+    "where",
+    "flip",
+    "roll",
+    "standardize",
+    "aggregate",
+    "all",
+    "any",
+    "max",
+    "mean",
+    "median",
+    "min",
+    "std",
+    "sum",
+    "detrend",
+    "correlate_shift",
+    "dispersion_phase_shift",
+    "normalize",
+    "differentiate",
+    "integrate",
+    "taper",
+    "taper_range",
+    "gaussian_filter",
+    "hampel_filter",
+    "median_filter",
+    "sobel_filter",
+    "savgol_filter",
+    "notch_filter",
+    "wiener_filter",
+    "slope_filter",
+    "pass_filter",
+    "line_mute",
+    "slope_mute",
+    "pad",
+    "hilbert",
+    "envelope",
+    "phase_weighted_stack",
+    "dft",
+    "idft",
+    "whiten",
+    "fbe",
+    "velocity_to_strain_rate",
+    "velocity_to_strain_rate_edgeless",
+    "radians_to_strain",
+    "tau_p",
+    "correlate",
+    "decimate",
+    "interpolate",
+    "istft",
+    "resample",
+    "stft",
+)
+
+EXPECTED_OPERATION_MODULES = {
+    "identity": "dasjax.operations.basic",
+    "scale": "dasjax.operations.basic",
+    "add": "dasjax.operations.basic",
+    "subtract": "dasjax.operations.basic",
+    "multiply": "dasjax.operations.basic",
+    "divide": "dasjax.operations.basic",
+    "maximum": "dasjax.operations.basic",
+    "minimum": "dasjax.operations.basic",
+    "abs": "dasjax.operations.basic",
+    "clip": "dasjax.operations.basic",
+    "real": "dasjax.operations.basic",
+    "imag": "dasjax.operations.basic",
+    "angle": "dasjax.operations.basic",
+    "conj": "dasjax.operations.basic",
+    "exp": "dasjax.operations.basic",
+    "log": "dasjax.operations.basic",
+    "log10": "dasjax.operations.basic",
+    "log2": "dasjax.operations.basic",
+    "is_finite": "dasjax.operations.basic",
+    "isinf": "dasjax.operations.basic",
+    "isnan": "dasjax.operations.basic",
+    "fillna": "dasjax.operations.basic",
+    "where": "dasjax.operations.basic",
+    "flip": "dasjax.operations.basic",
+    "roll": "dasjax.operations.basic",
+    "standardize": "dasjax.operations.basic",
+    "aggregate": "dasjax.operations.basic",
+    "all": "dasjax.operations.basic",
+    "any": "dasjax.operations.basic",
+    "max": "dasjax.operations.basic",
+    "mean": "dasjax.operations.basic",
+    "median": "dasjax.operations.basic",
+    "min": "dasjax.operations.basic",
+    "std": "dasjax.operations.basic",
+    "sum": "dasjax.operations.basic",
+    "detrend": "dasjax.operations.detrend",
+    "correlate_shift": "dasjax.operations.correlate",
+    "dispersion_phase_shift": "dasjax.operations.dispersion",
+    "normalize": "dasjax.operations.normalize",
+    "differentiate": "dasjax.operations.differentiate",
+    "integrate": "dasjax.operations.integrate",
+    "taper": "dasjax.operations.taper",
+    "taper_range": "dasjax.operations.taper",
+    "gaussian_filter": "dasjax.operations.filter",
+    "hampel_filter": "dasjax.operations.filter",
+    "median_filter": "dasjax.operations.filter",
+    "notch_filter": "dasjax.operations.filter",
+    "pass_filter": "dasjax.operations.filter",
+    "savgol_filter": "dasjax.operations.filter",
+    "sobel_filter": "dasjax.operations.filter",
+    "slope_filter": "dasjax.operations.filter",
+    "wiener_filter": "dasjax.operations.filter",
+    "line_mute": "dasjax.operations.mute",
+    "slope_mute": "dasjax.operations.mute",
+    "pad": "dasjax.operations.pad",
+    "hilbert": "dasjax.operations.hilbert",
+    "envelope": "dasjax.operations.hilbert",
+    "phase_weighted_stack": "dasjax.operations.hilbert",
+    "dft": "dasjax.operations.fourier",
+    "idft": "dasjax.operations.fourier",
+    "whiten": "dasjax.operations.whiten",
+    "fbe": "dasjax.operations.spectro",
+    "velocity_to_strain_rate": "dasjax.operations.strain",
+    "velocity_to_strain_rate_edgeless": "dasjax.operations.strain",
+    "radians_to_strain": "dasjax.operations.strain",
+    "tau_p": "dasjax.operations.taup",
+    "correlate": "dasjax.operations.numeric",
+    "decimate": "dasjax.operations.numeric",
+    "interpolate": "dasjax.operations.numeric",
+    "istft": "dasjax.operations.numeric",
+    "resample": "dasjax.operations.numeric",
+    "stft": "dasjax.operations.numeric",
+}
+
+
+def test_core_operation_names_are_unique() -> None:
+    """Ensure each registered operation has a distinct public name."""
+    names = [operation.operation_name() for operation in iter_patch_operations()]
     assert len(names) == len(set(names))
 
 
-def test_leaf_operations_define_leaf_transform() -> None:
-    """Require leaf operations to expose only the leaf transform path."""
-    for operation in iter_operations():
-        if operation.execution_policy is ExecutionPolicy.LEAF:
-            assert operation.leaf_transform is not None
-        else:
-            assert operation.leaf_transform is None
+def test_all_operations_are_patch_operation_subclasses() -> None:
+    """Keep the registry limited to PatchOperation subclasses."""
+    for operation in iter_patch_operations():
+        assert issubclass(operation, PatchOperation)
 
 
-def test_all_operations_define_patch_op_class() -> None:
-    """Ensure every registered operation exposes a PatchOp class."""
-    for operation in iter_operations():
-        assert operation.patch_op_cls is not None
+def test_list_patch_operations_preserves_registry_order() -> None:
+    """Expose operation names in deterministic registration order."""
+    assert dasjax.list_patch_operations() == EXPECTED_OPERATIONS
 
 
-def test_patch_op_subclass_registry_is_populated() -> None:
-    """Register concrete PatchOp subclasses for runtime introspection."""
-    subclass_names = {cls.__name__ for cls in PatchOp.iter_subclasses()}
-    assert "ScaleOp" in subclass_names
-    assert "PadOp" in subclass_names
+def test_get_patch_operation_resolves_all_registered_names() -> None:
+    """Resolve every expected operation through the public lookup helper."""
+    for name in EXPECTED_OPERATIONS:
+        assert get_patch_operation(name).operation_name() == name
 
 
-def test_patch_op_compile_category_table_contains_expected_groups() -> None:
-    """Expose the expected compile categories through the PatchOp table."""
-    table = PatchOp.compile_category_table()
-    assert "kernel_fusible" in table
-    assert "compiled_boundary" in table
-    assert "eager_boundary" in table
+def test_operations_live_in_domain_modules() -> None:
+    """Keep operation implementations grouped by DASCore-style domains."""
+    for name, module_name in EXPECTED_OPERATION_MODULES.items():
+        assert get_patch_operation(name).__module__ == module_name
 
 
 def test_package_root_exports_only_runtime_surface() -> None:
-    """Keep the root package export surface intentionally small."""
-    assert sorted(dasjax.__all__) == ["JaxPatchPipeline", "list_operations"]
-
-
-def test_list_operations_preserves_registry_order() -> None:
-    """Preserve registry order when listing operation names."""
-    assert list_operations() == tuple(operation.name for operation in OPERATIONS)
-
-
-def test_operation_families_export_specs_from_packages() -> None:
-    """Expose operation spec collections from each family package."""
-    for module in (basic, signal, filters, spectral):
-        assert hasattr(module, "OPERATIONS")
-        assert module.OPERATIONS
-        assert module.__file__ is not None
-        assert module.__file__.endswith("__init__.py")
-
-
-def test_operation_impl_modules_avoid_private_dascore_imports() -> None:
-    """Avoid private DASCore imports inside operation implementations."""
-    for module in (
-        basic_impl,
-        signal_impl,
-        filters_impl,
-        spectral_impl,
-    ):
-        source = inspect.getsource(module)
-        assert "from dascore" in source
-        assert " import _" not in source
+    """Avoid exporting implementation modules from the package root."""
+    assert sorted(dasjax.__all__) == [
+        "JaxPatchPipeline",
+        "PatchBoundary",
+        "PatchOperation",
+        "PatchPyTree",
+        "get_patch_operation",
+        "iter_patch_operations",
+        "list_patch_operations",
+    ]
diff --git a/zensical.toml b/zensical.toml
new file mode 100644
index 0000000..1ea3d98
--- /dev/null
+++ b/zensical.toml
@@ -0,0 +1,85 @@
+[project]
+site_name = "dasjax"
+site_url = "https://dasdae.github.io/dasjax/"
+repo_url = "https://github.com/dasdae/dasjax"
+docs_dir = "docs"
+site_dir = "site"
+nav = [
+  {"Home" = "index.md"},
+  {"Tutorial" = [
+    {"Overview" = "tutorial/index.md"},
+    {"Compiled Pipelines" = "tutorial/compiled-pipelines.md"},
+    {"Performance" = "tutorial/performance.md"},
+  ]},
+  {"Benchmarks" = [
+    {"Overview" = "benchmarks/index.md"},
+    {"Pipelines" = "benchmarks/pipelines.md"},
+    {"Methods" = "benchmarks/methods.md"},
+  ]},
+  {"Development" = [
+    {"Overview" = "development/index.md"},
+    {"Architecture" = "development/architecture.md"},
+    {"Operation Coverage" = "development/operation-coverage.md"},
+    {"Documentation" = "development/documentation.md"},
+  ]},
+  {"API Reference" = [
+    {"Overview" = "api/index.md"},
+  ]},
+]
+
+[project.theme]
+variant = "classic"
+logo = "static/dasjax_logo.png"
+favicon = "static/favicon.ico"
+features = [
+  "navigation.tabs",
+  "navigation.tabs.sticky",
+  "navigation.instant",
+  "navigation.tracking",
+  "navigation.sections",
+  "navigation.top",
+  "toc.follow",
+]
+
+[[project.theme.palette]]
+media = "(prefers-color-scheme: light)"
+scheme = "default"
+primary = "indigo"
+accent = "blue"
+toggle.icon = "lucide/sun"
+toggle.name = "Switch to dark mode"
+
+[[project.theme.palette]]
+media = "(prefers-color-scheme: dark)"
+scheme = "slate"
+primary = "indigo"
+accent = "blue"
+toggle.icon = "lucide/moon"
+toggle.name = "Switch to light mode"
+
+[project.markdown_extensions.admonition]
+
+[project.markdown_extensions.attr_list]
+
+[project.markdown_extensions.md_in_html]
+
+[project.markdown_extensions.tables]
+
+[project.markdown_extensions.pymdownx.details]
+
+[project.markdown_extensions.pymdownx.emoji]
+emoji_index = "zensical.extensions.emoji.twemoji"
+emoji_generator = "zensical.extensions.emoji.to_svg"
+
+[project.markdown_extensions.pymdownx.highlight]
+
+[project.markdown_extensions.pymdownx.inlinehilite]
+
+[project.markdown_extensions.pymdownx.snippets]
+base_path = ["."]
+check_paths = true
+
+[project.markdown_extensions.pymdownx.superfences]
+
+[project.markdown_extensions.pymdownx.tabbed]
+alternate_style = true