diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 54b4250..2b75c8c 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -22,7 +22,7 @@ jobs:
       - name: Compile
         run: |
           mkdir build
-          cmake -S . -B build -DBUILD_EXAMPLES=OFF -DBUILD_TESTING=OFF -DAOG_TC_VALIDATE_IOP=OFF -Wno-dev
+          cmake -S . -B build -DBUILD_EXAMPLES=OFF -DBUILD_TESTING=OFF -DAOG_TC_VALIDATE_IOP=OFF -DAOG_TC_BUILD_TESTS=OFF -Wno-dev
           cmake --build build --config Release --target package
       - name: 'Upload Windows Installer'
         uses: actions/upload-artifact@v4
@@ -52,7 +52,7 @@ jobs:
           sudo apt-get install -y --no-install-recommends \
             build-essential cmake ninja-build
       - name: Configure (CMake)
-        run: cmake -S . -B build -G Ninja -DBUILD_EXAMPLES=OFF -DBUILD_TESTING=OFF -DAOG_TC_VALIDATE_IOP=OFF -DCMAKE_BUILD_TYPE=Release -Wno-dev
+        run: cmake -S . -B build -G Ninja -DBUILD_EXAMPLES=OFF -DBUILD_TESTING=OFF -DAOG_TC_VALIDATE_IOP=OFF -DAOG_TC_BUILD_TESTS=OFF -DCMAKE_BUILD_TYPE=Release -Wno-dev
       - name: Build
         run: cmake --build build --config Release
       - name: Stage tarball
diff --git a/.github/workflows/validate-iop.yml b/.github/workflows/validate-iop.yml
index 13fd36f..6b018fa 100644
--- a/.github/workflows/validate-iop.yml
+++ b/.github/workflows/validate-iop.yml
@@ -34,7 +34,7 @@ jobs:
           -Wno-dev
 
       - name: Build
-        run: cmake --build build --config Release --target iop_validator
+        run: cmake --build build --config Release --target iop_validator ddop_hydration_test
 
-      - name: Validate object pool
+      - name: Validate object pool and run unit tests
         run: ctest --test-dir build --output-on-failure
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6785346..b681570 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -146,6 +146,28 @@ endif()
 
 install(TARGETS ${PROJECT_NAME} RUNTIME DESTINATION bin COMPONENT applications)
 
+option(AOG_TC_BUILD_TESTS "Build and register the unit tests" ON)
+if(AOG_TC_BUILD_TESTS)
+  enable_testing()
+  add_executable(
+    ddop_hydration_test
+    ${CMAKE_CURRENT_LIST_DIR}/tools/ddop_hydration_test.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/ddop_hydration.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/settings.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/logging.cpp)
+  target_compile_features(ddop_hydration_test PRIVATE cxx_std_20)
+  set_target_properties(ddop_hydration_test PROPERTIES CXX_EXTENSIONS OFF)
+  target_include_directories(ddop_hydration_test
+                             PRIVATE ${CMAKE_CURRENT_LIST_DIR}/include)
+  target_compile_definitions(
+    ddop_hydration_test PRIVATE PROJECT_VERSION="${PROJECT_VERSION}"
+                                PROJECT_NAME="${PROJECT_NAME}")
+  target_link_libraries(
+    ddop_hydration_test PRIVATE isobus::Isobus isobus::Utility
+                                nlohmann_json::nlohmann_json)
+  add_test(NAME ddop_hydration_snapshot COMMAND ddop_hydration_test)
+endif()
+
 option(AOG_TC_VALIDATE_IOP "Build and register the object pool validator test"
        ON)
 if(AOG_TC_VALIDATE_IOP)
diff --git a/docs/CONCURRENCY.md b/docs/CONCURRENCY.md
index 8df81de..396097e 100644
--- a/docs/CONCURRENCY.md
+++ b/docs/CONCURRENCY.md
@@ -57,6 +57,12 @@ registration point itself defers to an `update()` call, or invokes the listener/
   take `clientsMutex` at its top, even though (per the note above) the `TaskControllerServer`
   overrides may turn out to already be main-thread-only — the lock is cheap insurance and keeps
   every entry point consistent regardless of how the library's internals might change.
