diff --git a/.github/workflows/tag_and_publish.yml b/.github/workflows/tag_and_publish.yml
index 7c6ba1c..dd822ab 100644
--- a/.github/workflows/tag_and_publish.yml
+++ b/.github/workflows/tag_and_publish.yml
@@ -24,7 +24,7 @@ jobs:
       with:
         python-version: '3.10'
     - name: Install dependencies
-      run: uv sync
+      run: uv sync --extra full
     - name: Get Python version and Update README.md
       run: |
         python_version=$(grep "requires-python" pyproject.toml | grep -o ">=[^\"]*")
diff --git a/.github/workflows/test_and_lint.yml b/.github/workflows/test_and_lint.yml
index 7593130..ed0e022 100644
--- a/.github/workflows/test_and_lint.yml
+++ b/.github/workflows/test_and_lint.yml
@@ -21,7 +21,7 @@ jobs:
       with:
         python-version: ${{ matrix.python-version }}
     - name: Install dependencies
-      run: uv sync
+      run: uv sync --extra full
     - name: Run linter checks
       run: uv run ruff check . && uv run ruff format --check . && uv run interrogate --verbose .
     - name: Run tests and coverage
diff --git a/README.md b/README.md
index 6d8dc5e..034cccc 100644
--- a/README.md
+++ b/README.md
@@ -87,6 +87,18 @@ This project uses [uv](https://docs.astral.sh/uv/). From the root directory, run
 ```bash
 uv sync
 ```
+
+> [!IMPORTANT]
+> The base install includes **only** the raw data loader and does **not** pull in
+> `aind-data-schema` or `matplotlib`. The quality-control (`qc`) module requires
+> both, so importing `dynamic_foraging_processing.qc` will fail on a base install.
+> To use the QC module, install the `qc` (or equivalent `full`) extra:
+> ```bash
+> pip install -e ".[qc]"
+> ```
+> The `full` extra is currently an alias for `qc`.
+
+To develop the code, run
 to create the environment and install the package. To include the development
 dependencies (linting, tests, docs), run
 ```bash
@@ -101,6 +113,10 @@ uv run ruff check . && uv run ruff format --check .   # lint + format
 uv run interrogate -v .                               # docstring coverage
 uv run coverage run -m pytest && uv run coverage report
 ```
+To include the QC dependencies with uv, run
+```bash
+uv sync --extra qc
+```
 
 ## Release Status
 GitHub's tags and Release features can be used to indicate a Release status.
diff --git a/docs/qc_upgrade_plan.md b/docs/qc_upgrade_plan.md
index 3eb4413..47d43dc 100644
--- a/docs/qc_upgrade_plan.md
+++ b/docs/qc_upgrade_plan.md
@@ -70,6 +70,7 @@ any dataset on disk.
 | `left_lick_times` | `np.ndarray` of seconds | `B_LeftLickTime` |
 | `right_lick_times` | `np.ndarray` of seconds | `B_RightLickTime` |
 | `animal_response` | `np.ndarray` of `{0,1,2}` per trial | `B_AnimalResponseHistory` |
+| `side_bias` | `np.ndarray` per trial (right minus left, `nan` on no-response) | `B_Bias` |
 | `go_cue_times` | `np.ndarray` of seconds | `B_GoCueTimeSoundCard` |
 | `rewarded_history` | `pd.DataFrame` with `left`/`right` boolean columns | `B_RewardedHistory` |
 | `stage_positions` | `pd.DataFrame` with `x`/`y`/`z` columns per trial | `B_StagePositions` |
@@ -78,8 +79,8 @@ any dataset on disk.
 
 - `drop_frames_tag`, `frame_num`, `trigger_length` — dropped-frames check.
 - `Experimenter`, `dirty_files`, `repo_dirty_flag` — basic-configuration check.
-- `B_Bias`, `B_Bias_CI` — pre-computed side bias; recompute from
-  `animal_response` instead (rolling fraction of right vs. left choices).
+- `B_Bias_CI` — side-bias confidence interval; dropped (the bias trace plots
+  the per-trial `side_bias` column directly, with no CI band).
 
 ## 3. Metrics in the new capsule
 
@@ -88,10 +89,12 @@ Keep only what maps cleanly. All metrics get `stage=Stage.RAW` and
 
 ### Side bias (`tags={"behavior": "average side bias"}`)
 
-- Input: `animal_response: np.ndarray` (`0=left`, `1=right`, `2=ignore`).
-- Average bias = `mean(is_right) - mean(is_left)` over responded trials (or
-  the rolling form, matching the old `B_Bias`).
-- Metric: `"average side bias"`, pass when `abs(mean_bias) < 0.5`.
+- Input: `side_bias: np.ndarray` — the per-trial side bias read directly from
+  the trial table (right minus left; `nan` on no-response trials). It is *not*
+  recomputed from `animal_response`.
+- Average bias = `nanmean(side_bias)` over the session.
+- Metric: `"average side bias"`, pass when `abs(mean_bias) < 0.5`. An empty or
+  all-`nan` column yields `nan`, which fails.
 - `reference="side_bias.png"`.
 
 ### Lick intervals
@@ -118,8 +121,8 @@ All carry `reference="lick_intervals.png"`.
   (`left licks`, `right licks`, `left to right licks`, `right to left licks`,
   `all licks`); inputs are `left_lick_times` and `right_lick_times`.
 - `side_bias.png` — four-panel figure:
-  - Side bias trace (with confidence interval band) — rolling `B_Bias` /
-    `B_Bias_CI` recomputed from `animal_response`.
+  - Side bias trace — the per-trial `side_bias` column read from the trial
+    table (no confidence-interval band).
   - Lickspout position over trials — `stage_positions` (x / y1 / y2 / z,
     relative to session start, in mm).
   - Behavior event raster — `animal_response` (L/R choice, ignore),
@@ -210,3 +213,4 @@ test_suite
 | --- | --- | --- | --- |
 | 2026-06-03 | metrics | Confirmed kept QC metrics: side bias, lick intervals, and Harp/contract QA via `make_qc_runner`. Dropped checks tied to old `behavior.json` (dropped frames, basic configuration). | Meeting with Alex. |
 | 2026-06-03 | qa | Adopt contraqctor `qc.Runner` output (`make_qc_runner(dataset)`) as the source for Harp / camera / contract / DynamicForaging QA, converted into `QCMetric`s. | Meeting with Alex. |
+| 2026-06-22 | metrics, data inputs, plots | Side bias is read from the precomputed per-trial `side_bias` column (averaged via `nanmean`) instead of being recomputed from `animal_response`; dropped the `B_Bias_CI` confidence-interval band. | Reflect implemented `side_bias_result` / `plot_side_bias`. |
diff --git a/examples/qc_example.ipynb b/examples/qc_example.ipynb
new file mode 100644
index 0000000..2710f3d
--- /dev/null
+++ b/examples/qc_example.ipynb
@@ -0,0 +1,543 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "205e6429",
+   "metadata": {},
+   "source": [
+    "# Quality Control Example\n",
+    "\n",
+    "This notebook demonstrates the `dynamic_foraging_processing.qc` module: the\n",
+    "**metrics** that can be gathered and the **plots** that can be produced from the\n",
+    "trial table (the precomputed `side_bias` column).\n",
+    "\n",
+    "It uses **synthetic data** (no dataset loading) so it runs anywhere, mirroring\n",
+    "the arrays used in the unit tests. Swap in a real session's `side_bias` (e.g. the\n",
+    "column from `TrialTableBuilder.build()`) to use it for real."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "75bdf3a3",
+   "metadata": {},
+   "source": [
+    "## Create synthetic data\n",
+    "\n",
+    "A random per-trial choice sequence plus the optional per-trial context the\n",
+    "side-bias figure can display (reward history, reward probabilities, autowater,\n",
+    "go-cue times), assembled into a `trials` DataFrame using the same column names\n",
+    "the QC entry points expect. None of this needs a dataset."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "72ca85eb",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-06-22T17:15:14.933186Z",
+     "iopub.status.busy": "2026-06-22T17:15:14.933186Z",
+     "iopub.status.idle": "2026-06-22T17:15:15.066462Z",
+     "shell.execute_reply": "2026-06-22T17:15:15.066462Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "n trials: 200\n",
+      "left  (0): 70\n",
+      "right (1): 100\n",
+      "ignore(2): 30\n",
+      "columns: ['animal_response', 'side_bias', 'rewarded_historyL', 'rewarded_historyR', 'auto_waterL', 'auto_waterR', 'reward_probabilityL', 'reward_probabilityR', 'goCue_start_time']\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "\n",
+    "rng = np.random.default_rng(0)\n",
+    "n_trials = 200\n",
+    "\n",
+    "# Choice per trial: 0 left, 1 right, 2 ignore (slightly right-biased here).\n",
+    "animal_response = rng.choice([0, 1, 2], size=n_trials, p=[0.4, 0.5, 0.1])\n",
+    "\n",
+    "# Per-trial side bias from the trial table (right minus left). Computed over a\n",
+    "# sliding window, so it is nan only after many consecutive non-responses;\n",
+    "# synthetic here as a mild rightward bias.\n",
+    "side_bias = np.clip(rng.normal(0.15, 0.2, n_trials), -1.0, 1.0)\n",
+    "\n",
+    "# Per-trial context (synthetic), one column each.\n",
+    "rewarded_left = (animal_response == 0) & (rng.random(n_trials) < 0.5)\n",
+    "rewarded_right = (animal_response == 1) & (rng.random(n_trials) < 0.5)\n",
+    "autowater_left = np.zeros(n_trials, int)\n",
+    "autowater_right = np.zeros(n_trials, int)\n",
+    "reward_probability_left = np.full(n_trials, 0.4)\n",
+    "reward_probability_right = np.full(n_trials, 0.6)\n",
+    "go_cue_times = np.arange(n_trials, dtype=float)\n",
+    "\n",
+    "# Assemble the trials table. Column names match what the QC entry points expect\n",
+    "# (see `_COLUMNS` in qc.processed.results); a real session uses the table from\n",
+    "# `TrialTableBuilder.build()`.\n",
+    "trials = pd.DataFrame(\n",
+    "    {\n",
+    "        \"animal_response\": animal_response,\n",
+    "        \"side_bias\": side_bias,\n",
+    "        \"rewarded_historyL\": rewarded_left,\n",
+    "        \"rewarded_historyR\": rewarded_right,\n",
+    "        \"auto_waterL\": autowater_left,\n",
+    "        \"auto_waterR\": autowater_right,\n",
+    "        \"reward_probabilityL\": reward_probability_left,\n",
+    "        \"reward_probabilityR\": reward_probability_right,\n",
+    "        \"goCue_start_time\": go_cue_times,\n",
+    "    }\n",
+    ")\n",
+    "\n",
+    "print(\"n trials:\", n_trials)\n",
+    "print(\"left  (0):\", int(np.sum(animal_response == 0)))\n",
+    "print(\"right (1):\", int(np.sum(animal_response == 1)))\n",
+    "print(\"ignore(2):\", int(np.sum(animal_response == 2)))\n",
+    "print(\"columns:\", list(trials.columns))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f4981f30",
+   "metadata": {},
+   "source": [
+    "## Metrics from the trial table\n",
+    "\n",
+    "### Average side bias\n",
+    "The `side_bias` column is precomputed per trial in the trial table. The QC check averages it over the session; `abs(mean) < 0.5` passes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "abb13a1f",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-06-22T17:15:15.069820Z",
+     "iopub.status.busy": "2026-06-22T17:15:15.066462Z",
+     "iopub.status.idle": "2026-06-22T17:15:15.073147Z",
+     "shell.execute_reply": "2026-06-22T17:15:15.073147Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "average side bias: 0.132\n"
+     ]
+    }
+   ],
+   "source": [
+    "mean_bias = round(float(np.nanmean(side_bias)), 3)\n",
+    "print(f\"average side bias: {mean_bias}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "45cf1958",
+   "metadata": {},
+   "source": [
+    "### As a QC result / metric\n",
+    "`side_bias_result` averages the `side_bias` column into a `QCResult` (pass when\n",
+    "`abs(mean) < 0.5`), which converts to an `aind_data_schema` `QCMetric`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "58755f21",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-06-22T17:15:15.075017Z",
+     "iopub.status.busy": "2026-06-22T17:15:15.075017Z",
+     "iopub.status.idle": "2026-06-22T17:15:18.122180Z",
+     "shell.execute_reply": "2026-06-22T17:15:18.122180Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "name:    average side bias\n",
+      "value:   0.132\n",
+      "passed:  True\n",
+      "tags:    {'behavior': 'average side bias'}\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "QCMetric(object_type='QC metric', name='average side bias', modality=_Behavior(name='Behavior', abbreviation='behavior'), stage='Raw data', value=0.132, status_history=[QCStatus(object_type='QC status', evaluator='Automated', status='Pass', timestamp=datetime.datetime(2026, 6, 23, 16, 24, 27, 352495, tzinfo=zoneinfo.ZoneInfo(key='America/Los_Angeles')))], description='Average side bias across the session (right is positive).', reference='side_bias.png', tags={'behavior': 'average side bias'}, evaluated_assets=None)"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from dynamic_foraging_processing.qc import side_bias_result\n",
+    "\n",
+    "result = side_bias_result(side_bias)\n",
+    "print(\"name:   \", result.name)\n",
+    "print(\"value:  \", result.value)\n",
+    "print(\"passed: \", result.passed)\n",
+    "print(\"tags:   \", result.tags)\n",
+    "\n",
+    "metric = result.to_metric()\n",
+    "metric"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bb6846a3",
+   "metadata": {},
+   "source": [
+    "## Plot: side-bias figure\n",
+    "\n",
+    "`plot_side_bias` writes a four-panel `side_bias.png` into a results folder: the\n",
+    "per-trial `side_bias` trace, lickspout position, per-trial behavior raster, and\n",
+    "reward probabilities. The bias panel is driven by the `side_bias` column; the\n",
+    "remaining panels are populated from the optional per-trial context created above."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "72a51175",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-06-22T17:15:18.125824Z",
+     "iopub.status.busy": "2026-06-22T17:15:18.123685Z",
+     "iopub.status.idle": "2026-06-22T17:15:18.552676Z",
+     "shell.execute_reply": "2026-06-22T17:15:18.552171Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'side_bias.png'"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from pathlib import Path\n",
+    "\n",
+    "from dynamic_foraging_processing.qc import plot_side_bias\n",
+    "\n",
+    "results_folder = Path(\"qc_results\")\n",
+    "results_folder.mkdir(exist_ok=True)\n",
+    "\n",
+    "plot_side_bias(\n",
+    "    animal_response,\n",
+    "    side_bias,\n",
+    "    str(results_folder),\n",
+    "    rewarded_left=rewarded_left,\n",
+    "    rewarded_right=rewarded_right,\n",
+    "    reward_probability_left=reward_probability_left,\n",
+    "    reward_probability_right=reward_probability_right,\n",
+    "    go_cue_times=go_cue_times,\n",
+    "    autowater_left=autowater_left,\n",
+    "    autowater_right=autowater_right,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "0a361145",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-06-22T17:15:18.555189Z",
+     "iopub.status.busy": "2026-06-22T17:15:18.555189Z",
+     "iopub.status.idle": "2026-06-22T17:15:18.584054Z",
+     "shell.execute_reply": "2026-06-22T17:15:18.584054Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<IPython.core.display.Image object>"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from IPython.display import Image\n",
+    "\n",
+    "Image(filename=str(results_folder / \"side_bias.png\"))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "86cc9da8",
+   "metadata": {},
+   "source": [
+    "## Metrics: inter-lick intervals\n",
+    "\n",
+    "The lick metrics come from the per-port lick timestamps rather than the trial\n",
+    "table. `lick_interval_results` runs `calculate_lick_intervals` and returns four\n",
+    "`QCResult` objects — the percentage of left, right, and cross-side intervals\n",
+    "below the physiological threshold, plus an artifact percentage. Left/right/cross\n",
+    "pass when `< 10`; the artifact percent passes when `< 1`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "31cf3d8f",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-06-22T17:15:18.586013Z",
+     "iopub.status.busy": "2026-06-22T17:15:18.586013Z",
+     "iopub.status.idle": "2026-06-22T17:15:18.591081Z",
+     "shell.execute_reply": "2026-06-22T17:15:18.591081Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "left licks:  400\n",
+      "right licks: 500\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Synthetic per-port lick timestamps (s). Real sessions would use the lick\n",
+    "# times pulled from the NWB file; here we just scatter licks across the session.\n",
+    "rng_licks = np.random.default_rng(1)\n",
+    "left_lick_times = np.sort(rng_licks.uniform(0, n_trials, size=400))\n",
+    "right_lick_times = np.sort(rng_licks.uniform(0, n_trials, size=500))\n",
+    "\n",
+    "print(\"left licks: \", len(left_lick_times))\n",
+    "print(\"right licks:\", len(right_lick_times))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "445aa290",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-06-22T17:15:18.594151Z",
+     "iopub.status.busy": "2026-06-22T17:15:18.592092Z",
+     "iopub.status.idle": "2026-06-22T17:15:18.599276Z",
+     "shell.execute_reply": "2026-06-22T17:15:18.599276Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Left Lick Interval (%)         value=  9.270  passed=True\n",
+      "Right Lick Interval (%)        value= 12.420  passed=False\n",
+      "Cross Side Lick Interval (%)   value=  9.890  passed=True\n",
+      "Artifact Percent (%)           value=  0.445  passed=True\n"
+     ]
+    }
+   ],
+   "source": [
+    "from dynamic_foraging_processing.qc import lick_interval_results\n",
+    "\n",
+    "lick_results = lick_interval_results(left_lick_times, right_lick_times)\n",
+    "for r in lick_results:\n",
+    "    print(f\"{r.name:30s} value={r.value:7.3f}  passed={r.passed}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1513220c",
+   "metadata": {},
+   "source": [
+    "## Plot: inter-lick-interval histogram\n",
+    "\n",
+    "`plot_lick_intervals` writes a five-panel `lick_intervals.png` into the results\n",
+    "folder: histograms of the inter-lick intervals for left licks, right licks,\n",
+    "left-to-right transitions, right-to-left transitions, and all licks combined.\n",
+    "Like the metrics above, it is driven purely by the left/right lick timestamps."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "09aa51c9",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-06-22T17:15:18.600551Z",
+     "iopub.status.busy": "2026-06-22T17:15:18.600551Z",
+     "iopub.status.idle": "2026-06-22T17:15:19.294860Z",
+     "shell.execute_reply": "2026-06-22T17:15:19.294860Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'lick_intervals.png'"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from dynamic_foraging_processing.qc import plot_lick_intervals\n",
+    "\n",
+    "plot_lick_intervals(left_lick_times, right_lick_times, str(results_folder))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "fc39babb",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-06-22T17:15:19.296188Z",
+     "iopub.status.busy": "2026-06-22T17:15:19.296188Z",
+     "iopub.status.idle": "2026-06-22T17:15:19.315424Z",
+     "shell.execute_reply": "2026-06-22T17:15:19.314918Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<IPython.core.display.Image object>"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "Image(filename=str(results_folder / \"lick_intervals.png\"))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4d34d523",
+   "metadata": {},
+   "source": [
+    "## Assemble a `QualityControl` object\n",
+    "\n",
+    "The individual checks above can be collected in one call: `behavior_qc_results`\n",
+    "takes the `trials` table plus the left/right lick-time arrays and returns the\n",
+    "ordered list of `QCResult`s — the average side bias followed by the four\n",
+    "inter-lick-interval checks. `to_metrics` converts them to schema `QCMetric`s, and\n",
+    "`build_quality_control` assembles the final `QualityControl`. (Passing a\n",
+    "`results_folder` would also write the supporting plots; omitted here since the\n",
+    "cells above already produced them.)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "bf1b9b08",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-06-22T17:15:19.316159Z",
+     "iopub.status.busy": "2026-06-22T17:15:19.316159Z",
+     "iopub.status.idle": "2026-06-22T17:15:19.324151Z",
+     "shell.execute_reply": "2026-06-22T17:15:19.324151Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "total metrics: 5\n",
+      "  - average side bias: Pass\n",
+      "  - Left Lick Interval (%): Pass\n",
+      "  - Right Lick Interval (%): Fail\n",
+      "  - Cross Side Lick Interval (%): Pass\n",
+      "  - Artifact Percent (%): Pass\n",
+      "default grouping: ['behavior', 'test_suite']\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "QualityControl(object_type='Quality control', describedBy='https://raw.githubusercontent.com/AllenNeuralDynamics/aind-data-schema/main/src/aind_data_schema/core/quality_control.py', schema_version='2.4.2', metrics=[QCMetric(object_type='QC metric', name='average side bias', modality=_Behavior(name='Behavior', abbreviation='behavior'), stage='Raw data', value=0.132, status_history=[QCStatus(object_type='QC status', evaluator='Automated', status='Pass', timestamp=datetime.datetime(2026, 6, 23, 16, 24, 45, 236104, tzinfo=zoneinfo.ZoneInfo(key='America/Los_Angeles')))], description='Average side bias across the session (right is positive).', reference='side_bias.png', tags={'behavior': 'average side bias'}, evaluated_assets=None), QCMetric(object_type='QC metric', name='Left Lick Interval (%)', modality=_Behavior(name='Behavior', abbreviation='behavior'), stage='Raw data', value=9.27, status_history=[QCStatus(object_type='QC status', evaluator='Automated', status='Pass', timestamp=datetime.datetime(2026, 6, 23, 16, 24, 45, 236104, tzinfo=zoneinfo.ZoneInfo(key='America/Los_Angeles')))], description='Left Lick Interval (%) of inter-lick intervals; passes when < 10.0.', reference='lick_intervals.png', tags={'behavior': 'Left Lick Interval (%)'}, evaluated_assets=None), QCMetric(object_type='QC metric', name='Right Lick Interval (%)', modality=_Behavior(name='Behavior', abbreviation='behavior'), stage='Raw data', value=12.42, status_history=[QCStatus(object_type='QC status', evaluator='Automated', status='Fail', timestamp=datetime.datetime(2026, 6, 23, 16, 24, 45, 236104, tzinfo=zoneinfo.ZoneInfo(key='America/Los_Angeles')))], description='Right Lick Interval (%) of inter-lick intervals; passes when < 10.0.', reference='lick_intervals.png', tags={'behavior': 'Right Lick Interval (%)'}, evaluated_assets=None), QCMetric(object_type='QC metric', name='Cross Side Lick Interval (%)', modality=_Behavior(name='Behavior', abbreviation='behavior'), stage='Raw data', value=9.89, status_history=[QCStatus(object_type='QC status', evaluator='Automated', status='Pass', timestamp=datetime.datetime(2026, 6, 23, 16, 24, 45, 236104, tzinfo=zoneinfo.ZoneInfo(key='America/Los_Angeles')))], description='Cross Side Lick Interval (%) of inter-lick intervals; passes when < 10.0.', reference='lick_intervals.png', tags={'behavior': 'Cross Side Lick Interval (%)'}, evaluated_assets=None), QCMetric(object_type='QC metric', name='Artifact Percent (%)', modality=_Behavior(name='Behavior', abbreviation='behavior'), stage='Raw data', value=0.445, status_history=[QCStatus(object_type='QC status', evaluator='Automated', status='Pass', timestamp=datetime.datetime(2026, 6, 23, 16, 24, 45, 236104, tzinfo=zoneinfo.ZoneInfo(key='America/Los_Angeles')))], description='Artifact Percent (%) of inter-lick intervals; passes when < 1.0.', reference='lick_intervals.png', tags={'behavior': 'Artifact Percent (%)'}, evaluated_assets=None)], key_experimenters=None, notes=None, default_grouping=['behavior', 'test_suite'], allow_tag_failures=[], status={'behavior:Right Lick Interval (%)': <Status.FAIL: 'Fail'>, 'behavior:Cross Side Lick Interval (%)': <Status.PASS: 'Pass'>, 'behavior:Left Lick Interval (%)': <Status.PASS: 'Pass'>, 'behavior:average side bias': <Status.PASS: 'Pass'>, 'behavior:Artifact Percent (%)': <Status.PASS: 'Pass'>, 'behavior': <Status.FAIL: 'Fail'>, 'Raw data': <Status.FAIL: 'Fail'>})"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from dynamic_foraging_processing.qc import (\n",
+    "    behavior_qc_results,\n",
+    "    build_quality_control,\n",
+    "    to_metrics,\n",
+    ")\n",
+    "\n",
+    "# One call collects all five behavior results from the trials table plus the\n",
+    "# lick-time arrays: the average side bias and the four lick-interval checks.\n",
+    "behavior_results = behavior_qc_results(trials, left_lick_times, right_lick_times)\n",
+    "behavior_metrics = to_metrics(behavior_results)\n",
+    "\n",
+    "quality_control = build_quality_control(behavior_metrics)\n",
+    "print(\"total metrics:\", len(quality_control.metrics))\n",
+    "for m in quality_control.metrics:\n",
+    "    print(f\"  - {m.name}: {m.status_history[-1].status}\")\n",
+    "print(\"default grouping:\", quality_control.default_grouping)\n",
+    "quality_control"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "56793aff",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "dynamic-foraging-processing",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/pyproject.toml b/pyproject.toml
index 2ee5f23..0aca370 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -21,6 +21,15 @@ dependencies = [
     "ipykernel",
 ]
 
+[project.optional-dependencies]
+qc = [
+    "aind-data-schema>=2.4.1",
+    "matplotlib",
+]
+full = [
+    "dynamic-foraging-processing[qc]",
+]
+
 [dependency-groups]
 dev = [
     'ruff',
diff --git a/src/dynamic_foraging_processing/qc/__init__.py b/src/dynamic_foraging_processing/qc/__init__.py
new file mode 100644
index 0000000..44c2907
--- /dev/null
+++ b/src/dynamic_foraging_processing/qc/__init__.py
@@ -0,0 +1,65 @@
+"""Quality control for dynamic foraging datasets.
+
+Builds an ``aind_data_schema`` ``QualityControl`` object from primitive behavior
+data (lick times, per-trial choices) plus the contraqctor-based contract QA.
+
+The module is organized by QC stage:
+
+- :mod:`~dynamic_foraging_processing.qc._core` -- the shared stage interface,
+  schema helpers, per-check result type, and ``QualityControl`` assembler.
+- :mod:`~dynamic_foraging_processing.qc.raw` -- the raw-data (contract QA) stage.
+- :mod:`~dynamic_foraging_processing.qc.processed` -- the processed-data
+  (behavior metrics) stage.
+"""
+
+from dynamic_foraging_processing.qc._core import (
+    DEFAULT_GROUPING,
+    STATUS_CONVERTER,
+    BaseQC,
+    QCResult,
+    bool_to_status,
+    build_quality_control,
+    make_metric,
+    now_seattle,
+    now_utc,
+    to_builtin,
+    to_metrics,
+)
+from dynamic_foraging_processing.qc.processed import (
+    ProcessedQC,
+    behavior_qc_results,
+    calculate_lick_intervals,
+    lick_interval_results,
+    plot_lick_intervals,
+    plot_side_bias,
+    side_bias_result,
+)
+from dynamic_foraging_processing.qc.raw import (
+    RawQC,
+    contract_qc_metrics,
+    results_to_metrics,
+)
+
+__all__ = [
+    "DEFAULT_GROUPING",
+    "STATUS_CONVERTER",
+    "BaseQC",
+    "ProcessedQC",
+    "QCResult",
+    "RawQC",
+    "behavior_qc_results",
+    "bool_to_status",
+    "build_quality_control",
+    "calculate_lick_intervals",
+    "contract_qc_metrics",
+    "lick_interval_results",
+    "make_metric",
+    "now_seattle",
+    "now_utc",
+    "plot_lick_intervals",
+    "plot_side_bias",
+    "results_to_metrics",
+    "side_bias_result",
+    "to_builtin",
+    "to_metrics",
+]
diff --git a/src/dynamic_foraging_processing/qc/_core/__init__.py b/src/dynamic_foraging_processing/qc/_core/__init__.py
new file mode 100644
index 0000000..c609aac
--- /dev/null
+++ b/src/dynamic_foraging_processing/qc/_core/__init__.py
@@ -0,0 +1,34 @@
+"""Shared QC infrastructure: the stage interface, schema helpers, the per-check
+result type, and the ``QualityControl`` assembler.
+
+These pieces are stage-agnostic; the raw and processed stages build on them.
+"""
+
+from dynamic_foraging_processing.qc._core.base import BaseQC
+from dynamic_foraging_processing.qc._core.builder import (
+    DEFAULT_GROUPING,
+    build_quality_control,
+)
+from dynamic_foraging_processing.qc._core.result import QCResult, to_metrics
+from dynamic_foraging_processing.qc._core.schema import (
+    STATUS_CONVERTER,
+    bool_to_status,
+    make_metric,
+    now_seattle,
+    now_utc,
+    to_builtin,
+)
+
+__all__ = [
+    "DEFAULT_GROUPING",
+    "STATUS_CONVERTER",
+    "BaseQC",
+    "QCResult",
+    "bool_to_status",
+    "build_quality_control",
+    "make_metric",
+    "now_seattle",
+    "now_utc",
+    "to_builtin",
+    "to_metrics",
+]
diff --git a/src/dynamic_foraging_processing/qc/_core/base.py b/src/dynamic_foraging_processing/qc/_core/base.py
new file mode 100644
index 0000000..60d3bc0
--- /dev/null
+++ b/src/dynamic_foraging_processing/qc/_core/base.py
@@ -0,0 +1,33 @@
+"""Shared interface for the dynamic foraging QC stages.
+
+``BaseQC`` is an optional base class so the QC stages (raw, processed) share a
+single ``run`` interface. Each concrete stage computes its checks and returns
+them as schema ``QCMetric`` objects, which a caller assembles into one
+``QualityControl`` (see :func:`build_quality_control`).
+"""
+
+import abc
+import typing as t
+
+from aind_data_schema.core.quality_control import QCMetric
+
+
+class BaseQC(abc.ABC):
+    """Common interface for a QC stage.
+
+    A QC stage takes some slice of a session's data and produces a flat list of
+    ``QCMetric`` objects. Subclasses define what slice ``run`` consumes (raw
+    acquisition data, processed tables, ...); the return type is shared so the
+    metrics can be collected uniformly.
+    """
+
+    @abc.abstractmethod
+    def run(self, *args: t.Any, **kwargs: t.Any) -> t.List[QCMetric]:
+        """Run this stage's checks and return them as metrics.
+
+        Returns
+        -------
+        list of QCMetric
+            One metric per check, ready to assemble into a ``QualityControl``.
+        """
+        raise NotImplementedError
diff --git a/src/dynamic_foraging_processing/qc/_core/builder.py b/src/dynamic_foraging_processing/qc/_core/builder.py
new file mode 100644
index 0000000..d9b590f
--- /dev/null
+++ b/src/dynamic_foraging_processing/qc/_core/builder.py
@@ -0,0 +1,50 @@
+"""Assemble the dynamic foraging ``QualityControl`` object.
+
+Collects a flat list of metrics (behavior + contract QA) into a single
+``QualityControl``, wiring up ``default_grouping`` so the QC portal lays out
+``behavior`` and ``test_suite`` as sibling top-level groups.
+"""
+
+import typing as t
+
+from aind_data_schema.core.quality_control import QCMetric, QualityControl
+
+#: Tag keys laid out as siblings at the top level of the QC portal.
+DEFAULT_GROUPING = ["behavior", "test_suite"]
+
+
+def build_quality_control(
+    metrics: t.List[QCMetric],
+    *,
+    default_grouping: t.Optional[t.List[str]] = None,
+    allow_tag_failures: t.Optional[t.List[str]] = None,
+    key_experimenters: t.Optional[t.List[str]] = None,
+    notes: t.Optional[str] = None,
+) -> QualityControl:
+    """Wrap a flat list of metrics into a ``QualityControl`` object.
+
+    Parameters
+    ----------
+    metrics : list of QCMetric
+        All metrics (behavior + contract QA).
+    default_grouping : list of str, optional
+        Tag keys the portal groups by. Defaults to ``["behavior", "test_suite"]``.
+    allow_tag_failures : list of str, optional
+        Tag values whose metric failures should not fail the overall QC.
+    key_experimenters : list of str, optional
+        Experimenters associated with the session.
+    notes : str, optional
+        Free-text notes.
+
+    Returns
+    -------
+    QualityControl
+        The assembled quality-control object.
+    """
+    return QualityControl(
+        metrics=metrics,
+        default_grouping=default_grouping if default_grouping is not None else DEFAULT_GROUPING,
+        allow_tag_failures=allow_tag_failures if allow_tag_failures is not None else [],
+        key_experimenters=key_experimenters,
+        notes=notes,
+    )
diff --git a/src/dynamic_foraging_processing/qc/_core/result.py b/src/dynamic_foraging_processing/qc/_core/result.py
new file mode 100644
index 0000000..ae71125
--- /dev/null
+++ b/src/dynamic_foraging_processing/qc/_core/result.py
@@ -0,0 +1,75 @@
+"""The per-check ``QCResult`` and its conversion to a schema ``QCMetric``.
+
+A ``QCResult`` is the raw outcome of one behavior QC check (a name, value, and
+pass/fail). It converts into an ``aind_data_schema`` ``QCMetric`` via
+``to_metric``; the assembly step collects those metrics into a
+``QualityControl``.
+"""
+
+import dataclasses
+import typing as t
+
+from aind_data_schema.core.quality_control import QCMetric
+
+from dynamic_foraging_processing.qc._core.schema import bool_to_status, make_metric
+
+
+@dataclasses.dataclass(frozen=True)
+class QCResult:
+    """The raw outcome of a single QC check.
+
+    Attributes
+    ----------
+    name : str
+        Metric name.
+    value : Any
+        The computed value.
+    passed : bool
+        Whether the check passed.
+    description : str, optional
+        Human-readable description.
+    reference : str, optional
+        Relative path to a supporting asset (e.g. a plot).
+    tags : dict of str to str
+        Grouping tags (e.g. ``{"behavior": name}``).
+    """
+
+    name: str
+    value: t.Any
+    passed: bool
+    description: t.Optional[str] = None
+    reference: t.Optional[str] = None
+    tags: t.Dict[str, str] = dataclasses.field(default_factory=dict)
+
+    def to_metric(self) -> QCMetric:
+        """Convert this result into a schema ``QCMetric``.
+
+        Returns
+        -------
+        QCMetric
+            A metric carrying this result's value, pass/fail status, and tags.
+        """
+        return make_metric(
+            name=self.name,
+            value=self.value,
+            status=bool_to_status(self.passed),
+            description=self.description,
+            reference=self.reference,
+            tags=self.tags,
+        )
+
+
+def to_metrics(results: t.Sequence[QCResult]) -> t.List[QCMetric]:
+    """Convert a sequence of ``QCResult`` into schema ``QCMetric`` objects.
+
+    Parameters
+    ----------
+    results : sequence of QCResult
+        The per-check results to convert.
+
+    Returns
+    -------
+    list of QCMetric
+        One metric per result.
+    """
+    return [result.to_metric() for result in results]
diff --git a/src/dynamic_foraging_processing/qc/_core/schema.py b/src/dynamic_foraging_processing/qc/_core/schema.py
new file mode 100644
index 0000000..de8b025
--- /dev/null
+++ b/src/dynamic_foraging_processing/qc/_core/schema.py
@@ -0,0 +1,143 @@
+"""Schema helpers for building dynamic foraging quality-control objects.
+
+These helpers stamp the boilerplate that every ``QCMetric`` shares (modality,
+stage, evaluator, timestamps) and convert ``contraqctor`` statuses onto the
+``aind_data_schema`` quality-control schema (v2.4.1+).
+"""
+
+import datetime
+import typing as t
+from zoneinfo import ZoneInfo
+
+import numpy as np
+from aind_data_schema.core.quality_control import QCMetric, QCStatus, Stage, Status
+from aind_data_schema_models.modalities import Modality
+from contraqctor import qc
+
+#: Pacific timezone used for behavior-metric timestamps (schema requires
+#: timezone-aware datetimes).
+SEATTLE_TZ = ZoneInfo("America/Los_Angeles")
+
+#: Map ``contraqctor`` test statuses onto schema statuses. Warnings become
+#: ``PENDING`` (needs review); skips count as passing.
+STATUS_CONVERTER: t.Dict[qc.Status, Status] = {
+    qc.Status.PASSED: Status.PASS,
+    qc.Status.SKIPPED: Status.PASS,
+    qc.Status.WARNING: Status.PENDING,
+    qc.Status.FAILED: Status.FAIL,
+    qc.Status.ERROR: Status.FAIL,
+}
+
+
+def now_seattle() -> datetime.datetime:
+    """Return the current timezone-aware time in the Seattle timezone.
+
+    Returns
+    -------
+    datetime.datetime
+        Timezone-aware current time.
+    """
+    return datetime.datetime.now(SEATTLE_TZ)
+
+
+def now_utc() -> datetime.datetime:
+    """Return the current timezone-aware time in UTC.
+
+    Returns
+    -------
+    datetime.datetime
+        Timezone-aware current UTC time.
+    """
+    return datetime.datetime.now(datetime.timezone.utc)
+
+
+def bool_to_status(passed: bool, timestamp: t.Optional[datetime.datetime] = None) -> QCStatus:
+    """Convert a boolean pass/fail into an automated ``QCStatus``.
+
+    Parameters
+    ----------
+    passed : bool
+        ``True`` for a passing metric, ``False`` for a failing one.
+    timestamp : datetime.datetime, optional
+        Timezone-aware evaluation time. Defaults to the current Seattle time.
+
+    Returns
+    -------
+    QCStatus
+        An ``"Automated"`` status with ``PASS`` or ``FAIL``.
+    """
+    timestamp = timestamp if timestamp is not None else now_seattle()
+    status = Status.PASS if passed else Status.FAIL
+    return QCStatus(evaluator="Automated", status=status, timestamp=timestamp)
+
+
+def to_builtin(value: t.Any) -> t.Any:
+    """Convert numpy scalars/arrays to JSON-serializable Python builtins.
+
+    Parameters
+    ----------
+    value : Any
+        A value that may be a numpy scalar or array.
+
+    Returns
+    -------
+    Any
+        The equivalent Python builtin (``list`` for arrays, ``item()`` for
+        scalars), or ``value`` unchanged when it is not a numpy type.
+    """
+    if isinstance(value, np.ndarray):
+        return value.tolist()
+    if isinstance(value, np.generic):
+        return value.item()
+    return value
+
+
+def make_metric(
+    *,
+    name: str,
+    value: t.Any,
+    status: QCStatus,
+    description: t.Optional[str] = None,
+    reference: t.Optional[str] = None,
+    tags: t.Optional[t.Dict[str, str]] = None,
+    modality: Modality = Modality.BEHAVIOR,
+    stage: Stage = Stage.RAW,
+) -> QCMetric:
+    """Build a ``QCMetric`` with shared modality/stage/tag boilerplate.
+
+    Replaces the old capsule's ``create_evaluation`` + per-metric wiring.
+
+    Parameters
+    ----------
+    name : str
+        Metric name.
+    value : Any
+        Metric value; numpy types are converted to Python builtins.
+    status : QCStatus
+        The single status entry for this metric's ``status_history``.
+    description : str, optional
+        Human-readable description.
+    reference : str, optional
+        Relative path to a supporting asset (e.g. a plot).
+    tags : dict of str to str, optional
+        Grouping tags (e.g. ``{"behavior": name}``). Defaults to ``{}``.
+    modality : Modality, optional
+        Defaults to ``Modality.BEHAVIOR``.
+    stage : Stage, optional
+        Defaults to ``Stage.RAW``.
+
+    Returns
+    -------
+    QCMetric
+        The assembled metric.
+    """
+    return QCMetric(
+        name=name,
+        modality=modality,
+        stage=stage,
+        value=to_builtin(value),
+        status_history=[status],
+        description=description,
+        reference=reference,
+        tags=tags if tags is not None else {},
+    )
diff --git a/src/dynamic_foraging_processing/qc/processed/__init__.py b/src/dynamic_foraging_processing/qc/processed/__init__.py
new file mode 100644
index 0000000..8a67d12
--- /dev/null
+++ b/src/dynamic_foraging_processing/qc/processed/__init__.py
@@ -0,0 +1,23 @@
+"""Processed-data QC stage: behavior metrics computed from per-trial arrays."""
+
+from dynamic_foraging_processing.qc.processed.behavior import (
+    calculate_lick_intervals,
+    lick_interval_results,
+    side_bias_result,
+)
+from dynamic_foraging_processing.qc.processed.plots import (
+    plot_lick_intervals,
+    plot_side_bias,
+)
+from dynamic_foraging_processing.qc.processed.results import behavior_qc_results
+from dynamic_foraging_processing.qc.processed.stage import ProcessedQC
+
+__all__ = [
+    "ProcessedQC",
+    "behavior_qc_results",
+    "calculate_lick_intervals",
+    "lick_interval_results",
+    "plot_lick_intervals",
+    "plot_side_bias",
+    "side_bias_result",
+]
diff --git a/src/dynamic_foraging_processing/qc/processed/behavior.py b/src/dynamic_foraging_processing/qc/processed/behavior.py
new file mode 100644
index 0000000..73e6ebe
--- /dev/null
+++ b/src/dynamic_foraging_processing/qc/processed/behavior.py
@@ -0,0 +1,178 @@
+"""Behavior QC metrics computed from primitive arrays.
+
+These functions are agnostic to where the data came from: the caller supplies
+plain numpy arrays (lick times, per-trial choice codes), and the functions
+return ``QCMetric`` objects. The lick-interval computation is ported from the
+old ``aind-dynamic-foraging-qc`` capsule's ``calculate_lick_intervals``,
+adapted to take arrays directly instead of a ``behavior.json`` dict.
+"""
+
+import typing as t
+
+import numpy as np
+
+from dynamic_foraging_processing.qc._core.result import QCResult
+
+#: Reference plot assets shared by the behavior metrics.
+SIDE_BIAS_PLOT = "side_bias.png"
+LICK_INTERVALS_PLOT = "lick_intervals.png"
+
+
+def calculate_lick_intervals(
+    left_lick_times: np.ndarray, right_lick_times: np.ndarray
+) -> t.Dict[str, float]:
+    """Compute inter-lick-interval percentages from left/right lick times.
+
+    Ported from the old capsule's ``calculate_lick_intervals``; the inputs are
+    arrays of lick timestamps (seconds) rather than a ``behavior.json`` dict.
+
+    Parameters
+    ----------
+    left_lick_times : numpy.ndarray
+        Timestamps (s) of left-port licks.
+    right_lick_times : numpy.ndarray
+        Timestamps (s) of right-port licks.
+
+    Returns
+    -------
+    dict of str to float
+        ``LeftLickIntervalPercent``, ``RightLickIntervalPercent``,
+        ``SameSideIntervalPercent``, ``CrossSideIntervalPercent``, and
+        ``ArtifactPercent``.
+    """
+    left = np.asarray(left_lick_times, dtype=float)
+    right = np.asarray(right_lick_times, dtype=float)
+    same_side_l = np.diff(left)
+    same_side_r = np.diff(right)
+
+    threshold = 0.05  # time in s to consider as a fast interval
+
+    if (len(left) == 0) and (len(right) == 0):
+        ArtifactPercent = 0.0
+    else:
+        all_licks = np.sort(np.concatenate([left, right]))
+        all_diffs = np.sort(np.diff(all_licks))
+        ArtifactPercent = float(np.mean(all_diffs < 0.0005) * 100)
+
+    if len(left) > 1:
+        same_side_l_frac = round(float(np.mean(same_side_l <= threshold)), 4)
+        LeftLickIntervalPercent = same_side_l_frac * 100
+    else:
+        LeftLickIntervalPercent = 0.0
+
+    if len(right) > 1:
+        same_side_r_frac = round(float(np.mean(same_side_r <= threshold)), 4)
+        RightLickIntervalPercent = same_side_r_frac * 100
+    else:
+        RightLickIntervalPercent = 0.0
+
+    if len(right) > 0 and len(left) > 0:
+        same_side_combined = np.concatenate([same_side_l, same_side_r])
+        same_side_frac = round(
+            float(np.sum(same_side_combined <= threshold) / (len(right) + len(left))), 4
+        )
+        # Pair each lick time with a direction code (+1 right, -1 left), sort by
+        # time, then look at adjacent pairs that switch sides.
+        right_dummy = np.ones(np.shape(right))
+        left_dummy = np.negative(np.ones(np.shape(left)))
+        stacked_right = np.column_stack((right_dummy, right))
+        stacked_left = np.column_stack((left_dummy, left))
+        merged_sorted = np.array(
+            sorted(np.concatenate((stacked_right, stacked_left)), key=lambda x: x[1])
+        )
+        diffs = np.diff(merged_sorted[:, 0])
+        cross_sides = np.array(
+            [merged_sorted[i + 1, 1] - merged_sorted[i, 1] for i in np.where(diffs != 0)]
+        )[0]
+        cross_side_frac = round(
+            float(np.sum(cross_sides <= threshold) / (len(left) + len(right))), 4
+        )
+        CrossSideIntervalPercent = cross_side_frac * 100
+        SameSideIntervalPercent = same_side_frac * 100
+    else:
+        CrossSideIntervalPercent = 0.0
+        SameSideIntervalPercent = 0.0
+
+    return {
+        "LeftLickIntervalPercent": LeftLickIntervalPercent,
+        "RightLickIntervalPercent": RightLickIntervalPercent,
+        "SameSideIntervalPercent": SameSideIntervalPercent,
+        "CrossSideIntervalPercent": CrossSideIntervalPercent,
+        "ArtifactPercent": ArtifactPercent,
+    }
+
+
+def side_bias_result(side_bias: np.ndarray) -> QCResult:
+    """Build the average-side-bias ``QCResult`` from the trial-table column.
+
+    The per-trial side bias is read directly from the trial table rather than
+    recomputed; this check averages it over the session.
+
+    Parameters
+    ----------
+    side_bias : numpy.ndarray
+        Per-trial side bias from the trial table (right minus left); positive
+        means a rightward bias. Computed over a sliding window, so a single
+        no-response trial still has a value; entries are ``nan`` only when the
+        mouse has not responded for many consecutive trials.
+
+    Returns
+    -------
+    QCResult
+        Passes when ``abs(mean_bias) < 0.5``. Fails when the column is empty or
+        all ``nan`` (``mean_bias`` is ``nan``). Tagged ``{"behavior": ...}`` and
+        referencing ``side_bias.png``.
+    """
+    values = np.asarray(side_bias, dtype=float)
+    if values.size == 0 or np.all(np.isnan(values)):
+        mean_bias = float("nan")
+    else:
+        mean_bias = round(float(np.nanmean(values)), 3)
+    name = "average side bias"
+    return QCResult(
+        name=name,
+        value=mean_bias,
+        passed=bool(abs(mean_bias) < 0.5),  # nan comparisons are False -> fails
+        description="Average side bias across the session (right is positive).",
+        reference=SIDE_BIAS_PLOT,
+        tags={"behavior": name},
+    )
+
+
+def lick_interval_results(
+    left_lick_times: np.ndarray, right_lick_times: np.ndarray
+) -> t.List[QCResult]:
+    """Build the four inter-lick-interval ``QCResult`` objects.
+
+    Parameters
+    ----------
+    left_lick_times : numpy.ndarray
+        Timestamps (s) of left-port licks.
+    right_lick_times : numpy.ndarray
+        Timestamps (s) of right-port licks.
+
+    Returns
+    -------
+    list of QCResult
+        ``Left``/``Right``/``Cross Side`` lick-interval results (pass ``< 10``)
+        and ``Artifact Percent`` (pass ``< 1``), all referencing
+        ``lick_intervals.png``.
+    """
+    results = calculate_lick_intervals(left_lick_times, right_lick_times)
+    specs = [
+        ("Left Lick Interval (%)", round(results["LeftLickIntervalPercent"], 3), 10.0),
+        ("Right Lick Interval (%)", round(results["RightLickIntervalPercent"], 3), 10.0),
+        ("Cross Side Lick Interval (%)", round(results["CrossSideIntervalPercent"], 3), 10.0),
+        ("Artifact Percent (%)", round(results["ArtifactPercent"], 3), 1.0),
+    ]
+    return [
+        QCResult(
+            name=name,
+            value=value,
+            passed=value < limit,
+            description=f"{name} of inter-lick intervals; passes when < {limit}.",
+            reference=LICK_INTERVALS_PLOT,
+            tags={"behavior": name},
+        )
+        for name, value, limit in specs
+    ]
diff --git a/src/dynamic_foraging_processing/qc/processed/plots.py b/src/dynamic_foraging_processing/qc/processed/plots.py
new file mode 100644
index 0000000..d04c941
--- /dev/null
+++ b/src/dynamic_foraging_processing/qc/processed/plots.py
@@ -0,0 +1,308 @@
+"""QC plots for the dynamic foraging behavior metrics.
+
+Ported from the old ``aind-dynamic-foraging-qc`` capsule, adapted to take
+primitive per-trial and event-time arrays instead of a ``behavior.json`` dict.
+The Agg backend is forced so the plots render headlessly (no display required).
+"""
+
+import typing as t
+from pathlib import Path
+
+import matplotlib
+
+matplotlib.use("Agg")
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+from dynamic_foraging_processing.qc.processed.behavior import (
+    LICK_INTERVALS_PLOT,
+    SIDE_BIAS_PLOT,
+)
+
+
+def plot_lick_intervals(
+    left_lick_times: np.ndarray, right_lick_times: np.ndarray, results_folder: str
+) -> str:
+    """Save the five-panel inter-lick-interval histogram.
+
+    Panels: left licks, right licks, left-to-right, right-to-left, all licks.
+
+    Parameters
+    ----------
+    left_lick_times : numpy.ndarray
+        Timestamps (s) of left-port licks.
+    right_lick_times : numpy.ndarray
+        Timestamps (s) of right-port licks.
+    results_folder : str
+        Directory to write ``lick_intervals.png`` into.
+
+    Returns
+    -------
+    str
+        The plot filename (``lick_intervals.png``), for use as a metric
+        ``reference``.
+    """
+    left = np.asarray(left_lick_times, dtype=float)
+    right = np.asarray(right_lick_times, dtype=float)
+
+    fig, ax = plt.subplots(1, 5, figsize=(8, 3), sharex=True, sharey=True)
+    titles = [
+        "left licks",
+        "right licks",
+        "left to right licks",
+        "right to left licks",
+        "all licks",
+    ]
+    for axis, title in zip(ax, titles):
+        axis.set_title(title)
+        axis.set_xlabel("time (s)")
+        axis.spines["top"].set_visible(False)
+        axis.spines["right"].set_visible(False)
+    ax[0].set_xlim(-0.01, 0.3)
+    ax[0].set_ylabel("counts")
+
+    bins = np.linspace(-0.3, 0.3, 100)
+    left_index = np.zeros_like(left)
+    right_index = np.ones_like(right)
+    all_licks = np.concatenate((left, right))
+    all_index = np.concatenate((left_index, right_index))
+    sort_order = np.argsort(all_licks)
+    all_licks_sorted_diff = np.diff(all_licks[sort_order])
+    index_sorted_diff = np.diff(all_index[sort_order])
+    left_to_right = all_licks_sorted_diff[index_sorted_diff == 1]
+    right_to_left = all_licks_sorted_diff[index_sorted_diff == -1]
+
+    ax[0].hist(np.diff(left), bins=bins, color="red", alpha=0.7)
+    ax[1].hist(np.diff(right), bins=bins, color="blue", alpha=0.7)
+    ax[2].hist(left_to_right, bins=bins, color="black", alpha=0.7)
+    ax[3].hist(right_to_left, bins=bins, color="black", alpha=0.7)
+    ax[4].hist(all_licks_sorted_diff, bins=bins, color="black", alpha=0.7)
+
+    fig.tight_layout()
+    fig.savefig(Path(results_folder) / LICK_INTERVALS_PLOT, dpi=300, bbox_inches="tight")
+    plt.close(fig)
+    return LICK_INTERVALS_PLOT
+
+
+def _add_bias_plot(ax: plt.Axes, side_bias: np.ndarray) -> None:
+    """Draw the per-trial side-bias trace from the trial-table column."""
+    ax.set_xlabel("Trial #")
+    ax.set_ylabel("Side Bias")
+    ax.axhline(+0.7, color="r", linestyle="--")
+    ax.axhline(-0.7, color="r", linestyle="--")
+    ax.axhline(0, color="k", linestyle="--")
+    ax.set_ylim([-1, +1])
+
+    bias = np.asarray(side_bias, dtype=float)
+    trials = np.arange(len(bias))
+    ax.plot(trials, bias, "k", linewidth=2)
+    if len(bias):
+        ax.set_xlim([0, len(bias)])
+
+
+def _add_lickspout_position_plot(
+    ax: plt.Axes,
+    lickspout_x: t.Optional[np.ndarray],
+    lickspout_y1: t.Optional[np.ndarray],
+    lickspout_y2: t.Optional[np.ndarray],
+    lickspout_z: t.Optional[np.ndarray],
+) -> None:
+    """Draw lickspout x/y/z positions relative to session start (mm)."""
+    ax.set_xlabel("Trial #")
+    ax.set_ylabel("Lickspout Position \n relative to session start (mm)")
+    positions = [
+        ("X", lickspout_x, "r"),
+        ("Y1", lickspout_y1, "b"),
+        ("Y2", lickspout_y2, "lightblue"),
+        ("Z", lickspout_z, "m"),
+    ]
+    plotted = False
+    for label, position, color in positions:
+        if position is None or len(position) == 0:
+            continue
+        values = np.asarray(position, dtype=float)
+        ax.plot(values - values[0], color, label=label)
+        plotted = True
+    if plotted:
+        ax.legend()
+
+
+def _time_to_trial_index(go_cue_times: np.ndarray, times: np.ndarray) -> t.List[int]:
+    """Map event times to the index of the most recent preceding go cue."""
+    go_cue_times = np.asarray(go_cue_times, dtype=float)
+    trial_index = []
+    for event_time in np.asarray(times, dtype=float):
+        if len(go_cue_times) == 0 or event_time < go_cue_times[0]:
+            trial_index.append(-1)
+        else:
+            trial_index.append(int(np.where(go_cue_times < event_time)[0][-1]))
+    return trial_index
+
+
+def _add_behavior_plot(
+    ax: plt.Axes,
+    animal_response: np.ndarray,
+    rewarded_left: t.Optional[np.ndarray],
+    rewarded_right: t.Optional[np.ndarray],
+    autowater_left: t.Optional[np.ndarray],
+    autowater_right: t.Optional[np.ndarray],
+    manual_left_times: t.Optional[np.ndarray],
+    manual_right_times: t.Optional[np.ndarray],
+    go_cue_times: t.Optional[np.ndarray],
+) -> None:
+    """Draw the per-trial behavior raster (choices, rewards, water)."""
+    choices = np.asarray(animal_response)
+    ax.vlines(np.where(choices == 1)[0], 0.8, 1, linewidth=1, color="gray", label="Choice")
+    ax.vlines(np.where(choices == 0)[0], 0, 0.2, linewidth=1, color="gray")
+    ax.vlines(np.where(choices == 2)[0], 0.4, 0.6, linewidth=1, color="darkviolet", label="ignore")
+
+    if rewarded_left is not None:
+        left_rewards = np.where(np.asarray(rewarded_left))[0]
+        ax.vlines(left_rewards, -0.2, 0, linewidth=1, color="black", label="Earned Water")
+    if rewarded_right is not None:
+        right_rewards = np.where(np.asarray(rewarded_right))[0]
+        ax.vlines(right_rewards, 1, 1.2, linewidth=1, color="black")
+
+    if manual_right_times is not None and go_cue_times is not None:
+        ax.vlines(
+            _time_to_trial_index(go_cue_times, manual_right_times),
+            1.2,
+            1.4,
+            linewidth=1,
+            color="blue",
+            label="Manual Water",
+        )
+    if manual_left_times is not None and go_cue_times is not None:
+        ax.vlines(
+            _time_to_trial_index(go_cue_times, manual_left_times),
+            -0.4,
+            -0.2,
+            linewidth=1,
+            color="blue",
+        )
+
+    if autowater_right is not None:
+        ax.vlines(
+            np.where(np.asarray(autowater_right) == 1)[0],
+            1.2,
+            1.4,
+            linewidth=1,
+            color="cyan",
+            label="Auto Water",
+        )
+    if autowater_left is not None:
+        ax.vlines(
+            np.where(np.asarray(autowater_left) == 1)[0],
+            -0.4,
+            -0.2,
+            linewidth=1,
+            color="cyan",
+        )
+
+    ax.set_ylim([-0.4, 1.4])
+    ax.set_xlim([0, len(choices)])
+    ax.set_xlabel("Trial #")
+    ax.set_yticks(
+        [-0.3, -0.1, 0.1, 0.5, 0.9, 1.1, 1.3],
+        labels=[
+            "L Auto Water",
+            "L Reward",
+            "L Choice",
+            "Ignore",
+            "R Choice",
+            "R Reward",
+            "R Auto Water",
+        ],
+    )
+
+
+def _add_reward_probabilities(
+    ax: plt.Axes,
+    reward_probability_left: t.Optional[np.ndarray],
+    reward_probability_right: t.Optional[np.ndarray],
+) -> None:
+    """Draw the per-trial left/right reward probabilities."""
+    ax.set_xlabel("Trial #")
+    ax.set_ylim([0, 1])
+    if reward_probability_left is not None:
+        ax.plot(np.asarray(reward_probability_left, dtype=float), "b", label="Prob. L")
+    if reward_probability_right is not None:
+        ax.plot(np.asarray(reward_probability_right, dtype=float), "r", label="Prob. R")
+    ax.legend()
+
+
+def plot_side_bias(
+    animal_response: np.ndarray,
+    side_bias: np.ndarray,
+    results_folder: str,
+    *,
+    lickspout_x: t.Optional[np.ndarray] = None,
+    lickspout_y1: t.Optional[np.ndarray] = None,
+    lickspout_y2: t.Optional[np.ndarray] = None,
+    lickspout_z: t.Optional[np.ndarray] = None,
+    rewarded_left: t.Optional[np.ndarray] = None,
+    rewarded_right: t.Optional[np.ndarray] = None,
+    reward_probability_left: t.Optional[np.ndarray] = None,
+    reward_probability_right: t.Optional[np.ndarray] = None,
+    go_cue_times: t.Optional[np.ndarray] = None,
+    autowater_left: t.Optional[np.ndarray] = None,
+    autowater_right: t.Optional[np.ndarray] = None,
+    manual_left_times: t.Optional[np.ndarray] = None,
+    manual_right_times: t.Optional[np.ndarray] = None,
+) -> str:
+    """Save the four-panel side-bias figure.
+
+    Panels: per-trial side bias, lickspout position, behavior raster, and
+    reward probabilities.
+
+    Parameters
+    ----------
+    animal_response : numpy.ndarray
+        Per-trial choice codes (``0`` left, ``1`` right, ``2`` ignore).
+    side_bias : numpy.ndarray
+        Per-trial side bias from the trial table (right minus left).
+    results_folder : str
+        Directory to write ``side_bias.png`` into.
+    lickspout_x, lickspout_y1, lickspout_y2, lickspout_z : numpy.ndarray, optional
+        Per-trial lickspout positions (one array each).
+    rewarded_left, rewarded_right : numpy.ndarray, optional
+        Boolean per-trial earned-reward arrays.
+    reward_probability_left, reward_probability_right : numpy.ndarray, optional
+        Per-trial reward probabilities.
+    go_cue_times : numpy.ndarray, optional
+        Go-cue timestamps (s), used to map manual-water times to trials.
+    autowater_left, autowater_right : numpy.ndarray, optional
+        Per-trial autowater indicator arrays.
+    manual_left_times, manual_right_times : numpy.ndarray, optional
+        Manual-water delivery timestamps (s).
+
+    Returns
+    -------
+    str
+        The plot filename (``side_bias.png``), for use as a metric
+        ``reference``.
+    """
+    fig, ax = plt.subplots(nrows=4, figsize=(10, 12))
+    for axis in ax:
+        axis.spines["top"].set_visible(False)
+        axis.spines["right"].set_visible(False)
+
+    _add_bias_plot(ax[0], side_bias)
+    _add_lickspout_position_plot(ax[1], lickspout_x, lickspout_y1, lickspout_y2, lickspout_z)
+    _add_behavior_plot(
+        ax[2],
+        animal_response,
+        rewarded_left,
+        rewarded_right,
+        autowater_left,
+        autowater_right,
+        manual_left_times,
+        manual_right_times,
+        go_cue_times,
+    )
+    _add_reward_probabilities(ax[3], reward_probability_left, reward_probability_right)
+
+    fig.savefig(Path(results_folder) / SIDE_BIAS_PLOT, dpi=300, bbox_inches="tight")
+    plt.close(fig)
+    return SIDE_BIAS_PLOT
diff --git a/src/dynamic_foraging_processing/qc/processed/results.py b/src/dynamic_foraging_processing/qc/processed/results.py
new file mode 100644
index 0000000..1047c52
--- /dev/null
+++ b/src/dynamic_foraging_processing/qc/processed/results.py
@@ -0,0 +1,119 @@
+"""Build the behavior QC results from the trials table and lick-time arrays.
+
+Combines the side-bias and lick-interval checks into the ordered list of
+``QCResult`` objects the processed stage returns, optionally writing the
+supporting plots so the result references resolve. The per-trial inputs are
+pulled from the trials table by column; the lick and manual-water timestamps
+are event-time arrays (variable length, not per-trial) and stay explicit.
+Convert the results to schema metrics with ``to_metrics`` /
+``QCResult.to_metric`` when assembling a ``QualityControl``.
+"""
+
+import typing as t
+
+import numpy as np
+import pandas as pd
+
+from dynamic_foraging_processing.qc._core.result import QCResult
+from dynamic_foraging_processing.qc.processed.behavior import (
+    lick_interval_results,
+    side_bias_result,
+)
+from dynamic_foraging_processing.qc.processed.plots import plot_lick_intervals, plot_side_bias
+
+# Logical input -> trials-table column name. Centralized so the mapping is easy
+# to correct against the trial-table builder; ``side_bias`` and the
+# ``lickspout_*`` arrays are not yet pinned down in trials_table_mapping.md.
+_COLUMNS = {
+    "animal_response": "animal_response",
+    "side_bias": "side_bias",
+    "lickspout_x": "lickspout_x",
+    "lickspout_y1": "lickspout_y1",
+    "lickspout_y2": "lickspout_y2",
+    "lickspout_z": "lickspout_z",
+    "rewarded_left": "rewarded_historyL",
+    "rewarded_right": "rewarded_historyR",
+    "reward_probability_left": "reward_probabilityL",
+    "reward_probability_right": "reward_probabilityR",
+    "autowater_left": "auto_waterL",
+    "autowater_right": "auto_waterR",
+    "go_cue_times": "goCue_start_time",
+}
+
+
+def _column(trials: pd.DataFrame, key: str) -> t.Optional[np.ndarray]:
+    """Return the trials-table column for ``key`` as an array, or ``None``.
+
+    Missing columns return ``None`` so optional plot inputs degrade gracefully,
+    matching the previous per-array signature.
+    """
+    column = _COLUMNS[key]
+    if column in trials.columns:
+        return trials[column].to_numpy()
+    return None
+
+
+def behavior_qc_results(
+    trials: pd.DataFrame,
+    left_lick_times: np.ndarray,
+    right_lick_times: np.ndarray,
+    results_folder: t.Optional[str] = None,
+    *,
+    manual_left_times: t.Optional[np.ndarray] = None,
+    manual_right_times: t.Optional[np.ndarray] = None,
+) -> t.List[QCResult]:
+    """Build the behavior QC results (side bias + lick intervals).
+
+    When ``results_folder`` is provided, the supporting ``side_bias.png`` and
+    ``lick_intervals.png`` plots are written there so the result references
+    resolve. Convert the returned results to schema metrics with
+    ``to_metrics`` / ``QCResult.to_metric`` when assembling a ``QualityControl``.
+
+    Parameters
+    ----------
+    trials : pandas.DataFrame
+        Trials table. The per-trial inputs are read by column (see
+        ``_COLUMNS``): ``animal_response``, ``side_bias``, the ``lickspout_*``
+        positions, the earned-reward / autowater / reward-probability left/right
+        columns, and the go-cue start times. Columns that are absent are treated
+        as unavailable and skipped in the side-bias figure.
+    left_lick_times, right_lick_times : numpy.ndarray
+        Timestamps (s) of left/right-port licks. Event-time arrays, not
+        per-trial, so they are passed explicitly rather than read from ``trials``.
+    results_folder : str, optional
+        Directory to write the plots into. If ``None``, plots are skipped.
+    manual_left_times, manual_right_times : numpy.ndarray, optional
+        Manual-water delivery timestamps (s); event-time arrays passed through
+        to the side-bias figure.
+
+    Returns
+    -------
+    list of QCResult
+        The average-side-bias result followed by the four lick-interval results.
+    """
+    side_bias = _column(trials, "side_bias")
+    results = [
+        side_bias_result(side_bias),
+        *lick_interval_results(left_lick_times, right_lick_times),
+    ]
+    if results_folder is not None:
+        plot_side_bias(
+            _column(trials, "animal_response"),
+            side_bias,
+            results_folder,
+            lickspout_x=_column(trials, "lickspout_x"),
+            lickspout_y1=_column(trials, "lickspout_y1"),
+            lickspout_y2=_column(trials, "lickspout_y2"),
+            lickspout_z=_column(trials, "lickspout_z"),
+            rewarded_left=_column(trials, "rewarded_left"),
+            rewarded_right=_column(trials, "rewarded_right"),
+            reward_probability_left=_column(trials, "reward_probability_left"),
+            reward_probability_right=_column(trials, "reward_probability_right"),
+            go_cue_times=_column(trials, "go_cue_times"),
+            autowater_left=_column(trials, "autowater_left"),
+            autowater_right=_column(trials, "autowater_right"),
+            manual_left_times=manual_left_times,
+            manual_right_times=manual_right_times,
+        )
+        plot_lick_intervals(left_lick_times, right_lick_times, results_folder)
+    return results
diff --git a/src/dynamic_foraging_processing/qc/processed/stage.py b/src/dynamic_foraging_processing/qc/processed/stage.py
new file mode 100644
index 0000000..113412b
--- /dev/null
+++ b/src/dynamic_foraging_processing/qc/processed/stage.py
@@ -0,0 +1,64 @@
+"""Processed-data QC stage.
+
+``ProcessedQC`` wraps the behavior metrics computed from the trials table
+(side bias, lick intervals) into the ``BaseQC`` interface. It is a thin wrapper
+over :func:`behavior_qc_results`; the metric computation lives there.
+"""
+
+import typing as t
+
+import numpy as np
+import pandas as pd
+from aind_data_schema.core.quality_control import QCMetric
+
+from dynamic_foraging_processing.qc._core.base import BaseQC
+from dynamic_foraging_processing.qc._core.result import to_metrics
+from dynamic_foraging_processing.qc.processed.results import behavior_qc_results
+
+
+class ProcessedQC(BaseQC):
+    """Behavior QC over the trials table and lick-time arrays."""
+
+    def run(
+        self,
+        trials: pd.DataFrame,
+        left_lick_times: np.ndarray,
+        right_lick_times: np.ndarray,
+        results_folder: t.Optional[str] = None,
+        *,
+        manual_left_times: t.Optional[np.ndarray] = None,
+        manual_right_times: t.Optional[np.ndarray] = None,
+    ) -> t.List[QCMetric]:
+        """Compute the behavior QC checks and return them as metrics.
+
+        Parameters mirror :func:`behavior_qc_results`. When ``results_folder``
+        is provided, the supporting plots are written there so the metric
+        references resolve.
+
+        Parameters
+        ----------
+        trials : pandas.DataFrame
+            Trials table; the per-trial inputs (side bias, animal response,
+            lickspout positions, reward / autowater columns, go-cue times) are
+            read from it by column.
+        left_lick_times, right_lick_times : numpy.ndarray
+            Timestamps (s) of left/right-port licks.
+        results_folder : str, optional
+            Directory to write the plots into. If ``None``, plots are skipped.
+        manual_left_times, manual_right_times : numpy.ndarray, optional
+            Manual-water delivery timestamps passed through to the side-bias figure.
+
+        Returns
+        -------
+        list of QCMetric
+            The side-bias metric followed by the four lick-interval metrics.
+        """
+        results = behavior_qc_results(
+            trials,
+            left_lick_times,
+            right_lick_times,
+            results_folder,
+            manual_left_times=manual_left_times,
+            manual_right_times=manual_right_times,
+        )
+        return to_metrics(results)
diff --git a/src/dynamic_foraging_processing/qc/raw/__init__.py b/src/dynamic_foraging_processing/qc/raw/__init__.py
new file mode 100644
index 0000000..c3ba16d
--- /dev/null
+++ b/src/dynamic_foraging_processing/qc/raw/__init__.py
@@ -0,0 +1,9 @@
+"""Raw-data QC stage: contract QA over a loaded raw dynamic foraging dataset."""
+
+from dynamic_foraging_processing.qc.raw.contract_qa import (
+    contract_qc_metrics,
+    results_to_metrics,
+)
+from dynamic_foraging_processing.qc.raw.stage import RawQC
+
+__all__ = ["RawQC", "contract_qc_metrics", "results_to_metrics"]
diff --git a/src/dynamic_foraging_processing/qc/raw/contract_qa.py b/src/dynamic_foraging_processing/qc/raw/contract_qa.py
new file mode 100644
index 0000000..7c0ea33
--- /dev/null
+++ b/src/dynamic_foraging_processing/qc/raw/contract_qa.py
@@ -0,0 +1,144 @@
+"""Convert ``contraqctor`` QA runner results into ``QCMetric`` objects.
+
+The dynamic foraging contract QA (Harp devices, cameras, CSV streams, the data
+contract, and task-specific checks) is provided by
+``aind_behavior_dynamic_foraging.data_qc.make_qc_runner``. This module runs that
+runner over a dataset and maps each ``contraqctor`` ``Result`` onto a schema
+``QCMetric``, tagged so the QC portal groups them under ``test_suite``.
+"""
+
+import re
+import typing as t
+from pathlib import Path
+
+import matplotlib.figure
+from aind_behavior_dynamic_foraging.data_qc.suite import make_qc_runner
+from aind_data_schema.core.quality_control import QCMetric, QCStatus, Stage
+from aind_data_schema_models.modalities import Modality
+from contraqctor import contract, qc
+
+from dynamic_foraging_processing.qc._core.schema import STATUS_CONVERTER, now_utc, to_builtin
+
+#: Group value used when a runner result has no group.
+NO_GROUP = "NoGroup"
+
+
+def _sanitize(name: str) -> str:
+    """Make ``name`` safe to use as a filename component."""
+    return re.sub(r"[^0-9A-Za-z._-]+", "_", name)
+
+
+def _save_asset(result: qc.Result, results_folder: t.Optional[str]) -> t.Optional[str]:
+    """Save a result's figure asset (if any) and return its relative path.
+
+    Parameters
+    ----------
+    result : contraqctor.qc.Result
+        A single QA result; its ``context["asset"]`` may be a matplotlib figure.
+    results_folder : str or None
+        Directory to save figures into. If ``None``, nothing is saved.
+
+    Returns
+    -------
+    str or None
+        The saved figure's filename, or ``None`` when there is no figure asset
+        (or no ``results_folder``). The name combines the (sanitized) suite and
+        test names, e.g. a ``CameraTestSuite`` result for ``test_frame_rate``
+        becomes ``"CameraTestSuite_test_frame_rate.png"``.
+    """
+    context = result.context
+    if not isinstance(context, dict):
+        return None
+    asset = context.get("asset")
+    if not isinstance(asset, matplotlib.figure.Figure) or results_folder is None:
+        return None
+    filename = f"{_sanitize(result.suite_name)}_{_sanitize(result.test_name)}.png"
+    asset.savefig(Path(results_folder) / filename, dpi=300, bbox_inches="tight")
+    return filename
+
+
+def results_to_metrics(
+    results: t.Dict[t.Optional[str], t.List[qc.Result]],
+    results_folder: t.Optional[str] = None,
+) -> t.List[QCMetric]:
+    """Convert grouped ``contraqctor`` results into ``QCMetric`` objects.
+
+    Parameters
+    ----------
+    results : dict
+        Mapping of group name to list of ``contraqctor`` ``Result`` objects, as
+        returned by ``contraqctor.qc.Runner.run_all``. The keys are the group
+        names passed to ``runner.add_suite`` (e.g. ``"Data contract"``,
+        ``"HarpHub"``, ``"HarpLickometerRight"``, ``"DynamicForaging"``), and
+        each ``Result`` carries its suite's class name as ``suite_name`` (e.g.
+        ``"ContractTestSuite"``, ``"HarpDeviceTestSuite"``, ``"CameraTestSuite"``,
+        ``"DynamicForagingQcSuite"``). A ``None`` key becomes :data:`NO_GROUP`.
+    results_folder : str, optional
+        Directory to save figure assets into. If ``None``, assets are skipped.
+
+    Returns
+    -------
+    list of QCMetric
+        One metric per result, tagged ``{"test_suite": suite, suite: group}``.
+
+    Examples
+    --------
+    The dynamic foraging runner produces results grouped roughly like::
+
+        {
+            "Data contract": [<ContractTestSuite results>],
+            "HarpHub": [<HarpHubTestSuite results>],
+            "HarpLickometerRight": [<HarpLicketySplitTestSuite results>],
+            "DynamicForaging": [<DynamicForagingQcSuite results>],
+        }
+
+    Each result becomes a metric named ``"<suite_name>::<test_name>"`` tagged
+    with both its suite and group, e.g. a ``ContractTestSuite`` result in the
+    ``"Data contract"`` group yields::
+
+        name = "ContractTestSuite::test_no_load_errors"
+        tags = {"test_suite": "ContractTestSuite", "ContractTestSuite": "Data contract"}
+    """
+    metrics: t.List[QCMetric] = []
+    for group, group_results in results.items():
+        group_name = group if group is not None else NO_GROUP
+        for result in group_results:
+            status = QCStatus(
+                evaluator="Automated",
+                status=STATUS_CONVERTER[result.status],
+                timestamp=now_utc(),
+            )
+            metrics.append(
+                QCMetric(
+                    name=f"{result.suite_name}::{result.test_name}",
+                    modality=Modality.BEHAVIOR,
+                    stage=Stage.RAW,
+                    value=to_builtin(result.result),
+                    status_history=[status],
+                    description=f"Test: {result.description} // Message: {result.message}",
+                    reference=_save_asset(result, results_folder),
+                    tags={"test_suite": result.suite_name, result.suite_name: group_name},
+                )
+            )
+    return metrics
+
+
+def contract_qc_metrics(
+    dataset: contract.Dataset, results_folder: t.Optional[str] = None
+) -> t.List[QCMetric]:
+    """Run the dynamic foraging contract QA over a dataset and convert results.
+
+    Parameters
+    ----------
+    dataset : contraqctor.contract.Dataset
+        A dynamic foraging dataset (e.g. ``RawDataLoader.dataset``).
+    results_folder : str, optional
+        Directory to save figure assets into. If ``None``, assets are skipped.
+
+    Returns
+    -------
+    list of QCMetric
+        Converted QA metrics for every suite the runner wires up.
+    """
+    runner = make_qc_runner(dataset)
+    return results_to_metrics(runner.run_all(), results_folder)
diff --git a/src/dynamic_foraging_processing/qc/raw/stage.py b/src/dynamic_foraging_processing/qc/raw/stage.py
new file mode 100644
index 0000000..0bbf73f
--- /dev/null
+++ b/src/dynamic_foraging_processing/qc/raw/stage.py
@@ -0,0 +1,41 @@
+"""Raw-data QC stage.
+
+``RawQC`` wraps the ``contraqctor``-based contract QA (Harp devices, cameras,
+CSV streams, the data contract, task-specific checks) into the ``BaseQC``
+interface. It is a thin wrapper over :func:`contract_qc_metrics`; the metric
+computation lives there.
+"""
+
+import typing as t
+
+from aind_data_schema.core.quality_control import QCMetric
+from contraqctor import contract
+
+from dynamic_foraging_processing.qc._core.base import BaseQC
+from dynamic_foraging_processing.qc.raw.contract_qa import contract_qc_metrics
+
+
+class RawQC(BaseQC):
+    """Contract QA over a loaded raw dynamic foraging dataset."""
+
+    def run(
+        self,
+        acquisition: contract.Dataset,
+        results_folder: t.Optional[str] = None,
+    ) -> t.List[QCMetric]:
+        """Run the contract QA over ``acquisition`` and return its metrics.
+
+        Parameters
+        ----------
+        acquisition : contraqctor.contract.Dataset
+            A loaded dynamic foraging dataset (e.g. ``RawDataLoader.dataset``).
+        results_folder : str, optional
+            Directory to save figure assets into. If ``None``, assets are
+            skipped.
+
+        Returns
+        -------
+        list of QCMetric
+            Converted QA metrics for every suite the runner wires up.
+        """
+        return contract_qc_metrics(acquisition, results_folder)
diff --git a/tests/test_qc/__init__.py b/tests/test_qc/__init__.py
new file mode 100644
index 0000000..d824779
--- /dev/null
+++ b/tests/test_qc/__init__.py
@@ -0,0 +1 @@
+"""Tests for the ``qc`` package."""
diff --git a/tests/test_qc/test_behavior.py b/tests/test_qc/test_behavior.py
new file mode 100644
index 0000000..75733c9
--- /dev/null
+++ b/tests/test_qc/test_behavior.py
@@ -0,0 +1,78 @@
+"""Tests for ``dynamic_foraging_processing.qc.processed.behavior``."""
+
+import numpy as np
+import pytest
+
+from dynamic_foraging_processing.qc.processed import behavior as _behavior
+
+
+def test_calculate_lick_intervals_both_empty():
+    """No licks on either side yields zeroed percentages."""
+    result = _behavior.calculate_lick_intervals(np.array([]), np.array([]))
+    assert result["ArtifactPercent"] == 0.0
+    assert result["LeftLickIntervalPercent"] == 0.0
+    assert result["RightLickIntervalPercent"] == 0.0
+    assert result["CrossSideIntervalPercent"] == 0.0
+    assert result["SameSideIntervalPercent"] == 0.0
+
+
+def test_calculate_lick_intervals_single_side_only():
+    """Licks on one side only skip the cross-side computation."""
+    result = _behavior.calculate_lick_intervals(np.array([1.0]), np.array([]))
+    # Single left lick: len(left) > 1 is False, right empty.
+    assert result["LeftLickIntervalPercent"] == 0.0
+    assert result["RightLickIntervalPercent"] == 0.0
+    assert result["CrossSideIntervalPercent"] == 0.0
+
+
+def test_calculate_lick_intervals_fast_and_cross_side():
+    """Fast same-side and cross-side intervals are counted as percentages."""
+    left = np.array([1.0, 1.01, 5.0])  # one fast left interval
+    right = np.array([1.005, 1.02, 6.0])  # interleaved with left -> cross-side
+    result = _behavior.calculate_lick_intervals(left, right)
+    assert result["LeftLickIntervalPercent"] > 0
+    assert result["RightLickIntervalPercent"] > 0
+    assert result["CrossSideIntervalPercent"] > 0
+    # Sub-millisecond artifacts: none here.
+    assert result["ArtifactPercent"] == 0.0
+
+
+def test_calculate_lick_intervals_detects_artifacts():
+    """Sub-0.5ms gaps between licks count toward ArtifactPercent."""
+    result = _behavior.calculate_lick_intervals(np.array([1.0, 1.0001]), np.array([2.0]))
+    assert result["ArtifactPercent"] > 0
+
+
+def test_side_bias_result_pass_and_fail():
+    """Side-bias result averages the column; passes under 0.5 absolute bias."""
+    passing = _behavior.side_bias_result(np.array([-0.2, 0.1, np.nan, 0.1]))
+    assert passing.passed is True
+    assert passing.value == pytest.approx(0.0)
+    assert passing.reference == _behavior.SIDE_BIAS_PLOT
+    assert passing.tags == {"behavior": "average side bias"}
+
+    failing = _behavior.side_bias_result(np.array([0.8, 0.9, 1.0]))
+    assert failing.passed is False
+    assert failing.value == pytest.approx(0.9)
+
+    no_response = _behavior.side_bias_result(np.array([np.nan, np.nan]))
+    assert no_response.passed is False
+    assert np.isnan(no_response.value)
+
+    empty = _behavior.side_bias_result(np.array([]))
+    assert empty.passed is False
+    assert np.isnan(empty.value)
+
+
+def test_lick_interval_results_names_and_count():
+    """Four lick-interval results are produced with the expected names/tags."""
+    results = _behavior.lick_interval_results(np.array([1.0, 1.01]), np.array([2.0, 2.01]))
+    names = [r.name for r in results]
+    assert names == [
+        "Left Lick Interval (%)",
+        "Right Lick Interval (%)",
+        "Cross Side Lick Interval (%)",
+        "Artifact Percent (%)",
+    ]
+    assert all(r.reference == _behavior.LICK_INTERVALS_PLOT for r in results)
+    assert all(r.tags == {"behavior": r.name} for r in results)
diff --git a/tests/test_qc/test_builder.py b/tests/test_qc/test_builder.py
new file mode 100644
index 0000000..69507e8
--- /dev/null
+++ b/tests/test_qc/test_builder.py
@@ -0,0 +1,84 @@
+"""Tests for ``dynamic_foraging_processing.qc._core.builder`` and
+``dynamic_foraging_processing.qc.processed.results``."""
+
+import os
+
+import numpy as np
+import pandas as pd
+from aind_data_schema.core.quality_control import QualityControl
+
+from dynamic_foraging_processing.qc._core import builder as _builder
+from dynamic_foraging_processing.qc._core.result import to_metrics
+from dynamic_foraging_processing.qc.processed import results as _results
+
+
+def test_behavior_qc_results_without_plots():
+    """Five behavior results are produced and no plots are written."""
+    trials = pd.DataFrame(
+        {
+            "animal_response": [0, 1, 2, 1],
+            "side_bias": [-0.1, 0.0, np.nan, 0.1],
+        }
+    )
+    results = _results.behavior_qc_results(
+        trials,
+        np.array([1.0, 1.01]),
+        np.array([2.0, 2.01]),
+    )
+    assert len(results) == 5
+    assert results[0].name == "average side bias"
+
+
+def test_behavior_qc_results_writes_plots(tmp_path):
+    """Supplying a results folder writes both behavior plots."""
+    trials = pd.DataFrame(
+        {
+            "animal_response": [0, 1, 2, 1],
+            "side_bias": [-0.1, 0.0, np.nan, 0.1],
+        }
+    )
+    results = _results.behavior_qc_results(
+        trials,
+        np.array([1.0, 1.01]),
+        np.array([2.0, 2.01]),
+        str(tmp_path),
+    )
+    assert len(results) == 5
+    assert os.path.exists(tmp_path / "side_bias.png")
+    assert os.path.exists(tmp_path / "lick_intervals.png")
+
+
+def test_build_quality_control_defaults():
+    """Defaults fill in the standard grouping and an empty failure allowlist."""
+    metrics = to_metrics(
+        _results.behavior_qc_results(
+            pd.DataFrame({"animal_response": [0, 1], "side_bias": [0.1, -0.1]}),
+            np.array([1.0]),
+            np.array([2.0]),
+        )
+    )
+    qc = _builder.build_quality_control(metrics)
+    assert isinstance(qc, QualityControl)
+    assert qc.default_grouping == _builder.DEFAULT_GROUPING
+    assert qc.allow_tag_failures == []
+
+
+def test_build_quality_control_overrides():
+    """Explicit grouping / allowlist / metadata are passed through."""
+    metrics = to_metrics(
+        _results.behavior_qc_results(
+            pd.DataFrame({"animal_response": [0, 1], "side_bias": [0.1, -0.1]}),
+            np.array([1.0]),
+            np.array([2.0]),
+        )
+    )
+    qc = _builder.build_quality_control(
+        metrics,
+        default_grouping=["behavior"],
+        allow_tag_failures=["behavior"],
+        key_experimenters=["Alex"],
+        notes="hello",
+    )
+    assert qc.default_grouping == ["behavior"]
+    assert qc.allow_tag_failures == ["behavior"]
+    assert qc.notes == "hello"
diff --git a/tests/test_qc/test_contract_qa.py b/tests/test_qc/test_contract_qa.py
new file mode 100644
index 0000000..199e427
--- /dev/null
+++ b/tests/test_qc/test_contract_qa.py
@@ -0,0 +1,101 @@
+"""Tests for ``dynamic_foraging_processing.qc.raw.contract_qa``."""
+
+import os
+
+import matplotlib
+
+matplotlib.use("Agg")
+
+import matplotlib.pyplot as plt
+from contraqctor import qc as cqc
+
+from dynamic_foraging_processing.qc.raw import contract_qa as _contract_qa
+
+
+def _result(
+    status, *, suite="SuiteA", test="test_x", context=None, value=1, message="m", description="d"
+):
+    """Build a contraqctor ``Result`` for testing."""
+    return cqc.Result(
+        status=status,
+        result=value,
+        test_name=test,
+        suite_name=suite,
+        message=message,
+        description=description,
+        context=context,
+    )
+
+
+def test_sanitize_replaces_unsafe_characters():
+    """Non-filename-safe characters collapse to underscores."""
+    assert _contract_qa._sanitize("Harp Hub::test 1") == "Harp_Hub_test_1"
+
+
+def test_save_asset_non_dict_context_returns_none(tmp_path):
+    """A result with no dict context saves nothing."""
+    assert _contract_qa._save_asset(_result(cqc.Status.PASSED), str(tmp_path)) is None
+
+
+def test_save_asset_non_figure_asset_returns_none(tmp_path):
+    """A non-figure asset saves nothing."""
+    result = _result(cqc.Status.PASSED, context={"asset": "not-a-figure"})
+    assert _contract_qa._save_asset(result, str(tmp_path)) is None
+
+
+def test_save_asset_figure_without_folder_returns_none():
+    """A figure asset with no results folder saves nothing."""
+    fig = plt.figure()
+    result = _result(cqc.Status.PASSED, context={"asset": fig})
+    assert _contract_qa._save_asset(result, None) is None
+    plt.close(fig)
+
+
+def test_save_asset_figure_is_saved(tmp_path):
+    """A figure asset is written and its filename returned."""
+    fig = plt.figure()
+    result = _result(cqc.Status.PASSED, suite="S", test="t", context={"asset": fig})
+    name = _contract_qa._save_asset(result, str(tmp_path))
+    assert name == "S_t.png"
+    assert os.path.exists(tmp_path / name)
+    plt.close(fig)
+
+
+def test_results_to_metrics_grouping_and_status(tmp_path):
+    """Results convert to tagged metrics; missing group becomes ``NoGroup``."""
+    fig = plt.figure()
+    results = {
+        "Data contract": [
+            _result(cqc.Status.WARNING, suite="HubSuite", test="t1", context={"asset": fig})
+        ],
+        None: [_result(cqc.Status.FAILED, suite="CamSuite", test="t2")],
+    }
+    metrics = _contract_qa.results_to_metrics(results, str(tmp_path))
+    plt.close(fig)
+
+    by_name = {m.name: m for m in metrics}
+    warn = by_name["HubSuite::t1"]
+    assert warn.status_history[0].status == "Pending"
+    assert warn.tags == {"test_suite": "HubSuite", "HubSuite": "Data contract"}
+    assert warn.reference == "HubSuite_t1.png"
+
+    fail = by_name["CamSuite::t2"]
+    assert fail.status_history[0].status == "Fail"
+    assert fail.tags == {"test_suite": "CamSuite", "CamSuite": _contract_qa.NO_GROUP}
+    assert fail.reference is None
+
+
+def test_contract_qc_metrics_uses_runner(monkeypatch, tmp_path):
+    """``contract_qc_metrics`` runs the runner and converts its results."""
+
+    class _FakeRunner:
+        """Stand-in runner returning a fixed grouped-results dict."""
+
+        def run_all(self):
+            """Return one passing result under a single group."""
+            return {"grp": [_result(cqc.Status.PASSED, suite="S", test="t")]}
+
+    monkeypatch.setattr(_contract_qa, "make_qc_runner", lambda dataset: _FakeRunner())
+    metrics = _contract_qa.contract_qc_metrics(dataset=object(), results_folder=str(tmp_path))
+    assert [m.name for m in metrics] == ["S::t"]
+    assert metrics[0].status_history[0].status == "Pass"
diff --git a/tests/test_qc/test_plots.py b/tests/test_qc/test_plots.py
new file mode 100644
index 0000000..5109f59
--- /dev/null
+++ b/tests/test_qc/test_plots.py
@@ -0,0 +1,65 @@
+"""Tests for ``dynamic_foraging_processing.qc.processed.plots``."""
+
+import os
+
+import numpy as np
+
+from dynamic_foraging_processing.qc.processed import plots as _plots
+
+
+def test_plot_lick_intervals_writes_file(tmp_path):
+    """The lick-interval histogram is written and its filename returned."""
+    name = _plots.plot_lick_intervals(
+        np.array([1.0, 1.01, 2.0]), np.array([1.5, 1.6]), str(tmp_path)
+    )
+    assert name == _plots.LICK_INTERVALS_PLOT
+    assert os.path.exists(tmp_path / name)
+
+
+def test_time_to_trial_index_covers_all_branches():
+    """Empty go cues and early/late event times map to the right indices."""
+    # No go cues -> every event maps to -1.
+    assert _plots._time_to_trial_index(np.array([]), np.array([1.0])) == [-1]
+    # Event before first go cue -> -1; later events -> preceding cue index.
+    result = _plots._time_to_trial_index(np.array([1.0, 2.0, 3.0]), np.array([0.5, 2.5]))
+    assert result == [-1, 1]
+
+
+def test_plot_side_bias_full_inputs(tmp_path):
+    """All optional panels render when every per-trial array is supplied."""
+    animal_response = np.array([0, 1, 2, 1, 0, 1])
+    side_bias = np.array([-0.2, 0.0, np.nan, 0.3, 0.1, 0.2])
+    name = _plots.plot_side_bias(
+        animal_response,
+        side_bias,
+        str(tmp_path),
+        lickspout_x=np.array([1.0, 1.1, 1.0, 1.2, 1.1, 1.0]),
+        lickspout_y1=np.array([2.0, 2.0, 2.1, 2.0, 2.0, 2.1]),
+        lickspout_y2=np.array([3.0, 3.1, 3.0, 3.1, 3.0, 3.1]),
+        lickspout_z=np.array([4.0, 4.0, 4.0, 4.1, 4.0, 4.0]),
+        rewarded_left=np.array([True, False, False, False, True, False]),
+        rewarded_right=np.array([False, True, False, True, False, True]),
+        reward_probability_left=np.array([0.5, 0.6, 0.4, 0.5, 0.5, 0.6]),
+        reward_probability_right=np.array([0.5, 0.4, 0.6, 0.5, 0.5, 0.4]),
+        go_cue_times=np.array([0.5, 1.5, 2.5, 3.5, 4.5, 5.5]),
+        autowater_left=np.array([1, 0, 0, 0, 0, 0]),
+        autowater_right=np.array([0, 0, 0, 1, 0, 0]),
+        manual_left_times=np.array([0.1, 3.6]),  # 0.1 -> -1, 3.6 -> trial index
+        manual_right_times=np.array([5.6]),
+    )
+    assert name == _plots.SIDE_BIAS_PLOT
+    assert os.path.exists(tmp_path / name)
+
+
+def test_plot_side_bias_minimal_inputs(tmp_path):
+    """With only choices supplied, the optional panels are skipped cleanly."""
+    name = _plots.plot_side_bias(np.array([]), np.array([]), str(tmp_path))
+    assert os.path.exists(tmp_path / name)
+
+
+def test_plot_side_bias_empty_position_array(tmp_path):
+    """An empty lickspout-position array is skipped without plotting."""
+    name = _plots.plot_side_bias(
+        np.array([0, 1]), np.array([0.1, -0.1]), str(tmp_path), lickspout_x=np.array([])
+    )
+    assert os.path.exists(tmp_path / name)
diff --git a/tests/test_qc/test_result.py b/tests/test_qc/test_result.py
new file mode 100644
index 0000000..23f4753
--- /dev/null
+++ b/tests/test_qc/test_result.py
@@ -0,0 +1,47 @@
+"""Tests for ``dynamic_foraging_processing.qc._core.result``."""
+
+from dynamic_foraging_processing.qc._core import result as _result
+
+
+def _result_obj(passed=True):
+    """Build a simple QCResult for conversion tests."""
+    return _result.QCResult(
+        name="m",
+        value=0.25,
+        passed=passed,
+        description="d",
+        reference="r.png",
+        tags={"behavior": "m"},
+    )
+
+
+def test_to_metric_carries_fields_and_status():
+    """``to_metric`` produces a QCMetric with the result's fields and status."""
+    metric = _result_obj(passed=True).to_metric()
+    assert metric.name == "m"
+    assert metric.value == 0.25
+    assert metric.reference == "r.png"
+    assert metric.tags == {"behavior": "m"}
+    assert metric.status_history[0].status == "Pass"
+
+
+def test_to_metric_failing_status():
+    """A failing result converts to a failing metric."""
+    assert _result_obj(passed=False).to_metric().status_history[0].status == "Fail"
+
+
+def test_to_metrics_converts_each_result():
+    """``to_metrics`` converts a sequence of results into metrics."""
+    metrics = _result.to_metrics([_result_obj(True), _result_obj(False)])
+    assert [m.status_history[0].status for m in metrics] == ["Pass", "Fail"]
+
+
+def test_qc_result_is_frozen():
+    """``QCResult`` is immutable."""
+    result = _result_obj()
+    try:
+        result.passed = False
+    except Exception as exc:  # FrozenInstanceError
+        assert "cannot assign" in str(exc) or "frozen" in str(exc).lower()
+    else:  # pragma: no cover
+        raise AssertionError("QCResult should be frozen")
diff --git a/tests/test_qc/test_schema.py b/tests/test_qc/test_schema.py
new file mode 100644
index 0000000..ab017ed
--- /dev/null
+++ b/tests/test_qc/test_schema.py
@@ -0,0 +1,70 @@
+"""Tests for ``dynamic_foraging_processing.qc._core.schema``."""
+
+import datetime
+
+import numpy as np
+from aind_data_schema.core.quality_control import Stage, Status
+from aind_data_schema_models.modalities import Modality
+from contraqctor import qc as cqc
+
+from dynamic_foraging_processing.qc._core import schema as _schema
+
+
+def test_status_converter_maps_all_contraqctor_statuses():
+    """Every contraqctor status maps to a schema status (warnings -> pending)."""
+    assert _schema.STATUS_CONVERTER[cqc.Status.PASSED] == Status.PASS
+    assert _schema.STATUS_CONVERTER[cqc.Status.SKIPPED] == Status.PASS
+    assert _schema.STATUS_CONVERTER[cqc.Status.WARNING] == Status.PENDING
+    assert _schema.STATUS_CONVERTER[cqc.Status.FAILED] == Status.FAIL
+    assert _schema.STATUS_CONVERTER[cqc.Status.ERROR] == Status.FAIL
+
+
+def test_now_helpers_are_timezone_aware():
+    """``now_seattle`` and ``now_utc`` return aware datetimes."""
+    assert _schema.now_seattle().tzinfo is not None
+    assert _schema.now_utc().utcoffset() == datetime.timedelta(0)
+
+
+def test_bool_to_status_pass_and_fail_with_default_timestamp():
+    """A truthy value yields PASS, falsy yields FAIL; timestamp defaults to now."""
+    passed = _schema.bool_to_status(True)
+    failed = _schema.bool_to_status(False)
+    assert passed.status == Status.PASS
+    assert failed.status == Status.FAIL
+    assert passed.evaluator == "Automated"
+    assert passed.timestamp.tzinfo is not None
+
+
+def test_bool_to_status_uses_supplied_timestamp():
+    """An explicit timestamp is passed through unchanged."""
+    ts = datetime.datetime(2026, 6, 11, tzinfo=datetime.timezone.utc)
+    assert _schema.bool_to_status(True, ts).timestamp == ts
+
+
+def test_to_builtin_converts_numpy_types():
+    """Arrays become lists, numpy scalars become builtins, others pass through."""
+    assert _schema.to_builtin(np.array([1, 2])) == [1, 2]
+    assert _schema.to_builtin(np.float64(1.5)) == 1.5
+    assert isinstance(_schema.to_builtin(np.int64(3)), int)
+    assert _schema.to_builtin("text") == "text"
+
+
+def test_make_metric_defaults_and_overrides():
+    """``make_metric`` stamps modality/stage and defaults tags to ``{}``."""
+    status = _schema.bool_to_status(True)
+    default = _schema.make_metric(name="m", value=np.float64(2.0), status=status)
+    assert default.modality == Modality.BEHAVIOR
+    assert default.stage == Stage.RAW
+    assert default.tags == {}
+    assert default.value == 2.0
+
+    tagged = _schema.make_metric(
+        name="m",
+        value=1,
+        status=status,
+        description="d",
+        reference="r.png",
+        tags={"behavior": "m"},
+    )
+    assert tagged.tags == {"behavior": "m"}
+    assert tagged.reference == "r.png"
diff --git a/tests/test_qc/test_stages.py b/tests/test_qc/test_stages.py
new file mode 100644
index 0000000..11d23bd
--- /dev/null
+++ b/tests/test_qc/test_stages.py
@@ -0,0 +1,71 @@
+"""Tests for the QC stage wrappers (``BaseQC``, ``RawQC``, ``ProcessedQC``)."""
+
+import os
+
+import numpy as np
+import pandas as pd
+import pytest
+from aind_data_schema.core.quality_control import QCMetric
+
+from dynamic_foraging_processing.qc._core.base import BaseQC
+from dynamic_foraging_processing.qc.processed.stage import ProcessedQC
+from dynamic_foraging_processing.qc.raw import stage as raw_stage
+from dynamic_foraging_processing.qc.raw.stage import RawQC
+
+
+def test_base_qc_run_raises_not_implemented():
+    """The base ``run`` body raises ``NotImplementedError`` when delegated to."""
+
+    class _Stage(BaseQC):
+        """Concrete stage that defers to the base implementation."""
+
+        def run(self, *args, **kwargs):
+            """Delegate to ``BaseQC.run`` so its body executes."""
+            return super().run(*args, **kwargs)
+
+    with pytest.raises(NotImplementedError):
+        _Stage().run()
+
+
+def test_raw_qc_run_delegates_to_contract_metrics(monkeypatch):
+    """``RawQC.run`` forwards the dataset and folder to ``contract_qc_metrics``."""
+    captured = {}
+
+    def _fake_contract_qc_metrics(dataset, results_folder):
+        """Record arguments and return a sentinel metric list."""
+        captured["dataset"] = dataset
+        captured["results_folder"] = results_folder
+        return ["sentinel"]
+
+    monkeypatch.setattr(raw_stage, "contract_qc_metrics", _fake_contract_qc_metrics)
+    dataset = object()
+    result = RawQC().run(dataset, "out")
+    assert result == ["sentinel"]
+    assert captured == {"dataset": dataset, "results_folder": "out"}
+
+
+def test_processed_qc_run_returns_metrics():
+    """``ProcessedQC.run`` produces the five behavior metrics."""
+    trials = pd.DataFrame({"animal_response": [0, 1, 2, 1], "side_bias": [-0.1, 0.0, np.nan, 0.1]})
+    metrics = ProcessedQC().run(
+        trials,
+        np.array([1.0, 1.01]),
+        np.array([2.0, 2.01]),
+    )
+    assert len(metrics) == 5
+    assert all(isinstance(m, QCMetric) for m in metrics)
+    assert metrics[0].name == "average side bias"
+
+
+def test_processed_qc_run_writes_plots(tmp_path):
+    """Supplying a results folder writes the supporting plots."""
+    trials = pd.DataFrame({"animal_response": [0, 1, 2, 1], "side_bias": [-0.1, 0.0, np.nan, 0.1]})
+    metrics = ProcessedQC().run(
+        trials,
+        np.array([1.0, 1.01]),
+        np.array([2.0, 2.01]),
+        str(tmp_path),
+    )
+    assert len(metrics) == 5
+    assert os.path.exists(tmp_path / "side_bias.png")
+    assert os.path.exists(tmp_path / "lick_intervals.png")
diff --git a/uv.lock b/uv.lock
index 5b4d73e..ed89671 100644
--- a/uv.lock
+++ b/uv.lock
@@ -67,6 +67,35 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/bc/bf/423d28364d564008a33d40d7aad1fbbed5e028b5bda39ed5cafc41651d7e/aind_behavior_services-0.13.7-py3-none-any.whl", hash = "sha256:ab57927ce283cb07a47c4b02eecee8038421f8292c5efbeeaaf907fd6a69eb08", size = 39614, upload-time = "2026-04-18T22:20:02.941Z" },
 ]
 
+[[package]]
+name = "aind-data-schema"
+version = "2.8.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "aind-data-schema-models" },
+    { name = "pydantic" },
+    { name = "pydantic-extra-types" },
+    { name = "tzdata" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/1b/4d/6e1a5175da36d65c0467cab77bc508b7a4b9de4f27f9e6385288cdbece08/aind_data_schema-2.8.1.tar.gz", hash = "sha256:5f3dc809765bd25f27b667d1496499b1a5601c75e89e3804ccb2b0609f8ab84a", size = 960610, upload-time = "2026-06-09T16:15:45.62Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4c/d2/84fe4192caceb64a3f12d02d25aa3f25d7cf019d58890a24c75ab33c8791/aind_data_schema-2.8.1-py3-none-any.whl", hash = "sha256:71ea58072250719858cd8727bae3a8d974bfccd54b7e37aba21161172b54be41", size = 93863, upload-time = "2026-06-09T16:15:44.154Z" },
+]
+
+[[package]]
+name = "aind-data-schema-models"
+version = "5.7.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "importlib-resources" },
+    { name = "pydantic" },
+    { name = "requests" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/2a/4f/9b3c124c7b43bc0318b247c933ad945d0613f3f6088290db3542bbdf97fa/aind_data_schema_models-5.7.3.tar.gz", hash = "sha256:d68db456c0ce0aafa9b7f4da2f2c0e0925c724d1a4f1a509ca43e3a5f945a92c", size = 342029, upload-time = "2026-06-04T03:59:01.784Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/45/1a/b4706006fb390d4e64e1df6e9137683aca082e754b79d91e488c756bbf59/aind_data_schema_models-5.7.3-py3-none-any.whl", hash = "sha256:cd7c1a311338aeecfc1463ac069ef34db67f15508be17daa47d6155a00f1cbe0", size = 310756, upload-time = "2026-06-04T03:59:00.492Z" },
+]
+
 [[package]]
 name = "alabaster"
 version = "1.0.0"
@@ -534,6 +563,16 @@ dependencies = [
     { name = "ipykernel" },
 ]
 
+[package.optional-dependencies]
+full = [
+    { name = "aind-data-schema" },
+    { name = "matplotlib" },
+]
+qc = [
+    { name = "aind-data-schema" },
+    { name = "matplotlib" },
+]
+
 [package.dev-dependencies]
 dev = [
     { name = "coverage" },
@@ -546,9 +585,13 @@ dev = [
 
 [package.metadata]
 requires-dist = [
-    { name = "aind-behavior-dynamic-foraging", extras = ["data"], git = "https://github.com/AllenNeuralDynamics/Aind.Behavior.DynamicForaging.git?rev=v0.0.2" },
+    { name = "aind-behavior-dynamic-foraging", extras = ["data"], git = "https://github.com/AllenNeuralDynamics/Aind.Behavior.DynamicForaging.git?rev=v0.0.2rc27" },
+    { name = "aind-data-schema", marker = "extra == 'qc'", specifier = ">=2.4.1" },
+    { name = "dynamic-foraging-processing", extras = ["qc"], marker = "extra == 'full'" },
     { name = "ipykernel" },
+    { name = "matplotlib", marker = "extra == 'qc'" },
 ]
+provides-extras = ["qc", "full"]
 
 [package.metadata.requires-dev]
 dev = [
@@ -681,6 +724,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/5f/53/fb7122b71361a0d121b669dcf3d31244ef75badbbb724af388948de543e2/imagesize-2.0.0-py2.py3-none-any.whl", hash = "sha256:5667c5bbb57ab3f1fa4bc366f4fbc971db3d5ed011fd2715fd8001f782718d96", size = 9441, upload-time = "2026-03-03T14:18:27.892Z" },
 ]
 
+[[package]]
+name = "importlib-resources"
+version = "7.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e4/06/b56dfa750b44e86157093bc8fca0ab81dccbf5260510de4eaf1cb69b5b99/importlib_resources-7.1.0.tar.gz", hash = "sha256:0722d4c6212489c530f2a145a34c0a7a3b4721bc96a15fada5930e2a0b760708", size = 44985, upload-time = "2026-04-12T16:36:09.232Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8a/db/55a262f3606bebcae07cc14095338471ad7c0bbcaa37707e6f0ee49725b7/importlib_resources-7.1.0-py3-none-any.whl", hash = "sha256:1bd7b48b4088eddb2cd16382150bb515af0bd2c70128194392725f82ad2c96a1", size = 37232, upload-time = "2026-04-12T16:36:08.219Z" },
+]
+
 [[package]]
 name = "iniconfig"
 version = "2.3.0"
@@ -1406,7 +1458,7 @@ wheels = [
 
 [[package]]
 name = "pydantic"
-version = "2.13.4"
+version = "2.11.10"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "annotated-types" },
@@ -1414,84 +1466,64 @@ dependencies = [
     { name = "typing-extensions" },
     { name = "typing-inspection" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/18/a5/b60d21ac674192f8ab0ba4e9fd860690f9b4a6e51ca5df118733b487d8d6/pydantic-2.13.4.tar.gz", hash = "sha256:c40756b57adaa8b1efeeced5c196f3f3b7c435f90e84ea7f443901bec8099ef6", size = 844775, upload-time = "2026-05-06T13:43:05.343Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ae/54/ecab642b3bed45f7d5f59b38443dcb36ef50f85af192e6ece103dbfe9587/pydantic-2.11.10.tar.gz", hash = "sha256:dc280f0982fbda6c38fada4e476dc0a4f3aeaf9c6ad4c28df68a666ec3c61423", size = 788494, upload-time = "2025-10-04T10:40:41.338Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/fd/7b/122376b1fd3c62c1ed9dc80c931ace4844b3c55407b6fb2d199377c9736f/pydantic-2.13.4-py3-none-any.whl", hash = "sha256:45a282cde31d808236fd7ea9d919b128653c8b38b393d1c4ab335c62924d9aba", size = 472262, upload-time = "2026-05-06T13:43:02.641Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/1f/73c53fcbfb0b5a78f91176df41945ca466e71e9d9d836e5c522abda39ee7/pydantic-2.11.10-py3-none-any.whl", hash = "sha256:802a655709d49bd004c31e865ef37da30b540786a46bfce02333e0e24b5fe29a", size = 444823, upload-time = "2025-10-04T10:40:39.055Z" },
 ]
 
 [[package]]
 name = "pydantic-core"
-version = "2.46.4"
+version = "2.33.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ad/88/5f2260bdfae97aabf98f1778d43f69574390ad787afb646292a638c923d4/pydantic_core-2.33.2.tar.gz", hash = "sha256:7cb8bc3605c29176e1b105350d2e6474142d7c1bd1d9327c4a9bdb46bf827acc", size = 435195, upload-time = "2025-04-23T18:33:52.104Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/8a/2b41c97f554ec8c71f2a8a5f85cb56a8b0956addfe8b0efb5b3d77e8bdc3/pydantic_core-2.33.2-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:a7ec89dc587667f22b6a0b6579c249fca9026ce7c333fc142ba42411fa243cdc", size = 2009000, upload-time = "2025-04-23T18:31:25.863Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/02/6224312aacb3c8ecbaa959897af57181fb6cf3a3d7917fd44d0f2917e6f2/pydantic_core-2.33.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3c6db6e52c6d70aa0d00d45cdb9b40f0433b96380071ea80b09277dba021ddf7", size = 1847996, upload-time = "2025-04-23T18:31:27.341Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/46/6dcdf084a523dbe0a0be59d054734b86a981726f221f4562aed313dbcb49/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e61206137cbc65e6d5256e1166f88331d3b6238e082d9f74613b9b765fb9025", size = 1880957, upload-time = "2025-04-23T18:31:28.956Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/6b/1ec2c03837ac00886ba8160ce041ce4e325b41d06a034adbef11339ae422/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:eb8c529b2819c37140eb51b914153063d27ed88e3bdc31b71198a198e921e011", size = 1964199, upload-time = "2025-04-23T18:31:31.025Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/1d/6bf34d6adb9debd9136bd197ca72642203ce9aaaa85cfcbfcf20f9696e83/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c52b02ad8b4e2cf14ca7b3d918f3eb0ee91e63b3167c32591e57c4317e134f8f", size = 2120296, upload-time = "2025-04-23T18:31:32.514Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/94/2bd0aaf5a591e974b32a9f7123f16637776c304471a0ab33cf263cf5591a/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:96081f1605125ba0855dfda83f6f3df5ec90c61195421ba72223de35ccfb2f88", size = 2676109, upload-time = "2025-04-23T18:31:33.958Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/41/4b043778cf9c4285d59742281a769eac371b9e47e35f98ad321349cc5d61/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f57a69461af2a5fa6e6bbd7a5f60d3b7e6cebb687f55106933188e79ad155c1", size = 2002028, upload-time = "2025-04-23T18:31:39.095Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/d5/7bb781bf2748ce3d03af04d5c969fa1308880e1dca35a9bd94e1a96a922e/pydantic_core-2.33.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:572c7e6c8bb4774d2ac88929e3d1f12bc45714ae5ee6d9a788a9fb35e60bb04b", size = 2100044, upload-time = "2025-04-23T18:31:41.034Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/36/def5e53e1eb0ad896785702a5bbfd25eed546cdcf4087ad285021a90ed53/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:db4b41f9bd95fbe5acd76d89920336ba96f03e149097365afe1cb092fceb89a1", size = 2058881, upload-time = "2025-04-23T18:31:42.757Z" },
+    { url = "https://files.pythonhosted.org/packages/01/6c/57f8d70b2ee57fc3dc8b9610315949837fa8c11d86927b9bb044f8705419/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:fa854f5cf7e33842a892e5c73f45327760bc7bc516339fda888c75ae60edaeb6", size = 2227034, upload-time = "2025-04-23T18:31:44.304Z" },
+    { url = "https://files.pythonhosted.org/packages/27/b9/9c17f0396a82b3d5cbea4c24d742083422639e7bb1d5bf600e12cb176a13/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:5f483cfb75ff703095c59e365360cb73e00185e01aaea067cd19acffd2ab20ea", size = 2234187, upload-time = "2025-04-23T18:31:45.891Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/6a/adf5734ffd52bf86d865093ad70b2ce543415e0e356f6cacabbc0d9ad910/pydantic_core-2.33.2-cp312-cp312-win32.whl", hash = "sha256:9cb1da0f5a471435a7bc7e439b8a728e8b61e59784b2af70d7c169f8dd8ae290", size = 1892628, upload-time = "2025-04-23T18:31:47.819Z" },
+    { url = "https://files.pythonhosted.org/packages/43/e4/5479fecb3606c1368d496a825d8411e126133c41224c1e7238be58b87d7e/pydantic_core-2.33.2-cp312-cp312-win_amd64.whl", hash = "sha256:f941635f2a3d96b2973e867144fde513665c87f13fe0e193c158ac51bfaaa7b2", size = 1955866, upload-time = "2025-04-23T18:31:49.635Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/24/8b11e8b3e2be9dd82df4b11408a67c61bb4dc4f8e11b5b0fc888b38118b5/pydantic_core-2.33.2-cp312-cp312-win_arm64.whl", hash = "sha256:cca3868ddfaccfbc4bfb1d608e2ccaaebe0ae628e1416aeb9c4d88c001bb45ab", size = 1888894, upload-time = "2025-04-23T18:31:51.609Z" },
+    { url = "https://files.pythonhosted.org/packages/46/8c/99040727b41f56616573a28771b1bfa08a3d3fe74d3d513f01251f79f172/pydantic_core-2.33.2-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:1082dd3e2d7109ad8b7da48e1d4710c8d06c253cbc4a27c1cff4fbcaa97a9e3f", size = 2015688, upload-time = "2025-04-23T18:31:53.175Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/cc/5999d1eb705a6cefc31f0b4a90e9f7fc400539b1a1030529700cc1b51838/pydantic_core-2.33.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f517ca031dfc037a9c07e748cefd8d96235088b83b4f4ba8939105d20fa1dcd6", size = 1844808, upload-time = "2025-04-23T18:31:54.79Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/5e/a0a7b8885c98889a18b6e376f344da1ef323d270b44edf8174d6bce4d622/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a9f2c9dd19656823cb8250b0724ee9c60a82f3cdf68a080979d13092a3b0fef", size = 1885580, upload-time = "2025-04-23T18:31:57.393Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/2a/953581f343c7d11a304581156618c3f592435523dd9d79865903272c256a/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2b0a451c263b01acebe51895bfb0e1cc842a5c666efe06cdf13846c7418caa9a", size = 1973859, upload-time = "2025-04-23T18:31:59.065Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/55/f1a813904771c03a3f97f676c62cca0c0a4138654107c1b61f19c644868b/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1ea40a64d23faa25e62a70ad163571c0b342b8bf66d5fa612ac0dec4f069d916", size = 2120810, upload-time = "2025-04-23T18:32:00.78Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/c3/053389835a996e18853ba107a63caae0b9deb4a276c6b472931ea9ae6e48/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0fb2d542b4d66f9470e8065c5469ec676978d625a8b7a363f07d9a501a9cb36a", size = 2676498, upload-time = "2025-04-23T18:32:02.418Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/3c/f4abd740877a35abade05e437245b192f9d0ffb48bbbbd708df33d3cda37/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9fdac5d6ffa1b5a83bca06ffe7583f5576555e6c8b3a91fbd25ea7780f825f7d", size = 2000611, upload-time = "2025-04-23T18:32:04.152Z" },
+    { url = "https://files.pythonhosted.org/packages/59/a7/63ef2fed1837d1121a894d0ce88439fe3e3b3e48c7543b2a4479eb99c2bd/pydantic_core-2.33.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:04a1a413977ab517154eebb2d326da71638271477d6ad87a769102f7c2488c56", size = 2107924, upload-time = "2025-04-23T18:32:06.129Z" },
+    { url = "https://files.pythonhosted.org/packages/04/8f/2551964ef045669801675f1cfc3b0d74147f4901c3ffa42be2ddb1f0efc4/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:c8e7af2f4e0194c22b5b37205bfb293d166a7344a5b0d0eaccebc376546d77d5", size = 2063196, upload-time = "2025-04-23T18:32:08.178Z" },
+    { url = "https://files.pythonhosted.org/packages/26/bd/d9602777e77fc6dbb0c7db9ad356e9a985825547dce5ad1d30ee04903918/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:5c92edd15cd58b3c2d34873597a1e20f13094f59cf88068adb18947df5455b4e", size = 2236389, upload-time = "2025-04-23T18:32:10.242Z" },
+    { url = "https://files.pythonhosted.org/packages/42/db/0e950daa7e2230423ab342ae918a794964b053bec24ba8af013fc7c94846/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:65132b7b4a1c0beded5e057324b7e16e10910c106d43675d9bd87d4f38dde162", size = 2239223, upload-time = "2025-04-23T18:32:12.382Z" },
+    { url = "https://files.pythonhosted.org/packages/58/4d/4f937099c545a8a17eb52cb67fe0447fd9a373b348ccfa9a87f141eeb00f/pydantic_core-2.33.2-cp313-cp313-win32.whl", hash = "sha256:52fb90784e0a242bb96ec53f42196a17278855b0f31ac7c3cc6f5c1ec4811849", size = 1900473, upload-time = "2025-04-23T18:32:14.034Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/75/4a0a9bac998d78d889def5e4ef2b065acba8cae8c93696906c3a91f310ca/pydantic_core-2.33.2-cp313-cp313-win_amd64.whl", hash = "sha256:c083a3bdd5a93dfe480f1125926afcdbf2917ae714bdb80b36d34318b2bec5d9", size = 1955269, upload-time = "2025-04-23T18:32:15.783Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/86/1beda0576969592f1497b4ce8e7bc8cbdf614c352426271b1b10d5f0aa64/pydantic_core-2.33.2-cp313-cp313-win_arm64.whl", hash = "sha256:e80b087132752f6b3d714f041ccf74403799d3b23a72722ea2e6ba2e892555b9", size = 1893921, upload-time = "2025-04-23T18:32:18.473Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/7d/e09391c2eebeab681df2b74bfe6c43422fffede8dc74187b2b0bf6fd7571/pydantic_core-2.33.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:61c18fba8e5e9db3ab908620af374db0ac1baa69f0f32df4f61ae23f15e586ac", size = 1806162, upload-time = "2025-04-23T18:32:20.188Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/3d/847b6b1fed9f8ed3bb95a9ad04fbd0b212e832d4f0f50ff4d9ee5a9f15cf/pydantic_core-2.33.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:95237e53bb015f67b63c91af7518a62a8660376a6a0db19b89acc77a4d6199f5", size = 1981560, upload-time = "2025-04-23T18:32:22.354Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/9a/e73262f6c6656262b5fdd723ad90f518f579b7bc8622e43a942eec53c938/pydantic_core-2.33.2-cp313-cp313t-win_amd64.whl", hash = "sha256:c2fc0a768ef76c15ab9238afa6da7f69895bb5d1ee83aeea2e3509af4472d0b9", size = 1935777, upload-time = "2025-04-23T18:32:25.088Z" },
+]
+
+[[package]]
+name = "pydantic-extra-types"
+version = "2.11.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
+    { name = "pydantic" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/9d/56/921726b776ace8d8f5db44c4ef961006580d91dc52b803c489fafd1aa249/pydantic_core-2.46.4.tar.gz", hash = "sha256:62f875393d7f270851f20523dd2e29f082bcc82292d66db2b64ea71f64b6e1c1", size = 471464, upload-time = "2026-05-06T13:37:06.98Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/ce/8c/af022f0af448d7747c5154288d46b5f2bc5f17366eaa0e23e9aa04d59f3b/pydantic_core-2.46.4-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:3245406455a5d98187ec35530fd772b1d799b26667980872c8d4614991e2c4a2", size = 2106158, upload-time = "2026-05-06T13:38:57.215Z" },
-    { url = "https://files.pythonhosted.org/packages/19/95/6195171e385007300f0f5574592e467c568becce2d937a0b6804f218bc49/pydantic_core-2.46.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:962ccbab7b642487b1d8b7df90ef677e03134cf1fd8880bf698649b22a69371f", size = 1951724, upload-time = "2026-05-06T13:37:02.697Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/bc/f47d1ff9cbb1620e1b5b697eef06010035735f07820180e74178226b27b3/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8233f2947cf85404441fd7e0085f53b10c93e0ee78611099b5c7237e36aacbf7", size = 1975742, upload-time = "2026-05-06T13:37:09.448Z" },
-    { url = "https://files.pythonhosted.org/packages/5b/11/9b9a5b0306345664a2da6410877af6e8082481b5884b3ddd78d47c6013ce/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3a233125ac121aa3ffba9a2b59edfc4a985a76092dc8279586ab4b71390875e7", size = 2052418, upload-time = "2026-05-06T13:37:38.234Z" },
-    { url = "https://files.pythonhosted.org/packages/f1/b7/a65fec226f5d78fc39f4a13c4cc0c768c22b113438f60c14adc9d2865038/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5b712b53160b79a5850310b912a5ef8e57e56947c8ad690c227f5c9d7e561712", size = 2232274, upload-time = "2026-05-06T13:38:27.753Z" },
-    { url = "https://files.pythonhosted.org/packages/68/f0/92039db98b907ef49269a8271f67db9cb78ae2fc68062ef7e4e77adb5f61/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9401557acd873c3a7f3eb9383edef8ac4968f9510e340f4808d427e75667e7b4", size = 2309940, upload-time = "2026-05-06T13:38:05.353Z" },
-    { url = "https://files.pythonhosted.org/packages/5f/97/2aab507d3d00ca626e8e57c1eac6a79e4e5fbcc63eb99733ff55d1717f65/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:926c9541b14b12b1681dca8a0b75feb510b06c6341b70a8e500c2fdcff837cce", size = 2094516, upload-time = "2026-05-06T13:39:10.577Z" },
-    { url = "https://files.pythonhosted.org/packages/22/37/a8aca44d40d737dde2bc05b3c6c07dff0de07ce6f82e9f3167aeaf4d5dea/pydantic_core-2.46.4-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:56cb4851bcaf3d117eddcef4fe66afd750a50274b0da8e22be256d10e5611987", size = 2136854, upload-time = "2026-05-06T13:40:22.59Z" },
-    { url = "https://files.pythonhosted.org/packages/24/99/fcef1b79238c06a8cbec70819ac722ba76e02bc8ada9b0fd66eba40da01b/pydantic_core-2.46.4-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c68fcd102d71ea85c5b2dfac3f4f8476eff42a9e078fd5faefff6d145063536b", size = 2180306, upload-time = "2026-05-06T13:40:10.666Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/6c/fc44000918855b42779d007ae63b0532794739027b2f417321cddbc44f6a/pydantic_core-2.46.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:b2f69dec1725e79a012d920df1707de5caf7ed5e08f3be4435e25803efc47458", size = 2190044, upload-time = "2026-05-06T13:40:43.231Z" },
-    { url = "https://files.pythonhosted.org/packages/6b/65/d9cadc9f1920d7a127ad2edba16c1db7916e59719285cd6c94600b0080ba/pydantic_core-2.46.4-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:8d0820e8192167f80d88d64038e609c31452eeca865b4e1d9950a27a4609b00b", size = 2329133, upload-time = "2026-05-06T13:39:57.365Z" },
-    { url = "https://files.pythonhosted.org/packages/d0/cf/c873d91679f3a30bcf5e7ac280ce5573483e72295307685120d0d5ad3416/pydantic_core-2.46.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:fbdb89b3e1c94a30cc5edfce477c6e6a5dc4d8f84665b455c27582f211a1c72c", size = 2374464, upload-time = "2026-05-06T13:38:06.976Z" },
-    { url = "https://files.pythonhosted.org/packages/47/bd/6f2fc8188f31bf10590f1e98e7b306336161fac930a8c514cd7bd828c7dc/pydantic_core-2.46.4-cp312-cp312-win32.whl", hash = "sha256:9aa768456404a8bf48a4406685ac2bec8e72b62c69313734fa3b73cf33b3a894", size = 1974823, upload-time = "2026-05-06T13:40:47.985Z" },
-    { url = "https://files.pythonhosted.org/packages/40/8c/985c1d41ea1107c2534abd9870e4ed5c8e7669b5c308297835c001e7a1c4/pydantic_core-2.46.4-cp312-cp312-win_amd64.whl", hash = "sha256:e9c26f834c65f5752f3f06cb08cb86a913ceb7274d0db6e267808a708b46bc89", size = 2072919, upload-time = "2026-05-06T13:39:21.153Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/ba/f463d006e0c47373ca7ec5e1a261c59dc01ef4d62b2657af925fb0deee3a/pydantic_core-2.46.4-cp312-cp312-win_arm64.whl", hash = "sha256:4fc73cb559bdb54b1134a706a2802a4cddd27a0633f5abb7e53056268751ac6a", size = 2027604, upload-time = "2026-05-06T13:39:03.753Z" },
-    { url = "https://files.pythonhosted.org/packages/51/a2/5d30b469c5267a17b39dec53208222f76a8d351dfac4af661888c5aee77d/pydantic_core-2.46.4-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:5d5902252db0d3cedf8d4a1bc68f70eeb430f7e4c7104c8c476753519b423008", size = 2106306, upload-time = "2026-05-06T13:37:48.029Z" },
-    { url = "https://files.pythonhosted.org/packages/c1/81/4fa520eaffa8bd7d1525e644cd6d39e7d60b1592bc5b516693c7340b50f1/pydantic_core-2.46.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:c94f0688e7b8d0a67abf40e57a7eaaecd17cc9586706a31b76c031f63df052b4", size = 1951906, upload-time = "2026-05-06T13:37:17.012Z" },
-    { url = "https://files.pythonhosted.org/packages/03/d5/fd02da45b659668b05923b17ba3a0100a0a3d5541e3bd8fcc4ecb711309e/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f027324c56cd5406ca49c124b0db10e56c69064fec039acc571c29020cc87c76", size = 1976802, upload-time = "2026-05-06T13:37:35.113Z" },
-    { url = "https://files.pythonhosted.org/packages/21/f2/95727e1368be3d3ed485eaab7adbd7dda408f33f7a36e8b48e0144002b91/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e739fee756ba1010f8bcccb534252e85a35fe45ae92c295a06059ce58b74ccd3", size = 2052446, upload-time = "2026-05-06T13:37:12.313Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/86/5d99feea3f77c7234b8718075b23db11532773c1a0dbd9b9490215dc2eeb/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9d56801be94b86a9da183e5f3766e6310752b99ff647e38b09a9500d88e46e76", size = 2232757, upload-time = "2026-05-06T13:39:01.149Z" },
-    { url = "https://files.pythonhosted.org/packages/d2/3a/508ac615935ef7588cf6d9e9b91309fdc2da751af865e02a9098de88258c/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2412e734dcb48da14d4e4006b82b46b74f2518b8a26ee7e58c6844a6cd6d03c4", size = 2309275, upload-time = "2026-05-06T13:37:41.406Z" },
-    { url = "https://files.pythonhosted.org/packages/07/f8/41db9de19d7987d6b04715a02b3b40aea467000275d9d758ffaa31af7d50/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9551187363ffc0de2a00b2e47c25aeaeb1020b69b668762966df15fc5659dd5a", size = 2094467, upload-time = "2026-05-06T13:39:18.847Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/e2/f35033184cb11d0052daf4416e8e10a502ea2ac006fc4f459aee872727d1/pydantic_core-2.46.4-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:0186750b482eefa11d7f435892b09c5c606193ef3375bcf94aa00ae6bfb66262", size = 2134417, upload-time = "2026-05-06T13:40:17.944Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/7b/6ceeb1cc90e193862f444ebe373d8fdf613f0a82572dde03fb10734c6c71/pydantic_core-2.46.4-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5855698a4856556d86e8e6cd8434bc3ac0314ee8e12089ae0e143f64c6256e4e", size = 2179782, upload-time = "2026-05-06T13:40:32.618Z" },
-    { url = "https://files.pythonhosted.org/packages/5a/f2/c8d7773ede6af08036423a00ae0ceffce266c3c52a096c435d68c896083f/pydantic_core-2.46.4-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:cbaf13819775b7f769bf4a1f066cb6df7a28d4480081a589828ef190226881cd", size = 2188782, upload-time = "2026-05-06T13:36:51.018Z" },
-    { url = "https://files.pythonhosted.org/packages/59/31/0c864784e31f09f05cdd87606f08923b9c9e7f6e51dd27f20f62f975ce9f/pydantic_core-2.46.4-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:633147d34cf4550417f12e2b1a0383973bdf5cdfde212cb09e9a581cf10820be", size = 2328334, upload-time = "2026-05-06T13:40:37.764Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/eb/4f6c8a41efa30baa755590f4141abf3a8c370fab610915733e74134a7270/pydantic_core-2.46.4-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:82cf5301172168103724d49a1444d3378cb20cdee30b116a1bd6031236298a5d", size = 2372986, upload-time = "2026-05-06T13:39:34.152Z" },
-    { url = "https://files.pythonhosted.org/packages/5b/24/b375a480d53113860c299764bfe9f349a3dc9108b3adc0d7f0d786492ebf/pydantic_core-2.46.4-cp313-cp313-win32.whl", hash = "sha256:9fa8ae11da9e2b3126c6426f147e0fba88d96d65921799bb30c6abd1cb2c97fb", size = 1973693, upload-time = "2026-05-06T13:37:55.072Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/e8/cff247591966f2d22ec8c003cd7587e27b7ba7b81ab2fb888e3ab75dc285/pydantic_core-2.46.4-cp313-cp313-win_amd64.whl", hash = "sha256:6b3ace8194b0e5204818c92802dcdca7fc6d88aabbb799d7c795540d9cd6d292", size = 2071819, upload-time = "2026-05-06T13:38:49.139Z" },
-    { url = "https://files.pythonhosted.org/packages/c6/1a/f4aee670d5670e9e148e0c82c7db98d780be566c6e6a97ee8035528ca0b3/pydantic_core-2.46.4-cp313-cp313-win_arm64.whl", hash = "sha256:184c081504d17f1c1066e430e117142b2c77d9448a97f7b65c6ac9fd9aee238d", size = 2027411, upload-time = "2026-05-06T13:40:45.796Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/74/228a26ddad29c6672b805d9fd78e8d251cd04004fa7eed0e622096cd0250/pydantic_core-2.46.4-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:428e04521a40150c85216fc8b85e8d39fece235a9cf5e383761238c7fa9b96fb", size = 2102079, upload-time = "2026-05-06T13:38:41.019Z" },
-    { url = "https://files.pythonhosted.org/packages/ad/1f/8970b150a4b4365623ae00fc88603491f763c627311ae8031e3111356d6e/pydantic_core-2.46.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:23ace664830ee0bfe014a0c7bc248b1f7f25ed7ad103852c317624a1083af462", size = 1952179, upload-time = "2026-05-06T13:36:59.812Z" },
-    { url = "https://files.pythonhosted.org/packages/95/30/5211a831ae054928054b2f79731661087a2bc5c01e825c672b3a4a8f1b3e/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce5c1d2a8b27468f433ca974829c44060b8097eedc39933e3c206a90ee49c4a9", size = 1978926, upload-time = "2026-05-06T13:37:39.933Z" },
-    { url = "https://files.pythonhosted.org/packages/57/e9/689668733b1eb67adeef047db3c2e8788fcf65a7fd9c9e2b46b7744fe245/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7283d57845ecf5a163403eb0702dfc220cc4fbdd18919cb5ccea4f95ee1cdab4", size = 2046785, upload-time = "2026-05-06T13:38:01.995Z" },
-    { url = "https://files.pythonhosted.org/packages/60/d9/6715260422ff50a2109878fd24d948a6c3446bb2664f34ee78cd972b3acd/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8daafc69c93ee8a0204506a3b6b30f586ef54028f52aeeeb5c4cfc5184fd5914", size = 2228733, upload-time = "2026-05-06T13:40:50.371Z" },
-    { url = "https://files.pythonhosted.org/packages/18/ae/fdb2f64316afca925640f8e70bb1a564b0ec2721c1389e25b8eb4bf9a299/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cd2213145bcc2ba85884d0ac63d222fece9209678f77b9b4d76f054c561adb28", size = 2307534, upload-time = "2026-05-06T13:37:21.531Z" },
-    { url = "https://files.pythonhosted.org/packages/89/1d/8eff589b45bb8190a9d12c49cfad0f176a5cbd1534908a6b5125e2886239/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7a5f930472650a82629163023e630d160863fce524c616f4e5186e5de9d9a49b", size = 2099732, upload-time = "2026-05-06T13:39:31.942Z" },
-    { url = "https://files.pythonhosted.org/packages/06/d5/ee5a3366637fee41dee51a1fc91562dcf12ddbc68fda34e6b253da2324bb/pydantic_core-2.46.4-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:c1b3f518abeca3aa13c712fd202306e145abf59a18b094a6bafb2d2bbf59192c", size = 2129627, upload-time = "2026-05-06T13:37:25.033Z" },
-    { url = "https://files.pythonhosted.org/packages/94/33/2414be571d2c6a6c4d08be21f9292b6d3fdb08949a97b6dfe985017821db/pydantic_core-2.46.4-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1a7dd0b3ee80d90150e3495a3a13ac34dbcbfd4f012996a6a1d8900e91b5c0fb", size = 2179141, upload-time = "2026-05-06T13:37:14.046Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/79/7daa95be995be0eecc4cf75064cb33f9bbbfe3fe0158caf2f0d4a996a5c7/pydantic_core-2.46.4-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:3fb702cd90b0446a3a1c5e470bfa0dd23c0233b676a9099ddcc964fa6ca13898", size = 2184325, upload-time = "2026-05-06T13:36:53.615Z" },
-    { url = "https://files.pythonhosted.org/packages/9f/cb/d0a382f5c0de8a222dc61c65348e0ce831b1f68e0a018450d31c2cace3a5/pydantic_core-2.46.4-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:b8458003118a712e66286df6a707db01c52c0f52f7db8e4a38f0da1d3b94fc4e", size = 2323990, upload-time = "2026-05-06T13:40:29.971Z" },
-    { url = "https://files.pythonhosted.org/packages/05/db/d9ba624cc4a5aced1598e88c04fdbd8310c8a69b9d38b9a3d39ce3a61ed7/pydantic_core-2.46.4-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:372429a130e469c9cd698925ce5fc50940b7a1336b0d82038e63d5bbc4edc519", size = 2369978, upload-time = "2026-05-06T13:37:23.027Z" },
-    { url = "https://files.pythonhosted.org/packages/f2/20/d15df15ba918c423461905802bfd2981c3af0bfa0e40d05e13edbfa48bc3/pydantic_core-2.46.4-cp314-cp314-win32.whl", hash = "sha256:85bb3611ff1802f3ee7fdd7dbff26b56f343fb432d57a4728fdd49b6ef35e2f4", size = 1966354, upload-time = "2026-05-06T13:38:03.499Z" },
-    { url = "https://files.pythonhosted.org/packages/fc/b6/6b8de4c0a7d7ab3004c439c80c5c1e0a3e8d78bbae19379b01960383d9e5/pydantic_core-2.46.4-cp314-cp314-win_amd64.whl", hash = "sha256:811ff8e9c313ab425368bcbb36e5c4ebd7108c2bbf4e4089cfbb0b01eff63fac", size = 2072238, upload-time = "2026-05-06T13:39:40.807Z" },
-    { url = "https://files.pythonhosted.org/packages/32/36/51eb763beec1f4cf59b1db243a7dcc39cbb41230f050a09b9d69faaf0a48/pydantic_core-2.46.4-cp314-cp314-win_arm64.whl", hash = "sha256:bfec22eab3c8cc2ceec0248aec886624116dc079afa027ecc8ad4a7e62010f8a", size = 2018251, upload-time = "2026-05-06T13:37:26.72Z" },
-    { url = "https://files.pythonhosted.org/packages/e8/91/855af51d625b23aa987116a19e231d2aaef9c4a415273ddc189b79a45fee/pydantic_core-2.46.4-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:af8244b2bef6aaad6d92cda81372de7f8c8d36c9f0c3ea36e827c60e7d9467a0", size = 2099593, upload-time = "2026-05-06T13:39:47.682Z" },
-    { url = "https://files.pythonhosted.org/packages/fb/1b/8784a54c65edb5f49f0a14d6977cf1b209bba85a4c77445b255c2de58ab3/pydantic_core-2.46.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5a4330cdbc57162e4b3aa303f588ba752257694c9c9be3e7ebb11b4aca659b5d", size = 1935226, upload-time = "2026-05-06T13:40:40.428Z" },
-    { url = "https://files.pythonhosted.org/packages/e8/e7/1955d28d1afc56dd4b3ad7cc0cf39df1b9852964cf16e5d13912756d6d6b/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:29c61fc04a3d840155ff08e475a04809278972fe6aef51e2720554e96367e34b", size = 1974605, upload-time = "2026-05-06T13:37:32.029Z" },
-    { url = "https://files.pythonhosted.org/packages/93/e2/3fedbf0ba7a22850e6e9fd78117f1c0f10f950182344d8a6c535d468fdd8/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c50f2528cf200c5eed56faf3f4e22fcd5f38c157a8b78576e6ba3168ec35f000", size = 2030777, upload-time = "2026-05-06T13:38:55.239Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/61/46be275fcaaba0b4f5b9669dd852267ce1ff616592dccf7a7845588df091/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0cbe8b01f948de4286c74cdd6c667aceb38f5c1e26f0693b3983d9d74887c65e", size = 2236641, upload-time = "2026-05-06T13:37:08.096Z" },
-    { url = "https://files.pythonhosted.org/packages/60/db/12e93e46a8bac9988be3c016860f83293daea8c716c029c9ace279036f2f/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:617d7e2ca7dcb8c5cf6bcb8c59b8832c94b36196bbf1cbd1bfb56ed341905edd", size = 2286404, upload-time = "2026-05-06T13:40:20.221Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/4a/4d8b19008f38d31c53b8219cfedc2e3d5de5fe99d90076b7e767de29274f/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7027560ee92211647d0d34e3f7cd6f50da56399d26a9c8ad0da286d3869a53f3", size = 2109219, upload-time = "2026-05-06T13:38:12.153Z" },
-    { url = "https://files.pythonhosted.org/packages/88/70/3cbc40978fefb7bb09c6708d40d4ad1a5d70fd7213c3d17f971de868ec1f/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:f99626688942fb746e545232e7726926f3be91b5975f8b55327665fafda991c7", size = 2110594, upload-time = "2026-05-06T13:40:02.971Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/20/b8d36736216e29491125531685b2f9e61aa5b4b2599893f8268551da3338/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fc3e9034a63de20e15e8ade85358bc6efc614008cab72898b4b4952bea0509ff", size = 2159542, upload-time = "2026-05-06T13:39:27.506Z" },
-    { url = "https://files.pythonhosted.org/packages/1d/a2/367df868eb584dacf6bf82a389272406d7178e301c4ac82545ab98bc2dd9/pydantic_core-2.46.4-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:97e7cf2be5c77b7d1a9713a05605d49460d02c6078d38d8bef3cbe323c548424", size = 2168146, upload-time = "2026-05-06T13:38:31.93Z" },
-    { url = "https://files.pythonhosted.org/packages/c1/b8/4460f77f7e201893f649a29ab355dddd3beee8a97bcb1a320db414f9a06e/pydantic_core-2.46.4-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:3bf92c5d0e00fefaab325a4d27828fe6b6e2a21848686b5b60d2d9eeb09d76c6", size = 2306309, upload-time = "2026-05-06T13:37:44.717Z" },
-    { url = "https://files.pythonhosted.org/packages/64/c4/be2639293acd87dc8ddbcec41a73cee9b2ebf996fe6d892a1a74e88ad3f7/pydantic_core-2.46.4-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:3ecbc122d18468d06ca279dc26a8c2e2d5acb10943bb35e36ae92096dc3b5565", size = 2369736, upload-time = "2026-05-06T13:37:05.645Z" },
-    { url = "https://files.pythonhosted.org/packages/30/a6/9f9f380dbb301f67023bf8f707aaa75daadf84f7152d95c410fd7e81d994/pydantic_core-2.46.4-cp314-cp314t-win32.whl", hash = "sha256:e846ae7835bf0703ae43f534ab79a867146dadd59dc9ca5c8b53d5c8f7c9ef02", size = 1955575, upload-time = "2026-05-06T13:38:51.116Z" },
-    { url = "https://files.pythonhosted.org/packages/40/1f/f1eb9eb350e795d1af8586289746f5c5677d16043040d63710e22abc43c9/pydantic_core-2.46.4-cp314-cp314t-win_amd64.whl", hash = "sha256:2108ba5c1c1eca18030634489dc544844144ee36357f2f9f780b93e7ddbb44b5", size = 2051624, upload-time = "2026-05-06T13:38:21.672Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/d2/42dd53d0a85c27606f316d3aa5d2869c4e8470a5ed6dec30e4a1abe19192/pydantic_core-2.46.4-cp314-cp314t-win_arm64.whl", hash = "sha256:4fcbe087dbc2068af7eda3aa87634eba216dbda64d1ae73c8684b621d33f6596", size = 2017325, upload-time = "2026-05-06T13:40:52.723Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/1d/8987ad40f65ae1432753072f214fb5c74fe47ffbd0698bb9cbbb585664f8/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:1d8ba486450b14f3b1d63bc521d410ec7565e52f887b9fb671791886436a42f7", size = 2095527, upload-time = "2026-05-06T13:39:52.283Z" },
-    { url = "https://files.pythonhosted.org/packages/64/d3/84c282a7eee1d3ac4c0377546ef5a1ea436ce26840d9ac3b7ed54a377507/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:3009f12e4e90b7f88b4f9adb1b0c4a3d58fe7820f3238c190047209d148026df", size = 1936024, upload-time = "2026-05-06T13:40:15.671Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/ca/eac61596cdeb4d7e174d3dc0bd8a6238f14f75f97a24e7b7db4c7e7340a0/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ad785e92e6dc634c21555edc8bd6b64957ab844541bcb96a1366c202951ae526", size = 1990696, upload-time = "2026-05-06T13:38:34.717Z" },
-    { url = "https://files.pythonhosted.org/packages/fa/c3/7c8b240552251faf6b3a957db200fcfbbcec36763c050428b601e0c9b83b/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:00c603d540afdd6b80eb39f078f33ebd46211f02f33e34a32d9f053bba711de0", size = 2147590, upload-time = "2026-05-06T13:39:29.883Z" },
+sdist = { url = "https://files.pythonhosted.org/packages/66/71/dba38ee2651f84f7842206adbd2233d8bbdb59fb85e9fa14232486a8c471/pydantic_extra_types-2.11.1.tar.gz", hash = "sha256:46792d2307383859e923d8fcefa82108b1a141f8a9c0198982b3832ab5ef1049", size = 172002, upload-time = "2026-03-16T08:08:03.92Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/17/c1/3226e6d7f5a4f736f38ac11a6fbb262d701889802595cdb0f53a885ac2e0/pydantic_extra_types-2.11.1-py3-none-any.whl", hash = "sha256:1722ea2bddae5628ace25f2aa685b69978ef533123e5638cfbddb999e0100ec1", size = 79526, upload-time = "2026-03-16T08:08:02.533Z" },
 ]
 
 [[package]]