+- **Hydrated DDOP snapshot state** (`ClientState`'s shadow values, `MyTCServer::pendingHydration`) —
+  also guarded by `clientsMutex`. `on_value_command()` records values; `begin_hydration_snapshot()`
+  and `poll_hydration_snapshot()` run from `Application::update()`. The snapshot wait is polled,
+  never blocked on: `tcServer->update()` runs in the same main loop, and blocking it would stall the
+  responses being waited for. `poll_hydration_snapshot()` copies what it needs and writes files
+  after releasing the lock. The VT button listener only sets an `std::atomic<bool>`.
 
 ## What's *not* protected yet — known gap
 
diff --git a/include/app.hpp b/include/app.hpp
index d74de11..8d80e15 100644
--- a/include/app.hpp
+++ b/include/app.hpp
@@ -8,6 +8,7 @@
  */
 #pragma once
 
+#include <atomic>
 #include <boost/asio.hpp>
 #include <cstdint>
 #include <map>
@@ -68,6 +69,7 @@ class Application
 	void sync_vt_config_once();
 	void update_vt_section_map();
 	void update_vt_status_strings(bool aogConnected);
+	void update_hydration_snapshot();
 
 	void send_vt_string_if_changed(std::uint16_t objectID, const std::string &value);
 	void send_hardware_message(const std::string &text, std::uint8_t duration, std::uint8_t color);
@@ -96,6 +98,7 @@ class Application
 	bool vtWasConnected = false;
 	bool vtConnectionWarningLogged = false;
 	bool vtCapabilitiesLogged = false;
+	std::atomic<bool> hydrationSnapshotRequested{ false }; ///< Set by the VT button listener, handled in update()
 	std::uint8_t nmea2000SequenceIdentifier = 0;
 	std::uint32_t lastJ1939SpeedTransmit = 0;
 	std::uint32_t lastTCStatusTransmit = 0;
diff --git a/include/ddop_hydration.hpp b/include/ddop_hydration.hpp
new file mode 100644
index 0000000..828c2d1
--- /dev/null
+++ b/include/ddop_hydration.hpp
@@ -0,0 +1,123 @@
+/**
+ * @brief On-demand "hydrated" DDOP snapshots for debugging and visualization
+ *
+ * A client's canonical DDOP describes structure only: DeviceProcessData objects carry no value,
+ * those arrive later as process data value commands. A hydrated snapshot is a derived copy of the
+ * canonical pool in which hydratable DeviceProcessData objects are replaced by DeviceProperty
+ * objects (same object ID, DDI, designator and presentation) holding the latest known value, so
+ * external tools such as AgIsoDDOPGenerator can show those values.
+ *
+ * Snapshots are never uploaded to a TC and never replace or modify the canonical pool.
+ */
+
+#pragma once
+
+#include "isobus/isobus/can_NAME.hpp"
+#include "isobus/isobus/isobus_device_descriptor_object_pool.hpp"
+
+#include <cstdint>
+#include <filesystem>
+#include <map>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace ddop_hydration
+{
+	/// @brief How long a snapshot waits for answers to its value requests
+	constexpr std::uint32_t REQUEST_WAIT_MS = 10000;
+
+	/// @brief DDIs that are never hydrated: totals, setpoints and transient state such as work states,
+	/// section control state and actual rates.
+	bool is_always_excluded(std::uint16_t ddi);
+
+	/// @brief Whether a pool object is part of a snapshot, decided from the pool alone: every DeviceProperty,
+	/// and every DeviceProcessData that reports on change, is not a total and is not always excluded.
+	bool is_hydratable(const isobus::task_controller_object::Object &object);
+
+	/// @brief The latest process data value reported by a client for one object
+	struct ShadowValue
+	{
+		std::int32_t value = 0;
+		std::uint32_t timestamp_ms = 0;
+	};
+
+	/// @brief Latest reported process data values per object ID for one client.
+	/// Not thread-safe on its own; MyTCServer guards it with clientsMutex.
+	class ShadowValueStore
+	{
+	public:
+		void record(std::uint16_t objectID, std::int32_t value);
+		bool try_get(std::uint16_t objectID, ShadowValue &shadowValue) const;
+
+	private:
+		std::map<std::uint16_t, ShadowValue> values;
+	};
+
+	/// @brief Maps the (DDI, element number) addressing of process data messages to DDOP object IDs
+	class ProcessDataIndex
+	{
+	public:
+		void build(isobus::DeviceDescriptorObjectPool &pool);
+		bool try_get_object_id(std::uint16_t ddi, std::uint16_t elementNumber, std::uint16_t &objectID) const;
+		bool try_get_element_number(std::uint16_t objectID, std::uint16_t &elementNumber) const;
+
+	private:
+		std::map<std::pair<std::uint16_t, std::uint16_t>, std::uint16_t> ddiAndElementToObjectID;
+		std::map<std::uint16_t, std::uint16_t> objectIDToElementNumber;
+	};
+
+	/// @brief Where a snapshot object's value came from
+	enum class ValueSource : std::uint8_t
+	{
+		Pool, ///< DeviceProperty, value taken from the canonical pool as-is
+		Live, ///< Shadow value that was already known when the snapshot was requested
+		Requested, ///< Value arrived after an on-demand value request
+		NoResponse, ///< Value was requested but did not arrive in time
+		NotRequestable ///< DeviceProcessData that no device element references, so it cannot be addressed
+	};
+
+	const char *to_string(ValueSource source);
+
+	struct SnapshotEntry
+	{
+		static constexpr std::uint16_t NO_ELEMENT = 0xFFFF;
+
+		std::uint16_t objectID = 0;
+		std::uint16_t ddi = 0;
+		std::uint16_t elementNumber = NO_ELEMENT;
+		ValueSource source = ValueSource::NoResponse;
+		std::int32_t value = 0; ///< Only meaningful for Pool, Live and Requested
+	};
+
+	struct SnapshotInput
+	{
+		std::vector<std::vector<std::uint8_t>> canonicalPoolChunks; ///< The client's DDOP exactly as uploaded
+		std::uint8_t taskControllerCompatibilityLevel = 0;
+		std::uint64_t clientName = 0;
+		std::string fileStem; ///< Relative to the settings directory, e.g. "<NAME>/<label>"; the canonical pool is "<fileStem>.ddop"
+		std::vector<SnapshotEntry> entries;
+	};
+
+	struct SnapshotResult
+	{
+		bool success = false;
+		std::string ddopPath;
+		std::string metadataPath;
+		std::size_t patchedObjects = 0;
+		std::size_t missingValues = 0;
+		std::string error;
+	};
+
+	/// @brief Prefix added to the Device designator of a snapshot
+	constexpr const char *SNAPSHOT_DESIGNATOR_PREFIX = "SNAP ";
+	/// @brief Marker in snapshot file names: "<label>.SNAP-<timestamp>.ddop" next to "<label>.ddop"
+	constexpr const char *SNAPSHOT_FILENAME_MARKER = ".SNAP-";
+
+	/// @brief Clones the canonical pool, patches in the entries' values and writes the snapshot plus a JSON sidecar
+	SnapshotResult write_snapshot(const SnapshotInput &input);
+
+	/// @brief Whether a file is a hydrated snapshot (or its sidecar) rather than a canonical pool.
+	/// Anything that ever loads stored pools must skip these.
+	bool is_snapshot_file(const std::filesystem::path &path);
+} // namespace ddop_hydration
diff --git a/include/task_controller.hpp b/include/task_controller.hpp
index 705605e..df85a1e 100644
--- a/include/task_controller.hpp
+++ b/include/task_controller.hpp
@@ -9,6 +9,7 @@
 
 #pragma once
 
+#include "ddop_hydration.hpp"
 #include "isobus/isobus/isobus_data_dictionary.hpp"
 #include "isobus/isobus/isobus_device_descriptor_object_pool.hpp"
 #include "isobus/isobus/isobus_standard_data_description_indices.hpp"
@@ -16,8 +17,11 @@
 
 #include <cstdint>
 #include <map>
+#include <memory>
 #include <mutex>
+#include <optional>
 #include <queue>
+#include <string>
 
 constexpr std::uint8_t NUMBER_SECTIONS_PER_CONDENSED_MESSAGE = 16;
 
@@ -62,9 +66,19 @@ class ClientState
 	// Element work state management these act like master / override for actual sections
 	void set_element_work_state(std::uint16_t elementNumber, bool isWorking);
 	bool try_get_element_work_state(std::uint16_t elementNumber, bool &isWorking) const;
+	// Hydrated DDOP snapshot support, see ddop_hydration.hpp
+	void set_canonical_pool(std::vector<std::vector<std::uint8_t>> chunks, std::string fileStem);
+	const std::vector<std::vector<std::uint8_t>> &get_canonical_pool_chunks() const;
+	const std::string &get_canonical_file_stem() const;
+	ddop_hydration::ProcessDataIndex &get_process_data_index();
+	ddop_hydration::ShadowValueStore &get_shadow_values();
 
 private:
 	isobus::DeviceDescriptorObjectPool pool; ///< The device descriptor object pool (DDOP) for the TC
+	std::shared_ptr<const std::vector<std::vector<std::uint8_t>>> canonicalPoolChunks; ///< The DDOP exactly as uploaded, shared so get_clients() copies stay cheap
+	std::string canonicalFileStem; ///< "<NAME>/<label>"; the canonical pool is stored as "<stem>.ddop"
+	ddop_hydration::ProcessDataIndex processDataIndex; ///< (DDI, element number) -> object ID
+	ddop_hydration::ShadowValueStore shadowValues; ///< Latest reported process data values by object ID
 	bool areMeasurementCommandsSent = false; ///< Whether or not the measurement commands have been sent
 	std::map<isobus::DataDescriptionIndex, std::uint16_t> ddiToElementNumber; ///< Mapping of DDI to element number // TODO: better way to do this?
 
@@ -116,13 +130,37 @@ class MyTCServer : public isobus::TaskControllerServer
 	void update_section_states(std::vector<bool> &sectionStates);
 	void update_section_control_enabled(bool enabled);
 
+	enum class HydrationStartResult
+	{
+		Started,
+		AlreadyRunning,
+		UnknownClient
+	};
+
+	/// @brief Starts a hydrated DDOP snapshot for a client. Sends value requests for hydratable
+	/// objects without a known value; does not block. Finish it with poll_hydration_snapshot().
+	HydrationStartResult begin_hydration_snapshot(std::shared_ptr<isobus::ControlFunction> client);
+
+	/// @brief Call from the main loop. Once the request wait has elapsed, writes the snapshot and returns true.
+	/// @param[out] result The outcome of the finished snapshot, only set when this returns true
+	bool poll_hydration_snapshot(ddop_hydration::SnapshotResult &result);
+
 private:
+	struct PendingHydration
+	{
+		std::shared_ptr<isobus::ControlFunction> client;
+		std::vector<ddop_hydration::SnapshotEntry> entries;
+		std::uint32_t startedAt_ms = 0;
+		std::uint32_t wait_ms = 0;
+	};
+
 	void send_section_setpoint_states(std::shared_ptr<isobus::ControlFunction> client, std::uint8_t ddiOffset);
 	void send_section_control_state(std::shared_ptr<isobus::ControlFunction> client, bool enabled);
 	bool is_ddi_settable(std::shared_ptr<isobus::ControlFunction> client, std::uint16_t ddi);
 
 	std::map<std::shared_ptr<isobus::ControlFunction>, ClientState> clients;
 	std::map<std::shared_ptr<isobus::ControlFunction>, std::queue<std::vector<std::uint8_t>>> uploadedPools;
+	std::optional<PendingHydration> pendingHydration; ///< Guarded by clientsMutex
 
 	/// @brief Guards clients and uploadedPools.
 	///
diff --git a/readme.md b/readme.md
index 806746c..2ea4433 100644
--- a/readme.md
+++ b/readme.md
@@ -78,6 +78,16 @@ AOG-TaskController reads its configuration from a `settings.json` file located i
 }
 ```
 
+### Hydrated DDOP snapshots
+
+Many implement values, such as element offsets and working width, are not stored in the DDOP; the implement reports them as process data once it is running. The **Snapshot DDOP** button on the VT Implement page writes a copy of the connected implement's DDOP with those values filled in, for viewing in tools such as AgIsoDDOPGenerator.
+
+- The objects are picked from the DDOP itself: every DeviceProperty, and every DeviceProcessData that reports on change and is not a total, a setpoint, a work state, section control state or an actual rate.
+- Values that were already reported are used directly. For the rest, the TC sends value requests and waits 10 seconds for answers.
+- DeviceProcessData objects with a value are replaced by DeviceProperty objects with the same object ID, DDI and designator. The Device designator gets a `SNAP ` prefix and the structure label is changed.
+- The snapshot is stored next to the canonical pool as `<NAME>/<label>.SNAP-<timestamp>.ddop`, with a `.json` file that lists every object, its value and where the value came from.
+- Snapshots are for debugging only: never upload one to a TC. The canonical `<label>.ddop` is not changed.
+
 ### Virtual Terminal compatibility
 
 The VT object pool is embedded in the executable and automatically scales from its authored 480-pixel data mask and 80-pixel softkey designator to the connected terminal. It uses five virtual navigation softkeys. A VT with fewer than five physical keys must support softkey paging.
diff --git a/resources/AOG_TC.iop b/resources/AOG_TC.iop
index d90ab25..4c01a8b 100644
Binary files a/resources/AOG_TC.iop and b/resources/AOG_TC.iop differ
diff --git a/resources/AOG_TC.iop.h b/resources/AOG_TC.iop.h
index 8a12fbd..3278489 100644
--- a/resources/AOG_TC.iop.h
+++ b/resources/AOG_TC.iop.h
@@ -20,6 +20,7 @@
 #define NavImplement                       5004
 #define NavDiagnostics                     5005
 #define NavConfig                          5006
+#define ImplementSnapshotButton            6000
 #define VTControlFunctionsStr              8000
 #define InputList_10000                   10000
 #define ConfigHydliftAuxN                 10001
@@ -56,6 +57,7 @@
 #define ImplementHint                     11207
 #define ImplementBoomOffsetLabel          11208
 #define ImplementBoomOffset               11209
+#define ImplementSnapshotLabel            11210
 #define DiagnosticsTitle                  11300
 #define DiagnosticsLabels                 11301
 #define DiagnosticsValues                 11302
diff --git a/src/app.cpp b/src/app.cpp
index 3e9877e..d17472b 100644
--- a/src/app.cpp
+++ b/src/app.cpp
@@ -565,6 +565,7 @@ bool Application::update()
 
 	tcServer->request_measurement_commands();
 	tcServer->update();
+	update_hydration_snapshot();
 	if (tcFunctionalities)
 		tcFunctionalities->update();
 	if (tecuFunctionalities)
@@ -882,6 +883,50 @@ void Application::send_task_controller_status_message()
 	lastTCStatusTransmit = transmitAttemptTimestamp;
 }
 
+void Application::update_hydration_snapshot()
+{
+	if (hydrationSnapshotRequested.exchange(false))
+	{
+		auto clients = tcServer->get_clients(); // snapshot copy — see get_clients()'s declaration
+		if (clients.empty())
+		{
+			send_hardware_message("DDOP snapshot: no implement connected", 5, HW_MSG_ALERT);
+		}
+		else
+		{
+			// Same client the Implement page shows, see update_vt_status_strings()
+			switch (tcServer->begin_hydration_snapshot(clients.begin()->first))
+			{
+				case MyTCServer::HydrationStartResult::Started:
+					send_hardware_message("DDOP snapshot started", 5, HW_MSG_INFO);
+					break;
+				case MyTCServer::HydrationStartResult::AlreadyRunning:
+					send_hardware_message("DDOP snapshot already in progress", 5, HW_MSG_INFO);
+					break;
+				case MyTCServer::HydrationStartResult::UnknownClient:
+					send_hardware_message("DDOP snapshot: implement not active", 5, HW_MSG_ALERT);
+					break;
+			}
+		}
+	}
+
+	ddop_hydration::SnapshotResult result;
+	if (tcServer->poll_hydration_snapshot(result))
+	{
+		if (result.success)
+		{
+			log("TC Server") << "Saved hydrated DDOP snapshot: " << result.ddopPath << " (" << result.patchedObjects << " values patched, "
+			                 << result.missingValues << " missing, details in " << result.metadataPath << ")" << std::endl;
+			send_hardware_message("DDOP snapshot saved: " + std::to_string(result.patchedObjects) + " values, " + std::to_string(result.missingValues) + " missing", 10, HW_MSG_INFO);
+		}
+		else
+		{
+			log("TC Server") << "Hydrated DDOP snapshot failed: " << result.error << std::endl;
+			send_hardware_message("DDOP snapshot failed: " + result.error, 10, HW_MSG_ALERT);
+		}
+	}
+}
+
 void Application::setup_vt_client()
 {
 	vtObjectPool.assign(std::begin(AOG_TC_IOP_DATA), std::end(AOG_TC_IOP_DATA));
@@ -937,8 +982,14 @@ void Application::setup_vt_client()
 			log("VT") << "Navigating to mask " << targetMask << std::endl;
 		}
 	});
-	vtClient->get_vt_button_event_dispatcher().add_listener([](const isobus::VirtualTerminalClient::VTKeyEvent &event) {
+	vtClient->get_vt_button_event_dispatcher().add_listener([this](const isobus::VirtualTerminalClient::VTKeyEvent &event) {
 		log("VT") << "Button event, key=" << static_cast<int>(event.keyNumber) << std::endl;
+		if ((event.objectID == ImplementSnapshotButton) &&
+		    (event.keyEvent == isobus::VirtualTerminalClient::KeyActivationCode::ButtonPressedOrLatched))
+		{
+			// Only flag it: this runs on the CAN thread, the snapshot is driven from update()
+			hydrationSnapshotRequested = true;
+		}
 	});
 	vtUpdateHelper = std::make_unique<isobus::VirtualTerminalClientUpdateHelper>(vtClient);
 	vtUpdateHelper->add_tracked_numeric_value(VTSpeedValue, 0);
diff --git a/src/ddop_hydration.cpp b/src/ddop_hydration.cpp
new file mode 100644
index 0000000..0baa1e6
--- /dev/null
+++ b/src/ddop_hydration.cpp
@@ -0,0 +1,349 @@
+/**
+ * @brief On-demand "hydrated" DDOP snapshots for debugging and visualization
+ */
+#include "ddop_hydration.hpp"
+#include "settings.hpp"
+
+#include "isobus/isobus/isobus_data_dictionary.hpp"
+#include "isobus/isobus/isobus_standard_data_description_indices.hpp"
+#include "isobus/utility/system_timing.hpp"
+
+#include <ctime>
+#include <fstream>
+#include <iomanip>
+#include <nlohmann/json.hpp>
+#include <sstream>
+
+using json = nlohmann::json;
+
+namespace ddop_hydration
+{
+	namespace
+	{
+		using isobus::DataDescriptionIndex;
+		using isobus::task_controller_object::DeviceProcessDataObject;
+		using isobus::task_controller_object::DevicePropertyObject;
+		using isobus::task_controller_object::ObjectTypes;
+
+		constexpr std::size_t MAX_DESIGNATOR_LENGTH = 32; // TC version 3 limit; also valid for version 4
+
+		bool ddi_in_range(std::uint16_t ddi, DataDescriptionIndex first, DataDescriptionIndex last)
+		{
+			return (ddi >= static_cast<std::uint16_t>(first)) && (ddi <= static_cast<std::uint16_t>(last));
+		}
+
+		std::string local_timestamp(const char *format)
+		{
+			const std::time_t now = std::time(nullptr);
+			std::tm localTime{};
+#if defined(_WIN32)
+			localtime_s(&localTime, &now);
+#else
+			localtime_r(&now, &localTime);
+#endif
+			std::ostringstream stream;
+			stream << std::put_time(&localTime, format);
+			return stream.str();
+		}
+
+		std::string to_hex(const std::string &bytes)
+		{
+			std::ostringstream stream;
+			for (unsigned char byte : bytes)
+			{
+				stream << std::hex << std::setw(2) << std::setfill('0') << static_cast<int>(byte);
+			}
+			return stream.str();
+		}
+
+		bool write_file(const std::string &path, const char *data, std::size_t size, std::ios::openmode mode)
+		{
+			std::ofstream file(path, mode | std::ios::trunc);
+			if (!file.is_open())
+			{
+				return false;
+			}
+			file.write(data, static_cast<std::streamsize>(size));
+			return file.good();
+		}
+	} // namespace
+
+	bool is_always_excluded(std::uint16_t ddi)
+	{
+		if ((ddi == static_cast<std::uint16_t>(DataDescriptionIndex::ActualWorkState)) ||
+		    (ddi == static_cast<std::uint16_t>(DataDescriptionIndex::SetpointWorkState)) ||
+		    (ddi == static_cast<std::uint16_t>(DataDescriptionIndex::SectionControlState)) ||
+		    (ddi == static_cast<std::uint16_t>(DataDescriptionIndex::PrescriptionControlState)) ||
+		    ddi_in_range(ddi, DataDescriptionIndex::ActualCondensedWorkState1_16, DataDescriptionIndex::ActualCondensedWorkState241_256) ||
+		    ddi_in_range(ddi, DataDescriptionIndex::SetpointCondensedWorkState1_16, DataDescriptionIndex::SetpointCondensedWorkState241_256) ||
+		    ddi_in_range(ddi, DataDescriptionIndex::CondensedSectionOverrideState1_16, DataDescriptionIndex::CondensedSectionOverrideState241_256))
+		{
+			return true;
+		}
+
+		// Totals and actual rates change continuously, and setpoints are commands from the TC,
+		// so a snapshot of them says nothing about the implement's configuration.
+		const std::string &name = isobus::DataDictionary::get_entry(ddi).name;
+		const bool isTotal = (name.find("Total") != std::string::npos);
+		const bool isActualRate = (name.rfind("Actual", 0) == 0) && (name.find("Rate") != std::string::npos);
+		const bool isSetpoint = (name.rfind("Setpoint", 0) == 0);
+		return isTotal || isActualRate || isSetpoint;
+	}
+
+	bool is_hydratable(const isobus::task_controller_object::Object &object)
+	{
+		switch (object.get_object_type())
+		{
+			case ObjectTypes::DeviceProperty:
+				return true;
+
+			case ObjectTypes::DeviceProcessData:
+			{
+				const auto &processData = static_cast<const DeviceProcessDataObject &>(object);
+				// has_trigger_method() is not const in AgIsoStack, so test the bitfield directly
+				const std::uint8_t triggers = processData.get_trigger_methods_bitfield();
+				return (0 == (triggers & static_cast<std::uint8_t>(DeviceProcessDataObject::AvailableTriggerMethods::Total))) &&
+				  (0 != (triggers & static_cast<std::uint8_t>(DeviceProcessDataObject::AvailableTriggerMethods::OnChange))) &&
+				  !is_always_excluded(processData.get_ddi());
+			}
+
+			default:
+				return false;
+		}
+	}
+
+	void ShadowValueStore::record(std::uint16_t objectID, std::int32_t value)
+	{
+		values[objectID] = { value, isobus::SystemTiming::get_timestamp_ms() };
+	}
+
+	bool ShadowValueStore::try_get(std::uint16_t objectID, ShadowValue &shadowValue) const
+	{
+		auto it = values.find(objectID);
+		if (it == values.end())
+		{
+			return false;
+		}
+		shadowValue = it->second;
+		return true;
+	}
+
+	void ProcessDataIndex::build(isobus::DeviceDescriptorObjectPool &pool)
+	{
+		ddiAndElementToObjectID.clear();
+		objectIDToElementNumber.clear();
+
+		for (std::uint16_t i = 0; i < pool.size(); i++)
+		{
+			auto object = pool.get_object_by_index(i);
+			if (!object || (object->get_object_type() != ObjectTypes::DeviceElement))
+			{
+				continue;
+			}
+
+			auto element = std::static_pointer_cast<isobus::task_controller_object::DeviceElementObject>(object);
+			for (std::uint16_t childID : element->get_child_object_ids())
+			{
+				auto child = pool.get_object_by_id(childID);
+				if (!child)
+				{
+					continue;
+				}
+
+				std::uint16_t ddi;
+				if (child->get_object_type() == ObjectTypes::DeviceProcessData)
+				{
+					ddi = std::static_pointer_cast<DeviceProcessDataObject>(child)->get_ddi();
+				}
+				else if (child->get_object_type() == ObjectTypes::DeviceProperty)
+				{
+					ddi = std::static_pointer_cast<DevicePropertyObject>(child)->get_ddi();
+				}
+				else
+				{
+					continue;
+				}
+
+				ddiAndElementToObjectID.emplace(std::make_pair(ddi, element->get_element_number()), childID);
+				objectIDToElementNumber.emplace(childID, element->get_element_number());
+			}
+		}
+	}
+
+	bool ProcessDataIndex::try_get_object_id(std::uint16_t ddi, std::uint16_t elementNumber, std::uint16_t &objectID) const
+	{
+		auto it = ddiAndElementToObjectID.find(std::make_pair(ddi, elementNumber));
+		if (it == ddiAndElementToObjectID.end())
+		{
+			return false;
+		}
+		objectID = it->second;
+		return true;
+	}
+
+	bool ProcessDataIndex::try_get_element_number(std::uint16_t objectID, std::uint16_t &elementNumber) const
+	{
+		auto it = objectIDToElementNumber.find(objectID);
+		if (it == objectIDToElementNumber.end())
+		{
+			return false;
+		}
+		elementNumber = it->second;
+		return true;
+	}
+
+	const char *to_string(ValueSource source)
+	{
+		switch (source)
+		{
+			case ValueSource::Pool:
+				return "pool";
+			case ValueSource::Live:
+				return "live";
+			case ValueSource::Requested:
+				return "requested";
+			case ValueSource::NoResponse:
+				return "no_response";
+			case ValueSource::NotRequestable:
+				return "not_requestable";
+		}
+		return "unknown";
+	}
+
+	SnapshotResult write_snapshot(const SnapshotInput &input)
+	{
+		SnapshotResult result;
+
+		// Deserialize a fresh copy: pools copied through ClientState share their objects with the canonical pool.
+		isobus::DeviceDescriptorObjectPool pool;
+		pool.set_task_controller_compatibility_level(input.taskControllerCompatibilityLevel);
+		for (const auto &chunk : input.canonicalPoolChunks)
+		{
+			if (!pool.deserialize_binary_object_pool(chunk.data(), static_cast<std::uint32_t>(chunk.size()), isobus::NAME(input.clientName)))
+			{
+				result.error = "failed to deserialize canonical pool";
+				return result;
+			}
+		}
+
+		std::shared_ptr<isobus::task_controller_object::DeviceObject> device;
+		for (std::uint16_t i = 0; (i < pool.size()) && !device; i++)
+		{
+			auto object = pool.get_object_by_index(i);
+			if (object && (object->get_object_type() == ObjectTypes::Device))
+			{
+				device = std::static_pointer_cast<isobus::task_controller_object::DeviceObject>(object);
+			}
+		}
+		if (!device)
+		{
+			result.error = "pool has no Device object";
+			return result;
+		}
+
+		// Mark the snapshot so neither people nor a stored-pool lookup mistake it for the canonical upload.
+		const std::string canonicalDesignator = device->get_designator();
+		const std::string canonicalStructureLabel = device->get_structure_label();
+		device->set_designator((SNAPSHOT_DESIGNATOR_PREFIX + canonicalDesignator).substr(0, MAX_DESIGNATOR_LENGTH));
+		const std::string snapshotStructureLabel = "SNAP" + canonicalStructureLabel.substr(0, 3);
+		device->set_structure_label(snapshotStructureLabel);
+
+		json objects = json::array();
+		for (const auto &entry : input.entries)
+		{
+			const bool hasValue = (entry.source == ValueSource::Pool) || (entry.source == ValueSource::Live) || (entry.source == ValueSource::Requested);
+			bool patched = false;
+
+			if (hasValue && (entry.source != ValueSource::Pool))
+			{
+				auto object = pool.get_object_by_id(entry.objectID);
+				if (object && (object->get_object_type() == ObjectTypes::DeviceProcessData))
+				{
+					auto processData = std::static_pointer_cast<DeviceProcessDataObject>(object);
+					const std::string designator = processData->get_designator();
+					const std::uint16_t presentationID = processData->get_device_value_presentation_object_id();
+
+					// The parent element keeps referencing the same object ID, so the hierarchy stays intact.
+					pool.remove_object_by_id(entry.objectID);
+					patched = pool.add_device_property(designator, entry.value, entry.ddi, presentationID, entry.objectID);
+					if (!patched)
+					{
+						result.error = "failed to replace object " + std::to_string(entry.objectID);
+						return result;
+					}
+					result.patchedObjects++;
+				}
+			}
+			else if (!hasValue)
+			{
+				result.missingValues++;
+			}
+
+			json item = {
+				{ "objectId", entry.objectID },
+				{ "ddi", entry.ddi },
+				{ "ddiName", isobus::DataDictionary::get_entry(entry.ddi).name },
+				{ "elementNumber", (entry.elementNumber == SnapshotEntry::NO_ELEMENT) ? json(nullptr) : json(entry.elementNumber) },
+				{ "source", to_string(entry.source) },
+				{ "value", hasValue ? json(entry.value) : json(nullptr) },
+				{ "patchedToDeviceProperty", patched },
+			};
+			objects.push_back(item);
+		}
+
+		std::vector<std::uint8_t> binaryPool;
+		if (!pool.generate_binary_object_pool(binaryPool))
+		{
+			result.error = "failed to generate snapshot pool";
+			return result;
+		}
+
+		const std::string createdAt = local_timestamp("%Y-%m-%dT%H:%M:%S");
+		const std::string snapshotStem = input.fileStem + SNAPSHOT_FILENAME_MARKER + local_timestamp("%Y%m%d-%H%M%S");
+		result.ddopPath = Settings::get_filename_path(snapshotStem + ".ddop");
+		result.metadataPath = Settings::get_filename_path(snapshotStem + ".json");
+
+		std::ostringstream clientName;
+		clientName << "0x" << std::hex << std::setw(16) << std::setfill('0') << input.clientName;
+
+		json metadata = {
+			{ "kind", "AOG-TaskController hydrated DDOP snapshot" },
+			{ "notForReupload", true },
+			{ "note",
+			  "Derived debugging artifact, not an original upload. Hydratable DeviceProcessData objects with a known value "
+			  "were replaced by DeviceProperty objects with the same object ID, DDI, designator and presentation. "
+			  "The Device designator is prefixed with 'SNAP ' and the structure label is altered. Never upload this pool to a TC." },
+			{ "createdAt", createdAt },
+			{ "clientName", clientName.str() },
+			{ "canonicalPool", input.fileStem + ".ddop" },
+			{ "canonicalDesignator", canonicalDesignator },
+			{ "canonicalStructureLabelHex", to_hex(canonicalStructureLabel) },
+			{ "snapshotStructureLabelHex", to_hex(snapshotStructureLabel) },
+			{ "taskControllerCompatibilityLevel", input.taskControllerCompatibilityLevel },
+			{ "patchedObjects", result.patchedObjects },
+			{ "missingValues", result.missingValues },
+			{ "objects", objects },
+		};
+		// Designators come from the implement and are not guaranteed to be valid UTF-8.
+		const std::string metadataText = metadata.dump(4, ' ', false, json::error_handler_t::replace);
+
+		if (!write_file(result.ddopPath, reinterpret_cast<const char *>(binaryPool.data()), binaryPool.size(), std::ios::binary))
+		{
+			result.error = "unable to write " + result.ddopPath;
+			return result;
+		}
+		if (!write_file(result.metadataPath, metadataText.data(), metadataText.size(), std::ios::out))
+		{
+			result.error = "unable to write " + result.metadataPath;
+			return result;
+		}
+
+		result.success = true;
+		return result;
+	}
+
+	bool is_snapshot_file(const std::filesystem::path &path)
+	{
+		return path.filename().string().find(SNAPSHOT_FILENAME_MARKER) != std::string::npos;
+	}
+} // namespace ddop_hydration
diff --git a/src/task_controller.cpp b/src/task_controller.cpp
index 660da73..baab9af 100644
--- a/src/task_controller.cpp
+++ b/src/task_controller.cpp
@@ -12,6 +12,7 @@
 
 #include "isobus/isobus/isobus_device_descriptor_object_pool_helpers.hpp"
 #include "isobus/isobus/isobus_task_controller_server.hpp"
+#include "isobus/utility/system_timing.hpp"
 
 #include <bitset>
 #include <fstream>
@@ -202,6 +203,33 @@ void ClientState::mark_measurement_commands_sent()
 	areMeasurementCommandsSent = true;
 }
 
+void ClientState::set_canonical_pool(std::vector<std::vector<std::uint8_t>> chunks, std::string fileStem)
+{
+	canonicalPoolChunks = std::make_shared<const std::vector<std::vector<std::uint8_t>>>(std::move(chunks));
+	canonicalFileStem = std::move(fileStem);
+}
+
+const std::vector<std::vector<std::uint8_t>> &ClientState::get_canonical_pool_chunks() const
+{
+	static const std::vector<std::vector<std::uint8_t>> noChunks;
+	return canonicalPoolChunks ? *canonicalPoolChunks : noChunks;
+}
+
+const std::string &ClientState::get_canonical_file_stem() const
+{
+	return canonicalFileStem;
+}
+
+ddop_hydration::ProcessDataIndex &ClientState::get_process_data_index()
+{
+	return processDataIndex;
+}
+
+ddop_hydration::ShadowValueStore &ClientState::get_shadow_values()
+{
+	return shadowValues;
+}
+
 std::uint16_t ClientState::get_element_number_for_ddi(isobus::DataDescriptionIndex ddi) const
 {
 	auto it = ddiToElementNumber.find(ddi);
@@ -365,11 +393,13 @@ bool MyTCServer::activate_object_pool(std::shared_ptr<isobus::ControlFunction> p
 	state.get_pool().set_task_controller_compatibility_level(static_cast<std::uint8_t>(TaskControllerVersion::SecondEditionDraft));
 
 	bool deserialized = false;
+	std::vector<std::vector<std::uint8_t>> canonicalPoolChunks;
 	while (!uploadedPools[partnerCF].empty())
 	{
 		auto binaryPool = uploadedPools[partnerCF].front();
 		uploadedPools[partnerCF].pop();
 		deserialized = state.get_pool().deserialize_binary_object_pool(binaryPool.data(), static_cast<std::uint32_t>(binaryPool.size()), partnerCF->get_NAME());
+		canonicalPoolChunks.push_back(std::move(binaryPool));
 	}
 	if (deserialized)
 	{
@@ -409,7 +439,9 @@ bool MyTCServer::activate_object_pool(std::shared_ptr<isobus::ControlFunction> p
 		auto it = std::find_if(label.begin(), label.end(), [](unsigned char c) { return c < 0x20 || c >= 0x7F; });
 		label.erase(it, label.end());
 
-		auto fileName = std::to_string(partnerCF->get_NAME().get_full_name()) + "/" + sanitize_filename(label) + ".ddop";
+		const auto fileStem = std::to_string(partnerCF->get_NAME().get_full_name()) + "/" + sanitize_filename(label);
+		auto fileName = fileStem + ".ddop";
+		state.set_canonical_pool(std::move(canonicalPoolChunks), fileStem);
 		std::vector<std::uint8_t> binaryPool;
 		if (state.get_pool().generate_binary_object_pool(binaryPool))
 		{
@@ -545,6 +577,7 @@ bool MyTCServer::activate_object_pool(std::shared_ptr<isobus::ControlFunction> p
 		return false;
 	}
 
+	state.get_process_data_index().build(state.get_pool());
 	clients[partnerCF] = state;
 	log("TC Server") << "Client " << partnerCF->get_NAME().get_full_name() << " registered successfully with "
 	                 << static_cast<int>(state.get_number_of_sections()) << " sections." << std::endl;
@@ -632,6 +665,15 @@ bool MyTCServer::on_value_command(std::shared_ptr<isobus::ControlFunction> partn
                                   std::uint8_t &errorCodes)
 {
 	std::lock_guard<std::recursive_mutex> lock(clientsMutex);
+
+	// Keep the latest value per object for hydrated DDOP snapshots
+	auto clientIt = clients.find(partner);
+	std::uint16_t objectID;
+	if ((clientIt != clients.end()) && clientIt->second.get_process_data_index().try_get_object_id(dataDescriptionIndex, elementNumber, objectID))
+	{
+		clientIt->second.get_shadow_values().record(objectID, processDataValue);
+	}
+
 	switch (dataDescriptionIndex)
 	{
 		case static_cast<std::uint16_t>(isobus::DataDescriptionIndex::ActualCondensedWorkState1_16):
@@ -710,6 +752,135 @@ std::map<std::shared_ptr<isobus::ControlFunction>, ClientState> MyTCServer::get_
 	return clients; // copy, taken while locked — see the declaration's comment
 }
 
+MyTCServer::HydrationStartResult MyTCServer::begin_hydration_snapshot(std::shared_ptr<isobus::ControlFunction> client)
+{
+	std::lock_guard<std::recursive_mutex> lock(clientsMutex);
+	if (pendingHydration)
+	{
+		return HydrationStartResult::AlreadyRunning;
+	}
+
+	auto clientIt = clients.find(client);
+	if ((clientIt == clients.end()) || clientIt->second.get_canonical_pool_chunks().empty())
+	{
+		return HydrationStartResult::UnknownClient;
+	}
+
+	auto &state = clientIt->second;
+	PendingHydration pending;
+	pending.client = client;
+	pending.startedAt_ms = isobus::SystemTiming::get_timestamp_ms();
+	std::size_t requestCount = 0;
+
+	for (std::uint16_t i = 0; i < state.get_pool().size(); i++)
+	{
+		auto object = state.get_pool().get_object_by_index(i);
+		if (!object || !ddop_hydration::is_hydratable(*object))
+		{
+			continue;
+		}
+
+		ddop_hydration::SnapshotEntry entry;
+		entry.objectID = object->get_object_id();
+		state.get_process_data_index().try_get_element_number(entry.objectID, entry.elementNumber);
+
+		if (object->get_object_type() == isobus::task_controller_object::ObjectTypes::DeviceProperty)
+		{
+			auto property = std::static_pointer_cast<isobus::task_controller_object::DevicePropertyObject>(object);
+			entry.ddi = property->get_ddi();
+			entry.value = property->get_value();
+			entry.source = ddop_hydration::ValueSource::Pool;
+		}
+		else
+		{
+			entry.ddi = std::static_pointer_cast<isobus::task_controller_object::DeviceProcessDataObject>(object)->get_ddi();
+
+			ddop_hydration::ShadowValue shadowValue;
+			if (state.get_shadow_values().try_get(entry.objectID, shadowValue))
+			{
+				entry.value = shadowValue.value;
+				entry.source = ddop_hydration::ValueSource::Live;
+			}
+			else if (entry.elementNumber != ddop_hydration::SnapshotEntry::NO_ELEMENT)
+			{
+				// The response arrives through on_value_command, which records it in the shadow store.
+				send_request_value(client, entry.ddi, entry.elementNumber);
+				entry.source = ddop_hydration::ValueSource::Requested;
+				requestCount++;
+			}
+			else
+			{
+				entry.source = ddop_hydration::ValueSource::NotRequestable;
+			}
+		}
+		pending.entries.push_back(entry);
+	}
+
+	pending.wait_ms = (requestCount > 0) ? ddop_hydration::REQUEST_WAIT_MS : 0;
+	log("TC Server") << "Hydration snapshot for client " << client->get_NAME().get_full_name() << ": " << pending.entries.size()
+	                 << " hydratable objects, " << requestCount << " value requests sent" << std::endl;
+	pendingHydration = std::move(pending);
+	return HydrationStartResult::Started;
+}
+
+bool MyTCServer::poll_hydration_snapshot(ddop_hydration::SnapshotResult &result)
+{
+	ddop_hydration::SnapshotInput input;
+	{
+		std::lock_guard<std::recursive_mutex> lock(clientsMutex);
+		if (!pendingHydration || !isobus::SystemTiming::time_expired_ms(pendingHydration->startedAt_ms, pendingHydration->wait_ms))
+		{
+			return false;
+		}
+
+		auto clientIt = clients.find(pendingHydration->client);
+		if (clientIt == clients.end())
+		{
+			pendingHydration.reset();
+			result = ddop_hydration::SnapshotResult();
+			result.error = "implement disconnected";
+			return true;
+		}
+
+		auto &state = clientIt->second;
+		for (auto &entry : pendingHydration->entries)
+		{
+			ddop_hydration::ShadowValue shadowValue;
+			if (entry.source != ddop_hydration::ValueSource::Requested)
+			{
+				continue;
+			}
+			if (state.get_shadow_values().try_get(entry.objectID, shadowValue))
+			{
+				entry.value = shadowValue.value;
+			}
+			else
+			{
+				entry.source = ddop_hydration::ValueSource::NoResponse;
+			}
+		}
+
+		input.canonicalPoolChunks = state.get_canonical_pool_chunks();
+		input.taskControllerCompatibilityLevel = state.get_pool().get_task_controller_compatibility_level();
+		input.clientName = pendingHydration->client->get_NAME().get_full_name();
+		input.fileStem = state.get_canonical_file_stem();
+		input.entries = std::move(pendingHydration->entries);
+		pendingHydration.reset();
+	}
+
+	// Deserializing and file I/O happen outside the lock so CAN callbacks are not held up.
+	try
+	{
+		result = ddop_hydration::write_snapshot(input);
+	}
+	catch (const std::exception &e)
+	{
+		result = ddop_hydration::SnapshotResult();
+		result.error = e.what();
+	}
+	return true;
+}
+
 void MyTCServer::request_measurement_commands()
 {
 	std::lock_guard<std::recursive_mutex> lock(clientsMutex);
diff --git a/tools/ddop_hydration_test.cpp b/tools/ddop_hydration_test.cpp
new file mode 100644
index 0000000..18cc9c2
--- /dev/null
+++ b/tools/ddop_hydration_test.cpp
@@ -0,0 +1,170 @@
+// Offline test for hydrated DDOP snapshots: builds a small DDOP, hydrates it and reads the result back.
+#include "ddop_hydration.hpp"
+
+#include "isobus/isobus/can_constants.hpp"
+#include "isobus/isobus/isobus_standard_data_description_indices.hpp"
+#include "isobus/utility/iop_file_interface.hpp"
+
+#include <cstdio>
+#include <filesystem>
+#include <fstream>
+#include <nlohmann/json.hpp>
+#include <string>
+
+namespace
+{
+	using isobus::task_controller_object::DeviceElementObject;
+	using isobus::task_controller_object::DeviceProcessDataObject;
+	using isobus::task_controller_object::DevicePropertyObject;
+	using isobus::task_controller_object::ObjectTypes;
+	using Trigger = DeviceProcessDataObject::AvailableTriggerMethods;
+
+	int failures = 0;
+
+	void check(bool condition, const char *description)
+	{
+		if (!condition)
+		{
+			std::printf("FAIL: %s\n", description);
+			failures++;
+		}
+	}
+
+	constexpr std::uint16_t OFFSET_X_ID = 10; // on-change, live value known
+	constexpr std::uint16_t WIDTH_TOTAL_ID = 11; // on-change but flagged as a total
+	constexpr std::uint16_t WORK_STATE_ID = 12; // always excluded
+	constexpr std::uint16_t OFFSET_Y_PROPERTY_ID = 13; // device property
+	constexpr std::uint16_t OFFSET_Z_ID = 14; // on-change, requested but never answered
+	constexpr std::uint16_t MAX_WIDTH_INTERVAL_ID = 15; // no on-change trigger
+	constexpr std::uint16_t SETPOINT_ID = 16; // on-change setpoint
+	constexpr std::uint16_t SECTION_ELEMENT_ID = 2;
+	constexpr std::uint16_t SECTION_ELEMENT_NUMBER = 1;
+
+	std::uint8_t triggers(Trigger trigger)
+	{
+		return static_cast<std::uint8_t>(trigger);
+	}
+
+	isobus::DeviceDescriptorObjectPool build_canonical_pool()
+	{
+		using isobus::DataDescriptionIndex;
+		isobus::DeviceDescriptorObjectPool pool(3);
+		pool.add_device("Test sprayer", "1.0", "123", "ABCDEFG", { 'e', 'n', 0x50, 0x00, 0x00, 0x00, 0xFF }, {}, 0);
+		pool.add_device_element("Sprayer", 0, 0, DeviceElementObject::Type::Device, 1);
+		pool.add_device_element("Section 1", SECTION_ELEMENT_NUMBER, 1, DeviceElementObject::Type::Section, SECTION_ELEMENT_ID);
+
+		pool.add_device_process_data("Offset X", static_cast<std::uint16_t>(DataDescriptionIndex::DeviceElementOffsetX), isobus::NULL_OBJECT_ID, 0, triggers(Trigger::OnChange), OFFSET_X_ID);
+		pool.add_device_process_data("Width", static_cast<std::uint16_t>(DataDescriptionIndex::ActualWorkingWidth), isobus::NULL_OBJECT_ID, 0, triggers(Trigger::OnChange) | triggers(Trigger::Total), WIDTH_TOTAL_ID);
+		pool.add_device_process_data("Work state", static_cast<std::uint16_t>(DataDescriptionIndex::ActualWorkState), isobus::NULL_OBJECT_ID, 0, triggers(Trigger::OnChange), WORK_STATE_ID);
+		pool.add_device_property("Offset Y", 500, static_cast<std::uint16_t>(DataDescriptionIndex::DeviceElementOffsetY), isobus::NULL_OBJECT_ID, OFFSET_Y_PROPERTY_ID);
+		pool.add_device_process_data("Offset Z", static_cast<std::uint16_t>(DataDescriptionIndex::DeviceElementOffsetZ), isobus::NULL_OBJECT_ID, 0, triggers(Trigger::OnChange), OFFSET_Z_ID);
+		pool.add_device_process_data("Max width", static_cast<std::uint16_t>(DataDescriptionIndex::MaximumWorkingWidth), isobus::NULL_OBJECT_ID, 0, triggers(Trigger::TimeInterval), MAX_WIDTH_INTERVAL_ID);
+		pool.add_device_process_data("Setpoint width", static_cast<std::uint16_t>(DataDescriptionIndex::SetpointWorkingWidth), isobus::NULL_OBJECT_ID, 2, triggers(Trigger::OnChange), SETPOINT_ID);
+
+		auto section = std::static_pointer_cast<DeviceElementObject>(pool.get_object_by_id(SECTION_ELEMENT_ID));
+		for (std::uint16_t child : { OFFSET_X_ID, WIDTH_TOTAL_ID, WORK_STATE_ID, OFFSET_Y_PROPERTY_ID, OFFSET_Z_ID, MAX_WIDTH_INTERVAL_ID, SETPOINT_ID })
+		{
+			section->add_reference_to_child_object(child);
+		}
+		return pool;
+	}
+} // namespace
+
+int main()
+{
+	auto canonicalPool = build_canonical_pool();
+	std::vector<std::uint8_t> canonicalBinary;
+	check(canonicalPool.generate_binary_object_pool(canonicalBinary), "canonical test pool generates");
+
+	// Automatic eligibility
+	check(ddop_hydration::is_hydratable(*canonicalPool.get_object_by_id(OFFSET_X_ID)), "on-change offset is hydratable");
+	check(!ddop_hydration::is_hydratable(*canonicalPool.get_object_by_id(WIDTH_TOTAL_ID)), "total is not hydratable");
+	check(!ddop_hydration::is_hydratable(*canonicalPool.get_object_by_id(WORK_STATE_ID)), "work state is not hydratable");
+	check(!ddop_hydration::is_hydratable(*canonicalPool.get_object_by_id(SETPOINT_ID)), "setpoint is not hydratable");
+	check(ddop_hydration::is_hydratable(*canonicalPool.get_object_by_id(OFFSET_Y_PROPERTY_ID)), "device property is hydratable");
+	check(!ddop_hydration::is_hydratable(*canonicalPool.get_object_by_id(MAX_WIDTH_INTERVAL_ID)), "process data without on-change is not hydratable");
+
+	// Index
+	ddop_hydration::ProcessDataIndex index;
+	index.build(canonicalPool);
+	std::uint16_t objectID = 0;
+	check(index.try_get_object_id(static_cast<std::uint16_t>(isobus::DataDescriptionIndex::DeviceElementOffsetX), SECTION_ELEMENT_NUMBER, objectID) && (objectID == OFFSET_X_ID),
+	      "index maps (DDI, element) to object ID");
+
+	// Snapshot
+	ddop_hydration::SnapshotInput input;
+	input.canonicalPoolChunks = { canonicalBinary };
+	input.taskControllerCompatibilityLevel = 3;
+	input.fileStem = "ddop-hydration-test/test-label";
+	input.entries = {
+		{ OFFSET_X_ID, static_cast<std::uint16_t>(isobus::DataDescriptionIndex::DeviceElementOffsetX), SECTION_ELEMENT_NUMBER, ddop_hydration::ValueSource::Live, 1234 },
+		{ OFFSET_Y_PROPERTY_ID, static_cast<std::uint16_t>(isobus::DataDescriptionIndex::DeviceElementOffsetY), SECTION_ELEMENT_NUMBER, ddop_hydration::ValueSource::Pool, 500 },
+		{ OFFSET_Z_ID, static_cast<std::uint16_t>(isobus::DataDescriptionIndex::DeviceElementOffsetZ), SECTION_ELEMENT_NUMBER, ddop_hydration::ValueSource::NoResponse, 0 },
+	};
+
+	const auto result = ddop_hydration::write_snapshot(input);
+	check(result.success, "snapshot is written");
+	if (!result.success)
+	{
+		std::printf("snapshot error: %s\n", result.error.c_str());
+		return 1;
+	}
+	check(result.patchedObjects == 1, "one object patched");
+	check(result.missingValues == 1, "one value missing");
+	check(ddop_hydration::is_snapshot_file(result.ddopPath), "snapshot file is recognized as a snapshot");
+	check(!ddop_hydration::is_snapshot_file("123/test-label.ddop"), "canonical file is not recognized as a snapshot");
+
+	auto snapshotBinary = isobus::IOPFileInterface::read_iop_file(result.ddopPath);
+	isobus::DeviceDescriptorObjectPool snapshotPool(3);
+	check(snapshotPool.deserialize_binary_object_pool(snapshotBinary), "snapshot deserializes");
+
+	auto patched = snapshotPool.get_object_by_id(OFFSET_X_ID);
+	check(patched && (patched->get_object_type() == ObjectTypes::DeviceProperty), "live process data became a device property");
+	if (patched && (patched->get_object_type() == ObjectTypes::DeviceProperty))
+	{
+		auto property = std::static_pointer_cast<DevicePropertyObject>(patched);
+		check(property->get_value() == 1234, "patched value");
+		check(property->get_ddi() == static_cast<std::uint16_t>(isobus::DataDescriptionIndex::DeviceElementOffsetX), "patched DDI");
+		check(property->get_designator() == "Offset X", "patched designator");
+	}
+	auto missing = snapshotPool.get_object_by_id(OFFSET_Z_ID);
+	check(missing && (missing->get_object_type() == ObjectTypes::DeviceProcessData), "unanswered process data stays process data");
+
+	auto section = std::dynamic_pointer_cast<DeviceElementObject>(snapshotPool.get_object_by_id(SECTION_ELEMENT_ID));
+	bool stillReferenced = false;
+	if (section)
+	{
+		for (std::uint16_t child : section->get_child_object_ids())
+		{
+			stillReferenced = stillReferenced || (child == OFFSET_X_ID);
+		}
+	}
+	check(stillReferenced, "section still references the patched object");
+
+	std::shared_ptr<isobus::task_controller_object::DeviceObject> device;
+	for (std::uint16_t i = 0; (i < snapshotPool.size()) && !device; i++)
+	{
+		auto object = snapshotPool.get_object_by_index(i);
+		if (object && (object->get_object_type() == ObjectTypes::Device))
+		{
+			device = std::static_pointer_cast<isobus::task_controller_object::DeviceObject>(object);
+		}
+	}
+	check(device && (device->get_designator().rfind("SNAP ", 0) == 0), "device designator is prefixed");
+	check(device && (device->get_structure_label().rfind("SNAP", 0) == 0), "structure label is altered");
+
+	auto original = canonicalPool.get_object_by_id(OFFSET_X_ID);
+	check(original && (original->get_object_type() == ObjectTypes::DeviceProcessData), "canonical pool is untouched");
+
+	std::ifstream metadataFile(result.metadataPath);
+	const auto metadata = nlohmann::json::parse(metadataFile, nullptr, false);
+	check(!metadata.is_discarded() && metadata.value("notForReupload", false), "sidecar marks the snapshot as not for re-upload");
+	check(!metadata.is_discarded() && (metadata["objects"].size() == 3), "sidecar lists every entry");
+	metadataFile.close();
+
+	std::error_code cleanupError;
+	std::filesystem::remove_all(std::filesystem::path(result.ddopPath).parent_path(), cleanupError);
+
+	std::printf(failures == 0 ? "All ddop hydration checks passed\n" : "%d ddop hydration check(s) failed\n", failures);
+	return (failures == 0) ? 0 : 1;
+}