diff --git a/ACT/LibMC.xml b/ACT/LibMC.xml
index 6573f5486..2fd523ab1 100644
--- a/ACT/LibMC.xml
+++ b/ACT/LibMC.xml
@@ -744,6 +744,16 @@
 		<error name="INVALIDTOOLPATHPROFILEINDEX" code="719" description="Invalid toolpath profile index." />
 		<error name="INVALIDTOOLPATHMODIFIERINDEX" code="720" description="Invalid toolpath modifier index." />
 				
+		<error name="NOSTREAMRESULT" code="721" description="API response is not a stream." />
+		<error name="DOWNLOADCANCELLED" code="722" description="Download was cancelled." />
+		<error name="INVALIDSTREAMCHUNK" code="723" description="Invalid stream chunk range." />
+		<error name="DOWNLOADTICKETEXPIRED" code="724" description="Download ticket has expired or has been revoked." />
+		<error name="TOOMANYDOWNLOADS" code="725" description="Too many concurrent downloads." />
+		<error name="CLIENTACTIONNOTFOUND" code="726" description="Client action not found." />
+		<error name="CLIENTACTIONALREADYCLAIMED" code="727" description="Client action has already been claimed." />
+		<error name="STREAMHASACTIVEDOWNLOADS" code="728" description="Storage stream has active downloads." />
+		<error name="SESSIONHANDLERNOTAVAILABLE" code="729" description="Session handler is not available." />
+
 		
 		
 		
@@ -866,9 +876,33 @@
 		</method>
 		
 		<method name="GetContentDispositionName" description="returns the cached stream content disposition string of the resulting data. Call only after Handle().">
-			<param name="ContentDispositionName" type="string" pass="return" description="Returns non-empty string if content disposition header should be added." />	
+			<param name="ContentDispositionName" type="string" pass="return" description="Returns non-empty string if content disposition header should be added." />
 		</method>
-		
+
+		<method name="SetClientAddress" description="Sets the network address of the client that sent the request. Call before Handle().">
+			<param name="Address" type="string" pass="in" description="Network address of the client." />
+		</method>
+
+		<method name="HasStreamResult" description="Returns true if the result is a storage stream that must be sent in chunks with ReadResultStreamChunk instead of a buffer. Call only after Handle().">
+			<param name="HasStream" type="bool" pass="return" description="Result is a stream." />
+		</method>
+
+		<method name="GetResultStreamInfo" description="Returns size and validators of the result stream. Fails if the result is not a stream.">
+			<param name="Size" type="uint64" pass="out" description="Stream size in bytes." />
+			<param name="ETag" type="string" pass="out" description="Strong entity tag of the stream, without quotes." />
+			<param name="LastModified" type="string" pass="out" description="Creation time of the stream as HTTP date." />
+		</method>
+
+		<method name="ReadResultStreamChunk" description="Reads a part of the result stream and records it as sent. Fails if the range is outside the stream, the length exceeds 16 MiB or the download was cancelled.">
+			<param name="Offset" type="uint64" pass="in" description="Start position in bytes." />
+			<param name="Length" type="uint64" pass="in" description="Number of bytes to read." />
+			<param name="Data" type="basicarray" class="uint8" pass="out" description="Data that was read." />
+		</method>
+
+		<method name="FinishStreamResult" description="Reports that sending the result stream has ended. May be called more than once and without any chunk having been read.">
+			<param name="Success" type="bool" pass="in" description="All requested bytes were sent." />
+		</method>
+
 	</class>
 
 
diff --git a/ACT/LibMCData.xml b/ACT/LibMCData.xml
index dc5583b37..7aab68f13 100644
--- a/ACT/LibMCData.xml
+++ b/ACT/LibMCData.xml
@@ -453,6 +453,21 @@
 		<error name="JOBNAMETOOLONG" code="451" description="Job name exceeds maximum allowed length" />
 		<error name="STRINGPARAMETERTOOLONG" code="452" description="String parameter exceeds maximum allowed length" />
 		<error name="TELEMETRYSETTINGAFTERINITIALISATION" code="453" description="Telemetry setting changed after database initialisation" />
+		<error name="DATACAPTURENOTFOUND" code="454" description="Data capture not found." />
+		<error name="DUPLICATEDATACAPTUREIDENTIFIER" code="455" description="Duplicate data capture identifier." />
+		<error name="INVALIDDATACAPTUREIDENTIFIER" code="456" description="Invalid data capture identifier." />
+		<error name="INVALIDDATACAPTURENAME" code="457" description="Invalid data capture name." />
+		<error name="DATACAPTURENOTRECORDING" code="458" description="Data capture is not recording." />
+		<error name="INVALIDDATACAPTURESTATUS" code="459" description="Invalid data capture status." />
+		<error name="INVALIDDATACAPTURECOLUMNINDEX" code="460" description="Invalid data capture column index." />
+		<error name="INVALIDDATACAPTURESEGMENTINDEX" code="461" description="Invalid data capture segment index." />
+		<error name="DUPLICATEDATACAPTURESEGMENT" code="462" description="Duplicate data capture segment." />
+		<error name="DUPLICATEDATACAPTURECOLUMN" code="463" description="Duplicate data capture column." />
+		<error name="DATACAPTUREALREADYABORTED" code="464" description="Data capture has already been aborted." />
+		<error name="RANDOMWRITESTREAMNOTFOUND" code="465" description="Random write stream not found." />
+		<error name="DOWNLOADENTRYNOTFOUND" code="466" description="Download access log entry not found." />
+		<error name="STREAMHASACTIVEWRITER" code="467" description="Storage stream is still being written." />
+		<error name="ZIPSTREAMALREADYFINISHED" code="468" description="ZIP stream has already been finished and can not be discarded." />
 
 	</errors>
 	
@@ -536,6 +551,13 @@
 		<option name="IntervalEndMarker" value="3"/>
 	</enum>		
 	
+	<enum name="DataCaptureStatus">
+		<option name="Unknown" value="0" />
+		<option name="Recording" value="1" />
+		<option name="Finished" value="2" />
+		<option name="Aborted" value="3" />
+	</enum>
+
 	<enum name="BuildJobExecutionStatus">
 		<option name="Unknown" value="0" />
 		<option name="InProcess" value="1" />
@@ -1136,7 +1158,10 @@
 		<method name="IsFinished" description="Returns if the stream writing has already been finished.">
 			<param name="Finished" type="bool" pass="return" description="If true, writing into the stream is not possible anymore." />
 		</method>
-		
+
+		<method name="Discard" description="Discards an unfinished ZIP stream. The file on disk and the stream entry are deleted. Fails if the stream has been finished already. A ZIP writer that is released without Finish is discarded automatically.">
+		</method>
+
 	</class>
 
 
@@ -1252,11 +1277,66 @@
 			<param name="UserUUID" type="string" pass="out" description="UUID of user that created the ticket." />	
 		</method>	
 
+		<method name="GetDownloadTicketDetails" description="Returns the details of a download ticket without creating an access log entry. Fails if the ticket does not exist.">
+			<param name="TicketUUID" type="string" pass="in" description="UUID of download ticket." />
+			<param name="StreamUUID" type="string" pass="out" description="UUID of storage stream." />
+			<param name="ClientFileName" type="string" pass="out" description="ClientFileName of the ticket." />
+			<param name="SessionUUID" type="string" pass="out" description="UUID of user session." />
+			<param name="UserUUID" type="string" pass="out" description="UUID of user that created the ticket." />
+			<param name="CreationTimeStamp" type="uint64" pass="out" description="Creation time of the ticket in microseconds since 1970." />
+			<param name="Revoked" type="bool" pass="out" description="True if the ticket has been revoked." />
+		</method>
+
+		<method name="RevokeDownloadTicketsOfStream" description="Revokes all download tickets of a stream. Revoked tickets can not be used for downloads anymore.">
+			<param name="StreamUUID" type="string" pass="in" description="UUID of storage stream." />
+			<param name="RevokedCount" type="uint32" pass="return" description="Number of tickets that were revoked by this call." />
+		</method>
+
+		<method name="LogDownloadStart" description="Creates an entry in the download access log of a ticket and returns the UUID of the entry.">
+			<param name="TicketUUID" type="string" pass="in" description="UUID of download ticket." />
+			<param name="IPAddress" type="string" pass="in" description="IP Address where the request came from." />
+			<param name="AbsoluteTimeStamp" type="uint64" pass="in" description="Absolute Time Stamp in Microseconds since 1970." />
+			<param name="DownloadUUID" type="string" pass="return" description="UUID of the access log entry." />
+		</method>
+
+		<method name="LogDownloadFinish" description="Records the result of a download in its access log entry. Fails if the entry does not exist.">
+			<param name="DownloadUUID" type="string" pass="in" description="UUID of the access log entry." />
+			<param name="SentBytes" type="uint64" pass="in" description="Number of bytes that were sent to the client." />
+			<param name="Success" type="bool" pass="in" description="True if all requested bytes were sent." />
+			<param name="AbsoluteTimeStamp" type="uint64" pass="in" description="Absolute Time Stamp in Microseconds since 1970." />
+		</method>
+
+		<method name="DeleteStream" description="Deletes a finished stream from disk and database, including its download tickets and journal links. Fails if the stream does not exist or is still being written.">
+			<param name="UUID" type="string" pass="in" description="UUID of storage stream." />
+		</method>
+
+		<method name="DiscardUnfinishedZIPStreams" description="Deletes all ZIP streams that were never finished and have no active writer, for example after a crash. Returns the number of deleted streams.">
+			<param name="DeletedCount" type="uint32" pass="return" description="Number of deleted streams." />
+		</method>
+
+		<method name="ListStreamUUIDsByName" description="Returns the UUIDs of all finished streams with the given name, newest first, separated by commas.">
+			<param name="Name" type="string" pass="in" description="Name of the streams." />
+			<param name="UUIDList" type="string" pass="return" description="Comma separated list of stream UUIDs. Empty if there is none." />
+		</method>
+
 		<method name="AttachStreamToJournal" description="Attaches a stream to a journal as temporary stream.">
 			<param name="StreamUUID" type="string" pass="in" description="UUID of stream. Call fails if stream does not exist." />	
 			<param name="JournalUUID" type="string" pass="in" description="UUID of journal. Call fails if journal does not exist." />	
 		</method>	
 
+		<method name="DiscardRandomWriteStream" description="Discards an unfinished random write stream. The data on disk and the stream entry are deleted.">
+			<param name="UUID" type="string" pass="in" description="UUID of storage stream. MUST have been created with BeginRandomWriteStream first and MUST NOT be finished." />
+		</method>
+
+		<method name="GetDataCaptureStorageSize" description="Returns the size of all data capture segments that are stored on disk.">
+			<param name="SizeInBytes" type="uint64" pass="return" description="Size in bytes." />
+		</method>
+
+		<method name="EnforceDataCaptureStorageLimit" description="Deletes the oldest stored data capture segments until the total stored size is within the limit.">
+			<param name="LimitInBytes" type="uint64" pass="in" description="Maximum total size of all stored data capture segments in bytes." />
+			<param name="PurgedSegmentCount" type="uint32" pass="return" description="Number of segments that have been deleted." />
+		</method>
+
 	</class>
 
 
@@ -1346,6 +1426,97 @@
 
 
     <!-- The BuildJobExecution class is not thread safe and MUST ONLY be used in a single thread context... -->
+	<class name="DataCapture" parent="Base" description="Manifest of a streaming data capture that belongs to a build job execution. It ties the segment streams of the capture together.">
+
+		<method name="GetUUID" description="returns the uuid of the data capture.">
+			<param name="UUID" type="string" pass="return" description="UUID String" />
+		</method>
+
+		<method name="GetExecutionUUID" description="returns the uuid of the build job execution the capture belongs to.">
+			<param name="ExecutionUUID" type="string" pass="return" description="UUID String" />
+		</method>
+
+		<method name="GetIdentifier" description="returns the identifier of the data capture. It is unique within the build job execution.">
+			<param name="Identifier" type="string" pass="return" description="Identifier String" />
+		</method>
+
+		<method name="GetName" description="returns the human readable name of the data capture.">
+			<param name="Name" type="string" pass="return" description="Name String" />
+		</method>
+
+		<method name="GetStatus" description="returns the current status of the data capture.">
+			<param name="Status" type="enum" class="DataCaptureStatus" pass="return" description="Status Value" />
+		</method>
+
+		<method name="GetTimeStamp" description="returns the time stamp when the data capture was created.">
+			<param name="TimeStamp" type="string" pass="return" description="Timestamp in ISO8601 UTC format" />
+		</method>
+
+		<method name="AddColumn" description="Registers a column of the capture schema. Fails if the capture is not recording or the column index already exists.">
+			<param name="ColumnIndex" type="uint32" pass="in" description="Index of the column. 0-based." />
+			<param name="Identifier" type="string" pass="in" description="Identifier of the column." />
+			<param name="Description" type="string" pass="in" description="Description of the column." />
+			<param name="ColumnType" type="uint32" pass="in" description="Data type of the column as numeric data table column type." />
+		</method>
+
+		<method name="GetColumnCount" description="returns the number of columns of the capture schema.">
+			<param name="ColumnCount" type="uint32" pass="return" description="Number of columns." />
+		</method>
+
+		<method name="GetColumnInformation" description="returns the schema information of a column. Fails if the index does not exist.">
+			<param name="ColumnIndex" type="uint32" pass="in" description="Index of the column. 0-based." />
+			<param name="Identifier" type="string" pass="out" description="Identifier of the column." />
+			<param name="Description" type="string" pass="out" description="Description of the column." />
+			<param name="ColumnType" type="uint32" pass="out" description="Data type of the column as numeric data table column type." />
+		</method>
+
+		<method name="AddSegment" description="Registers a finished segment stream of the capture. Fails if the capture is not recording or the segment index already exists.">
+			<param name="SegmentIndex" type="uint32" pass="in" description="Index of the segment. 0-based." />
+			<param name="StreamUUID" type="string" pass="in" description="UUID of the storage stream that holds the segment. The stream MUST exist." />
+			<param name="FirstRow" type="uint64" pass="in" description="Index of the first row of the segment within the capture." />
+			<param name="RowCount" type="uint64" pass="in" description="Number of rows in the segment." />
+			<param name="ChunkCount" type="uint32" pass="in" description="Number of chunks in the segment." />
+			<param name="SizeInBytes" type="uint64" pass="in" description="Size of the segment stream in bytes." />
+			<param name="StartTimeStamp" type="uint64" pass="in" description="Absolute time stamp in microseconds since 1970 when the segment was opened." />
+			<param name="EndTimeStamp" type="uint64" pass="in" description="Absolute time stamp in microseconds since 1970 when the segment was closed." />
+		</method>
+
+		<method name="GetSegmentCount" description="returns the number of registered segments, including purged ones.">
+			<param name="SegmentCount" type="uint32" pass="return" description="Number of segments." />
+		</method>
+
+		<method name="GetSegmentInformation" description="returns the manifest entry of a segment. Fails if the index does not exist.">
+			<param name="SegmentIndex" type="uint32" pass="in" description="Index of the segment. 0-based." />
+			<param name="StreamUUID" type="string" pass="out" description="UUID of the storage stream that holds the segment." />
+			<param name="FirstRow" type="uint64" pass="out" description="Index of the first row of the segment within the capture." />
+			<param name="RowCount" type="uint64" pass="out" description="Number of rows in the segment." />
+			<param name="SizeInBytes" type="uint64" pass="out" description="Size of the segment stream in bytes." />
+			<param name="IsPurged" type="bool" pass="out" description="Returns true if the segment data has been deleted by retention or abort." />
+		</method>
+
+		<method name="GetSegmentChunkCount" description="returns the number of chunks of a segment. Fails if the index does not exist.">
+			<param name="SegmentIndex" type="uint32" pass="in" description="Index of the segment. 0-based." />
+			<param name="ChunkCount" type="uint32" pass="return" description="Number of chunks in the segment." />
+		</method>
+
+		<method name="GetRowCount" description="returns the number of rows in all registered segments, including purged ones.">
+			<param name="RowCount" type="uint64" pass="return" description="Number of rows." />
+		</method>
+
+		<method name="GetStoredSizeInBytes" description="returns the size of all segments of the capture that are still stored on disk.">
+			<param name="SizeInBytes" type="uint64" pass="return" description="Size in bytes." />
+		</method>
+
+		<method name="Finish" description="Marks the capture as finished. Fails if the capture is not recording.">
+			<param name="AbsoluteTimeStamp" type="uint64" pass="in" description="Absolute Time Stamp in Microseconds since 1970." />
+		</method>
+
+		<method name="Abort" description="Deletes all stored segments of the capture and marks it as aborted. Fails if the capture has been aborted before.">
+			<param name="AbsoluteTimeStamp" type="uint64" pass="in" description="Absolute Time Stamp in Microseconds since 1970." />
+		</method>
+
+	</class>
+
 	<class name="BuildJobExecution" parent="Base" description="Build Job Execution instance, handling a specific execution of the build job.">
 
 		<method name="GetExecutionUUID" description="returns the uuid of a build job execution.">
@@ -1470,6 +1641,33 @@
 			<param name="Value" type="string" pass="return" description="Return value." />
 		</method>
 
+		<method name="CreateDataCapture" description="Creates the manifest of a new data capture in recording state. Fails if the identifier already exists in this execution.">
+			<param name="Identifier" type="string" pass="in" description="Identifier of the capture. MUST be unique within the execution, alphanumeric and not empty." />
+			<param name="Name" type="string" pass="in" description="Human readable name of the capture. MUST NOT be empty." />
+			<param name="UserUUID" type="string" pass="in" description="UUID of the user that started the capture. Use 00000000-0000-0000-0000-000000000000 if no user shall be recorded." />
+			<param name="AbsoluteTimeStamp" type="uint64" pass="in" description="Absolute Time Stamp in Microseconds since 1970." />
+			<param name="DataCaptureInstance" type="class" class="DataCapture" pass="return" description="Data capture manifest instance." />
+		</method>
+
+		<method name="HasDataCapture" description="Returns if a data capture with a specific identifier exists in this execution.">
+			<param name="Identifier" type="string" pass="in" description="Identifier of the capture." />
+			<param name="HasDataCapture" type="bool" pass="return" description="Returns true, if the data capture exists." />
+		</method>
+
+		<method name="RetrieveDataCapture" description="Retrieves the manifest of a data capture by its identifier. Fails if the identifier does not exist.">
+			<param name="Identifier" type="string" pass="in" description="Identifier of the capture." />
+			<param name="DataCaptureInstance" type="class" class="DataCapture" pass="return" description="Data capture manifest instance." />
+		</method>
+
+		<method name="GetDataCaptureCount" description="Returns the number of data captures of this execution.">
+			<param name="DataCaptureCount" type="uint32" pass="return" description="Number of data captures." />
+		</method>
+
+		<method name="RetrieveDataCaptureByIndex" description="Retrieves the manifest of a data capture of this execution by its index. Captures are ordered by their creation time.">
+			<param name="Index" type="uint32" pass="in" description="Index of the capture. 0-based. Fails if the index is out of bounds." />
+			<param name="DataCaptureInstance" type="class" class="DataCapture" pass="return" description="Data capture manifest instance." />
+		</method>
+
 	</class>
 
     <!-- The BuildJobExecutionIterator class is not thread safe and MUST ONLY be used in a single thread context... -->
@@ -1730,6 +1928,11 @@
 			<param name="IteratorInstance" type="class" class="BuildJobExecutionIterator" pass="return" description="Returns the list of execution instances that changed. List may be empty." />
 		</method>
 			
+		<method name="RetrieveDataCapture" description="Retrieves the manifest of a data capture by its uuid. Fails if the capture does not exist.">
+			<param name="DataCaptureUUID" type="string" pass="in" description="UUID of the data capture." />
+			<param name="DataCaptureInstance" type="class" class="DataCapture" pass="return" description="Data capture manifest instance." />
+		</method>
+
 	</class>
 
 
diff --git a/ACT/LibMCEnv.xml b/ACT/LibMCEnv.xml
index 32a5748e9..b6ef258a8 100644
--- a/ACT/LibMCEnv.xml
+++ b/ACT/LibMCEnv.xml
@@ -307,6 +307,44 @@
 		<error name="FORMULAEVALUATIONFAILED" code="10267" description="Formula evaluation failed." />
 		<error name="FORMULASESSIONREFERENCESNOTAVAILABLE" code="10268" description="Session and user references are only available in formulas of the UI environment." />
 		<error name="INVALIDFORMULAREFERENCEINDEX" code="10269" description="Invalid formula reference index." />			
+		<error name="COLUMNISNOTOFTYPEFLOAT" code="10270" description="Column is not of type float." />
+		<error name="COLUMNISNOTOFTYPEBOOL" code="10271" description="Column is not of type bool." />
+		<error name="COLUMNISNOTOFTYPETIMESTAMP" code="10272" description="Column is not of type timestamp." />
+		<error name="UNSUPPORTEDDATATABLEVERSION" code="10273" description="Unsupported datatable format version." />
+		<error name="UNSUPPORTEDDATATABLEENCODING" code="10274" description="Unsupported datatable column encoding." />
+		<error name="INVALIDDATATABLECOLUMNHEADER" code="10275" description="Invalid datatable column header." />
+		<error name="DATACAPTURENOTCONFIGURABLE" code="10276" description="Data capture schema is frozen and can not be changed anymore." />
+		<error name="DATACAPTURENOTRECORDING" code="10277" description="Data capture is not recording." />
+		<error name="DATACAPTURECHUNKALREADYOPEN" code="10278" description="Data capture has an uncommitted chunk already." />
+		<error name="DATACAPTURECHUNKINVALID" code="10279" description="Data capture chunk is invalid or has been committed already." />
+		<error name="DATACAPTURECHUNKINCOMPLETE" code="10280" description="Data capture chunk columns have different row counts." />
+		<error name="DATACAPTURECHUNKOVERFLOW" code="10281" description="Data capture chunk capacity exceeded." />
+		<error name="DATACAPTUREQUEUEFULL" code="10282" description="Data capture queue is full." />
+		<error name="DATACAPTUREWRITERFAILED" code="10283" description="Data capture writer failed." />
+		<error name="INVALIDDATACAPTUREOPTION" code="10284" description="Invalid data capture option." />
+		<error name="DATACAPTUREROWNOTOPEN" code="10285" description="Data capture chunk has no open row." />
+		<error name="DATACAPTUREROWALREADYOPEN" code="10286" description="Data capture chunk has an open row already." />
+		<error name="DATACAPTUREVALUEOUTOFRANGE" code="10287" description="Data capture value is out of range for the column type." />
+		<error name="DATACAPTURESEGMENTPURGED" code="10288" description="Data capture segment has been deleted by retention." />
+		<error name="EMPTYDATACAPTURENAME" code="10289" description="Empty data capture name." />
+		<error name="EMPTYDATACAPTUREIDENTIFIER" code="10290" description="Empty data capture identifier." />
+		<error name="INVALIDDATACAPTUREIDENTIFIER" code="10291" description="Invalid data capture identifier." />
+		<error name="DATACAPTUREEXECUTIONNOTINPROCESS" code="10292" description="Data captures can only be created while the build execution is in process." />
+		<error name="DATATABLESEGMENTTRUNCATED" code="10293" description="Datatable segment is truncated and has no footer." />
+		<error name="UNSUPPORTEDDATATABLECODEC" code="10294" description="Unsupported datatable page codec." />
+		<error name="INVALIDDATATABLESEGMENT" code="10295" description="Invalid datatable segment." />
+		<error name="DATACAPTURECHUNKOUTSTANDING" code="10296" description="Data capture has an uncommitted chunk." />
+		<error name="DATACAPTURECOLUMNTYPEMISMATCH" code="10297" description="Data capture column has a different type." />
+		<error name="INVALIDDATACAPTURESEGMENTINDEX" code="10298" description="Invalid data capture segment index." />
+		<error name="DATACAPTURECOLUMNNOTFOUND" code="10299" description="Data capture column not found." />
+		<error name="INVALIDDATATABLEROWRANGE" code="10300" description="Invalid datatable row range." />
+		<error name="INVALIDDOWNSAMPLEPARAMETERS" code="10301" description="Invalid downsample parameters." />
+		<error name="DATATABLECOLUMNTYPEMISMATCH" code="10302" description="Datatable column can not be read as the requested type." />
+		<error name="INVALIDDATATABLECHUNKINDEX" code="10303" description="Invalid datatable chunk index." />
+		<error name="STREAMHASACTIVEDOWNLOADS" code="10304" description="Storage stream has active downloads." />
+		<error name="ZIPSTREAMALREADYFINISHED" code="10305" description="ZIP stream has already been finished." />
+		<error name="SESSIONHANDLERNOTAVAILABLE" code="10306" description="Session handler is not available." />
+
 		
 	</errors>
 
@@ -457,8 +495,49 @@
 		<option name="Uint32Column" value="3" />
 		<option name="Int64Column" value="4" />
 		<option name="Uint64Column" value="5" />
+		<option name="FloatColumn" value="6" />
+		<option name="BoolColumn" value="7" />
+		<option name="TimestampColumn" value="8" />
 	</enum>
 	
+	<enum name="DataCaptureBackpressureMode">
+		<option name="Unknown" value="0" />
+		<option name="Block" value="1" />
+		<option name="DropOldest" value="2" />
+		<option name="Fail" value="3" />
+	</enum>
+
+	<enum name="DataCaptureCompression">
+		<option name="Unknown" value="0" />
+		<option name="None" value="1" />
+		<option name="LZ4" value="2" />
+		<option name="Deflate" value="3" />
+	</enum>
+
+	<enum name="DataCaptureEncoding">
+		<option name="Unknown" value="0" />
+		<option name="Automatic" value="1" />
+		<option name="Plain" value="2" />
+		<option name="Delta" value="3" />
+		<option name="BitPack" value="4" />
+	</enum>
+
+	<enum name="DataTableDownsampleMode">
+		<option name="Unknown" value="0" />
+		<option name="Stride" value="1" />
+		<option name="MinMax" value="2" />
+		<option name="Average" value="3" />
+	</enum>
+
+	<enum name="DataCaptureStatus">
+		<option name="Unknown" value="0" />
+		<option name="Configuring" value="1" />
+		<option name="Recording" value="2" />
+		<option name="Finished" value="3" />
+		<option name="Aborted" value="4" />
+		<option name="Failed" value="5" />
+	</enum>
+
 	<enum name="TelemetryChannelType">
 		<option name="Unknown" value="0"/>
 		<option name="CustomMarker" value="1"/>
@@ -1253,6 +1332,10 @@
 			<param name="RowCount" type="uint32" pass="return" description="Number of rows." />
 		</method>
 
+		<method name="GetRowCount64" description="Returns the current row count as 64 bit value. GetRowCount is kept for ABI compatibility and truncates large row counts.">
+			<param name="RowCount" type="uint64" pass="return" description="Number of rows." />
+		</method>
+
 		<method name="GetColumnCount" description="Returns the current column count.">
 			<param name="ColumnCount" type="uint32" pass="return" description="Number of columns." />
 		</method>
@@ -1303,6 +1386,21 @@
 			<param name="Values" type="basicarray" class="uint64" pass="out" description="Value array of a column." />
 		</method>
 
+		<method name="GetFloatColumnValues" description="Returns the values of a float (32 bit) column. Will fail if column does not exist or type is not float.">
+			<param name="Identifier" type="string" pass="in" description="Identifier of the column." />
+			<param name="Values" type="basicarray" class="single" pass="out" description="Value array of a column." />
+		</method>
+
+		<method name="GetBoolColumnValues" description="Returns the values of a bool column as bytes (0 = false, 1 = true). Will fail if column does not exist or type is not bool.">
+			<param name="Identifier" type="string" pass="in" description="Identifier of the column." />
+			<param name="Values" type="basicarray" class="uint8" pass="out" description="Value array of a column. Each entry is 0 or 1." />
+		</method>
+
+		<method name="GetTimestampColumnValues" description="Returns the values of a timestamp column in microseconds. Will fail if column does not exist or type is not timestamp.">
+			<param name="Identifier" type="string" pass="in" description="Identifier of the column." />
+			<param name="Values" type="basicarray" class="uint64" pass="out" description="Value array of a column. Timestamps in microseconds." />
+		</method>
+
 		<method name="SetDoubleColumnValues" description="Sets the values of a double column. Will fail if column does not exist or type is not double.">
 			<param name="Identifier" type="string" pass="in" description="Identifier of the column." />
 			<param name="Values" type="basicarray" class="double" pass="in" description="New Value array of a column. Array length should match RowCount. Values will be filled up with 0, if length is less than RowCount. RowCount will be extended if length is larger than RowCount." />
@@ -1327,6 +1425,21 @@
 			<param name="Identifier" type="string" pass="in" description="Identifier of the column." />
 			<param name="Values" type="basicarray" class="uint64" pass="in" description="New Value array of a column. Array length should match RowCount. Values will be filled up with 0, if length is less than RowCount. RowCount will be extended if length is larger than RowCount." />
 		</method>
+
+		<method name="SetFloatColumnValues" description="Sets the values of a float (32 bit) column. Will fail if column does not exist or type is not float.">
+			<param name="Identifier" type="string" pass="in" description="Identifier of the column." />
+			<param name="Values" type="basicarray" class="single" pass="in" description="New Value array of a column. Array length should match RowCount. Values will be filled up with 0, if length is less than RowCount. RowCount will be extended if length is larger than RowCount." />
+		</method>
+
+		<method name="SetBoolColumnValues" description="Sets the values of a bool column from bytes (0 = false, nonzero = true). Will fail if column does not exist or type is not bool.">
+			<param name="Identifier" type="string" pass="in" description="Identifier of the column." />
+			<param name="Values" type="basicarray" class="uint8" pass="in" description="New Value array of a column. Array length should match RowCount. Values will be filled up with 0, if length is less than RowCount. RowCount will be extended if length is larger than RowCount." />
+		</method>
+
+		<method name="SetTimestampColumnValues" description="Sets the values of a timestamp column in microseconds. Will fail if column does not exist or type is not timestamp.">
+			<param name="Identifier" type="string" pass="in" description="Identifier of the column." />
+			<param name="Values" type="basicarray" class="uint64" pass="in" description="New Value array of a column. Array length should match RowCount. Values will be filled up with 0, if length is less than RowCount. RowCount will be extended if length is larger than RowCount." />
+		</method>
 		
 		<method name="CreateWriteOptions" description="Creates a Write Option.">
 			<param name="Options" type="class" class="DataTableWriteOptions" pass="return" description="Writer Options Instance to pass on to WriteDataToStream." />
@@ -1361,6 +1474,333 @@
 		
 	</class>
 
+	<class name="DataCaptureOptions" parent="Base" description="Configuration of a streaming data capture. The options are copied when the capture is created.">
+
+		<method name="SetChunkRowCount" description="Sets the number of rows a chunk can hold. Default is 65536.">
+			<param name="ChunkRowCount" type="uint32" pass="in" description="Rows per chunk. MUST be between 1 and 16777216." />
+		</method>
+
+		<method name="GetChunkRowCount" description="Returns the number of rows a chunk can hold.">
+			<param name="ChunkRowCount" type="uint32" pass="return" description="Rows per chunk." />
+		</method>
+
+		<method name="SetSegmentSizeInBytes" description="Sets the size at which the capture rolls over into a new segment stream. Default is 1 GB.">
+			<param name="SegmentSizeInBytes" type="uint64" pass="in" description="Maximum segment size in bytes. 0 means the capture never rolls over. A segment always holds at least one chunk." />
+		</method>
+
+		<method name="GetSegmentSizeInBytes" description="Returns the size at which the capture rolls over into a new segment stream.">
+			<param name="SegmentSizeInBytes" type="uint64" pass="return" description="Maximum segment size in bytes. 0 means the capture never rolls over." />
+		</method>
+
+		<method name="SetMaxQueuedChunks" description="Sets the maximum number of committed chunks that may wait for the writer thread. Default is 16.">
+			<param name="MaxQueuedChunks" type="uint32" pass="in" description="Queue depth. MUST be between 1 and 1024." />
+		</method>
+
+		<method name="GetMaxQueuedChunks" description="Returns the maximum number of committed chunks that may wait for the writer thread.">
+			<param name="MaxQueuedChunks" type="uint32" pass="return" description="Queue depth." />
+		</method>
+
+		<method name="SetBackpressureMode" description="Sets what happens when the producer is faster than the disk. Default is Block.">
+			<param name="BackpressureMode" type="enum" class="DataCaptureBackpressureMode" pass="in" description="Block waits for the writer, DropOldest discards the oldest queued chunk, Fail raises an error." />
+		</method>
+
+		<method name="GetBackpressureMode" description="Returns what happens when the producer is faster than the disk.">
+			<param name="BackpressureMode" type="enum" class="DataCaptureBackpressureMode" pass="return" description="Backpressure mode." />
+		</method>
+
+		<method name="SetStorageLimitInBytes" description="Sets the retention limit for all data capture segments stored on this machine. When it is exceeded after a segment has been finalized, the oldest stored segments are deleted first. Default is 0.">
+			<param name="StorageLimitInBytes" type="uint64" pass="in" description="Total size limit in bytes. 0 disables retention." />
+		</method>
+
+		<method name="GetStorageLimitInBytes" description="Returns the retention limit for all data capture segments stored on this machine.">
+			<param name="StorageLimitInBytes" type="uint64" pass="return" description="Total size limit in bytes. 0 means retention is disabled." />
+		</method>
+
+		<method name="SetCompression" description="Sets the codec the pages of the capture are compressed with. Default is LZ4. A page is stored uncompressed if the codec does not make it smaller.">
+			<param name="Compression" type="enum" class="DataCaptureCompression" pass="in" description="None, LZ4 or Deflate. Deflate is meant for cold data, it costs considerably more processing time than LZ4." />
+		</method>
+
+		<method name="GetCompression" description="Returns the codec the pages of the capture are compressed with.">
+			<param name="Compression" type="enum" class="DataCaptureCompression" pass="return" description="Compression codec." />
+		</method>
+
+		<method name="SetColumnEncoding" description="Sets the encoding of a column. Default is Automatic, which uses Delta for integer and timestamp columns, BitPack for bool columns and Plain for float and double columns. The column MUST exist when the capture starts recording and the encoding MUST fit its type.">
+			<param name="ColumnIdentifier" type="string" pass="in" description="Identifier of the column." />
+			<param name="Encoding" type="enum" class="DataCaptureEncoding" pass="in" description="Automatic, Plain, Delta or BitPack." />
+		</method>
+
+		<method name="SetDoubleQuantization" description="Opts a double column into lossy storage: values are stored as integer multiples of the step with Delta encoding. Columns that are not quantised stay bit-exact. The step is recorded in the capture and the column MUST be a double column.">
+			<param name="ColumnIdentifier" type="string" pass="in" description="Identifier of the column." />
+			<param name="Step" type="double" pass="in" description="Quantisation step. MUST be positive. 0 removes the quantisation." />
+		</method>
+
+	</class>
+
+	<class name="DataCaptureChunk" parent="Base" description="One block of rows of a data capture. The producer owns exactly one chunk at a time, fills it and commits it.">
+
+		<method name="GetCapacity" description="Returns the number of rows the chunk can hold.">
+			<param name="Capacity" type="uint32" pass="return" description="Number of rows." />
+		</method>
+
+		<method name="GetRowCount" description="Returns the number of rows in the chunk. This is the row count of the longest column.">
+			<param name="RowCount" type="uint32" pass="return" description="Number of rows." />
+		</method>
+
+		<method name="IsFull" description="Returns if the chunk has reached its capacity.">
+			<param name="Full" type="bool" pass="return" description="Returns true if no more rows fit into the chunk." />
+		</method>
+
+		<method name="SetDoubleColumnValues" description="Sets all rows of a double column in this chunk. Fails if the column type does not match or the capacity is exceeded.">
+			<param name="ColumnIndex" type="uint32" pass="in" description="Index of the column. 0-based." />
+			<param name="Values" type="basicarray" class="double" pass="in" description="Values of the column. All columns of a chunk MUST have the same length on commit." />
+		</method>
+
+		<method name="SetInt32ColumnValues" description="Sets all rows of an int32 column in this chunk. Fails if the column type does not match or the capacity is exceeded.">
+			<param name="ColumnIndex" type="uint32" pass="in" description="Index of the column. 0-based." />
+			<param name="Values" type="basicarray" class="int32" pass="in" description="Values of the column. All columns of a chunk MUST have the same length on commit." />
+		</method>
+
+		<method name="SetUint32ColumnValues" description="Sets all rows of an uint32 column in this chunk. Fails if the column type does not match or the capacity is exceeded.">
+			<param name="ColumnIndex" type="uint32" pass="in" description="Index of the column. 0-based." />
+			<param name="Values" type="basicarray" class="uint32" pass="in" description="Values of the column. All columns of a chunk MUST have the same length on commit." />
+		</method>
+
+		<method name="SetInt64ColumnValues" description="Sets all rows of an int64 column in this chunk. Fails if the column type does not match or the capacity is exceeded.">
+			<param name="ColumnIndex" type="uint32" pass="in" description="Index of the column. 0-based." />
+			<param name="Values" type="basicarray" class="int64" pass="in" description="Values of the column. All columns of a chunk MUST have the same length on commit." />
+		</method>
+
+		<method name="SetUint64ColumnValues" description="Sets all rows of an uint64 column in this chunk. Fails if the column type does not match or the capacity is exceeded.">
+			<param name="ColumnIndex" type="uint32" pass="in" description="Index of the column. 0-based." />
+			<param name="Values" type="basicarray" class="uint64" pass="in" description="Values of the column. All columns of a chunk MUST have the same length on commit." />
+		</method>
+
+		<method name="SetFloatColumnValues" description="Sets all rows of a float (32 bit) column in this chunk. Fails if the column type does not match or the capacity is exceeded.">
+			<param name="ColumnIndex" type="uint32" pass="in" description="Index of the column. 0-based." />
+			<param name="Values" type="basicarray" class="single" pass="in" description="Values of the column. All columns of a chunk MUST have the same length on commit." />
+		</method>
+
+		<method name="SetBoolColumnValues" description="Sets all rows of a bool column in this chunk from bytes (0 = false, nonzero = true). Fails if the column type does not match or the capacity is exceeded.">
+			<param name="ColumnIndex" type="uint32" pass="in" description="Index of the column. 0-based." />
+			<param name="Values" type="basicarray" class="uint8" pass="in" description="Values of the column. All columns of a chunk MUST have the same length on commit." />
+		</method>
+
+		<method name="SetTimestampColumnValues" description="Sets all rows of a timestamp column in this chunk in microseconds. Fails if the column type does not match or the capacity is exceeded.">
+			<param name="ColumnIndex" type="uint32" pass="in" description="Index of the column. 0-based." />
+			<param name="Values" type="basicarray" class="uint64" pass="in" description="Values of the column. All columns of a chunk MUST have the same length on commit." />
+		</method>
+
+		<method name="BeginRow" description="Starts a new row at the end of the chunk. This is the convenience path for low-rate producers. Fails if the chunk is full, a row is open or the columns have different row counts.">
+		</method>
+
+		<method name="SetRowDoubleValue" description="Sets a value of the open row. The column MUST be of type double or float.">
+			<param name="ColumnIndex" type="uint32" pass="in" description="Index of the column. 0-based." />
+			<param name="Value" type="double" pass="in" description="Value to set." />
+		</method>
+
+		<method name="SetRowIntegerValue" description="Sets a value of the open row. The column MUST be of an integer, bool or timestamp type and the value MUST be in its range.">
+			<param name="ColumnIndex" type="uint32" pass="in" description="Index of the column. 0-based." />
+			<param name="Value" type="int64" pass="in" description="Value to set." />
+		</method>
+
+		<method name="EndRow" description="Finishes the open row. Columns that have not been set in this row are zero.">
+		</method>
+
+	</class>
+
+	<class name="DataCapture" parent="Base" description="A streaming data capture of a build execution. Committed chunks are written to segmented storage streams by a background thread, so that memory use does not grow with the capture length.">
+
+		<method name="GetUUID" description="Returns the UUID of the capture.">
+			<param name="UUID" type="string" pass="return" description="UUID of the capture." />
+		</method>
+
+		<method name="GetIdentifier" description="Returns the identifier of the capture. It is unique within the build execution.">
+			<param name="Identifier" type="string" pass="return" description="Identifier of the capture." />
+		</method>
+
+		<method name="GetName" description="Returns the human readable name of the capture.">
+			<param name="Name" type="string" pass="return" description="Name of the capture." />
+		</method>
+
+		<method name="GetStatus" description="Returns the status of the capture.">
+			<param name="Status" type="enum" class="DataCaptureStatus" pass="return" description="Status of the capture." />
+		</method>
+
+		<method name="AddColumn" description="Adds a column to the capture. The schema is frozen with the first call to BeginChunk.">
+			<param name="Identifier" type="string" pass="in" description="Identifier of the column. MUST be unique, alphanumeric and not empty." />
+			<param name="Description" type="string" pass="in" description="Description of the column." />
+			<param name="ColumnType" type="enum" class="DataTableColumnType" pass="in" description="Data type of the column." />
+		</method>
+
+		<method name="GetColumnCount" description="Returns the number of columns of the capture.">
+			<param name="ColumnCount" type="uint32" pass="return" description="Number of columns." />
+		</method>
+
+		<method name="BeginChunk" description="Borrows an empty chunk from the chunk pool. Freezes the schema on the first call. If no chunk is free, the backpressure mode of the capture applies.">
+			<param name="ChunkInstance" type="class" class="DataCaptureChunk" pass="return" description="Chunk to fill." />
+		</method>
+
+		<method name="CommitChunk" description="Hands a filled chunk over to the writer thread and returns immediately. All columns MUST have the same row count. The chunk instance MUST NOT be used afterwards.">
+			<param name="ChunkInstance" type="class" class="DataCaptureChunk" pass="in" description="Chunk that has been returned by BeginChunk." />
+		</method>
+
+		<method name="Flush" description="Blocks until all committed chunks have been written to storage.">
+		</method>
+
+		<method name="GetCapturedRowCount" description="Returns the number of rows that have been committed and not dropped.">
+			<param name="RowCount" type="uint64" pass="return" description="Number of rows." />
+		</method>
+
+		<method name="GetStorageSizeInBytes" description="Returns the number of bytes that have been written to storage so far.">
+			<param name="SizeInBytes" type="uint64" pass="return" description="Size in bytes." />
+		</method>
+
+		<method name="GetSegmentCount" description="Returns the number of segment streams that have been opened so far.">
+			<param name="SegmentCount" type="uint32" pass="return" description="Number of segments." />
+		</method>
+
+		<method name="GetQueuedChunkCount" description="Returns the number of committed chunks that are waiting for the writer thread.">
+			<param name="QueuedChunkCount" type="uint32" pass="return" description="Number of queued chunks." />
+		</method>
+
+		<method name="GetDroppedRowCount" description="Returns the number of rows that have been discarded by the DropOldest backpressure mode.">
+			<param name="DroppedRowCount" type="uint64" pass="return" description="Number of dropped rows." />
+		</method>
+
+		<method name="Finish" description="Writes all committed chunks, closes the last segment and marks the capture as finished. Fails if a chunk is uncommitted.">
+			<param name="CaptureUUID" type="string" pass="return" description="UUID of the capture." />
+		</method>
+
+		<method name="Abort" description="Stops the capture and deletes all its segments.">
+		</method>
+
+		<method name="AddColumnsFromDataTable" description="Adds one column to the capture for every column of a data table, with the same identifier, description and type and in the same order. Fails if the schema is frozen or an identifier already exists.">
+			<param name="DataTable" type="class" class="DataTable" pass="in" description="Data table whose columns describe the schema. Its rows are not read." />
+		</method>
+
+		<method name="AppendDataTable" description="Appends all rows of a data table to the capture and splits them into chunks. Every column of the capture MUST exist in the table with the same identifier and type, and these columns MUST have the same row count. Further columns of the table are ignored. Freezes the schema on the first call. If no chunk is free, the backpressure mode of the capture applies. Fails if a chunk is uncommitted.">
+			<param name="DataTable" type="class" class="DataTable" pass="in" description="Data table that holds the rows to append." />
+			<param name="RowCount" type="uint64" pass="return" description="Number of rows that have been appended." />
+		</method>
+
+	</class>
+
+	<class name="DataTableReader" parent="Base" description="Reads a data capture selectively: single columns, row ranges and downsampled ranges are resolved to the pages that overlap the request, across all segments of the capture. A reader instance MUST only be used in a single thread.">
+
+		<method name="GetRowCount" description="Returns the number of rows of the capture, including rows in segments that have been deleted by retention.">
+			<param name="RowCount" type="uint64" pass="return" description="Number of rows." />
+		</method>
+
+		<method name="GetFirstAvailableRow" description="Returns the index of the first row that is still stored. Rows before it have been deleted by retention.">
+			<param name="FirstAvailableRow" type="uint64" pass="return" description="Row index. Equal to the row count if nothing is stored." />
+		</method>
+
+		<method name="GetColumnCount" description="Returns the number of columns.">
+			<param name="ColumnCount" type="uint32" pass="return" description="Number of columns." />
+		</method>
+
+		<method name="HasColumn" description="Returns if a column exists.">
+			<param name="Identifier" type="string" pass="in" description="Identifier of the column." />
+			<param name="ColumnExists" type="bool" pass="return" description="Returns if the column exists." />
+		</method>
+
+		<method name="GetColumnInformation" description="Returns the schema information of a column. Fails if the index is out of bounds.">
+			<param name="ColumnIndex" type="uint32" pass="in" description="Index of column. 0-based." />
+			<param name="Identifier" type="string" pass="out" description="Identifier of the column." />
+			<param name="Description" type="string" pass="out" description="Description of the column." />
+			<param name="ColumnType" type="enum" class="DataTableColumnType" pass="out" description="Data type of the column." />
+		</method>
+
+		<method name="GetColumnQuantization" description="Returns the quantisation step of a column. Values of a quantised column are exact to half a step.">
+			<param name="Identifier" type="string" pass="in" description="Identifier of the column." />
+			<param name="Step" type="double" pass="return" description="Quantisation step. 0 if the column is not quantised." />
+		</method>
+
+		<method name="GetSegmentCount" description="Returns the number of segments of the capture, including deleted ones.">
+			<param name="SegmentCount" type="uint32" pass="return" description="Number of segments." />
+		</method>
+
+		<method name="GetSegmentInformation" description="Returns the row range and the size of a segment. Fails if the index is out of bounds.">
+			<param name="SegmentIndex" type="uint32" pass="in" description="Index of the segment. 0-based." />
+			<param name="FirstRow" type="uint64" pass="out" description="Index of the first row of the segment." />
+			<param name="RowCount" type="uint64" pass="out" description="Number of rows in the segment." />
+			<param name="SizeInBytes" type="uint64" pass="out" description="Size of the segment stream in bytes." />
+			<param name="IsAvailable" type="bool" pass="out" description="Returns false if the segment has been deleted by retention." />
+		</method>
+
+		<method name="GetChunkCount" description="Returns the number of chunks of the capture, including chunks in deleted segments.">
+			<param name="ChunkCount" type="uint64" pass="return" description="Number of chunks." />
+		</method>
+
+		<method name="GetChunkInformation" description="Returns the position of a chunk. Fails if the index is out of bounds.">
+			<param name="ChunkIndex" type="uint64" pass="in" description="Index of the chunk. 0-based." />
+			<param name="SegmentIndex" type="uint32" pass="out" description="Index of the segment that holds the chunk." />
+			<param name="FirstRow" type="uint64" pass="out" description="Index of the first row of the chunk. For a chunk in a deleted segment this is the first row of the segment." />
+			<param name="RowCount" type="uint64" pass="out" description="Number of rows in the chunk. 0 for a chunk in a deleted segment." />
+			<param name="IsAvailable" type="bool" pass="out" description="Returns false if the chunk has been deleted by retention." />
+		</method>
+
+		<method name="GetChunkStatistics" description="Returns the minimum and maximum of a column in a chunk from the page directory, without reading the chunk.">
+			<param name="ChunkIndex" type="uint64" pass="in" description="Index of the chunk. 0-based." />
+			<param name="Identifier" type="string" pass="in" description="Identifier of the column." />
+			<param name="MinValue" type="double" pass="out" description="Minimum value of the column in the chunk." />
+			<param name="MaxValue" type="double" pass="out" description="Maximum value of the column in the chunk." />
+			<param name="HasStatistics" type="bool" pass="return" description="Returns false if the chunk has been deleted or holds no comparable value." />
+		</method>
+
+		<method name="ReadDoubleColumnRange" description="Reads a row range of a column as doubles. Works for every column type. Only the pages that overlap the range are read.">
+			<param name="Identifier" type="string" pass="in" description="Identifier of the column." />
+			<param name="FromRow" type="uint64" pass="in" description="Index of the first row to read." />
+			<param name="RowCount" type="uint64" pass="in" description="Number of rows to read." />
+			<param name="Values" type="basicarray" class="double" pass="out" description="Values of the row range." />
+		</method>
+
+		<method name="ReadFloatColumnRange" description="Reads a row range of a float or double column as floats.">
+			<param name="Identifier" type="string" pass="in" description="Identifier of the column." />
+			<param name="FromRow" type="uint64" pass="in" description="Index of the first row to read." />
+			<param name="RowCount" type="uint64" pass="in" description="Number of rows to read." />
+			<param name="Values" type="basicarray" class="single" pass="out" description="Values of the row range." />
+		</method>
+
+		<method name="ReadInt64ColumnRange" description="Reads a row range of an integer, bool or timestamp column as 64 bit integers.">
+			<param name="Identifier" type="string" pass="in" description="Identifier of the column." />
+			<param name="FromRow" type="uint64" pass="in" description="Index of the first row to read." />
+			<param name="RowCount" type="uint64" pass="in" description="Number of rows to read." />
+			<param name="Values" type="basicarray" class="int64" pass="out" description="Values of the row range." />
+		</method>
+
+		<method name="ReadBoolColumnRange" description="Reads a row range of a bool column as bytes (0 = false, 1 = true).">
+			<param name="Identifier" type="string" pass="in" description="Identifier of the column." />
+			<param name="FromRow" type="uint64" pass="in" description="Index of the first row to read." />
+			<param name="RowCount" type="uint64" pass="in" description="Number of rows to read." />
+			<param name="Values" type="basicarray" class="uint8" pass="out" description="Values of the row range." />
+		</method>
+
+		<method name="ReadColumnDownsampled" description="Reduces a row range of a column to at most TargetPoints buckets without materialising the range. Stride returns the first value of each bucket, Average the mean and MinMax the minimum followed by the maximum of each bucket, which preserves the envelope of the signal.">
+			<param name="Identifier" type="string" pass="in" description="Identifier of the column." />
+			<param name="FromRow" type="uint64" pass="in" description="Index of the first row of the range." />
+			<param name="RowCount" type="uint64" pass="in" description="Number of rows of the range." />
+			<param name="TargetPoints" type="uint32" pass="in" description="Maximum number of buckets. MUST be positive." />
+			<param name="Mode" type="enum" class="DataTableDownsampleMode" pass="in" description="Stride, MinMax or Average." />
+			<param name="Values" type="basicarray" class="double" pass="out" description="One value per bucket, or two values per bucket in MinMax mode. The number of buckets is the smaller of TargetPoints and RowCount." />
+		</method>
+
+		<method name="FindChunksInValueRange" description="Finds the chunks whose value range of a column overlaps a given range. Only the page directory is used, no chunk is read.">
+			<param name="Identifier" type="string" pass="in" description="Identifier of the column." />
+			<param name="MinValue" type="double" pass="in" description="Lower bound of the value range." />
+			<param name="MaxValue" type="double" pass="in" description="Upper bound of the value range." />
+			<param name="ChunkIndices" type="basicarray" class="uint64" pass="out" description="Indices of the chunks that may hold a value in the range." />
+		</method>
+
+		<method name="ExtractDataTable" description="Materialises a row range as an ordinary in-memory data table.">
+			<param name="FromRow" type="uint64" pass="in" description="Index of the first row of the range." />
+			<param name="RowCount" type="uint64" pass="in" description="Number of rows of the range." />
+			<param name="ColumnIdentifiers" type="string" pass="in" description="Comma separated identifiers of the columns to extract. An empty string extracts all columns." />
+			<param name="DataTableInstance" type="class" class="DataTable" pass="return" description="Data table instance." />
+		</method>
+
+	</class>
+
 	<class name="DataSeries" parent="Base" description="A data series of points.">
 	
 		<method name="GetName" description="Returns the name of the data series.">
@@ -2696,6 +3136,44 @@
 		</method>	
 		
 
+		<method name="CreateDataCaptureOptions" description="Creates an options object for a data capture with default values.">
+			<param name="Options" type="class" class="DataCaptureOptions" pass="return" description="Data capture options instance." />
+		</method>
+
+		<method name="CreateDataCapture" description="Creates a streaming data capture in this build execution. The execution MUST be in process.">
+			<param name="Identifier" type="string" pass="in" description="Unique identifier of the capture in this execution. Fails if the identifier already exists or is invalid." />
+			<param name="Name" type="string" pass="in" description="Human readable name of the capture." />
+			<param name="Options" type="optionalclass" class="DataCaptureOptions" pass="in" description="Data capture options. Defaults are used if not given." />
+			<param name="UserUUID" type="string" pass="in" description="User UUID of the user that this data comes from. Empty string means no user attached." />
+			<param name="DataCaptureInstance" type="class" class="DataCapture" pass="return" description="Data capture instance." />
+		</method>
+
+		<method name="HasDataCapture" description="Returns if the execution has a data capture with a certain identifier.">
+			<param name="Identifier" type="string" pass="in" description="Identifier of the capture." />
+			<param name="CaptureExists" type="bool" pass="return" description="Returns true if the capture exists." />
+		</method>
+
+		<method name="GetDataCaptureRowCount" description="Returns the number of rows of a data capture that have been stored in segments. Fails if the capture does not exist.">
+			<param name="Identifier" type="string" pass="in" description="Identifier of the capture." />
+			<param name="RowCount" type="uint64" pass="return" description="Number of rows." />
+		</method>
+
+		<method name="GetDataCaptureSegmentCount" description="Returns the number of stored segments of a data capture. Fails if the capture does not exist.">
+			<param name="Identifier" type="string" pass="in" description="Identifier of the capture." />
+			<param name="SegmentCount" type="uint32" pass="return" description="Number of segments." />
+		</method>
+
+		<method name="LoadDataCaptureSegment" description="Loads one segment of a data capture as in-memory data table. Fails if the capture or the segment does not exist or the segment has been deleted by retention.">
+			<param name="Identifier" type="string" pass="in" description="Identifier of the capture." />
+			<param name="SegmentIndex" type="uint32" pass="in" description="Index of the segment. 0-based." />
+			<param name="DataTableInstance" type="class" class="DataTable" pass="return" description="Loaded data table instance." />
+		</method>
+
+		<method name="OpenDataCaptureReader" description="Opens a reader on the stored segments of a data capture. Fails if the capture does not exist.">
+			<param name="Identifier" type="string" pass="in" description="Identifier of the capture." />
+			<param name="ReaderInstance" type="class" class="DataTableReader" pass="return" description="Reader instance." />
+		</method>
+
 	</class>
 	
 	
@@ -4577,9 +5055,12 @@
 			<param name="FileName" type="string" pass="in" description="File Name for the new entry in the ZIP file. Entry MUST not exist yet." />
 			<param name="StreamReader" type="class" class="StreamReader" pass="in" description="Stream to read from." />
 		</method>
-		
+
+		<method name="Discard" description="Discards the unfinished ZIP stream. The file on disk and the stream entry are deleted. Fails if the stream has been finished already. A ZIP writer that is released without Finish is discarded automatically.">
+		</method>
+
 	</class>
-	
+
 	
 	<class name="StreamReader" parent="Base" description="A reader class that allows to access a storage stream.">
 	
@@ -6152,6 +6633,37 @@
 			<param name="Value" type="bool" pass="return" description="Result of the formula." />
 		</method>
 
+		<method name="StartStreamDownloadForSession" description="Starts a stream download in the browser of a client session. Creates a download ticket for the user of the session and queues the download action for delivery to the session. Returns false if the session does not exist or is not authorized.">
+			<param name="SessionUUID" type="string" pass="in" description="UUID of the client session." />
+			<param name="StreamUUID" type="string" pass="in" description="Storage stream. Fails if the stream does not exist or is not finished." />
+			<param name="FileName" type="string" pass="in" description="File name offered to the browser. Fails if empty." />
+			<param name="Success" type="bool" pass="return" description="True if the download action was queued for the session." />
+		</method>
+
+		<method name="GetStreamDownloadProgress" description="Returns the delivery progress of all downloads of a storage stream.">
+			<param name="StreamUUID" type="string" pass="in" description="Storage stream." />
+			<param name="ActiveConnections" type="uint32" pass="out" description="Connections that are sending the stream right now." />
+			<param name="DeliveredBytes" type="uint64" pass="out" description="Bytes from the start of the stream that were sent without a gap." />
+			<param name="TotalBytes" type="uint64" pass="out" description="Size of the stream." />
+			<param name="Completed" type="bool" pass="out" description="The last byte was sent and its connection ended successfully." />
+			<param name="MillisecondsSinceActivity" type="uint64" pass="out" description="Time since the last chunk was sent or since the download was handed over." />
+		</method>
+
+		<method name="CancelStreamDownloads" description="Stops all running downloads of a storage stream, revokes its download tickets and drops its unclaimed download actions. Does nothing if the stream was already delivered completely.">
+			<param name="StreamUUID" type="string" pass="in" description="Storage stream." />
+			<param name="Cancelled" type="bool" pass="return" description="False if the download had already completed and nothing was cancelled." />
+		</method>
+
+		<method name="DeleteStorageStream" description="Deletes a finished storage stream from disk and database, including its download tickets. Fails if the stream does not exist, is still being written or is being downloaded right now.">
+			<param name="UUID" type="string" pass="in" description="UUID of the storage stream." />
+		</method>
+
+		<method name="EnforceStreamRetention" description="Deletes all finished streams with the given name except the newest ones. Streams with running downloads or pending download actions are kept. Returns the number of deleted streams.">
+			<param name="Name" type="string" pass="in" description="Name of the streams." />
+			<param name="KeepCount" type="uint32" pass="in" description="Number of newest streams to keep." />
+			<param name="DeletedCount" type="uint32" pass="return" description="Number of deleted streams." />
+		</method>
+
 	</class>
 
 	<class name="UIItem" parent="Base" description="Base item that represents a user interface element.">
diff --git a/BuildScripts/createPackageXML.cpp b/BuildScripts/createPackageXML.cpp
index 9f85550da..f8f1c329a 100644
--- a/BuildScripts/createPackageXML.cpp
+++ b/BuildScripts/createPackageXML.cpp
@@ -338,7 +338,7 @@ int main(int argc, char* argv[])
 		
 		std::stringstream serverXMLStream;
 		serverXMLStream << "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n";
-		serverXMLStream << "<amc xmlns=\"http://schemas.autodesk.com/amc/2020/06\">\n";
+		serverXMLStream << "<amc xmlns=\"http://schemas.autodesk.com/amc/2020/06\" client=\"" << sDefaultClient << "\">\n";
 		serverXMLStream << "  <server hostname=\"0.0.0.0\" port=\"8869\" " << sTempFolderXMLAttribute << "/>\n";
 		serverXMLStream << "  <data directory=\"data/\" database=\"sqlite\" sqlitedb=\"storage.db\" />\n";
 		serverXMLStream << "  <defaultpackage name=\""<< sDevPackagePrefix << "_package.xml\" githash=\"" << sDevPackagePrefix <<"\" sha256=\"" << sPackageSHA << "\" />\n";
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 1df0c4310..10cdb26b0 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -304,6 +304,9 @@ file(GLOB LIBMC_SRC_DEP_ZIP
 file(GLOB LIBMC_SRC_DEP_ZLIB
 	${CMAKE_CURRENT_SOURCE_DIR}/Libraries/zlib/*.c
 )
+file(GLOB LIBMC_SRC_DEP_LZ4
+	${CMAKE_CURRENT_SOURCE_DIR}/Libraries/lz4/*.c
+)
 file(GLOB LIBMC_SRC_DEP_PUGIXML
 	${CMAKE_CURRENT_SOURCE_DIR}/Libraries/PugiXML/pugixml.cpp
 )
@@ -323,6 +326,7 @@ source_group("libmcenv" FILES ${LIBMC_SRC_LIBMCENV})
 source_group("dependencies\\crossguid" FILES ${LIBMC_SRC_DEP_CROSSGUID})
 source_group("dependencies\\zip" FILES ${LIBMC_SRC_DEP_ZIP})
 source_group("dependencies\\zlib" FILES ${LIBMC_SRC_DEP_ZLIB})
+source_group("dependencies\\lz4" FILES ${LIBMC_SRC_DEP_LZ4})
 source_group("dependencies\\pugixml" FILES ${LIBMC_SRC_DEP_PUGIXML})
 source_group("dependencies\\lodepng" FILES ${LIBMC_SRC_DEP_LODEPNG})
 
@@ -336,6 +340,7 @@ set(LIBMC_SRC
   ${LIBMC_SRC_LIBMCENV}
   ${LIBMC_SRC_DEP_ZIP}
   ${LIBMC_SRC_DEP_ZLIB}
+  ${LIBMC_SRC_DEP_LZ4}
   ${LIBMC_SRC_DEP_PUGIXML}
   ${LIBMC_SRC_DEP_CROSSGUID}
   ${LIBMC_SRC_DEP_LODEPNG}
@@ -368,6 +373,7 @@ target_include_directories(libmc PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/Implementat
 target_include_directories(libmc PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/Libraries/PugiXML)
 target_include_directories(libmc PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/Libraries/PicoSHA2)
 target_include_directories(libmc PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/Libraries/libzip)
+target_include_directories(libmc PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/Libraries/lz4)
 target_include_directories(libmc PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/Libraries)
 target_include_directories(libmc PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/)
 
@@ -595,6 +601,7 @@ file(GLOB SERVER_SRC
 	${CMAKE_CURRENT_SOURCE_DIR}/Libraries/PugiXML/pugixml.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/Libraries/zlib/*.c
 	${CMAKE_CURRENT_SOURCE_DIR}/Implementation/Common/common_utils.cpp 
+	${CMAKE_CURRENT_SOURCE_DIR}/Implementation/Common/common_httprange.cpp 
 	${CMAKE_CURRENT_SOURCE_DIR}/Implementation/Common/common_guid.cpp 
 	${CMAKE_CURRENT_SOURCE_DIR}/Implementation/Common/common_importstream_native.cpp 
 	${CMAKE_CURRENT_SOURCE_DIR}/Implementation/Common/common_exportstream_native.cpp 
@@ -677,6 +684,7 @@ file(GLOB SERVER_WIN32_SRC
 	${CMAKE_CURRENT_SOURCE_DIR}/Libraries/PugiXML/pugixml.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/Libraries/zlib/*.c
 	${CMAKE_CURRENT_SOURCE_DIR}/Implementation/Common/common_utils.cpp 
+	${CMAKE_CURRENT_SOURCE_DIR}/Implementation/Common/common_httprange.cpp 
 	${CMAKE_CURRENT_SOURCE_DIR}/Implementation/Common/common_guid.cpp 
 	${CMAKE_CURRENT_SOURCE_DIR}/Implementation/Common/common_importstream_native.cpp 
 	${CMAKE_CURRENT_SOURCE_DIR}/Implementation/Common/common_exportstream_native.cpp 
@@ -759,6 +767,7 @@ file(GLOB UNITTEST_SRC
   ${LIBMC_SRC_LIBMCENV}
   ${LIBMC_SRC_DEP_ZIP}
   ${LIBMC_SRC_DEP_ZLIB}
+  ${LIBMC_SRC_DEP_LZ4}
   ${LIBMC_SRC_DEP_PUGIXML}
   ${LIBMC_SRC_DEP_CROSSGUID}
   ${LIBMC_SRC_DEP_LODEPNG}
@@ -790,6 +799,7 @@ target_include_directories(amc_unittest PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/Libr
 target_include_directories(amc_unittest PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/Libraries/PicoSHA2)
 target_include_directories(amc_unittest PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/Libraries/libzip)
 target_include_directories(amc_unittest PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/Libraries/SQLite)
+target_include_directories(amc_unittest PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/Libraries/lz4)
 target_include_directories(amc_unittest PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/Libraries)
 target_include_directories(amc_unittest PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/)
 target_compile_options(amc_unittest PRIVATE "-D__GITHASH=${GLOBALGITHASH}")
diff --git a/Client/core/common/AMCApplication.js b/Client/core/common/AMCApplication.js
index a488f40be..2f3a3b4fd 100644
--- a/Client/core/common/AMCApplication.js
+++ b/Client/core/common/AMCApplication.js
@@ -49,6 +49,7 @@ import AMCApplicationModule_TogglePanel from "../modules/AMCModule_TogglePanel.j
 import AMCApplicationModule_Form from "../modules/AMCModule_Form.js"
 import AMCApplicationModule_Chart from "../modules/AMCModule_Chart.js"
 import AMCApplicationModule_JournalHistory from "../modules/AMCModule_JournalHistory.js"
+import AMCApplicationModule_DataCapture from "../modules/AMCModule_DataCapture.js"
 import AMCApplicationModule_Image from "../modules/AMCModule_Image.js"
 import AMCApplicationModule_StateMachineGraph from "../modules/AMCModule_StateMachineGraph.js"
 import AMCApplicationModule_Paragraph from "../modules/AMCModule_Paragraph.js"
@@ -74,6 +75,10 @@ import AMCApplicationDialog from "./AMCDialog.js"
 
 const CONFIG_REQUEST_TIMEOUT_MS = 2000;
 const DEFAULT_REQUEST_TIMEOUT_MS = 10000;
+// UI events run plugin code on the server (loading a recording of 60M rows for the SMC Viewer
+// takes 10-50 s), so they get a much longer timeout than plain status requests.
+const EVENT_REQUEST_TIMEOUT_MS = 120000;
+const EVENT_ERROR_SNACKBAR_TIMEOUT_MS = 8000;
 const MAX_CONSECUTIVE_FAILURES = 5;
 
 // Client reactivity metrics: aggregate /api/frontend roundtrips over this window
@@ -175,10 +180,18 @@ export default class AMCApplication extends Common.AMCObject {
 			Timeout: -1,
 			Text: "",
 			Color: "secondary",
-			FontColor: "white"			
+			FontColor: "white",
+			// Incremented on every showSnackBar () call, so the client can restart its auto-hide
+			// timer even if text and visibility have not changed.
+			Sequence: 0
 		}
 
 		// mode is one of "off" / "connecting" / "stream" / "polling".
+		// Senders whose event request is still running (double-send guard of triggerUIEvent).
+		this.PendingEventSenders = new Set ();
+		// Session client actions this tab has claimed or tried to claim.
+		this.ClaimedClientActions = new Set ();
+
 		this.FrontendUpdates = {
 			// Identifies this tab within the session's event stream, which serves each tab its active pages and dialogs.
 			clientID: this._createFrontendClientID (),
@@ -817,6 +830,8 @@ export default class AMCApplication extends Common.AMCObject {
 			return new AMCApplicationModule_Chart (page, def);
 		if (def.type === "journalhistory")
 			return new AMCApplicationModule_JournalHistory (page, def);
+		if (def.type === "datacapture")
+			return new AMCApplicationModule_DataCapture (page, def);
 		if (def.type === "image")
 			return new AMCApplicationModule_Image (page, def);
 		if (def.type === "paragraph")
@@ -1152,6 +1167,10 @@ export default class AMCApplication extends Common.AMCObject {
 		applyPageVisibility(this.AppContent.PageMap, data.pages);
 		applyPageVisibility(this.AppContent.CustomPageMap, data.custompages);
 		applyPageVisibility(this.AppContent.DialogMap, data.dialogs);
+
+		// Server-driven dialogs follow their "active" flag; patches update the dialog objects in place.
+		if (data.dialogs)
+			this._syncServerDrivenDialogs(data.dialogs);
 	}
 
 	// Leaves a page that became hidden and closes dialogs that became hidden.
@@ -1201,6 +1220,9 @@ export default class AMCApplication extends Common.AMCObject {
 	}
 
 	_setFrontendState(data, scope) {
+		if (data && Array.isArray (data.pendingactions))
+			this._handlePendingClientActions (data.pendingactions);
+
 		this.API.frontendState = data;
 		this.API.frontendScope = scope;
 		this.API.frontendRevision = Number.isSafeInteger (data.revision) ? data.revision : 0;
@@ -1241,6 +1263,37 @@ export default class AMCApplication extends Common.AMCObject {
 		}
 	}
 
+	// Applies the server-side open state of dialogs that carry an "active" flag (dialogs
+	// with sync:active in the machine configuration). The server is authoritative: such a
+	// dialog is opened while the flag is true, even if a client action closed it in between,
+	// and closed as soon as the flag turns false. Dialogs without the flag are untouched.
+	_syncServerDrivenDialogs(dialogsJSON) {
+		let changed = false;
+
+		for (let dialogJSON of dialogsJSON) {
+			if (typeof dialogJSON.active !== "boolean")
+				continue;
+
+			let dialog = this.AppContent.DialogMap.get(dialogJSON.name);
+			if (!dialog)
+				continue;
+
+			dialog.serverDriven = true;
+			dialog.closable = (dialogJSON.closable !== false);
+
+			if (dialogJSON.active && !dialog.dialogIsActive && (dialog.visible !== false)) {
+				// showDialog already refreshes the content items.
+				this.showDialog(dialog.name);
+			} else if (!dialogJSON.active && dialog.dialogIsActive) {
+				dialog.dialogIsActive = false;
+				changed = true;
+			}
+		}
+
+		if (changed)
+			this.updateContentItems();
+	}
+
 	// Recursively index a v2 module (and its submodules) by UUID.
 	_indexFrontendModule(mod, containerUUIDs) {
 		if (!mod || !mod.uuid)
@@ -1503,6 +1556,7 @@ export default class AMCApplication extends Common.AMCObject {
 			updates.source = source;
 			source.addEventListener ("snapshot", event => this._onFrontendStreamEvent (generation, "snapshot", event));
 			source.addEventListener ("patch", event => this._onFrontendStreamEvent (generation, "patch", event));
+			source.addEventListener ("actions", event => this._onFrontendActionsEvent (generation, event));
 			source.onerror = () => this._onFrontendStreamError (generation);
 		})
 		.catch (err => {
@@ -1550,6 +1604,23 @@ export default class AMCApplication extends Common.AMCObject {
 		}, delayMS);
 	}
 
+	_onFrontendActionsEvent(generation, event) {
+		let updates = this.FrontendUpdates;
+		if ((generation !== updates.generation) || !updates.enabled)
+			return;
+
+		let data;
+		try {
+			data = JSON.parse (event.data);
+		}
+		catch (err) {
+			console.warn ("[frontend updates] malformed actions event:", err);
+			return;
+		}
+		if (data && (typeof data === "object"))
+			this._handlePendingClientActions (data.pendingactions);
+	}
+
 	_onFrontendStreamEvent(generation, eventType, event) {
 		let updates = this.FrontendUpdates;
 		if ((generation !== updates.generation) || !updates.enabled)
@@ -2104,6 +2175,9 @@ export default class AMCApplication extends Common.AMCObject {
         }
     }
 
+    // Only one dialog is open at a time. A server-driven dialog (see
+    // _syncServerDrivenDialogs) re-opens on the next frontend poll while its flag is
+    // set, so it wins over dialogs opened by client actions.
     showDialog(dialog) {
 
         this.closeAllDialogs();
@@ -2125,20 +2199,19 @@ export default class AMCApplication extends Common.AMCObject {
 		
     }
 	
-	streamDownload (downloadticketuuid) 
+	streamDownload (downloadticketuuid, downloadfilename)
 	{
-				
-	
-		/*// Start download in Browser
-		const a = document.createElement('a');
-		a.href = this.getDownloadURL (downloadticketuuid);
-		a.download = downloadfilename;
-		document.body.appendChild(a);    
-		a.click();
-		document.body.removeChild(a); */
-			
-		window.open (this.getDownloadURL (downloadticketuuid), "_blank");
-		
+		// Hand the download over to the browser download manager: it streams the file to disk, shows
+		// progress and can pause and resume. Large files must never be loaded into page memory, and a
+		// programmatic link click is not blocked by the popup blocker like window.open is.
+		const link = document.createElement ("a");
+		link.href = this.getDownloadURL (downloadticketuuid);
+		if (downloadfilename)
+			link.download = downloadfilename;
+		link.rel = "noopener";
+		document.body.appendChild (link);
+		link.click ();
+		document.body.removeChild (link);
 	}
 
     getImageURL(uuid) {
@@ -2170,76 +2243,136 @@ export default class AMCApplication extends Common.AMCObject {
         if (eventParameters)
             requestBody["parameters"] = eventParameters;
 
-        this.axiosPostRequest("/event", requestBody)
+        // A sender whose previous event is still running (usually 50-200 ms) does not send a second one:
+        // the second click of a double click would otherwise reach the server as a new command.
+        let pendingKey = senderuuid ? String (senderuuid) : null;
+        if (pendingKey) {
+            if (this.PendingEventSenders.has (pendingKey)) {
+                console.info ("[events] ignoring " + eventname + ": the previous event of this sender is still running");
+                return;
+            }
+            this.PendingEventSenders.add (pendingKey);
+        }
+
+        this.axiosPostRequest("/event", requestBody, { timeout: EVENT_REQUEST_TIMEOUT_MS })
         .then(resultHandleEvent => {
-			
-			if (resultHandleEvent.data.actions) {
-				if (Array.isArray(resultHandleEvent.data.actions)) {
-					let action;
-					for (action of resultHandleEvent.data.actions) {
-						if (action.action === "activatemodaldialog") {
-							this.showDialog(action.dialogname);
-						}
-						if (action.action === "activatepage") {
-							this.changePage(action.pagename);
-						}
-						if (action.action === "closemodaldialog") {
-							this.closeAllDialogs();
-						}
-						if (action.action === "streamdownload") {
-							this.streamDownload(action.downloadticket);
-						}
-						
-						//this.updateContentItemResult(item.uuid, item);
-					}
-				}
+
+			// A failed event carries no actions and must not run the success callback
+			if (resultHandleEvent.data.errorcode) {
+				this.showEventError(eventname, resultHandleEvent.data.errormessage);
+				return;
 			}
-			
+
+			this.executeClientActions (resultHandleEvent.data.actions);
+
 			if (executionCallback) {
 				executionCallback ();
-			}				
-			
+			}
+
         })
         .catch(err => {
             console.log(err);
+            this.showEventError(eventname, this.extractErrorMessage(err));
+        })
+        .finally(() => {
+            if (pendingKey)
+                this.PendingEventSenders.delete (pendingKey);
         });
     }
 
-    triggerWidgetRequest (widgetuuid, requestType, requestJSON, executionCallback) {
+    // Runs the client actions of an event response, a widget response or the session's pending action queue.
+    executeClientActions(actions) {
+        if (!Array.isArray (actions))
+            return;
+
+        for (let action of actions) {
+            if (!action || (typeof action !== "object"))
+                continue;
+            if (action.action === "activatemodaldialog") {
+                this.showDialog(action.dialogname);
+            }
+            if (action.action === "activatepage") {
+                this.changePage(action.pagename);
+            }
+            if (action.action === "closemodaldialog") {
+                this.closeAllDialogs();
+            }
+            if (action.action === "streamdownload") {
+                this.streamDownload(action.downloadticket, action.downloadfilename);
+            }
+        }
+    }
+
+    // Actions that the server queued for this session (for example a download prepared by a state
+    // machine) arrive through the event stream or the polling response. Several tabs of one session
+    // receive the same list; the first tab that claims an action executes it, the others get 409.
+    _handlePendingClientActions(actions) {
+        if (!Array.isArray (actions))
+            return;
+
+        for (let action of actions) {
+            if (!action || (typeof action !== "object") || !action.actionuuid)
+                continue;
+
+            let actionUUID = String (action.actionuuid);
+            if (this.ClaimedClientActions.has (actionUUID))
+                continue;
+            this.ClaimedClientActions.add (actionUUID);
+
+            this.axiosPostRequest ("/frontend/actions/" + actionUUID + "/claim", {})
+            .then (resultJSON => {
+                if (resultJSON.data && resultJSON.data.errorcode) {
+                    console.info ("[frontend updates] client action " + actionUUID + " was claimed by another tab");
+                    return;
+                }
+                this.executeClientActions ([action]);
+            })
+            .catch (err => {
+                let status = (err && err.response) ? err.response.status : 0;
+                if (status === 409) {
+                    console.info ("[frontend updates] client action " + actionUUID + " was claimed by another tab");
+                    return;
+                }
+                console.warn ("[frontend updates] claiming client action " + actionUUID + " failed:", this.extractErrorMessage (err));
+                this.ClaimedClientActions.delete (actionUUID);
+            });
+        }
+    }
+
+    // Sets every snack bar field, so a caller never inherits the color or timeout of a previous message.
+    // timeout <= 0 keeps the message until it is dismissed.
+    showSnackBar(text, color, timeout) {
+        this.SnackBar.Text = text;
+        this.SnackBar.Color = color || "secondary";
+        this.SnackBar.Timeout = (timeout > 0) ? timeout : -1;
+        this.SnackBar.Sequence++;
+        this.SnackBar.Visible = true;
+    }
+
+    // Failed events were only visible in the browser console. Report them in the snack bar.
+    showEventError(eventname, errormessage) {
+        this.showSnackBar("Event \"" + eventname + "\" failed: " + errormessage, "error", EVENT_ERROR_SNACKBAR_TIMEOUT_MS);
+    }
+
+    // failureCallback receives the request error, so the caller can roll back optimistic UI state.
+    triggerWidgetRequest (widgetuuid, requestType, requestJSON, executionCallback, failureCallback) {
 
 		
         this.axiosPostRequest("/widget/" + Assert.UUIDValue (widgetuuid) + "/" + Assert.StringValue (requestType), Assert.ObjectValue (requestJSON))
         .then(resultHandleWidgetRequest => {
 			
-			if (resultHandleWidgetRequest.data.actions) {
-				if (Array.isArray(resultHandleWidgetRequest.data.actions)) {
-					let action;
-					for (action of resultHandleWidgetRequest.data.actions) {
-						if (action.action === "activatemodaldialog") {
-							this.showDialog(action.dialogname);
-						}
-						if (action.action === "activatepage") {
-							this.changePage(action.pagename);
-						}
-						if (action.action === "closemodaldialog") {
-							this.closeAllDialogs();
-						}
-						if (action.action === "streamdownload") {
-							this.streamDownload(action.downloadticket);
-						}
-						
-						//this.updateContentItemResult(item.uuid, item);
-					}
-				}
-			}
-			
+			this.executeClientActions (resultHandleWidgetRequest.data.actions);
+
 			if (executionCallback) {
 				executionCallback ();
-			}				
-			
+			}
+
         })
         .catch(err => {
             console.log(err);
+            if (failureCallback) {
+                failureCallback (err);
+            }
         });
     }
 
diff --git a/Client/core/common/AMCDialog.js b/Client/core/common/AMCDialog.js
index fdc622384..03ee82ad6 100644
--- a/Client/core/common/AMCDialog.js
+++ b/Client/core/common/AMCDialog.js
@@ -41,6 +41,13 @@ export default class AMCApplicationDialog extends AMCApplicationPage {
 		// dialog JSON); capture it so the client can render the dialog header.
 		this.title = dialogJSON.title || "";
 		this.dialogIsActive = false;
+
+		// "closable" (default true): a non-closable dialog has no close button and ignores
+		// Escape and outside clicks. "active" is only sent for server-driven dialogs; their
+		// open state follows the server on every frontend poll instead of client actions.
+		// Both are initialised here so Vue 2 tracks them.
+		this.closable = (dialogJSON.closable !== false);
+		this.serverDriven = (typeof dialogJSON.active === "boolean");
 	}
 
 	// A dialog is never the application's active page, so the inherited page-based
diff --git a/Client/core/common/AMCImplementation_WebGL.js b/Client/core/common/AMCImplementation_WebGL.js
index 6220bcf23..9f528bcf2 100644
--- a/Client/core/common/AMCImplementation_WebGL.js
+++ b/Client/core/common/AMCImplementation_WebGL.js
@@ -472,8 +472,6 @@ class WebGLLocalizedPointsElement extends WebGLElement {
 		let localmouseX = (mouseX - this.position.x) / this.scale.x;
 		let localmouseY = (mouseY - this.position.y) / this.scale.y;
 		
-		console.log (mouseX + " " + mouseY + ": " + localmouseX + " " + localmouseY);
-		
 		let quadx = Math.floor ( (localmouseX - this.originx) / this.quadsizex);
 		let quady = Math.floor ( (localmouseY - this.originy) / this.quadsizey);
 			
diff --git a/Client/core/common/AMCModuleSchema.js b/Client/core/common/AMCModuleSchema.js
index a7db4f84d..23b52eb72 100644
--- a/Client/core/common/AMCModuleSchema.js
+++ b/Client/core/common/AMCModuleSchema.js
@@ -135,6 +135,10 @@ const MODULE_SCHEMAS = {
 		required: ['uuid', 'type'],
 		optional: ['caption', 'visible', 'severity', 'title', 'description'],
 	},
+	datacapture: {
+		required: ['uuid', 'type'],
+		optional: ['caption', 'visible', 'title', 'captureuuid', 'defaultcolumns'],
+	},
 	custom: {
 		required: ['uuid', 'type'],
 		optional: ['caption', 'visible'],
diff --git a/Client/core/modules/AMCModule_ButtonGroup.js b/Client/core/modules/AMCModule_ButtonGroup.js
index 44723728e..bcc020ede 100644
--- a/Client/core/modules/AMCModule_ButtonGroup.js
+++ b/Client/core/modules/AMCModule_ButtonGroup.js
@@ -99,6 +99,7 @@ export default class AMCApplicationModule_ButtonGroup extends Common.AMCApplicat
 					event:           a.event     || "",
 					targetpage:      a.targetpage || "",
 					icon:            a.icon      || "",
+					hint:            a.hint      || "",
 					kind:            a.kind || "button",
 					variant:         a.variant || "default",
 					width:           a.width || "auto",
diff --git a/Client/core/modules/AMCModule_DataCapture.js b/Client/core/modules/AMCModule_DataCapture.js
new file mode 100644
index 000000000..9a0fdc85f
--- /dev/null
+++ b/Client/core/modules/AMCModule_DataCapture.js
@@ -0,0 +1,91 @@
+/*++
+
+Copyright (C) 2020 Autodesk Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+	* Redistributions of source code must retain the above copyright
+	  notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+	  notice, this list of conditions and the following disclaimer in the
+	  documentation and/or other materials provided with the distribution.
+	* Neither the name of the Autodesk Inc. nor the
+	  names of its contributors may be used to endorse or promote products
+	  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL AUTODESK INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+import * as Assert from "../common/AMCAsserts.js";
+import * as Common from "../common/AMCCommon.js"
+
+
+// A viewer for a streaming data capture. The module only carries presentation
+// configuration; the data is fetched from the /api/datatable REST endpoints.
+export default class AMCApplicationModule_DataCapture extends Common.AMCApplicationModule {
+
+	constructor (page, moduleJSON)
+	{
+		Assert.ObjectValue (moduleJSON);
+		super (page, moduleJSON.uuid, moduleJSON.type, moduleJSON.name || moduleJSON.uuid, moduleJSON.caption || "");
+		this.registerClass ("amcModule_DataCapture");
+
+		this.usesV2Frontend = true;
+
+		this.title = "";
+		// UUID of the capture to show. Usually bound to a state machine parameter.
+		this.captureuuid = "";
+		// Comma separated identifiers of the columns that are plotted initially.
+		this.defaultcolumns = "";
+
+		this.updateFromJSON (moduleJSON);
+	}
+
+
+	updateFromJSON (updateJSON)
+	{
+		Assert.ObjectValue (updateJSON);
+
+		if (updateJSON.title !== undefined)
+			this.title = Assert.StringValue (updateJSON.title);
+		if (updateJSON.captureuuid !== undefined)
+			this.captureuuid = Assert.StringValue (updateJSON.captureuuid);
+		if (updateJSON.defaultcolumns !== undefined)
+			this.defaultcolumns = Assert.StringValue (updateJSON.defaultcolumns);
+		if (updateJSON.caption !== undefined)
+			this.caption = Assert.StringValue (updateJSON.caption);
+	}
+
+
+	updateFromV2Attributes (attrs)
+	{
+		if (!attrs)
+			return true;
+
+		if (attrs.title !== undefined)
+			this.title = attrs.title;
+		if (attrs.captureuuid !== undefined)
+			this.captureuuid = attrs.captureuuid;
+		if (attrs.defaultcolumns !== undefined)
+			this.defaultcolumns = attrs.defaultcolumns;
+		if (attrs.caption !== undefined)
+			this.caption = attrs.caption;
+		if (attrs.visible !== undefined)
+			this.visible = (attrs.visible === true || attrs.visible === "1" || attrs.visible === "true");
+
+		return true;
+	}
+
+}
diff --git a/Client/svelte/src/lib/amcf/MdiIcon.svelte b/Client/svelte/src/lib/amcf/MdiIcon.svelte
index e00c941d0..0998a65ba 100644
--- a/Client/svelte/src/lib/amcf/MdiIcon.svelte
+++ b/Client/svelte/src/lib/amcf/MdiIcon.svelte
@@ -158,6 +158,7 @@
 		'mdi-clock': Clock,
 		'mdi-clock-outline': Clock,
 		'mdi-timer': Clock,
+		'mdi-timer-outline': Clock,
 		'mdi-calendar': Calendar,
 		'mdi-calendar-outline': Calendar,
 		'mdi-map': Map,
diff --git a/Client/svelte/src/lib/amcf/ModuleFactory.svelte b/Client/svelte/src/lib/amcf/ModuleFactory.svelte
index 1a07e3578..0bbe2b6e5 100644
--- a/Client/svelte/src/lib/amcf/ModuleFactory.svelte
+++ b/Client/svelte/src/lib/amcf/ModuleFactory.svelte
@@ -26,6 +26,7 @@
 	import ModuleWorkflow from './modules/ModuleWorkflow.svelte';
 	import ModuleStateMachineGraph from './modules/ModuleStateMachineGraph.svelte';
 	import ModuleHistoryBrowser from './modules/ModuleHistoryBrowser.svelte';
+	import ModuleDataCapture from './modules/ModuleDataCapture.svelte';
 	import ModuleFallback from './modules/ModuleFallback.svelte';
 
 	let { module, app }: { module: any; app: any } = $props();
@@ -58,6 +59,7 @@
 		workflow: ModuleWorkflow,
 		statemachinegraph: ModuleStateMachineGraph,
 		journalhistory: ModuleHistoryBrowser,
+		datacapture: ModuleDataCapture,
 	};
 
 	let Component = $derived(componentMap[module?.type] || ModuleFallback);
diff --git a/Client/svelte/src/lib/amcf/Snackbar.svelte b/Client/svelte/src/lib/amcf/Snackbar.svelte
index f0c36939f..c9e2f44df 100644
--- a/Client/svelte/src/lib/amcf/Snackbar.svelte
+++ b/Client/svelte/src/lib/amcf/Snackbar.svelte
@@ -10,11 +10,14 @@
 	let color     = $derived.by(() => { poll.v; return app?.SnackBar?.Color || 'secondary'; });
 	let fontColor = $derived.by(() => { poll.v; return app?.SnackBar?.FontColor || 'white'; });
 	let timeout   = $derived.by(() => { poll.v; return app?.SnackBar?.Timeout || -1; });
+	let sequence  = $derived.by(() => { poll.v; return app?.SnackBar?.Sequence || 0; });
 
 	let show = $state(false);
 	let autoHideTimer: ReturnType<typeof setTimeout> | null = null;
 
 	$effect(() => {
+		// Depend on the sequence so that a repeated identical message restarts the auto-hide timer
+		sequence;
 		if (visible && text) {
 			show = true;
 			if (autoHideTimer) clearTimeout(autoHideTimer);
diff --git a/Client/svelte/src/lib/amcf/dataCaptureApi.ts b/Client/svelte/src/lib/amcf/dataCaptureApi.ts
new file mode 100644
index 000000000..8a74a9d47
--- /dev/null
+++ b/Client/svelte/src/lib/amcf/dataCaptureApi.ts
@@ -0,0 +1,216 @@
+// Service layer for the AMCF data capture REST API (/api/datatable/*).
+//
+// All requests go through the shared AMCApplication axios wrapper so that the
+// bearer token and base URL handling stay consistent with the rest of the client.
+//
+// A capture can hold tens of GB. The server therefore never returns a capture as
+// a whole: a request names a row range, and a chart asks for a downsampled
+// envelope whose size follows the pixel width of the chart.
+
+export interface DataCaptureColumn {
+	name: string;
+	description: string;
+	type: string;
+	quantization: number;
+	hasRange: boolean;
+	min: number;
+	max: number;
+}
+
+export interface DataCaptureSegment {
+	index: number;
+	firstRow: number;
+	rowCount: number;
+	size: number;
+	available: boolean;
+}
+
+export interface DataCaptureInfo {
+	uuid: string;
+	identifier: string;
+	name: string;
+	status: string;
+	timestamp: string;
+	rowCount: number;
+	firstAvailableRow: number;
+	storedSize: number;
+	// The server rejects data requests that return more values than this.
+	maxValueCount: number;
+	maxTargetPoints: number;
+	columns: DataCaptureColumn[];
+	segments: DataCaptureSegment[];
+}
+
+export interface DataCaptureBucket {
+	row: number;
+	min: number;
+	max: number;
+}
+
+export interface DataCaptureSeries {
+	name: string;
+	available: boolean;
+	buckets: DataCaptureBucket[];
+}
+
+export interface DataCaptureEnvelope {
+	fromRow: number;
+	rowCount: number;
+	series: DataCaptureSeries[];
+}
+
+export interface DataCaptureRowColumn {
+	name: string;
+	type: string;
+	values: (number | boolean | null)[];
+}
+
+export interface DataCaptureRows {
+	fromRow: number;
+	rowCount: number;
+	columns: DataCaptureRowColumn[];
+}
+
+function columnList (columns: string[]): string {
+	return columns.map((name) => encodeURIComponent(name)).join(',');
+}
+
+// JSON has no NaN, the server sends null for values that are not finite.
+function toNumber (value: unknown): number {
+	return (value === null || value === undefined) ? NaN : Number(value);
+}
+
+// Retrieves schema, row counts, segments and the value range of every column.
+// Only the manifest and the segment footers are read on the server.
+export async function getDataCaptureInfo (app: any, captureUUID: string): Promise<DataCaptureInfo> {
+	const response = await app.axiosGetRequest(`/datatable/${encodeURIComponent(captureUUID)}/info`);
+	const data = response.data || {};
+
+	return {
+		uuid: String(data.uuid || captureUUID),
+		identifier: String(data.identifier || ''),
+		name: String(data.name || ''),
+		status: String(data.status || 'unknown'),
+		timestamp: String(data.timestamp || ''),
+		rowCount: Number(data.rowcount || 0),
+		firstAvailableRow: Number(data.firstavailablerow || 0),
+		storedSize: Number(data.storedsize || 0),
+		maxValueCount: Number(data.maxvaluecount || 0),
+		maxTargetPoints: Number(data.maxtargetpoints || 0),
+		columns: ((data.columns as any[]) || []).map((entry) => ({
+			name: String(entry.name),
+			description: String(entry.description || ''),
+			type: String(entry.type),
+			quantization: Number(entry.quantization || 0),
+			hasRange: entry.hasrange === true,
+			min: Number(entry.min),
+			max: Number(entry.max)
+		})),
+		segments: ((data.segments as any[]) || []).map((entry) => ({
+			index: Number(entry.index),
+			firstRow: Number(entry.firstrow),
+			rowCount: Number(entry.rowcount),
+			size: Number(entry.size),
+			available: entry.available === true
+		}))
+	};
+}
+
+// Retrieves the min/max envelope of one or more columns over a row range.
+// `targetPoints` should be roughly the pixel width of the chart: the response is
+// bounded by it and not by the length of the capture, and single-sample spikes
+// stay visible because every bucket reports its extremes.
+export async function getDataCaptureEnvelope (
+	app: any,
+	captureUUID: string,
+	columns: string[],
+	fromRow: number,
+	rowCount: number,
+	targetPoints: number
+): Promise<DataCaptureEnvelope> {
+	if (columns.length === 0 || rowCount <= 0)
+		return { fromRow, rowCount, series: [] };
+
+	const query =
+		`/datatable/${encodeURIComponent(captureUUID)}?format=json&downsample=minmax` +
+		`&columns=${columnList(columns)}` +
+		`&fromrow=${Math.floor(fromRow)}` +
+		`&rowcount=${Math.floor(rowCount)}` +
+		`&targetpoints=${Math.floor(targetPoints)}`;
+
+	const response = await app.axiosGetRequest(query);
+	const data = response.data || {};
+
+	return {
+		fromRow: Number(data.fromrow ?? fromRow),
+		rowCount: Number(data.rowcount ?? rowCount),
+		series: ((data.series as any[]) || []).map((entry) => ({
+			name: String(entry.name),
+			available: entry.available !== false,
+			buckets: ((entry.buckets as any[]) || []).map((bucket) => ({
+				row: Number(bucket.row),
+				min: toNumber(bucket.min),
+				max: toNumber(bucket.max)
+			}))
+		}))
+	};
+}
+
+// Retrieves a window of rows with their exact values, for a table view.
+export async function getDataCaptureRows (
+	app: any,
+	captureUUID: string,
+	columns: string[],
+	fromRow: number,
+	rowCount: number
+): Promise<DataCaptureRows> {
+	if (columns.length === 0 || rowCount <= 0)
+		return { fromRow, rowCount: 0, columns: [] };
+
+	const query =
+		`/datatable/${encodeURIComponent(captureUUID)}?format=json` +
+		`&columns=${columnList(columns)}` +
+		`&fromrow=${Math.floor(fromRow)}` +
+		`&rowcount=${Math.floor(rowCount)}`;
+
+	const response = await app.axiosGetRequest(query);
+	const data = response.data || {};
+
+	return {
+		fromRow: Number(data.fromrow ?? fromRow),
+		rowCount: Number(data.rowcount ?? rowCount),
+		columns: ((data.columns as any[]) || []).map((entry) => ({
+			name: String(entry.name),
+			type: String(entry.type),
+			values: (entry.values as (number | boolean | null)[]) || []
+		}))
+	};
+}
+
+// Retrieves a row range as CSV text. The range must stay within the value limit
+// that the info document reports (maxValueCount).
+export async function getDataCaptureCSV (
+	app: any,
+	captureUUID: string,
+	columns: string[],
+	fromRow: number,
+	rowCount: number
+): Promise<string> {
+	const query =
+		`/datatable/${encodeURIComponent(captureUUID)}?format=csv` +
+		`&columns=${columnList(columns)}` +
+		`&fromrow=${Math.floor(fromRow)}` +
+		`&rowcount=${Math.floor(rowCount)}`;
+
+	const response = await app.axiosGetRequest(query, { responseType: 'text' });
+	return String(response.data ?? '');
+}
+
+// Requests a download ticket for one segment of the capture and returns its uuid.
+// The segment is the native data table stream and is downloaded through the
+// regular ticket flow of the download endpoint.
+export async function requestSegmentDownloadTicket (app: any, captureUUID: string, segmentIndex: number): Promise<string> {
+	const response = await app.axiosGetRequest(`/datatable/${encodeURIComponent(captureUUID)}/segment/${Math.floor(segmentIndex)}`);
+	const data = response.data || {};
+	return String(data.ticketuuid || '');
+}
diff --git a/Client/svelte/src/lib/amcf/modules/ModuleButtonGroup.svelte b/Client/svelte/src/lib/amcf/modules/ModuleButtonGroup.svelte
index 1b77aa18c..884855440 100644
--- a/Client/svelte/src/lib/amcf/modules/ModuleButtonGroup.svelte
+++ b/Client/svelte/src/lib/amcf/modules/ModuleButtonGroup.svelte
@@ -54,6 +54,8 @@
 					variant={btn.variant === 'primary' ? 'default' : 'outline'}
 					style={isEqual ? '' : buttoncssstyle}
 					disabled={btn.disabled}
+					title={btn.hint || undefined}
+					aria-label={btn.hint || undefined}
 					onclick={() => handleClick(btn)}
 					class="{widthClass(btn)} {isEqual && !widthClass(btn) ? 'flex-1' : ''} {hasIcon ? 'h-auto flex-col gap-1 py-2' : ''}"
 				>
diff --git a/Client/svelte/src/lib/amcf/modules/ModuleConfigurationList.svelte b/Client/svelte/src/lib/amcf/modules/ModuleConfigurationList.svelte
index 7a05895a2..a7924a1ee 100644
--- a/Client/svelte/src/lib/amcf/modules/ModuleConfigurationList.svelte
+++ b/Client/svelte/src/lib/amcf/modules/ModuleConfigurationList.svelte
@@ -24,13 +24,16 @@
 		} catch { return ts; }
 	}
 
+	// Used when the configuration list defines no <button> elements. These actions have no
+	// server-side button UUID, so only the selected configuration is sent with the event.
+	const fallbackActions = [
+		{ uuid: 'load',     caption: 'Load',       selectevent: 'loadconfiguration',      fallback: true },
+		{ uuid: 'activate', caption: 'Set Active', selectevent: 'setactiveconfiguration', fallback: true },
+	];
+
 	function getActions (item: any) {
 		if (entrybuttons.length > 0) return entrybuttons;
-		return [
-			{ uuid: 'load',     caption: 'Load',       selectevent: 'loadconfiguration' },
-			{ uuid: 'activate', caption: 'Set Active',  selectevent: 'setactiveconfiguration' },
-			{ uuid: 'delete',   caption: 'Delete',      selectevent: 'deleteconfiguration' },
-		];
+		return fallbackActions;
 	}
 
 	function triggerAction (action: any, config: any) {
@@ -38,7 +41,7 @@
 			const formvalues: Record<string, string> = {};
 			if (module.selectionvalueuuid)
 				formvalues[module.selectionvalueuuid] = config.configurationUUID;
-			if (module.buttonvalueuuid)
+			if (module.buttonvalueuuid && !action.fallback)
 				formvalues[module.buttonvalueuuid] = action.uuid;
 			app.triggerUIEvent(action.selectevent, module.uuid, formvalues);
 		}
diff --git a/Client/svelte/src/lib/amcf/modules/ModuleDataCapture.svelte b/Client/svelte/src/lib/amcf/modules/ModuleDataCapture.svelte
new file mode 100644
index 000000000..6b937886f
--- /dev/null
+++ b/Client/svelte/src/lib/amcf/modules/ModuleDataCapture.svelte
@@ -0,0 +1,503 @@
+<script lang="ts">
+	import { untrack } from 'svelte';
+	import * as Card from '$lib/components/ui/card/index.js';
+	import { Button } from '$lib/components/ui/button/index.js';
+	import UPlotChart, { type ChartTrace } from '$lib/components/UPlotChart.svelte';
+	import { usePollTick } from '$lib/amcf/poll.svelte';
+	import {
+		getDataCaptureInfo,
+		getDataCaptureEnvelope,
+		getDataCaptureRows,
+		getDataCaptureCSV,
+		requestSegmentDownloadTicket,
+		type DataCaptureInfo,
+		type DataCaptureEnvelope,
+		type DataCaptureRows
+	} from '$lib/amcf/dataCaptureApi';
+
+	// Viewer for a streaming data capture. A capture can hold tens of GB, so the
+	// module never loads it as a whole: the chart asks the server for a min/max
+	// envelope at the pixel width of the chart, and the table shows a window of rows.
+
+	let { module, app }: { module: any; app: any } = $props();
+	const poll = usePollTick();
+
+	const PALETTE = [
+		'#6366f1', '#ef4444', '#10b981', '#f59e0b',
+		'#3b82f6', '#ec4899', '#14b8a6', '#a855f7'
+	];
+
+	// Rows of the table window.
+	const PAGE_ROWS = 25;
+	// A recording capture grows; its info is refreshed at most this often.
+	const INFO_REFRESH_MS = 2000;
+
+	let visible = $derived.by(() => { poll.v; return module.visible !== false; });
+	let title = $derived.by(() => { poll.v; return module.title || module.caption || 'Data Capture'; });
+	let captureUUID = $derived.by(() => { poll.v; return String(module.captureuuid || '').trim(); });
+
+	let info = $state<DataCaptureInfo | null>(null);
+	let selected = $state<string[]>([]);
+
+	// Row window of the chart. It follows the capture until the user zooms.
+	let windowFrom = $state(0);
+	let windowCount = $state(0);
+	let zoomed = $state(false);
+
+	let xValues = $state<number[]>([]);
+	let traces = $state<ChartTrace[]>([]);
+	let hoveredIdx = $state<number | null>(null);
+	let chartWidth = $state(800);
+
+	let tableFrom = $state(0);
+	let tableRows = $state<DataCaptureRows | null>(null);
+
+	let errorMsg = $state('');
+	let exporting = $state(false);
+
+	// Non-reactive coordination state (must not drive the reactive graph).
+	let loadedUUID = '';
+	let lastInfoTime = 0;
+	let defaultsInitialized = false;
+	let lastChartSignature = '';
+	let lastTableSignature = '';
+	let fetching = false;
+	let pending = false;
+
+	let availableEnd = $derived(info ? info.rowCount : 0);
+	let availableStart = $derived(info ? info.firstAvailableRow : 0);
+	let allColumnNames = $derived(info ? info.columns.map((c) => c.name) : []);
+
+	// The CSV export of the chart window must stay within the response limit of the server.
+	let exportValueCount = $derived(windowCount * allColumnNames.length);
+	let exportAllowed = $derived(info !== null && exportValueCount > 0 && exportValueCount <= info.maxValueCount);
+
+	function paletteColor (name: string): string {
+		const idx = selected.indexOf(name);
+		if (idx < 0) return '#94a3b8';
+		return PALETTE[idx % PALETTE.length];
+	}
+
+	function toggleColumn (name: string) {
+		if (selected.includes(name)) {
+			selected = selected.filter((n) => n !== name);
+		} else {
+			if (selected.length >= PALETTE.length) return;
+			selected = [...selected, name];
+		}
+	}
+
+	function handleZoom (minX: number, maxX: number) {
+		const from = Math.max(availableStart, Math.floor(minX));
+		const to = Math.min(availableEnd, Math.ceil(maxX));
+		if (to - from < 2) return;
+		windowFrom = from;
+		windowCount = to - from;
+		zoomed = true;
+	}
+
+	function resetZoom () {
+		zoomed = false;
+		windowFrom = availableStart;
+		windowCount = Math.max(0, availableEnd - availableStart);
+	}
+
+	function handleHover (idx: number | null) {
+		hoveredIdx = idx;
+	}
+
+	function clampTableFrom (row: number): number {
+		const last = Math.max(availableStart, availableEnd - PAGE_ROWS);
+		return Math.min(Math.max(availableStart, Math.floor(row)), last);
+	}
+
+	function pageTable (direction: number) {
+		tableFrom = clampTableFrom(tableFrom + direction * PAGE_ROWS);
+	}
+
+	function showWindowInTable () {
+		tableFrom = clampTableFrom(windowFrom);
+	}
+
+	// Arrays are only replaced when they hold something: a new empty array is a state change,
+	// and `selected` is a dependency of the refresh effect.
+	function clearData () {
+		info = null;
+		if (selected.length > 0) selected = [];
+		if (xValues.length > 0) xValues = [];
+		if (traces.length > 0) traces = [];
+		tableRows = null;
+		lastChartSignature = '';
+		lastTableSignature = '';
+	}
+
+	function applyEnvelope (result: DataCaptureEnvelope) {
+		const available = result.series.filter((s) => s.available && s.buckets.length > 0);
+		if (available.length === 0) {
+			xValues = [];
+			traces = [];
+			return;
+		}
+
+		xValues = available[0].buckets.map((b) => b.row);
+		traces = available.map((s) => ({
+			label: s.name,
+			color: paletteColor(s.name),
+			// The line follows the middle of the envelope; the band shows the extremes.
+			avg: s.buckets.map((b) => (b.min + b.max) / 2),
+			min: s.buckets.map((b) => b.min),
+			max: s.buckets.map((b) => b.max)
+		}));
+	}
+
+	function initializeDefaults (captureInfo: DataCaptureInfo) {
+		const names = captureInfo.columns.map((c) => c.name);
+		const configured = String(module.defaultcolumns || '').split(',').map((s) => s.trim()).filter((n) => names.includes(n));
+
+		if (configured.length > 0) {
+			selected = configured.slice(0, PALETTE.length);
+		} else {
+			// Without configuration the first two value columns are plotted; a time axis is not a value.
+			selected = captureInfo.columns.filter((c) => c.type !== 'timestamp').map((c) => c.name).slice(0, 2);
+		}
+		defaultsInitialized = true;
+	}
+
+	async function doRefresh () {
+		if (!app) return;
+
+		const uuid = captureUUID;
+		if (!uuid) {
+			clearData();
+			loadedUUID = '';
+			errorMsg = '';
+			return;
+		}
+
+		try {
+			const now = Date.now();
+			const isNewCapture = uuid !== loadedUUID;
+			const isGrowing = info !== null && info.status === 'recording' && (now - lastInfoTime) > INFO_REFRESH_MS;
+
+			if (isNewCapture || info === null || isGrowing) {
+				const captureInfo = await getDataCaptureInfo(app, uuid);
+				lastInfoTime = now;
+
+				if (isNewCapture) {
+					clearData();
+					loadedUUID = uuid;
+					defaultsInitialized = false;
+					zoomed = false;
+					tableFrom = captureInfo.firstAvailableRow;
+				}
+
+				info = captureInfo;
+				if (!defaultsInitialized)
+					initializeDefaults(captureInfo);
+
+				if (!zoomed) {
+					windowFrom = captureInfo.firstAvailableRow;
+					windowCount = Math.max(0, captureInfo.rowCount - captureInfo.firstAvailableRow);
+				}
+			}
+
+			const captureInfo = info;
+			if (captureInfo === null) return;
+
+			// Chart: one bucket per pixel, whatever the length of the window.
+			if (selected.length === 0 || windowCount <= 0) {
+				if (xValues.length > 0) xValues = [];
+				if (traces.length > 0) traces = [];
+				lastChartSignature = '';
+			} else {
+				const targetPoints = Math.min(Math.max(Math.floor(chartWidth), 100), Math.min(4000, captureInfo.maxTargetPoints || 4000));
+				const signature = [uuid, selected.join(','), windowFrom, windowCount, targetPoints].join('|');
+				if (signature !== lastChartSignature) {
+					applyEnvelope(await getDataCaptureEnvelope(app, uuid, selected, windowFrom, windowCount, targetPoints));
+					lastChartSignature = signature;
+				}
+			}
+
+			// Table: a window of exact rows.
+			const names = captureInfo.columns.map((c) => c.name);
+			const from = clampTableFrom(tableFrom);
+			const count = Math.max(0, Math.min(PAGE_ROWS, captureInfo.rowCount - from));
+			if (names.length === 0 || count === 0) {
+				tableRows = null;
+				lastTableSignature = '';
+			} else {
+				const signature = [uuid, from, count].join('|');
+				if (signature !== lastTableSignature) {
+					tableRows = await getDataCaptureRows(app, uuid, names, from, count);
+					lastTableSignature = signature;
+				}
+			}
+
+			errorMsg = '';
+		} catch (e: any) {
+			errorMsg = app.extractErrorMessage(e);
+		}
+	}
+
+	async function scheduleRefresh () {
+		if (fetching) {
+			pending = true;
+			return;
+		}
+		fetching = true;
+		try {
+			await doRefresh();
+		} finally {
+			fetching = false;
+			if (pending) {
+				pending = false;
+				scheduleRefresh();
+			}
+		}
+	}
+
+	// React to polling, the configured capture, the column selection and both windows.
+	// Data writes happen untracked so they never feed back into this effect.
+	$effect(() => {
+		poll.v;
+		captureUUID;
+		selected.join(',');
+		windowFrom;
+		windowCount;
+		tableFrom;
+		chartWidth;
+		untrack(() => { scheduleRefresh(); });
+	});
+
+	async function exportWindowAsCSV () {
+		if (!info || !exportAllowed || exporting) return;
+		exporting = true;
+		try {
+			const csv = await getDataCaptureCSV(app, info.uuid, allColumnNames, windowFrom, windowCount);
+			const url = URL.createObjectURL(new Blob([csv], { type: 'text/csv' }));
+			const anchor = document.createElement('a');
+			anchor.href = url;
+			anchor.download = `${info.identifier || 'datacapture'}_${windowFrom}_${windowFrom + windowCount - 1}.csv`;
+			anchor.click();
+			URL.revokeObjectURL(url);
+			errorMsg = '';
+		} catch (e: any) {
+			errorMsg = app.extractErrorMessage(e);
+		} finally {
+			exporting = false;
+		}
+	}
+
+	async function downloadSegment (segmentIndex: number) {
+		if (!info) return;
+		try {
+			const ticket = await requestSegmentDownloadTicket(app, info.uuid, segmentIndex);
+			if (ticket) app.streamDownload(ticket);
+			errorMsg = '';
+		} catch (e: any) {
+			errorMsg = app.extractErrorMessage(e);
+		}
+	}
+
+	function trimFraction (text: string): string {
+		return text.includes('.') ? text.replace(/0+$/, '').replace(/\.$/, '') : text;
+	}
+
+	// The x axis of the chart is the row index. Enough digits are kept to tell the ticks of a
+	// zoomed window apart.
+	function formatRow (v: number): string {
+		if (!isFinite(v)) return '';
+		const abs = Math.abs(v);
+		if (abs >= 1e9) return trimFraction((v / 1e9).toFixed(6)) + 'G';
+		if (abs >= 1e6) return trimFraction((v / 1e6).toFixed(4)) + 'M';
+		if (abs >= 1e4) return trimFraction((v / 1e3).toFixed(2)) + 'k';
+		return v.toFixed(0);
+	}
+
+	function formatNumber (v: number): string {
+		if (!isFinite(v)) return '—';
+		const abs = Math.abs(v);
+		if (abs >= 1000) return v.toFixed(0);
+		if (abs >= 1) return v.toFixed(2);
+		return v.toFixed(4);
+	}
+
+	function formatCell (value: number | boolean | null, type: string): string {
+		if (value === null || value === undefined) return '—';
+		if (typeof value === 'boolean') return value ? 'true' : 'false';
+		if (type === 'float' || type === 'double') return formatNumber(value);
+		return String(value);
+	}
+
+	function formatBytes (bytes: number): string {
+		if (bytes >= 1024 * 1024 * 1024) return (bytes / (1024 * 1024 * 1024)).toFixed(2) + ' GB';
+		if (bytes >= 1024 * 1024) return (bytes / (1024 * 1024)).toFixed(1) + ' MB';
+		if (bytes >= 1024) return (bytes / 1024).toFixed(1) + ' kB';
+		return bytes + ' B';
+	}
+
+	function legendValue (trace: ChartTrace): string {
+		const idx = hoveredIdx !== null && hoveredIdx < trace.avg.length ? hoveredIdx : trace.avg.length - 1;
+		if (idx < 0 || !trace.min || !trace.max) return '—';
+		const lo = trace.min[idx];
+		const hi = trace.max[idx];
+		return lo === hi ? formatNumber(lo) : `${formatNumber(lo)} … ${formatNumber(hi)}`;
+	}
+</script>
+
+{#if visible}
+	<Card.Root class="w-full h-full min-h-0 flex flex-col">
+		<Card.Header class="pb-2">
+			<div class="flex flex-wrap items-center justify-between gap-2">
+				<Card.Title class="text-base">{title}</Card.Title>
+				{#if info}
+					<div class="flex flex-wrap items-center gap-x-3 gap-y-1 text-xs text-muted-foreground">
+						<span>{info.name || info.identifier}</span>
+						<span class="uppercase tracking-wide">{info.status}</span>
+						<span class="tabular-nums">{info.rowCount.toLocaleString()} rows</span>
+						<span class="tabular-nums">{formatBytes(info.storedSize)}</span>
+						{#if info.firstAvailableRow > 0}
+							<span class="text-amber-600" title="Older rows have been deleted by the storage limit.">
+								rows before {info.firstAvailableRow.toLocaleString()} deleted
+							</span>
+						{/if}
+					</div>
+				{/if}
+			</div>
+		</Card.Header>
+
+		<Card.Content class="flex-1 min-h-0 flex flex-col gap-3 overflow-y-auto">
+			{#if errorMsg}
+				<div class="text-sm text-red-500 border border-red-500/30 rounded p-2 bg-red-500/5">{errorMsg}</div>
+			{/if}
+
+			{#if !captureUUID}
+				<div class="flex-1 flex items-center justify-center text-sm text-muted-foreground">
+					No data capture selected.
+				</div>
+			{:else if !info}
+				<div class="flex-1 flex items-center justify-center text-sm text-muted-foreground">
+					Loading data capture…
+				</div>
+			{:else}
+				<!-- Column selection -->
+				<div class="flex flex-wrap items-center gap-1.5">
+					{#each info.columns as column (column.name)}
+						<button
+							type="button"
+							class="inline-flex items-center gap-1.5 rounded-md border px-2 py-0.5 text-xs hover:bg-muted"
+							class:bg-muted={selected.includes(column.name)}
+							title={`${column.description} (${column.type})`}
+							onclick={() => toggleColumn(column.name)}
+						>
+							<span class="size-2.5 rounded-sm" style={`background:${paletteColor(column.name)};`}></span>
+							<span class="font-medium">{column.name}</span>
+						</button>
+					{/each}
+				</div>
+
+				<!-- Envelope chart over the row window -->
+				<div class="border rounded-md p-2 relative min-h-[260px]" bind:clientWidth={chartWidth}>
+					{#if selected.length === 0}
+						<div class="absolute inset-0 flex items-center justify-center text-sm text-muted-foreground">
+							Select one or more columns to plot.
+						</div>
+					{:else if xValues.length === 0}
+						<div class="absolute inset-0 flex items-center justify-center text-sm text-muted-foreground">
+							No stored rows in this range.
+						</div>
+					{:else}
+						<UPlotChart
+							{xValues}
+							{traces}
+							height={240}
+							formatX={formatRow}
+							onZoom={handleZoom}
+							onHover={handleHover}
+						/>
+					{/if}
+				</div>
+
+				<div class="flex flex-wrap items-center gap-x-4 gap-y-1 text-xs">
+					<span class="text-muted-foreground tabular-nums">
+						Rows {windowFrom.toLocaleString()} – {Math.max(windowFrom, windowFrom + windowCount - 1).toLocaleString()}
+					</span>
+					{#each traces as trace (trace.label)}
+						<span class="inline-flex items-center gap-1.5">
+							<span class="size-2.5 rounded-sm" style={`background:${trace.color};`}></span>
+							<span class="font-medium">{trace.label}</span>
+							<span class="tabular-nums text-muted-foreground">{legendValue(trace)}</span>
+						</span>
+					{/each}
+					<span class="flex-1"></span>
+					{#if zoomed}
+						<Button size="sm" variant="outline" onclick={resetZoom}>Reset zoom</Button>
+					{/if}
+					<Button size="sm" variant="outline" onclick={showWindowInTable}>Show rows</Button>
+					<Button
+						size="sm"
+						variant="outline"
+						disabled={!exportAllowed || exporting}
+						title={exportAllowed ? 'Export the rows of the chart window as CSV' : `Zoom in to export: the window holds ${exportValueCount.toLocaleString()} values, the limit is ${info.maxValueCount.toLocaleString()}`}
+						onclick={exportWindowAsCSV}
+					>
+						Export CSV
+					</Button>
+				</div>
+
+				<!-- Window of exact rows -->
+				{#if tableRows && tableRows.columns.length > 0}
+					<div class="border rounded-md overflow-x-auto">
+						<table class="w-full text-xs tabular-nums">
+							<thead class="bg-muted/50">
+								<tr>
+									<th class="px-2 py-1 text-left font-medium">row</th>
+									{#each tableRows.columns as column (column.name)}
+										<th class="px-2 py-1 text-right font-medium">{column.name}</th>
+									{/each}
+								</tr>
+							</thead>
+							<tbody>
+								{#each { length: tableRows.rowCount } as _, rowIndex (rowIndex)}
+									<tr class="border-t">
+										<td class="px-2 py-0.5 text-muted-foreground">{(tableRows.fromRow + rowIndex).toLocaleString()}</td>
+										{#each tableRows.columns as column (column.name)}
+											<td class="px-2 py-0.5 text-right">{formatCell(column.values[rowIndex], column.type)}</td>
+										{/each}
+									</tr>
+								{/each}
+							</tbody>
+						</table>
+					</div>
+					<div class="flex items-center gap-2 text-xs">
+						<Button size="sm" variant="outline" disabled={tableFrom <= availableStart} onclick={() => pageTable(-1)}>Previous</Button>
+						<Button size="sm" variant="outline" disabled={tableFrom + PAGE_ROWS >= availableEnd} onclick={() => pageTable(1)}>Next</Button>
+					</div>
+				{/if}
+
+				<!-- A full capture is exported segment by segment. -->
+				{#if info.segments.length > 0}
+					<div class="text-xs">
+						<div class="font-medium mb-1">Segments</div>
+						<div class="max-h-32 overflow-y-auto border rounded-md divide-y">
+							{#each info.segments as segment (segment.index)}
+								<div class="flex items-center gap-3 px-2 py-1 tabular-nums">
+									<span class="w-10 text-muted-foreground">#{segment.index}</span>
+									<span class="flex-1">
+										rows {segment.firstRow.toLocaleString()} – {Math.max(segment.firstRow, segment.firstRow + segment.rowCount - 1).toLocaleString()}
+									</span>
+									<span class="text-muted-foreground">{formatBytes(segment.size)}</span>
+									{#if segment.available}
+										<Button size="sm" variant="ghost" onclick={() => downloadSegment(segment.index)}>Download</Button>
+									{:else}
+										<span class="text-amber-600">deleted</span>
+									{/if}
+								</div>
+							{/each}
+						</div>
+					</div>
+				{/if}
+			{/if}
+		</Card.Content>
+	</Card.Root>
+{/if}
diff --git a/Client/svelte/src/lib/amcf/modules/ModuleLayerView.svelte b/Client/svelte/src/lib/amcf/modules/ModuleLayerView.svelte
index cd3631258..eb720fc78 100644
--- a/Client/svelte/src/lib/amcf/modules/ModuleLayerView.svelte
+++ b/Client/svelte/src/lib/amcf/modules/ModuleLayerView.svelte
@@ -18,6 +18,10 @@
 	import RotateCcw from '@lucide/svelte/icons/rotate-ccw';
 	import ChevronDown from '@lucide/svelte/icons/chevron-down';
 	import Spline from '@lucide/svelte/icons/spline';
+	import Minus from '@lucide/svelte/icons/minus';
+	import Plus from '@lucide/svelte/icons/plus';
+	import LoaderCircle from '@lucide/svelte/icons/loader-circle';
+	import MdiIcon from '$lib/amcf/MdiIcon.svelte';
 	// @ts-ignore — core JS has no type declarations yet
 	import WebGLImpl from '@core/common/AMCImplementation_WebGL.js';
 	// @ts-ignore
@@ -106,6 +110,11 @@
 		poll.v;
 		return platform?.labelvisible ? String(platform.labelcaption || '') : '';
 	});
+	let labelIcon = $derived.by(() => {
+		poll.v;
+		return platform?.labelvisible ? String(platform.labelicon || '') : '';
+	});
+	let sliderFixed = $derived.by(() => { poll.v; return !!platform?.sliderfixed; });
 
 	// Scatter plot (platform.scatterplotuuid) drawn as points on top of the toolpath.
 	let pointsLoaded = $state(false);
@@ -192,6 +201,14 @@
 	});
 
 	let sliderValue = $state(0);
+	// Written by the follow-server effect; only a changed server layer moves the slider.
+	let lastServerLayer: number | null = null;
+	let draggingSlider = false;
+	let loadingLayer = $state(false);
+	let loadingPoints = $state(false);
+	// Plain tooltip with the point or toolpath segment under the mouse. Always on, unlike the
+	// "Properties" inspector, which replaces it while active.
+	let hoverInfo = $state({ visible: false, text: '', x: 0, y: 0, flipX: false, flipY: false });
 	let appliedColorTheme = $state('');
 	let coordinateSystemOverride: boolean | null = $state(null);
 	let coordinateSystemVisible = $derived.by(() => {
@@ -216,13 +233,23 @@
 		untrack(() => resetView());
 	});
 
+	// Follow the layer of the server, unless the slider is being dragged. Only a changed server value
+	// is applied, so the slider does not jump back while a layer change is still being processed.
 	$effect(() => {
 		poll.v;
-		if (platform) {
-			sliderValue = platform.currentlayer || 0;
+		if (!platform) return;
+		const serverLayer = platform.currentlayer || 0;
+		if (serverLayer !== lastServerLayer) {
+			lastServerLayer = serverLayer;
+			if (!draggingSlider)
+				sliderValue = serverLayer;
 		}
 	});
 
+	function isValidUUID (uuid: string): boolean {
+		return !!uuid && (uuid !== NULL_UUID);
+	}
+
 	function getCurrentColorSet(): Record<string, string> | null {
 		if (!platform) return null;
 		const isDark = document.documentElement.classList.contains('dark');
@@ -232,12 +259,10 @@
 	function getBuildPlateURL(): string | null {
 		if (!platform || !app) return null;
 		const isDark = document.documentElement.classList.contains('dark');
-		if (isDark && platform.dark_baseimageresource) {
+		if (isDark && isValidUUID(platform.dark_baseimageresource))
 			return app.getImageURL(platform.dark_baseimageresource);
-		}
-		if (platform.baseimageresource) {
+		if (isValidUUID(platform.baseimageresource))
 			return app.getImageURL(platform.baseimageresource);
-		}
 		return null;
 	}
 
@@ -411,31 +436,42 @@
 		playbackFrame = 0;
 	}
 
+	// Runs on mount and whenever the container reappears: hiding the module destroys the container
+	// together with the canvas that three.js appended to it.
 	function ensureInit() {
-		if (initialized || !containerEl || !app) return;
+		if (!containerEl || !app) return;
 		const w = containerEl.clientWidth, h = containerEl.clientHeight;
 		if (w === 0 || h === 0) return;
 
+		let firstInit = false;
+
 		try {
-			glInstance = app.retrieveWebGLInstance(module.uuid);
 			if (!glInstance) {
-				glInstance = new WebGLImpl();
-				app.storeWebGLInstance(module.uuid, glInstance);
+				glInstance = app.retrieveWebGLInstance(module.uuid);
+				if (!glInstance) {
+					glInstance = new WebGLImpl();
+					app.storeWebGLInstance(module.uuid, glInstance);
+				}
 			}
 
-			layerViewer = new LayerViewImpl(glInstance);
-			// Write-only, so effects that pan or zoom do not subscribe to viewVersion.
-			layerViewer.onTransformChanged = () => { viewVersion = ++transformChangeCount; };
-			layerViewer.toolpathVisible = toolpathVisible;
-			layerViewer.showLaserOffPoints = showLaserOffPoints;
-			layerViewer.setTimeCapFraction(timeSliderValue / TIME_SLIDER_STEPS);
+			if (!layerViewer) {
+				layerViewer = new LayerViewImpl(glInstance);
+				// Write-only, so effects that pan or zoom do not subscribe to viewVersion.
+				layerViewer.onTransformChanged = () => { viewVersion = ++transformChangeCount; };
+				layerViewer.toolpathVisible = toolpathVisible;
+				layerViewer.showLaserOffPoints = showLaserOffPoints;
+				layerViewer.setTimeCapFraction(timeSliderValue / TIME_SLIDER_STEPS);
+				firstInit = true;
+			}
 
-			glInstance.setupDOMElement(containerEl);
+			// Re-attach the canvas when the container has been recreated
+			if (!containerEl.contains(glInstance.renderer.domElement))
+				glInstance.setupDOMElement(containerEl);
 			layerViewer.updateSize(w, h);
 			layerViewer.setCoordinateTransform(...coordinateTransform);
 			appliedCoordinateTransform = coordinateTransform;
 
-			if (platform) {
+			if (firstInit && platform) {
 				const plateURL = getBuildPlateURL();
 				if (plateURL) {
 					layerViewer.SetBuildPlateSVG(plateURL);
@@ -446,6 +482,8 @@
 				platform.displayed_layer = 0;
 				platform.displayed_build = 0;
 				platform.displayed_scatterplot = '';
+			} else if (autoFrame) {
+				centerOnPlatform();
 			}
 
 			const cs = getCurrentColorSet();
@@ -459,64 +497,97 @@
 			initialized = true;
 		} catch (e) {
 			console.warn('[LayerView] init failed:', e);
+			return;
 		}
+
+		// Load the current layer right away instead of waiting for the next poll
+		if (firstInit)
+			onDataChanged(module);
 	}
 
 	function onDataChanged(sender: any) {
-		if (!layerViewer || !platform || !sender) return;
+		const currentPlatform = module.platform;
+		if (!layerViewer || !currentPlatform || !sender) return;
 		if (!module.isActive || !module.isActive()) return;
 		if (sender.uuid !== module.uuid) return;
 
-		if (platform.displayed_layer !== platform.currentlayer ||
-			platform.displayed_build !== platform.builduuid ||
-			platform.displayed_partstateversion !== platform.partstateversion) {
+		if (currentPlatform.displayed_layer !== currentPlatform.currentlayer ||
+			currentPlatform.displayed_build !== currentPlatform.builduuid ||
+			currentPlatform.displayed_partstateversion !== currentPlatform.partstateversion) {
 
-			if (platform.displayed_layer !== platform.currentlayer || platform.displayed_build !== platform.builduuid) {
+			if (currentPlatform.displayed_layer !== currentPlatform.currentlayer || currentPlatform.displayed_build !== currentPlatform.builduuid) {
 				stopPlayback();
 				setTimeSliderValue(TIME_SLIDER_STEPS);
 				editedTimeRange = null;
 			}
-			if (platform.displayed_build !== platform.builduuid) {
+			if (currentPlatform.displayed_build !== currentPlatform.builduuid) {
 				editedPowerRange = null;
 				editedVelocityRange = null;
 			}
-			platform.displayed_layer = platform.currentlayer;
-			platform.displayed_build = platform.builduuid;
-			platform.displayed_partstateversion = platform.partstateversion;
-			sliderValue = platform.currentlayer || 0;
-
-			app.axiosPostRequest('/build/toolpath', {
-				builduuid: platform.builduuid,
-				layerindex: platform.currentlayer
-			})
-			.then((layerJSON: any) => {
-				if (layerViewer) {
-					clearHover();
-					buildPowerRange = readPowerRange(layerJSON.data);
-					layerViewer.loadLayer(layerJSON.data.segments, layerJSON.data.parts);
-					layerPowerRange = layerViewer.getLayerPowerRange();
-					layerVelocityRange = layerViewer.getLayerVelocityRange();
-					refreshTimeline();
-					layerViewer.RenderScene(true);
-				}
-			})
-			.catch((err: any) => {
-				console.warn('[LayerView] layer load error:', err?.response || err);
-				if (layerViewer) layerViewer.RenderScene(true);
-			});
+			currentPlatform.displayed_layer = currentPlatform.currentlayer;
+			currentPlatform.displayed_build = currentPlatform.builduuid;
+			currentPlatform.displayed_partstateversion = currentPlatform.partstateversion;
+			loadToolpath(currentPlatform.builduuid, currentPlatform.currentlayer);
 		}
 
-		const scatterPlotUUID = typeof platform.scatterplotuuid === 'string' ? platform.scatterplotuuid.toLowerCase() : NULL_UUID;
-		if (platform.displayed_scatterplot !== scatterPlotUUID) {
-			platform.displayed_scatterplot = scatterPlotUUID;
+		const scatterPlotUUID = typeof currentPlatform.scatterplotuuid === 'string' ? currentPlatform.scatterplotuuid.toLowerCase() : NULL_UUID;
+		if (currentPlatform.displayed_scatterplot !== scatterPlotUUID) {
+			currentPlatform.displayed_scatterplot = scatterPlotUUID;
 			loadScatterPlot(scatterPlotUUID);
 		}
 	}
 
+	function isDisplayedToolpath(buildUUID: string, layerIndex: number): boolean {
+		const currentPlatform = module.platform;
+		return !!currentPlatform && (currentPlatform.displayed_build === buildUUID) && (currentPlatform.displayed_layer === layerIndex);
+	}
+
+	function loadToolpath(buildUUID: string, layerIndex: number) {
+		if (!layerViewer) return;
+		hideHoverInfo();
+		clearHover();
+
+		// The null UUID means "no build": show the empty platform
+		if (!isValidUUID(buildUUID)) {
+			loadingLayer = false;
+			buildPowerRange = null;
+			layerViewer.loadLayer(null, null);
+			layerPowerRange = layerViewer.getLayerPowerRange();
+			layerVelocityRange = layerViewer.getLayerVelocityRange();
+			refreshTimeline();
+			return;
+		}
+
+		loadingLayer = true;
+		app.axiosPostRequest('/build/toolpath', {
+			builduuid: buildUUID,
+			layerindex: layerIndex
+		})
+		.then((layerJSON: any) => {
+			// A newer layer has been requested in the meantime
+			if (!layerViewer || !isDisplayedToolpath(buildUUID, layerIndex)) return;
+			clearHover();
+			buildPowerRange = readPowerRange(layerJSON.data);
+			layerViewer.loadLayer(layerJSON.data.segments, layerJSON.data.parts);
+			layerPowerRange = layerViewer.getLayerPowerRange();
+			layerVelocityRange = layerViewer.getLayerVelocityRange();
+			refreshTimeline();
+			layerViewer.RenderScene(true);
+		})
+		.catch((err: any) => {
+			console.warn('[LayerView] layer load error:', err?.response || err);
+			if (layerViewer) layerViewer.RenderScene(true);
+		})
+		.finally(() => {
+			if (isDisplayedToolpath(buildUUID, layerIndex)) loadingLayer = false;
+		});
+	}
+
 	function clearScatterPlot() {
 		pointsLoaded = false;
 		pointColumns = [];
 		hoverPoint = null;
+		hideHoverInfo();
 		if (!layerViewer) return;
 		layerViewer.clearPointsChannelData(POINT_CHANNEL);
 		layerViewer.clearPoints();
@@ -546,8 +617,10 @@
 	async function loadScatterPlot(scatterPlotUUID: string) {
 		const loadIndex = ++pointLoadCounter;
 		clearScatterPlot();
+		loadingPoints = false;
 		if (!layerViewer || scatterPlotUUID === NULL_UUID || !UUID_PATTERN.test(scatterPlotUUID)) return;
 
+		loadingPoints = true;
 		try {
 			const pointsResponse = await app.axiosGetArrayBufferRequest('/pointcloud/' + scatterPlotUUID);
 			let channelColumns: [string, Float32Array][] = [];
@@ -575,11 +648,15 @@
 		} catch (err: any) {
 			console.warn('[LayerView] point cloud error:', err?.response || err);
 			if (layerViewer) layerViewer.RenderScene(true);
+		} finally {
+			// Another scatter plot may have been requested in the meantime
+			if (loadIndex === pointLoadCounter) loadingPoints = false;
 		}
 	}
 
 	function toggleLaserOffPoints() {
 		showLaserOffPoints = !showLaserOffPoints;
+		hideHoverInfo();
 		if (!layerViewer) return;
 		layerViewer.showLaserOffPoints = showLaserOffPoints;
 		layerViewer.updateLayerPoints();
@@ -588,6 +665,7 @@
 
 	function toggleToolpath() {
 		toolpathVisible = !toolpathVisible;
+		hideHoverInfo();
 		if (!layerViewer) return;
 		clearHover();
 		layerViewer.toolpathVisible = toolpathVisible;
@@ -596,15 +674,36 @@
 		layerViewer.RenderScene(true);
 	}
 
-	function changeLayer(layer: number) {
-		sliderValue = layer;
-		if (platform) {
-			app.triggerWidgetRequest(platform.uuid, 'changelayer', { targetlayer: layer });
+	function changeLayerTo(targetLayer: number) {
+		if (!app || !platform || sliderFixed) return;
+		if (isNaN(targetLayer) || (targetLayer < 0) || (targetLayer >= layerCount)) return;
+
+		sliderValue = targetLayer;
+		if (targetLayer !== platform.currentlayer) {
+			// The slider moves optimistically. If the request fails, the server keeps its layer and the
+			// follow-server effect will not fire (the value did not change), so roll back here.
+			app.triggerWidgetRequest(platform.uuid, 'changelayer', { targetlayer: targetLayer }, undefined, (err: any) => {
+				if (!draggingSlider && (sliderValue === targetLayer))
+					sliderValue = module.platform?.currentlayer || 0;
+				app.showSnackBar('Layer change to ' + targetLayer + ' failed: ' + app.extractErrorMessage(err), 'error', 8000);
+			});
 		}
 	}
 
+	// Every layer change recomputes the scatter plot on the server, so the layer is only sent when
+	// the slider is released and not for every intermediate position.
+	function onSliderInput(e: Event) {
+		draggingSlider = true;
+		sliderValue = parseInt((e.target as HTMLInputElement).value);
+	}
+
 	function onSliderChange(e: Event) {
-		changeLayer(parseInt((e.target as HTMLInputElement).value));
+		draggingSlider = false;
+		changeLayerTo(parseInt((e.target as HTMLInputElement).value));
+	}
+
+	function onSliderRelease() {
+		draggingSlider = false;
 	}
 
 	// Clicking the "Layer x / n" badge swaps it for a number field; Enter jumps to the typed
@@ -613,6 +712,7 @@
 	let layerJumpValue = $state<number | null>(null);
 
 	function openLayerJump() {
+		if (sliderFixed) return;
 		layerJumpValue = sliderValue;
 		layerJumpOpen = true;
 	}
@@ -621,7 +721,7 @@
 		if (!layerJumpOpen) return;
 		layerJumpOpen = false;
 		if (typeof layerJumpValue !== 'number' || !Number.isFinite(layerJumpValue)) return;
-		changeLayer(Math.min(Math.max(Math.round(layerJumpValue), 0), layerCount));
+		changeLayerTo(Math.min(Math.max(Math.round(layerJumpValue), 0), Math.max(layerCount - 1, 0)));
 	}
 
 	function onLayerJumpKeyDown(event: KeyboardEvent) {
@@ -640,9 +740,96 @@
 		node.select();
 	}
 
+	function hideHoverInfo() {
+		// A hover update that is already scheduled would show the tooltip again
+		pendingHover = null;
+		if (hoverRAF) {
+			cancelAnimationFrame(hoverRAF);
+			hoverRAF = 0;
+		}
+		if (hoverInfo.visible)
+			hoverInfo.visible = false;
+	}
+
+	function describePoint(mouseX: number, mouseY: number): string {
+		if (!pointsLoaded) return '';
+		const pointIndex = layerViewer.resolvePointIndex(glInstance.getRaycasterCollisions('layerdata_points', mouseX, mouseY));
+		if (pointIndex < 0) return '';
+
+		let text = `Point ID = ${pointIndex}`;
+		const position = layerViewer.getPointPosition(pointIndex);
+		if (position) text += `\nPosition: ${position.x.toFixed(4)} / ${position.y.toFixed(4)} mm`;
+		const velocity = layerViewer.getPointVelocity(pointIndex);
+		if (velocity > 0) text += `\nVelocity: ${velocity.toFixed(4)} mm/s`;
+		const acceleration = layerViewer.getPointAcceleration(pointIndex);
+		if (acceleration) text += `\nAcceleration: ${(acceleration.a / 1000).toFixed(4)} m/s²`;
+		const jerk = layerViewer.getPointJerk(pointIndex);
+		if (jerk) text += `\nJerk: ${(jerk.j / 1000000).toFixed(4)} km/s³`;
+		const power = layerViewer.getPointPower(pointIndex);
+		if (power !== null) text += `\nPower: ${power.toFixed(4)} W`;
+		return text;
+	}
+
+	function describeSegment(mouseX: number, mouseY: number): string {
+		if (!toolpathVisible) return '';
+		const lineIndex = glInstance.getRaycasterCollisions('layerdata_lines', mouseX, mouseY);
+		const coordinates = layerViewer.linesCoordinates;
+		if ((lineIndex < 0) || !coordinates || (lineIndex * 4 + 3 >= coordinates.length)) return '';
+
+		const [x1, y1, x2, y2] = coordinates.slice(lineIndex * 4, lineIndex * 4 + 4);
+		let text = `Line ID = ${lineIndex}\n${x1.toFixed(3)} / ${y1.toFixed(3)} - ${x2.toFixed(3)} / ${y2.toFixed(3)} mm`;
+		const properties = layerViewer.segmentProperties?.[lineIndex];
+		if (properties) {
+			if ((typeof properties.laserpower === 'number') && (typeof properties.laserspeed === 'number'))
+				text += `\n${properties.laserpower.toFixed(0)} W / ${properties.laserspeed.toFixed(1)} mm/s`;
+			if (properties.profilename)
+				text += `\nProfile: ${properties.profilename}`;
+		}
+		return text;
+	}
+
+	// Runs once per animation frame, see scheduleHoverUpdate ()
+	function updateHover(clientX: number, clientY: number) {
+		if (dragging) return;
+
+		if (propertiesMode) {
+			// The "Properties" inspector replaces the plain tooltip while it is active
+			if (hoverInfo.visible) hoverInfo.visible = false;
+			updateHoverSegment(clientX, clientY);
+			return;
+		}
+
+		updateHoverInfo(clientX, clientY);
+	}
+
+	function updateHoverInfo(clientX: number, clientY: number) {
+		if (!glInstance?.renderer || !layerViewer || !containerEl) return;
+
+		const canvasBox = glInstance.renderer.domElement.getBoundingClientRect();
+		const mouseX = clientX - canvasBox.left;
+		const mouseY = clientY - canvasBox.top;
+		const text = describePoint(mouseX, mouseY) || describeSegment(mouseX, mouseY);
+		if (!text) {
+			hideHoverInfo();
+			return;
+		}
+
+		const containerBox = containerEl.getBoundingClientRect();
+		const x = clientX - containerBox.left;
+		const y = clientY - containerBox.top;
+		hoverInfo.text = text;
+		hoverInfo.x = x;
+		hoverInfo.y = y;
+		hoverInfo.flipX = x > containerBox.width / 2;
+		hoverInfo.flipY = y > containerBox.height / 2;
+		hoverInfo.visible = true;
+	}
+
 	function onWheel(event: WheelEvent) {
 		if (!containerEl || !layerViewer) return;
 		event.preventDefault();
+		hideHoverInfo();
+		clearHover();
 
 		let delta = event.deltaY;
 		if (delta > 5) delta = 5;
@@ -908,14 +1095,14 @@
 		return `${characters.slice(0, maxCharacters - 1).join('').trimEnd()}…`;
 	}
 
-	// Segment picking scans every line of the layer, so throttle it to one hit
-	// test per animation frame regardless of how fast pointer events arrive.
+	// Segment and point picking scan every line and point of the layer, so throttle it to one
+	// hit test per animation frame regardless of how fast pointer events arrive.
 	function scheduleHoverUpdate(clientX: number, clientY: number) {
 		pendingHover = { x: clientX, y: clientY };
 		if (hoverRAF) return;
 		hoverRAF = requestAnimationFrame(() => {
 			hoverRAF = 0;
-			if (pendingHover) updateHoverSegment(pendingHover.x, pendingHover.y);
+			if (pendingHover) updateHover(pendingHover.x, pendingHover.y);
 		});
 	}
 
@@ -935,13 +1122,17 @@
 
 	function togglePropertiesMode() {
 		propertiesMode = !propertiesMode;
+		hideHoverInfo();
 		if (!propertiesMode) clearHover();
 	}
 
 	function toggleZoomSelectMode() {
 		zoomSelectMode = !zoomSelectMode;
 		zoomSelection = null;
-		if (zoomSelectMode) clearHover();
+		if (zoomSelectMode) {
+			hideHoverInfo();
+			clearHover();
+		}
 	}
 
 	function localViewportPoint(event: PointerEvent): { x: number; y: number } | null {
@@ -984,6 +1175,7 @@
 		if (zoomSelectMode && event.button === 0) {
 			const point = localViewportPoint(event);
 			if (!point) return;
+			hideHoverInfo();
 			clearHover();
 			zoomSelection = { startX: point.x, startY: point.y, endX: point.x, endY: point.y };
 			(event.target as HTMLElement).setPointerCapture(event.pointerId);
@@ -992,6 +1184,7 @@
 
 		if (event.button === 0 || event.button === 1) {
 			dragging = true;
+			hideHoverInfo();
 			clearHover();
 			dragX = event.clientX;
 			dragY = event.clientY;
@@ -1019,7 +1212,7 @@
 			return;
 		}
 
-		if (propertiesMode && !zoomSelectMode) scheduleHoverUpdate(event.clientX, event.clientY);
+		if (!zoomSelectMode) scheduleHoverUpdate(event.clientX, event.clientY);
 	}
 
 	function onPointerUp() {
@@ -1037,17 +1230,18 @@
 
 	function onPointerLeave() {
 		mousePosition = null;
+		hideHoverInfo();
 		clearHover();
 	}
 
-	// Frames the build-area rectangle. The origin is the location of machine-zero
-	// inside the plate (measured from the lower-left corner), so the plate corners in
-	// machine coordinates run from -origin to (size - origin). For origin=(sx/2,sy/2)
-	// this yields a view symmetric around zero, e.g. [-100..100] x [-125..125].
+	// Frames the build-area rectangle. CenterOnRectangle() works in plate coordinates:
+	// the build plate image is drawn from (0, 0) to (sizex, sizey) and the toolpath is
+	// shifted by the origin (see LayerViewImpl.setOrigin / updateTransform), so the
+	// frame is the plate itself, not "-origin .. size - origin". Framing with the origin
+	// subtracted (as the Vue 2 client does since "Layer Viewer updates") puts the plate
+	// corner into the view center for origin = (sizex/2, sizey/2).
 	function centerOnPlatform() {
 		if (!layerViewer || !platform) return;
-		const ox = platform.originx || 0;
-		const oy = platform.originy || 0;
 		const sx = platform.sizex || 300;
 		const sy = platform.sizey || 300;
 		// Optional per-axis padding (in mm) that enlarges the reset zoom window,
@@ -1055,8 +1249,8 @@
 		const px = platform.paddingx || 0;
 		const py = platform.paddingy || 0;
 		layerViewer.CenterOnRectangle(
-			-ox - ZOOM_MARGIN - px, -oy - ZOOM_MARGIN - py,
-			(sx - ox) + ZOOM_MARGIN + px, (sy - oy) + ZOOM_MARGIN + py
+			-ZOOM_MARGIN - px, -ZOOM_MARGIN - py,
+			sx + ZOOM_MARGIN + px, sy + ZOOM_MARGIN + py
 		);
 	}
 
@@ -1085,6 +1279,33 @@
 		} catch { resetView(); }
 	}
 
+	// The container is recreated whenever the module is hidden and shown again, so the canvas has to be
+	// re-attached and the resize observer re-registered. ensureInit () reads and writes state that must
+	// not become a dependency of this effect.
+	$effect(() => {
+		const element = containerEl;
+		if (!element) return;
+
+		untrack(() => ensureInit());
+
+		const observer = new ResizeObserver(() => {
+			const w = element.clientWidth, h = element.clientHeight;
+			if ((w === 0) || (h === 0)) return;
+
+			if (!layerViewer || !glInstance?.renderer || !element.contains(glInstance.renderer.domElement)) {
+				ensureInit();
+				return;
+			}
+
+			layerViewer.updateSize(w, h);
+			if (autoFrame) centerOnPlatform();
+			layerViewer.RenderScene(true);
+		});
+		observer.observe(element);
+
+		return () => observer.disconnect();
+	});
+
 	onMount(() => {
 		module.onDataHasChanged = onDataChanged;
 
@@ -1093,31 +1314,12 @@
 			platform.displayed_build = 0;
 			platform.displayed_scatterplot = '';
 		}
-
-		requestAnimationFrame(() => {
-			ensureInit();
-		});
-
-		const ro = new ResizeObserver(() => {
-			if (!initialized) {
-				ensureInit();
-			} else if (layerViewer && containerEl) {
-				const w = containerEl.clientWidth, h = containerEl.clientHeight;
-				if (w > 0 && h > 0) {
-					layerViewer.updateSize(w, h);
-					if (autoFrame) centerOnPlatform();
-					layerViewer.RenderScene(true);
-				}
-			}
-		});
-		if (containerEl) ro.observe(containerEl);
-
-		return () => ro.disconnect();
 	});
 
 	onDestroy(() => {
 		module.onDataHasChanged = null;
 		stopPlayback();
+		hideHoverInfo();
 		clearHover();
 		pointLoadCounter++;
 		if (platform) {
@@ -1178,105 +1380,121 @@
 			></div>
 		{/if}
 
-		<!-- Overlaid toolbar -->
-		<div class="layerview-toolbar">
-			<button class="layerview-btn" onclick={resetView} title="Frame the build platform" aria-label="Zoom to platform">
-				<Square size={16} />
-				<span>Zoom to Platform</span>
-			</button>
-			<button class="layerview-btn" onclick={fitToPath} title="Frame the parts" aria-label="Zoom to parts">
-				<Shapes size={16} />
-				<span>Zoom to Parts</span>
-			</button>
-			<button
-				class="layerview-btn"
-				onclick={toggleZoomSelectMode}
-				title="Drag a rectangle to zoom into it (Esc to cancel)"
-				aria-label="Custom zoom: select a rectangle"
-				aria-pressed={zoomSelectMode}
-			>
-				<ZoomIn size={16} />
-				<span>Custom Zoom</span>
-			</button>
-			<button
-				class="layerview-btn"
-				onclick={() => coordinateSystemOverride = !coordinateSystemVisible}
-				title="Toggle coordinate axes"
-				aria-label="Toggle coordinate axes"
-				aria-pressed={coordinateSystemVisible}
-			>
-				<Axis3d size={16} />
-				<span>Axes</span>
-			</button>
-			<button
-				class="layerview-btn"
-				onclick={() => namesMode = !namesMode}
-				title="Show part outlines and names"
-				aria-label="Toggle part outlines and names"
-				aria-pressed={namesMode}
-			>
-				<Tags size={16} />
-				<span>Names</span>
-			</button>
-			<button
-				class="layerview-btn"
-				onclick={togglePropertiesMode}
-				title="Show segment and recorded point properties on hover"
-				aria-label="Toggle segment and point properties inspector"
-				aria-pressed={propertiesMode}
-			>
-				<Info size={16} />
-				<span>Properties</span>
-			</button>
-			<button
-				class="layerview-btn"
-				onclick={cycleToolpathColorMode}
-				title="Change how the toolpath and the recorded points are coloured: profile color, segment type, start time, laser power, velocity or laser on/off"
-				aria-label={`Display mode: ${toolpathColorCaption}. Click to change`}
-			>
-				<Paintbrush size={16} />
-				<span>{toolpathColorCaption}</span>
-			</button>
-			<button
-				class="layerview-btn"
-				onclick={() => (endPointsVisible = !endPointsVisible)}
-				title="Show the start and end points of the toolpath lines"
-				aria-label="Toggle toolpath end points"
-				aria-pressed={endPointsVisible}
-			>
-				<Spline size={16} />
-				<span>End Points</span>
-			</button>
-			{#if pointsLoaded}
-				{#if pointColumns.includes('laseron')}
+		<!-- Overlaid toolbar, with the platform label and the loading indicator below it -->
+		<div class="layerview-top-left">
+			<div class="layerview-toolbar">
+				<button class="layerview-btn" onclick={resetView} title="Frame the build platform" aria-label="Zoom to platform">
+					<Square size={16} />
+					<span>Zoom to Platform</span>
+				</button>
+				<button class="layerview-btn" onclick={fitToPath} title="Frame the parts" aria-label="Zoom to parts">
+					<Shapes size={16} />
+					<span>Zoom to Parts</span>
+				</button>
+				<button
+					class="layerview-btn"
+					onclick={toggleZoomSelectMode}
+					title="Drag a rectangle to zoom into it (Esc to cancel)"
+					aria-label="Custom zoom: select a rectangle"
+					aria-pressed={zoomSelectMode}
+				>
+					<ZoomIn size={16} />
+					<span>Custom Zoom</span>
+				</button>
+				<button
+					class="layerview-btn"
+					onclick={() => coordinateSystemOverride = !coordinateSystemVisible}
+					title="Toggle coordinate axes"
+					aria-label="Toggle coordinate axes"
+					aria-pressed={coordinateSystemVisible}
+				>
+					<Axis3d size={16} />
+					<span>Axes</span>
+				</button>
+				<button
+					class="layerview-btn"
+					onclick={() => namesMode = !namesMode}
+					title="Show part outlines and names"
+					aria-label="Toggle part outlines and names"
+					aria-pressed={namesMode}
+				>
+					<Tags size={16} />
+					<span>Names</span>
+				</button>
+				<button
+					class="layerview-btn"
+					onclick={togglePropertiesMode}
+					title="Show segment and recorded point properties on hover"
+					aria-label="Toggle segment and point properties inspector"
+					aria-pressed={propertiesMode}
+				>
+					<Info size={16} />
+					<span>Properties</span>
+				</button>
+				<button
+					class="layerview-btn"
+					onclick={cycleToolpathColorMode}
+					title="Change how the toolpath and the recorded points are coloured: profile color, segment type, start time, laser power, velocity or laser on/off"
+					aria-label={`Display mode: ${toolpathColorCaption}. Click to change`}
+				>
+					<Paintbrush size={16} />
+					<span>{toolpathColorCaption}</span>
+				</button>
+				<button
+					class="layerview-btn"
+					onclick={() => (endPointsVisible = !endPointsVisible)}
+					title="Show the start and end points of the toolpath lines"
+					aria-label="Toggle toolpath end points"
+					aria-pressed={endPointsVisible}
+				>
+					<Spline size={16} />
+					<span>End Points</span>
+				</button>
+				{#if pointsLoaded}
+					{#if pointColumns.includes('laseron')}
+						<button
+							class="layerview-btn"
+							onclick={toggleLaserOffPoints}
+							title="Also show points recorded while the laser was off"
+							aria-label="Toggle points with laser off"
+							aria-pressed={showLaserOffPoints}
+						>
+							<ZapOff size={16} />
+							<span>Laser Off</span>
+						</button>
+					{/if}
 					<button
 						class="layerview-btn"
-						onclick={toggleLaserOffPoints}
-						title="Also show points recorded while the laser was off"
-						aria-label="Toggle points with laser off"
-						aria-pressed={showLaserOffPoints}
+						onclick={toggleToolpath}
+						title="Show or hide the toolpath below the recorded points"
+						aria-label="Toggle toolpath"
+						aria-pressed={toolpathVisible}
 					>
-						<ZapOff size={16} />
-						<span>Laser Off</span>
+						<Route size={16} />
+						<span>Toolpath</span>
 					</button>
 				{/if}
-				<button
-					class="layerview-btn"
-					onclick={toggleToolpath}
-					title="Show or hide the toolpath below the recorded points"
-					aria-label="Toggle toolpath"
-					aria-pressed={toolpathVisible}
-				>
-					<Route size={16} />
-					<span>Toolpath</span>
-				</button>
+			</div>
+
+			<!-- Platform label and loading indicator -->
+			{#if labelCaption || labelIcon || loadingLayer || loadingPoints}
+				<div class="layerview-status">
+					{#if labelCaption || labelIcon}
+						<div class="layerview-label">
+							{#if labelIcon}<MdiIcon icon={labelIcon} class="h-3.5 w-3.5" />{/if}
+							<span>{labelCaption}</span>
+						</div>
+					{/if}
+					{#if loadingLayer || loadingPoints}
+						<div class="layerview-label">
+							<LoaderCircle class="h-3.5 w-3.5 animate-spin" />
+							<span>Loading layer data</span>
+						</div>
+					{/if}
+				</div>
 			{/if}
 		</div>
 
-		{#if labelCaption}
-			<div class="layerview-label">{labelCaption}</div>
-		{/if}
-
 		<!-- Layer info overlay -->
 		{#if layerCount > 0}
 			{#if layerJumpOpen}
@@ -1287,7 +1505,7 @@
 						type="number"
 						inputmode="numeric"
 						min="0"
-						max={layerCount}
+						max={layerCount - 1}
 						step="1"
 						bind:value={layerJumpValue}
 						onkeydown={onLayerJumpKeyDown}
@@ -1301,7 +1519,7 @@
 					type="button"
 					class="layerview-layer-info layerview-layer-info-button"
 					onclick={openLayerJump}
-					title="Click to jump to a layer"
+					title={sliderFixed ? 'Layer' : 'Click to jump to a layer'}
 					aria-label={`Layer ${sliderValue} of ${layerCount}. Click to jump to a layer`}
 				>
 					Layer {sliderValue} / {layerCount}
@@ -1429,6 +1647,14 @@
 			</div>
 		{/if}
 
+		<!-- Info about the point or toolpath segment under the mouse -->
+		{#if hoverInfo.visible && !propertiesMode}
+			<div
+				class="layerview-hover-info"
+				style="left: {hoverInfo.x}px; top: {hoverInfo.y}px; transform: translate({hoverInfo.flipX ? 'calc(-100% - 12px)' : '12px'}, {hoverInfo.flipY ? 'calc(-100% - 12px)' : '12px'});"
+			>{hoverInfo.text}</div>
+		{/if}
+
 		<!-- Recorded point inspector popup (Properties toggle) -->
 		{#if propertiesMode && hoverPoint}
 			{#if hoverPointScreen}
@@ -1586,19 +1812,32 @@
 			</div>
 		{/if}
 
-		<!-- Layer slider (vertical) -->
+		<!-- Layer slider (vertical) with -/+ step buttons -->
 		{#if layerCount > 0}
 			<div class="layerview-slider-wrap">
+				{#if !sliderFixed}
+					<button class="layerview-btn layerview-step" onclick={() => changeLayerTo(sliderValue + 1)} disabled={sliderValue >= layerCount - 1} title="Next layer" aria-label="Next layer">
+						<Plus size={14} />
+					</button>
+				{/if}
 				<input
 					type="range"
 					class="layerview-slider"
 					min="0"
-					max={layerCount}
+					max={layerCount - 1}
 					value={sliderValue}
-					oninput={onSliderChange}
+					disabled={sliderFixed}
+					oninput={onSliderInput}
+					onchange={onSliderChange}
+					onpointerup={onSliderRelease}
 					aria-label="Layer"
 					aria-orientation="vertical"
 				/>
+				{#if !sliderFixed}
+					<button class="layerview-btn layerview-step" onclick={() => changeLayerTo(sliderValue - 1)} disabled={sliderValue <= 0} title="Previous layer" aria-label="Previous layer">
+						<Minus size={14} />
+					</button>
+				{/if}
 			</div>
 		{/if}
 	</div>
@@ -1700,13 +1939,24 @@
 		fill: var(--destructive, #dc2626);
 		text-decoration: line-through;
 	}
-	.layerview-toolbar {
+	.layerview-top-left {
 		position: absolute;
 		top: 8px;
 		left: 8px;
+		/* Leave room for the layer-info badge in the top-right corner */
+		max-width: calc(100% - 140px);
 		display: flex;
+		flex-direction: column;
+		align-items: flex-start;
 		gap: 4px;
 		z-index: 10;
+		pointer-events: none;
+	}
+	.layerview-toolbar {
+		display: flex;
+		flex-wrap: wrap;
+		gap: 4px;
+		pointer-events: auto;
 	}
 	.layerview-btn {
 		display: inline-flex;
@@ -1737,23 +1987,38 @@
 		background-color: var(--primary, #2563eb);
 		box-shadow: 0 0 0 1px rgba(255, 255, 255, 0.65);
 	}
+	.layerview-btn:disabled {
+		opacity: 0.4;
+		cursor: default;
+	}
+	.layerview-step {
+		width: 24px;
+		height: 24px;
+		padding: 0;
+	}
+	.layerview-status {
+		display: flex;
+		flex-wrap: wrap;
+		gap: 4px;
+		max-width: 100%;
+	}
 	.layerview-label {
-		position: absolute;
-		/* Below the toolbar (top 8px + 56px buttons). */
-		top: 72px;
-		left: 8px;
-		max-width: calc(100% - 56px);
+		display: flex;
+		align-items: center;
+		gap: 6px;
+		min-width: 0;
+		max-width: 100%;
 		padding: 4px 10px;
 		border-radius: 4px;
 		background: rgba(0, 0, 0, 0.65);
 		color: white;
 		font-size: 11px;
 		font-variant-numeric: tabular-nums;
+		white-space: nowrap;
+	}
+	.layerview-label span {
 		overflow: hidden;
 		text-overflow: ellipsis;
-		white-space: nowrap;
-		pointer-events: none;
-		z-index: 10;
 	}
 	.layerview-layer-info {
 		position: absolute;
@@ -1797,6 +2062,8 @@
 		bottom: 8px;
 		width: 64px;
 		height: 64px;
+		border-radius: 4px;
+		background: rgba(0, 0, 0, 0.35);
 		pointer-events: none;
 		z-index: 9;
 	}
@@ -2024,6 +2291,18 @@
 		opacity: 0.4;
 		cursor: default;
 	}
+	.layerview-hover-info {
+		position: absolute;
+		z-index: 20;
+		padding: 5px 8px;
+		border-radius: 4px;
+		background: rgba(0, 0, 0, 0.75);
+		color: white;
+		font-size: 11px;
+		font-variant-numeric: tabular-nums;
+		white-space: pre-line;
+		pointer-events: none;
+	}
 	.layerview-point-marker {
 		position: absolute;
 		width: 14px;
@@ -2086,14 +2365,17 @@
 		top: 44px;
 		bottom: 16px;
 		display: flex;
+		flex-direction: column;
 		align-items: center;
 		justify-content: center;
+		gap: 6px;
 		z-index: 10;
 	}
 	.layerview-slider {
 		writing-mode: vertical-lr;
 		direction: rtl;
-		height: 100%;
+		flex: 1;
+		min-height: 0;
 		width: 20px;
 		accent-color: var(--primary, #2563eb);
 	}
diff --git a/Client/svelte/src/lib/components/UPlotChart.svelte b/Client/svelte/src/lib/components/UPlotChart.svelte
index 7de9b2562..2b7a3754e 100644
--- a/Client/svelte/src/lib/components/UPlotChart.svelte
+++ b/Client/svelte/src/lib/components/UPlotChart.svelte
@@ -17,6 +17,7 @@
 		height = 320,
 		fillHeight = false,
 		showLiveLabels = false,
+		formatX = undefined,
 		onZoom = undefined,
 		onHover = undefined
 	}: {
@@ -29,6 +30,8 @@
 		// When true the latest value of each trace is drawn directly on the canvas
 		// next to the series, at the right-hand edge of the plot.
 		showLiveLabels?: boolean;
+		// Formats the tick labels of the x axis. The default reads x as seconds.
+		formatX?: (value: number) => string;
 		onZoom?: (minX: number, maxX: number) => void;
 		onHover?: (idx: number | null) => void;
 	} = $props();
@@ -172,7 +175,7 @@
 					stroke: '#94a3b8',
 					grid: { stroke: 'rgba(148,163,184,0.15)' },
 					ticks: { stroke: 'rgba(148,163,184,0.25)' },
-					values: (_u, splits) => splits.map((v) => formatSeconds(v))
+					values: (_u, splits) => splits.map((v) => (formatX ? formatX(v) : formatSeconds(v)))
 				},
 				{
 					stroke: '#94a3b8',
diff --git a/Client/svelte/src/lib/components/ui/dialog/dialog-content.svelte b/Client/svelte/src/lib/components/ui/dialog/dialog-content.svelte
index 5c6ee6db3..27966c81e 100644
--- a/Client/svelte/src/lib/components/ui/dialog/dialog-content.svelte
+++ b/Client/svelte/src/lib/components/ui/dialog/dialog-content.svelte
@@ -27,7 +27,7 @@
 		bind:ref
 		data-slot="dialog-content"
 		class={cn(
-			"bg-background data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 fixed top-[50%] left-[50%] z-50 grid w-full max-w-[calc(100%-2rem)] translate-x-[-50%] translate-y-[-50%] gap-4 rounded-lg border p-6 shadow-lg duration-200 sm:max-w-lg",
+			"bg-background data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 fixed top-[50%] left-[50%] z-50 grid grid-cols-[minmax(0,1fr)] w-full max-w-[calc(100%-2rem)] translate-x-[-50%] translate-y-[-50%] gap-4 rounded-lg border p-6 shadow-lg duration-200 wrap-anywhere sm:max-w-lg",
 			className
 		)}
 		{...restProps}
diff --git a/Client/svelte/src/lib/components/ui/dialog/dialog-footer.svelte b/Client/svelte/src/lib/components/ui/dialog/dialog-footer.svelte
index e7ff4468e..e19ffa1b4 100644
--- a/Client/svelte/src/lib/components/ui/dialog/dialog-footer.svelte
+++ b/Client/svelte/src/lib/components/ui/dialog/dialog-footer.svelte
@@ -13,7 +13,7 @@
 <div
 	bind:this={ref}
 	data-slot="dialog-footer"
-	class={cn("flex flex-col-reverse gap-2 sm:flex-row sm:justify-end", className)}
+	class={cn("flex flex-col-reverse gap-2 sm:flex-row sm:flex-wrap sm:justify-end", className)}
 	{...restProps}
 >
 	{@render children?.()}
diff --git a/Client/svelte/src/lib/components/ui/dialog/dialog-title.svelte b/Client/svelte/src/lib/components/ui/dialog/dialog-title.svelte
index e4d4b344a..62937330d 100644
--- a/Client/svelte/src/lib/components/ui/dialog/dialog-title.svelte
+++ b/Client/svelte/src/lib/components/ui/dialog/dialog-title.svelte
@@ -12,6 +12,6 @@
 <DialogPrimitive.Title
 	bind:ref
 	data-slot="dialog-title"
-	class={cn("text-lg leading-none font-semibold", className)}
+	class={cn("text-lg leading-none font-semibold pe-6", className)}
 	{...restProps}
 />
diff --git a/Client/svelte/src/routes/+page.svelte b/Client/svelte/src/routes/+page.svelte
index 0c21e7727..e43f428ca 100644
--- a/Client/svelte/src/routes/+page.svelte
+++ b/Client/svelte/src/routes/+page.svelte
@@ -260,10 +260,20 @@
 		if (open) {
 			app.showDialog(dialog.name);
 		} else {
+			// A non-closable dialog is only closed by the server (see
+			// AMCApplication._syncServerDrivenDialogs) or by a client action.
+			if (dialog.closable === false) return;
 			dialog.dialogIsActive = false;
 			bumpTick();
 		}
 	}
+
+	// Read through a poll-tick dependency: closable is a plain property mutation on a
+	// dialog object with stable identity, so it would not re-trigger on its own.
+	function dialogIsClosable (dialog: any): boolean {
+		poll.v;
+		return dialog.closable !== false;
+	}
 </script>
 
 <!-- Loading -->
@@ -431,11 +441,17 @@
 
 	<!-- Dialogs -->
 	{#each dialogs as dialog (dialog.name)}
+		{@const closable = dialogIsClosable(dialog)}
 		<Dialog.Root
 			open={dialog.name === activeDialogName}
 			onOpenChange={(open) => setDialogOpen(dialog, open)}
 		>
-			<Dialog.Content class="sm:max-w-[50vw] max-h-[80vh] overflow-hidden flex flex-col">
+			<Dialog.Content
+				class="sm:max-w-[50vw] max-h-[80vh] overflow-hidden flex flex-col"
+				showCloseButton={closable}
+				escapeKeydownBehavior={closable ? 'close' : 'ignore'}
+				interactOutsideBehavior={closable ? 'close' : 'ignore'}
+			>
 				{#if dialog.title}
 					<Dialog.Header class="shrink-0">
 						<Dialog.Title>{dialog.title}</Dialog.Title>
diff --git a/Client/vue2/src/App.vue b/Client/vue2/src/App.vue
index a2c364a0f..35a16bfd3 100644
--- a/Client/vue2/src/App.vue
+++ b/Client/vue2/src/App.vue
@@ -109,11 +109,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 		
 		
 		<template v-for="uiDialog in Application.AppContent.Dialogs">
-			<v-dialog :key="uiDialog.name"						
+			<v-dialog :key="uiDialog.name"
 				v-model="uiDialog.dialogIsActive"
 				transition="dialog-bottom-transition"
 				max-width="50vw"
 				height="80vh"
+				:persistent="uiDialog.closable === false"
+				:no-click-animation="uiDialog.closable === false"
 			>
 			
 			<v-card> 
@@ -271,10 +273,16 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 			},
 
-			snackBarVisible () {
-				if (!this.Application)
-					return false;
-				return this.Application.SnackBar.Visible;
+			snackBarVisible: {
+				get () {
+					if (!this.Application)
+						return false;
+					return this.Application.SnackBar.Visible;
+				},
+				set (visible) {
+					if (this.Application)
+						this.Application.SnackBar.Visible = visible;
+				}
 			},
 			
 			snackBarTimeout () {
diff --git a/Drivers/GRPC/Implementation/libmcdriver_grpc_driver_grpc.cpp b/Drivers/GRPC/Implementation/libmcdriver_grpc_driver_grpc.cpp
index 831b3b588..18bdc8133 100644
--- a/Drivers/GRPC/Implementation/libmcdriver_grpc_driver_grpc.cpp
+++ b/Drivers/GRPC/Implementation/libmcdriver_grpc_driver_grpc.cpp
@@ -40,6 +40,12 @@ Abstract: This is a stub class definition of CDriver_GRPC
 
 #include "libmcdriver_grpc_grpcconnection.hpp"
 
+#include <thread>
+#include <chrono>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
 using namespace LibMCDriver_GRPC::Impl;
 
 /*************************************************************************************************************************
@@ -136,6 +142,40 @@ void CDriver_GRPC::loadGRPCSDK()
 
 		SetDllDirectoryW(m_sDLLDirectoryW.c_str ());
 
+		// SetDllDirectoryW is process-wide state and the ScanLab OIE and SMC drivers set it to
+		// their own directories while their state machines initialize, which happens at the same
+		// time as this. The generated loadLibrary() below uses a plain LoadLibraryW, whose
+		// dependency search then goes to the wrong directory (abseil, protobuf, ... not found;
+		// intermittent COULDNOTLOADLIBRARY at startup, 2026-10-07). Bring the wrapper DLL into
+		// the process first with LOAD_WITH_ALTERED_SEARCH_PATH, which resolves its dependencies
+		// from its own directory regardless of that state. loadLibrary() then only finds the
+		// module that is already loaded. The handle is kept for the lifetime of the process, like
+		// the wrapper's own handle.
+		{
+			std::string sWrapperFileNameUTF8 = m_pGRPCDLL_LibGRPCWrapper->GetAbsoluteFileName();
+			int nWrapperLength = (int)sWrapperFileNameUTF8.length();
+			int nWrapperBufferSize = nWrapperLength * 2 + 2;
+			std::vector<wchar_t> wsWrapperFileName(nWrapperBufferSize);
+			int nWrapperResult = MultiByteToWideChar(CP_UTF8, 0, sWrapperFileNameUTF8.c_str(), nWrapperLength, &wsWrapperFileName[0], nWrapperBufferSize);
+			if (nWrapperResult == 0)
+				throw ELibMCDriver_GRPCInterfaceException(LIBMCDRIVER_GRPC_ERROR_COULDNOTLOADLIBRARY);
+
+			HMODULE hPreloaded = 0;
+			DWORD nLastLoadError = 0;
+			for (uint32_t nAttempt = 0; (nAttempt < 5) && (hPreloaded == 0); nAttempt++) {
+				if (nAttempt > 0) {
+					std::this_thread::sleep_for(std::chrono::milliseconds(200));
+					SetDllDirectoryW(m_sDLLDirectoryW.c_str());
+				}
+				hPreloaded = LoadLibraryExW(wsWrapperFileName.data(), NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
+				if (hPreloaded == 0)
+					nLastLoadError = GetLastError();
+			}
+			if (hPreloaded == 0)
+				throw ELibMCDriver_GRPCInterfaceException(LIBMCDRIVER_GRPC_ERROR_COULDNOTLOADLIBRARY, "could not load gRPC wrapper library " + sWrapperFileNameUTF8 + " (Windows error " + std::to_string(nLastLoadError) + ")");
+			m_pPreloadedGRPCWrapperModule = (void*)hPreloaded;
+		}
+
 		m_pGRPCWrapper = LibGRPCWrapper::CWrapper::loadLibrary (m_pGRPCDLL_LibGRPCWrapper->GetAbsoluteFileName ());
 #endif
 
diff --git a/Drivers/GRPC/Implementation/libmcdriver_grpc_driver_grpc.hpp b/Drivers/GRPC/Implementation/libmcdriver_grpc_driver_grpc.hpp
index 7f56b6570..9c297a2d5 100644
--- a/Drivers/GRPC/Implementation/libmcdriver_grpc_driver_grpc.hpp
+++ b/Drivers/GRPC/Implementation/libmcdriver_grpc_driver_grpc.hpp
@@ -70,6 +70,10 @@ class CDriver_GRPC : public virtual IDriver_GRPC, public virtual CDriver {
 
 	std::wstring m_sDLLDirectoryW;
 
+	// Module handle of the wrapper DLL loaded ahead of the generated wrapper (see loadGRPCSDK).
+	// Never released: the DLL stays in the process as long as the wrapper uses it.
+	void* m_pPreloadedGRPCWrapperModule = nullptr;
+
 	LibMCEnv::PWorkingFile m_pGRPCDLL_AbseilDLL;
 	LibMCEnv::PWorkingFile m_pGRPCDLL_Cares;
 	LibMCEnv::PWorkingFile m_pGRPCDLL_LibCrypto3;
diff --git a/Drivers/Pylon/ACT/LibMCDriver_Pylon.xml b/Drivers/Pylon/ACT/LibMCDriver_Pylon.xml
index a2b7ff17f..b4a99174a 100644
--- a/Drivers/Pylon/ACT/LibMCDriver_Pylon.xml
+++ b/Drivers/Pylon/ACT/LibMCDriver_Pylon.xml
@@ -288,6 +288,11 @@ Custom implementation
 			<param name="Device" type="class" class="PylonDevice" pass="return" description="Device Instance" />
 		</method>
 
+		<method name="ConnectToUniqueEmulatedDevice" description="Enables the pylon camera emulation for the time of the connection, checks if there is exactly one emulated device and connects to it. Physical cameras are ignored.">
+			<param name="Identifier" type="string" pass="in" description="Identifier for the connection. Fails if identifier is already existing. MUST be non-empty a alpanumerical string with _, up until 64 characters." />
+			<param name="Device" type="class" class="PylonDevice" pass="return" description="Device Instance" />
+		</method>
+
 		<method name="ConnectionExists" description= "Checks if a connection exists with a certain identifier.">
 			<param name="Identifier" type="string" pass="in" description="Identifier for the connection." />
 			<param name="Exists" type="bool" pass="return" description="Returns true, if the connection exists, false otherwise." />
diff --git a/Drivers/Pylon/Headers/CppDynamic/libmcdriver_pylon_dynamic.h b/Drivers/Pylon/Headers/CppDynamic/libmcdriver_pylon_dynamic.h
index 18cc277e6..d0483bab0 100644
--- a/Drivers/Pylon/Headers/CppDynamic/libmcdriver_pylon_dynamic.h
+++ b/Drivers/Pylon/Headers/CppDynamic/libmcdriver_pylon_dynamic.h
@@ -430,6 +430,16 @@ typedef LibMCDriver_PylonResult (*PLibMCDriver_PylonDriver_Pylon_ConnectToUnique
 */
 typedef LibMCDriver_PylonResult (*PLibMCDriver_PylonDriver_Pylon_ConnectToUniqueGigEDevicePtr) (LibMCDriver_Pylon_Driver_Pylon pDriver_Pylon, const char * pIdentifier, LibMCDriver_Pylon_PylonDevice * pDevice);
 
+/**
+* Enables the pylon camera emulation for the time of the connection, checks if there is exactly one emulated device and connects to it. Physical cameras are ignored.
+*
+* @param[in] pDriver_Pylon - Driver_Pylon instance.
+* @param[in] pIdentifier - Identifier for the connection. Fails if identifier is already existing. MUST be non-empty a alpanumerical string with _, up until 64 characters.
+* @param[out] pDevice - Device Instance
+* @return error code or 0 (success)
+*/
+typedef LibMCDriver_PylonResult (*PLibMCDriver_PylonDriver_Pylon_ConnectToUniqueEmulatedDevicePtr) (LibMCDriver_Pylon_Driver_Pylon pDriver_Pylon, const char * pIdentifier, LibMCDriver_Pylon_PylonDevice * pDevice);
+
 /**
 * Checks if a connection exists with a certain identifier.
 *
@@ -570,6 +580,7 @@ typedef struct {
 	PLibMCDriver_PylonDriver_Pylon_SetCustomSDKResourcePtr m_Driver_Pylon_SetCustomSDKResource;
 	PLibMCDriver_PylonDriver_Pylon_ConnectToUniqueGenericDevicePtr m_Driver_Pylon_ConnectToUniqueGenericDevice;
 	PLibMCDriver_PylonDriver_Pylon_ConnectToUniqueGigEDevicePtr m_Driver_Pylon_ConnectToUniqueGigEDevice;
+	PLibMCDriver_PylonDriver_Pylon_ConnectToUniqueEmulatedDevicePtr m_Driver_Pylon_ConnectToUniqueEmulatedDevice;
 	PLibMCDriver_PylonDriver_Pylon_ConnectionExistsPtr m_Driver_Pylon_ConnectionExists;
 	PLibMCDriver_PylonDriver_Pylon_FindDeviceConnectionPtr m_Driver_Pylon_FindDeviceConnection;
 	PLibMCDriver_PylonDriver_Pylon_CloseAllConnectionsPtr m_Driver_Pylon_CloseAllConnections;
diff --git a/Drivers/Pylon/Headers/CppDynamic/libmcdriver_pylon_dynamic.hpp b/Drivers/Pylon/Headers/CppDynamic/libmcdriver_pylon_dynamic.hpp
index d75662464..623688ed0 100644
--- a/Drivers/Pylon/Headers/CppDynamic/libmcdriver_pylon_dynamic.hpp
+++ b/Drivers/Pylon/Headers/CppDynamic/libmcdriver_pylon_dynamic.hpp
@@ -520,6 +520,7 @@ class CDriver_Pylon : public CDriver {
 	inline void SetCustomSDKResource(const std::string & sResourceName);
 	inline PPylonDevice ConnectToUniqueGenericDevice(const std::string & sIdentifier);
 	inline PPylonDevice ConnectToUniqueGigEDevice(const std::string & sIdentifier);
+	inline PPylonDevice ConnectToUniqueEmulatedDevice(const std::string & sIdentifier);
 	inline bool ConnectionExists(const std::string & sIdentifier);
 	inline PPylonDevice FindDeviceConnection(const std::string & sIdentifier);
 	inline void CloseAllConnections();
@@ -683,6 +684,7 @@ class CDriver_Pylon : public CDriver {
 		pWrapperTable->m_Driver_Pylon_SetCustomSDKResource = nullptr;
 		pWrapperTable->m_Driver_Pylon_ConnectToUniqueGenericDevice = nullptr;
 		pWrapperTable->m_Driver_Pylon_ConnectToUniqueGigEDevice = nullptr;
+		pWrapperTable->m_Driver_Pylon_ConnectToUniqueEmulatedDevice = nullptr;
 		pWrapperTable->m_Driver_Pylon_ConnectionExists = nullptr;
 		pWrapperTable->m_Driver_Pylon_FindDeviceConnection = nullptr;
 		pWrapperTable->m_Driver_Pylon_CloseAllConnections = nullptr;
@@ -1067,6 +1069,15 @@ class CDriver_Pylon : public CDriver {
 		if (pWrapperTable->m_Driver_Pylon_ConnectToUniqueGigEDevice == nullptr)
 			return LIBMCDRIVER_PYLON_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
+		#ifdef _WIN32
+		pWrapperTable->m_Driver_Pylon_ConnectToUniqueEmulatedDevice = (PLibMCDriver_PylonDriver_Pylon_ConnectToUniqueEmulatedDevicePtr) GetProcAddress(hLibrary, "libmcdriver_pylon_driver_pylon_connecttouniqueemulateddevice");
+		#else // _WIN32
+		pWrapperTable->m_Driver_Pylon_ConnectToUniqueEmulatedDevice = (PLibMCDriver_PylonDriver_Pylon_ConnectToUniqueEmulatedDevicePtr) dlsym(hLibrary, "libmcdriver_pylon_driver_pylon_connecttouniqueemulateddevice");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_Driver_Pylon_ConnectToUniqueEmulatedDevice == nullptr)
+			return LIBMCDRIVER_PYLON_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
 		#ifdef _WIN32
 		pWrapperTable->m_Driver_Pylon_ConnectionExists = (PLibMCDriver_PylonDriver_Pylon_ConnectionExistsPtr) GetProcAddress(hLibrary, "libmcdriver_pylon_driver_pylon_connectionexists");
 		#else // _WIN32
@@ -1317,6 +1328,10 @@ class CDriver_Pylon : public CDriver {
 		if ( (eLookupError != 0) || (pWrapperTable->m_Driver_Pylon_ConnectToUniqueGigEDevice == nullptr) )
 			return LIBMCDRIVER_PYLON_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
+		eLookupError = (*pLookup)("libmcdriver_pylon_driver_pylon_connecttouniqueemulateddevice", (void**)&(pWrapperTable->m_Driver_Pylon_ConnectToUniqueEmulatedDevice));
+		if ( (eLookupError != 0) || (pWrapperTable->m_Driver_Pylon_ConnectToUniqueEmulatedDevice == nullptr) )
+			return LIBMCDRIVER_PYLON_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
 		eLookupError = (*pLookup)("libmcdriver_pylon_driver_pylon_connectionexists", (void**)&(pWrapperTable->m_Driver_Pylon_ConnectionExists));
 		if ( (eLookupError != 0) || (pWrapperTable->m_Driver_Pylon_ConnectionExists == nullptr) )
 			return LIBMCDRIVER_PYLON_ERROR_COULDNOTFINDLIBRARYEXPORT;
@@ -1829,6 +1844,22 @@ class CDriver_Pylon : public CDriver {
 		return std::make_shared<CPylonDevice>(m_pWrapper, hDevice);
 	}
 	
+	/**
+	* CDriver_Pylon::ConnectToUniqueEmulatedDevice - Enables the pylon camera emulation for the time of the connection, checks if there is exactly one emulated device and connects to it. Physical cameras are ignored.
+	* @param[in] sIdentifier - Identifier for the connection. Fails if identifier is already existing. MUST be non-empty a alpanumerical string with _, up until 64 characters.
+	* @return Device Instance
+	*/
+	PPylonDevice CDriver_Pylon::ConnectToUniqueEmulatedDevice(const std::string & sIdentifier)
+	{
+		LibMCDriver_PylonHandle hDevice = nullptr;
+		CheckError(m_pWrapper->m_WrapperTable.m_Driver_Pylon_ConnectToUniqueEmulatedDevice(m_pHandle, sIdentifier.c_str(), &hDevice));
+		
+		if (!hDevice) {
+			CheckError(LIBMCDRIVER_PYLON_ERROR_INVALIDPARAM);
+		}
+		return std::make_shared<CPylonDevice>(m_pWrapper, hDevice);
+	}
+	
 	/**
 	* CDriver_Pylon::ConnectionExists - Checks if a connection exists with a certain identifier.
 	* @param[in] sIdentifier - Identifier for the connection.
diff --git a/Drivers/Pylon/Implementation/libmcdriver_pylon_driver_pylon.cpp b/Drivers/Pylon/Implementation/libmcdriver_pylon_driver_pylon.cpp
index 7acae7231..0049a6c30 100644
--- a/Drivers/Pylon/Implementation/libmcdriver_pylon_driver_pylon.cpp
+++ b/Drivers/Pylon/Implementation/libmcdriver_pylon_driver_pylon.cpp
@@ -39,8 +39,97 @@ Abstract: This is a stub class definition of CDriver_Pylon
 #define __STRINGIZE(x) #x
 #define __STRINGIZE_VALUE_OF(x) __STRINGIZE(x)
 
+#include <vector>
+
+#ifdef _WIN32
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#include <windows.h>
+#else // _WIN32
+#include <cstdlib>
+#endif // _WIN32
+
 using namespace LibMCDriver_Pylon::Impl;
 
+namespace {
+
+	// Name of the environment variable that announces emulated cameras to pylon, and the value for
+	// exactly one emulated camera.
+	const char* PYLON_CAMERAEMULATION_VARIABLE = "PYLON_CAMEMU";
+	const char* PYLON_CAMERAEMULATION_ONEDEVICE = "1";
+
+	// Device class pylon reports for an emulated camera.
+	const char* PYLON_CAMERAEMULATION_DEVICECLASS = "BaslerCamEmu";
+
+	// Buffer size for device info property names and values. The pylon C API writes the terminating
+	// zero into the buffer and fails if the buffer is too small.
+	const size_t PYLON_DEVICEINFO_BUFFERSIZE = 1024;
+
+	// pylon reads PYLON_CAMEMU whenever it enumerates devices. The variable is only needed until the
+	// emulated device is open, so it is restored as soon as the scope ends and never shows up in later
+	// enumerations of physical cameras. The variable is process wide, which is why it is set here and
+	// not by the plugin or the server start.
+	class CPylonCameraEmulationScope {
+	private:
+		bool m_bHadValue;
+		std::string m_sPreviousValue;
+
+		static bool readVariable(std::string& sValue)
+		{
+#ifdef _WIN32
+			std::vector<char> buffer(32767, 0);
+			DWORD nLength = GetEnvironmentVariableA(PYLON_CAMERAEMULATION_VARIABLE, buffer.data(), (DWORD)buffer.size());
+			if ((nLength == 0) || (nLength >= buffer.size()))
+				return false;
+			sValue = std::string(buffer.data(), nLength);
+			return true;
+#else
+			const char* pValue = getenv(PYLON_CAMERAEMULATION_VARIABLE);
+			if (pValue == nullptr)
+				return false;
+			sValue = pValue;
+			return true;
+#endif
+		}
+
+		static void writeVariable(const std::string& sValue)
+		{
+#ifdef _WIN32
+			SetEnvironmentVariableA(PYLON_CAMERAEMULATION_VARIABLE, sValue.c_str());
+#else
+			setenv(PYLON_CAMERAEMULATION_VARIABLE, sValue.c_str(), 1);
+#endif
+		}
+
+		static void removeVariable()
+		{
+#ifdef _WIN32
+			SetEnvironmentVariableA(PYLON_CAMERAEMULATION_VARIABLE, nullptr);
+#else
+			unsetenv(PYLON_CAMERAEMULATION_VARIABLE);
+#endif
+		}
+
+	public:
+		CPylonCameraEmulationScope()
+			: m_bHadValue(false)
+		{
+			m_bHadValue = readVariable(m_sPreviousValue);
+			writeVariable(PYLON_CAMERAEMULATION_ONEDEVICE);
+		}
+
+		~CPylonCameraEmulationScope()
+		{
+			if (m_bHadValue)
+				writeVariable(m_sPreviousValue);
+			else
+				removeVariable();
+		}
+	};
+
+}
+
 /*************************************************************************************************************************
  Class definition of CDriver_Pylon 
 **************************************************************************************************************************/
@@ -203,6 +292,75 @@ IPylonDevice * CDriver_Pylon::ConnectToUniqueGigEDevice(const std::string & sIde
 
 }
 
+std::string CDriver_Pylon::readDeviceClass(size_t nDeviceIndex)
+{
+	libPylonDeviceInfoHandle pDeviceInfoHandle = nullptr;
+	m_pPylonSDK->checkError(m_pPylonSDK->PylonGetDeviceInfoHandle(nDeviceIndex, &pDeviceInfoHandle));
+
+	size_t nPropertyCount = 0;
+	m_pPylonSDK->checkError(m_pPylonSDK->PylonDeviceInfoGetNumProperties(pDeviceInfoHandle, &nPropertyCount));
+
+	for (size_t nPropertyIndex = 0; nPropertyIndex < nPropertyCount; nPropertyIndex++) {
+		std::vector<char> nameBuffer(PYLON_DEVICEINFO_BUFFERSIZE, 0);
+		size_t nNameLength = nameBuffer.size();
+		m_pPylonSDK->checkError(m_pPylonSDK->PylonDeviceInfoGetPropertyName(pDeviceInfoHandle, nPropertyIndex, nameBuffer.data(), &nNameLength));
+
+		if (std::string(nameBuffer.data()) != "DeviceClass")
+			continue;
+
+		std::vector<char> valueBuffer(PYLON_DEVICEINFO_BUFFERSIZE, 0);
+		size_t nValueLength = valueBuffer.size();
+		m_pPylonSDK->checkError(m_pPylonSDK->PylonDeviceInfoGetPropertyValueByIndex(pDeviceInfoHandle, nPropertyIndex, valueBuffer.data(), &nValueLength));
+
+		return std::string(valueBuffer.data());
+	}
+
+	return "";
+}
+
+IPylonDevice * CDriver_Pylon::ConnectToUniqueEmulatedDevice(const std::string & sIdentifier)
+{
+	auto iIter = m_ConnectedDevices.find(sIdentifier);
+	if (iIter != m_ConnectedDevices.end())
+		throw ELibMCDriver_PylonInterfaceException(LIBMCDRIVER_PYLON_ERROR_CONNECTIONIDENTIFIERALREADYINUSE, "connection identifier already in use: " + sIdentifier);
+
+	checkIdentifier(sIdentifier);
+
+	loadPylonSDK();
+
+	// The variable has to be set while the devices are enumerated and while the device is opened,
+	// which happens in the constructor of CPylonDeviceInstance. The scope restores it afterwards.
+	CPylonCameraEmulationScope emulationScope;
+
+	size_t numDevices = 0;
+	m_pPylonSDK->checkError(m_pPylonSDK->PylonEnumerateDevices(&numDevices));
+
+	// A physical camera is listed as well, so the count of all devices says nothing here: only the
+	// devices of the emulation class count.
+	size_t nEmulatedDevices = 0;
+	size_t nDeviceIndex = 0;
+	for (size_t nIndex = 0; nIndex < numDevices; nIndex++) {
+		if (readDeviceClass(nIndex) == PYLON_CAMERAEMULATION_DEVICECLASS) {
+			nEmulatedDevices++;
+			nDeviceIndex = nIndex;
+		}
+	}
+
+	if (nEmulatedDevices != 1)
+		throw ELibMCDriver_PylonInterfaceException(LIBMCDRIVER_PYLON_ERROR_DEVICENOTUNIQUE, "number of emulated devices is not unique: " + std::to_string(nEmulatedDevices));
+
+	libPylonDeviceHandle pDeviceHandle = nullptr;
+	m_pPylonSDK->checkError(m_pPylonSDK->PylonCreateDeviceByIndex(nDeviceIndex, &pDeviceHandle));
+
+	if (pDeviceHandle == nullptr)
+		throw ELibMCDriver_PylonInterfaceException(LIBMCDRIVER_PYLON_ERROR_COULDNOTCREATEGENERICDEVICE);
+
+	auto pDeviceInstance = std::make_shared<CPylonDeviceInstance>(sIdentifier, m_pPylonSDK, pDeviceHandle);
+	m_ConnectedDevices.insert(std::make_pair(sIdentifier, pDeviceInstance));
+
+	return new CPylonDevice(pDeviceInstance);
+}
+
 bool CDriver_Pylon::ConnectionExists(const std::string & sIdentifier)
 {
 	auto iIter = m_ConnectedDevices.find(sIdentifier);
diff --git a/Drivers/Pylon/Implementation/libmcdriver_pylon_driver_pylon.hpp b/Drivers/Pylon/Implementation/libmcdriver_pylon_driver_pylon.hpp
index b0cdce848..9c2ed14ec 100644
--- a/Drivers/Pylon/Implementation/libmcdriver_pylon_driver_pylon.hpp
+++ b/Drivers/Pylon/Implementation/libmcdriver_pylon_driver_pylon.hpp
@@ -76,6 +76,9 @@ class CDriver_Pylon : public virtual IDriver_Pylon, public virtual CDriver {
 
 	void checkIdentifier(const std::string& sIdentifier);
 
+	// Returns the DeviceClass property of an enumerated device, empty if the device has none.
+	std::string readDeviceClass(size_t nDeviceIndex);
+
 public:
 
 	CDriver_Pylon(const std::string & sName, LibMCEnv::PDriverEnvironment pDriverEnvironment);
@@ -100,6 +103,8 @@ class CDriver_Pylon : public virtual IDriver_Pylon, public virtual CDriver {
 
 	IPylonDevice * ConnectToUniqueGigEDevice(const std::string & sIdentifier) override;
 
+	IPylonDevice * ConnectToUniqueEmulatedDevice(const std::string & sIdentifier) override;
+
 	bool ConnectionExists(const std::string & sIdentifier) override;
 
 	IPylonDevice* FindDeviceConnection(const std::string& sIdentifier) override;
diff --git a/Drivers/Pylon/Interfaces/libmcdriver_pylon_abi.hpp b/Drivers/Pylon/Interfaces/libmcdriver_pylon_abi.hpp
index e2ae8ad95..b71d96583 100644
--- a/Drivers/Pylon/Interfaces/libmcdriver_pylon_abi.hpp
+++ b/Drivers/Pylon/Interfaces/libmcdriver_pylon_abi.hpp
@@ -443,6 +443,16 @@ LIBMCDRIVER_PYLON_DECLSPEC LibMCDriver_PylonResult libmcdriver_pylon_driver_pylo
 */
 LIBMCDRIVER_PYLON_DECLSPEC LibMCDriver_PylonResult libmcdriver_pylon_driver_pylon_connecttouniquegigedevice(LibMCDriver_Pylon_Driver_Pylon pDriver_Pylon, const char * pIdentifier, LibMCDriver_Pylon_PylonDevice * pDevice);
 
+/**
+* Enables the pylon camera emulation for the time of the connection, checks if there is exactly one emulated device and connects to it. Physical cameras are ignored.
+*
+* @param[in] pDriver_Pylon - Driver_Pylon instance.
+* @param[in] pIdentifier - Identifier for the connection. Fails if identifier is already existing. MUST be non-empty a alpanumerical string with _, up until 64 characters.
+* @param[out] pDevice - Device Instance
+* @return error code or 0 (success)
+*/
+LIBMCDRIVER_PYLON_DECLSPEC LibMCDriver_PylonResult libmcdriver_pylon_driver_pylon_connecttouniqueemulateddevice(LibMCDriver_Pylon_Driver_Pylon pDriver_Pylon, const char * pIdentifier, LibMCDriver_Pylon_PylonDevice * pDevice);
+
 /**
 * Checks if a connection exists with a certain identifier.
 *
diff --git a/Drivers/Pylon/Interfaces/libmcdriver_pylon_interfaces.hpp b/Drivers/Pylon/Interfaces/libmcdriver_pylon_interfaces.hpp
index d3c150bd4..8bb818e4a 100644
--- a/Drivers/Pylon/Interfaces/libmcdriver_pylon_interfaces.hpp
+++ b/Drivers/Pylon/Interfaces/libmcdriver_pylon_interfaces.hpp
@@ -540,6 +540,13 @@ class IDriver_Pylon : public virtual IDriver {
 	*/
 	virtual IPylonDevice * ConnectToUniqueGigEDevice(const std::string & sIdentifier) = 0;
 
+	/**
+	* IDriver_Pylon::ConnectToUniqueEmulatedDevice - Enables the pylon camera emulation for the time of the connection, checks if there is exactly one emulated device and connects to it. Physical cameras are ignored.
+	* @param[in] sIdentifier - Identifier for the connection. Fails if identifier is already existing. MUST be non-empty a alpanumerical string with _, up until 64 characters.
+	* @return Device Instance
+	*/
+	virtual IPylonDevice * ConnectToUniqueEmulatedDevice(const std::string & sIdentifier) = 0;
+
 	/**
 	* IDriver_Pylon::ConnectionExists - Checks if a connection exists with a certain identifier.
 	* @param[in] sIdentifier - Identifier for the connection.
diff --git a/Drivers/Pylon/Interfaces/libmcdriver_pylon_interfacewrapper.cpp b/Drivers/Pylon/Interfaces/libmcdriver_pylon_interfacewrapper.cpp
index f2c3309d6..3e06e801c 100644
--- a/Drivers/Pylon/Interfaces/libmcdriver_pylon_interfacewrapper.cpp
+++ b/Drivers/Pylon/Interfaces/libmcdriver_pylon_interfacewrapper.cpp
@@ -1273,6 +1273,37 @@ LibMCDriver_PylonResult libmcdriver_pylon_driver_pylon_connecttouniquegigedevice
 	}
 }
 
+LibMCDriver_PylonResult libmcdriver_pylon_driver_pylon_connecttouniqueemulateddevice(LibMCDriver_Pylon_Driver_Pylon pDriver_Pylon, const char * pIdentifier, LibMCDriver_Pylon_PylonDevice * pDevice)
+{
+	IBase* pIBaseClass = (IBase *)pDriver_Pylon;
+
+	try {
+		if (pIdentifier == nullptr)
+			throw ELibMCDriver_PylonInterfaceException (LIBMCDRIVER_PYLON_ERROR_INVALIDPARAM);
+		if (pDevice == nullptr)
+			throw ELibMCDriver_PylonInterfaceException (LIBMCDRIVER_PYLON_ERROR_INVALIDPARAM);
+		std::string sIdentifier(pIdentifier);
+		IBase* pBaseDevice(nullptr);
+		IDriver_Pylon* pIDriver_Pylon = dynamic_cast<IDriver_Pylon*>(pIBaseClass);
+		if (!pIDriver_Pylon)
+			throw ELibMCDriver_PylonInterfaceException(LIBMCDRIVER_PYLON_ERROR_INVALIDCAST);
+		
+		pBaseDevice = pIDriver_Pylon->ConnectToUniqueEmulatedDevice(sIdentifier);
+
+		*pDevice = (IBase*)(pBaseDevice);
+		return LIBMCDRIVER_PYLON_SUCCESS;
+	}
+	catch (ELibMCDriver_PylonInterfaceException & Exception) {
+		return handleLibMCDriver_PylonException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
 LibMCDriver_PylonResult libmcdriver_pylon_driver_pylon_connectionexists(LibMCDriver_Pylon_Driver_Pylon pDriver_Pylon, const char * pIdentifier, bool * pExists)
 {
 	IBase* pIBaseClass = (IBase *)pDriver_Pylon;
@@ -1444,6 +1475,8 @@ LibMCDriver_PylonResult LibMCDriver_Pylon::Impl::LibMCDriver_Pylon_GetProcAddres
 		*ppProcAddress = (void*) &libmcdriver_pylon_driver_pylon_connecttouniquegenericdevice;
 	if (sProcName == "libmcdriver_pylon_driver_pylon_connecttouniquegigedevice") 
 		*ppProcAddress = (void*) &libmcdriver_pylon_driver_pylon_connecttouniquegigedevice;
+	if (sProcName == "libmcdriver_pylon_driver_pylon_connecttouniqueemulateddevice") 
+		*ppProcAddress = (void*) &libmcdriver_pylon_driver_pylon_connecttouniqueemulateddevice;
 	if (sProcName == "libmcdriver_pylon_driver_pylon_connectionexists") 
 		*ppProcAddress = (void*) &libmcdriver_pylon_driver_pylon_connectionexists;
 	if (sProcName == "libmcdriver_pylon_driver_pylon_finddeviceconnection") 
diff --git a/Drivers/ScanLab/ACT/LibMCDriver_ScanLab.xml b/Drivers/ScanLab/ACT/LibMCDriver_ScanLab.xml
index cef033f90..d7b068397 100644
--- a/Drivers/ScanLab/ACT/LibMCDriver_ScanLab.xml
+++ b/Drivers/ScanLab/ACT/LibMCDriver_ScanLab.xml
@@ -218,6 +218,8 @@
 		<error name="UNSUPPORTEDPROFILEMODIFIER" code="1166" description="Toolpath profile has a modifier that the driver cannot execute." />
 		<error name="MODIFIEDLASERPOWEROUTOFRANGE" code="1167" description="Modified laser power is outside of the calibrated laser power range." />
 
+		<error name="RECORDINGREADOUTNOTSTARTED" code="1168" description="The incremental readout of the recording has not been started." />
+							
 	</errors>
 
 
@@ -639,7 +641,17 @@ Custom implementation
 			<param name="ColumnIdentifierY" type="string" pass="in" description="Identifier of the X Column." />
 			<param name="ColumnDescriptionY" type="string" pass="in" description="Description of the X Column." />
 		</method>
-		
+
+		<method name="StartListWithRecording" description="Starts the execution of the list and the incremental readout of the recorded data. Returns immediately. ReadRecordedData MUST be called repeatedly afterwards until it reports that the recording is complete.">
+		</method>
+
+		<method name="ReadRecordedData" description="Reads the data that the RTC card has recorded since the last call into the channels. Does not wait for new data. Fails if StartListWithRecording has not been called.">
+			<param name="RecordingComplete" type="bool" pass="return" description="True if the list has finished and all recorded data has been read." />
+		</method>
+
+		<method name="DiscardRecords" description="Drops the record entries of all channels. The channels and the readout position are kept, so that the recorded data can be handed on piece by piece between calls to ReadRecordedData.">
+		</method>
+
 	</class>
 
 
@@ -1059,6 +1071,32 @@ Custom implementation
 			<param name="PrebufferFraction" type="double" pass="in" description="Fraction of the layer (0..1) that is downloaded before execution starts. 0 uses the built-in default of 0.4. Values below 0.25 risk margin aborts on download slowdowns and are only meant for testing the overrun detector." />
 		</method>
 
+		<method name="SetMicrovectorListSwitchingEnabled" description="Enables alternating List1/List2 execution for microvector layers that do not fit into one RTC6 list. AddMicrovectorMovement then splits the layer into segments, closes each full list with set_end_of_list, arms an automatic list change and continues in the other list while the laser keeps marking. Requires the streamed download (SetMicrovectorStreamingEnabled). Default is disabled.">
+			<param name="Enabled" type="bool" pass="in" description="True to execute oversized layers alternately from List1 and List2." />
+			<param name="ListCapacityLimit" type="uint32" pass="in" description="Test aid: maximum list positions used per segment, 0 = full configured list size. Values below 84096 (four check blocks in the worst case plus the tail reserve) are clamped to it." />
+			<param name="TailReserve" type="uint32" pass="in" description="List positions kept free at the end of every segment for set_end_of_list and the layer epilogue. 0 = built-in default of 4096." />
+		</method>
+
+		<method name="GetMicrovectorListSwitchingStatistics" description="Returns counters of the last AddMicrovectorMovement call: number of segments the layer was split into, number of segments that had to be started explicitly because the card had already finished the previous one, the minimum observed download margin and the longest wait for a list to become free.">
+			<param name="SegmentCount" type="uint32" pass="out" description="Segments written (1 = no list switch)." />
+			<param name="FallbackCount" type="uint32" pass="out" description="Segments started explicitly instead of by automatic list change." />
+			<param name="MinMargin" type="uint64" pass="out" description="Minimum observed distance between input and output pointer in list positions." />
+			<param name="MaxListWaitInMS" type="uint64" pass="out" description="Longest wait for the previous list to be consumed before it could be reused, in milliseconds." />
+		</method>
+
+		<method name="BeginMicrovectorStreaming" description="Stepwise variant of AddMicrovectorMovement, same semantics and configuration. Writes the first part of the layer and, on the streamed path, starts list execution. The rest is written by ContinueMicrovectorStreaming calls; between two calls the caller is free to do other work, e.g. read out the RTC recording while the card is marking. The microvector buffer MUST stay valid and unchanged until ContinueMicrovectorStreaming has returned true or AbortMicrovectorStreaming has been called. Small layers and the sequential download are written completely by this call.">
+			<param name="MicrovectorArray" type="structarray" class="MicroVector" pass="in" description="Microvector array to execute. Must outlive the streaming session." />
+			<param name="ExecutionStarted" type="bool" pass="return" description="True if this call has started list execution (streamed download). False if the layer was written without starting execution; the caller executes the list as usual afterwards." />
+		</method>
+
+		<method name="ContinueMicrovectorStreaming" description="Writes the next part of the layer passed to BeginMicrovectorStreaming. Returns as soon as the time budget is used up, the download has to wait for the card to free a list, or the layer is complete. Never waits for the card. Fails if no streaming session has been begun.">
+			<param name="TimeBudgetInMS" type="uint32" pass="in" description="Upper bound for the time spent writing in this call, in milliseconds. 0 writes a single block." />
+			<param name="Complete" type="bool" pass="return" description="True once all microvectors have been written. The session is finished then; further calls return true without doing anything." />
+		</method>
+
+		<method name="AbortMicrovectorStreaming" description="Ends a streaming session before completion, e.g. when the caller fails between two ContinueMicrovectorStreaming calls. Stops list execution, consumes an armed list change and resets the segmentation state. Does nothing if no session is active.">
+		</method>
+
 
 		<method name="GetCurrentFreeVariable" description="Returns the currently set free variable.">
 			<param name="VariableNo" type="uint32" pass="in" description="Number of the variable (0-7)." />
diff --git a/Drivers/ScanLab/Headers/CppDynamic/libmcdriver_scanlab_dynamic.h b/Drivers/ScanLab/Headers/CppDynamic/libmcdriver_scanlab_dynamic.h
index b7ed93e5e..4ea458c9a 100644
--- a/Drivers/ScanLab/Headers/CppDynamic/libmcdriver_scanlab_dynamic.h
+++ b/Drivers/ScanLab/Headers/CppDynamic/libmcdriver_scanlab_dynamic.h
@@ -558,6 +558,31 @@ typedef LibMCDriver_ScanLabResult (*PLibMCDriver_ScanLabRTCRecording_Backtransfo
 */
 typedef LibMCDriver_ScanLabResult (*PLibMCDriver_ScanLabRTCRecording_AddTargetPositionsToDataTablePtr) (LibMCDriver_ScanLab_RTCRecording pRTCRecording, LibMCEnv_DataTable pDataTable, const char * pColumnIdentifierX, const char * pColumnDescriptionX, const char * pColumnIdentifierY, const char * pColumnDescriptionY);
 
+/**
+* Starts the execution of the list and the incremental readout of the recorded data. Returns immediately. ReadRecordedData MUST be called repeatedly afterwards until it reports that the recording is complete.
+*
+* @param[in] pRTCRecording - RTCRecording instance.
+* @return error code or 0 (success)
+*/
+typedef LibMCDriver_ScanLabResult (*PLibMCDriver_ScanLabRTCRecording_StartListWithRecordingPtr) (LibMCDriver_ScanLab_RTCRecording pRTCRecording);
+
+/**
+* Reads the data that the RTC card has recorded since the last call into the channels. Does not wait for new data. Fails if StartListWithRecording has not been called.
+*
+* @param[in] pRTCRecording - RTCRecording instance.
+* @param[out] pRecordingComplete - True if the list has finished and all recorded data has been read.
+* @return error code or 0 (success)
+*/
+typedef LibMCDriver_ScanLabResult (*PLibMCDriver_ScanLabRTCRecording_ReadRecordedDataPtr) (LibMCDriver_ScanLab_RTCRecording pRTCRecording, bool * pRecordingComplete);
+
+/**
+* Drops the record entries of all channels. The channels and the readout position are kept, so that the recorded data can be handed on piece by piece between calls to ReadRecordedData.
+*
+* @param[in] pRTCRecording - RTCRecording instance.
+* @return error code or 0 (success)
+*/
+typedef LibMCDriver_ScanLabResult (*PLibMCDriver_ScanLabRTCRecording_DiscardRecordsPtr) (LibMCDriver_ScanLab_RTCRecording pRTCRecording);
+
 /*************************************************************************************************************************
  Class definition for GPIOSequence
 **************************************************************************************************************************/
@@ -1412,6 +1437,58 @@ typedef LibMCDriver_ScanLabResult (*PLibMCDriver_ScanLabRTCContext_AddMicrovecto
 */
 typedef LibMCDriver_ScanLabResult (*PLibMCDriver_ScanLabRTCContext_SetMicrovectorStreamingEnabledPtr) (LibMCDriver_ScanLab_RTCContext pRTCContext, bool bEnabled, LibMCDriver_ScanLab_uint32 nMinLayerSize, LibMCDriver_ScanLab_double dPrebufferFraction);
 
+/**
+* Enables alternating List1/List2 execution for microvector layers that do not fit into one RTC6 list. AddMicrovectorMovement then splits the layer into segments, closes each full list with set_end_of_list, arms an automatic list change and continues in the other list while the laser keeps marking. Requires the streamed download (SetMicrovectorStreamingEnabled). Default is disabled.
+*
+* @param[in] pRTCContext - RTCContext instance.
+* @param[in] bEnabled - True to execute oversized layers alternately from List1 and List2.
+* @param[in] nListCapacityLimit - Test aid: maximum list positions used per segment, 0 = full configured list size. Values below 84096 (four check blocks in the worst case plus the tail reserve) are clamped to it.
+* @param[in] nTailReserve - List positions kept free at the end of every segment for set_end_of_list and the layer epilogue. 0 = built-in default of 4096.
+* @return error code or 0 (success)
+*/
+typedef LibMCDriver_ScanLabResult (*PLibMCDriver_ScanLabRTCContext_SetMicrovectorListSwitchingEnabledPtr) (LibMCDriver_ScanLab_RTCContext pRTCContext, bool bEnabled, LibMCDriver_ScanLab_uint32 nListCapacityLimit, LibMCDriver_ScanLab_uint32 nTailReserve);
+
+/**
+* Returns counters of the last AddMicrovectorMovement call: number of segments the layer was split into, number of segments that had to be started explicitly because the card had already finished the previous one, the minimum observed download margin and the longest wait for a list to become free.
+*
+* @param[in] pRTCContext - RTCContext instance.
+* @param[out] pSegmentCount - Segments written (1 = no list switch).
+* @param[out] pFallbackCount - Segments started explicitly instead of by automatic list change.
+* @param[out] pMinMargin - Minimum observed distance between input and output pointer in list positions.
+* @param[out] pMaxListWaitInMS - Longest wait for the previous list to be consumed before it could be reused, in milliseconds.
+* @return error code or 0 (success)
+*/
+typedef LibMCDriver_ScanLabResult (*PLibMCDriver_ScanLabRTCContext_GetMicrovectorListSwitchingStatisticsPtr) (LibMCDriver_ScanLab_RTCContext pRTCContext, LibMCDriver_ScanLab_uint32 * pSegmentCount, LibMCDriver_ScanLab_uint32 * pFallbackCount, LibMCDriver_ScanLab_uint64 * pMinMargin, LibMCDriver_ScanLab_uint64 * pMaxListWaitInMS);
+
+/**
+* Stepwise variant of AddMicrovectorMovement, same semantics and configuration. Writes the first part of the layer and, on the streamed path, starts list execution. The rest is written by ContinueMicrovectorStreaming calls; between two calls the caller is free to do other work, e.g. read out the RTC recording while the card is marking. The microvector buffer MUST stay valid and unchanged until ContinueMicrovectorStreaming has returned true or AbortMicrovectorStreaming has been called. Small layers and the sequential download are written completely by this call.
+*
+* @param[in] pRTCContext - RTCContext instance.
+* @param[in] nMicrovectorArrayBufferSize - Number of elements in buffer
+* @param[in] pMicrovectorArrayBuffer - MicroVector buffer of Microvector array to execute. Must outlive the streaming session.
+* @param[out] pExecutionStarted - True if this call has started list execution (streamed download). False if the layer was written without starting execution; the caller executes the list as usual afterwards.
+* @return error code or 0 (success)
+*/
+typedef LibMCDriver_ScanLabResult (*PLibMCDriver_ScanLabRTCContext_BeginMicrovectorStreamingPtr) (LibMCDriver_ScanLab_RTCContext pRTCContext, LibMCDriver_ScanLab_uint64 nMicrovectorArrayBufferSize, const LibMCDriver_ScanLab::sMicroVector * pMicrovectorArrayBuffer, bool * pExecutionStarted);
+
+/**
+* Writes the next part of the layer passed to BeginMicrovectorStreaming. Returns as soon as the time budget is used up, the download has to wait for the card to free a list, or the layer is complete. Never waits for the card. Fails if no streaming session has been begun.
+*
+* @param[in] pRTCContext - RTCContext instance.
+* @param[in] nTimeBudgetInMS - Upper bound for the time spent writing in this call, in milliseconds. 0 writes a single block.
+* @param[out] pComplete - True once all microvectors have been written. The session is finished then; further calls return true without doing anything.
+* @return error code or 0 (success)
+*/
+typedef LibMCDriver_ScanLabResult (*PLibMCDriver_ScanLabRTCContext_ContinueMicrovectorStreamingPtr) (LibMCDriver_ScanLab_RTCContext pRTCContext, LibMCDriver_ScanLab_uint32 nTimeBudgetInMS, bool * pComplete);
+
+/**
+* Ends a streaming session before completion, e.g. when the caller fails between two ContinueMicrovectorStreaming calls. Stops list execution, consumes an armed list change and resets the segmentation state. Does nothing if no session is active.
+*
+* @param[in] pRTCContext - RTCContext instance.
+* @return error code or 0 (success)
+*/
+typedef LibMCDriver_ScanLabResult (*PLibMCDriver_ScanLabRTCContext_AbortMicrovectorStreamingPtr) (LibMCDriver_ScanLab_RTCContext pRTCContext);
+
 /**
 * Returns the currently set free variable.
 *
@@ -3278,6 +3355,9 @@ typedef struct {
 	PLibMCDriver_ScanLabRTCRecording_AddBacktransformedZPositionsToDataTablePtr m_RTCRecording_AddBacktransformedZPositionsToDataTable;
 	PLibMCDriver_ScanLabRTCRecording_BacktransformRawZCoordinatePtr m_RTCRecording_BacktransformRawZCoordinate;
 	PLibMCDriver_ScanLabRTCRecording_AddTargetPositionsToDataTablePtr m_RTCRecording_AddTargetPositionsToDataTable;
+	PLibMCDriver_ScanLabRTCRecording_StartListWithRecordingPtr m_RTCRecording_StartListWithRecording;
+	PLibMCDriver_ScanLabRTCRecording_ReadRecordedDataPtr m_RTCRecording_ReadRecordedData;
+	PLibMCDriver_ScanLabRTCRecording_DiscardRecordsPtr m_RTCRecording_DiscardRecords;
 	PLibMCDriver_ScanLabGPIOSequence_GetIdentifierPtr m_GPIOSequence_GetIdentifier;
 	PLibMCDriver_ScanLabGPIOSequence_ClearPtr m_GPIOSequence_Clear;
 	PLibMCDriver_ScanLabGPIOSequence_AddOutputPtr m_GPIOSequence_AddOutput;
@@ -3360,6 +3440,11 @@ typedef struct {
 	PLibMCDriver_ScanLabRTCContext_AddFreeVariablePtr m_RTCContext_AddFreeVariable;
 	PLibMCDriver_ScanLabRTCContext_AddMicrovectorMovementPtr m_RTCContext_AddMicrovectorMovement;
 	PLibMCDriver_ScanLabRTCContext_SetMicrovectorStreamingEnabledPtr m_RTCContext_SetMicrovectorStreamingEnabled;
+	PLibMCDriver_ScanLabRTCContext_SetMicrovectorListSwitchingEnabledPtr m_RTCContext_SetMicrovectorListSwitchingEnabled;
+	PLibMCDriver_ScanLabRTCContext_GetMicrovectorListSwitchingStatisticsPtr m_RTCContext_GetMicrovectorListSwitchingStatistics;
+	PLibMCDriver_ScanLabRTCContext_BeginMicrovectorStreamingPtr m_RTCContext_BeginMicrovectorStreaming;
+	PLibMCDriver_ScanLabRTCContext_ContinueMicrovectorStreamingPtr m_RTCContext_ContinueMicrovectorStreaming;
+	PLibMCDriver_ScanLabRTCContext_AbortMicrovectorStreamingPtr m_RTCContext_AbortMicrovectorStreaming;
 	PLibMCDriver_ScanLabRTCContext_GetCurrentFreeVariablePtr m_RTCContext_GetCurrentFreeVariable;
 	PLibMCDriver_ScanLabRTCContext_GetTimeStampPtr m_RTCContext_GetTimeStamp;
 	PLibMCDriver_ScanLabRTCContext_GetRTCChannelPtr m_RTCContext_GetRTCChannel;
diff --git a/Drivers/ScanLab/Headers/CppDynamic/libmcdriver_scanlab_dynamic.hpp b/Drivers/ScanLab/Headers/CppDynamic/libmcdriver_scanlab_dynamic.hpp
index b29dff87b..e57b3398c 100644
--- a/Drivers/ScanLab/Headers/CppDynamic/libmcdriver_scanlab_dynamic.hpp
+++ b/Drivers/ScanLab/Headers/CppDynamic/libmcdriver_scanlab_dynamic.hpp
@@ -380,6 +380,7 @@ class ELibMCDriver_ScanLabException : public std::exception {
 			case LIBMCDRIVER_SCANLAB_ERROR_MINIMUMJUMPDISTANCEPROVIDEDTWICEINPROFILE: return "MINIMUMJUMPDISTANCEPROVIDEDTWICEINPROFILE";
 			case LIBMCDRIVER_SCANLAB_ERROR_UNSUPPORTEDPROFILEMODIFIER: return "UNSUPPORTEDPROFILEMODIFIER";
 			case LIBMCDRIVER_SCANLAB_ERROR_MODIFIEDLASERPOWEROUTOFRANGE: return "MODIFIEDLASERPOWEROUTOFRANGE";
+			case LIBMCDRIVER_SCANLAB_ERROR_RECORDINGREADOUTNOTSTARTED: return "RECORDINGREADOUTNOTSTARTED";
 		}
 		return "UNKNOWN";
 	}
@@ -562,6 +563,7 @@ class ELibMCDriver_ScanLabException : public std::exception {
 			case LIBMCDRIVER_SCANLAB_ERROR_MINIMUMJUMPDISTANCEPROVIDEDTWICEINPROFILE: return "Minimum jump distance provided twice in profile.";
 			case LIBMCDRIVER_SCANLAB_ERROR_UNSUPPORTEDPROFILEMODIFIER: return "Toolpath profile has a modifier that the driver cannot execute.";
 			case LIBMCDRIVER_SCANLAB_ERROR_MODIFIEDLASERPOWEROUTOFRANGE: return "Modified laser power is outside of the calibrated laser power range.";
+			case LIBMCDRIVER_SCANLAB_ERROR_RECORDINGREADOUTNOTSTARTED: return "The incremental readout of the recording has not been started.";
 		}
 		return "unknown error";
 	}
@@ -865,6 +867,9 @@ class CRTCRecording : public CBase {
 	inline void AddBacktransformedZPositionsToDataTable(classParam<LibMCEnv::CDataTable> pDataTable, const std::string & sColumnIdentifierZ, const std::string & sColumnDescriptionZ);
 	inline LibMCDriver_ScanLab_double BacktransformRawZCoordinate(const LibMCDriver_ScanLab_int32 nRawCoordinateZ);
 	inline void AddTargetPositionsToDataTable(classParam<LibMCEnv::CDataTable> pDataTable, const std::string & sColumnIdentifierX, const std::string & sColumnDescriptionX, const std::string & sColumnIdentifierY, const std::string & sColumnDescriptionY);
+	inline void StartListWithRecording();
+	inline bool ReadRecordedData();
+	inline void DiscardRecords();
 };
 	
 /*************************************************************************************************************************
@@ -1011,6 +1016,11 @@ class CRTCContext : public CBase {
 	inline void AddFreeVariable(const LibMCDriver_ScanLab_uint32 nVariableNo, const LibMCDriver_ScanLab_uint32 nValue);
 	inline void AddMicrovectorMovement(const CInputVector<sMicroVector> & MicrovectorArrayBuffer);
 	inline void SetMicrovectorStreamingEnabled(const bool bEnabled, const LibMCDriver_ScanLab_uint32 nMinLayerSize, const LibMCDriver_ScanLab_double dPrebufferFraction);
+	inline void SetMicrovectorListSwitchingEnabled(const bool bEnabled, const LibMCDriver_ScanLab_uint32 nListCapacityLimit, const LibMCDriver_ScanLab_uint32 nTailReserve);
+	inline void GetMicrovectorListSwitchingStatistics(LibMCDriver_ScanLab_uint32 & nSegmentCount, LibMCDriver_ScanLab_uint32 & nFallbackCount, LibMCDriver_ScanLab_uint64 & nMinMargin, LibMCDriver_ScanLab_uint64 & nMaxListWaitInMS);
+	inline bool BeginMicrovectorStreaming(const CInputVector<sMicroVector> & MicrovectorArrayBuffer);
+	inline bool ContinueMicrovectorStreaming(const LibMCDriver_ScanLab_uint32 nTimeBudgetInMS);
+	inline void AbortMicrovectorStreaming();
 	inline LibMCDriver_ScanLab_uint32 GetCurrentFreeVariable(const LibMCDriver_ScanLab_uint32 nVariableNo);
 	inline LibMCDriver_ScanLab_uint32 GetTimeStamp();
 	inline LibMCDriver_ScanLab_int32 GetRTCChannel(const eRTCChannelType eChannelType);
@@ -1415,6 +1425,9 @@ class CDriver_ScanLab_RTC6xN : public CDriver_ScanLab {
 		pWrapperTable->m_RTCRecording_AddBacktransformedZPositionsToDataTable = nullptr;
 		pWrapperTable->m_RTCRecording_BacktransformRawZCoordinate = nullptr;
 		pWrapperTable->m_RTCRecording_AddTargetPositionsToDataTable = nullptr;
+		pWrapperTable->m_RTCRecording_StartListWithRecording = nullptr;
+		pWrapperTable->m_RTCRecording_ReadRecordedData = nullptr;
+		pWrapperTable->m_RTCRecording_DiscardRecords = nullptr;
 		pWrapperTable->m_GPIOSequence_GetIdentifier = nullptr;
 		pWrapperTable->m_GPIOSequence_Clear = nullptr;
 		pWrapperTable->m_GPIOSequence_AddOutput = nullptr;
@@ -1497,6 +1510,11 @@ class CDriver_ScanLab_RTC6xN : public CDriver_ScanLab {
 		pWrapperTable->m_RTCContext_AddFreeVariable = nullptr;
 		pWrapperTable->m_RTCContext_AddMicrovectorMovement = nullptr;
 		pWrapperTable->m_RTCContext_SetMicrovectorStreamingEnabled = nullptr;
+		pWrapperTable->m_RTCContext_SetMicrovectorListSwitchingEnabled = nullptr;
+		pWrapperTable->m_RTCContext_GetMicrovectorListSwitchingStatistics = nullptr;
+		pWrapperTable->m_RTCContext_BeginMicrovectorStreaming = nullptr;
+		pWrapperTable->m_RTCContext_ContinueMicrovectorStreaming = nullptr;
+		pWrapperTable->m_RTCContext_AbortMicrovectorStreaming = nullptr;
 		pWrapperTable->m_RTCContext_GetCurrentFreeVariable = nullptr;
 		pWrapperTable->m_RTCContext_GetTimeStamp = nullptr;
 		pWrapperTable->m_RTCContext_GetRTCChannel = nullptr;
@@ -2146,6 +2164,33 @@ class CDriver_ScanLab_RTC6xN : public CDriver_ScanLab {
 		if (pWrapperTable->m_RTCRecording_AddTargetPositionsToDataTable == nullptr)
 			return LIBMCDRIVER_SCANLAB_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
+		#ifdef _WIN32
+		pWrapperTable->m_RTCRecording_StartListWithRecording = (PLibMCDriver_ScanLabRTCRecording_StartListWithRecordingPtr) GetProcAddress(hLibrary, "libmcdriver_scanlab_rtcrecording_startlistwithrecording");
+		#else // _WIN32
+		pWrapperTable->m_RTCRecording_StartListWithRecording = (PLibMCDriver_ScanLabRTCRecording_StartListWithRecordingPtr) dlsym(hLibrary, "libmcdriver_scanlab_rtcrecording_startlistwithrecording");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_RTCRecording_StartListWithRecording == nullptr)
+			return LIBMCDRIVER_SCANLAB_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_RTCRecording_ReadRecordedData = (PLibMCDriver_ScanLabRTCRecording_ReadRecordedDataPtr) GetProcAddress(hLibrary, "libmcdriver_scanlab_rtcrecording_readrecordeddata");
+		#else // _WIN32
+		pWrapperTable->m_RTCRecording_ReadRecordedData = (PLibMCDriver_ScanLabRTCRecording_ReadRecordedDataPtr) dlsym(hLibrary, "libmcdriver_scanlab_rtcrecording_readrecordeddata");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_RTCRecording_ReadRecordedData == nullptr)
+			return LIBMCDRIVER_SCANLAB_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_RTCRecording_DiscardRecords = (PLibMCDriver_ScanLabRTCRecording_DiscardRecordsPtr) GetProcAddress(hLibrary, "libmcdriver_scanlab_rtcrecording_discardrecords");
+		#else // _WIN32
+		pWrapperTable->m_RTCRecording_DiscardRecords = (PLibMCDriver_ScanLabRTCRecording_DiscardRecordsPtr) dlsym(hLibrary, "libmcdriver_scanlab_rtcrecording_discardrecords");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_RTCRecording_DiscardRecords == nullptr)
+			return LIBMCDRIVER_SCANLAB_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
 		#ifdef _WIN32
 		pWrapperTable->m_GPIOSequence_GetIdentifier = (PLibMCDriver_ScanLabGPIOSequence_GetIdentifierPtr) GetProcAddress(hLibrary, "libmcdriver_scanlab_gpiosequence_getidentifier");
 		#else // _WIN32
@@ -2884,6 +2929,51 @@ class CDriver_ScanLab_RTC6xN : public CDriver_ScanLab {
 		if (pWrapperTable->m_RTCContext_SetMicrovectorStreamingEnabled == nullptr)
 			return LIBMCDRIVER_SCANLAB_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
+		#ifdef _WIN32
+		pWrapperTable->m_RTCContext_SetMicrovectorListSwitchingEnabled = (PLibMCDriver_ScanLabRTCContext_SetMicrovectorListSwitchingEnabledPtr) GetProcAddress(hLibrary, "libmcdriver_scanlab_rtccontext_setmicrovectorlistswitchingenabled");
+		#else // _WIN32
+		pWrapperTable->m_RTCContext_SetMicrovectorListSwitchingEnabled = (PLibMCDriver_ScanLabRTCContext_SetMicrovectorListSwitchingEnabledPtr) dlsym(hLibrary, "libmcdriver_scanlab_rtccontext_setmicrovectorlistswitchingenabled");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_RTCContext_SetMicrovectorListSwitchingEnabled == nullptr)
+			return LIBMCDRIVER_SCANLAB_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_RTCContext_GetMicrovectorListSwitchingStatistics = (PLibMCDriver_ScanLabRTCContext_GetMicrovectorListSwitchingStatisticsPtr) GetProcAddress(hLibrary, "libmcdriver_scanlab_rtccontext_getmicrovectorlistswitchingstatistics");
+		#else // _WIN32
+		pWrapperTable->m_RTCContext_GetMicrovectorListSwitchingStatistics = (PLibMCDriver_ScanLabRTCContext_GetMicrovectorListSwitchingStatisticsPtr) dlsym(hLibrary, "libmcdriver_scanlab_rtccontext_getmicrovectorlistswitchingstatistics");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_RTCContext_GetMicrovectorListSwitchingStatistics == nullptr)
+			return LIBMCDRIVER_SCANLAB_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_RTCContext_BeginMicrovectorStreaming = (PLibMCDriver_ScanLabRTCContext_BeginMicrovectorStreamingPtr) GetProcAddress(hLibrary, "libmcdriver_scanlab_rtccontext_beginmicrovectorstreaming");
+		#else // _WIN32
+		pWrapperTable->m_RTCContext_BeginMicrovectorStreaming = (PLibMCDriver_ScanLabRTCContext_BeginMicrovectorStreamingPtr) dlsym(hLibrary, "libmcdriver_scanlab_rtccontext_beginmicrovectorstreaming");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_RTCContext_BeginMicrovectorStreaming == nullptr)
+			return LIBMCDRIVER_SCANLAB_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_RTCContext_ContinueMicrovectorStreaming = (PLibMCDriver_ScanLabRTCContext_ContinueMicrovectorStreamingPtr) GetProcAddress(hLibrary, "libmcdriver_scanlab_rtccontext_continuemicrovectorstreaming");
+		#else // _WIN32
+		pWrapperTable->m_RTCContext_ContinueMicrovectorStreaming = (PLibMCDriver_ScanLabRTCContext_ContinueMicrovectorStreamingPtr) dlsym(hLibrary, "libmcdriver_scanlab_rtccontext_continuemicrovectorstreaming");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_RTCContext_ContinueMicrovectorStreaming == nullptr)
+			return LIBMCDRIVER_SCANLAB_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_RTCContext_AbortMicrovectorStreaming = (PLibMCDriver_ScanLabRTCContext_AbortMicrovectorStreamingPtr) GetProcAddress(hLibrary, "libmcdriver_scanlab_rtccontext_abortmicrovectorstreaming");
+		#else // _WIN32
+		pWrapperTable->m_RTCContext_AbortMicrovectorStreaming = (PLibMCDriver_ScanLabRTCContext_AbortMicrovectorStreamingPtr) dlsym(hLibrary, "libmcdriver_scanlab_rtccontext_abortmicrovectorstreaming");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_RTCContext_AbortMicrovectorStreaming == nullptr)
+			return LIBMCDRIVER_SCANLAB_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
 		#ifdef _WIN32
 		pWrapperTable->m_RTCContext_GetCurrentFreeVariable = (PLibMCDriver_ScanLabRTCContext_GetCurrentFreeVariablePtr) GetProcAddress(hLibrary, "libmcdriver_scanlab_rtccontext_getcurrentfreevariable");
 		#else // _WIN32
@@ -4672,6 +4762,18 @@ class CDriver_ScanLab_RTC6xN : public CDriver_ScanLab {
 		if ( (eLookupError != 0) || (pWrapperTable->m_RTCRecording_AddTargetPositionsToDataTable == nullptr) )
 			return LIBMCDRIVER_SCANLAB_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
+		eLookupError = (*pLookup)("libmcdriver_scanlab_rtcrecording_startlistwithrecording", (void**)&(pWrapperTable->m_RTCRecording_StartListWithRecording));
+		if ( (eLookupError != 0) || (pWrapperTable->m_RTCRecording_StartListWithRecording == nullptr) )
+			return LIBMCDRIVER_SCANLAB_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcdriver_scanlab_rtcrecording_readrecordeddata", (void**)&(pWrapperTable->m_RTCRecording_ReadRecordedData));
+		if ( (eLookupError != 0) || (pWrapperTable->m_RTCRecording_ReadRecordedData == nullptr) )
+			return LIBMCDRIVER_SCANLAB_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcdriver_scanlab_rtcrecording_discardrecords", (void**)&(pWrapperTable->m_RTCRecording_DiscardRecords));
+		if ( (eLookupError != 0) || (pWrapperTable->m_RTCRecording_DiscardRecords == nullptr) )
+			return LIBMCDRIVER_SCANLAB_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
 		eLookupError = (*pLookup)("libmcdriver_scanlab_gpiosequence_getidentifier", (void**)&(pWrapperTable->m_GPIOSequence_GetIdentifier));
 		if ( (eLookupError != 0) || (pWrapperTable->m_GPIOSequence_GetIdentifier == nullptr) )
 			return LIBMCDRIVER_SCANLAB_ERROR_COULDNOTFINDLIBRARYEXPORT;
@@ -5000,6 +5102,26 @@ class CDriver_ScanLab_RTC6xN : public CDriver_ScanLab {
 		if ( (eLookupError != 0) || (pWrapperTable->m_RTCContext_SetMicrovectorStreamingEnabled == nullptr) )
 			return LIBMCDRIVER_SCANLAB_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
+		eLookupError = (*pLookup)("libmcdriver_scanlab_rtccontext_setmicrovectorlistswitchingenabled", (void**)&(pWrapperTable->m_RTCContext_SetMicrovectorListSwitchingEnabled));
+		if ( (eLookupError != 0) || (pWrapperTable->m_RTCContext_SetMicrovectorListSwitchingEnabled == nullptr) )
+			return LIBMCDRIVER_SCANLAB_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcdriver_scanlab_rtccontext_getmicrovectorlistswitchingstatistics", (void**)&(pWrapperTable->m_RTCContext_GetMicrovectorListSwitchingStatistics));
+		if ( (eLookupError != 0) || (pWrapperTable->m_RTCContext_GetMicrovectorListSwitchingStatistics == nullptr) )
+			return LIBMCDRIVER_SCANLAB_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcdriver_scanlab_rtccontext_beginmicrovectorstreaming", (void**)&(pWrapperTable->m_RTCContext_BeginMicrovectorStreaming));
+		if ( (eLookupError != 0) || (pWrapperTable->m_RTCContext_BeginMicrovectorStreaming == nullptr) )
+			return LIBMCDRIVER_SCANLAB_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcdriver_scanlab_rtccontext_continuemicrovectorstreaming", (void**)&(pWrapperTable->m_RTCContext_ContinueMicrovectorStreaming));
+		if ( (eLookupError != 0) || (pWrapperTable->m_RTCContext_ContinueMicrovectorStreaming == nullptr) )
+			return LIBMCDRIVER_SCANLAB_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcdriver_scanlab_rtccontext_abortmicrovectorstreaming", (void**)&(pWrapperTable->m_RTCContext_AbortMicrovectorStreaming));
+		if ( (eLookupError != 0) || (pWrapperTable->m_RTCContext_AbortMicrovectorStreaming == nullptr) )
+			return LIBMCDRIVER_SCANLAB_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
 		eLookupError = (*pLookup)("libmcdriver_scanlab_rtccontext_getcurrentfreevariable", (void**)&(pWrapperTable->m_RTCContext_GetCurrentFreeVariable));
 		if ( (eLookupError != 0) || (pWrapperTable->m_RTCContext_GetCurrentFreeVariable == nullptr) )
 			return LIBMCDRIVER_SCANLAB_ERROR_COULDNOTFINDLIBRARYEXPORT;
@@ -6271,6 +6393,34 @@ class CDriver_ScanLab_RTC6xN : public CDriver_ScanLab {
 		CheckError(m_pWrapper->m_WrapperTable.m_RTCRecording_AddTargetPositionsToDataTable(m_pHandle, hDataTable, sColumnIdentifierX.c_str(), sColumnDescriptionX.c_str(), sColumnIdentifierY.c_str(), sColumnDescriptionY.c_str()));
 	}
 	
+	/**
+	* CRTCRecording::StartListWithRecording - Starts the execution of the list and the incremental readout of the recorded data. Returns immediately. ReadRecordedData MUST be called repeatedly afterwards until it reports that the recording is complete.
+	*/
+	void CRTCRecording::StartListWithRecording()
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_RTCRecording_StartListWithRecording(m_pHandle));
+	}
+	
+	/**
+	* CRTCRecording::ReadRecordedData - Reads the data that the RTC card has recorded since the last call into the channels. Does not wait for new data. Fails if StartListWithRecording has not been called.
+	* @return True if the list has finished and all recorded data has been read.
+	*/
+	bool CRTCRecording::ReadRecordedData()
+	{
+		bool resultRecordingComplete = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_RTCRecording_ReadRecordedData(m_pHandle, &resultRecordingComplete));
+		
+		return resultRecordingComplete;
+	}
+	
+	/**
+	* CRTCRecording::DiscardRecords - Drops the record entries of all channels. The channels and the readout position are kept, so that the recorded data can be handed on piece by piece between calls to ReadRecordedData.
+	*/
+	void CRTCRecording::DiscardRecords()
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_RTCRecording_DiscardRecords(m_pHandle));
+	}
+	
 	/**
 	 * Method definitions for class CGPIOSequence
 	 */
@@ -7161,6 +7311,63 @@ class CDriver_ScanLab_RTC6xN : public CDriver_ScanLab {
 		CheckError(m_pWrapper->m_WrapperTable.m_RTCContext_SetMicrovectorStreamingEnabled(m_pHandle, bEnabled, nMinLayerSize, dPrebufferFraction));
 	}
 	
+	/**
+	* CRTCContext::SetMicrovectorListSwitchingEnabled - Enables alternating List1/List2 execution for microvector layers that do not fit into one RTC6 list. AddMicrovectorMovement then splits the layer into segments, closes each full list with set_end_of_list, arms an automatic list change and continues in the other list while the laser keeps marking. Requires the streamed download (SetMicrovectorStreamingEnabled). Default is disabled.
+	* @param[in] bEnabled - True to execute oversized layers alternately from List1 and List2.
+	* @param[in] nListCapacityLimit - Test aid: maximum list positions used per segment, 0 = full configured list size. Values below 84096 (four check blocks in the worst case plus the tail reserve) are clamped to it.
+	* @param[in] nTailReserve - List positions kept free at the end of every segment for set_end_of_list and the layer epilogue. 0 = built-in default of 4096.
+	*/
+	void CRTCContext::SetMicrovectorListSwitchingEnabled(const bool bEnabled, const LibMCDriver_ScanLab_uint32 nListCapacityLimit, const LibMCDriver_ScanLab_uint32 nTailReserve)
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_RTCContext_SetMicrovectorListSwitchingEnabled(m_pHandle, bEnabled, nListCapacityLimit, nTailReserve));
+	}
+	
+	/**
+	* CRTCContext::GetMicrovectorListSwitchingStatistics - Returns counters of the last AddMicrovectorMovement call: number of segments the layer was split into, number of segments that had to be started explicitly because the card had already finished the previous one, the minimum observed download margin and the longest wait for a list to become free.
+	* @param[out] nSegmentCount - Segments written (1 = no list switch).
+	* @param[out] nFallbackCount - Segments started explicitly instead of by automatic list change.
+	* @param[out] nMinMargin - Minimum observed distance between input and output pointer in list positions.
+	* @param[out] nMaxListWaitInMS - Longest wait for the previous list to be consumed before it could be reused, in milliseconds.
+	*/
+	void CRTCContext::GetMicrovectorListSwitchingStatistics(LibMCDriver_ScanLab_uint32 & nSegmentCount, LibMCDriver_ScanLab_uint32 & nFallbackCount, LibMCDriver_ScanLab_uint64 & nMinMargin, LibMCDriver_ScanLab_uint64 & nMaxListWaitInMS)
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_RTCContext_GetMicrovectorListSwitchingStatistics(m_pHandle, &nSegmentCount, &nFallbackCount, &nMinMargin, &nMaxListWaitInMS));
+	}
+	
+	/**
+	* CRTCContext::BeginMicrovectorStreaming - Stepwise variant of AddMicrovectorMovement, same semantics and configuration. Writes the first part of the layer and, on the streamed path, starts list execution. The rest is written by ContinueMicrovectorStreaming calls; between two calls the caller is free to do other work, e.g. read out the RTC recording while the card is marking. The microvector buffer MUST stay valid and unchanged until ContinueMicrovectorStreaming has returned true or AbortMicrovectorStreaming has been called. Small layers and the sequential download are written completely by this call.
+	* @param[in] MicrovectorArrayBuffer - Microvector array to execute. Must outlive the streaming session.
+	* @return True if this call has started list execution (streamed download). False if the layer was written without starting execution; the caller executes the list as usual afterwards.
+	*/
+	bool CRTCContext::BeginMicrovectorStreaming(const CInputVector<sMicroVector> & MicrovectorArrayBuffer)
+	{
+		bool resultExecutionStarted = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_RTCContext_BeginMicrovectorStreaming(m_pHandle, (LibMCDriver_ScanLab_uint64)MicrovectorArrayBuffer.size(), MicrovectorArrayBuffer.data(), &resultExecutionStarted));
+		
+		return resultExecutionStarted;
+	}
+	
+	/**
+	* CRTCContext::ContinueMicrovectorStreaming - Writes the next part of the layer passed to BeginMicrovectorStreaming. Returns as soon as the time budget is used up, the download has to wait for the card to free a list, or the layer is complete. Never waits for the card. Fails if no streaming session has been begun.
+	* @param[in] nTimeBudgetInMS - Upper bound for the time spent writing in this call, in milliseconds. 0 writes a single block.
+	* @return True once all microvectors have been written. The session is finished then; further calls return true without doing anything.
+	*/
+	bool CRTCContext::ContinueMicrovectorStreaming(const LibMCDriver_ScanLab_uint32 nTimeBudgetInMS)
+	{
+		bool resultComplete = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_RTCContext_ContinueMicrovectorStreaming(m_pHandle, nTimeBudgetInMS, &resultComplete));
+		
+		return resultComplete;
+	}
+	
+	/**
+	* CRTCContext::AbortMicrovectorStreaming - Ends a streaming session before completion, e.g. when the caller fails between two ContinueMicrovectorStreaming calls. Stops list execution, consumes an armed list change and resets the segmentation state. Does nothing if no session is active.
+	*/
+	void CRTCContext::AbortMicrovectorStreaming()
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_RTCContext_AbortMicrovectorStreaming(m_pHandle));
+	}
+	
 	/**
 	* CRTCContext::GetCurrentFreeVariable - Returns the currently set free variable.
 	* @param[in] nVariableNo - Number of the variable (0-7).
diff --git a/Drivers/ScanLab/Headers/CppDynamic/libmcdriver_scanlab_types.hpp b/Drivers/ScanLab/Headers/CppDynamic/libmcdriver_scanlab_types.hpp
index 0d5f77032..d807443df 100644
--- a/Drivers/ScanLab/Headers/CppDynamic/libmcdriver_scanlab_types.hpp
+++ b/Drivers/ScanLab/Headers/CppDynamic/libmcdriver_scanlab_types.hpp
@@ -270,6 +270,7 @@ typedef void * LibMCDriver_ScanLab_pvoid;
 #define LIBMCDRIVER_SCANLAB_ERROR_MINIMUMJUMPDISTANCEPROVIDEDTWICEINPROFILE 1165 /** Minimum jump distance provided twice in profile. */
 #define LIBMCDRIVER_SCANLAB_ERROR_UNSUPPORTEDPROFILEMODIFIER 1166 /** Toolpath profile has a modifier that the driver cannot execute. */
 #define LIBMCDRIVER_SCANLAB_ERROR_MODIFIEDLASERPOWEROUTOFRANGE 1167 /** Modified laser power is outside of the calibrated laser power range. */
+#define LIBMCDRIVER_SCANLAB_ERROR_RECORDINGREADOUTNOTSTARTED 1168 /** The incremental readout of the recording has not been started. */
 
 /*************************************************************************************************************************
  Error strings for LibMCDriver_ScanLab
@@ -452,6 +453,7 @@ inline const char * LIBMCDRIVER_SCANLAB_GETERRORSTRING (LibMCDriver_ScanLabResul
     case LIBMCDRIVER_SCANLAB_ERROR_MINIMUMJUMPDISTANCEPROVIDEDTWICEINPROFILE: return "Minimum jump distance provided twice in profile.";
     case LIBMCDRIVER_SCANLAB_ERROR_UNSUPPORTEDPROFILEMODIFIER: return "Toolpath profile has a modifier that the driver cannot execute.";
     case LIBMCDRIVER_SCANLAB_ERROR_MODIFIEDLASERPOWEROUTOFRANGE: return "Modified laser power is outside of the calibrated laser power range.";
+    case LIBMCDRIVER_SCANLAB_ERROR_RECORDINGREADOUTNOTSTARTED: return "The incremental readout of the recording has not been started.";
     default: return "unknown error";
   }
 }
diff --git a/Drivers/ScanLab/Implementation/libmcdriver_scanlab_rtccontext.cpp b/Drivers/ScanLab/Implementation/libmcdriver_scanlab_rtccontext.cpp
index 31c5d8b6e..9f8acde38 100644
--- a/Drivers/ScanLab/Implementation/libmcdriver_scanlab_rtccontext.cpp
+++ b/Drivers/ScanLab/Implementation/libmcdriver_scanlab_rtccontext.cpp
@@ -114,10 +114,42 @@ using namespace LibMCDriver_ScanLab::Impl;
 // ~100 checks on a 2M layer - do not lower this by an order of magnitude.
 #define RTCCONTEXT_MICROVECTORSTREAM_CHECKINTERVAL 20000
 
+// Time budget the blocking AddMicrovectorMovement() passes to ContinueMicrovectorStreaming(): it
+// only returns to wait for a list or when the layer is complete.
+#define RTCCONTEXT_MICROVECTORSTREAM_BLOCKINGBUDGETMS 0xffffffffUL
+
 // Minimum allowed distance between input and output pointer in list positions (= 0.5 s of
 // marking). Less than this aborts the download before the board can reach stale memory.
 #define RTCCONTEXT_MICROVECTORSTREAM_MINMARGIN 50000
 
+// --- Alternating List1/List2 execution (see Plan/RTC6_DoubleBuffering_Implementation_Plan_2026-10-07.html)
+// A layer that does not fit into the open list is written as segments: every full list is closed
+// with set_end_of_list, a one-time auto_change_pos(0) continues execution in the other list
+// "without delay" (RTC6 manual p. 383), and the other list is reused once load_list(3, 0)
+// reports it as processed (p. 599). The laser signals stay as they are across an armed list
+// change (p. 758). Measured on 2026-10-07: High Performance Mode download 1.08 us/vector against
+// 10 us/vector execution, so the PC fills the next list about nine times faster than the card
+// empties the current one.
+
+// Positions kept free at the end of every segment for its set_end_of_list and, in the last
+// segment, for the layer epilogue the plugin writes after AddMicrovectorMovement returns.
+#define RTCCONTEXT_LISTSWITCH_TAILRESERVE 4096
+
+// Smallest list capacity a segment may be limited to (test aid): a prebuffer and two check
+// blocks in the worst case plus the tail reserve. Smaller segments could end before the PC has
+// armed the next list change.
+#define RTCCONTEXT_LISTSWITCH_MINCAPACITYLIMIT (4 * RTCCONTEXT_MICROVECTORSTREAM_CHECKINTERVAL + RTCCONTEXT_LISTSWITCH_TAILRESERVE)
+
+// Polling interval while waiting for the card to finish the previous list. Nothing is being
+// downloaded meanwhile, so the control commands do not cost pipeline throughput.
+#define RTCCONTEXT_LISTSWITCH_WAITPOLLINTERVALMS 20
+
+// Added to twice the execution time of the largest segment to form the wait timeout.
+#define RTCCONTEXT_LISTSWITCH_WAITTIMEOUTEXTRAMS 5000
+
+// get_status bit 0: BUSY list execution status (manual p. 503).
+#define RTCCONTEXT_GETSTATUS_BUSYBIT (1UL << 0)
+
 
 
 CRTCPowerMapping::CRTCPowerMapping ()
@@ -566,7 +598,20 @@ CRTCContext::CRTCContext(PRTCContextOwnerData pOwnerData, uint32_t nCardNo, bool
 	m_nCurrentStartListPosition (0),
 	m_bMicrovectorStreamingEnabled (false),
 	m_nMicrovectorStreamMinLayerSize (RTCCONTEXT_MICROVECTORSTREAM_MINLAYERSIZE),
-	m_dMicrovectorStreamPrebufferFraction (RTCCONTEXT_MICROVECTORSTREAM_PREBUFFERFRACTION)
+	m_dMicrovectorStreamPrebufferFraction (RTCCONTEXT_MICROVECTORSTREAM_PREBUFFERFRACTION),
+	m_bMicrovectorListSwitchingEnabled (false),
+	m_nMicrovectorListCapacityLimit (0),
+	m_nMicrovectorSegmentTailReserve (RTCCONTEXT_LISTSWITCH_TAILRESERVE),
+	m_nCurrentOpenListIndex (1),
+	m_nSegmentsClosed (0),
+	m_bListChangeArmed (false),
+	m_bPendingExplicitStart (false),
+	m_nMaxSegmentVectors (0),
+	m_nListSwitchFallbackCount (0),
+	m_nLastLayerSegmentCount (0),
+	m_nLastLayerFallbackCount (0),
+	m_nLastLayerMinMargin (0),
+	m_nLastLayerMaxWaitInMS (0)
 
 
 {
@@ -574,6 +619,7 @@ CRTCContext::CRTCContext(PRTCContextOwnerData pOwnerData, uint32_t nCardNo, bool
 		throw ELibMCDriver_ScanLabInterfaceException(LIBMCDRIVER_SCANLAB_ERROR_INVALIDPARAM);
 
 	m_pMicrovectorStreamExecutionStarted = std::make_shared<std::atomic<bool>> (false);
+	m_pMicrovectorStreamDownloadActive = std::make_shared<std::atomic<bool>> (false);
 
 	m_pScanLabSDK = pOwnerData->getScanLabSDK();
 	if (m_pScanLabSDK.get() == nullptr)
@@ -913,6 +959,27 @@ void CRTCContext::SetStartList(const LibMCDriver_ScanLab_uint32 nListIndex, cons
 	m_nCurrentStartListIndex = nListIndex;
 	m_nCurrentStartListPosition = nPosition;
 
+	// A list change armed by the previous layer is normally consumed while that layer runs to
+	// its end. If it is still flagged here, the layer was interrupted outside the driver's own
+	// abort path; consume the change now, otherwise it would fire at this layer's first
+	// set_end_of_list and jump into stale list memory.
+	if (m_bListChangeArmed) {
+		m_pDriverEnvironment->LogWarning("List switching: a list change armed by the previous layer is still pending, draining it before the new list is loaded.");
+		drainPendingListChange();
+		m_pScanLabSDK->n_set_start_list_pos(m_CardNo, nListIndex, nPosition);
+		m_pScanLabSDK->checkError(m_pScanLabSDK->n_get_last_error(m_CardNo));
+	}
+
+	// A stepwise download that was never completed or aborted belongs to a layer that was
+	// interrupted outside the driver's own paths. Its list is not running anymore (a new list is
+	// being built), so only the bookkeeping is dropped.
+	if ((m_StreamSession.eState == eMicrovectorStreamState::Writing) || (m_StreamSession.eState == eMicrovectorStreamState::WaitingForList))
+		m_pDriverEnvironment->LogWarning("Microvector streaming: the previous layer's download session was still open, dropping it.");
+	m_pMicrovectorStreamDownloadActive->store(false);
+	resetMicrovectorStreamSession();
+
+	resetListSwitchingLayerState();
+
 	m_CurrentMeasurementTagInfo.m_PartID = 0;
 	m_CurrentMeasurementTagInfo.m_ProfileID = 0;
 	m_CurrentMeasurementTagInfo.m_SegmentID = 0;
@@ -1089,9 +1156,9 @@ void CRTCContext::writePower(double dPowerInPercent, bool bOIEPIDControlFlag, bo
 
 		if (m_LaserPort == eLaserPort::LaserPulseModulation) {
 
-			uint32_t nHalfPeriodInBits = (uint32_t)round(m_dLaserPulseHalfPeriodInMS * 64.0);
-			uint32_t nFullPeriodInBits = nHalfPeriodInBits * 2;
-			uint32_t nPulseLength = (uint32_t)round((double)nFullPeriodInBits * dClippedPowerFactor);
+			uint32_t nHalfPeriodInBits = 0;
+			uint32_t nPulseLength = 0;
+			quantizePulseModulationPower(dClippedPowerFactor, nHalfPeriodInBits, nPulseLength);
 
 			if (bUseMicrovectorPowerCache
 				&& (nHalfPeriodInBits == m_nMicrovectorPowerCachePulseHalfPeriodInBits)
@@ -1109,21 +1176,7 @@ void CRTCContext::writePower(double dPowerInPercent, bool bOIEPIDControlFlag, bo
 		}
 		else {
 
-			switch (m_LaserPort) {
-			case eLaserPort::Port16bitDigital:
-				digitalPowerValue = (int32_t)round(dClippedPowerFactor * 65535.0);
-				break;
-			case eLaserPort::Port8bitDigital:
-				digitalPowerValue = (int32_t)round(dClippedPowerFactor * 255.0);
-				break;
-			case eLaserPort::Port12BitAnalog1:
-			case eLaserPort::Port12BitAnalog2:
-			case eLaserPort::Port12BitAnalog1andAnalog2:
-				digitalPowerValue = (int32_t)round(dClippedPowerFactor * 4095.0);
-				break;
-			default:
-				break;
-			}
+			digitalPowerValue = quantizeDigitalPowerValue(dClippedPowerFactor);
 
 			if (bUseMicrovectorPowerCache && (digitalPowerValue == m_nMicrovectorPowerCacheDACValue))
 				return;
@@ -1492,7 +1545,123 @@ void CRTCContext::emitMicroVectorsToOpenList(const LibMCDriver_ScanLab::sMicroVe
 	}
 }
 
-uint64_t CRTCContext::checkStreamMargin(uint64_t nMinObservedMargin)
+CRTCContext::sListLocation CRTCContext::resolveListLocation(uint64_t nAbsolutePointer) const
+{
+	// n_get_input_pointer and n_get_status return ABSOLUTE list memory addresses, i.e. offsets
+	// relative to the start of "List1" (manual p. 479, 504). Map them onto the configured lists;
+	// a pointer beyond both lists lies in the protected "List3" area.
+	sListLocation location;
+	location.nListIndex = 0;
+	location.nOffset = nAbsolutePointer;
+	location.nListSize = 0;
+
+	if (m_nConfiguredListSizeA == 0)
+		return location;
+
+	if (nAbsolutePointer < (uint64_t)m_nConfiguredListSizeA) {
+		location.nListIndex = 1;
+		location.nListSize = m_nConfiguredListSizeA;
+		return location;
+	}
+
+	uint64_t nListEnd = (uint64_t)m_nConfiguredListSizeA + (uint64_t)m_nConfiguredListSizeB;
+	if (nAbsolutePointer < nListEnd) {
+		location.nListIndex = 2;
+		location.nOffset = nAbsolutePointer - (uint64_t)m_nConfiguredListSizeA;
+		location.nListSize = m_nConfiguredListSizeB;
+	}
+
+	return location;
+}
+
+uint64_t CRTCContext::effectiveListCapacity(const sListLocation& location) const
+{
+	uint64_t nCapacity = location.nListSize;
+	if ((m_nMicrovectorListCapacityLimit > 0) && ((uint64_t)m_nMicrovectorListCapacityLimit < nCapacity))
+		nCapacity = m_nMicrovectorListCapacityLimit;
+	return nCapacity;
+}
+
+int32_t CRTCContext::quantizeDigitalPowerValue(double dClippedPowerFactor) const
+{
+	switch (m_LaserPort) {
+	case eLaserPort::Port16bitDigital:
+		return (int32_t)round(dClippedPowerFactor * 65535.0);
+	case eLaserPort::Port8bitDigital:
+		return (int32_t)round(dClippedPowerFactor * 255.0);
+	case eLaserPort::Port12BitAnalog1:
+	case eLaserPort::Port12BitAnalog2:
+	case eLaserPort::Port12BitAnalog1andAnalog2:
+		return (int32_t)round(dClippedPowerFactor * 4095.0);
+	default:
+		return 0;
+	}
+}
+
+void CRTCContext::quantizePulseModulationPower(double dClippedPowerFactor, uint32_t& nHalfPeriodInBits, uint32_t& nPulseLength) const
+{
+	nHalfPeriodInBits = (uint32_t)round(m_dLaserPulseHalfPeriodInMS * 64.0);
+	uint32_t nFullPeriodInBits = nHalfPeriodInBits * 2;
+	nPulseLength = (uint32_t)round((double)nFullPeriodInBits * dClippedPowerFactor);
+}
+
+uint64_t CRTCContext::countMicrovectorPowerPositions(const LibMCDriver_ScanLab::sMicroVector* pBegin, uint64_t nCount) const
+{
+	// Mirrors the deduplication of writePower(..., bUseMicrovectorPowerCache = true) starting
+	// from an invalid cache, so the first vector always counts. One list position per power
+	// command; Port12BitAnalog1andAnalog2 issues two commands per change.
+	uint64_t nCommandsPerChange = 0;
+	switch (m_LaserPort) {
+	case eLaserPort::Port16bitDigital:
+	case eLaserPort::Port8bitDigital:
+	case eLaserPort::Port12BitAnalog1:
+	case eLaserPort::Port12BitAnalog2:
+	case eLaserPort::LaserPulseModulation:
+		nCommandsPerChange = 1;
+		break;
+	case eLaserPort::Port12BitAnalog1andAnalog2:
+		nCommandsPerChange = 2;
+		break;
+	default:
+		return 0;
+	}
+
+	bool bPulseModulation = (m_LaserPort == eLaserPort::LaserPulseModulation);
+	int32_t nLastDACValue = RTCCONTEXT_INVALIDMICROVECTORPOWERCACHE;
+	uint32_t nLastHalfPeriodInBits = 0xffffffffUL;
+	uint32_t nLastPulseLength = 0xffffffffUL;
+	uint64_t nChanges = 0;
+
+	for (uint64_t nIndex = 0; nIndex < nCount; nIndex++) {
+		double dClippedPowerFactor = pBegin[nIndex].m_LaserPowerInPercent / 100.0;
+		if (dClippedPowerFactor > 1.0)
+			dClippedPowerFactor = 1.0;
+		if (dClippedPowerFactor < 0.0)
+			dClippedPowerFactor = 0.0;
+
+		if (bPulseModulation) {
+			uint32_t nHalfPeriodInBits = 0;
+			uint32_t nPulseLength = 0;
+			quantizePulseModulationPower(dClippedPowerFactor, nHalfPeriodInBits, nPulseLength);
+			if ((nHalfPeriodInBits != nLastHalfPeriodInBits) || (nPulseLength != nLastPulseLength)) {
+				nChanges++;
+				nLastHalfPeriodInBits = nHalfPeriodInBits;
+				nLastPulseLength = nPulseLength;
+			}
+		}
+		else {
+			int32_t nDACValue = quantizeDigitalPowerValue(dClippedPowerFactor);
+			if (nDACValue != nLastDACValue) {
+				nChanges++;
+				nLastDACValue = nDACValue;
+			}
+		}
+	}
+
+	return nChanges * nCommandsPerChange;
+}
+
+uint64_t CRTCContext::checkStreamMargin(uint64_t nMinObservedMargin, sListLocation& inputLocation)
 {
 	// Both pointers are ABSOLUTE list memory addresses (offsets from the start of "List1"):
 	// the output pointer via n_get_status (manual p. 503-504), the input pointer via
@@ -1504,22 +1673,32 @@ uint64_t CRTCContext::checkStreamMargin(uint64_t nMinObservedMargin)
 	m_pScanLabSDK->n_get_status(m_CardNo, &nStatus, &nOutputPointer);
 	uint64_t nInputPointer = m_pScanLabSDK->n_get_input_pointer(m_CardNo);
 
+	inputLocation = resolveListLocation(nInputPointer);
+	sListLocation outputLocation = resolveListLocation((uint64_t)nOutputPointer);
+
+	// Pointers in different lists: the PC writes a list the card is not executing. The card can
+	// only enter that list through an armed list change at the end of its current segment, and
+	// the written list was opened only after it had been processed (load_list) or before it was
+	// ever started. No overrun is possible; the margin is the rest of the executing list plus
+	// what is already written, for diagnostics only.
+	if ((inputLocation.nListIndex != 0) && (outputLocation.nListIndex != 0)
+		&& (inputLocation.nListIndex != outputLocation.nListIndex)) {
+		uint64_t nRestOfExecutingList = (outputLocation.nOffset < outputLocation.nListSize)
+			? (outputLocation.nListSize - outputLocation.nOffset) : 0;
+		uint64_t nMargin = nRestOfExecutingList + inputLocation.nOffset;
+		return (nMargin < nMinObservedMargin) ? nMargin : nMinObservedMargin;
+	}
+
 	bool bOvertaken = ((uint64_t)nOutputPointer > nInputPointer);
 	uint64_t nMargin = bOvertaken ? 0 : (nInputPointer - (uint64_t)nOutputPointer);
 
-	if (bOvertaken || (nMargin < (uint64_t)RTCCONTEXT_MICROVECTORSTREAM_MINMARGIN)) {
-
-		// Stop the list before throwing: past this point the board would run into stale list
-		// memory with the laser armed. stop_execution also switches the laser signals off.
-		m_pScanLabSDK->n_stop_execution(m_CardNo);
-		m_pMicrovectorStreamExecutionStarted->store(false);
-
-		if (bOvertaken)
-			throw ELibMCDriver_ScanLabInterfaceException(LIBMCDRIVER_SCANLAB_ERROR_DRIVERERROR,
-				"Microvector streaming: output pointer overtook the download (output pointer at "
-				+ std::to_string(nOutputPointer) + ", input pointer at " + std::to_string(nInputPointer)
-				+ ") - the board has executed stale list memory, the layer is corrupted. Execution was stopped.");
+	if (bOvertaken)
+		throw ELibMCDriver_ScanLabInterfaceException(LIBMCDRIVER_SCANLAB_ERROR_DRIVERERROR,
+			"Microvector streaming: output pointer overtook the download (output pointer at "
+			+ std::to_string(nOutputPointer) + ", input pointer at " + std::to_string(nInputPointer)
+			+ ") - the board has executed stale list memory, the layer is corrupted. Execution was stopped.");
 
+	if (nMargin < (uint64_t)RTCCONTEXT_MICROVECTORSTREAM_MINMARGIN)
 		throw ELibMCDriver_ScanLabInterfaceException(LIBMCDRIVER_SCANLAB_ERROR_DRIVERERROR,
 			"Microvector streaming: download margin exhausted (input pointer at " + std::to_string(nInputPointer)
 			+ ", output pointer at " + std::to_string(nOutputPointer) + ", margin " + std::to_string(nMargin)
@@ -1527,150 +1706,615 @@ uint64_t CRTCContext::checkStreamMargin(uint64_t nMinObservedMargin)
 			+ " list positions). Execution was stopped before reaching stale list memory."
 			+ " Increase cardconfig/microvectorstreamingprebufferfraction or disable streaming via"
 			+ " cardconfig/enablemicrovectorstreaming.");
-	}
 
 	return (nMargin < nMinObservedMargin) ? nMargin : nMinObservedMargin;
 }
 
-void CRTCContext::AddMicrovectorMovement(const LibMCDriver_ScanLab_uint64 nMicrovectorArrayBufferSize, const LibMCDriver_ScanLab::sMicroVector* pMicrovectorArrayBuffer)
+void CRTCContext::resetListSwitchingLayerState()
 {
-	if (nMicrovectorArrayBufferSize > 0) {
-		if (pMicrovectorArrayBuffer == nullptr)
-			throw ELibMCDriver_ScanLabInterfaceException(LIBMCDRIVER_SCANLAB_ERROR_INVALIDPARAM);
-		m_pScanLabSDK->checkGlobalErrorOfCard(m_CardNo);
-		invalidateMicrovectorPowerCache();
+	m_nCurrentOpenListIndex = m_nCurrentStartListIndex;
+	m_nSegmentsClosed = 0;
+	m_bListChangeArmed = false;
+	m_bPendingExplicitStart = false;
+	m_nMaxSegmentVectors = 0;
+	m_nListSwitchFallbackCount = 0;
+}
+
+void CRTCContext::drainPendingListChange()
+{
+	// An armed one-time list change that has not been consumed is not documented to be cleared
+	// by stop_execution (manual p. 383, 393, 962). Left alone it would fire at the next
+	// set_end_of_list the card executes and continue in stale list memory. Consume it with two
+	// empty lists: List1 ends at once, the pending change continues in List2, which ends too.
+	// The laser signals are already off (stop_execution) and stay off (p. 758).
+	m_pScanLabSDK->n_set_start_list_pos(m_CardNo, 2, 0);
+	m_pScanLabSDK->n_set_end_of_list(m_CardNo);
+	m_pScanLabSDK->n_set_start_list_pos(m_CardNo, 1, 0);
+	m_pScanLabSDK->n_set_end_of_list(m_CardNo);
+	m_pScanLabSDK->n_execute_list_pos(m_CardNo, 1, 0);
+
+	auto tStart = std::chrono::steady_clock::now();
+	for (;;) {
+		uint32_t nStatus = 0;
+		uint32_t nPosition = 0;
+		m_pScanLabSDK->n_get_status(m_CardNo, &nStatus, &nPosition);
+		if ((nStatus & RTCCONTEXT_GETSTATUS_BUSYBIT) == 0)
+			break;
+
+		double dElapsedInMS = std::chrono::duration_cast<std::chrono::duration<double, std::milli>>
+			(std::chrono::steady_clock::now() - tStart).count();
+		if (dElapsedInMS > 1000.0) {
+			m_pDriverEnvironment->LogWarning("List switching: draining the pending list change did not finish within 1 s (get_status 0x"
+				+ std::to_string(nStatus) + ", read_status " + std::to_string(m_pScanLabSDK->n_read_status(m_CardNo)) + ").");
+			break;
+		}
+		std::this_thread::sleep_for(std::chrono::milliseconds(RTCCONTEXT_LISTSWITCH_WAITPOLLINTERVALMS));
+	}
+
+	uint32_t nLastError = m_pScanLabSDK->n_get_last_error(m_CardNo);
+	if (nLastError != 0)
+		m_pDriverEnvironment->LogWarning("List switching: draining the pending list change reported RTC error " + std::to_string(nLastError) + ".");
+	m_pScanLabSDK->n_reset_error(m_CardNo, 0xffffffff);
+
+	m_bListChangeArmed = false;
+}
+
+void CRTCContext::closeSegment(uint64_t nSegmentVectors)
+{
+	// set_end_of_list is a normal list command and flushes the buffered list input (manual
+	// p. 758). Any accumulated error of the segment is checked by the caller right after.
+	m_pScanLabSDK->n_set_end_of_list(m_CardNo);
+
+	m_nSegmentsClosed++;
+	if (nSegmentVectors > m_nMaxSegmentVectors)
+		m_nMaxSegmentVectors = nSegmentVectors;
+
+	m_pDriverEnvironment->LogMessage("List switching: segment " + std::to_string(m_nSegmentsClosed - 1)
+		+ " closed in list " + std::to_string(m_nCurrentOpenListIndex) + " after "
+		+ std::to_string(nSegmentVectors) + " microvectors.");
+}
+
+bool CRTCContext::armListChangeIfBusy()
+{
+	// auto_change_pos while no list is being processed starts the other list immediately
+	// (manual p. 383), so the BUSY list execution status is checked first. The card entered the
+	// current segment just now (load_list reported the previous list as processed) and a segment
+	// is never shorter than two check blocks, so the window between the two calls is safe.
+	uint32_t nStatus = 0;
+	uint32_t nPosition = 0;
+	m_pScanLabSDK->n_get_status(m_CardNo, &nStatus, &nPosition);
+	if ((nStatus & RTCCONTEXT_GETSTATUS_BUSYBIT) == 0)
+		return false;
+
+	m_pScanLabSDK->n_auto_change_pos(m_CardNo, 0);
+	m_pScanLabSDK->checkError(m_pScanLabSDK->n_get_last_error(m_CardNo));
+	m_bListChangeArmed = true;
+	return true;
+}
+
+void CRTCContext::beginOpenNextSegmentList()
+{
+	uint32_t nTargetList = (m_nCurrentOpenListIndex == 1) ? 2 : 1;
+	bool bFirstSwitch = (m_nSegmentsClosed == 1);
+
+	if (bFirstSwitch) {
+		// The other list has not been started this layer, open it unconditionally (manual
+		// p. 904). The change into it (boundary 0) was armed right after execute_list_pos.
+		m_pScanLabSDK->n_set_start_list_pos(m_CardNo, nTargetList, 0);
+		m_pScanLabSDK->checkError(m_pScanLabSDK->n_get_last_error(m_CardNo));
+		completeSegmentListOpen(nTargetList, 0, m_bListChangeArmed);
+		refreshRoomAfterSegmentOpen();
+		return;
+	}
+
+	// The target list holds the segment before the one the card executes now. It can only be
+	// reused once the card has left it (which also confirms the previous list change has fired).
+	// The wait is not done here: ContinueMicrovectorStreaming() polls it with pollListConsumed()
+	// and the caller is free meanwhile. The timeout covers twice the execution time of the
+	// largest segment so far.
+	m_StreamSession.nWaitTargetList = nTargetList;
+	m_StreamSession.tWaitStart = std::chrono::steady_clock::now();
+	m_StreamSession.nWaitTimeoutInMS = (m_nMaxSegmentVectors / 100) * 2 + (uint64_t)RTCCONTEXT_LISTSWITCH_WAITTIMEOUTEXTRAMS;
+	m_StreamSession.eState = eMicrovectorStreamState::WaitingForList;
+}
+
+bool CRTCContext::pollListConsumed()
+{
+	// load_list(3, 0) opens the list that is not BUSY but USED, i.e. whose set_end_of_list has
+	// been executed, and returns 0 while there is none (manual p. 599-600).
+	uint32_t nExpectedListIndex = m_StreamSession.nWaitTargetList;
+	uint32_t nOpenedList = m_pScanLabSDK->n_load_list(m_CardNo, 3, 0);
+	double dElapsedInMS = std::chrono::duration_cast<std::chrono::duration<double, std::milli>>
+		(std::chrono::steady_clock::now() - m_StreamSession.tWaitStart).count();
+
+	if (nOpenedList == nExpectedListIndex)
+		return true;
+
+	if (nOpenedList != 0)
+		throw ELibMCDriver_ScanLabInterfaceException(LIBMCDRIVER_SCANLAB_ERROR_DRIVERERROR,
+			"List switching: load_list opened list " + std::to_string(nOpenedList) + " but list "
+			+ std::to_string(nExpectedListIndex) + " was expected to be the processed one (read_status "
+			+ std::to_string(m_pScanLabSDK->n_read_status(m_CardNo)) + "). Execution was stopped.");
+
+	if (dElapsedInMS > (double)m_StreamSession.nWaitTimeoutInMS)
+		throw ELibMCDriver_ScanLabInterfaceException(LIBMCDRIVER_SCANLAB_ERROR_DRIVERERROR,
+			"List switching: list " + std::to_string(nExpectedListIndex) + " was not processed within "
+			+ std::to_string(m_StreamSession.nWaitTimeoutInMS) + " ms (read_status " + std::to_string(m_pScanLabSDK->n_read_status(m_CardNo))
+			+ "). Execution was stopped.");
+
+	return false;
+}
+
+void CRTCContext::finishOpenNextSegmentList()
+{
+	uint64_t nWaitInMS = (uint64_t)std::chrono::duration_cast<std::chrono::duration<double, std::milli>>
+		(std::chrono::steady_clock::now() - m_StreamSession.tWaitStart).count();
+	if (nWaitInMS > m_StreamSession.nMaxWaitInMS)
+		m_StreamSession.nMaxWaitInMS = nWaitInMS;
+	m_bListChangeArmed = false;
+
+	// Arm the change from the executing segment into the one written next.
+	bool bArmed = armListChangeIfBusy();
+	if (!bArmed) {
+		// The card has already finished the executing segment (laser off at its
+		// set_end_of_list, manual p. 758). The new segment is started explicitly once enough
+		// of it is written; the layer continues with a gap in the marking.
+		m_nListSwitchFallbackCount++;
+		m_bPendingExplicitStart = true;
+		m_pDriverEnvironment->LogWarning("List switching: the card finished segment " + std::to_string(m_nSegmentsClosed)
+			+ " before the next list change could be armed - segment " + std::to_string(m_nSegmentsClosed + 1)
+			+ " will be started explicitly (fallback " + std::to_string(m_nListSwitchFallbackCount) + ").");
+	}
+
+	completeSegmentListOpen(m_StreamSession.nWaitTargetList, nWaitInMS, bArmed);
+	refreshRoomAfterSegmentOpen();
+	m_StreamSession.eState = eMicrovectorStreamState::Writing;
+}
+
+void CRTCContext::completeSegmentListOpen(uint32_t nTargetList, uint64_t nWaitInMS, bool bArmed)
+{
+	m_nCurrentOpenListIndex = nTargetList;
+
+	// The card keeps the last power across the list change, but the first vector of a segment
+	// re-issues it: one list position, and the segment never ends with a power command (p. 355).
+	invalidateMicrovectorPowerCache();
+
+	m_pDriverEnvironment->LogMessage("List switching: list " + std::to_string(nTargetList) + " opened for segment "
+		+ std::to_string(m_nSegmentsClosed) + " (waited " + std::to_string(nWaitInMS) + " ms, list change armed: "
+		+ (bArmed ? "yes" : "no") + ").");
+}
+
+void CRTCContext::refreshRoomAfterSegmentOpen()
+{
+	auto& session = m_StreamSession;
+	session.inputLocation = resolveListLocation(m_pScanLabSDK->n_get_input_pointer(m_CardNo));
+	session.nRoomLeft = (session.inputLocation.nListIndex != 0)
+		? (effectiveListCapacity(session.inputLocation) - session.inputLocation.nOffset)
+		: std::numeric_limits<uint64_t>::max();
 
-		// Refuse to overrun the open list. The RTC6 does not report this: once the input pointer
-		// reaches the end of a list it silently wraps to the start of that same list and keeps
-		// loading (RTC6 manual, ch. 6.4.1), overwriting the beginning of the layer.
-		if (m_nConfiguredListSizeA > 0) {
+	// The append loop runs without per-command checks; start the new segment with a clean slate.
+	m_pScanLabSDK->n_reset_error(m_CardNo, 0xffffffff);
+}
 
-			// n_get_input_pointer returns the ABSOLUTE list memory address, i.e. an offset
-			// relative to the start of "List1" - not a position within the open list. Derive
-			// which list we are in, and how much room is left in it. A pointer beyond both lists
-			// means we are in the protected "List3" area, where this check does not apply.
-			uint64_t nInputPointer = m_pScanLabSDK->n_get_input_pointer(m_CardNo);
-			uint64_t nListEnd = (uint64_t)m_nConfiguredListSizeA + (uint64_t)m_nConfiguredListSizeB;
+void CRTCContext::AddMicrovectorMovement(const LibMCDriver_ScanLab_uint64 nMicrovectorArrayBufferSize, const LibMCDriver_ScanLab::sMicroVector* pMicrovectorArrayBuffer)
+{
+	// Blocking wrapper around the stepwise download, with the behavior this call always had. The
+	// caller's buffer is valid for the whole call, so the lifetime contract of
+	// BeginMicrovectorStreaming holds trivially.
+	BeginMicrovectorStreaming(nMicrovectorArrayBufferSize, pMicrovectorArrayBuffer);
 
-			if (nInputPointer < nListEnd) {
+	while (!ContinueMicrovectorStreaming(RTCCONTEXT_MICROVECTORSTREAM_BLOCKINGBUDGETMS)) {
+		// Only reached while the card still executes the list the next segment goes into.
+		if (m_StreamSession.eState == eMicrovectorStreamState::WaitingForList)
+			std::this_thread::sleep_for(std::chrono::milliseconds(RTCCONTEXT_LISTSWITCH_WAITPOLLINTERVALMS));
+	}
+}
 
-				if (nInputPointer < (uint64_t)m_nConfiguredListSizeA)
-					nListEnd = m_nConfiguredListSizeA;
+void CRTCContext::resetMicrovectorStreamSession()
+{
+	m_StreamSession = sMicrovectorStreamSession();
+}
 
-				uint64_t nAvailablePositions = nListEnd - nInputPointer;
+bool CRTCContext::BeginMicrovectorStreaming(const LibMCDriver_ScanLab_uint64 nMicrovectorArrayBufferSize, const LibMCDriver_ScanLab::sMicroVector* pMicrovectorArrayBuffer)
+{
+	if ((m_StreamSession.eState == eMicrovectorStreamState::Writing) || (m_StreamSession.eState == eMicrovectorStreamState::WaitingForList))
+		throw ELibMCDriver_ScanLabInterfaceException(LIBMCDRIVER_SCANLAB_ERROR_DRIVERERROR,
+			"BeginMicrovectorStreaming: a microvector download session is already active (" + std::to_string(m_StreamSession.nWritten)
+			+ " of " + std::to_string(m_StreamSession.nTotal) + " microvectors written).");
+	resetMicrovectorStreamSession();
 
-				// Worst case, not the cached case: the skip rate depends on the microvector data,
-				// and this guard must not rely on it.
-				uint64_t nWorstCasePositions = nMicrovectorArrayBufferSize * (uint64_t)RTCCONTEXT_LISTPOSITIONS_PER_MICROVECTOR
-					+ (uint64_t)RTCCONTEXT_LISTCAPACITY_SAFETYMARGIN;
+	if (nMicrovectorArrayBufferSize == 0) {
+		m_StreamSession.eState = eMicrovectorStreamState::Complete;
+		return false;
+	}
+	if (pMicrovectorArrayBuffer == nullptr)
+		throw ELibMCDriver_ScanLabInterfaceException(LIBMCDRIVER_SCANLAB_ERROR_INVALIDPARAM);
 
-				if (nWorstCasePositions > nAvailablePositions)
-					throw ELibMCDriver_ScanLabInterfaceException(LIBMCDRIVER_SCANLAB_ERROR_DRIVERERROR,
-						"RTC list capacity exceeded: " + std::to_string(nMicrovectorArrayBufferSize)
-						+ " microvectors need up to " + std::to_string(nWorstCasePositions)
-						+ " list positions, but only " + std::to_string(nAvailablePositions)
-						+ " are left in the open list (input pointer at " + std::to_string(nInputPointer) + ")");
+	m_pScanLabSDK->checkGlobalErrorOfCard(m_CardNo);
+	invalidateMicrovectorPowerCache();
+
+	// Exact number of list positions this block takes when written from a fresh power cache:
+	// one micro_vector_abs per vector plus one power command per change of the quantized power.
+	uint64_t nPowerPositions = countMicrovectorPowerPositions(pMicrovectorArrayBuffer, nMicrovectorArrayBufferSize);
+	uint64_t nNeededPositions = nMicrovectorArrayBufferSize + nPowerPositions + (uint64_t)RTCCONTEXT_LISTCAPACITY_SAFETYMARGIN;
+
+	// Streaming starts list execution after a prebuffer and appends the rest while the laser
+	// marks (see the constant block above). It requires the explicit opt-in via
+	// SetMicrovectorStreamingEnabled and stays off for small layers and when execution is
+	// already running (a second block in the same list must not issue another
+	// execute_list_pos).
+	bool bStreamDownload = m_bMicrovectorStreamingEnabled
+		&& (nMicrovectorArrayBufferSize >= m_nMicrovectorStreamMinLayerSize)
+		&& (!m_pMicrovectorStreamExecutionStarted->load());
+
+	// Refuse to overrun the open list. The RTC6 does not report this: once the input pointer
+	// reaches the end of a list it silently wraps to the start of that same list and keeps
+	// loading (RTC6 manual, ch. 6.4.1), overwriting the beginning of the layer. With list
+	// switching enabled a block that does not fit is written as segments instead.
+	bool bSwitchLists = false;
+	uint64_t nRoomLeft = std::numeric_limits<uint64_t>::max();
+	sListLocation inputLocation = resolveListLocation(0);
+	inputLocation.nListIndex = 0;
+
+	if (m_nConfiguredListSizeA > 0) {
+		uint64_t nInputPointer = m_pScanLabSDK->n_get_input_pointer(m_CardNo);
+		inputLocation = resolveListLocation(nInputPointer);
+
+		// A pointer beyond both lists means the protected "List3" area, where this check does
+		// not apply.
+		if (inputLocation.nListIndex != 0) {
+			uint64_t nCapacity = effectiveListCapacity(inputLocation);
+			nRoomLeft = (inputLocation.nOffset < nCapacity) ? (nCapacity - inputLocation.nOffset) : 0;
+
+			bool bCanSwitch = bStreamDownload && m_bMicrovectorListSwitchingEnabled && (m_nConfiguredListSizeB > 0);
+			if (bCanSwitch) {
+				bSwitchLists = (nNeededPositions + (uint64_t)m_nMicrovectorSegmentTailReserve > nRoomLeft);
+			}
+			else if (nNeededPositions > nRoomLeft) {
+				throw ELibMCDriver_ScanLabInterfaceException(LIBMCDRIVER_SCANLAB_ERROR_DRIVERERROR,
+					"RTC list capacity exceeded: " + std::to_string(nMicrovectorArrayBufferSize)
+					+ " microvectors need " + std::to_string(nNeededPositions) + " list positions ("
+					+ std::to_string(nPowerPositions) + " power commands, " + std::to_string((uint64_t)RTCCONTEXT_LISTCAPACITY_SAFETYMARGIN)
+					+ " margin), but only " + std::to_string(nRoomLeft) + " are left in list " + std::to_string(inputLocation.nListIndex)
+					+ " (input pointer at " + std::to_string(nInputPointer) + ")."
+					+ (m_bMicrovectorListSwitchingEnabled
+						? " List switching is enabled but needs the streamed download for this layer (check cardconfig/enablemicrovectorstreaming and the minimum layer size)."
+						: " Enable cardconfig/enablemicrovectorlistswitching to execute oversized layers alternately from both lists."));
 			}
 		}
+	}
 
-		// Streaming starts list execution after a prebuffer and appends the rest while the laser
-		// marks (see the constant block above). It requires the explicit opt-in via
-		// SetMicrovectorStreamingEnabled and stays off for small layers and when execution is
-		// already running (a second block in the same list must not issue another
-		// execute_list_pos).
-		bool bStreamDownload = m_bMicrovectorStreamingEnabled
-			&& (nMicrovectorArrayBufferSize >= m_nMicrovectorStreamMinLayerSize)
-			&& (!m_pMicrovectorStreamExecutionStarted->load());
-
-		// The loops below write the list without querying n_get_last_error per command. Clear the
-		// accumulated error first so the check after the loop reports only this block. Nothing can
-		// be masked: the checkGlobalErrorOfCard above already threw on any pre-existing error.
-		m_pScanLabSDK->n_reset_error(m_CardNo, 0xffffffff);
+	m_pDriverEnvironment->LogMessage("Microvector layer: " + std::to_string(nMicrovectorArrayBufferSize) + " vectors, "
+		+ std::to_string(nPowerPositions) + " power positions, needs " + std::to_string(nNeededPositions) + " list positions, "
+		+ ((nRoomLeft == std::numeric_limits<uint64_t>::max()) ? std::string("list capacity unknown") : (std::to_string(nRoomLeft) + " left in list " + std::to_string(inputLocation.nListIndex)))
+		+ (bStreamDownload ? ", streamed" : ", sequential")
+		+ (bSwitchLists ? ", list switching" : ""));
 
-		auto tLoadStartTime = std::chrono::steady_clock::now();
-		uint64_t nPowerCommandsBefore = m_nMicrovectorPowerCommandsWritten;
+	// The loops below write the list without querying n_get_last_error per command. Clear the
+	// accumulated error first so the check after the loop reports only this block. Nothing can
+	// be masked: the checkGlobalErrorOfCard above already threw on any pre-existing error.
+	m_pScanLabSDK->n_reset_error(m_CardNo, 0xffffffff);
 
-		if (!bStreamDownload) {
+	auto tLoadStartTime = std::chrono::steady_clock::now();
+	uint64_t nPowerCommandsBefore = m_nMicrovectorPowerCommandsWritten;
 
-			// Sequential path - unchanged behavior: write the whole block, check once.
-			emitMicroVectorsToOpenList(pMicrovectorArrayBuffer, nMicrovectorArrayBufferSize);
+	if (!bStreamDownload) {
 
-			m_pScanLabSDK->checkGlobalErrorOfCard(m_CardNo);
+		// Sequential path - unchanged behavior: write the whole block, check once.
+		emitMicroVectorsToOpenList(pMicrovectorArrayBuffer, nMicrovectorArrayBufferSize);
 
-			// One summary line per block, not per vector. Reports both the achieved download rate and
-			// the power deduplication hit rate, which is what determines how many list positions the
-			// block actually consumed.
-			double dLoadDurationInMS = std::chrono::duration_cast<std::chrono::duration<double, std::milli>>
-				(std::chrono::steady_clock::now() - tLoadStartTime).count();
-			uint64_t nPowerCommands = m_nMicrovectorPowerCommandsWritten - nPowerCommandsBefore;
+		m_pScanLabSDK->checkGlobalErrorOfCard(m_CardNo);
 
-			m_pDriverEnvironment->LogMessage("Wrote " + std::to_string(nMicrovectorArrayBufferSize)
-				+ " microvectors in " + std::to_string(dLoadDurationInMS) + " ms ("
-				+ std::to_string((dLoadDurationInMS * 1000.0) / (double)nMicrovectorArrayBufferSize)
-				+ " us/vector), " + std::to_string(nPowerCommands) + " power commands, "
-				+ std::to_string(nMicrovectorArrayBufferSize + nPowerCommands) + " list positions used");
+		// One summary line per block, not per vector. Reports both the achieved download rate and
+		// the power deduplication hit rate, which is what determines how many list positions the
+		// block actually consumed.
+		double dLoadDurationInMS = std::chrono::duration_cast<std::chrono::duration<double, std::milli>>
+			(std::chrono::steady_clock::now() - tLoadStartTime).count();
+		uint64_t nPowerCommands = m_nMicrovectorPowerCommandsWritten - nPowerCommandsBefore;
 
-		}
-		else {
+		m_pDriverEnvironment->LogMessage("Wrote " + std::to_string(nMicrovectorArrayBufferSize)
+			+ " microvectors in " + std::to_string(dLoadDurationInMS) + " ms ("
+			+ std::to_string((dLoadDurationInMS * 1000.0) / (double)nMicrovectorArrayBufferSize)
+			+ " us/vector), " + std::to_string(nPowerCommands) + " power commands, "
+			+ std::to_string(nMicrovectorArrayBufferSize + nPowerCommands) + " list positions used");
+
+		m_nLastLayerSegmentCount = 1;
+		m_nLastLayerFallbackCount = 0;
+		m_nLastLayerMinMargin = 0;
+		m_nLastLayerMaxWaitInMS = 0;
+
+		invalidateMicrovectorPowerCache();
 
-			uint64_t nPrebufferCount = (uint64_t)((double)nMicrovectorArrayBufferSize * m_dMicrovectorStreamPrebufferFraction);
-			if (nPrebufferCount < (uint64_t)RTCCONTEXT_MICROVECTORSTREAM_MINPREBUFFER)
-				nPrebufferCount = (uint64_t)RTCCONTEXT_MICROVECTORSTREAM_MINPREBUFFER;
-			if (nPrebufferCount > nMicrovectorArrayBufferSize)
-				nPrebufferCount = nMicrovectorArrayBufferSize;
+		// Nothing is executing: the caller starts the list as usual.
+		m_StreamSession.eState = eMicrovectorStreamState::Complete;
+		return false;
+	}
 
-			emitMicroVectorsToOpenList(pMicrovectorArrayBuffer, nPrebufferCount);
+	uint64_t nPrebufferCount = (uint64_t)((double)nMicrovectorArrayBufferSize * m_dMicrovectorStreamPrebufferFraction);
+	if (nPrebufferCount < (uint64_t)RTCCONTEXT_MICROVECTORSTREAM_MINPREBUFFER)
+		nPrebufferCount = (uint64_t)RTCCONTEXT_MICROVECTORSTREAM_MINPREBUFFER;
+	if (nPrebufferCount > nMicrovectorArrayBufferSize)
+		nPrebufferCount = nMicrovectorArrayBufferSize;
+
+	if (bSwitchLists) {
+		// The first segment must hold the prebuffer, two check blocks in the worst case and the
+		// tail reserve, otherwise it would close before execution has started.
+		uint64_t nReservedPositions = (uint64_t)m_nMicrovectorSegmentTailReserve
+			+ 2ULL * (uint64_t)RTCCONTEXT_MICROVECTORSTREAM_CHECKINTERVAL * (uint64_t)RTCCONTEXT_LISTPOSITIONS_PER_MICROVECTOR;
+		uint64_t nPrebufferRoom = (nRoomLeft > nReservedPositions) ? (nRoomLeft - nReservedPositions) : 0;
+		uint64_t nMaxPrebufferCount = nPrebufferRoom / (uint64_t)RTCCONTEXT_LISTPOSITIONS_PER_MICROVECTOR;
+		if (nPrebufferCount > nMaxPrebufferCount)
+			nPrebufferCount = nMaxPrebufferCount;
+		if (nPrebufferCount == 0)
+			throw ELibMCDriver_ScanLabInterfaceException(LIBMCDRIVER_SCANLAB_ERROR_DRIVERERROR,
+				"List switching: the open list has no room for a prebuffer (" + std::to_string(nRoomLeft)
+				+ " positions left in list " + std::to_string(inputLocation.nListIndex) + ", "
+				+ std::to_string(nReservedPositions) + " reserved).");
+	}
 
-			// The prologue and the prebuffer must be known-good before the laser starts on them.
-			m_pScanLabSDK->checkGlobalErrorOfCard(m_CardNo);
+	auto& session = m_StreamSession;
+	session.pVectors = pMicrovectorArrayBuffer;
+	session.nTotal = nMicrovectorArrayBufferSize;
+	session.nPrebufferCount = nPrebufferCount;
+	session.bSwitchLists = bSwitchLists;
+	session.nRoomLeft = nRoomLeft;
+	session.inputLocation = inputLocation;
+	session.nMinObservedMargin = std::numeric_limits<uint64_t>::max();
+	session.nMaxWaitInMS = 0;
+	session.nPowerCommandsBefore = nPowerCommandsBefore;
+	session.tLoadStart = tLoadStartTime;
+	session.eState = eMicrovectorStreamState::Writing;
+
+	try {
+		emitMicroVectorsToOpenList(pMicrovectorArrayBuffer, nPrebufferCount);
+		session.nWritten = nPrebufferCount;
+		session.nSegmentVectors = nPrebufferCount;
+
+		// The prologue and the prebuffer must be known-good before the laser starts on them.
+		m_pScanLabSDK->checkGlobalErrorOfCard(m_CardNo);
 
-			// Start execution at the position SetStartList opened the list at, so the prologue
-			// (laser pins, delays, OIE trigger) runs first. Simultaneous loading and execution of
-			// the same list is explicitly supported (manual p. 447). Deliberately NOT routed
-			// through ExecuteList(), because that would issue a duplicate execution request.
-			// The microvector power cache remains valid across the prebuffer and append chunks.
-			m_pScanLabSDK->n_execute_list_pos(m_CardNo, m_nCurrentStartListIndex, m_nCurrentStartListPosition);
+		// Start execution at the position SetStartList opened the list at, so the prologue
+		// (laser pins, delays, OIE trigger) runs first. Simultaneous loading and execution of
+		// the same list is explicitly supported (manual p. 447). Deliberately NOT routed
+		// through ExecuteList(), because that would issue a duplicate execution request.
+		// The microvector power cache remains valid across the prebuffer and append chunks.
+		m_pScanLabSDK->n_execute_list_pos(m_CardNo, m_nCurrentStartListIndex, m_nCurrentStartListPosition);
+		m_pScanLabSDK->checkError(m_pScanLabSDK->n_get_last_error(m_CardNo));
+		m_pMicrovectorStreamExecutionStarted->store(true);
+		m_pMicrovectorStreamDownloadActive->store(true);
+		session.bExecutionStarted = true;
+
+		if (bSwitchLists) {
+			// Arm the change at the end of segment 0 now: execute_list_pos is synchronous, the
+			// card is BUSY, so the change cannot fire early (manual p. 383). It takes effect at
+			// the set_end_of_list closeSegment() writes once this list is full.
+			m_pScanLabSDK->n_auto_change_pos(m_CardNo, 0);
 			m_pScanLabSDK->checkError(m_pScanLabSDK->n_get_last_error(m_CardNo));
-			m_pMicrovectorStreamExecutionStarted->store(true);
+			m_bListChangeArmed = true;
+		}
 
-			// Clear again: the append loop below runs without per-command checks too.
-			m_pScanLabSDK->n_reset_error(m_CardNo, 0xffffffff);
+		// Clear again: the append steps run without per-command checks too.
+		m_pScanLabSDK->n_reset_error(m_CardNo, 0xffffffff);
 
-			uint64_t nMinObservedMargin = std::numeric_limits<uint64_t>::max();
-			uint64_t nWritten = nPrebufferCount;
+		// A layer that the prebuffer covers completely has nothing left to stream.
+		if (session.nWritten >= session.nTotal)
+			finishMicrovectorStreamSession();
+	}
+	catch (const std::exception&) {
+		abortMicrovectorStreamSession();
+		throw;
+	}
 
-			while (nWritten < nMicrovectorArrayBufferSize) {
+	return true;
+}
+
+bool CRTCContext::ContinueMicrovectorStreaming(const LibMCDriver_ScanLab_uint32 nTimeBudgetInMS)
+{
+	auto& session = m_StreamSession;
 
-				uint64_t nChunk = nMicrovectorArrayBufferSize - nWritten;
-				if (nChunk > (uint64_t)RTCCONTEXT_MICROVECTORSTREAM_CHECKINTERVAL)
-					nChunk = (uint64_t)RTCCONTEXT_MICROVECTORSTREAM_CHECKINTERVAL;
+	switch (session.eState) {
+	case eMicrovectorStreamState::None:
+		throw ELibMCDriver_ScanLabInterfaceException(LIBMCDRIVER_SCANLAB_ERROR_DRIVERERROR,
+			"ContinueMicrovectorStreaming: no microvector download session is active, call BeginMicrovectorStreaming first.");
+	case eMicrovectorStreamState::Complete:
+		return true;
+	default:
+		break;
+	}
 
-				emitMicroVectorsToOpenList(pMicrovectorArrayBuffer + nWritten, nChunk);
-				nWritten += nChunk;
+	auto tStepStart = std::chrono::steady_clock::now();
 
-				nMinObservedMargin = checkStreamMargin(nMinObservedMargin);
+	try {
+		for (;;) {
+			if (session.eState == eMicrovectorStreamState::WaitingForList) {
+				// The card still executes the list the next segment goes into. Not waited for
+				// here: the caller has its own work to do meanwhile (recording readout).
+				if (!pollListConsumed())
+					return false;
+				finishOpenNextSegmentList();
 			}
 
-			m_pScanLabSDK->checkGlobalErrorOfCard(m_CardNo);
+			writeNextMicrovectorBlock();
 
-			double dLoadDurationInMS = std::chrono::duration_cast<std::chrono::duration<double, std::milli>>
-				(std::chrono::steady_clock::now() - tLoadStartTime).count();
-			uint64_t nPowerCommands = m_nMicrovectorPowerCommandsWritten - nPowerCommandsBefore;
+			if (session.nWritten >= session.nTotal) {
+				finishMicrovectorStreamSession();
+				return true;
+			}
 
-			// The minimum observed margin is the main tuning indicator: close to MINMARGIN means
-			// PREBUFFERFRACTION has to grow; a large value means exposure time is wasted.
-			m_pDriverEnvironment->LogMessage("Wrote " + std::to_string(nMicrovectorArrayBufferSize)
-				+ " microvectors in " + std::to_string(dLoadDurationInMS) + " ms ("
-				+ std::to_string((dLoadDurationInMS * 1000.0) / (double)nMicrovectorArrayBufferSize)
-				+ " us/vector), " + std::to_string(nPowerCommands) + " power commands, "
-				+ std::to_string(nMicrovectorArrayBufferSize + nPowerCommands) + " list positions used"
-				+ " (streamed: execution started after " + std::to_string(nPrebufferCount)
-				+ " vectors, min margin " + std::to_string(nMinObservedMargin) + " list positions)");
+			// The block closed its segment and the next list is not free yet.
+			if (session.eState == eMicrovectorStreamState::WaitingForList)
+				return false;
 
+			double dElapsedInMS = std::chrono::duration_cast<std::chrono::duration<double, std::milli>>
+				(std::chrono::steady_clock::now() - tStepStart).count();
+			if (dElapsedInMS >= (double)nTimeBudgetInMS)
+				return false;
 		}
+	}
+	catch (const std::exception&) {
+		abortMicrovectorStreamSession();
+		throw;
+	}
+}
 
-		invalidateMicrovectorPowerCache();
+void CRTCContext::AbortMicrovectorStreaming()
+{
+	if ((m_StreamSession.eState != eMicrovectorStreamState::Writing) && (m_StreamSession.eState != eMicrovectorStreamState::WaitingForList))
+		return;
+
+	m_pDriverEnvironment->LogWarning("Microvector streaming: download aborted by the caller after " + std::to_string(m_StreamSession.nWritten)
+		+ " of " + std::to_string(m_StreamSession.nTotal) + " microvectors. Execution is stopped.");
+	abortMicrovectorStreamSession();
+}
+
+void CRTCContext::writeNextMicrovectorBlock()
+{
+	auto& session = m_StreamSession;
+	const LibMCDriver_ScanLab::sMicroVector* pVectors = session.pVectors;
+
+	uint64_t nChunk = session.nTotal - session.nWritten;
+	if (nChunk > (uint64_t)RTCCONTEXT_MICROVECTORSTREAM_CHECKINTERVAL)
+		nChunk = (uint64_t)RTCCONTEXT_MICROVECTORSTREAM_CHECKINTERVAL;
+
+	if (session.bSwitchLists && !session.bRestFitsExactly) {
+		// Worst case for the next block: two positions per vector plus the tail reserve.
+		// Only when that does not fit, count the rest exactly; if even the exact rest does
+		// not fit, close the segment here (it ends with a micro_vector_abs, p. 355).
+		uint64_t nWorstCasePositions = nChunk * (uint64_t)RTCCONTEXT_LISTPOSITIONS_PER_MICROVECTOR
+			+ (uint64_t)m_nMicrovectorSegmentTailReserve;
+		if (nWorstCasePositions > session.nRoomLeft) {
+			uint64_t nRestVectors = session.nTotal - session.nWritten;
+			uint64_t nRestPositions = nRestVectors
+				+ countMicrovectorPowerPositions(pVectors + session.nWritten, nRestVectors)
+				+ (uint64_t)RTCCONTEXT_LISTCAPACITY_SAFETYMARGIN + (uint64_t)m_nMicrovectorSegmentTailReserve;
+			if (nRestPositions <= session.nRoomLeft) {
+				session.bRestFitsExactly = true;
+			}
+			else {
+				closeSegment(session.nSegmentVectors);
+				m_pScanLabSDK->checkGlobalErrorOfCard(m_CardNo);
+				session.nSegmentVectors = 0;
+
+				// Opens the other list at once (first switch) or starts waiting for it; in the
+				// latter case this block is written once the list is free.
+				beginOpenNextSegmentList();
+				if (session.eState == eMicrovectorStreamState::WaitingForList)
+					return;
+			}
+		}
+	}
+
+	emitMicroVectorsToOpenList(pVectors + session.nWritten, nChunk);
+	session.nWritten += nChunk;
+	session.nSegmentVectors += nChunk;
+
+	if (m_bPendingExplicitStart
+		&& ((session.nSegmentVectors >= (uint64_t)RTCCONTEXT_MICROVECTORSTREAM_MINPREBUFFER) || (session.nWritten == session.nTotal))) {
+		// Fallback start of a segment the card could not change into automatically. Like
+		// the initial prebuffer: the written part must be known-good before the laser
+		// starts on it, and the rest is appended under the margin check.
+		m_pScanLabSDK->checkGlobalErrorOfCard(m_CardNo);
+		m_pScanLabSDK->n_execute_list_pos(m_CardNo, m_nCurrentOpenListIndex, 0);
+		m_pScanLabSDK->checkError(m_pScanLabSDK->n_get_last_error(m_CardNo));
+		m_bPendingExplicitStart = false;
+		m_pScanLabSDK->n_reset_error(m_CardNo, 0xffffffff);
+
+		m_pDriverEnvironment->LogMessage("List switching: segment " + std::to_string(m_nSegmentsClosed)
+			+ " started explicitly in list " + std::to_string(m_nCurrentOpenListIndex) + " after "
+			+ std::to_string(session.nSegmentVectors) + " microvectors.");
+	}
+
+	session.nMinObservedMargin = checkStreamMargin(session.nMinObservedMargin, session.inputLocation);
+	session.nRoomLeft = (session.inputLocation.nListIndex != 0)
+		? ((session.inputLocation.nOffset < effectiveListCapacity(session.inputLocation)) ? (effectiveListCapacity(session.inputLocation) - session.inputLocation.nOffset) : 0)
+		: std::numeric_limits<uint64_t>::max();
+}
+
+void CRTCContext::finishMicrovectorStreamSession()
+{
+	auto& session = m_StreamSession;
+
+	m_pScanLabSDK->checkGlobalErrorOfCard(m_CardNo);
+
+	double dLoadDurationInMS = std::chrono::duration_cast<std::chrono::duration<double, std::milli>>
+		(std::chrono::steady_clock::now() - session.tLoadStart).count();
+	uint64_t nPowerCommands = m_nMicrovectorPowerCommandsWritten - session.nPowerCommandsBefore;
+
+	m_nLastLayerSegmentCount = m_nSegmentsClosed + 1;
+	m_nLastLayerFallbackCount = m_nListSwitchFallbackCount;
+	m_nLastLayerMinMargin = session.nMinObservedMargin;
+	m_nLastLayerMaxWaitInMS = session.nMaxWaitInMS;
+
+	// The minimum observed margin is the main tuning indicator: close to MINMARGIN means
+	// PREBUFFERFRACTION has to grow; a large value means exposure time is wasted.
+	m_pDriverEnvironment->LogMessage("Wrote " + std::to_string(session.nTotal)
+		+ " microvectors in " + std::to_string(dLoadDurationInMS) + " ms ("
+		+ std::to_string((dLoadDurationInMS * 1000.0) / (double)session.nTotal)
+		+ " us/vector), " + std::to_string(nPowerCommands) + " power commands, "
+		+ std::to_string(session.nTotal + nPowerCommands) + " list positions used"
+		+ " (streamed: execution started after " + std::to_string(session.nPrebufferCount)
+		+ " vectors, min margin " + std::to_string(session.nMinObservedMargin) + " list positions"
+		+ (session.bSwitchLists
+			? (", list switching: " + std::to_string(m_nLastLayerSegmentCount) + " segments, "
+				+ std::to_string(m_nLastLayerFallbackCount) + " fallbacks, max list wait " + std::to_string(session.nMaxWaitInMS) + " ms")
+			: std::string(""))
+		+ ")");
+
+	// The last armed change (if any) fires when the card reaches the end of the segment before
+	// the last one; the plugin waits for the layer to finish before the next SetStartList.
+	m_bListChangeArmed = false;
+
+	invalidateMicrovectorPowerCache();
+
+	// From here on a BUSY drop is the end of the layer again (see CRTCRecordingInstance).
+	m_pMicrovectorStreamDownloadActive->store(false);
+
+	session.eState = eMicrovectorStreamState::Complete;
+	session.pVectors = nullptr;
+}
+
+void CRTCContext::abortMicrovectorStreamSession()
+{
+	// Stop the list before leaving: past this point the card could run into stale list
+	// memory with the laser armed. stop_execution also switches the laser signals off
+	// (manual p. 962). A list change that is still armed is consumed so that it cannot
+	// fire in the next layer.
+	m_pScanLabSDK->n_stop_execution(m_CardNo);
+	m_pMicrovectorStreamExecutionStarted->store(false);
+	m_pMicrovectorStreamDownloadActive->store(false);
+	if (m_bListChangeArmed)
+		drainPendingListChange();
+	resetListSwitchingLayerState();
+	resetMicrovectorStreamSession();
+}
+
+void CRTCContext::SetMicrovectorListSwitchingEnabled(const bool bEnabled, const LibMCDriver_ScanLab_uint32 nListCapacityLimit, const LibMCDriver_ScanLab_uint32 nTailReserve)
+{
+	uint32_t nEffectiveLimit = nListCapacityLimit;
+	if ((nEffectiveLimit != 0) && (nEffectiveLimit < (uint32_t)RTCCONTEXT_LISTSWITCH_MINCAPACITYLIMIT)) {
+		m_pDriverEnvironment->LogMessage("Microvector list capacity limit " + std::to_string(nEffectiveLimit)
+			+ " is below the minimum, clamping to " + std::to_string((uint32_t)RTCCONTEXT_LISTSWITCH_MINCAPACITYLIMIT) + " positions.");
+		nEffectiveLimit = (uint32_t)RTCCONTEXT_LISTSWITCH_MINCAPACITYLIMIT;
 	}
+
+	uint32_t nEffectiveTailReserve = (nTailReserve == 0) ? (uint32_t)RTCCONTEXT_LISTSWITCH_TAILRESERVE : nTailReserve;
+	if (nEffectiveTailReserve < (uint32_t)RTCCONTEXT_LISTCAPACITY_SAFETYMARGIN)
+		nEffectiveTailReserve = (uint32_t)RTCCONTEXT_LISTCAPACITY_SAFETYMARGIN;
+
+	if (bEnabled && !m_bMicrovectorStreamingEnabled)
+		m_pDriverEnvironment->LogWarning("Microvector list switching is enabled without the streamed download: oversized layers are still rejected until streaming is enabled.");
+
+	m_bMicrovectorListSwitchingEnabled = bEnabled;
+	m_nMicrovectorListCapacityLimit = nEffectiveLimit;
+	m_nMicrovectorSegmentTailReserve = nEffectiveTailReserve;
+}
+
+void CRTCContext::GetMicrovectorListSwitchingStatistics(LibMCDriver_ScanLab_uint32& nSegmentCount, LibMCDriver_ScanLab_uint32& nFallbackCount, LibMCDriver_ScanLab_uint64& nMinMargin, LibMCDriver_ScanLab_uint64& nMaxListWaitInMS)
+{
+	nSegmentCount = m_nLastLayerSegmentCount;
+	nFallbackCount = m_nLastLayerFallbackCount;
+	nMinMargin = m_nLastLayerMinMargin;
+	nMaxListWaitInMS = m_nLastLayerMaxWaitInMS;
 }
 
 
@@ -2766,7 +3410,7 @@ IRTCRecording* CRTCContext::PrepareRecording(const bool bKeepInMemory, const boo
 	std::string sUUID = pCryptoContext->CreateUUID();
 	// The shared flag lets executeListWithRecording() know when the streamed microvector download
 	// has already started list execution, so it must not issue a second execute_list_pos.
-	auto pInstance = std::make_shared<CRTCRecordingInstance>(sUUID, m_pScanLabSDK, m_CardNo, m_dCorrectionFactor, m_dZCorrectionFactor, RTC_CHUNKSIZE_DEFAULT, bEnableScanheadFeedback, bEnableBacktransformation, m_pMicrovectorStreamExecutionStarted);
+	auto pInstance = std::make_shared<CRTCRecordingInstance>(sUUID, m_pScanLabSDK, m_CardNo, m_dCorrectionFactor, m_dZCorrectionFactor, RTC_CHUNKSIZE_DEFAULT, bEnableScanheadFeedback, bEnableBacktransformation, m_pMicrovectorStreamExecutionStarted, m_pMicrovectorStreamDownloadActive);
 
 	std::lock_guard<std::mutex> guard(m_RecordingsMutex);
 
diff --git a/Drivers/ScanLab/Implementation/libmcdriver_scanlab_rtccontext.hpp b/Drivers/ScanLab/Implementation/libmcdriver_scanlab_rtccontext.hpp
index f70d632d5..6973c9b78 100644
--- a/Drivers/ScanLab/Implementation/libmcdriver_scanlab_rtccontext.hpp
+++ b/Drivers/ScanLab/Implementation/libmcdriver_scanlab_rtccontext.hpp
@@ -41,6 +41,7 @@ Abstract: This is the class declaration of CRTCContext
 
 #include <set>
 #include <atomic>
+#include <chrono>
 
 namespace LibMCDriver_ScanLab {
 namespace Impl {
@@ -232,6 +233,11 @@ class CRTCContext : public virtual IRTCContext, public virtual CBase {
 	// path starts list execution itself and bypasses this context.
 	std::shared_ptr<std::atomic<bool>> m_pMicrovectorStreamExecutionStarted;
 
+	// true while a stepwise microvector download (BeginMicrovectorStreaming .. completion) is in
+	// progress. Shared with CRTCRecordingInstance: its readout must not report completion while
+	// the card may just be between two segments of the layer (BUSY drops in the fallback case).
+	std::shared_ptr<std::atomic<bool>> m_pMicrovectorStreamDownloadActive;
+
 	// List index / position of the last SetStartList() call, i.e. where the currently open list
 	// begins. The streaming path starts execution from here (prologue included).
 	uint32_t m_nCurrentStartListIndex;
@@ -253,6 +259,28 @@ class CRTCContext : public virtual IRTCContext, public virtual CBase {
 	// sense for testing the overrun detector and are accepted with a logged warning.
 	double m_dMicrovectorStreamPrebufferFraction;
 
+	// --- Alternating List1/List2 execution for layers that do not fit into one list -----------
+	// Opt-in via the public SetMicrovectorListSwitchingEnabled(); only effective together with
+	// the streamed download. See the constant block in the .cpp and
+	// Plan/RTC6_DoubleBuffering_Implementation_Plan_2026-10-07.html.
+	bool m_bMicrovectorListSwitchingEnabled;
+	uint32_t m_nMicrovectorListCapacityLimit;		// 0 == full configured list size (test aid)
+	uint32_t m_nMicrovectorSegmentTailReserve;		// positions kept free at the end of a segment
+
+	// Per-layer state of the segmented download, reset by SetStartList() and on any abort.
+	uint32_t m_nCurrentOpenListIndex;				// list the PC currently writes into (1 or 2)
+	uint32_t m_nSegmentsClosed;						// set_end_of_list issued by the driver this layer
+	bool m_bListChangeArmed;						// auto_change_pos armed and not yet confirmed consumed
+	bool m_bPendingExplicitStart;					// fallback: the open list has to be started by execute_list_pos
+	uint64_t m_nMaxSegmentVectors;					// largest closed segment, sizes the wait timeout
+	uint32_t m_nListSwitchFallbackCount;
+
+	// Statistics of the last AddMicrovectorMovement call for GetMicrovectorListSwitchingStatistics().
+	uint32_t m_nLastLayerSegmentCount;
+	uint32_t m_nLastLayerFallbackCount;
+	uint64_t m_nLastLayerMinMargin;
+	uint64_t m_nLastLayerMaxWaitInMS;
+
 	LibMCEnv::PDriverEnvironment m_pDriverEnvironment;
 
 	LibMCDriver_ScanLab::eOIEOperationMode m_OIEOperationMode;
@@ -334,11 +362,100 @@ class CRTCContext : public virtual IRTCContext, public virtual CBase {
 	// paths of AddMicrovectorMovement; callers bracket it with n_reset_error / n_get_error.
 	void emitMicroVectorsToOpenList(const LibMCDriver_ScanLab::sMicroVector* pBegin, uint64_t nCount);
 
+	// Where an absolute list memory address lies: list 1 or 2 with the offset relative to that
+	// list, or list index 0 for the protected area / unconfigured lists.
+	struct sListLocation {
+		uint32_t nListIndex;
+		uint64_t nOffset;
+		uint64_t nListSize;
+	};
+	sListLocation resolveListLocation(uint64_t nAbsolutePointer) const;
+
+	// Usable positions of a list: its configured size, capped by the test-aid capacity limit.
+	uint64_t effectiveListCapacity(const sListLocation& location) const;
+
+	// Power quantization shared by writePower() and the exact capacity pre-scan, so that both
+	// agree on when two consecutive microvectors need a power command.
+	int32_t quantizeDigitalPowerValue(double dClippedPowerFactor) const;
+	void quantizePulseModulationPower(double dClippedPowerFactor, uint32_t& nHalfPeriodInBits, uint32_t& nPulseLength) const;
+
+	// Number of list positions the power commands of a microvector block take when it is written
+	// from an invalid power cache (first vector always counts). Exact for a whole block,
+	// conservative for a suffix.
+	uint64_t countMicrovectorPowerPositions(const LibMCDriver_ScanLab::sMicroVector* pBegin, uint64_t nCount) const;
+
 	// Streaming download only: reads input and output pointer (two control commands, so this
 	// drains the High Performance Mode pipeline - call sparingly) and verifies that the output
-	// pointer has not caught up with the download. Throws after stopping list execution if the
-	// margin is exhausted. Returns min(nMinObservedMargin, current margin) for diagnostics.
-	uint64_t checkStreamMargin(uint64_t nMinObservedMargin);
+	// pointer has not caught up with the download. Throws if the margin is exhausted; the caller
+	// stops list execution. Pointers in different lists cannot collide, the margin is then only
+	// diagnostic. Returns min(nMinObservedMargin, current margin) and the input pointer location.
+	uint64_t checkStreamMargin(uint64_t nMinObservedMargin, sListLocation& inputLocation);
+
+	// Segmented download helpers (see BeginMicrovectorStreaming / ContinueMicrovectorStreaming).
+	void resetListSwitchingLayerState();
+	void closeSegment(uint64_t nSegmentVectors);
+	bool armListChangeIfBusy();
+	void drainPendingListChange();
+
+	// --- Stepwise microvector download ---------------------------------------------------------
+	// One download of a layer is a session: BeginMicrovectorStreaming() opens it (and starts list
+	// execution on the streamed path), ContinueMicrovectorStreaming() advances it in time-boxed
+	// steps and never waits for the card, so the caller can interleave other work - the plugin
+	// reads out the RTC recording between the steps. AddMicrovectorMovement() is the blocking
+	// wrapper around the same state machine.
+	enum class eMicrovectorStreamState : uint32_t {
+		None = 0,				// no session
+		Writing = 1,			// Continue writes blocks
+		WaitingForList = 2,		// the next segment's list is still executing; Continue polls load_list
+		Complete = 3			// all vectors written, statistics published
+	};
+
+	struct sMicrovectorStreamSession {
+		eMicrovectorStreamState eState = eMicrovectorStreamState::None;
+
+		// The caller's buffer. The interface contract requires it to stay valid and unchanged
+		// until the session is complete or aborted; the layer is far too large to copy.
+		const LibMCDriver_ScanLab::sMicroVector* pVectors = nullptr;
+		uint64_t nTotal = 0;
+		uint64_t nWritten = 0;
+		uint64_t nSegmentVectors = 0;			// vectors written into the open segment
+		uint64_t nPrebufferCount = 0;
+		bool bExecutionStarted = false;			// streamed path: execute_list_pos has been issued
+		bool bSwitchLists = false;
+		bool bRestFitsExactly = false;
+		uint64_t nRoomLeft = 0;
+		sListLocation inputLocation = { 0, 0, 0 };
+		uint64_t nMinObservedMargin = 0;
+		uint64_t nMaxWaitInMS = 0;
+		uint64_t nPowerCommandsBefore = 0;
+		std::chrono::steady_clock::time_point tLoadStart;
+
+		// WaitingForList: which list has to be reported as processed by load_list(3, 0), since when,
+		// and the timeout derived from the largest segment so far.
+		uint32_t nWaitTargetList = 0;
+		std::chrono::steady_clock::time_point tWaitStart;
+		uint64_t nWaitTimeoutInMS = 0;
+	};
+	sMicrovectorStreamSession m_StreamSession;
+
+	void resetMicrovectorStreamSession();
+	// Writes one check block of the session, closing the segment and opening the next list first
+	// if the block does not fit. Leaves the session in WaitingForList when the next list is not
+	// free yet; the block is then written by a later call.
+	void writeNextMicrovectorBlock();
+	// Closes the current segment's list and opens the other one. The first switch opens it at
+	// once; later switches have to wait until the card has left the target list and only start
+	// that wait (state WaitingForList).
+	void beginOpenNextSegmentList();
+	// One load_list(3, 0) poll of the WaitingForList state. True once the target list is open.
+	bool pollListConsumed();
+	// Arms the next list change and makes the freed list the open one. Follows a successful poll.
+	void finishOpenNextSegmentList();
+	void completeSegmentListOpen(uint32_t nTargetList, uint64_t nWaitInMS, bool bArmed);
+	void refreshRoomAfterSegmentOpen();
+	void finishMicrovectorStreamSession();
+	// Stops list execution, consumes an armed list change and forgets the session.
+	void abortMicrovectorStreamSession();
 
 public:
 
@@ -656,6 +773,16 @@ class CRTCContext : public virtual IRTCContext, public virtual CBase {
 
 	void SetMicrovectorStreamingEnabled(const bool bEnabled, const LibMCDriver_ScanLab_uint32 nMinLayerSize, const LibMCDriver_ScanLab_double dPrebufferFraction) override;
 
+	void SetMicrovectorListSwitchingEnabled(const bool bEnabled, const LibMCDriver_ScanLab_uint32 nListCapacityLimit, const LibMCDriver_ScanLab_uint32 nTailReserve) override;
+
+	void GetMicrovectorListSwitchingStatistics(LibMCDriver_ScanLab_uint32& nSegmentCount, LibMCDriver_ScanLab_uint32& nFallbackCount, LibMCDriver_ScanLab_uint64& nMinMargin, LibMCDriver_ScanLab_uint64& nMaxListWaitInMS) override;
+
+	bool BeginMicrovectorStreaming(const LibMCDriver_ScanLab_uint64 nMicrovectorArrayBufferSize, const LibMCDriver_ScanLab::sMicroVector* pMicrovectorArrayBuffer) override;
+
+	bool ContinueMicrovectorStreaming(const LibMCDriver_ScanLab_uint32 nTimeBudgetInMS) override;
+
+	void AbortMicrovectorStreaming() override;
+
 };
 
 
diff --git a/Drivers/ScanLab/Implementation/libmcdriver_scanlab_rtcrecording.cpp b/Drivers/ScanLab/Implementation/libmcdriver_scanlab_rtcrecording.cpp
index d250886d9..fed3b7b46 100644
--- a/Drivers/ScanLab/Implementation/libmcdriver_scanlab_rtcrecording.cpp
+++ b/Drivers/ScanLab/Implementation/libmcdriver_scanlab_rtcrecording.cpp
@@ -141,6 +141,21 @@ void CRTCRecording::ExecuteListWithRecording()
 	m_pInstance->executeListWithRecording();
 }
 
+void CRTCRecording::StartListWithRecording()
+{
+	m_pInstance->startListWithRecording();
+}
+
+bool CRTCRecording::ReadRecordedData()
+{
+	return m_pInstance->readRecordedData();
+}
+
+void CRTCRecording::DiscardRecords()
+{
+	m_pInstance->discardRecords();
+}
+
 void CRTCRecording::AddRecordsToDataTable(const std::string & sChannelName, LibMCEnv::PDataTable pDataTable, const std::string & sColumnIdentifier, const std::string & sColumnDescription)
 {
 	m_pInstance->addRecordsToDataTable(sChannelName, pDataTable, sColumnIdentifier, sColumnDescription);
diff --git a/Drivers/ScanLab/Implementation/libmcdriver_scanlab_rtcrecording.hpp b/Drivers/ScanLab/Implementation/libmcdriver_scanlab_rtcrecording.hpp
index 740eaf9bf..24ea17fee 100644
--- a/Drivers/ScanLab/Implementation/libmcdriver_scanlab_rtcrecording.hpp
+++ b/Drivers/ScanLab/Implementation/libmcdriver_scanlab_rtcrecording.hpp
@@ -91,6 +91,12 @@ class CRTCRecording : public virtual IRTCRecording, public virtual CBase {
 
 	void ExecuteListWithRecording() override;
 
+	void StartListWithRecording() override;
+
+	bool ReadRecordedData() override;
+
+	void DiscardRecords() override;
+
 	void AddRecordsToDataTable(const std::string & sChannelName, LibMCEnv::PDataTable pDataTable, const std::string & sColumnIdentifier, const std::string & sColumnDescription) override;
 
 	void AddScaledRecordsToDataTable(const std::string & sChannelName, LibMCEnv::PDataTable pDataTable, const std::string & sColumnIdentifier, const std::string & sColumnDescription, const LibMCDriver_ScanLab_double dScaleFactor, const LibMCDriver_ScanLab_double dOffset) override;
diff --git a/Drivers/ScanLab/Implementation/libmcdriver_scanlab_rtcrecordinginstance.cpp b/Drivers/ScanLab/Implementation/libmcdriver_scanlab_rtcrecordinginstance.cpp
index 6645eaa18..5844b614d 100644
--- a/Drivers/ScanLab/Implementation/libmcdriver_scanlab_rtcrecordinginstance.cpp
+++ b/Drivers/ScanLab/Implementation/libmcdriver_scanlab_rtcrecordinginstance.cpp
@@ -116,6 +116,11 @@ int32_t* CRTCRecordingChunk::reserveDataBuffer(uint32_t nCount, uint32_t& nEntri
 	return &m_Buffer.at(nResultOffset);
 }
 
+void CRTCRecordingChunk::resetWriteOffset()
+{
+	m_nWriteOffset = 0;
+}
+
 
 CRTCRecordingChannel::CRTCRecordingChannel(const std::string& sChannelName, uint32_t nRTCChannelID, const LibMCDriver_ScanLab::eRTCChannelType eChannelType, size_t nChunkSize)
 	: m_sChannelName (sChannelName), 
@@ -171,6 +176,21 @@ int32_t* CRTCRecordingChannel::reserveDataBuffer(uint32_t nCount, uint32_t& nEnt
 
 }
 
+void CRTCRecordingChannel::discardRecords()
+{
+	m_nEntryCount = 0;
+
+	// The first chunk starts at entry 0 and is reused, so that the next piece does not allocate.
+	if (!m_Chunks.empty()) {
+		m_Chunks.resize(1);
+		m_pCurrentChunk = m_Chunks.front();
+		m_pCurrentChunk->resetWriteOffset();
+	}
+	else {
+		m_pCurrentChunk = nullptr;
+	}
+}
+
 uint32_t CRTCRecordingChannel::getRTCChannelID()
 {
 	return m_nRTCChannelID;
@@ -395,7 +415,7 @@ void CRTCRecordingChannel::getAllScaledRecordEntries(uint64_t nValuesBufferSize,
 /*************************************************************************************************************************
  Class definition of CRTCRecording 
 **************************************************************************************************************************/
-CRTCRecordingInstance::CRTCRecordingInstance(const std::string& sUUID, PScanLabSDK pSDK, uint32_t cardNo, double dXYCorrectionFactor, double dZCorrectionFactor, size_t nChunkSize, bool bEnableScanheadFeedback, bool bEnableBacktransformation, std::shared_ptr<std::atomic<bool>> pListExecutionAlreadyStarted)
+CRTCRecordingInstance::CRTCRecordingInstance(const std::string& sUUID, PScanLabSDK pSDK, uint32_t cardNo, double dXYCorrectionFactor, double dZCorrectionFactor, size_t nChunkSize, bool bEnableScanheadFeedback, bool bEnableBacktransformation, std::shared_ptr<std::atomic<bool>> pListExecutionAlreadyStarted, std::shared_ptr<std::atomic<bool>> pMicrovectorDownloadActive)
 	: m_pSDK (pSDK),
 	m_sUUID (sUUID),
 	m_CardNo (cardNo),
@@ -404,7 +424,13 @@ CRTCRecordingInstance::CRTCRecordingInstance(const std::string& sUUID, PScanLabS
 	m_nChunkSize (nChunkSize),
 	m_bEnableScanheadFeedback (bEnableScanheadFeedback),
 	m_bEnableBacktransformation (bEnableBacktransformation),
-	m_pListExecutionAlreadyStarted (pListExecutionAlreadyStarted)
+	m_pListExecutionAlreadyStarted (pListExecutionAlreadyStarted),
+	m_pMicrovectorDownloadActive (pMicrovectorDownloadActive),
+	m_bReadoutActive (false),
+	m_bMeasurementStarted (false),
+	m_nReadoutLastPosition (0),
+	m_bReadoutStepPending (false),
+	m_nReadoutLastBusy (0)
 
 {
 	if (pSDK.get() == nullptr)
@@ -695,10 +721,19 @@ void CRTCRecordingInstance::readRecordedDataBlockFromRTC(uint32_t DataStart, uin
 
 
 void CRTCRecordingInstance::executeListWithRecording()
+{
+	startListWithRecording();
+
+	// Blockwise data polling, until the job has finished executing and all data has been read.
+	while (!readRecordedData())
+		std::this_thread::sleep_for(std::chrono::milliseconds(10));
+}
+
+void CRTCRecordingInstance::startListWithRecording()
 {
 	// The streamed microvector download (CRTCContext::AddMicrovectorMovement) may have started
 	// list execution already; a second execute_list_pos would fail with RTC6_BUSY. In that case
-	// only the measurement readout loop below is needed.
+	// only the measurement readout is needed.
 	bool bAlreadyStarted = (m_pListExecutionAlreadyStarted.get() != nullptr)
 		&& m_pListExecutionAlreadyStarted->exchange(false);
 
@@ -707,60 +742,107 @@ void CRTCRecordingInstance::executeListWithRecording()
 		m_pSDK->checkError(m_pSDK->n_get_last_error(m_CardNo));
 	}
 
-	uint32_t Busy, Position, MesBusy, MesPosition;
-	uint32_t LastPosition = 0;
-	uint32_t Increment = 100000;
+	m_bReadoutActive = true;
+	m_bMeasurementStarted = false;
+	m_nReadoutLastPosition = 0;
+	m_bReadoutStepPending = false;
+	m_nReadoutLastBusy = 0;
+}
 
-	uint32_t nMaxMESPosition = (1UL << 22) - 1;
+bool CRTCRecordingInstance::readRecordedData()
+{
+	if (!m_bReadoutActive)
+		throw ELibMCDriver_ScanLabInterfaceException(LIBMCDRIVER_SCANLAB_ERROR_RECORDINGREADOUTNOTSTARTED);
 
-	do // Wait for measurement to start
-	{
+	uint32_t Busy, Position, MesBusy, MesPosition;
+	const uint32_t Increment = 100000;
+
+	// Entries of the measurement memory per channel. The measurement runs in ring buffer mode
+	// (RTC6_BITFLAG_SETTRIGGER_ROUNDTRIP), so MesPosition wraps to 0 at this size and the last
+	// block before the wrap ends here. Confirmed on hardware 2026-10-07: a get_waveform_offset
+	// block crossing 4194304 fails with RTC error 16 (parameter error), so the value must not
+	// be raised. A wrap with a readout position beyond this size is a hard error below.
+	const uint32_t nMeasurementMemorySize = (1UL << 22);
+	const uint32_t nMaxMESPosition = nMeasurementMemorySize - 1;
+
+	if (!m_bMeasurementStarted) {
+		// Wait for measurement to start
 		m_pSDK->n_measurement_status(m_CardNo, &MesBusy, &MesPosition);
-		std::this_thread::sleep_for(std::chrono::milliseconds(10));
-	} while ((MesBusy == 0) && (MesPosition == (uint32_t)-1));
+		if ((MesBusy == 0) && (MesPosition == (uint32_t)-1))
+			return false;
 
-	do   //blockwise data polling
-	{
+		m_bMeasurementStarted = true;
+		return false;
+	}
+
+	// The previous step has read its block. The measurement position is taken again after the
+	// pause of the caller, so that samples that arrived in between are not missed.
+	if (m_bReadoutStepPending) {
+		m_bReadoutStepPending = false;
 
-		m_pSDK->n_get_status(m_CardNo, &Busy, &Position);
 		m_pSDK->n_measurement_status(m_CardNo, &MesBusy, &MesPosition);
-		if (MesPosition > LastPosition + Increment)
-		{
-			readRecordedDataBlockFromRTC(LastPosition, LastPosition + Increment);
-			LastPosition += Increment;
-		}
-		else if (MesPosition < LastPosition)
-		{
-			if (MesPosition > nMaxMESPosition)
-				throw ELibMCDriver_ScanLabInterfaceException(LIBMCDRIVER_SCANLAB_ERROR_DATARECORDINGOVERFLOW, "data recording interval overflow: MesPosition exceeds Max MES Position");
-
-			uint32_t nBytesToRead = nMaxMESPosition - LastPosition;
-			if (nBytesToRead > Increment) {
-				readRecordedDataBlockFromRTC(LastPosition, LastPosition + Increment);
-				LastPosition += Increment;
-			}
-			else {
-				readRecordedDataBlockFromRTC(LastPosition, nMaxMESPosition);
-				LastPosition = 0;
 
-			}
+		// The job has finished executing and the readout has caught up with the measurement.
+		// While the stepwise microvector download is still running this is not the end of the
+		// layer: the card may be idle between two segments (fallback start of a segment).
+		bool bDownloadActive = (m_pMicrovectorDownloadActive.get() != nullptr) && m_pMicrovectorDownloadActive->load();
+		if (!(m_nReadoutLastBusy || (MesPosition != m_nReadoutLastPosition)) && !bDownloadActive) {
+			m_bReadoutActive = false;
+			return true;
+		}
+	}
 
+	// Blockwise data polling
+	m_pSDK->n_get_status(m_CardNo, &Busy, &Position);
+	m_pSDK->n_measurement_status(m_CardNo, &MesBusy, &MesPosition);
+	if (MesPosition > m_nReadoutLastPosition + Increment)
+	{
+		readRecordedDataBlockFromRTC(m_nReadoutLastPosition, m_nReadoutLastPosition + Increment);
+		m_nReadoutLastPosition += Increment;
+	}
+	else if (MesPosition < m_nReadoutLastPosition)
+	{
+		// The measurement has wrapped around. Read the rest of the memory up to its end, then
+		// continue from 0 in the next step.
+		if (MesPosition > nMaxMESPosition)
+			throw ELibMCDriver_ScanLabInterfaceException(LIBMCDRIVER_SCANLAB_ERROR_DATARECORDINGOVERFLOW, "data recording interval overflow: MesPosition exceeds Max MES Position");
+		if (m_nReadoutLastPosition >= nMeasurementMemorySize)
+			throw ELibMCDriver_ScanLabInterfaceException(LIBMCDRIVER_SCANLAB_ERROR_DATARECORDINGOVERFLOW, "data recording interval overflow: readout position " + std::to_string(m_nReadoutLastPosition) + " is beyond the measurement memory");
+
+		uint32_t nEntriesToRead = nMeasurementMemorySize - m_nReadoutLastPosition;
+		if (nEntriesToRead > Increment) {
+			readRecordedDataBlockFromRTC(m_nReadoutLastPosition, m_nReadoutLastPosition + Increment);
+			m_nReadoutLastPosition += Increment;
 		}
 		else {
-			//if (!MesBusy) {
-			if (!Busy) {
-				readRecordedDataBlockFromRTC(LastPosition, MesPosition);
-				LastPosition = MesPosition;
-			}
+			readRecordedDataBlockFromRTC(m_nReadoutLastPosition, nMeasurementMemorySize);
+			m_nReadoutLastPosition = 0;
+
 		}
 
-		std::this_thread::sleep_for(std::chrono::milliseconds(10));
+	}
+	else {
+		//if (!MesBusy) {
+		if (!Busy) {
+			readRecordedDataBlockFromRTC(m_nReadoutLastPosition, MesPosition);
+			m_nReadoutLastPosition = MesPosition;
+		}
+	}
 
-		m_pSDK->n_measurement_status(m_CardNo, &MesBusy, &MesPosition);
+	m_nReadoutLastBusy = Busy;
+	m_bReadoutStepPending = true;
 
-	} while (Busy || (MesPosition != LastPosition));           // Wait for the job to be finished executing
-	//} while (MesBusy || (MesPosition != LastPosition));           // Wait for the job to be finished executing
+	return false;
+}
 
+void CRTCRecordingInstance::discardRecords()
+{
+	std::lock_guard<std::mutex> lockGuard(m_Mutex);
+
+	for (auto pChannel : m_Channels) {
+		if (pChannel.get() != nullptr)
+			pChannel->discardRecords();
+	}
 }
 
 void CRTCRecordingInstance::addRecordsToDataTable(const std::string& sChannelName, LibMCEnv::PDataTable pDataTable, const std::string& sColumnIdentifier, const std::string& sColumnDescription)
diff --git a/Drivers/ScanLab/Implementation/libmcdriver_scanlab_rtcrecordinginstance.hpp b/Drivers/ScanLab/Implementation/libmcdriver_scanlab_rtcrecordinginstance.hpp
index 431d1f0ed..15d21f0be 100644
--- a/Drivers/ScanLab/Implementation/libmcdriver_scanlab_rtcrecordinginstance.hpp
+++ b/Drivers/ScanLab/Implementation/libmcdriver_scanlab_rtcrecordinginstance.hpp
@@ -93,6 +93,9 @@ class CRTCRecordingChunk
 
 	int32_t* reserveDataBuffer(uint32_t nCount, uint32_t& nEntriesToRead);
 
+	// Makes the chunk empty again, so that its buffer is reused.
+	void resetWriteOffset();
+
 
 };
 
@@ -136,6 +139,9 @@ class CRTCRecordingChannel
 	void getAllScaledRecordEntries(uint64_t nValuesBufferSize, uint64_t* pValuesNeededCount, double* pValuesBuffer, double dScaleFactor, double dOffset);
 
 	int32_t* reserveDataBuffer(uint32_t nCount, uint32_t& nEntriesToRead);
+
+	// Drops all record entries. The first chunk is kept and reused.
+	void discardRecords();
 };
 
 
@@ -170,6 +176,20 @@ class CRTCRecordingInstance {
 	// May be nullptr (no streaming-aware context).
 	std::shared_ptr<std::atomic<bool>> m_pListExecutionAlreadyStarted;
 
+	// Shared with the owning CRTCContext. Set while a stepwise microvector download is in
+	// progress: the readout then runs in parallel to the download and must not take a BUSY drop
+	// between two segments (fallback start) for the end of the layer. May be nullptr.
+	std::shared_ptr<std::atomic<bool>> m_pMicrovectorDownloadActive;
+
+	// State of the incremental readout between startListWithRecording() and the call of
+	// readRecordedData() that reports completion.
+	bool m_bReadoutActive;
+	bool m_bMeasurementStarted;
+	uint32_t m_nReadoutLastPosition;
+	// A polling step has read its block and waits for the completion check of the next call.
+	bool m_bReadoutStepPending;
+	uint32_t m_nReadoutLastBusy;
+
 	void readRecordedDataBlockFromRTC(uint32_t DataStart, uint32_t DataEnd);
 
 	static std::string normalizeChannelName(const std::string& sChannelName);
@@ -178,7 +198,7 @@ class CRTCRecordingInstance {
 
 public:
 
-	CRTCRecordingInstance(const std::string & sUUID, PScanLabSDK pSDK, uint32_t cardNo, double dXYCorrectionFactor, double dZCorrectionFactor, size_t nChunkSize, bool bEnableScanheadFeedback, bool bEnableBacktransformation, std::shared_ptr<std::atomic<bool>> pListExecutionAlreadyStarted);
+	CRTCRecordingInstance(const std::string & sUUID, PScanLabSDK pSDK, uint32_t cardNo, double dXYCorrectionFactor, double dZCorrectionFactor, size_t nChunkSize, bool bEnableScanheadFeedback, bool bEnableBacktransformation, std::shared_ptr<std::atomic<bool>> pListExecutionAlreadyStarted, std::shared_ptr<std::atomic<bool>> pMicrovectorDownloadActive);
 
 	virtual ~CRTCRecordingInstance();
 	
@@ -206,6 +226,17 @@ class CRTCRecordingInstance {
 
 	void executeListWithRecording();
 
+	// Starts list execution and the incremental readout. Returns immediately.
+	void startListWithRecording();
+
+	// Reads at most one block of recorded data from the card into the channels. Returns true
+	// once the list has finished and all recorded data has been read. Does not wait: the caller
+	// pauses between calls, 10 ms in executeListWithRecording().
+	bool readRecordedData();
+
+	// Drops the record entries of all channels and keeps channels and readout position.
+	void discardRecords();
+
 	void addRecordsToDataTable(const std::string & sChannelName, LibMCEnv::PDataTable pDataTable, const std::string & sColumnIdentifier, const std::string & sColumnDescription);
 
 	void addScaledRecordsToDataTable(const std::string & sChannelName, LibMCEnv::PDataTable pDataTable, const std::string & sColumnIdentifier, const std::string & sColumnDescription, const LibMCDriver_ScanLab_double dScaleFactor, const LibMCDriver_ScanLab_double dOffset);
diff --git a/Drivers/ScanLab/Implementation/libmcdriver_scanlab_sdk.cpp b/Drivers/ScanLab/Implementation/libmcdriver_scanlab_sdk.cpp
index d62e7dc99..f8283f69f 100644
--- a/Drivers/ScanLab/Implementation/libmcdriver_scanlab_sdk.cpp
+++ b/Drivers/ScanLab/Implementation/libmcdriver_scanlab_sdk.cpp
@@ -235,6 +235,11 @@ CScanLabSDK::CScanLabSDK(const std::string& sDLLNameUTF8)
 	this->ptr_n_long_delay = (PScanLabPtr_n_long_delay)_loadScanLabAddress(hLibrary, "n_long_delay");
 	this->ptr_n_get_status = (PScanLabPtr_n_get_status)_loadScanLabAddress(hLibrary, "n_get_status");
 	this->ptr_n_get_input_pointer = (PScanLabPtr_n_get_input_pointer)_loadScanLabAddress(hLibrary, "n_get_input_pointer");
+	this->ptr_n_load_list = (PScanLabPtr_n_load_list)_loadScanLabAddress(hLibrary, "n_load_list");
+	this->ptr_n_read_status = (PScanLabPtr_n_read_status)_loadScanLabAddress(hLibrary, "n_read_status");
+	this->ptr_n_get_list_space = (PScanLabPtr_n_get_list_space)_loadScanLabAddress(hLibrary, "n_get_list_space");
+	this->ptr_n_get_list_pointer = (PScanLabPtr_n_get_list_pointer)_loadScanLabAddress(hLibrary, "n_get_list_pointer");
+	this->ptr_n_get_out_pointer = (PScanLabPtr_n_get_out_pointer)_loadScanLabAddress(hLibrary, "n_get_out_pointer");
 	this->ptr_n_set_laser_delays = (PScanLabPtr_n_set_laser_delays)_loadScanLabAddress(hLibrary, "n_set_laser_delays");
 	this->ptr_n_set_start_list_pos = (PScanLabPtr_n_set_start_list_pos)_loadScanLabAddress(hLibrary, "n_set_start_list_pos");
 	this->ptr_n_set_defocus_list = (PScanLabPtr_n_set_defocus_list)_loadScanLabAddress(hLibrary, "n_set_defocus_list");
@@ -457,6 +462,11 @@ void CScanLabSDK::resetFunctionPtrs()
 	ptr_n_long_delay = nullptr;
 	ptr_n_get_status = nullptr;
 	ptr_n_get_input_pointer = nullptr;
+	ptr_n_load_list = nullptr;
+	ptr_n_read_status = nullptr;
+	ptr_n_get_list_space = nullptr;
+	ptr_n_get_list_pointer = nullptr;
+	ptr_n_get_out_pointer = nullptr;
 	ptr_n_set_laser_delays = nullptr;
 	ptr_n_set_start_list_pos = nullptr;
 	ptr_n_set_defocus_list = nullptr;
@@ -974,6 +984,46 @@ uint32_t CScanLabSDK::n_get_input_pointer(uint32_t nCardNo)
 	return ptr_n_get_input_pointer(nCardNo);
 }
 
+uint32_t CScanLabSDK::n_load_list(uint32_t nCardNo, uint32_t nListNo, uint32_t nPos)
+{
+	if (m_pLogJournal.get() != nullptr)
+		m_pLogJournal->logCall("n_load_list", std::to_string(nCardNo) + ", " + std::to_string(nListNo) + ", " + std::to_string(nPos));
+
+	return ptr_n_load_list(nCardNo, nListNo, nPos);
+}
+
+uint32_t CScanLabSDK::n_read_status(uint32_t nCardNo)
+{
+	if (m_pLogJournal.get() != nullptr)
+		m_pLogJournal->logCall("n_read_status", std::to_string(nCardNo));
+
+	return ptr_n_read_status(nCardNo);
+}
+
+uint32_t CScanLabSDK::n_get_list_space(uint32_t nCardNo)
+{
+	if (m_pLogJournal.get() != nullptr)
+		m_pLogJournal->logCall("n_get_list_space", std::to_string(nCardNo));
+
+	return ptr_n_get_list_space(nCardNo);
+}
+
+void CScanLabSDK::n_get_list_pointer(uint32_t nCardNo, uint32_t* pnListNo, uint32_t* pnPos)
+{
+	if (m_pLogJournal.get() != nullptr)
+		m_pLogJournal->logCall("n_get_list_pointer", std::to_string(nCardNo) + ", &" + m_pLogJournal->defineUint32Variable("nListNo") + ", &" + m_pLogJournal->defineUint32Variable("nListPos"));
+
+	ptr_n_get_list_pointer(nCardNo, pnListNo, pnPos);
+}
+
+uint32_t CScanLabSDK::n_get_out_pointer(uint32_t nCardNo)
+{
+	if (m_pLogJournal.get() != nullptr)
+		m_pLogJournal->logCall("n_get_out_pointer", std::to_string(nCardNo));
+
+	return ptr_n_get_out_pointer(nCardNo);
+}
+
 void CScanLabSDK::n_set_laser_delays(uint32_t nCardNo, int32_t nLaserOnDelay, uint32_t nLaserOffDelay)
 {
 	if (m_pLogJournal.get() != nullptr)
diff --git a/Drivers/ScanLab/Implementation/libmcdriver_scanlab_sdk.hpp b/Drivers/ScanLab/Implementation/libmcdriver_scanlab_sdk.hpp
index 03e76ac04..cf864bd46 100644
--- a/Drivers/ScanLab/Implementation/libmcdriver_scanlab_sdk.hpp
+++ b/Drivers/ScanLab/Implementation/libmcdriver_scanlab_sdk.hpp
@@ -117,6 +117,12 @@ namespace LibMCDriver_ScanLab {
 		typedef void(SCANLAB_CALLINGCONVENTION* PScanLabPtr_n_long_delay) (uint32_t nCardNo, uint32_t nDelay);
 		typedef void(SCANLAB_CALLINGCONVENTION* PScanLabPtr_n_get_status) (uint32_t nCardNo, uint32_t * pnStatus, uint32_t * pnPos);
 		typedef uint32_t(SCANLAB_CALLINGCONVENTION* PScanLabPtr_n_get_input_pointer) (uint32_t nCardNo);
+		// List handling for the alternating List1/List2 microvector download (RTC6 manual p. 482, 483, 504, 599, 702).
+		typedef uint32_t(SCANLAB_CALLINGCONVENTION* PScanLabPtr_n_load_list) (uint32_t nCardNo, uint32_t nListNo, uint32_t nPos);
+		typedef uint32_t(SCANLAB_CALLINGCONVENTION* PScanLabPtr_n_read_status) (uint32_t nCardNo);
+		typedef uint32_t(SCANLAB_CALLINGCONVENTION* PScanLabPtr_n_get_list_space) (uint32_t nCardNo);
+		typedef void(SCANLAB_CALLINGCONVENTION* PScanLabPtr_n_get_list_pointer) (uint32_t nCardNo, uint32_t * pnListNo, uint32_t * pnPos);
+		typedef uint32_t(SCANLAB_CALLINGCONVENTION* PScanLabPtr_n_get_out_pointer) (uint32_t nCardNo);
 		typedef void(SCANLAB_CALLINGCONVENTION* PScanLabPtr_n_set_laser_delays) (uint32_t nCardNo, int32_t nLaserOnDelay, uint32_t nLaserOffDelay);
 		typedef void(SCANLAB_CALLINGCONVENTION* PScanLabPtr_n_set_start_list_pos) (uint32_t nCardNo, uint32_t nListNo, uint32_t nListPos);
 		typedef void(SCANLAB_CALLINGCONVENTION* PScanLabPtr_n_set_defocus_list) (uint32_t nCardNo, int32_t nShift);
@@ -321,6 +327,11 @@ namespace LibMCDriver_ScanLab {
 			PScanLabPtr_n_long_delay ptr_n_long_delay = nullptr;
 			PScanLabPtr_n_get_status ptr_n_get_status = nullptr;
 			PScanLabPtr_n_get_input_pointer ptr_n_get_input_pointer = nullptr;
+			PScanLabPtr_n_load_list ptr_n_load_list = nullptr;
+			PScanLabPtr_n_read_status ptr_n_read_status = nullptr;
+			PScanLabPtr_n_get_list_space ptr_n_get_list_space = nullptr;
+			PScanLabPtr_n_get_list_pointer ptr_n_get_list_pointer = nullptr;
+			PScanLabPtr_n_get_out_pointer ptr_n_get_out_pointer = nullptr;
 			PScanLabPtr_n_set_laser_delays ptr_n_set_laser_delays = nullptr;
 			PScanLabPtr_n_set_start_list_pos ptr_n_set_start_list_pos = nullptr;
 			PScanLabPtr_n_set_defocus_list ptr_n_set_defocus_list = nullptr;
@@ -488,6 +499,16 @@ namespace LibMCDriver_ScanLab {
 			void n_long_delay (uint32_t nCardNo, uint32_t nDelay);
 			void n_get_status (uint32_t nCardNo, uint32_t* pnStatus, uint32_t* pnPos);
 			uint32_t n_get_input_pointer (uint32_t nCardNo);
+			// Returns the number of the opened list (1 or 2) or 0 if no list could be opened (manual p. 599).
+			uint32_t n_load_list (uint32_t nCardNo, uint32_t nListNo, uint32_t nPos);
+			// LOAD/READY/BUSY/USED list status bits of both lists (manual p. 702).
+			uint32_t n_read_status (uint32_t nCardNo);
+			// Free list positions from the input pointer to the end of the open list (manual p. 483).
+			uint32_t n_get_list_space (uint32_t nCardNo);
+			// List number and list-relative position of the input pointer (manual p. 482).
+			void n_get_list_pointer (uint32_t nCardNo, uint32_t* pnListNo, uint32_t* pnPos);
+			// List-relative position of the output pointer (manual p. 504).
+			uint32_t n_get_out_pointer (uint32_t nCardNo);
 			void n_set_laser_delays (uint32_t nCardNo, int32_t nLaserOnDelay, uint32_t nLaserOffDelay);
 			void n_set_start_list_pos (uint32_t nCardNo, uint32_t nListNo, uint32_t nListPos);
 			void n_set_defocus_list (uint32_t nCardNo, int32_t nShift);
diff --git a/Drivers/ScanLab/Interfaces/libmcdriver_scanlab_abi.hpp b/Drivers/ScanLab/Interfaces/libmcdriver_scanlab_abi.hpp
index 374cacaab..e49edc330 100644
--- a/Drivers/ScanLab/Interfaces/libmcdriver_scanlab_abi.hpp
+++ b/Drivers/ScanLab/Interfaces/libmcdriver_scanlab_abi.hpp
@@ -571,6 +571,31 @@ LIBMCDRIVER_SCANLAB_DECLSPEC LibMCDriver_ScanLabResult libmcdriver_scanlab_rtcre
 */
 LIBMCDRIVER_SCANLAB_DECLSPEC LibMCDriver_ScanLabResult libmcdriver_scanlab_rtcrecording_addtargetpositionstodatatable(LibMCDriver_ScanLab_RTCRecording pRTCRecording, LibMCEnv_DataTable pDataTable, const char * pColumnIdentifierX, const char * pColumnDescriptionX, const char * pColumnIdentifierY, const char * pColumnDescriptionY);
 
+/**
+* Starts the execution of the list and the incremental readout of the recorded data. Returns immediately. ReadRecordedData MUST be called repeatedly afterwards until it reports that the recording is complete.
+*
+* @param[in] pRTCRecording - RTCRecording instance.
+* @return error code or 0 (success)
+*/
+LIBMCDRIVER_SCANLAB_DECLSPEC LibMCDriver_ScanLabResult libmcdriver_scanlab_rtcrecording_startlistwithrecording(LibMCDriver_ScanLab_RTCRecording pRTCRecording);
+
+/**
+* Reads the data that the RTC card has recorded since the last call into the channels. Does not wait for new data. Fails if StartListWithRecording has not been called.
+*
+* @param[in] pRTCRecording - RTCRecording instance.
+* @param[out] pRecordingComplete - True if the list has finished and all recorded data has been read.
+* @return error code or 0 (success)
+*/
+LIBMCDRIVER_SCANLAB_DECLSPEC LibMCDriver_ScanLabResult libmcdriver_scanlab_rtcrecording_readrecordeddata(LibMCDriver_ScanLab_RTCRecording pRTCRecording, bool * pRecordingComplete);
+
+/**
+* Drops the record entries of all channels. The channels and the readout position are kept, so that the recorded data can be handed on piece by piece between calls to ReadRecordedData.
+*
+* @param[in] pRTCRecording - RTCRecording instance.
+* @return error code or 0 (success)
+*/
+LIBMCDRIVER_SCANLAB_DECLSPEC LibMCDriver_ScanLabResult libmcdriver_scanlab_rtcrecording_discardrecords(LibMCDriver_ScanLab_RTCRecording pRTCRecording);
+
 /*************************************************************************************************************************
  Class definition for GPIOSequence
 **************************************************************************************************************************/
@@ -1425,6 +1450,58 @@ LIBMCDRIVER_SCANLAB_DECLSPEC LibMCDriver_ScanLabResult libmcdriver_scanlab_rtcco
 */
 LIBMCDRIVER_SCANLAB_DECLSPEC LibMCDriver_ScanLabResult libmcdriver_scanlab_rtccontext_setmicrovectorstreamingenabled(LibMCDriver_ScanLab_RTCContext pRTCContext, bool bEnabled, LibMCDriver_ScanLab_uint32 nMinLayerSize, LibMCDriver_ScanLab_double dPrebufferFraction);
 
+/**
+* Enables alternating List1/List2 execution for microvector layers that do not fit into one RTC6 list. AddMicrovectorMovement then splits the layer into segments, closes each full list with set_end_of_list, arms an automatic list change and continues in the other list while the laser keeps marking. Requires the streamed download (SetMicrovectorStreamingEnabled). Default is disabled.
+*
+* @param[in] pRTCContext - RTCContext instance.
+* @param[in] bEnabled - True to execute oversized layers alternately from List1 and List2.
+* @param[in] nListCapacityLimit - Test aid: maximum list positions used per segment, 0 = full configured list size. Values below 84096 (four check blocks in the worst case plus the tail reserve) are clamped to it.
+* @param[in] nTailReserve - List positions kept free at the end of every segment for set_end_of_list and the layer epilogue. 0 = built-in default of 4096.
+* @return error code or 0 (success)
+*/
+LIBMCDRIVER_SCANLAB_DECLSPEC LibMCDriver_ScanLabResult libmcdriver_scanlab_rtccontext_setmicrovectorlistswitchingenabled(LibMCDriver_ScanLab_RTCContext pRTCContext, bool bEnabled, LibMCDriver_ScanLab_uint32 nListCapacityLimit, LibMCDriver_ScanLab_uint32 nTailReserve);
+
+/**
+* Returns counters of the last AddMicrovectorMovement call: number of segments the layer was split into, number of segments that had to be started explicitly because the card had already finished the previous one, the minimum observed download margin and the longest wait for a list to become free.
+*
+* @param[in] pRTCContext - RTCContext instance.
+* @param[out] pSegmentCount - Segments written (1 = no list switch).
+* @param[out] pFallbackCount - Segments started explicitly instead of by automatic list change.
+* @param[out] pMinMargin - Minimum observed distance between input and output pointer in list positions.
+* @param[out] pMaxListWaitInMS - Longest wait for the previous list to be consumed before it could be reused, in milliseconds.
+* @return error code or 0 (success)
+*/
+LIBMCDRIVER_SCANLAB_DECLSPEC LibMCDriver_ScanLabResult libmcdriver_scanlab_rtccontext_getmicrovectorlistswitchingstatistics(LibMCDriver_ScanLab_RTCContext pRTCContext, LibMCDriver_ScanLab_uint32 * pSegmentCount, LibMCDriver_ScanLab_uint32 * pFallbackCount, LibMCDriver_ScanLab_uint64 * pMinMargin, LibMCDriver_ScanLab_uint64 * pMaxListWaitInMS);
+
+/**
+* Stepwise variant of AddMicrovectorMovement, same semantics and configuration. Writes the first part of the layer and, on the streamed path, starts list execution. The rest is written by ContinueMicrovectorStreaming calls; between two calls the caller is free to do other work, e.g. read out the RTC recording while the card is marking. The microvector buffer MUST stay valid and unchanged until ContinueMicrovectorStreaming has returned true or AbortMicrovectorStreaming has been called. Small layers and the sequential download are written completely by this call.
+*
+* @param[in] pRTCContext - RTCContext instance.
+* @param[in] nMicrovectorArrayBufferSize - Number of elements in buffer
+* @param[in] pMicrovectorArrayBuffer - MicroVector buffer of Microvector array to execute. Must outlive the streaming session.
+* @param[out] pExecutionStarted - True if this call has started list execution (streamed download). False if the layer was written without starting execution; the caller executes the list as usual afterwards.
+* @return error code or 0 (success)
+*/
+LIBMCDRIVER_SCANLAB_DECLSPEC LibMCDriver_ScanLabResult libmcdriver_scanlab_rtccontext_beginmicrovectorstreaming(LibMCDriver_ScanLab_RTCContext pRTCContext, LibMCDriver_ScanLab_uint64 nMicrovectorArrayBufferSize, const LibMCDriver_ScanLab::sMicroVector * pMicrovectorArrayBuffer, bool * pExecutionStarted);
+
+/**
+* Writes the next part of the layer passed to BeginMicrovectorStreaming. Returns as soon as the time budget is used up, the download has to wait for the card to free a list, or the layer is complete. Never waits for the card. Fails if no streaming session has been begun.
+*
+* @param[in] pRTCContext - RTCContext instance.
+* @param[in] nTimeBudgetInMS - Upper bound for the time spent writing in this call, in milliseconds. 0 writes a single block.
+* @param[out] pComplete - True once all microvectors have been written. The session is finished then; further calls return true without doing anything.
+* @return error code or 0 (success)
+*/
+LIBMCDRIVER_SCANLAB_DECLSPEC LibMCDriver_ScanLabResult libmcdriver_scanlab_rtccontext_continuemicrovectorstreaming(LibMCDriver_ScanLab_RTCContext pRTCContext, LibMCDriver_ScanLab_uint32 nTimeBudgetInMS, bool * pComplete);
+
+/**
+* Ends a streaming session before completion, e.g. when the caller fails between two ContinueMicrovectorStreaming calls. Stops list execution, consumes an armed list change and resets the segmentation state. Does nothing if no session is active.
+*
+* @param[in] pRTCContext - RTCContext instance.
+* @return error code or 0 (success)
+*/
+LIBMCDRIVER_SCANLAB_DECLSPEC LibMCDriver_ScanLabResult libmcdriver_scanlab_rtccontext_abortmicrovectorstreaming(LibMCDriver_ScanLab_RTCContext pRTCContext);
+
 /**
 * Returns the currently set free variable.
 *
diff --git a/Drivers/ScanLab/Interfaces/libmcdriver_scanlab_interfaces.hpp b/Drivers/ScanLab/Interfaces/libmcdriver_scanlab_interfaces.hpp
index 5bd811407..f10433ca0 100644
--- a/Drivers/ScanLab/Interfaces/libmcdriver_scanlab_interfaces.hpp
+++ b/Drivers/ScanLab/Interfaces/libmcdriver_scanlab_interfaces.hpp
@@ -786,6 +786,22 @@ class IRTCRecording : public virtual IBase {
 	*/
 	virtual void AddTargetPositionsToDataTable(LibMCEnv::PDataTable pDataTable, const std::string & sColumnIdentifierX, const std::string & sColumnDescriptionX, const std::string & sColumnIdentifierY, const std::string & sColumnDescriptionY) = 0;
 
+	/**
+	* IRTCRecording::StartListWithRecording - Starts the execution of the list and the incremental readout of the recorded data. Returns immediately. ReadRecordedData MUST be called repeatedly afterwards until it reports that the recording is complete.
+	*/
+	virtual void StartListWithRecording() = 0;
+
+	/**
+	* IRTCRecording::ReadRecordedData - Reads the data that the RTC card has recorded since the last call into the channels. Does not wait for new data. Fails if StartListWithRecording has not been called.
+	* @return True if the list has finished and all recorded data has been read.
+	*/
+	virtual bool ReadRecordedData() = 0;
+
+	/**
+	* IRTCRecording::DiscardRecords - Drops the record entries of all channels. The channels and the readout position are kept, so that the recorded data can be handed on piece by piece between calls to ReadRecordedData.
+	*/
+	virtual void DiscardRecords() = 0;
+
 };
 
 typedef IBaseSharedPtr<IRTCRecording> PIRTCRecording;
@@ -1416,6 +1432,43 @@ class IRTCContext : public virtual IBase {
 	*/
 	virtual void SetMicrovectorStreamingEnabled(const bool bEnabled, const LibMCDriver_ScanLab_uint32 nMinLayerSize, const LibMCDriver_ScanLab_double dPrebufferFraction) = 0;
 
+	/**
+	* IRTCContext::SetMicrovectorListSwitchingEnabled - Enables alternating List1/List2 execution for microvector layers that do not fit into one RTC6 list. AddMicrovectorMovement then splits the layer into segments, closes each full list with set_end_of_list, arms an automatic list change and continues in the other list while the laser keeps marking. Requires the streamed download (SetMicrovectorStreamingEnabled). Default is disabled.
+	* @param[in] bEnabled - True to execute oversized layers alternately from List1 and List2.
+	* @param[in] nListCapacityLimit - Test aid: maximum list positions used per segment, 0 = full configured list size. Values below 84096 (four check blocks in the worst case plus the tail reserve) are clamped to it.
+	* @param[in] nTailReserve - List positions kept free at the end of every segment for set_end_of_list and the layer epilogue. 0 = built-in default of 4096.
+	*/
+	virtual void SetMicrovectorListSwitchingEnabled(const bool bEnabled, const LibMCDriver_ScanLab_uint32 nListCapacityLimit, const LibMCDriver_ScanLab_uint32 nTailReserve) = 0;
+
+	/**
+	* IRTCContext::GetMicrovectorListSwitchingStatistics - Returns counters of the last AddMicrovectorMovement call: number of segments the layer was split into, number of segments that had to be started explicitly because the card had already finished the previous one, the minimum observed download margin and the longest wait for a list to become free.
+	* @param[out] nSegmentCount - Segments written (1 = no list switch).
+	* @param[out] nFallbackCount - Segments started explicitly instead of by automatic list change.
+	* @param[out] nMinMargin - Minimum observed distance between input and output pointer in list positions.
+	* @param[out] nMaxListWaitInMS - Longest wait for the previous list to be consumed before it could be reused, in milliseconds.
+	*/
+	virtual void GetMicrovectorListSwitchingStatistics(LibMCDriver_ScanLab_uint32 & nSegmentCount, LibMCDriver_ScanLab_uint32 & nFallbackCount, LibMCDriver_ScanLab_uint64 & nMinMargin, LibMCDriver_ScanLab_uint64 & nMaxListWaitInMS) = 0;
+
+	/**
+	* IRTCContext::BeginMicrovectorStreaming - Stepwise variant of AddMicrovectorMovement, same semantics and configuration. Writes the first part of the layer and, on the streamed path, starts list execution. The rest is written by ContinueMicrovectorStreaming calls; between two calls the caller is free to do other work, e.g. read out the RTC recording while the card is marking. The microvector buffer MUST stay valid and unchanged until ContinueMicrovectorStreaming has returned true or AbortMicrovectorStreaming has been called. Small layers and the sequential download are written completely by this call.
+	* @param[in] nMicrovectorArrayBufferSize - Number of elements in buffer
+	* @param[in] pMicrovectorArrayBuffer - Microvector array to execute. Must outlive the streaming session.
+	* @return True if this call has started list execution (streamed download). False if the layer was written without starting execution; the caller executes the list as usual afterwards.
+	*/
+	virtual bool BeginMicrovectorStreaming(const LibMCDriver_ScanLab_uint64 nMicrovectorArrayBufferSize, const LibMCDriver_ScanLab::sMicroVector * pMicrovectorArrayBuffer) = 0;
+
+	/**
+	* IRTCContext::ContinueMicrovectorStreaming - Writes the next part of the layer passed to BeginMicrovectorStreaming. Returns as soon as the time budget is used up, the download has to wait for the card to free a list, or the layer is complete. Never waits for the card. Fails if no streaming session has been begun.
+	* @param[in] nTimeBudgetInMS - Upper bound for the time spent writing in this call, in milliseconds. 0 writes a single block.
+	* @return True once all microvectors have been written. The session is finished then; further calls return true without doing anything.
+	*/
+	virtual bool ContinueMicrovectorStreaming(const LibMCDriver_ScanLab_uint32 nTimeBudgetInMS) = 0;
+
+	/**
+	* IRTCContext::AbortMicrovectorStreaming - Ends a streaming session before completion, e.g. when the caller fails between two ContinueMicrovectorStreaming calls. Stops list execution, consumes an armed list change and resets the segmentation state. Does nothing if no session is active.
+	*/
+	virtual void AbortMicrovectorStreaming() = 0;
+
 	/**
 	* IRTCContext::GetCurrentFreeVariable - Returns the currently set free variable.
 	* @param[in] nVariableNo - Number of the variable (0-7).
diff --git a/Drivers/ScanLab/Interfaces/libmcdriver_scanlab_interfacewrapper.cpp b/Drivers/ScanLab/Interfaces/libmcdriver_scanlab_interfacewrapper.cpp
index 7556a3acf..f823cdbb5 100644
--- a/Drivers/ScanLab/Interfaces/libmcdriver_scanlab_interfacewrapper.cpp
+++ b/Drivers/ScanLab/Interfaces/libmcdriver_scanlab_interfacewrapper.cpp
@@ -1491,6 +1491,80 @@ LibMCDriver_ScanLabResult libmcdriver_scanlab_rtcrecording_addtargetpositionstod
 	}
 }
 
+LibMCDriver_ScanLabResult libmcdriver_scanlab_rtcrecording_startlistwithrecording(LibMCDriver_ScanLab_RTCRecording pRTCRecording)
+{
+	IBase* pIBaseClass = (IBase *)pRTCRecording;
+
+	try {
+		IRTCRecording* pIRTCRecording = dynamic_cast<IRTCRecording*>(pIBaseClass);
+		if (!pIRTCRecording)
+			throw ELibMCDriver_ScanLabInterfaceException(LIBMCDRIVER_SCANLAB_ERROR_INVALIDCAST);
+		
+		pIRTCRecording->StartListWithRecording();
+
+		return LIBMCDRIVER_SCANLAB_SUCCESS;
+	}
+	catch (ELibMCDriver_ScanLabInterfaceException & Exception) {
+		return handleLibMCDriver_ScanLabException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCDriver_ScanLabResult libmcdriver_scanlab_rtcrecording_readrecordeddata(LibMCDriver_ScanLab_RTCRecording pRTCRecording, bool * pRecordingComplete)
+{
+	IBase* pIBaseClass = (IBase *)pRTCRecording;
+
+	try {
+		if (pRecordingComplete == nullptr)
+			throw ELibMCDriver_ScanLabInterfaceException (LIBMCDRIVER_SCANLAB_ERROR_INVALIDPARAM);
+		IRTCRecording* pIRTCRecording = dynamic_cast<IRTCRecording*>(pIBaseClass);
+		if (!pIRTCRecording)
+			throw ELibMCDriver_ScanLabInterfaceException(LIBMCDRIVER_SCANLAB_ERROR_INVALIDCAST);
+		
+		*pRecordingComplete = pIRTCRecording->ReadRecordedData();
+
+		return LIBMCDRIVER_SCANLAB_SUCCESS;
+	}
+	catch (ELibMCDriver_ScanLabInterfaceException & Exception) {
+		return handleLibMCDriver_ScanLabException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCDriver_ScanLabResult libmcdriver_scanlab_rtcrecording_discardrecords(LibMCDriver_ScanLab_RTCRecording pRTCRecording)
+{
+	IBase* pIBaseClass = (IBase *)pRTCRecording;
+
+	try {
+		IRTCRecording* pIRTCRecording = dynamic_cast<IRTCRecording*>(pIBaseClass);
+		if (!pIRTCRecording)
+			throw ELibMCDriver_ScanLabInterfaceException(LIBMCDRIVER_SCANLAB_ERROR_INVALIDCAST);
+		
+		pIRTCRecording->DiscardRecords();
+
+		return LIBMCDRIVER_SCANLAB_SUCCESS;
+	}
+	catch (ELibMCDriver_ScanLabInterfaceException & Exception) {
+		return handleLibMCDriver_ScanLabException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
 
 /*************************************************************************************************************************
  Class implementation for GPIOSequence
@@ -3656,6 +3730,140 @@ LibMCDriver_ScanLabResult libmcdriver_scanlab_rtccontext_setmicrovectorstreaming
 	}
 }
 
+LibMCDriver_ScanLabResult libmcdriver_scanlab_rtccontext_setmicrovectorlistswitchingenabled(LibMCDriver_ScanLab_RTCContext pRTCContext, bool bEnabled, LibMCDriver_ScanLab_uint32 nListCapacityLimit, LibMCDriver_ScanLab_uint32 nTailReserve)
+{
+	IBase* pIBaseClass = (IBase *)pRTCContext;
+
+	try {
+		IRTCContext* pIRTCContext = dynamic_cast<IRTCContext*>(pIBaseClass);
+		if (!pIRTCContext)
+			throw ELibMCDriver_ScanLabInterfaceException(LIBMCDRIVER_SCANLAB_ERROR_INVALIDCAST);
+		
+		pIRTCContext->SetMicrovectorListSwitchingEnabled(bEnabled, nListCapacityLimit, nTailReserve);
+
+		return LIBMCDRIVER_SCANLAB_SUCCESS;
+	}
+	catch (ELibMCDriver_ScanLabInterfaceException & Exception) {
+		return handleLibMCDriver_ScanLabException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCDriver_ScanLabResult libmcdriver_scanlab_rtccontext_getmicrovectorlistswitchingstatistics(LibMCDriver_ScanLab_RTCContext pRTCContext, LibMCDriver_ScanLab_uint32 * pSegmentCount, LibMCDriver_ScanLab_uint32 * pFallbackCount, LibMCDriver_ScanLab_uint64 * pMinMargin, LibMCDriver_ScanLab_uint64 * pMaxListWaitInMS)
+{
+	IBase* pIBaseClass = (IBase *)pRTCContext;
+
+	try {
+		if (!pSegmentCount)
+			throw ELibMCDriver_ScanLabInterfaceException (LIBMCDRIVER_SCANLAB_ERROR_INVALIDPARAM);
+		if (!pFallbackCount)
+			throw ELibMCDriver_ScanLabInterfaceException (LIBMCDRIVER_SCANLAB_ERROR_INVALIDPARAM);
+		if (!pMinMargin)
+			throw ELibMCDriver_ScanLabInterfaceException (LIBMCDRIVER_SCANLAB_ERROR_INVALIDPARAM);
+		if (!pMaxListWaitInMS)
+			throw ELibMCDriver_ScanLabInterfaceException (LIBMCDRIVER_SCANLAB_ERROR_INVALIDPARAM);
+		IRTCContext* pIRTCContext = dynamic_cast<IRTCContext*>(pIBaseClass);
+		if (!pIRTCContext)
+			throw ELibMCDriver_ScanLabInterfaceException(LIBMCDRIVER_SCANLAB_ERROR_INVALIDCAST);
+		
+		pIRTCContext->GetMicrovectorListSwitchingStatistics(*pSegmentCount, *pFallbackCount, *pMinMargin, *pMaxListWaitInMS);
+
+		return LIBMCDRIVER_SCANLAB_SUCCESS;
+	}
+	catch (ELibMCDriver_ScanLabInterfaceException & Exception) {
+		return handleLibMCDriver_ScanLabException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCDriver_ScanLabResult libmcdriver_scanlab_rtccontext_beginmicrovectorstreaming(LibMCDriver_ScanLab_RTCContext pRTCContext, LibMCDriver_ScanLab_uint64 nMicrovectorArrayBufferSize, const sLibMCDriver_ScanLabMicroVector * pMicrovectorArrayBuffer, bool * pExecutionStarted)
+{
+	IBase* pIBaseClass = (IBase *)pRTCContext;
+
+	try {
+		if ( (!pMicrovectorArrayBuffer) && (nMicrovectorArrayBufferSize>0))
+			throw ELibMCDriver_ScanLabInterfaceException (LIBMCDRIVER_SCANLAB_ERROR_INVALIDPARAM);
+		if (pExecutionStarted == nullptr)
+			throw ELibMCDriver_ScanLabInterfaceException (LIBMCDRIVER_SCANLAB_ERROR_INVALIDPARAM);
+		IRTCContext* pIRTCContext = dynamic_cast<IRTCContext*>(pIBaseClass);
+		if (!pIRTCContext)
+			throw ELibMCDriver_ScanLabInterfaceException(LIBMCDRIVER_SCANLAB_ERROR_INVALIDCAST);
+		
+		*pExecutionStarted = pIRTCContext->BeginMicrovectorStreaming(nMicrovectorArrayBufferSize, pMicrovectorArrayBuffer);
+
+		return LIBMCDRIVER_SCANLAB_SUCCESS;
+	}
+	catch (ELibMCDriver_ScanLabInterfaceException & Exception) {
+		return handleLibMCDriver_ScanLabException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCDriver_ScanLabResult libmcdriver_scanlab_rtccontext_continuemicrovectorstreaming(LibMCDriver_ScanLab_RTCContext pRTCContext, LibMCDriver_ScanLab_uint32 nTimeBudgetInMS, bool * pComplete)
+{
+	IBase* pIBaseClass = (IBase *)pRTCContext;
+
+	try {
+		if (pComplete == nullptr)
+			throw ELibMCDriver_ScanLabInterfaceException (LIBMCDRIVER_SCANLAB_ERROR_INVALIDPARAM);
+		IRTCContext* pIRTCContext = dynamic_cast<IRTCContext*>(pIBaseClass);
+		if (!pIRTCContext)
+			throw ELibMCDriver_ScanLabInterfaceException(LIBMCDRIVER_SCANLAB_ERROR_INVALIDCAST);
+		
+		*pComplete = pIRTCContext->ContinueMicrovectorStreaming(nTimeBudgetInMS);
+
+		return LIBMCDRIVER_SCANLAB_SUCCESS;
+	}
+	catch (ELibMCDriver_ScanLabInterfaceException & Exception) {
+		return handleLibMCDriver_ScanLabException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCDriver_ScanLabResult libmcdriver_scanlab_rtccontext_abortmicrovectorstreaming(LibMCDriver_ScanLab_RTCContext pRTCContext)
+{
+	IBase* pIBaseClass = (IBase *)pRTCContext;
+
+	try {
+		IRTCContext* pIRTCContext = dynamic_cast<IRTCContext*>(pIBaseClass);
+		if (!pIRTCContext)
+			throw ELibMCDriver_ScanLabInterfaceException(LIBMCDRIVER_SCANLAB_ERROR_INVALIDCAST);
+		
+		pIRTCContext->AbortMicrovectorStreaming();
+
+		return LIBMCDRIVER_SCANLAB_SUCCESS;
+	}
+	catch (ELibMCDriver_ScanLabInterfaceException & Exception) {
+		return handleLibMCDriver_ScanLabException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
 LibMCDriver_ScanLabResult libmcdriver_scanlab_rtccontext_getcurrentfreevariable(LibMCDriver_ScanLab_RTCContext pRTCContext, LibMCDriver_ScanLab_uint32 nVariableNo, LibMCDriver_ScanLab_uint32 * pValue)
 {
 	IBase* pIBaseClass = (IBase *)pRTCContext;
@@ -8317,6 +8525,12 @@ LibMCDriver_ScanLabResult LibMCDriver_ScanLab::Impl::LibMCDriver_ScanLab_GetProc
 		*ppProcAddress = (void*) &libmcdriver_scanlab_rtcrecording_backtransformrawzcoordinate;
 	if (sProcName == "libmcdriver_scanlab_rtcrecording_addtargetpositionstodatatable") 
 		*ppProcAddress = (void*) &libmcdriver_scanlab_rtcrecording_addtargetpositionstodatatable;
+	if (sProcName == "libmcdriver_scanlab_rtcrecording_startlistwithrecording") 
+		*ppProcAddress = (void*) &libmcdriver_scanlab_rtcrecording_startlistwithrecording;
+	if (sProcName == "libmcdriver_scanlab_rtcrecording_readrecordeddata") 
+		*ppProcAddress = (void*) &libmcdriver_scanlab_rtcrecording_readrecordeddata;
+	if (sProcName == "libmcdriver_scanlab_rtcrecording_discardrecords") 
+		*ppProcAddress = (void*) &libmcdriver_scanlab_rtcrecording_discardrecords;
 	if (sProcName == "libmcdriver_scanlab_gpiosequence_getidentifier") 
 		*ppProcAddress = (void*) &libmcdriver_scanlab_gpiosequence_getidentifier;
 	if (sProcName == "libmcdriver_scanlab_gpiosequence_clear") 
@@ -8481,6 +8695,16 @@ LibMCDriver_ScanLabResult LibMCDriver_ScanLab::Impl::LibMCDriver_ScanLab_GetProc
 		*ppProcAddress = (void*) &libmcdriver_scanlab_rtccontext_addmicrovectormovement;
 	if (sProcName == "libmcdriver_scanlab_rtccontext_setmicrovectorstreamingenabled") 
 		*ppProcAddress = (void*) &libmcdriver_scanlab_rtccontext_setmicrovectorstreamingenabled;
+	if (sProcName == "libmcdriver_scanlab_rtccontext_setmicrovectorlistswitchingenabled") 
+		*ppProcAddress = (void*) &libmcdriver_scanlab_rtccontext_setmicrovectorlistswitchingenabled;
+	if (sProcName == "libmcdriver_scanlab_rtccontext_getmicrovectorlistswitchingstatistics") 
+		*ppProcAddress = (void*) &libmcdriver_scanlab_rtccontext_getmicrovectorlistswitchingstatistics;
+	if (sProcName == "libmcdriver_scanlab_rtccontext_beginmicrovectorstreaming") 
+		*ppProcAddress = (void*) &libmcdriver_scanlab_rtccontext_beginmicrovectorstreaming;
+	if (sProcName == "libmcdriver_scanlab_rtccontext_continuemicrovectorstreaming") 
+		*ppProcAddress = (void*) &libmcdriver_scanlab_rtccontext_continuemicrovectorstreaming;
+	if (sProcName == "libmcdriver_scanlab_rtccontext_abortmicrovectorstreaming") 
+		*ppProcAddress = (void*) &libmcdriver_scanlab_rtccontext_abortmicrovectorstreaming;
 	if (sProcName == "libmcdriver_scanlab_rtccontext_getcurrentfreevariable") 
 		*ppProcAddress = (void*) &libmcdriver_scanlab_rtccontext_getcurrentfreevariable;
 	if (sProcName == "libmcdriver_scanlab_rtccontext_gettimestamp") 
diff --git a/Drivers/ScanLab/Interfaces/libmcdriver_scanlab_types.hpp b/Drivers/ScanLab/Interfaces/libmcdriver_scanlab_types.hpp
index 0d5f77032..d807443df 100644
--- a/Drivers/ScanLab/Interfaces/libmcdriver_scanlab_types.hpp
+++ b/Drivers/ScanLab/Interfaces/libmcdriver_scanlab_types.hpp
@@ -270,6 +270,7 @@ typedef void * LibMCDriver_ScanLab_pvoid;
 #define LIBMCDRIVER_SCANLAB_ERROR_MINIMUMJUMPDISTANCEPROVIDEDTWICEINPROFILE 1165 /** Minimum jump distance provided twice in profile. */
 #define LIBMCDRIVER_SCANLAB_ERROR_UNSUPPORTEDPROFILEMODIFIER 1166 /** Toolpath profile has a modifier that the driver cannot execute. */
 #define LIBMCDRIVER_SCANLAB_ERROR_MODIFIEDLASERPOWEROUTOFRANGE 1167 /** Modified laser power is outside of the calibrated laser power range. */
+#define LIBMCDRIVER_SCANLAB_ERROR_RECORDINGREADOUTNOTSTARTED 1168 /** The incremental readout of the recording has not been started. */
 
 /*************************************************************************************************************************
  Error strings for LibMCDriver_ScanLab
@@ -452,6 +453,7 @@ inline const char * LIBMCDRIVER_SCANLAB_GETERRORSTRING (LibMCDriver_ScanLabResul
     case LIBMCDRIVER_SCANLAB_ERROR_MINIMUMJUMPDISTANCEPROVIDEDTWICEINPROFILE: return "Minimum jump distance provided twice in profile.";
     case LIBMCDRIVER_SCANLAB_ERROR_UNSUPPORTEDPROFILEMODIFIER: return "Toolpath profile has a modifier that the driver cannot execute.";
     case LIBMCDRIVER_SCANLAB_ERROR_MODIFIEDLASERPOWEROUTOFRANGE: return "Modified laser power is outside of the calibrated laser power range.";
+    case LIBMCDRIVER_SCANLAB_ERROR_RECORDINGREADOUTNOTSTARTED: return "The incremental readout of the recording has not been started.";
     default: return "unknown error";
   }
 }
diff --git a/Drivers/ScanLabOIE/Implementation/libmcdriver_scanlaboie_driver_scanlab_oie.cpp b/Drivers/ScanLabOIE/Implementation/libmcdriver_scanlaboie_driver_scanlab_oie.cpp
index 5d38c62da..9b493a46f 100644
--- a/Drivers/ScanLabOIE/Implementation/libmcdriver_scanlaboie_driver_scanlab_oie.cpp
+++ b/Drivers/ScanLabOIE/Implementation/libmcdriver_scanlaboie_driver_scanlab_oie.cpp
@@ -373,7 +373,7 @@ IOIEDevice* CDriver_ScanLab_OIE::AddDevice(const std::string& sName, const std::
 		}
 	}
 
-	auto pDeviceInstance = std::make_shared<COIEDeviceInstance>(m_pOIESDK, m_pInstance, sName, sHostName, nPort, nResponseTimeOut, pDeviceConfig, correctionData,  m_pWorkingDirectory);
+	auto pDeviceInstance = std::make_shared<COIEDeviceInstance>(m_pOIESDK, m_pInstance, sName, sHostName, nPort, nResponseTimeOut, pDeviceConfig, correctionData,  m_pWorkingDirectory, m_pDriverEnvironment);
 	m_Devices.insert(std::make_pair(sName, pDeviceInstance));
 
 	return new COIEDevice(pDeviceInstance);
diff --git a/Drivers/ScanLabOIE/Implementation/libmcdriver_scanlaboie_oiedevice.cpp b/Drivers/ScanLabOIE/Implementation/libmcdriver_scanlaboie_oiedevice.cpp
index 56bdacf78..f18abc22f 100644
--- a/Drivers/ScanLabOIE/Implementation/libmcdriver_scanlaboie_oiedevice.cpp
+++ b/Drivers/ScanLabOIE/Implementation/libmcdriver_scanlaboie_oiedevice.cpp
@@ -37,7 +37,6 @@ Abstract: This is a stub class definition of COIEDevice
 
 #include <array>
 #include <algorithm>
-#include <iostream>
 #include <cstring>
 #include <sstream>
 #include <limits>
@@ -100,7 +99,7 @@ void oieErrorListener(oie_device device, oie_error error, int32_t value, void* u
 	}
 }
 
-COIEDeviceInstance::COIEDeviceInstance(PScanLabOIESDK pOIESDK, oie_instance pInstance, const std::string& sDeviceName, const std::string& sHostName, const LibMCDriver_ScanLabOIE_uint32 nPort, uint32_t nResponseTimeOut, IDeviceConfiguration* pDeviceConfiguration, std::vector<uint8_t>& correctionFileData, LibMCEnv::PWorkingDirectory pWorkingDirectory)
+COIEDeviceInstance::COIEDeviceInstance(PScanLabOIESDK pOIESDK, oie_instance pInstance, const std::string& sDeviceName, const std::string& sHostName, const LibMCDriver_ScanLabOIE_uint32 nPort, uint32_t nResponseTimeOut, IDeviceConfiguration* pDeviceConfiguration, std::vector<uint8_t>& correctionFileData, LibMCEnv::PWorkingDirectory pWorkingDirectory, LibMCEnv::PDriverEnvironment pDriverEnvironment)
 	: m_pOIESDK (pOIESDK), 
 	  m_pInstance (pInstance), 
 	  m_pDevice (nullptr), 
@@ -121,7 +120,22 @@ COIEDeviceInstance::COIEDeviceInstance(PScanLabOIESDK pOIESDK, oie_instance pIns
 	  m_nPacketRecordedCounter(0),
 	  m_nPacketSkippedCounter(0),
 	  m_DeviceDriverType(eOIEDeviceDriverType::Unknown),
-	  m_RecordingFrequency(LibMCDriver_ScanLabOIE::eOIERecordingFrequency::Record100kHz)
+	  m_RecordingFrequency(LibMCDriver_ScanLabOIE::eOIERecordingFrequency::Record100kHz),
+	  m_pDriverEnvironment(pDriverEnvironment),
+	  m_nXYFallbackCount(0),
+	  m_nSignalCountMismatchCount(0),
+	  m_nPacketExceptionCount(0),
+	  m_nPacketUnknownExceptionCount(0),
+	  m_nErrorEventCount(0),
+	  m_nFirstErrorEventCode(0),
+	  m_nFirstErrorEventValue(0),
+	  m_nLastErrorEventCode(0),
+	  m_nLastErrorEventValue(0),
+	  m_nReportedXYFallbacks(0),
+	  m_nReportedSignalCountMismatches(0),
+	  m_nReportedPacketExceptions(0),
+	  m_nReportedPacketUnknownExceptions(0),
+	  m_nReportedErrorEvents(0)
 
 {
 	if ((pOIESDK.get() == nullptr) || (pInstance == nullptr) || (pWorkingDirectory.get () == nullptr) || (pDeviceConfiguration == nullptr))
@@ -509,13 +523,15 @@ void COIEDeviceInstance::startAppEx(const std::string& sName, const int32_t nMaj
 		m_pCurrentDataRecording = std::make_shared<CDataRecordingInstance>(m_nSensorSignalCount, m_nRTCSignalCount, m_nAdditionalSignalCount, nBufferSizeInRecords);
 	}
 
-	std::cout << "OIE-DIAG startAppEx: driverType=" << (uint32_t)m_DeviceDriverType
-		<< " recordingFrequency=" << (uint32_t)m_RecordingFrequency
-		<< " packetSkipCounter=" << m_nPacketReceiveSkipCounter
-		<< " rtcSignals=" << m_nRTCSignalCount
-		<< " sensorSignals=" << m_nSensorSignalCount
-		<< " additionalSignals=" << m_nAdditionalSignalCount
-		<< std::endl;
+	{
+		std::lock_guard<std::mutex> diagnosticsLock(m_DiagnosticsMutex);
+		resetDiagnostics();
+	}
+
+	logDriverInfo("OIE device " + m_sDeviceName + ": app " + sName + " started, driver type " + std::to_string((uint32_t)m_DeviceDriverType)
+		+ ", recording frequency " + std::to_string((uint32_t)m_RecordingFrequency) + ", packet skip counter " + std::to_string(m_nPacketReceiveSkipCounter)
+		+ ", " + std::to_string(m_nRTCSignalCount) + " rtc signals, " + std::to_string(m_nSensorSignalCount) + " sensor signals, "
+		+ std::to_string(m_nAdditionalSignalCount) + " additional signals.");
 
 }
 
@@ -635,8 +651,8 @@ void COIEDeviceInstance::SetRecordingFrequency(const LibMCDriver_ScanLabOIE::eOI
 		}
 
 		m_RecordingFrequency = eFrequency;
-		std::cout << "OIE-DIAG SetRecordingFrequency: eFrequency=" << (uint32_t)eFrequency
-			<< " packetSkipCounter=" << m_nPacketReceiveSkipCounter << std::endl;
+		logDriverInfo("OIE device " + m_sDeviceName + ": recording frequency set to " + std::to_string((uint32_t)eFrequency)
+			+ ", packet skip counter " + std::to_string(m_nPacketReceiveSkipCounter) + ".");
 
 	}
 	else {
@@ -771,10 +787,8 @@ void COIEDeviceInstance::onPacketEvent(oie_device device, const oie_pkt* pkt)
 					if (m_bHasCorrectionData) {
 						oie_error nXYError = m_pOIESDK->oie_pkt_get_xy(pkt, &dX, &dY);
 						if (nXYError != 0) {
-							static uint64_t nXYFallbackCounter = 0;
-							nXYFallbackCounter++;
-
-							if ((nXYFallbackCounter <= 20) || ((nXYFallbackCounter % 1000) == 0)) {
+							// Counted only; the first case is kept for the report of the plugin thread.
+							if (m_nXYFallbackCount.fetch_add(1) == 0) {
 								std::string sXYError = "unknown OIE xy error";
 								if (m_pOIESDK->oie_get_error != nullptr) {
 									const size_t nXYErrorBufferSize = 1024;
@@ -785,12 +799,10 @@ void COIEDeviceInstance::onPacketEvent(oie_device device, const oie_pkt* pkt)
 									sXYError = std::string(buffer.data());
 								}
 
-								std::cout << "OIE-DIAG xy fallback #" << nXYFallbackCounter
-									<< " packet=" << *pPacketNumber
-									<< " tag=" << *pMeasurementTag
-									<< " error=" << sXYError
-									<< " (" << nXYError << ")"
-									<< std::endl;
+								std::lock_guard<std::mutex> diagnosticsLock(m_DiagnosticsMutex);
+								m_FirstXYFallback.m_nPacket = *pPacketNumber;
+								m_FirstXYFallback.m_nTag = *pMeasurementTag;
+								m_FirstXYFallback.m_sText = sXYError + " (" + std::to_string(nXYError) + ")";
 							}
 
 							dX = 0.0;
@@ -847,16 +859,16 @@ void COIEDeviceInstance::onPacketEvent(oie_device device, const oie_pkt* pkt)
 					//std::cout << "Additional signal count" << additionalSignalCount << " (packetNr " << *pPacketNumber << ")" << std::endl;
 
 					if ((sensorSignalCount != nExpectedSensorSignalCount) || (rtcSignalCount != nExpectedRTCSignalCount) || (additionalSignalCount != nExpectedAdditionalSignalCount)) {
-						static uint64_t nSignalCountMismatchCounter = 0;
-						nSignalCountMismatchCounter++;
-
-						if ((nSignalCountMismatchCounter <= 20) || ((nSignalCountMismatchCounter % 1000) == 0)) {
-							std::cout << "OIE-DIAG packet signal-count mismatch #" << nSignalCountMismatchCounter
-								<< " packet=" << *pPacketNumber
-								<< " tag=" << *pMeasurementTag
-								<< " expected[s/r/a]=" << nExpectedSensorSignalCount << "/" << nExpectedRTCSignalCount << "/" << nExpectedAdditionalSignalCount
-								<< " got[s/r/a]=" << sensorSignalCount << "/" << rtcSignalCount << "/" << additionalSignalCount
-								<< std::endl;
+						if (m_nSignalCountMismatchCount.fetch_add(1) == 0) {
+							std::lock_guard<std::mutex> diagnosticsLock(m_DiagnosticsMutex);
+							m_FirstSignalCountMismatch.m_nPacket = *pPacketNumber;
+							m_FirstSignalCountMismatch.m_nTag = *pMeasurementTag;
+							m_FirstSignalCountMismatch.m_nExpected[0] = nExpectedSensorSignalCount;
+							m_FirstSignalCountMismatch.m_nExpected[1] = nExpectedRTCSignalCount;
+							m_FirstSignalCountMismatch.m_nExpected[2] = nExpectedAdditionalSignalCount;
+							m_FirstSignalCountMismatch.m_nGot[0] = sensorSignalCount;
+							m_FirstSignalCountMismatch.m_nGot[1] = rtcSignalCount;
+							m_FirstSignalCountMismatch.m_nGot[2] = additionalSignalCount;
 						}
 					}
 
@@ -889,79 +901,191 @@ void COIEDeviceInstance::onPacketEvent(oie_device device, const oie_pkt* pkt)
 
 		} */
 	}
-	catch (std::exception& E) {
-		static uint64_t nPacketExceptionCounter = 0;
-		nPacketExceptionCounter++;
-		if ((nPacketExceptionCounter <= 20) || ((nPacketExceptionCounter % 1000) == 0)) {
-			std::cout << "OIE-DIAG packet exception #" << nPacketExceptionCounter << ": " << E.what() << std::endl;
+	catch (const std::exception& E) {
+		// Counted and reported by the plugin thread; the callback must not throw into the SDK.
+		if (m_nPacketExceptionCount.fetch_add(1) == 0) {
+			std::lock_guard<std::mutex> diagnosticsLock(m_DiagnosticsMutex);
+			m_FirstPacketException.m_nPacket = 0;
+			m_FirstPacketException.m_nTag = 0;
+			m_FirstPacketException.m_sText = E.what();
 		}
 	}
 	catch (...) {
-		static uint64_t nPacketUnknownExceptionCounter = 0;
-		nPacketUnknownExceptionCounter++;
-		if ((nPacketUnknownExceptionCounter <= 20) || ((nPacketUnknownExceptionCounter % 1000) == 0)) {
-			std::cout << "OIE-DIAG packet unknown exception #" << nPacketUnknownExceptionCounter << std::endl;
-		}
+		m_nPacketUnknownExceptionCount++;
 	}
 }
 
 void COIEDeviceInstance::onErrorEvent(oie_device device, oie_error error, int32_t value)
 {
-	try {
-		if (device == m_pDevice) {
-			//std::cout << "Error event: " << error << " value: " << value << std::endl;
-		}
-	}
-	catch (...)
-	{
+	if (device != m_pDevice)
+		return;
 
+	// Callback of the OIE SDK: only counted here (atomics, nothing that could throw), reported by
+	// the next RetrieveCurrentRecording of the plugin thread.
+	if (m_nErrorEventCount.fetch_add(1) == 0) {
+		m_nFirstErrorEventCode = (int32_t)error;
+		m_nFirstErrorEventValue = value;
 	}
+	m_nLastErrorEventCode = (int32_t)error;
+	m_nLastErrorEventValue = value;
 }
 
 
 PDataRecordingInstance COIEDeviceInstance::RetrieveCurrentRecording()
 {
-	std::lock_guard<std::mutex> lockGuard(m_RecordingMutex);
+	PDataRecordingInstance pOldRecording;
 
-	if (m_pCurrentDataRecording.get() != nullptr) {
+	{
+		std::lock_guard<std::mutex> lockGuard(m_RecordingMutex);
 
-		auto pOldRecording = m_pCurrentDataRecording;
+		if (m_pCurrentDataRecording.get() == nullptr)
+			throw ELibMCDriver_ScanLabOIEInterfaceException(LIBMCDRIVER_SCANLABOIE_ERROR_NODATARECORDINGAVAILABLE);
+
+		pOldRecording = m_pCurrentDataRecording;
 		m_pCurrentDataRecording = nullptr;
 		m_pCurrentDataRecording = pOldRecording->createEmptyDuplicate();
-
-		std::cout << "OIE-DIAG retrieve: records=" << pOldRecording->getRecordCount()
-			<< " callbacks=" << m_nPacketCallbackCounter.load()
-			<< " recorded=" << m_nPacketRecordedCounter.load()
-			<< " skipped=" << m_nPacketSkippedCounter.load()
-			<< " skipCounter=" << m_nPacketReceiveSkipCounter
-			<< std::endl;
-
-		return pOldRecording;
-	}
-	else {
-		throw ELibMCDriver_ScanLabOIEInterfaceException(LIBMCDRIVER_SCANLABOIE_ERROR_NODATARECORDINGAVAILABLE);
 	}
 
+	// Outside of the recording lock: the log goes to the database of the server.
+	reportDiagnosticsIncrease();
 
+	return pOldRecording;
 }
 
 
 
 void COIEDeviceInstance::ClearCurrentRecording()
 {
-	std::lock_guard<std::mutex> lockGuard(m_RecordingMutex);
-	if (m_pCurrentDataRecording.get() != nullptr) {
+	std::string sSummary;
+
+	{
+		std::lock_guard<std::mutex> lockGuard(m_RecordingMutex);
+		if (m_pCurrentDataRecording.get() == nullptr)
+			return;
+
 		auto pOldRecording = m_pCurrentDataRecording;
 		m_pCurrentDataRecording = nullptr;
 		m_pCurrentDataRecording = pOldRecording->createEmptyDuplicate();
 
+		// The summary describes the time since the previous clear, i.e. the previous layer: the
+		// driver does not know when a layer ends. The packets that were not retrieved arrived
+		// after the last retrieval of that layer, normally during the pause between the layers.
+		sSummary = "OIE device " + m_sDeviceName + ": recording cleared, " + std::to_string(pOldRecording->getRecordCount())
+			+ " packets not retrieved; since the previous clear: " + std::to_string(m_nPacketCallbackCounter.load()) + " packets ("
+			+ std::to_string(m_nPacketRecordedCounter.load()) + " recorded, " + std::to_string(m_nPacketSkippedCounter.load()) + " skipped), "
+			+ describeDiagnostics() + ", last measurement tag " + std::to_string(n_LastReceivedMeasurementTag.load()) + ".";
+
 		n_LastReceivedMeasurementTag = 0;
 		m_nPacketReceiveCounter = 0;
 		m_nPacketCallbackCounter = 0;
 		m_nPacketRecordedCounter = 0;
 		m_nPacketSkippedCounter = 0;
 
+		std::lock_guard<std::mutex> diagnosticsLock(m_DiagnosticsMutex);
+		resetDiagnostics();
 	}
+
+	logDriverMessage(sSummary);
+}
+
+void COIEDeviceInstance::resetDiagnostics()
+{
+	// Called under m_DiagnosticsMutex.
+	m_nXYFallbackCount = 0;
+	m_nSignalCountMismatchCount = 0;
+	m_nPacketExceptionCount = 0;
+	m_nPacketUnknownExceptionCount = 0;
+	m_nErrorEventCount = 0;
+	m_FirstXYFallback = sFirstPacketIssue();
+	m_FirstPacketException = sFirstPacketIssue();
+	m_FirstSignalCountMismatch = sFirstSignalCountMismatch();
+	m_nFirstErrorEventCode = 0;
+	m_nFirstErrorEventValue = 0;
+	m_nLastErrorEventCode = 0;
+	m_nLastErrorEventValue = 0;
+	m_nReportedXYFallbacks = 0;
+	m_nReportedSignalCountMismatches = 0;
+	m_nReportedPacketExceptions = 0;
+	m_nReportedPacketUnknownExceptions = 0;
+	m_nReportedErrorEvents = 0;
+}
+
+std::string COIEDeviceInstance::describeDiagnostics()
+{
+	std::lock_guard<std::mutex> diagnosticsLock(m_DiagnosticsMutex);
+	return std::to_string(m_nXYFallbackCount.load()) + " xy fallbacks, " + std::to_string(m_nSignalCountMismatchCount.load()) + " signal-count mismatches, "
+		+ std::to_string(m_nPacketExceptionCount.load() + m_nPacketUnknownExceptionCount.load()) + " packet exceptions, "
+		+ std::to_string(m_nErrorEventCount.load()) + " error events";
+}
+
+void COIEDeviceInstance::reportDiagnosticsIncrease()
+{
+	if (m_pDriverEnvironment.get() == nullptr)
+		return;
+
+	std::vector<std::string> warnings;
+
+	{
+		std::lock_guard<std::mutex> diagnosticsLock(m_DiagnosticsMutex);
+		std::string sPrefix = "OIE device " + m_sDeviceName + ": ";
+
+		uint64_t nXYFallbacks = m_nXYFallbackCount.load();
+		if (nXYFallbacks > m_nReportedXYFallbacks) {
+			warnings.push_back(sPrefix + std::to_string(nXYFallbacks - m_nReportedXYFallbacks) + " xy fallbacks since the last report, first at packet "
+				+ std::to_string(m_FirstXYFallback.m_nPacket) + " (tag " + std::to_string(m_FirstXYFallback.m_nTag) + "): " + m_FirstXYFallback.m_sText + ".");
+			m_nReportedXYFallbacks = nXYFallbacks;
+		}
+
+		uint64_t nMismatches = m_nSignalCountMismatchCount.load();
+		if (nMismatches > m_nReportedSignalCountMismatches) {
+			warnings.push_back(sPrefix + std::to_string(nMismatches - m_nReportedSignalCountMismatches) + " signal-count mismatches since the last report, first at packet "
+				+ std::to_string(m_FirstSignalCountMismatch.m_nPacket) + " (tag " + std::to_string(m_FirstSignalCountMismatch.m_nTag) + "): expected sensor/rtc/additional "
+				+ std::to_string(m_FirstSignalCountMismatch.m_nExpected[0]) + "/" + std::to_string(m_FirstSignalCountMismatch.m_nExpected[1]) + "/" + std::to_string(m_FirstSignalCountMismatch.m_nExpected[2])
+				+ ", got " + std::to_string(m_FirstSignalCountMismatch.m_nGot[0]) + "/" + std::to_string(m_FirstSignalCountMismatch.m_nGot[1]) + "/" + std::to_string(m_FirstSignalCountMismatch.m_nGot[2]) + ".");
+			m_nReportedSignalCountMismatches = nMismatches;
+		}
+
+		uint64_t nExceptions = m_nPacketExceptionCount.load();
+		if (nExceptions > m_nReportedPacketExceptions) {
+			warnings.push_back(sPrefix + std::to_string(nExceptions - m_nReportedPacketExceptions) + " packet callbacks failed since the last report, first: " + m_FirstPacketException.m_sText + ".");
+			m_nReportedPacketExceptions = nExceptions;
+		}
+
+		uint64_t nUnknownExceptions = m_nPacketUnknownExceptionCount.load();
+		if (nUnknownExceptions > m_nReportedPacketUnknownExceptions) {
+			warnings.push_back(sPrefix + std::to_string(nUnknownExceptions - m_nReportedPacketUnknownExceptions) + " packet callbacks failed with an unknown exception since the last report.");
+			m_nReportedPacketUnknownExceptions = nUnknownExceptions;
+		}
+
+		uint64_t nErrorEvents = m_nErrorEventCount.load();
+		if (nErrorEvents > m_nReportedErrorEvents) {
+			warnings.push_back(sPrefix + std::to_string(nErrorEvents - m_nReportedErrorEvents) + " error events since the last report, first error "
+				+ std::to_string(m_nFirstErrorEventCode.load()) + " (value " + std::to_string(m_nFirstErrorEventValue.load()) + "), last error "
+				+ std::to_string(m_nLastErrorEventCode.load()) + " (value " + std::to_string(m_nLastErrorEventValue.load()) + ").");
+			m_nReportedErrorEvents = nErrorEvents;
+		}
+	}
+
+	for (auto& sWarning : warnings)
+		logDriverWarning(sWarning);
+}
+
+void COIEDeviceInstance::logDriverMessage(const std::string& sMessage)
+{
+	if (m_pDriverEnvironment.get() != nullptr)
+		m_pDriverEnvironment->LogMessage(sMessage);
+}
+
+void COIEDeviceInstance::logDriverWarning(const std::string& sMessage)
+{
+	if (m_pDriverEnvironment.get() != nullptr)
+		m_pDriverEnvironment->LogWarning(sMessage);
+}
+
+void COIEDeviceInstance::logDriverInfo(const std::string& sMessage)
+{
+	if (m_pDriverEnvironment.get() != nullptr)
+		m_pDriverEnvironment->LogInfo(sMessage);
 }
 
 
diff --git a/Drivers/ScanLabOIE/Implementation/libmcdriver_scanlaboie_oiedevice.hpp b/Drivers/ScanLabOIE/Implementation/libmcdriver_scanlaboie_oiedevice.hpp
index 56adc4e05..cce66d318 100644
--- a/Drivers/ScanLabOIE/Implementation/libmcdriver_scanlaboie_oiedevice.hpp
+++ b/Drivers/ScanLabOIE/Implementation/libmcdriver_scanlaboie_oiedevice.hpp
@@ -119,6 +119,57 @@ class COIEDeviceInstance {
 
 	std::mutex m_RecordingMutex;
 
+	// Diagnostics of the packet and error callbacks of the OIE SDK. The callbacks run in a thread
+	// of the SDK at up to 100 kHz, so they only count and keep the first occurrence; the log lines
+	// are written through the driver environment from RetrieveCurrentRecording and
+	// ClearCurrentRecording, which the plugin calls from its own thread. A null driver environment
+	// switches the output off.
+	LibMCEnv::PDriverEnvironment m_pDriverEnvironment;
+	std::mutex m_DiagnosticsMutex;
+
+	std::atomic<uint64_t> m_nXYFallbackCount;
+	std::atomic<uint64_t> m_nSignalCountMismatchCount;
+	std::atomic<uint64_t> m_nPacketExceptionCount;
+	std::atomic<uint64_t> m_nPacketUnknownExceptionCount;
+	std::atomic<uint64_t> m_nErrorEventCount;
+
+	// First occurrence per category since the last clear, written under m_DiagnosticsMutex.
+	struct sFirstPacketIssue {
+		uint32_t m_nPacket = 0;
+		uint32_t m_nTag = 0;
+		std::string m_sText;
+	};
+	sFirstPacketIssue m_FirstXYFallback;
+	sFirstPacketIssue m_FirstPacketException;
+
+	struct sFirstSignalCountMismatch {
+		uint32_t m_nPacket = 0;
+		uint32_t m_nTag = 0;
+		uint32_t m_nExpected[3] = { 0, 0, 0 };   // sensor, rtc, additional
+		uint32_t m_nGot[3] = { 0, 0, 0 };
+	};
+	sFirstSignalCountMismatch m_FirstSignalCountMismatch;
+
+	// Error events carry two integers only, so the first and the last one are kept in atomics.
+	std::atomic<int32_t> m_nFirstErrorEventCode;
+	std::atomic<int32_t> m_nFirstErrorEventValue;
+	std::atomic<int32_t> m_nLastErrorEventCode;
+	std::atomic<int32_t> m_nLastErrorEventValue;
+
+	// Counter values at the previous report, so that every report shows the increase.
+	uint64_t m_nReportedXYFallbacks;
+	uint64_t m_nReportedSignalCountMismatches;
+	uint64_t m_nReportedPacketExceptions;
+	uint64_t m_nReportedPacketUnknownExceptions;
+	uint64_t m_nReportedErrorEvents;
+
+	void resetDiagnostics();
+	void reportDiagnosticsIncrease();
+	std::string describeDiagnostics();
+	void logDriverMessage(const std::string& sMessage);
+	void logDriverWarning(const std::string& sMessage);
+	void logDriverInfo(const std::string& sMessage);
+
 	void ensureConnectivity();
 	void removeDevice(bool bCheckForError);
 
@@ -133,7 +184,7 @@ class COIEDeviceInstance {
 
 public:
 
-	COIEDeviceInstance(PScanLabOIESDK pOIESDK, oie_instance pInstance, const std::string & sDeviceName, const std::string& sHostName, const LibMCDriver_ScanLabOIE_uint32 nPort, uint32_t nResponseTimeOut, IDeviceConfiguration* pDeviceConfiguration, std::vector<uint8_t>& correctionFileData, LibMCEnv::PWorkingDirectory pWorkingDirectory);
+	COIEDeviceInstance(PScanLabOIESDK pOIESDK, oie_instance pInstance, const std::string & sDeviceName, const std::string& sHostName, const LibMCDriver_ScanLabOIE_uint32 nPort, uint32_t nResponseTimeOut, IDeviceConfiguration* pDeviceConfiguration, std::vector<uint8_t>& correctionFileData, LibMCEnv::PWorkingDirectory pWorkingDirectory, LibMCEnv::PDriverEnvironment pDriverEnvironment);
 
 	virtual ~COIEDeviceInstance();
 
diff --git a/Drivers/ScanLabOIE/Implementation/libmcdriver_scanlaboie_sdk.cpp b/Drivers/ScanLabOIE/Implementation/libmcdriver_scanlaboie_sdk.cpp
index 6a1b64f37..2d6983ba6 100644
--- a/Drivers/ScanLabOIE/Implementation/libmcdriver_scanlaboie_sdk.cpp
+++ b/Drivers/ScanLabOIE/Implementation/libmcdriver_scanlaboie_sdk.cpp
@@ -42,6 +42,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <vector>
 #include <iostream>
+#include <thread>
+#include <chrono>
 
 using namespace LibMCDriver_ScanLabOIE::Impl;
 
@@ -129,9 +131,26 @@ CScanLabOIESDK::CScanLabOIESDK(const std::string& sDLLNameUTF8, const std::strin
 
 	auto pDirectoryCache = cacheDllDirectory();
 
-	HMODULE hLibrary = LoadLibraryW(wsLibraryFileName.data());
+	// The DLL directory and the current directory set by cacheDllDirectory() are process-wide
+	// state. Other drivers (GRPC, SMC) set them too, and their state machines initialize at the
+	// same time, so between the two calls above and this load another thread may have pointed
+	// them elsewhere; liboie then fails to find Qt5Core & Co. (seen 2026-10-07 as an intermittent
+	// COULDNOTLOADLIBRARY at startup). LOAD_WITH_ALTERED_SEARCH_PATH with the absolute file name
+	// makes the loader resolve the dependencies from the directory of liboie itself, independent
+	// of that global state. The retry covers a dependency the loader still picks up by name.
+	HMODULE hLibrary = 0;
+	DWORD nLastLoadError = 0;
+	for (uint32_t nAttempt = 0; (nAttempt < 5) && (hLibrary == 0); nAttempt++) {
+		if (nAttempt > 0) {
+			std::this_thread::sleep_for(std::chrono::milliseconds(200));
+			SetDllDirectoryW(m_sDLLDirectoryW.c_str());
+		}
+		hLibrary = LoadLibraryExW(wsLibraryFileName.data(), NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
+		if (hLibrary == 0)
+			nLastLoadError = GetLastError();
+	}
 	if (hLibrary == 0)
-		throw ELibMCDriver_ScanLabOIEInterfaceException(LIBMCDRIVER_SCANLABOIE_ERROR_COULDNOTLOADLIBRARY);
+		throw ELibMCDriver_ScanLabOIEInterfaceException(LIBMCDRIVER_SCANLABOIE_ERROR_COULDNOTLOADLIBRARY, "could not load OIE library " + sDLLNameUTF8 + " (Windows error " + std::to_string(nLastLoadError) + ")");
 #else // _WIN32
 	void* hLibrary = dlopen(sDLLNameUTF8.c_str(), RTLD_LAZY);
 	if (hLibrary == 0) {
diff --git a/Drivers/ScanLabSMC/ACT/LibMCDriver_ScanLabSMC.xml b/Drivers/ScanLabSMC/ACT/LibMCDriver_ScanLabSMC.xml
index ffa6672e6..838cbbf67 100644
--- a/Drivers/ScanLabSMC/ACT/LibMCDriver_ScanLabSMC.xml
+++ b/Drivers/ScanLabSMC/ACT/LibMCDriver_ScanLabSMC.xml
@@ -110,6 +110,7 @@
 		<error name="INVALIDMAXPOWERVALUE" code="1056" description="Invalid max power value." />
 		<error name="SIMULATIONWORKINGFILEISNOTINITIALIZED" code="1057" description="Simulation working file is not initialized." />
 		<error name="SIMULATIONWORKINGFILESIZEMISMATCH" code="1058" description="Simulation working file size mismatch." />
+		<error name="SIMULATIONFILEOUTPUTDISABLED" code="1059" description="Simulation file output has been disabled in the SMC configuration, LoadSimulationData is not available." />
 		
 	</errors>
 
@@ -331,13 +332,13 @@ Custom implementation
 		<method name="StopExecution" description="Stops the execution of the current list immediately.">
 		</method>	
 
-		<method name="LoadSimulationData" description="Reads the SMC Simulation data into a data table.">
+		<method name="LoadSimulationData" description="Reads the SMC Simulation data into a data table. Can be called once per job: after a successful read the simulation output files (or the RTC log record file in hardware mode) are deleted. Fails with SIMULATIONFILEOUTPUTDISABLED if the configuration disabled the simulation file output.">
 			<param name="SimulationDataTable" type="class" class="LibMCEnv:DataTable" pass="in" description="Data table object to read the simulation into." />
-		</method>	
+		</method>
 
-		<method name="LoadRawSimulationData" description="Returns raw simulation data.">
+		<method name="LoadRawSimulationData" description="Returns raw simulation data. Can be called once per job (one size query followed by one data read): after a successful read the temporary module file is deleted.">
 			<param name="Data" type="basicarray" class="uint8" pass="out" description="Raw binary simulation data." />
-		</method>	
+		</method>
 		
 		<method name="GetJobCharacteristic" description="Returns a characteristic value of a job.">
 			<param name="ValueType" type="enum" class="JobCharacteristic" pass="in" description="Type of job" />
@@ -391,6 +392,14 @@ Custom implementation
 			<param name="SendToHardware" type="bool" pass="return" description="Flag, if the computation shall be sent to the hardware." />
 		</method>
 
+		<method name="SetSimulationFileOutputEnabled" description="Sets if SMC shall write its simulation output files (SimOutputFileDirectory) during job execution. Default is true. Set to false if LoadSimulationData is never called: this saves several GB of disk space and minutes of planning time per large layer.">
+			<param name="Enabled" type="bool" pass="in" description="Flag, if the simulation output files shall be written." />
+		</method>
+
+		<method name="GetSimulationFileOutputEnabled" description="Returns if SMC shall write its simulation output files during job execution.">
+			<param name="Enabled" type="bool" pass="return" description="Flag, if the simulation output files shall be written." />
+		</method>
+
 	
 		<method name="SetSerialNumber" description="Sets the RTC Serial number. MUST be larger than 0.">
 			<param name="Value" type="uint32" class="WarnLevel" pass="in" description="Value to set." />
diff --git a/Drivers/ScanLabSMC/Headers/CppDynamic/libmcdriver_scanlabsmc_dynamic.h b/Drivers/ScanLabSMC/Headers/CppDynamic/libmcdriver_scanlabsmc_dynamic.h
index e2d401711..20f3c944d 100644
--- a/Drivers/ScanLabSMC/Headers/CppDynamic/libmcdriver_scanlabsmc_dynamic.h
+++ b/Drivers/ScanLabSMC/Headers/CppDynamic/libmcdriver_scanlabsmc_dynamic.h
@@ -244,7 +244,7 @@ typedef LibMCDriver_ScanLabSMCResult (*PLibMCDriver_ScanLabSMCSMCJob_WaitForExec
 typedef LibMCDriver_ScanLabSMCResult (*PLibMCDriver_ScanLabSMCSMCJob_StopExecutionPtr) (LibMCDriver_ScanLabSMC_SMCJob pSMCJob);
 
 /**
-* Reads the SMC Simulation data into a data table.
+* Reads the SMC Simulation data into a data table. Can be called once per job: after a successful read the simulation output files (or the RTC log record file in hardware mode) are deleted. Fails with SIMULATIONFILEOUTPUTDISABLED if the configuration disabled the simulation file output.
 *
 * @param[in] pSMCJob - SMCJob instance.
 * @param[in] pSimulationDataTable - Data table object to read the simulation into.
@@ -253,7 +253,7 @@ typedef LibMCDriver_ScanLabSMCResult (*PLibMCDriver_ScanLabSMCSMCJob_StopExecuti
 typedef LibMCDriver_ScanLabSMCResult (*PLibMCDriver_ScanLabSMCSMCJob_LoadSimulationDataPtr) (LibMCDriver_ScanLabSMC_SMCJob pSMCJob, LibMCEnv_DataTable pSimulationDataTable);
 
 /**
-* Returns raw simulation data.
+* Returns raw simulation data. Can be called once per job (one size query followed by one data read): after a successful read the temporary module file is deleted.
 *
 * @param[in] pSMCJob - SMCJob instance.
 * @param[in] nDataBufferSize - Number of elements in buffer
@@ -374,6 +374,24 @@ typedef LibMCDriver_ScanLabSMCResult (*PLibMCDriver_ScanLabSMCSMCConfiguration_S
 */
 typedef LibMCDriver_ScanLabSMCResult (*PLibMCDriver_ScanLabSMCSMCConfiguration_GetSendToHardwarePtr) (LibMCDriver_ScanLabSMC_SMCConfiguration pSMCConfiguration, bool * pSendToHardware);
 
+/**
+* Sets if SMC shall write its simulation output files (SimOutputFileDirectory) during job execution. Default is true. Set to false if LoadSimulationData is never called: this saves several GB of disk space and minutes of planning time per large layer.
+*
+* @param[in] pSMCConfiguration - SMCConfiguration instance.
+* @param[in] bEnabled - Flag, if the simulation output files shall be written.
+* @return error code or 0 (success)
+*/
+typedef LibMCDriver_ScanLabSMCResult (*PLibMCDriver_ScanLabSMCSMCConfiguration_SetSimulationFileOutputEnabledPtr) (LibMCDriver_ScanLabSMC_SMCConfiguration pSMCConfiguration, bool bEnabled);
+
+/**
+* Returns if SMC shall write its simulation output files during job execution.
+*
+* @param[in] pSMCConfiguration - SMCConfiguration instance.
+* @param[out] pEnabled - Flag, if the simulation output files shall be written.
+* @return error code or 0 (success)
+*/
+typedef LibMCDriver_ScanLabSMCResult (*PLibMCDriver_ScanLabSMCSMCConfiguration_GetSimulationFileOutputEnabledPtr) (LibMCDriver_ScanLabSMC_SMCConfiguration pSMCConfiguration, bool * pEnabled);
+
 /**
 * Sets the RTC Serial number. MUST be larger than 0.
 *
@@ -898,6 +916,8 @@ typedef struct {
 	PLibMCDriver_ScanLabSMCSMCConfiguration_GetBlendModePtr m_SMCConfiguration_GetBlendMode;
 	PLibMCDriver_ScanLabSMCSMCConfiguration_SetSendToHardwarePtr m_SMCConfiguration_SetSendToHardware;
 	PLibMCDriver_ScanLabSMCSMCConfiguration_GetSendToHardwarePtr m_SMCConfiguration_GetSendToHardware;
+	PLibMCDriver_ScanLabSMCSMCConfiguration_SetSimulationFileOutputEnabledPtr m_SMCConfiguration_SetSimulationFileOutputEnabled;
+	PLibMCDriver_ScanLabSMCSMCConfiguration_GetSimulationFileOutputEnabledPtr m_SMCConfiguration_GetSimulationFileOutputEnabled;
 	PLibMCDriver_ScanLabSMCSMCConfiguration_SetSerialNumberPtr m_SMCConfiguration_SetSerialNumber;
 	PLibMCDriver_ScanLabSMCSMCConfiguration_GetSerialNumberPtr m_SMCConfiguration_GetSerialNumber;
 	PLibMCDriver_ScanLabSMCSMCConfiguration_SetIPAddressPtr m_SMCConfiguration_SetIPAddress;
diff --git a/Drivers/ScanLabSMC/Headers/CppDynamic/libmcdriver_scanlabsmc_dynamic.hpp b/Drivers/ScanLabSMC/Headers/CppDynamic/libmcdriver_scanlabsmc_dynamic.hpp
index 0e44e0a5b..5909fd6c3 100644
--- a/Drivers/ScanLabSMC/Headers/CppDynamic/libmcdriver_scanlabsmc_dynamic.hpp
+++ b/Drivers/ScanLabSMC/Headers/CppDynamic/libmcdriver_scanlabsmc_dynamic.hpp
@@ -246,6 +246,7 @@ class ELibMCDriver_ScanLabSMCException : public std::exception {
 			case LIBMCDRIVER_SCANLABSMC_ERROR_INVALIDMAXPOWERVALUE: return "INVALIDMAXPOWERVALUE";
 			case LIBMCDRIVER_SCANLABSMC_ERROR_SIMULATIONWORKINGFILEISNOTINITIALIZED: return "SIMULATIONWORKINGFILEISNOTINITIALIZED";
 			case LIBMCDRIVER_SCANLABSMC_ERROR_SIMULATIONWORKINGFILESIZEMISMATCH: return "SIMULATIONWORKINGFILESIZEMISMATCH";
+			case LIBMCDRIVER_SCANLABSMC_ERROR_SIMULATIONFILEOUTPUTDISABLED: return "SIMULATIONFILEOUTPUTDISABLED";
 		}
 		return "UNKNOWN";
 	}
@@ -322,6 +323,7 @@ class ELibMCDriver_ScanLabSMCException : public std::exception {
 			case LIBMCDRIVER_SCANLABSMC_ERROR_INVALIDMAXPOWERVALUE: return "Invalid max power value.";
 			case LIBMCDRIVER_SCANLABSMC_ERROR_SIMULATIONWORKINGFILEISNOTINITIALIZED: return "Simulation working file is not initialized.";
 			case LIBMCDRIVER_SCANLABSMC_ERROR_SIMULATIONWORKINGFILESIZEMISMATCH: return "Simulation working file size mismatch.";
+			case LIBMCDRIVER_SCANLABSMC_ERROR_SIMULATIONFILEOUTPUTDISABLED: return "Simulation file output has been disabled in the SMC configuration, LoadSimulationData is not available.";
 		}
 		return "unknown error";
 	}
@@ -587,6 +589,8 @@ class CSMCConfiguration : public CBase {
 	inline eBlendMode GetBlendMode();
 	inline void SetSendToHardware(const bool bSendToHardware);
 	inline bool GetSendToHardware();
+	inline void SetSimulationFileOutputEnabled(const bool bEnabled);
+	inline bool GetSimulationFileOutputEnabled();
 	inline void SetSerialNumber(const LibMCDriver_ScanLabSMC_uint32 nValue);
 	inline LibMCDriver_ScanLabSMC_uint32 GetSerialNumber();
 	inline void SetIPAddress(const std::string & sValue);
@@ -816,6 +820,8 @@ class CDriver_ScanLabSMC : public CDriver {
 		pWrapperTable->m_SMCConfiguration_GetBlendMode = nullptr;
 		pWrapperTable->m_SMCConfiguration_SetSendToHardware = nullptr;
 		pWrapperTable->m_SMCConfiguration_GetSendToHardware = nullptr;
+		pWrapperTable->m_SMCConfiguration_SetSimulationFileOutputEnabled = nullptr;
+		pWrapperTable->m_SMCConfiguration_GetSimulationFileOutputEnabled = nullptr;
 		pWrapperTable->m_SMCConfiguration_SetSerialNumber = nullptr;
 		pWrapperTable->m_SMCConfiguration_GetSerialNumber = nullptr;
 		pWrapperTable->m_SMCConfiguration_SetIPAddress = nullptr;
@@ -1202,6 +1208,24 @@ class CDriver_ScanLabSMC : public CDriver {
 		if (pWrapperTable->m_SMCConfiguration_GetSendToHardware == nullptr)
 			return LIBMCDRIVER_SCANLABSMC_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
+		#ifdef _WIN32
+		pWrapperTable->m_SMCConfiguration_SetSimulationFileOutputEnabled = (PLibMCDriver_ScanLabSMCSMCConfiguration_SetSimulationFileOutputEnabledPtr) GetProcAddress(hLibrary, "libmcdriver_scanlabsmc_smcconfiguration_setsimulationfileoutputenabled");
+		#else // _WIN32
+		pWrapperTable->m_SMCConfiguration_SetSimulationFileOutputEnabled = (PLibMCDriver_ScanLabSMCSMCConfiguration_SetSimulationFileOutputEnabledPtr) dlsym(hLibrary, "libmcdriver_scanlabsmc_smcconfiguration_setsimulationfileoutputenabled");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_SMCConfiguration_SetSimulationFileOutputEnabled == nullptr)
+			return LIBMCDRIVER_SCANLABSMC_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_SMCConfiguration_GetSimulationFileOutputEnabled = (PLibMCDriver_ScanLabSMCSMCConfiguration_GetSimulationFileOutputEnabledPtr) GetProcAddress(hLibrary, "libmcdriver_scanlabsmc_smcconfiguration_getsimulationfileoutputenabled");
+		#else // _WIN32
+		pWrapperTable->m_SMCConfiguration_GetSimulationFileOutputEnabled = (PLibMCDriver_ScanLabSMCSMCConfiguration_GetSimulationFileOutputEnabledPtr) dlsym(hLibrary, "libmcdriver_scanlabsmc_smcconfiguration_getsimulationfileoutputenabled");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_SMCConfiguration_GetSimulationFileOutputEnabled == nullptr)
+			return LIBMCDRIVER_SCANLABSMC_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
 		#ifdef _WIN32
 		pWrapperTable->m_SMCConfiguration_SetSerialNumber = (PLibMCDriver_ScanLabSMCSMCConfiguration_SetSerialNumberPtr) GetProcAddress(hLibrary, "libmcdriver_scanlabsmc_smcconfiguration_setserialnumber");
 		#else // _WIN32
@@ -1778,6 +1802,14 @@ class CDriver_ScanLabSMC : public CDriver {
 		if ( (eLookupError != 0) || (pWrapperTable->m_SMCConfiguration_GetSendToHardware == nullptr) )
 			return LIBMCDRIVER_SCANLABSMC_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
+		eLookupError = (*pLookup)("libmcdriver_scanlabsmc_smcconfiguration_setsimulationfileoutputenabled", (void**)&(pWrapperTable->m_SMCConfiguration_SetSimulationFileOutputEnabled));
+		if ( (eLookupError != 0) || (pWrapperTable->m_SMCConfiguration_SetSimulationFileOutputEnabled == nullptr) )
+			return LIBMCDRIVER_SCANLABSMC_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcdriver_scanlabsmc_smcconfiguration_getsimulationfileoutputenabled", (void**)&(pWrapperTable->m_SMCConfiguration_GetSimulationFileOutputEnabled));
+		if ( (eLookupError != 0) || (pWrapperTable->m_SMCConfiguration_GetSimulationFileOutputEnabled == nullptr) )
+			return LIBMCDRIVER_SCANLABSMC_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
 		eLookupError = (*pLookup)("libmcdriver_scanlabsmc_smcconfiguration_setserialnumber", (void**)&(pWrapperTable->m_SMCConfiguration_SetSerialNumber));
 		if ( (eLookupError != 0) || (pWrapperTable->m_SMCConfiguration_SetSerialNumber == nullptr) )
 			return LIBMCDRIVER_SCANLABSMC_ERROR_COULDNOTFINDLIBRARYEXPORT;
@@ -2197,7 +2229,7 @@ class CDriver_ScanLabSMC : public CDriver {
 	}
 	
 	/**
-	* CSMCJob::LoadSimulationData - Reads the SMC Simulation data into a data table.
+	* CSMCJob::LoadSimulationData - Reads the SMC Simulation data into a data table. Can be called once per job: after a successful read the simulation output files (or the RTC log record file in hardware mode) are deleted. Fails with SIMULATIONFILEOUTPUTDISABLED if the configuration disabled the simulation file output.
 	* @param[in] pSimulationDataTable - Data table object to read the simulation into.
 	*/
 	void CSMCJob::LoadSimulationData(classParam<LibMCEnv::CDataTable> pSimulationDataTable)
@@ -2207,7 +2239,7 @@ class CDriver_ScanLabSMC : public CDriver {
 	}
 	
 	/**
-	* CSMCJob::LoadRawSimulationData - Returns raw simulation data.
+	* CSMCJob::LoadRawSimulationData - Returns raw simulation data. Can be called once per job (one size query followed by one data read): after a successful read the temporary module file is deleted.
 	* @param[out] DataBuffer - Raw binary simulation data.
 	*/
 	void CSMCJob::LoadRawSimulationData(std::vector<LibMCDriver_ScanLabSMC_uint8> & DataBuffer)
@@ -2348,6 +2380,27 @@ class CDriver_ScanLabSMC : public CDriver {
 		return resultSendToHardware;
 	}
 	
+	/**
+	* CSMCConfiguration::SetSimulationFileOutputEnabled - Sets if SMC shall write its simulation output files (SimOutputFileDirectory) during job execution. Default is true. Set to false if LoadSimulationData is never called: this saves several GB of disk space and minutes of planning time per large layer.
+	* @param[in] bEnabled - Flag, if the simulation output files shall be written.
+	*/
+	void CSMCConfiguration::SetSimulationFileOutputEnabled(const bool bEnabled)
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_SMCConfiguration_SetSimulationFileOutputEnabled(m_pHandle, bEnabled));
+	}
+	
+	/**
+	* CSMCConfiguration::GetSimulationFileOutputEnabled - Returns if SMC shall write its simulation output files during job execution.
+	* @return Flag, if the simulation output files shall be written.
+	*/
+	bool CSMCConfiguration::GetSimulationFileOutputEnabled()
+	{
+		bool resultEnabled = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_SMCConfiguration_GetSimulationFileOutputEnabled(m_pHandle, &resultEnabled));
+		
+		return resultEnabled;
+	}
+	
 	/**
 	* CSMCConfiguration::SetSerialNumber - Sets the RTC Serial number. MUST be larger than 0.
 	* @param[in] nValue - Value to set.
diff --git a/Drivers/ScanLabSMC/Headers/CppDynamic/libmcdriver_scanlabsmc_types.hpp b/Drivers/ScanLabSMC/Headers/CppDynamic/libmcdriver_scanlabsmc_types.hpp
index 8f31e9a16..9fede9330 100644
--- a/Drivers/ScanLabSMC/Headers/CppDynamic/libmcdriver_scanlabsmc_types.hpp
+++ b/Drivers/ScanLabSMC/Headers/CppDynamic/libmcdriver_scanlabsmc_types.hpp
@@ -164,6 +164,7 @@ typedef void * LibMCDriver_ScanLabSMC_pvoid;
 #define LIBMCDRIVER_SCANLABSMC_ERROR_INVALIDMAXPOWERVALUE 1056 /** Invalid max power value. */
 #define LIBMCDRIVER_SCANLABSMC_ERROR_SIMULATIONWORKINGFILEISNOTINITIALIZED 1057 /** Simulation working file is not initialized. */
 #define LIBMCDRIVER_SCANLABSMC_ERROR_SIMULATIONWORKINGFILESIZEMISMATCH 1058 /** Simulation working file size mismatch. */
+#define LIBMCDRIVER_SCANLABSMC_ERROR_SIMULATIONFILEOUTPUTDISABLED 1059 /** Simulation file output has been disabled in the SMC configuration, LoadSimulationData is not available. */
 
 /*************************************************************************************************************************
  Error strings for LibMCDriver_ScanLabSMC
@@ -240,6 +241,7 @@ inline const char * LIBMCDRIVER_SCANLABSMC_GETERRORSTRING (LibMCDriver_ScanLabSM
     case LIBMCDRIVER_SCANLABSMC_ERROR_INVALIDMAXPOWERVALUE: return "Invalid max power value.";
     case LIBMCDRIVER_SCANLABSMC_ERROR_SIMULATIONWORKINGFILEISNOTINITIALIZED: return "Simulation working file is not initialized.";
     case LIBMCDRIVER_SCANLABSMC_ERROR_SIMULATIONWORKINGFILESIZEMISMATCH: return "Simulation working file size mismatch.";
+    case LIBMCDRIVER_SCANLABSMC_ERROR_SIMULATIONFILEOUTPUTDISABLED: return "Simulation file output has been disabled in the SMC configuration, LoadSimulationData is not available.";
     default: return "unknown error";
   }
 }
diff --git a/Drivers/ScanLabSMC/Implementation/libmcdriver_scanlabsmc_sdk.cpp b/Drivers/ScanLabSMC/Implementation/libmcdriver_scanlabsmc_sdk.cpp
index 2e587af73..d959ae443 100644
--- a/Drivers/ScanLabSMC/Implementation/libmcdriver_scanlabsmc_sdk.cpp
+++ b/Drivers/ScanLabSMC/Implementation/libmcdriver_scanlabsmc_sdk.cpp
@@ -41,6 +41,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <vector>
 #include <sstream>
 #include <string>
+#include <thread>
+#include <chrono>
 
 using namespace LibMCDriver_ScanLabSMC::Impl;
 
@@ -195,9 +197,26 @@ CScanLabSMCSDK::CScanLabSMCSDK(const std::string& sDLLNameUTF8, const std::strin
 
 	auto pDirectoryCache = cacheDllDirectory();
 
-	HMODULE hLibrary = LoadLibraryW(wsLibraryFileName.data());
+	// The DLL directory and the current directory set by cacheDllDirectory() are process-wide
+	// state. Other drivers (GRPC, OIE) set them too, and their state machines initialize at the
+	// same time, so between the two calls above and this load another thread may have pointed
+	// them elsewhere (intermittent COULDNOTLOADLIBRARY at startup, 2026-10-07).
+	// LOAD_WITH_ALTERED_SEARCH_PATH with the absolute file name makes the loader resolve the
+	// dependencies from the directory of the SMC DLL itself, independent of that global state.
+	HMODULE hLibrary = 0;
+	DWORD nLastLoadError = 0;
+	for (uint32_t nAttempt = 0; (nAttempt < 5) && (hLibrary == 0); nAttempt++) {
+		if (nAttempt > 0) {
+			std::this_thread::sleep_for(std::chrono::milliseconds(200));
+			SetDllDirectoryW(m_sDLLDirectoryW.c_str());
+			SetCurrentDirectoryW(m_sDLLDirectoryW.c_str());
+		}
+		hLibrary = LoadLibraryExW(wsLibraryFileName.data(), NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
+		if (hLibrary == 0)
+			nLastLoadError = GetLastError();
+	}
 	if (hLibrary == 0)
-		throw ELibMCDriver_ScanLabSMCInterfaceException(LIBMCDRIVER_SCANLABSMC_ERROR_COULDNOTLOADLIBRARY);
+		throw ELibMCDriver_ScanLabSMCInterfaceException(LIBMCDRIVER_SCANLABSMC_ERROR_COULDNOTLOADLIBRARY, "could not load SMC library " + sDLLNameUTF8 + " (Windows error " + std::to_string(nLastLoadError) + ")");
 #else // _WIN32
 	void* hLibrary = dlopen(sDLLNameUTF8.c_str(), RTLD_LAZY);
 	if (hLibrary == 0) {
diff --git a/Drivers/ScanLabSMC/Implementation/libmcdriver_scanlabsmc_smcconfiguration.cpp b/Drivers/ScanLabSMC/Implementation/libmcdriver_scanlabsmc_smcconfiguration.cpp
index 8a9046790..58df1dbb1 100644
--- a/Drivers/ScanLabSMC/Implementation/libmcdriver_scanlabsmc_smcconfiguration.cpp
+++ b/Drivers/ScanLabSMC/Implementation/libmcdriver_scanlabsmc_smcconfiguration.cpp
@@ -50,7 +50,8 @@ CSMCConfiguration::CSMCConfiguration(LibMCEnv::PDriverEnvironment pDriverEnviron
      m_WarnLevel (LibMCDriver_ScanLabSMC::eWarnLevel::Error),
     m_nSerialNumber (0),
     m_BlendMode (LibMCDriver_ScanLabSMC::eBlendMode::Deactivated),
-    m_bSendToHardware (false)
+    m_bSendToHardware (false),
+    m_bSimulationFileOutputEnabled (true)
 
 {
     if (pDriverEnvironment.get() == nullptr)
@@ -110,6 +111,16 @@ bool CSMCConfiguration::GetSendToHardware()
     return m_bSendToHardware;
 }
 
+void CSMCConfiguration::SetSimulationFileOutputEnabled(const bool bEnabled)
+{
+    m_bSimulationFileOutputEnabled = bEnabled;
+}
+
+bool CSMCConfiguration::GetSimulationFileOutputEnabled()
+{
+    return m_bSimulationFileOutputEnabled;
+}
+
 
 std::string CSMCConfiguration::GetIPAddress()
 {
@@ -484,7 +495,9 @@ std::string CSMCConfiguration::buildConfigurationXML(LibMCEnv::CWorkingDirectory
     pSimulationConfigNode->AddChildText("", "SimulationMode", sSimulationMode);
     pSimulationConfigNode->AddChildText("", "SimOutputFileDirectory", sSimulationDirectory);
     pSimulationConfigNode->AddChildText("", "BinaryOutput", "false");
-    pSimulationConfigNode->AddChildText("", "DisableFileOutput", "false");
+    // Writing the simulation output costs several GB of disk and minutes of planning time per large
+    // layer, so plugins that only use LoadRawSimulationData switch it off via the configuration.
+    pSimulationConfigNode->AddChildText("", "DisableFileOutput", m_bSimulationFileOutputEnabled ? "false" : "true");
 
     auto pRTCConfigNode = pConfigurationNode->AddChild("", "RTCConfig");
     pRTCConfigNode->AddChildText("", "BoardIdentificationMethod", "BySerialNumber");
diff --git a/Drivers/ScanLabSMC/Implementation/libmcdriver_scanlabsmc_smcconfiguration.hpp b/Drivers/ScanLabSMC/Implementation/libmcdriver_scanlabsmc_smcconfiguration.hpp
index 1228a78f7..f65b7439d 100644
--- a/Drivers/ScanLabSMC/Implementation/libmcdriver_scanlabsmc_smcconfiguration.hpp
+++ b/Drivers/ScanLabSMC/Implementation/libmcdriver_scanlabsmc_smcconfiguration.hpp
@@ -79,6 +79,7 @@ class CSMCConfiguration : public virtual ISMCConfiguration, public virtual CBase
     std::string m_sSimulationSubDirectory;
 
     bool m_bSendToHardware;
+    bool m_bSimulationFileOutputEnabled;
 
 public:
 
@@ -104,6 +105,10 @@ class CSMCConfiguration : public virtual ISMCConfiguration, public virtual CBase
 
     bool GetSendToHardware() override;
 
+    void SetSimulationFileOutputEnabled(const bool bEnabled) override;
+
+    bool GetSimulationFileOutputEnabled() override;
+
 	std::string GetIPAddress() override;
 
 	void SetCorrectionFile(const LibMCDriver_ScanLabSMC_uint64 nCorrectionFileDataBufferSize, const LibMCDriver_ScanLabSMC_uint8* pCorrectionFileDataBuffer) override;
diff --git a/Drivers/ScanLabSMC/Implementation/libmcdriver_scanlabsmc_smccontextinstance.cpp b/Drivers/ScanLabSMC/Implementation/libmcdriver_scanlabsmc_smccontextinstance.cpp
index 4c88833af..561494d6d 100644
--- a/Drivers/ScanLabSMC/Implementation/libmcdriver_scanlabsmc_smccontextinstance.cpp
+++ b/Drivers/ScanLabSMC/Implementation/libmcdriver_scanlabsmc_smccontextinstance.cpp
@@ -92,7 +92,8 @@ CSMCContextInstance::CSMCContextInstance(const std::string& sContextName, ISMCCo
 	m_pDriverEnvironment (pDriverEnvironment), 
 	m_sContextName (sContextName), 
 	m_nSerialNumber (0),
-	m_bSendToHardware (false)
+	m_bSendToHardware (false),
+	m_bSimulationFileOutputEnabled (true)
 {
 	if (pSDK.get() == nullptr)
 		throw ELibMCDriver_ScanLabSMCInterfaceException(LIBMCDRIVER_SCANLABSMC_ERROR_INVALIDPARAM);
@@ -115,7 +116,8 @@ CSMCContextInstance::CSMCContextInstance(const std::string& sContextName, ISMCCo
 
 	m_sIPAddress = pSMCConfiguration->GetIPAddress();
 
-	m_bSendToHardware = pSMCConfiguration->GetSendToHardware();	
+	m_bSendToHardware = pSMCConfiguration->GetSendToHardware();
+	m_bSimulationFileOutputEnabled = pSMCConfiguration->GetSimulationFileOutputEnabled();
 
 	eSMCConfigVersion configVersion = eSMCConfigVersion::Unknown;
 	auto versionInfo = m_pSDK->slsc_cfg_get_scanmotioncontrol_version();
@@ -232,7 +234,7 @@ std::string CSMCContextInstance::GetSimulationSubDirectory()
 
 PSMCJobInstance CSMCContextInstance::BeginJob(const double dStartPositionX, const double dStartPositionY, const double dMaxPowerInWatts)
 {
-	return std::make_shared<CSMCJobInstance> (m_pContextHandle, m_pDriverEnvironment, dStartPositionX, dStartPositionY, m_pWorkingDirectory, m_sSimulationSubDirectory, m_bSendToHardware, dMaxPowerInWatts);
+	return std::make_shared<CSMCJobInstance> (m_pContextHandle, m_pDriverEnvironment, dStartPositionX, dStartPositionY, m_pWorkingDirectory, m_sSimulationSubDirectory, m_bSendToHardware, m_bSimulationFileOutputEnabled, dMaxPowerInWatts);
 }
 
 PSMCJobInstance CSMCContextInstance::GetUnfinishedJob()
diff --git a/Drivers/ScanLabSMC/Implementation/libmcdriver_scanlabsmc_smccontextinstance.hpp b/Drivers/ScanLabSMC/Implementation/libmcdriver_scanlabsmc_smccontextinstance.hpp
index 2ebbc4b54..967883861 100644
--- a/Drivers/ScanLabSMC/Implementation/libmcdriver_scanlabsmc_smccontextinstance.hpp
+++ b/Drivers/ScanLabSMC/Implementation/libmcdriver_scanlabsmc_smccontextinstance.hpp
@@ -65,6 +65,7 @@ class CSMCContextInstance {
 	uint32_t m_nSerialNumber;
 
 	bool m_bSendToHardware;
+	bool m_bSimulationFileOutputEnabled;
 
 public:
 
diff --git a/Drivers/ScanLabSMC/Implementation/libmcdriver_scanlabsmc_smcjobinstance.cpp b/Drivers/ScanLabSMC/Implementation/libmcdriver_scanlabsmc_smcjobinstance.cpp
index 20bf07e7d..6d243792a 100644
--- a/Drivers/ScanLabSMC/Implementation/libmcdriver_scanlabsmc_smcjobinstance.cpp
+++ b/Drivers/ScanLabSMC/Implementation/libmcdriver_scanlabsmc_smcjobinstance.cpp
@@ -47,6 +47,8 @@ Abstract: This is a stub class definition of CSMCJob
 #include <cmath>
 #include <cstring>
 #include <chrono>
+#include <filesystem>
+#include <system_error>
 
 using namespace LibMCDriver_ScanLabSMC::Impl;
 
@@ -54,16 +56,17 @@ using namespace LibMCDriver_ScanLabSMC::Impl;
  Class definition of CSMCJob
 **************************************************************************************************************************/
 
-CSMCJobInstance::CSMCJobInstance(PSMCContextHandle pContextHandle, LibMCEnv::PDriverEnvironment pDriverEnvironment, double dStartPositionX, double dStartPositionY, LibMCEnv::PWorkingDirectory pWorkingDirectory, std::string sSimulationSubDirectory, bool bSendToHardware, double dMaxPowerInWatts)
-    : m_pContextHandle(pContextHandle), 
+CSMCJobInstance::CSMCJobInstance(PSMCContextHandle pContextHandle, LibMCEnv::PDriverEnvironment pDriverEnvironment, double dStartPositionX, double dStartPositionY, LibMCEnv::PWorkingDirectory pWorkingDirectory, std::string sSimulationSubDirectory, bool bSendToHardware, bool bSimulationFileOutputEnabled, double dMaxPowerInWatts)
+    : m_pContextHandle(pContextHandle),
     m_pDriverEnvironment(pDriverEnvironment),
-    m_pWorkingDirectory (pWorkingDirectory), 
+    m_pWorkingDirectory (pWorkingDirectory),
     m_sSimulationSubDirectory (sSimulationSubDirectory),
     m_JobID(0),
     m_bIsFinalized(false),
     m_bHasJobDuration (false),
     m_dJobDuration (0.0),
     m_bSendToHardware (bSendToHardware),
+    m_bSimulationFileOutputEnabled (bSimulationFileOutputEnabled),
     m_dMaxPowerInWatts (dMaxPowerInWatts)
 {
     if (m_pWorkingDirectory.get() == nullptr)
@@ -73,7 +76,12 @@ CSMCJobInstance::CSMCJobInstance(PSMCContextHandle pContextHandle, LibMCEnv::PDr
     if (m_pDriverEnvironment.get() == nullptr)
         throw ELibMCDriver_ScanLabSMCInterfaceException(LIBMCDRIVER_SCANLABSMC_ERROR_INVALIDPARAM);
 
-    m_pSDK = m_pContextHandle->getSDK();    
+    m_pSDK = m_pContextHandle->getSDK();
+
+    // Same layout as SimOutputFileDirectory in CSMCConfiguration::buildConfigurationXML.
+    m_sSimulationOutputDirectory = m_pWorkingDirectory->GetAbsoluteFilePath();
+    if (!m_sSimulationSubDirectory.empty())
+        m_sSimulationOutputDirectory += "/" + m_sSimulationSubDirectory;
 
     auto contextHandle = m_pContextHandle->getHandle();
 
@@ -114,7 +122,126 @@ CSMCJobInstance::CSMCJobInstance(PSMCContextHandle pContextHandle, LibMCEnv::PDr
 
 CSMCJobInstance::~CSMCJobInstance()
 {
+    // Safety net for jobs whose data was never read (exception in the plugin, context re-creation
+    // after an error, simulation output enabled but LoadSimulationData not called). The helpers
+    // report failures as warnings instead of throwing; only the logging itself can still throw.
+    try {
+        deleteWorkingFileQuietly(m_tmpSimulationFile, "simulation module file");
+        resolveSimulationOutputFilePrefix();
+        deleteSimulationOutputFilesQuietly();
+    }
+    catch (const std::exception& E) {
+        m_pDriverEnvironment->LogWarning(std::string("could not clean up temporary files of SMC job: ") + E.what());
+    }
+}
+
+void CSMCJobInstance::deleteWorkingFileQuietly(LibMCEnv::PWorkingFile& pFile, const std::string& sPurpose)
+{
+    if (pFile.get() == nullptr)
+        return;
+
+    std::string sFileName = pFile->GetAbsoluteFileName();
+
+    if (pFile->FileExists()) {
+        // DeleteFromDisk reports a failure (e.g. SMC still holding the handle) as false and does not throw.
+        // The file stays managed, so the working directory cleanup removes it at the latest.
+        if (pFile->DeleteFromDisk()) {
+            m_pDriverEnvironment->LogMessage("Deleted " + sPurpose + ": " + sFileName);
+        }
+        else {
+            m_pDriverEnvironment->LogWarning("Could not delete " + sPurpose + ", it will be removed with the working directory: " + sFileName);
+        }
+    }
+
+    pFile = nullptr;
+}
+
+void CSMCJobInstance::resolveSimulationOutputFilePrefix()
+{
+    if (!m_sSimulationOutputFilePrefix.empty())
+        return;
+    if (m_bSendToHardware || !m_bSimulationFileOutputEnabled)
+        return;
+
+    auto contextHandle = m_pContextHandle->getHandle();
+
+    std::vector<char> buffer;
+    buffer.resize(16384);
+    uint32_t nErrorCode = m_pSDK->slsc_ctrl_get_simulation_filename(contextHandle, m_JobID, buffer.data(), buffer.size());
+    if (nErrorCode != 0) {
+        m_pDriverEnvironment->LogWarning("SMC did not report a simulation output file name for job " + std::to_string(m_JobID) + " (error " + std::to_string(nErrorCode) + "), its simulation output files will stay in the working directory.");
+        return;
+    }
+    buffer.at(buffer.size() - 1) = 0;
+
+    std::string sSimulationFileName(buffer.data());
+    if (sSimulationFileName.empty())
+        return;
+
+    // SMC rotates the output into <base>.csv, <base>.1.csv, ... and writes <base>.xml, so only the
+    // base name without extension is kept.
+    size_t nDotPosition = sSimulationFileName.rfind('.');
+    if ((nDotPosition != std::string::npos) && (nDotPosition > 0))
+        m_sSimulationOutputFilePrefix = sSimulationFileName.substr(0, nDotPosition);
+    else
+        m_sSimulationOutputFilePrefix = sSimulationFileName;
+}
+
+std::string CSMCJobInstance::getSimulationOutputFileName()
+{
+    auto contextHandle = m_pContextHandle->getHandle();
+
+    std::vector<char> buffer;
+    buffer.resize(16384);
+    m_pSDK->checkError(contextHandle, m_pSDK->slsc_ctrl_get_simulation_filename(contextHandle, m_JobID, buffer.data(), buffer.size()));
+    buffer.at(buffer.size() - 1) = 0;
+
+    std::string sSimulationFileName(buffer.data());
 
+    return m_sSimulationOutputDirectory + "/" + sSimulationFileName;
+}
+
+void CSMCJobInstance::deleteSimulationOutputFilesQuietly()
+{
+    if (m_sSimulationOutputFilePrefix.empty())
+        return;
+
+    namespace fs = std::filesystem;
+    std::error_code ec;
+
+    fs::path simulationDirectory = fs::u8path(m_sSimulationOutputDirectory);
+    if (!fs::is_directory(simulationDirectory, ec)) {
+        m_sSimulationOutputFilePrefix.clear();
+        return;
+    }
+
+    // The prefix contains job ID and timestamp; the dot keeps Simulation_ID_1_TS_x. apart from Simulation_ID_10_TS_y.
+    const std::string sMatch = m_sSimulationOutputFilePrefix + ".";
+    uint32_t nDeletedCount = 0;
+
+    for (const auto& entry : fs::directory_iterator(simulationDirectory, ec)) {
+        if (!entry.is_regular_file(ec))
+            continue;
+
+        std::string sFileName = entry.path().filename().u8string();
+        if (sFileName.compare(0, sMatch.size(), sMatch) != 0)
+            continue;
+
+        std::error_code removeError;
+        if (fs::remove(entry.path(), removeError) && !removeError) {
+            nDeletedCount++;
+        }
+        else {
+            m_pDriverEnvironment->LogWarning("Could not delete SMC simulation output file " + sFileName + ": " + removeError.message());
+        }
+    }
+
+    if (ec)
+        m_pDriverEnvironment->LogWarning("Could not enumerate SMC simulation output directory " + m_sSimulationOutputDirectory + ": " + ec.message());
+
+    m_pDriverEnvironment->LogMessage("Deleted " + std::to_string(nDeletedCount) + " SMC simulation output file(s) for " + m_sSimulationOutputFilePrefix);
+
+    m_sSimulationOutputFilePrefix.clear();
 }
 
 LibMCDriver_ScanLabSMC_uint64 CSMCJobInstance::GetJobID()
@@ -435,6 +562,10 @@ void CSMCJobInstance::Execute(const bool bBlocking)
     } 
 
     m_pDriverEnvironment->LogMessage("Execution finished");
+
+    // SMC has closed its simulation output files now; remember their name so that the destructor
+    // can delete them even if nobody calls LoadSimulationData.
+    resolveSimulationOutputFilePrefix();
 }
 
 bool CSMCJobInstance::IsExecuting()
@@ -715,6 +846,11 @@ void CSMCJobInstance::ExecuteLaserShutdownSequence()
 
 void CSMCJobInstance::ReadSimulationFile(LibMCEnv::PDataTable pDataTable)
 {
+    // In simulation mode the data comes from the SMC simulation output files, which the
+    // configuration may have switched off. The hardware log record does not depend on them.
+    if (!m_bSendToHardware && !m_bSimulationFileOutputEnabled)
+        throw ELibMCDriver_ScanLabSMCInterfaceException(LIBMCDRIVER_SCANLABSMC_ERROR_SIMULATIONFILEOUTPUTDISABLED);
+
     slsc_VersionInfo version = m_pSDK->slsc_cfg_get_scanmotioncontrol_version();
 
     if (version.m_nMajor == 0) {
@@ -744,20 +880,8 @@ void CSMCJobInstance::ReadSimulationFile_SMC_v0_8(LibMCEnv::PDataTable pDataTabl
     if (pDataTable.get() == nullptr)
         throw ELibMCDriver_ScanLabSMCInterfaceException(LIBMCDRIVER_SCANLABSMC_ERROR_INVALIDPARAM);
 
-    auto contextHandle = m_pContextHandle->getHandle();
-
-    std::vector<char> buffer;
-    buffer.resize(16384);
-    m_pSDK->checkError(contextHandle, m_pSDK->slsc_ctrl_get_simulation_filename(contextHandle, m_JobID, buffer.data (), buffer.size ()));
-    buffer.at(buffer.size() - 1) = 0;
-
-    std::string sSimulationFileName(buffer.data());
-
-    std::string sSimulationDirectory = m_pWorkingDirectory->GetAbsoluteFilePath() + "/";
-    if (!m_sSimulationSubDirectory.empty ())
-        sSimulationDirectory += m_sSimulationSubDirectory + "/";
-
-    CSMCSimulationParser parser(sSimulationDirectory + sSimulationFileName);
+    resolveSimulationOutputFilePrefix();
+    std::string sSimulationFileName = getSimulationOutputFileName();
 
     pDataTable->AddColumn("timestamp", "Timestamp", LibMCEnv::eDataTableColumnType::DoubleColumn);
     pDataTable->AddColumn("x", "X", LibMCEnv::eDataTableColumnType::DoubleColumn);
@@ -767,23 +891,31 @@ void CSMCJobInstance::ReadSimulationFile_SMC_v0_8(LibMCEnv::PDataTable pDataTabl
     pDataTable->AddColumn("active2", "Active Channel 2", LibMCEnv::eDataTableColumnType::DoubleColumn);
     pDataTable->AddColumn("cmdindex", "Command Index", LibMCEnv::eDataTableColumnType::Int32Column);
 
-    std::vector<double> timestampValues;
-    parser.readTimestampValues(timestampValues);
-    pDataTable->SetDoubleColumnValues("timestamp", timestampValues);
-    timestampValues.resize(0);
-
-    std::vector<double> xValues;
-    parser.readXValues(xValues);
-    pDataTable->SetDoubleColumnValues("x", xValues);
-    xValues.resize(0);
-
-    std::vector<double> yValues;
-    parser.readYValues(yValues);
-    pDataTable->SetDoubleColumnValues("y", yValues);
-    yValues.resize(0);
+    {
+        // Scoped so that the parser has released the file before it is deleted below.
+        CSMCSimulationParser parser(sSimulationFileName);
+
+        std::vector<double> timestampValues;
+        parser.readTimestampValues(timestampValues);
+        pDataTable->SetDoubleColumnValues("timestamp", timestampValues);
+        timestampValues.resize(0);
+
+        std::vector<double> xValues;
+        parser.readXValues(xValues);
+        pDataTable->SetDoubleColumnValues("x", xValues);
+        xValues.resize(0);
+
+        std::vector<double> yValues;
+        parser.readYValues(yValues);
+        pDataTable->SetDoubleColumnValues("y", yValues);
+        yValues.resize(0);
+
+        m_dJobDuration = (double)parser.getCount() / (double)SCANLABSMC_MICROSTEPSPERSECOND;
+        m_bHasJobDuration = true;
+    }
 
-    m_dJobDuration = (double)parser.getCount() / (double)SCANLABSMC_MICROSTEPSPERSECOND;
-    m_bHasJobDuration = true;
+    // The table holds everything; the simulation output is not needed any more.
+    deleteSimulationOutputFilesQuietly();
 }
 
 void CSMCJobInstance::ReadSimulationFile_SMC_v1_0(LibMCEnv::PDataTable pDataTable)
@@ -791,20 +923,8 @@ void CSMCJobInstance::ReadSimulationFile_SMC_v1_0(LibMCEnv::PDataTable pDataTabl
     if (pDataTable.get() == nullptr)
         throw ELibMCDriver_ScanLabSMCInterfaceException(LIBMCDRIVER_SCANLABSMC_ERROR_INVALIDPARAM);
 
-    auto contextHandle = m_pContextHandle->getHandle();
-
-    std::vector<char> buffer;
-    buffer.resize(16384);
-    m_pSDK->checkError(contextHandle, m_pSDK->slsc_ctrl_get_simulation_filename(contextHandle, m_JobID, buffer.data(), buffer.size()));
-    buffer.at(buffer.size() - 1) = 0;
-
-    std::string sSimulationFileName(buffer.data());
-
-    std::string sSimulationDirectory = m_pWorkingDirectory->GetAbsoluteFilePath() + "/";
-    if (!m_sSimulationSubDirectory.empty())
-        sSimulationDirectory += m_sSimulationSubDirectory + "/";
-
-    CSMCCSVParser parser(sSimulationDirectory + sSimulationFileName, ';');
+    resolveSimulationOutputFilePrefix();
+    std::string sSimulationFileName = getSimulationOutputFileName();
 
     std::vector<double>     scanheadX;            // DisplacedX_Galvo_1
     std::vector<double>     scanheadY;            // DisplacedY_Galvo_1
@@ -832,13 +952,11 @@ void CSMCJobInstance::ReadSimulationFile_SMC_v1_0(LibMCEnv::PDataTable pDataTabl
         {{CSMCCSVParser::FieldParserType::Timestamp,CSMCCSVParser::FieldProcessingStep::Nop}, &timestampValues}
     };
 
-    parser.Parse(bindings);
-
-#if NOT_IMPLEMENTED
-    const auto& headers = parser.getHeader();
-    const auto& types = parser.getColumnTypes();
-    const auto& rows = parser.getRows();
-#endif
+    {
+        // Scoped so that the parser has released the file before it is deleted at the end.
+        CSMCCSVParser parser(sSimulationFileName, ';');
+        parser.Parse(bindings);
+    }
 
     pDataTable->AddColumn("timestamp", "Timestamp", LibMCEnv::eDataTableColumnType::DoubleColumn);
     pDataTable->AddColumn("x", "X", LibMCEnv::eDataTableColumnType::DoubleColumn);
@@ -867,7 +985,10 @@ void CSMCJobInstance::ReadSimulationFile_SMC_v1_0(LibMCEnv::PDataTable pDataTabl
     activeChannel0.resize(0);
 
     pDataTable->SetDoubleColumnValues("active1", activeChannel1);
-    activeChannel1.resize(0);    
+    activeChannel1.resize(0);
+
+    // The table holds everything; the simulation output is not needed any more.
+    deleteSimulationOutputFilesQuietly();
 }
 
 void CSMCJobInstance::ReadLogRecordFile(LibMCEnv::PDataTable pDataTable)
@@ -879,20 +1000,26 @@ void CSMCJobInstance::ReadLogRecordFile(LibMCEnv::PDataTable pDataTable)
 
     auto pLogRecordFile = m_pWorkingDirectory->AddManagedTempFile("csv");
 
-    //if(!pLogRecordFile->FileExists())
-    //    throw ELibMCDriver_ScanLabSMCInterfaceException(LIBMCDRIVER_SCANLABSMC_ERROR_INVALIDPARAM);
+    // The log record is only an intermediate: once parsed into the table it is deleted, on the
+    // normal path as well as when the parser or the table throws.
+    struct CLogRecordFileGuard {
+        CSMCJobInstance* m_pJob;
+        LibMCEnv::PWorkingFile& m_pFile;
+        ~CLogRecordFileGuard()
+        {
+            m_pJob->deleteWorkingFileQuietly(m_pFile, "RTC log record file");
+        }
+    } logRecordFileGuard{ this, pLogRecordFile };
 
     auto sLogRecordAbsoluteFileName = pLogRecordFile->GetAbsoluteFileName();
 
-    //auto eTransformationStep = slsc_TransformationStep::slsc_TransformationStep_Rtc; // needs scaling and rotation 
+    //auto eTransformationStep = slsc_TransformationStep::slsc_TransformationStep_Rtc; // needs scaling and rotation
     auto eTransformationStep = slsc_TransformationStep::slsc_TransformationStep_Corrected;
 
     m_pSDK->slsc_ctrl_log_record(m_pContextHandle->getHandle(), sLogRecordAbsoluteFileName.c_str(), eTransformationStep);
 
     //-----------------------------------
 
-    CSMCCSVParser parser(sLogRecordAbsoluteFileName, ';');
-
     std::vector<double> timestampValues;
     std::vector<double> scanheadX;
     std::vector<double> scanheadY;
@@ -905,15 +1032,11 @@ void CSMCJobInstance::ReadLogRecordFile(LibMCEnv::PDataTable pDataTable)
         {{CSMCCSVParser::FieldParserType::Timestamp,CSMCCSVParser::FieldProcessingStep::Nop}, &timestampValues}
     };
 
-    auto start = std::chrono::high_resolution_clock::now();
-
-    parser.Parse(bindings);
-
-#if NOT_IMPLEMENTED
-    const auto& headers = parser.getHeader();
-    const auto& types = parser.getColumnTypes();
-    const auto& rows = parser.getRows();
-#endif
+    {
+        // Scoped so that the parser has released the file before the guard deletes it.
+        CSMCCSVParser parser(sLogRecordAbsoluteFileName, ';');
+        parser.Parse(bindings);
+    }
 
     pDataTable->AddColumn("timestamp", "Timestamp", LibMCEnv::eDataTableColumnType::DoubleColumn);
     pDataTable->AddColumn("x", "X", LibMCEnv::eDataTableColumnType::DoubleColumn);
@@ -1072,7 +1195,10 @@ void CSMCJobInstance::LoadRawSimulationData(LibMCDriver_ScanLabSMC_uint64 nDataB
     *pDataNeededCount = nDataSize;
 
     if (pDataBuffer)
-    {		
+    {
+        if (nDataBufferSize < nDataSize)
+            throw ELibMCDriver_ScanLabSMCInterfaceException(LIBMCDRIVER_SCANLABSMC_ERROR_BUFFERTOOSMALL);
+
         std::vector<LibMCEnv_uint8> tmpFileContentBuffer;
         m_tmpSimulationFile->ReadContent(tmpFileContentBuffer);
 
@@ -1081,5 +1207,9 @@ void CSMCJobInstance::LoadRawSimulationData(LibMCDriver_ScanLabSMC_uint64 nDataB
 
         if (tmpFileContentBuffer.size () > 0)
             memcpy(pDataBuffer, tmpFileContentBuffer.data(), tmpFileContentBuffer.size());
+
+        // The caller owns the content now. The module file can be several GB per layer, so it is
+        // deleted right here instead of with the working directory. A second read is not possible.
+        deleteWorkingFileQuietly(m_tmpSimulationFile, "simulation module file");
     }
 }
\ No newline at end of file
diff --git a/Drivers/ScanLabSMC/Implementation/libmcdriver_scanlabsmc_smcjobinstance.hpp b/Drivers/ScanLabSMC/Implementation/libmcdriver_scanlabsmc_smcjobinstance.hpp
index b71353150..90189b1c9 100644
--- a/Drivers/ScanLabSMC/Implementation/libmcdriver_scanlabsmc_smcjobinstance.hpp
+++ b/Drivers/ScanLabSMC/Implementation/libmcdriver_scanlabsmc_smcjobinstance.hpp
@@ -64,10 +64,35 @@ class CSMCJobInstance {
 	double m_dJobDuration;
 
 	bool m_bSendToHardware;
+	bool m_bSimulationFileOutputEnabled;
 	double m_dMaxPowerInWatts;
 
+	// Module recording of the planned layer (simulation mode only). Deleted as soon as
+	// LoadRawSimulationData has handed the content to the caller, or in the destructor.
 	LibMCEnv::PWorkingFile m_tmpSimulationFile;
 
+	// Absolute path of the directory SMC writes its simulation output into (no trailing slash).
+	std::string m_sSimulationOutputDirectory;
+
+	// Base name of the SMC simulation output without extension, e.g. Simulation_ID_1_TS_1791536807083.
+	// SMC rotates its output into <base>.csv, <base>.1.csv, <base>.2.csv, ... plus <base>.xml, so the
+	// whole set is deleted by this prefix. Empty while unknown or if the file output is disabled.
+	std::string m_sSimulationOutputFilePrefix;
+
+	// Deletes a managed working file if it exists. A failure is logged as a warning and never thrown:
+	// the file stays managed and is removed with the working directory at the latest.
+	void deleteWorkingFileQuietly(LibMCEnv::PWorkingFile& pFile, const std::string& sPurpose);
+
+	// Asks SMC for the simulation output file name of this job. Never throws; an SMC error leaves the
+	// prefix empty. Idempotent.
+	void resolveSimulationOutputFilePrefix();
+
+	// Absolute name of the SMC simulation output file as reported by SMC (for the parsers).
+	std::string getSimulationOutputFileName();
+
+	// Deletes every simulation output file of this job (see m_sSimulationOutputFilePrefix). Never throws.
+	void deleteSimulationOutputFilesQuietly();
+
 	void drawPolylineEx(slscHandle contextHandle, const uint64_t nPointsBufferSize, const LibMCDriver_ScanLabSMC::sPoint2D* pPointsBuffer, bool bIsClosed, double dPowerInWatts);
 	void drawHatchesEx(const LibMCDriver_ScanLabSMC_uint64 nHatchesBufferSize, const LibMCDriver_ScanLabSMC::sHatch2D* pHatchesBuffer, const LibMCDriver_ScanLabSMC_double dMarkSpeed, const LibMCDriver_ScanLabSMC_double dJumpSpeed, const LibMCDriver_ScanLabSMC_double dPowerInWatts, const LibMCDriver_ScanLabSMC_double dZValue);
 	void drawHatchesExLinearPower(const LibMCDriver_ScanLabSMC_uint64 nHatchesBufferSize, const LibMCDriver_ScanLabSMC::sHatch2D* pHatchesBuffer, const LibMCDriver_ScanLabSMC_double dMarkSpeed, const LibMCDriver_ScanLabSMC_double dJumpSpeed, const LibMCDriver_ScanLabSMC_double dPowerInWatts, const LibMCDriver_ScanLabSMC_double dZValue, std::vector<double>& PowerValues1, std::vector<double>& PowerValues2);
@@ -75,7 +100,7 @@ class CSMCJobInstance {
 
 public:
 
-	CSMCJobInstance(PSMCContextHandle pContextHandle, LibMCEnv::PDriverEnvironment pDriverEnvironment, double dStartPositionX, double dStartPositionY, LibMCEnv::PWorkingDirectory pWorkingDirectory, std::string sSimulationSubDirectory, bool bSendToHardware, double dMaxPowerInWatts);
+	CSMCJobInstance(PSMCContextHandle pContextHandle, LibMCEnv::PDriverEnvironment pDriverEnvironment, double dStartPositionX, double dStartPositionY, LibMCEnv::PWorkingDirectory pWorkingDirectory, std::string sSimulationSubDirectory, bool bSendToHardware, bool bSimulationFileOutputEnabled, double dMaxPowerInWatts);
 
 	virtual ~CSMCJobInstance();
 
diff --git a/Drivers/ScanLabSMC/Interfaces/libmcdriver_scanlabsmc_abi.hpp b/Drivers/ScanLabSMC/Interfaces/libmcdriver_scanlabsmc_abi.hpp
index 7b0463afb..8e691bb76 100644
--- a/Drivers/ScanLabSMC/Interfaces/libmcdriver_scanlabsmc_abi.hpp
+++ b/Drivers/ScanLabSMC/Interfaces/libmcdriver_scanlabsmc_abi.hpp
@@ -257,7 +257,7 @@ LIBMCDRIVER_SCANLABSMC_DECLSPEC LibMCDriver_ScanLabSMCResult libmcdriver_scanlab
 LIBMCDRIVER_SCANLABSMC_DECLSPEC LibMCDriver_ScanLabSMCResult libmcdriver_scanlabsmc_smcjob_stopexecution(LibMCDriver_ScanLabSMC_SMCJob pSMCJob);
 
 /**
-* Reads the SMC Simulation data into a data table.
+* Reads the SMC Simulation data into a data table. Can be called once per job: after a successful read the simulation output files (or the RTC log record file in hardware mode) are deleted. Fails with SIMULATIONFILEOUTPUTDISABLED if the configuration disabled the simulation file output.
 *
 * @param[in] pSMCJob - SMCJob instance.
 * @param[in] pSimulationDataTable - Data table object to read the simulation into.
@@ -266,7 +266,7 @@ LIBMCDRIVER_SCANLABSMC_DECLSPEC LibMCDriver_ScanLabSMCResult libmcdriver_scanlab
 LIBMCDRIVER_SCANLABSMC_DECLSPEC LibMCDriver_ScanLabSMCResult libmcdriver_scanlabsmc_smcjob_loadsimulationdata(LibMCDriver_ScanLabSMC_SMCJob pSMCJob, LibMCEnv_DataTable pSimulationDataTable);
 
 /**
-* Returns raw simulation data.
+* Returns raw simulation data. Can be called once per job (one size query followed by one data read): after a successful read the temporary module file is deleted.
 *
 * @param[in] pSMCJob - SMCJob instance.
 * @param[in] nDataBufferSize - Number of elements in buffer
@@ -387,6 +387,24 @@ LIBMCDRIVER_SCANLABSMC_DECLSPEC LibMCDriver_ScanLabSMCResult libmcdriver_scanlab
 */
 LIBMCDRIVER_SCANLABSMC_DECLSPEC LibMCDriver_ScanLabSMCResult libmcdriver_scanlabsmc_smcconfiguration_getsendtohardware(LibMCDriver_ScanLabSMC_SMCConfiguration pSMCConfiguration, bool * pSendToHardware);
 
+/**
+* Sets if SMC shall write its simulation output files (SimOutputFileDirectory) during job execution. Default is true. Set to false if LoadSimulationData is never called: this saves several GB of disk space and minutes of planning time per large layer.
+*
+* @param[in] pSMCConfiguration - SMCConfiguration instance.
+* @param[in] bEnabled - Flag, if the simulation output files shall be written.
+* @return error code or 0 (success)
+*/
+LIBMCDRIVER_SCANLABSMC_DECLSPEC LibMCDriver_ScanLabSMCResult libmcdriver_scanlabsmc_smcconfiguration_setsimulationfileoutputenabled(LibMCDriver_ScanLabSMC_SMCConfiguration pSMCConfiguration, bool bEnabled);
+
+/**
+* Returns if SMC shall write its simulation output files during job execution.
+*
+* @param[in] pSMCConfiguration - SMCConfiguration instance.
+* @param[out] pEnabled - Flag, if the simulation output files shall be written.
+* @return error code or 0 (success)
+*/
+LIBMCDRIVER_SCANLABSMC_DECLSPEC LibMCDriver_ScanLabSMCResult libmcdriver_scanlabsmc_smcconfiguration_getsimulationfileoutputenabled(LibMCDriver_ScanLabSMC_SMCConfiguration pSMCConfiguration, bool * pEnabled);
+
 /**
 * Sets the RTC Serial number. MUST be larger than 0.
 *
diff --git a/Drivers/ScanLabSMC/Interfaces/libmcdriver_scanlabsmc_interfaces.hpp b/Drivers/ScanLabSMC/Interfaces/libmcdriver_scanlabsmc_interfaces.hpp
index 73283199e..871f49c1f 100644
--- a/Drivers/ScanLabSMC/Interfaces/libmcdriver_scanlabsmc_interfaces.hpp
+++ b/Drivers/ScanLabSMC/Interfaces/libmcdriver_scanlabsmc_interfaces.hpp
@@ -430,13 +430,13 @@ class ISMCJob : public virtual IBase {
 	virtual void StopExecution() = 0;
 
 	/**
-	* ISMCJob::LoadSimulationData - Reads the SMC Simulation data into a data table.
+	* ISMCJob::LoadSimulationData - Reads the SMC Simulation data into a data table. Can be called once per job: after a successful read the simulation output files (or the RTC log record file in hardware mode) are deleted. Fails with SIMULATIONFILEOUTPUTDISABLED if the configuration disabled the simulation file output.
 	* @param[in] pSimulationDataTable - Data table object to read the simulation into.
 	*/
 	virtual void LoadSimulationData(LibMCEnv::PDataTable pSimulationDataTable) = 0;
 
 	/**
-	* ISMCJob::LoadRawSimulationData - Returns raw simulation data.
+	* ISMCJob::LoadRawSimulationData - Returns raw simulation data. Can be called once per job (one size query followed by one data read): after a successful read the temporary module file is deleted.
 	* @param[in] nDataBufferSize - Number of elements in buffer
 	* @param[out] pDataNeededCount - will be filled with the count of the written structs, or needed buffer size.
 	* @param[out] pDataBuffer - uint8 buffer of Raw binary simulation data.
@@ -525,6 +525,18 @@ class ISMCConfiguration : public virtual IBase {
 	*/
 	virtual bool GetSendToHardware() = 0;
 
+	/**
+	* ISMCConfiguration::SetSimulationFileOutputEnabled - Sets if SMC shall write its simulation output files (SimOutputFileDirectory) during job execution. Default is true. Set to false if LoadSimulationData is never called: this saves several GB of disk space and minutes of planning time per large layer.
+	* @param[in] bEnabled - Flag, if the simulation output files shall be written.
+	*/
+	virtual void SetSimulationFileOutputEnabled(const bool bEnabled) = 0;
+
+	/**
+	* ISMCConfiguration::GetSimulationFileOutputEnabled - Returns if SMC shall write its simulation output files during job execution.
+	* @return Flag, if the simulation output files shall be written.
+	*/
+	virtual bool GetSimulationFileOutputEnabled() = 0;
+
 	/**
 	* ISMCConfiguration::SetSerialNumber - Sets the RTC Serial number. MUST be larger than 0.
 	* @param[in] nValue - Value to set.
diff --git a/Drivers/ScanLabSMC/Interfaces/libmcdriver_scanlabsmc_interfacewrapper.cpp b/Drivers/ScanLabSMC/Interfaces/libmcdriver_scanlabsmc_interfacewrapper.cpp
index 4fa02c149..b632dedb1 100644
--- a/Drivers/ScanLabSMC/Interfaces/libmcdriver_scanlabsmc_interfacewrapper.cpp
+++ b/Drivers/ScanLabSMC/Interfaces/libmcdriver_scanlabsmc_interfacewrapper.cpp
@@ -983,6 +983,56 @@ LibMCDriver_ScanLabSMCResult libmcdriver_scanlabsmc_smcconfiguration_getsendtoha
 	}
 }
 
+LibMCDriver_ScanLabSMCResult libmcdriver_scanlabsmc_smcconfiguration_setsimulationfileoutputenabled(LibMCDriver_ScanLabSMC_SMCConfiguration pSMCConfiguration, bool bEnabled)
+{
+	IBase* pIBaseClass = (IBase *)pSMCConfiguration;
+
+	try {
+		ISMCConfiguration* pISMCConfiguration = dynamic_cast<ISMCConfiguration*>(pIBaseClass);
+		if (!pISMCConfiguration)
+			throw ELibMCDriver_ScanLabSMCInterfaceException(LIBMCDRIVER_SCANLABSMC_ERROR_INVALIDCAST);
+		
+		pISMCConfiguration->SetSimulationFileOutputEnabled(bEnabled);
+
+		return LIBMCDRIVER_SCANLABSMC_SUCCESS;
+	}
+	catch (ELibMCDriver_ScanLabSMCInterfaceException & Exception) {
+		return handleLibMCDriver_ScanLabSMCException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCDriver_ScanLabSMCResult libmcdriver_scanlabsmc_smcconfiguration_getsimulationfileoutputenabled(LibMCDriver_ScanLabSMC_SMCConfiguration pSMCConfiguration, bool * pEnabled)
+{
+	IBase* pIBaseClass = (IBase *)pSMCConfiguration;
+
+	try {
+		if (pEnabled == nullptr)
+			throw ELibMCDriver_ScanLabSMCInterfaceException (LIBMCDRIVER_SCANLABSMC_ERROR_INVALIDPARAM);
+		ISMCConfiguration* pISMCConfiguration = dynamic_cast<ISMCConfiguration*>(pIBaseClass);
+		if (!pISMCConfiguration)
+			throw ELibMCDriver_ScanLabSMCInterfaceException(LIBMCDRIVER_SCANLABSMC_ERROR_INVALIDCAST);
+		
+		*pEnabled = pISMCConfiguration->GetSimulationFileOutputEnabled();
+
+		return LIBMCDRIVER_SCANLABSMC_SUCCESS;
+	}
+	catch (ELibMCDriver_ScanLabSMCInterfaceException & Exception) {
+		return handleLibMCDriver_ScanLabSMCException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
 LibMCDriver_ScanLabSMCResult libmcdriver_scanlabsmc_smcconfiguration_setserialnumber(LibMCDriver_ScanLabSMC_SMCConfiguration pSMCConfiguration, LibMCDriver_ScanLabSMC_uint32 nValue)
 {
 	IBase* pIBaseClass = (IBase *)pSMCConfiguration;
@@ -2297,6 +2347,10 @@ LibMCDriver_ScanLabSMCResult LibMCDriver_ScanLabSMC::Impl::LibMCDriver_ScanLabSM
 		*ppProcAddress = (void*) &libmcdriver_scanlabsmc_smcconfiguration_setsendtohardware;
 	if (sProcName == "libmcdriver_scanlabsmc_smcconfiguration_getsendtohardware") 
 		*ppProcAddress = (void*) &libmcdriver_scanlabsmc_smcconfiguration_getsendtohardware;
+	if (sProcName == "libmcdriver_scanlabsmc_smcconfiguration_setsimulationfileoutputenabled") 
+		*ppProcAddress = (void*) &libmcdriver_scanlabsmc_smcconfiguration_setsimulationfileoutputenabled;
+	if (sProcName == "libmcdriver_scanlabsmc_smcconfiguration_getsimulationfileoutputenabled") 
+		*ppProcAddress = (void*) &libmcdriver_scanlabsmc_smcconfiguration_getsimulationfileoutputenabled;
 	if (sProcName == "libmcdriver_scanlabsmc_smcconfiguration_setserialnumber") 
 		*ppProcAddress = (void*) &libmcdriver_scanlabsmc_smcconfiguration_setserialnumber;
 	if (sProcName == "libmcdriver_scanlabsmc_smcconfiguration_getserialnumber") 
diff --git a/Drivers/ScanLabSMC/Interfaces/libmcdriver_scanlabsmc_types.hpp b/Drivers/ScanLabSMC/Interfaces/libmcdriver_scanlabsmc_types.hpp
index 8f31e9a16..9fede9330 100644
--- a/Drivers/ScanLabSMC/Interfaces/libmcdriver_scanlabsmc_types.hpp
+++ b/Drivers/ScanLabSMC/Interfaces/libmcdriver_scanlabsmc_types.hpp
@@ -164,6 +164,7 @@ typedef void * LibMCDriver_ScanLabSMC_pvoid;
 #define LIBMCDRIVER_SCANLABSMC_ERROR_INVALIDMAXPOWERVALUE 1056 /** Invalid max power value. */
 #define LIBMCDRIVER_SCANLABSMC_ERROR_SIMULATIONWORKINGFILEISNOTINITIALIZED 1057 /** Simulation working file is not initialized. */
 #define LIBMCDRIVER_SCANLABSMC_ERROR_SIMULATIONWORKINGFILESIZEMISMATCH 1058 /** Simulation working file size mismatch. */
+#define LIBMCDRIVER_SCANLABSMC_ERROR_SIMULATIONFILEOUTPUTDISABLED 1059 /** Simulation file output has been disabled in the SMC configuration, LoadSimulationData is not available. */
 
 /*************************************************************************************************************************
  Error strings for LibMCDriver_ScanLabSMC
@@ -240,6 +241,7 @@ inline const char * LIBMCDRIVER_SCANLABSMC_GETERRORSTRING (LibMCDriver_ScanLabSM
     case LIBMCDRIVER_SCANLABSMC_ERROR_INVALIDMAXPOWERVALUE: return "Invalid max power value.";
     case LIBMCDRIVER_SCANLABSMC_ERROR_SIMULATIONWORKINGFILEISNOTINITIALIZED: return "Simulation working file is not initialized.";
     case LIBMCDRIVER_SCANLABSMC_ERROR_SIMULATIONWORKINGFILESIZEMISMATCH: return "Simulation working file size mismatch.";
+    case LIBMCDRIVER_SCANLABSMC_ERROR_SIMULATIONFILEOUTPUTDISABLED: return "Simulation file output has been disabled in the SMC configuration, LoadSimulationData is not available.";
     default: return "unknown error";
   }
 }
diff --git a/Framework/HeadersCore/CppDynamic/libmc_dynamic.h b/Framework/HeadersCore/CppDynamic/libmc_dynamic.h
index 0ac4e9017..8025e6219 100644
--- a/Framework/HeadersCore/CppDynamic/libmc_dynamic.h
+++ b/Framework/HeadersCore/CppDynamic/libmc_dynamic.h
@@ -227,6 +227,61 @@ typedef LibMCResult (*PLibMCAPIRequestHandler_GetResultDataPtr) (LibMC_APIReques
 */
 typedef LibMCResult (*PLibMCAPIRequestHandler_GetContentDispositionNamePtr) (LibMC_APIRequestHandler pAPIRequestHandler, const LibMC_uint32 nContentDispositionNameBufferSize, LibMC_uint32* pContentDispositionNameNeededChars, char * pContentDispositionNameBuffer);
 
+/**
+* Sets the network address of the client that sent the request. Call before Handle().
+*
+* @param[in] pAPIRequestHandler - APIRequestHandler instance.
+* @param[in] pAddress - Network address of the client.
+* @return error code or 0 (success)
+*/
+typedef LibMCResult (*PLibMCAPIRequestHandler_SetClientAddressPtr) (LibMC_APIRequestHandler pAPIRequestHandler, const char * pAddress);
+
+/**
+* Returns true if the result is a storage stream that must be sent in chunks with ReadResultStreamChunk instead of a buffer. Call only after Handle().
+*
+* @param[in] pAPIRequestHandler - APIRequestHandler instance.
+* @param[out] pHasStream - Result is a stream.
+* @return error code or 0 (success)
+*/
+typedef LibMCResult (*PLibMCAPIRequestHandler_HasStreamResultPtr) (LibMC_APIRequestHandler pAPIRequestHandler, bool * pHasStream);
+
+/**
+* Returns size and validators of the result stream. Fails if the result is not a stream.
+*
+* @param[in] pAPIRequestHandler - APIRequestHandler instance.
+* @param[out] pSize - Stream size in bytes.
+* @param[in] nETagBufferSize - size of the buffer (including trailing 0)
+* @param[out] pETagNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pETagBuffer -  buffer of Strong entity tag of the stream, without quotes., may be NULL
+* @param[in] nLastModifiedBufferSize - size of the buffer (including trailing 0)
+* @param[out] pLastModifiedNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pLastModifiedBuffer -  buffer of Creation time of the stream as HTTP date., may be NULL
+* @return error code or 0 (success)
+*/
+typedef LibMCResult (*PLibMCAPIRequestHandler_GetResultStreamInfoPtr) (LibMC_APIRequestHandler pAPIRequestHandler, LibMC_uint64 * pSize, const LibMC_uint32 nETagBufferSize, LibMC_uint32* pETagNeededChars, char * pETagBuffer, const LibMC_uint32 nLastModifiedBufferSize, LibMC_uint32* pLastModifiedNeededChars, char * pLastModifiedBuffer);
+
+/**
+* Reads a part of the result stream and records it as sent. Fails if the range is outside the stream, the length exceeds 16 MiB or the download was cancelled.
+*
+* @param[in] pAPIRequestHandler - APIRequestHandler instance.
+* @param[in] nOffset - Start position in bytes.
+* @param[in] nLength - Number of bytes to read.
+* @param[in] nDataBufferSize - Number of elements in buffer
+* @param[out] pDataNeededCount - will be filled with the count of the written elements, or needed buffer size.
+* @param[out] pDataBuffer - uint8  buffer of Data that was read.
+* @return error code or 0 (success)
+*/
+typedef LibMCResult (*PLibMCAPIRequestHandler_ReadResultStreamChunkPtr) (LibMC_APIRequestHandler pAPIRequestHandler, LibMC_uint64 nOffset, LibMC_uint64 nLength, const LibMC_uint64 nDataBufferSize, LibMC_uint64* pDataNeededCount, LibMC_uint8 * pDataBuffer);
+
+/**
+* Reports that sending the result stream has ended. May be called more than once and without any chunk having been read.
+*
+* @param[in] pAPIRequestHandler - APIRequestHandler instance.
+* @param[in] bSuccess - All requested bytes were sent.
+* @return error code or 0 (success)
+*/
+typedef LibMCResult (*PLibMCAPIRequestHandler_FinishStreamResultPtr) (LibMC_APIRequestHandler pAPIRequestHandler, bool bSuccess);
+
 /*************************************************************************************************************************
  Class definition for MCContext
 **************************************************************************************************************************/
@@ -457,6 +512,11 @@ typedef struct {
 	PLibMCAPIRequestHandler_HandlePtr m_APIRequestHandler_Handle;
 	PLibMCAPIRequestHandler_GetResultDataPtr m_APIRequestHandler_GetResultData;
 	PLibMCAPIRequestHandler_GetContentDispositionNamePtr m_APIRequestHandler_GetContentDispositionName;
+	PLibMCAPIRequestHandler_SetClientAddressPtr m_APIRequestHandler_SetClientAddress;
+	PLibMCAPIRequestHandler_HasStreamResultPtr m_APIRequestHandler_HasStreamResult;
+	PLibMCAPIRequestHandler_GetResultStreamInfoPtr m_APIRequestHandler_GetResultStreamInfo;
+	PLibMCAPIRequestHandler_ReadResultStreamChunkPtr m_APIRequestHandler_ReadResultStreamChunk;
+	PLibMCAPIRequestHandler_FinishStreamResultPtr m_APIRequestHandler_FinishStreamResult;
 	PLibMCMCContext_RegisterLibraryPathPtr m_MCContext_RegisterLibraryPath;
 	PLibMCMCContext_SetTempBasePathPtr m_MCContext_SetTempBasePath;
 	PLibMCMCContext_ParseConfigurationPtr m_MCContext_ParseConfiguration;
diff --git a/Framework/HeadersCore/CppDynamic/libmc_dynamic.hpp b/Framework/HeadersCore/CppDynamic/libmc_dynamic.hpp
index db17fd7d2..0664fd2d6 100644
--- a/Framework/HeadersCore/CppDynamic/libmc_dynamic.hpp
+++ b/Framework/HeadersCore/CppDynamic/libmc_dynamic.hpp
@@ -812,6 +812,15 @@ class ELibMCException : public std::exception {
 			case LIBMC_ERROR_INVALIDTELEMETRYSETTING: return "INVALIDTELEMETRYSETTING";
 			case LIBMC_ERROR_INVALIDTOOLPATHPROFILEINDEX: return "INVALIDTOOLPATHPROFILEINDEX";
 			case LIBMC_ERROR_INVALIDTOOLPATHMODIFIERINDEX: return "INVALIDTOOLPATHMODIFIERINDEX";
+			case LIBMC_ERROR_NOSTREAMRESULT: return "NOSTREAMRESULT";
+			case LIBMC_ERROR_DOWNLOADCANCELLED: return "DOWNLOADCANCELLED";
+			case LIBMC_ERROR_INVALIDSTREAMCHUNK: return "INVALIDSTREAMCHUNK";
+			case LIBMC_ERROR_DOWNLOADTICKETEXPIRED: return "DOWNLOADTICKETEXPIRED";
+			case LIBMC_ERROR_TOOMANYDOWNLOADS: return "TOOMANYDOWNLOADS";
+			case LIBMC_ERROR_CLIENTACTIONNOTFOUND: return "CLIENTACTIONNOTFOUND";
+			case LIBMC_ERROR_CLIENTACTIONALREADYCLAIMED: return "CLIENTACTIONALREADYCLAIMED";
+			case LIBMC_ERROR_STREAMHASACTIVEDOWNLOADS: return "STREAMHASACTIVEDOWNLOADS";
+			case LIBMC_ERROR_SESSIONHANDLERNOTAVAILABLE: return "SESSIONHANDLERNOTAVAILABLE";
 		}
 		return "UNKNOWN";
 	}
@@ -1458,6 +1467,15 @@ class ELibMCException : public std::exception {
 			case LIBMC_ERROR_INVALIDTELEMETRYSETTING: return "Invalid telemetry setting.";
 			case LIBMC_ERROR_INVALIDTOOLPATHPROFILEINDEX: return "Invalid toolpath profile index.";
 			case LIBMC_ERROR_INVALIDTOOLPATHMODIFIERINDEX: return "Invalid toolpath modifier index.";
+			case LIBMC_ERROR_NOSTREAMRESULT: return "API response is not a stream.";
+			case LIBMC_ERROR_DOWNLOADCANCELLED: return "Download was cancelled.";
+			case LIBMC_ERROR_INVALIDSTREAMCHUNK: return "Invalid stream chunk range.";
+			case LIBMC_ERROR_DOWNLOADTICKETEXPIRED: return "Download ticket has expired or has been revoked.";
+			case LIBMC_ERROR_TOOMANYDOWNLOADS: return "Too many concurrent downloads.";
+			case LIBMC_ERROR_CLIENTACTIONNOTFOUND: return "Client action not found.";
+			case LIBMC_ERROR_CLIENTACTIONALREADYCLAIMED: return "Client action has already been claimed.";
+			case LIBMC_ERROR_STREAMHASACTIVEDOWNLOADS: return "Storage stream has active downloads.";
+			case LIBMC_ERROR_SESSIONHANDLERNOTAVAILABLE: return "Session handler is not available.";
 		}
 		return "unknown error";
 	}
@@ -1705,6 +1723,11 @@ class CAPIRequestHandler : public CBase {
 	inline void Handle(const CInputVector<LibMC_uint8> & RawBodyBuffer, std::string & sContentType, LibMC_uint32 & nHTTPCode);
 	inline void GetResultData(std::vector<LibMC_uint8> & DataBuffer);
 	inline std::string GetContentDispositionName();
+	inline void SetClientAddress(const std::string & sAddress);
+	inline bool HasStreamResult();
+	inline void GetResultStreamInfo(LibMC_uint64 & nSize, std::string & sETag, std::string & sLastModified);
+	inline void ReadResultStreamChunk(const LibMC_uint64 nOffset, const LibMC_uint64 nLength, std::vector<LibMC_uint8> & DataBuffer);
+	inline void FinishStreamResult(const bool bSuccess);
 };
 	
 /*************************************************************************************************************************
@@ -1861,6 +1884,11 @@ class CMCContext : public CBase {
 		pWrapperTable->m_APIRequestHandler_Handle = nullptr;
 		pWrapperTable->m_APIRequestHandler_GetResultData = nullptr;
 		pWrapperTable->m_APIRequestHandler_GetContentDispositionName = nullptr;
+		pWrapperTable->m_APIRequestHandler_SetClientAddress = nullptr;
+		pWrapperTable->m_APIRequestHandler_HasStreamResult = nullptr;
+		pWrapperTable->m_APIRequestHandler_GetResultStreamInfo = nullptr;
+		pWrapperTable->m_APIRequestHandler_ReadResultStreamChunk = nullptr;
+		pWrapperTable->m_APIRequestHandler_FinishStreamResult = nullptr;
 		pWrapperTable->m_MCContext_RegisterLibraryPath = nullptr;
 		pWrapperTable->m_MCContext_SetTempBasePath = nullptr;
 		pWrapperTable->m_MCContext_ParseConfiguration = nullptr;
@@ -2076,6 +2104,51 @@ class CMCContext : public CBase {
 		if (pWrapperTable->m_APIRequestHandler_GetContentDispositionName == nullptr)
 			return LIBMC_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
+		#ifdef _WIN32
+		pWrapperTable->m_APIRequestHandler_SetClientAddress = (PLibMCAPIRequestHandler_SetClientAddressPtr) GetProcAddress(hLibrary, "libmc_apirequesthandler_setclientaddress");
+		#else // _WIN32
+		pWrapperTable->m_APIRequestHandler_SetClientAddress = (PLibMCAPIRequestHandler_SetClientAddressPtr) dlsym(hLibrary, "libmc_apirequesthandler_setclientaddress");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_APIRequestHandler_SetClientAddress == nullptr)
+			return LIBMC_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_APIRequestHandler_HasStreamResult = (PLibMCAPIRequestHandler_HasStreamResultPtr) GetProcAddress(hLibrary, "libmc_apirequesthandler_hasstreamresult");
+		#else // _WIN32
+		pWrapperTable->m_APIRequestHandler_HasStreamResult = (PLibMCAPIRequestHandler_HasStreamResultPtr) dlsym(hLibrary, "libmc_apirequesthandler_hasstreamresult");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_APIRequestHandler_HasStreamResult == nullptr)
+			return LIBMC_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_APIRequestHandler_GetResultStreamInfo = (PLibMCAPIRequestHandler_GetResultStreamInfoPtr) GetProcAddress(hLibrary, "libmc_apirequesthandler_getresultstreaminfo");
+		#else // _WIN32
+		pWrapperTable->m_APIRequestHandler_GetResultStreamInfo = (PLibMCAPIRequestHandler_GetResultStreamInfoPtr) dlsym(hLibrary, "libmc_apirequesthandler_getresultstreaminfo");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_APIRequestHandler_GetResultStreamInfo == nullptr)
+			return LIBMC_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_APIRequestHandler_ReadResultStreamChunk = (PLibMCAPIRequestHandler_ReadResultStreamChunkPtr) GetProcAddress(hLibrary, "libmc_apirequesthandler_readresultstreamchunk");
+		#else // _WIN32
+		pWrapperTable->m_APIRequestHandler_ReadResultStreamChunk = (PLibMCAPIRequestHandler_ReadResultStreamChunkPtr) dlsym(hLibrary, "libmc_apirequesthandler_readresultstreamchunk");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_APIRequestHandler_ReadResultStreamChunk == nullptr)
+			return LIBMC_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_APIRequestHandler_FinishStreamResult = (PLibMCAPIRequestHandler_FinishStreamResultPtr) GetProcAddress(hLibrary, "libmc_apirequesthandler_finishstreamresult");
+		#else // _WIN32
+		pWrapperTable->m_APIRequestHandler_FinishStreamResult = (PLibMCAPIRequestHandler_FinishStreamResultPtr) dlsym(hLibrary, "libmc_apirequesthandler_finishstreamresult");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_APIRequestHandler_FinishStreamResult == nullptr)
+			return LIBMC_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
 		#ifdef _WIN32
 		pWrapperTable->m_MCContext_RegisterLibraryPath = (PLibMCMCContext_RegisterLibraryPathPtr) GetProcAddress(hLibrary, "libmc_mccontext_registerlibrarypath");
 		#else // _WIN32
@@ -2345,6 +2418,26 @@ class CMCContext : public CBase {
 		if ( (eLookupError != 0) || (pWrapperTable->m_APIRequestHandler_GetContentDispositionName == nullptr) )
 			return LIBMC_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
+		eLookupError = (*pLookup)("libmc_apirequesthandler_setclientaddress", (void**)&(pWrapperTable->m_APIRequestHandler_SetClientAddress));
+		if ( (eLookupError != 0) || (pWrapperTable->m_APIRequestHandler_SetClientAddress == nullptr) )
+			return LIBMC_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmc_apirequesthandler_hasstreamresult", (void**)&(pWrapperTable->m_APIRequestHandler_HasStreamResult));
+		if ( (eLookupError != 0) || (pWrapperTable->m_APIRequestHandler_HasStreamResult == nullptr) )
+			return LIBMC_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmc_apirequesthandler_getresultstreaminfo", (void**)&(pWrapperTable->m_APIRequestHandler_GetResultStreamInfo));
+		if ( (eLookupError != 0) || (pWrapperTable->m_APIRequestHandler_GetResultStreamInfo == nullptr) )
+			return LIBMC_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmc_apirequesthandler_readresultstreamchunk", (void**)&(pWrapperTable->m_APIRequestHandler_ReadResultStreamChunk));
+		if ( (eLookupError != 0) || (pWrapperTable->m_APIRequestHandler_ReadResultStreamChunk == nullptr) )
+			return LIBMC_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmc_apirequesthandler_finishstreamresult", (void**)&(pWrapperTable->m_APIRequestHandler_FinishStreamResult));
+		if ( (eLookupError != 0) || (pWrapperTable->m_APIRequestHandler_FinishStreamResult == nullptr) )
+			return LIBMC_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
 		eLookupError = (*pLookup)("libmc_mccontext_registerlibrarypath", (void**)&(pWrapperTable->m_MCContext_RegisterLibraryPath));
 		if ( (eLookupError != 0) || (pWrapperTable->m_MCContext_RegisterLibraryPath == nullptr) )
 			return LIBMC_ERROR_COULDNOTFINDLIBRARYEXPORT;
@@ -2655,6 +2748,71 @@ class CMCContext : public CBase {
 		return std::string(&bufferContentDispositionName[0]);
 	}
 	
+	/**
+	* CAPIRequestHandler::SetClientAddress - Sets the network address of the client that sent the request. Call before Handle().
+	* @param[in] sAddress - Network address of the client.
+	*/
+	void CAPIRequestHandler::SetClientAddress(const std::string & sAddress)
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_APIRequestHandler_SetClientAddress(m_pHandle, sAddress.c_str()));
+	}
+	
+	/**
+	* CAPIRequestHandler::HasStreamResult - Returns true if the result is a storage stream that must be sent in chunks with ReadResultStreamChunk instead of a buffer. Call only after Handle().
+	* @return Result is a stream.
+	*/
+	bool CAPIRequestHandler::HasStreamResult()
+	{
+		bool resultHasStream = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_APIRequestHandler_HasStreamResult(m_pHandle, &resultHasStream));
+		
+		return resultHasStream;
+	}
+	
+	/**
+	* CAPIRequestHandler::GetResultStreamInfo - Returns size and validators of the result stream. Fails if the result is not a stream.
+	* @param[out] nSize - Stream size in bytes.
+	* @param[out] sETag - Strong entity tag of the stream, without quotes.
+	* @param[out] sLastModified - Creation time of the stream as HTTP date.
+	*/
+	void CAPIRequestHandler::GetResultStreamInfo(LibMC_uint64 & nSize, std::string & sETag, std::string & sLastModified)
+	{
+		LibMC_uint32 bytesNeededETag = 0;
+		LibMC_uint32 bytesWrittenETag = 0;
+		LibMC_uint32 bytesNeededLastModified = 0;
+		LibMC_uint32 bytesWrittenLastModified = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_APIRequestHandler_GetResultStreamInfo(m_pHandle, &nSize, 0, &bytesNeededETag, nullptr, 0, &bytesNeededLastModified, nullptr));
+		std::vector<char> bufferETag(bytesNeededETag);
+		std::vector<char> bufferLastModified(bytesNeededLastModified);
+		CheckError(m_pWrapper->m_WrapperTable.m_APIRequestHandler_GetResultStreamInfo(m_pHandle, &nSize, bytesNeededETag, &bytesWrittenETag, &bufferETag[0], bytesNeededLastModified, &bytesWrittenLastModified, &bufferLastModified[0]));
+		sETag = std::string(&bufferETag[0]);
+		sLastModified = std::string(&bufferLastModified[0]);
+	}
+	
+	/**
+	* CAPIRequestHandler::ReadResultStreamChunk - Reads a part of the result stream and records it as sent. Fails if the range is outside the stream, the length exceeds 16 MiB or the download was cancelled.
+	* @param[in] nOffset - Start position in bytes.
+	* @param[in] nLength - Number of bytes to read.
+	* @param[out] DataBuffer - Data that was read.
+	*/
+	void CAPIRequestHandler::ReadResultStreamChunk(const LibMC_uint64 nOffset, const LibMC_uint64 nLength, std::vector<LibMC_uint8> & DataBuffer)
+	{
+		LibMC_uint64 elementsNeededData = 0;
+		LibMC_uint64 elementsWrittenData = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_APIRequestHandler_ReadResultStreamChunk(m_pHandle, nOffset, nLength, 0, &elementsNeededData, nullptr));
+		DataBuffer.resize((size_t) elementsNeededData);
+		CheckError(m_pWrapper->m_WrapperTable.m_APIRequestHandler_ReadResultStreamChunk(m_pHandle, nOffset, nLength, elementsNeededData, &elementsWrittenData, DataBuffer.data()));
+	}
+	
+	/**
+	* CAPIRequestHandler::FinishStreamResult - Reports that sending the result stream has ended. May be called more than once and without any chunk having been read.
+	* @param[in] bSuccess - All requested bytes were sent.
+	*/
+	void CAPIRequestHandler::FinishStreamResult(const bool bSuccess)
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_APIRequestHandler_FinishStreamResult(m_pHandle, bSuccess));
+	}
+	
 	/**
 	 * Method definitions for class CMCContext
 	 */
diff --git a/Framework/HeadersCore/CppDynamic/libmc_types.hpp b/Framework/HeadersCore/CppDynamic/libmc_types.hpp
index 3166875d8..a3453bd14 100644
--- a/Framework/HeadersCore/CppDynamic/libmc_types.hpp
+++ b/Framework/HeadersCore/CppDynamic/libmc_types.hpp
@@ -734,6 +734,15 @@ typedef void * LibMC_pvoid;
 #define LIBMC_ERROR_INVALIDTELEMETRYSETTING 718 /** Invalid telemetry setting. */
 #define LIBMC_ERROR_INVALIDTOOLPATHPROFILEINDEX 719 /** Invalid toolpath profile index. */
 #define LIBMC_ERROR_INVALIDTOOLPATHMODIFIERINDEX 720 /** Invalid toolpath modifier index. */
+#define LIBMC_ERROR_NOSTREAMRESULT 721 /** API response is not a stream. */
+#define LIBMC_ERROR_DOWNLOADCANCELLED 722 /** Download was cancelled. */
+#define LIBMC_ERROR_INVALIDSTREAMCHUNK 723 /** Invalid stream chunk range. */
+#define LIBMC_ERROR_DOWNLOADTICKETEXPIRED 724 /** Download ticket has expired or has been revoked. */
+#define LIBMC_ERROR_TOOMANYDOWNLOADS 725 /** Too many concurrent downloads. */
+#define LIBMC_ERROR_CLIENTACTIONNOTFOUND 726 /** Client action not found. */
+#define LIBMC_ERROR_CLIENTACTIONALREADYCLAIMED 727 /** Client action has already been claimed. */
+#define LIBMC_ERROR_STREAMHASACTIVEDOWNLOADS 728 /** Storage stream has active downloads. */
+#define LIBMC_ERROR_SESSIONHANDLERNOTAVAILABLE 729 /** Session handler is not available. */
 
 /*************************************************************************************************************************
  Error strings for LibMC
@@ -1380,6 +1389,15 @@ inline const char * LIBMC_GETERRORSTRING (LibMCResult nErrorCode) {
     case LIBMC_ERROR_INVALIDTELEMETRYSETTING: return "Invalid telemetry setting.";
     case LIBMC_ERROR_INVALIDTOOLPATHPROFILEINDEX: return "Invalid toolpath profile index.";
     case LIBMC_ERROR_INVALIDTOOLPATHMODIFIERINDEX: return "Invalid toolpath modifier index.";
+    case LIBMC_ERROR_NOSTREAMRESULT: return "API response is not a stream.";
+    case LIBMC_ERROR_DOWNLOADCANCELLED: return "Download was cancelled.";
+    case LIBMC_ERROR_INVALIDSTREAMCHUNK: return "Invalid stream chunk range.";
+    case LIBMC_ERROR_DOWNLOADTICKETEXPIRED: return "Download ticket has expired or has been revoked.";
+    case LIBMC_ERROR_TOOMANYDOWNLOADS: return "Too many concurrent downloads.";
+    case LIBMC_ERROR_CLIENTACTIONNOTFOUND: return "Client action not found.";
+    case LIBMC_ERROR_CLIENTACTIONALREADYCLAIMED: return "Client action has already been claimed.";
+    case LIBMC_ERROR_STREAMHASACTIVEDOWNLOADS: return "Storage stream has active downloads.";
+    case LIBMC_ERROR_SESSIONHANDLERNOTAVAILABLE: return "Session handler is not available.";
     default: return "unknown error";
   }
 }
diff --git a/Framework/HeadersCore/CppDynamic/libmcdata_dynamic.h b/Framework/HeadersCore/CppDynamic/libmcdata_dynamic.h
index d8b18fdf3..f21eb9535 100644
--- a/Framework/HeadersCore/CppDynamic/libmcdata_dynamic.h
+++ b/Framework/HeadersCore/CppDynamic/libmcdata_dynamic.h
@@ -1156,6 +1156,14 @@ typedef LibMCDataResult (*PLibMCDataStorageZIPWriter_FinishPtr) (LibMCData_Stora
 */
 typedef LibMCDataResult (*PLibMCDataStorageZIPWriter_IsFinishedPtr) (LibMCData_StorageZIPWriter pStorageZIPWriter, bool * pFinished);
 
+/**
+* Discards an unfinished ZIP stream. The file on disk and the stream entry are deleted. Fails if the stream has been finished already. A ZIP writer that is released without Finish is discarded automatically.
+*
+* @param[in] pStorageZIPWriter - StorageZIPWriter instance.
+* @return error code or 0 (success)
+*/
+typedef LibMCDataResult (*PLibMCDataStorageZIPWriter_DiscardPtr) (LibMCData_StorageZIPWriter pStorageZIPWriter);
+
 /*************************************************************************************************************************
  Class definition for Storage
 **************************************************************************************************************************/
@@ -1364,6 +1372,95 @@ typedef LibMCDataResult (*PLibMCDataStorage_CreateDownloadTicketPtr) (LibMCData_
 */
 typedef LibMCDataResult (*PLibMCDataStorage_RequestDownloadTicketPtr) (LibMCData_Storage pStorage, const char * pTicketUUID, const char * pIPAddress, LibMCData_uint64 nAbsoluteTimeStamp, const LibMCData_uint32 nStreamUUIDBufferSize, LibMCData_uint32* pStreamUUIDNeededChars, char * pStreamUUIDBuffer, const LibMCData_uint32 nClientFileNameBufferSize, LibMCData_uint32* pClientFileNameNeededChars, char * pClientFileNameBuffer, const LibMCData_uint32 nSessionUUIDBufferSize, LibMCData_uint32* pSessionUUIDNeededChars, char * pSessionUUIDBuffer, const LibMCData_uint32 nUserUUIDBufferSize, LibMCData_uint32* pUserUUIDNeededChars, char * pUserUUIDBuffer);
 
+/**
+* Returns the details of a download ticket without creating an access log entry. Fails if the ticket does not exist.
+*
+* @param[in] pStorage - Storage instance.
+* @param[in] pTicketUUID - UUID of download ticket.
+* @param[in] nStreamUUIDBufferSize - size of the buffer (including trailing 0)
+* @param[out] pStreamUUIDNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pStreamUUIDBuffer -  buffer of UUID of storage stream., may be NULL
+* @param[in] nClientFileNameBufferSize - size of the buffer (including trailing 0)
+* @param[out] pClientFileNameNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pClientFileNameBuffer -  buffer of ClientFileName of the ticket., may be NULL
+* @param[in] nSessionUUIDBufferSize - size of the buffer (including trailing 0)
+* @param[out] pSessionUUIDNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pSessionUUIDBuffer -  buffer of UUID of user session., may be NULL
+* @param[in] nUserUUIDBufferSize - size of the buffer (including trailing 0)
+* @param[out] pUserUUIDNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pUserUUIDBuffer -  buffer of UUID of user that created the ticket., may be NULL
+* @param[out] pCreationTimeStamp - Creation time of the ticket in microseconds since 1970.
+* @param[out] pRevoked - True if the ticket has been revoked.
+* @return error code or 0 (success)
+*/
+typedef LibMCDataResult (*PLibMCDataStorage_GetDownloadTicketDetailsPtr) (LibMCData_Storage pStorage, const char * pTicketUUID, const LibMCData_uint32 nStreamUUIDBufferSize, LibMCData_uint32* pStreamUUIDNeededChars, char * pStreamUUIDBuffer, const LibMCData_uint32 nClientFileNameBufferSize, LibMCData_uint32* pClientFileNameNeededChars, char * pClientFileNameBuffer, const LibMCData_uint32 nSessionUUIDBufferSize, LibMCData_uint32* pSessionUUIDNeededChars, char * pSessionUUIDBuffer, const LibMCData_uint32 nUserUUIDBufferSize, LibMCData_uint32* pUserUUIDNeededChars, char * pUserUUIDBuffer, LibMCData_uint64 * pCreationTimeStamp, bool * pRevoked);
+
+/**
+* Revokes all download tickets of a stream. Revoked tickets can not be used for downloads anymore.
+*
+* @param[in] pStorage - Storage instance.
+* @param[in] pStreamUUID - UUID of storage stream.
+* @param[out] pRevokedCount - Number of tickets that were revoked by this call.
+* @return error code or 0 (success)
+*/
+typedef LibMCDataResult (*PLibMCDataStorage_RevokeDownloadTicketsOfStreamPtr) (LibMCData_Storage pStorage, const char * pStreamUUID, LibMCData_uint32 * pRevokedCount);
+
+/**
+* Creates an entry in the download access log of a ticket and returns the UUID of the entry.
+*
+* @param[in] pStorage - Storage instance.
+* @param[in] pTicketUUID - UUID of download ticket.
+* @param[in] pIPAddress - IP Address where the request came from.
+* @param[in] nAbsoluteTimeStamp - Absolute Time Stamp in Microseconds since 1970.
+* @param[in] nDownloadUUIDBufferSize - size of the buffer (including trailing 0)
+* @param[out] pDownloadUUIDNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pDownloadUUIDBuffer -  buffer of UUID of the access log entry., may be NULL
+* @return error code or 0 (success)
+*/
+typedef LibMCDataResult (*PLibMCDataStorage_LogDownloadStartPtr) (LibMCData_Storage pStorage, const char * pTicketUUID, const char * pIPAddress, LibMCData_uint64 nAbsoluteTimeStamp, const LibMCData_uint32 nDownloadUUIDBufferSize, LibMCData_uint32* pDownloadUUIDNeededChars, char * pDownloadUUIDBuffer);
+
+/**
+* Records the result of a download in its access log entry. Fails if the entry does not exist.
+*
+* @param[in] pStorage - Storage instance.
+* @param[in] pDownloadUUID - UUID of the access log entry.
+* @param[in] nSentBytes - Number of bytes that were sent to the client.
+* @param[in] bSuccess - True if all requested bytes were sent.
+* @param[in] nAbsoluteTimeStamp - Absolute Time Stamp in Microseconds since 1970.
+* @return error code or 0 (success)
+*/
+typedef LibMCDataResult (*PLibMCDataStorage_LogDownloadFinishPtr) (LibMCData_Storage pStorage, const char * pDownloadUUID, LibMCData_uint64 nSentBytes, bool bSuccess, LibMCData_uint64 nAbsoluteTimeStamp);
+
+/**
+* Deletes a finished stream from disk and database, including its download tickets and journal links. Fails if the stream does not exist or is still being written.
+*
+* @param[in] pStorage - Storage instance.
+* @param[in] pUUID - UUID of storage stream.
+* @return error code or 0 (success)
+*/
+typedef LibMCDataResult (*PLibMCDataStorage_DeleteStreamPtr) (LibMCData_Storage pStorage, const char * pUUID);
+
+/**
+* Deletes all ZIP streams that were never finished and have no active writer, for example after a crash. Returns the number of deleted streams.
+*
+* @param[in] pStorage - Storage instance.
+* @param[out] pDeletedCount - Number of deleted streams.
+* @return error code or 0 (success)
+*/
+typedef LibMCDataResult (*PLibMCDataStorage_DiscardUnfinishedZIPStreamsPtr) (LibMCData_Storage pStorage, LibMCData_uint32 * pDeletedCount);
+
+/**
+* Returns the UUIDs of all finished streams with the given name, newest first, separated by commas.
+*
+* @param[in] pStorage - Storage instance.
+* @param[in] pName - Name of the streams.
+* @param[in] nUUIDListBufferSize - size of the buffer (including trailing 0)
+* @param[out] pUUIDListNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pUUIDListBuffer -  buffer of Comma separated list of stream UUIDs. Empty if there is none., may be NULL
+* @return error code or 0 (success)
+*/
+typedef LibMCDataResult (*PLibMCDataStorage_ListStreamUUIDsByNamePtr) (LibMCData_Storage pStorage, const char * pName, const LibMCData_uint32 nUUIDListBufferSize, LibMCData_uint32* pUUIDListNeededChars, char * pUUIDListBuffer);
+
 /**
 * Attaches a stream to a journal as temporary stream.
 *
@@ -1374,6 +1471,34 @@ typedef LibMCDataResult (*PLibMCDataStorage_RequestDownloadTicketPtr) (LibMCData
 */
 typedef LibMCDataResult (*PLibMCDataStorage_AttachStreamToJournalPtr) (LibMCData_Storage pStorage, const char * pStreamUUID, const char * pJournalUUID);
 
+/**
+* Discards an unfinished random write stream. The data on disk and the stream entry are deleted.
+*
+* @param[in] pStorage - Storage instance.
+* @param[in] pUUID - UUID of storage stream. MUST have been created with BeginRandomWriteStream first and MUST NOT be finished.
+* @return error code or 0 (success)
+*/
+typedef LibMCDataResult (*PLibMCDataStorage_DiscardRandomWriteStreamPtr) (LibMCData_Storage pStorage, const char * pUUID);
+
+/**
+* Returns the size of all data capture segments that are stored on disk.
+*
+* @param[in] pStorage - Storage instance.
+* @param[out] pSizeInBytes - Size in bytes.
+* @return error code or 0 (success)
+*/
+typedef LibMCDataResult (*PLibMCDataStorage_GetDataCaptureStorageSizePtr) (LibMCData_Storage pStorage, LibMCData_uint64 * pSizeInBytes);
+
+/**
+* Deletes the oldest stored data capture segments until the total stored size is within the limit.
+*
+* @param[in] pStorage - Storage instance.
+* @param[in] nLimitInBytes - Maximum total size of all stored data capture segments in bytes.
+* @param[out] pPurgedSegmentCount - Number of segments that have been deleted.
+* @return error code or 0 (success)
+*/
+typedef LibMCDataResult (*PLibMCDataStorage_EnforceDataCaptureStorageLimitPtr) (LibMCData_Storage pStorage, LibMCData_uint64 nLimitInBytes, LibMCData_uint32 * pPurgedSegmentCount);
+
 /*************************************************************************************************************************
  Class definition for CustomDataStream
 **************************************************************************************************************************/
@@ -1560,6 +1685,198 @@ typedef LibMCDataResult (*PLibMCDataBuildJobExecutionData_GetExecutionUUIDPtr) (
 */
 typedef LibMCDataResult (*PLibMCDataBuildJobExecutionDataIterator_GetCurrentJobExecutionDataPtr) (LibMCData_BuildJobExecutionDataIterator pBuildJobExecutionDataIterator, LibMCData_BuildJobExecutionData * pCurrentInstance);
 
+/*************************************************************************************************************************
+ Class definition for DataCapture
+**************************************************************************************************************************/
+
+/**
+* returns the uuid of the data capture.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[in] nUUIDBufferSize - size of the buffer (including trailing 0)
+* @param[out] pUUIDNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pUUIDBuffer -  buffer of UUID String, may be NULL
+* @return error code or 0 (success)
+*/
+typedef LibMCDataResult (*PLibMCDataDataCapture_GetUUIDPtr) (LibMCData_DataCapture pDataCapture, const LibMCData_uint32 nUUIDBufferSize, LibMCData_uint32* pUUIDNeededChars, char * pUUIDBuffer);
+
+/**
+* returns the uuid of the build job execution the capture belongs to.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[in] nExecutionUUIDBufferSize - size of the buffer (including trailing 0)
+* @param[out] pExecutionUUIDNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pExecutionUUIDBuffer -  buffer of UUID String, may be NULL
+* @return error code or 0 (success)
+*/
+typedef LibMCDataResult (*PLibMCDataDataCapture_GetExecutionUUIDPtr) (LibMCData_DataCapture pDataCapture, const LibMCData_uint32 nExecutionUUIDBufferSize, LibMCData_uint32* pExecutionUUIDNeededChars, char * pExecutionUUIDBuffer);
+
+/**
+* returns the identifier of the data capture. It is unique within the build job execution.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[in] nIdentifierBufferSize - size of the buffer (including trailing 0)
+* @param[out] pIdentifierNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pIdentifierBuffer -  buffer of Identifier String, may be NULL
+* @return error code or 0 (success)
+*/
+typedef LibMCDataResult (*PLibMCDataDataCapture_GetIdentifierPtr) (LibMCData_DataCapture pDataCapture, const LibMCData_uint32 nIdentifierBufferSize, LibMCData_uint32* pIdentifierNeededChars, char * pIdentifierBuffer);
+
+/**
+* returns the human readable name of the data capture.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[in] nNameBufferSize - size of the buffer (including trailing 0)
+* @param[out] pNameNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pNameBuffer -  buffer of Name String, may be NULL
+* @return error code or 0 (success)
+*/
+typedef LibMCDataResult (*PLibMCDataDataCapture_GetNamePtr) (LibMCData_DataCapture pDataCapture, const LibMCData_uint32 nNameBufferSize, LibMCData_uint32* pNameNeededChars, char * pNameBuffer);
+
+/**
+* returns the current status of the data capture.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[out] pStatus - Status Value
+* @return error code or 0 (success)
+*/
+typedef LibMCDataResult (*PLibMCDataDataCapture_GetStatusPtr) (LibMCData_DataCapture pDataCapture, LibMCData::eDataCaptureStatus * pStatus);
+
+/**
+* returns the time stamp when the data capture was created.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[in] nTimeStampBufferSize - size of the buffer (including trailing 0)
+* @param[out] pTimeStampNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pTimeStampBuffer -  buffer of Timestamp in ISO8601 UTC format, may be NULL
+* @return error code or 0 (success)
+*/
+typedef LibMCDataResult (*PLibMCDataDataCapture_GetTimeStampPtr) (LibMCData_DataCapture pDataCapture, const LibMCData_uint32 nTimeStampBufferSize, LibMCData_uint32* pTimeStampNeededChars, char * pTimeStampBuffer);
+
+/**
+* Registers a column of the capture schema. Fails if the capture is not recording or the column index already exists.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[in] nColumnIndex - Index of the column. 0-based.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] pDescription - Description of the column.
+* @param[in] nColumnType - Data type of the column as numeric data table column type.
+* @return error code or 0 (success)
+*/
+typedef LibMCDataResult (*PLibMCDataDataCapture_AddColumnPtr) (LibMCData_DataCapture pDataCapture, LibMCData_uint32 nColumnIndex, const char * pIdentifier, const char * pDescription, LibMCData_uint32 nColumnType);
+
+/**
+* returns the number of columns of the capture schema.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[out] pColumnCount - Number of columns.
+* @return error code or 0 (success)
+*/
+typedef LibMCDataResult (*PLibMCDataDataCapture_GetColumnCountPtr) (LibMCData_DataCapture pDataCapture, LibMCData_uint32 * pColumnCount);
+
+/**
+* returns the schema information of a column. Fails if the index does not exist.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[in] nColumnIndex - Index of the column. 0-based.
+* @param[in] nIdentifierBufferSize - size of the buffer (including trailing 0)
+* @param[out] pIdentifierNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pIdentifierBuffer -  buffer of Identifier of the column., may be NULL
+* @param[in] nDescriptionBufferSize - size of the buffer (including trailing 0)
+* @param[out] pDescriptionNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pDescriptionBuffer -  buffer of Description of the column., may be NULL
+* @param[out] pColumnType - Data type of the column as numeric data table column type.
+* @return error code or 0 (success)
+*/
+typedef LibMCDataResult (*PLibMCDataDataCapture_GetColumnInformationPtr) (LibMCData_DataCapture pDataCapture, LibMCData_uint32 nColumnIndex, const LibMCData_uint32 nIdentifierBufferSize, LibMCData_uint32* pIdentifierNeededChars, char * pIdentifierBuffer, const LibMCData_uint32 nDescriptionBufferSize, LibMCData_uint32* pDescriptionNeededChars, char * pDescriptionBuffer, LibMCData_uint32 * pColumnType);
+
+/**
+* Registers a finished segment stream of the capture. Fails if the capture is not recording or the segment index already exists.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[in] nSegmentIndex - Index of the segment. 0-based.
+* @param[in] pStreamUUID - UUID of the storage stream that holds the segment. The stream MUST exist.
+* @param[in] nFirstRow - Index of the first row of the segment within the capture.
+* @param[in] nRowCount - Number of rows in the segment.
+* @param[in] nChunkCount - Number of chunks in the segment.
+* @param[in] nSizeInBytes - Size of the segment stream in bytes.
+* @param[in] nStartTimeStamp - Absolute time stamp in microseconds since 1970 when the segment was opened.
+* @param[in] nEndTimeStamp - Absolute time stamp in microseconds since 1970 when the segment was closed.
+* @return error code or 0 (success)
+*/
+typedef LibMCDataResult (*PLibMCDataDataCapture_AddSegmentPtr) (LibMCData_DataCapture pDataCapture, LibMCData_uint32 nSegmentIndex, const char * pStreamUUID, LibMCData_uint64 nFirstRow, LibMCData_uint64 nRowCount, LibMCData_uint32 nChunkCount, LibMCData_uint64 nSizeInBytes, LibMCData_uint64 nStartTimeStamp, LibMCData_uint64 nEndTimeStamp);
+
+/**
+* returns the number of registered segments, including purged ones.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[out] pSegmentCount - Number of segments.
+* @return error code or 0 (success)
+*/
+typedef LibMCDataResult (*PLibMCDataDataCapture_GetSegmentCountPtr) (LibMCData_DataCapture pDataCapture, LibMCData_uint32 * pSegmentCount);
+
+/**
+* returns the manifest entry of a segment. Fails if the index does not exist.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[in] nSegmentIndex - Index of the segment. 0-based.
+* @param[in] nStreamUUIDBufferSize - size of the buffer (including trailing 0)
+* @param[out] pStreamUUIDNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pStreamUUIDBuffer -  buffer of UUID of the storage stream that holds the segment., may be NULL
+* @param[out] pFirstRow - Index of the first row of the segment within the capture.
+* @param[out] pRowCount - Number of rows in the segment.
+* @param[out] pSizeInBytes - Size of the segment stream in bytes.
+* @param[out] pIsPurged - Returns true if the segment data has been deleted by retention or abort.
+* @return error code or 0 (success)
+*/
+typedef LibMCDataResult (*PLibMCDataDataCapture_GetSegmentInformationPtr) (LibMCData_DataCapture pDataCapture, LibMCData_uint32 nSegmentIndex, const LibMCData_uint32 nStreamUUIDBufferSize, LibMCData_uint32* pStreamUUIDNeededChars, char * pStreamUUIDBuffer, LibMCData_uint64 * pFirstRow, LibMCData_uint64 * pRowCount, LibMCData_uint64 * pSizeInBytes, bool * pIsPurged);
+
+/**
+* returns the number of chunks of a segment. Fails if the index does not exist.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[in] nSegmentIndex - Index of the segment. 0-based.
+* @param[out] pChunkCount - Number of chunks in the segment.
+* @return error code or 0 (success)
+*/
+typedef LibMCDataResult (*PLibMCDataDataCapture_GetSegmentChunkCountPtr) (LibMCData_DataCapture pDataCapture, LibMCData_uint32 nSegmentIndex, LibMCData_uint32 * pChunkCount);
+
+/**
+* returns the number of rows in all registered segments, including purged ones.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[out] pRowCount - Number of rows.
+* @return error code or 0 (success)
+*/
+typedef LibMCDataResult (*PLibMCDataDataCapture_GetRowCountPtr) (LibMCData_DataCapture pDataCapture, LibMCData_uint64 * pRowCount);
+
+/**
+* returns the size of all segments of the capture that are still stored on disk.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[out] pSizeInBytes - Size in bytes.
+* @return error code or 0 (success)
+*/
+typedef LibMCDataResult (*PLibMCDataDataCapture_GetStoredSizeInBytesPtr) (LibMCData_DataCapture pDataCapture, LibMCData_uint64 * pSizeInBytes);
+
+/**
+* Marks the capture as finished. Fails if the capture is not recording.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[in] nAbsoluteTimeStamp - Absolute Time Stamp in Microseconds since 1970.
+* @return error code or 0 (success)
+*/
+typedef LibMCDataResult (*PLibMCDataDataCapture_FinishPtr) (LibMCData_DataCapture pDataCapture, LibMCData_uint64 nAbsoluteTimeStamp);
+
+/**
+* Deletes all stored segments of the capture and marks it as aborted. Fails if the capture has been aborted before.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[in] nAbsoluteTimeStamp - Absolute Time Stamp in Microseconds since 1970.
+* @return error code or 0 (success)
+*/
+typedef LibMCDataResult (*PLibMCDataDataCapture_AbortPtr) (LibMCData_DataCapture pDataCapture, LibMCData_uint64 nAbsoluteTimeStamp);
+
 /*************************************************************************************************************************
  Class definition for BuildJobExecution
 **************************************************************************************************************************/
@@ -1836,6 +2153,58 @@ typedef LibMCDataResult (*PLibMCDataBuildJobExecution_HasMetaDataStringPtr) (Lib
 */
 typedef LibMCDataResult (*PLibMCDataBuildJobExecution_GetMetaDataStringPtr) (LibMCData_BuildJobExecution pBuildJobExecution, const char * pKey, const LibMCData_uint32 nValueBufferSize, LibMCData_uint32* pValueNeededChars, char * pValueBuffer);
 
+/**
+* Creates the manifest of a new data capture in recording state. Fails if the identifier already exists in this execution.
+*
+* @param[in] pBuildJobExecution - BuildJobExecution instance.
+* @param[in] pIdentifier - Identifier of the capture. MUST be unique within the execution, alphanumeric and not empty.
+* @param[in] pName - Human readable name of the capture. MUST NOT be empty.
+* @param[in] pUserUUID - UUID of the user that started the capture. Use 00000000-0000-0000-0000-000000000000 if no user shall be recorded.
+* @param[in] nAbsoluteTimeStamp - Absolute Time Stamp in Microseconds since 1970.
+* @param[out] pDataCaptureInstance - Data capture manifest instance.
+* @return error code or 0 (success)
+*/
+typedef LibMCDataResult (*PLibMCDataBuildJobExecution_CreateDataCapturePtr) (LibMCData_BuildJobExecution pBuildJobExecution, const char * pIdentifier, const char * pName, const char * pUserUUID, LibMCData_uint64 nAbsoluteTimeStamp, LibMCData_DataCapture * pDataCaptureInstance);
+
+/**
+* Returns if a data capture with a specific identifier exists in this execution.
+*
+* @param[in] pBuildJobExecution - BuildJobExecution instance.
+* @param[in] pIdentifier - Identifier of the capture.
+* @param[out] pHasDataCapture - Returns true, if the data capture exists.
+* @return error code or 0 (success)
+*/
+typedef LibMCDataResult (*PLibMCDataBuildJobExecution_HasDataCapturePtr) (LibMCData_BuildJobExecution pBuildJobExecution, const char * pIdentifier, bool * pHasDataCapture);
+
+/**
+* Retrieves the manifest of a data capture by its identifier. Fails if the identifier does not exist.
+*
+* @param[in] pBuildJobExecution - BuildJobExecution instance.
+* @param[in] pIdentifier - Identifier of the capture.
+* @param[out] pDataCaptureInstance - Data capture manifest instance.
+* @return error code or 0 (success)
+*/
+typedef LibMCDataResult (*PLibMCDataBuildJobExecution_RetrieveDataCapturePtr) (LibMCData_BuildJobExecution pBuildJobExecution, const char * pIdentifier, LibMCData_DataCapture * pDataCaptureInstance);
+
+/**
+* Returns the number of data captures of this execution.
+*
+* @param[in] pBuildJobExecution - BuildJobExecution instance.
+* @param[out] pDataCaptureCount - Number of data captures.
+* @return error code or 0 (success)
+*/
+typedef LibMCDataResult (*PLibMCDataBuildJobExecution_GetDataCaptureCountPtr) (LibMCData_BuildJobExecution pBuildJobExecution, LibMCData_uint32 * pDataCaptureCount);
+
+/**
+* Retrieves the manifest of a data capture of this execution by its index. Captures are ordered by their creation time.
+*
+* @param[in] pBuildJobExecution - BuildJobExecution instance.
+* @param[in] nIndex - Index of the capture. 0-based. Fails if the index is out of bounds.
+* @param[out] pDataCaptureInstance - Data capture manifest instance.
+* @return error code or 0 (success)
+*/
+typedef LibMCDataResult (*PLibMCDataBuildJobExecution_RetrieveDataCaptureByIndexPtr) (LibMCData_BuildJobExecution pBuildJobExecution, LibMCData_uint32 nIndex, LibMCData_DataCapture * pDataCaptureInstance);
+
 /*************************************************************************************************************************
  Class definition for BuildJobExecutionIterator
 **************************************************************************************************************************/
@@ -2377,6 +2746,16 @@ typedef LibMCDataResult (*PLibMCDataBuildJobHandler_ListJobsChangedSincePtr) (Li
 */
 typedef LibMCDataResult (*PLibMCDataBuildJobHandler_ListJobExecutionsChangedSincePtr) (LibMCData_BuildJobHandler pBuildJobHandler, LibMCData_uint64 nIncrementalID, LibMCData_BuildJobExecutionIterator * pIteratorInstance);
 
+/**
+* Retrieves the manifest of a data capture by its uuid. Fails if the capture does not exist.
+*
+* @param[in] pBuildJobHandler - BuildJobHandler instance.
+* @param[in] pDataCaptureUUID - UUID of the data capture.
+* @param[out] pDataCaptureInstance - Data capture manifest instance.
+* @return error code or 0 (success)
+*/
+typedef LibMCDataResult (*PLibMCDataBuildJobHandler_RetrieveDataCapturePtr) (LibMCData_BuildJobHandler pBuildJobHandler, const char * pDataCaptureUUID, LibMCData_DataCapture * pDataCaptureInstance);
+
 /*************************************************************************************************************************
  Class definition for UserList
 **************************************************************************************************************************/
@@ -3840,6 +4219,7 @@ typedef struct {
 	PLibMCDataStorageZIPWriter_GetZIPStreamSizePtr m_StorageZIPWriter_GetZIPStreamSize;
 	PLibMCDataStorageZIPWriter_FinishPtr m_StorageZIPWriter_Finish;
 	PLibMCDataStorageZIPWriter_IsFinishedPtr m_StorageZIPWriter_IsFinished;
+	PLibMCDataStorageZIPWriter_DiscardPtr m_StorageZIPWriter_Discard;
 	PLibMCDataStorage_StreamIsReadyPtr m_Storage_StreamIsReady;
 	PLibMCDataStorage_RetrieveStreamPtr m_Storage_RetrieveStream;
 	PLibMCDataStorage_StoreNewStreamPtr m_Storage_StoreNewStream;
@@ -3857,7 +4237,17 @@ typedef struct {
 	PLibMCDataStorage_StreamIsImagePtr m_Storage_StreamIsImage;
 	PLibMCDataStorage_CreateDownloadTicketPtr m_Storage_CreateDownloadTicket;
 	PLibMCDataStorage_RequestDownloadTicketPtr m_Storage_RequestDownloadTicket;
+	PLibMCDataStorage_GetDownloadTicketDetailsPtr m_Storage_GetDownloadTicketDetails;
+	PLibMCDataStorage_RevokeDownloadTicketsOfStreamPtr m_Storage_RevokeDownloadTicketsOfStream;
+	PLibMCDataStorage_LogDownloadStartPtr m_Storage_LogDownloadStart;
+	PLibMCDataStorage_LogDownloadFinishPtr m_Storage_LogDownloadFinish;
+	PLibMCDataStorage_DeleteStreamPtr m_Storage_DeleteStream;
+	PLibMCDataStorage_DiscardUnfinishedZIPStreamsPtr m_Storage_DiscardUnfinishedZIPStreams;
+	PLibMCDataStorage_ListStreamUUIDsByNamePtr m_Storage_ListStreamUUIDsByName;
 	PLibMCDataStorage_AttachStreamToJournalPtr m_Storage_AttachStreamToJournal;
+	PLibMCDataStorage_DiscardRandomWriteStreamPtr m_Storage_DiscardRandomWriteStream;
+	PLibMCDataStorage_GetDataCaptureStorageSizePtr m_Storage_GetDataCaptureStorageSize;
+	PLibMCDataStorage_EnforceDataCaptureStorageLimitPtr m_Storage_EnforceDataCaptureStorageLimit;
 	PLibMCDataCustomDataStream_GetDataUUIDPtr m_CustomDataStream_GetDataUUID;
 	PLibMCDataCustomDataStream_GetIdentifierPtr m_CustomDataStream_GetIdentifier;
 	PLibMCDataCustomDataStream_GetNamePtr m_CustomDataStream_GetName;
@@ -3874,6 +4264,23 @@ typedef struct {
 	PLibMCDataBuildJobDataIterator_GetCurrentJobDataPtr m_BuildJobDataIterator_GetCurrentJobData;
 	PLibMCDataBuildJobExecutionData_GetExecutionUUIDPtr m_BuildJobExecutionData_GetExecutionUUID;
 	PLibMCDataBuildJobExecutionDataIterator_GetCurrentJobExecutionDataPtr m_BuildJobExecutionDataIterator_GetCurrentJobExecutionData;
+	PLibMCDataDataCapture_GetUUIDPtr m_DataCapture_GetUUID;
+	PLibMCDataDataCapture_GetExecutionUUIDPtr m_DataCapture_GetExecutionUUID;
+	PLibMCDataDataCapture_GetIdentifierPtr m_DataCapture_GetIdentifier;
+	PLibMCDataDataCapture_GetNamePtr m_DataCapture_GetName;
+	PLibMCDataDataCapture_GetStatusPtr m_DataCapture_GetStatus;
+	PLibMCDataDataCapture_GetTimeStampPtr m_DataCapture_GetTimeStamp;
+	PLibMCDataDataCapture_AddColumnPtr m_DataCapture_AddColumn;
+	PLibMCDataDataCapture_GetColumnCountPtr m_DataCapture_GetColumnCount;
+	PLibMCDataDataCapture_GetColumnInformationPtr m_DataCapture_GetColumnInformation;
+	PLibMCDataDataCapture_AddSegmentPtr m_DataCapture_AddSegment;
+	PLibMCDataDataCapture_GetSegmentCountPtr m_DataCapture_GetSegmentCount;
+	PLibMCDataDataCapture_GetSegmentInformationPtr m_DataCapture_GetSegmentInformation;
+	PLibMCDataDataCapture_GetSegmentChunkCountPtr m_DataCapture_GetSegmentChunkCount;
+	PLibMCDataDataCapture_GetRowCountPtr m_DataCapture_GetRowCount;
+	PLibMCDataDataCapture_GetStoredSizeInBytesPtr m_DataCapture_GetStoredSizeInBytes;
+	PLibMCDataDataCapture_FinishPtr m_DataCapture_Finish;
+	PLibMCDataDataCapture_AbortPtr m_DataCapture_Abort;
 	PLibMCDataBuildJobExecution_GetExecutionUUIDPtr m_BuildJobExecution_GetExecutionUUID;
 	PLibMCDataBuildJobExecution_GetJobUUIDPtr m_BuildJobExecution_GetJobUUID;
 	PLibMCDataBuildJobExecution_GetJobNamePtr m_BuildJobExecution_GetJobName;
@@ -3900,6 +4307,11 @@ typedef struct {
 	PLibMCDataBuildJobExecution_StoreMetaDataStringPtr m_BuildJobExecution_StoreMetaDataString;
 	PLibMCDataBuildJobExecution_HasMetaDataStringPtr m_BuildJobExecution_HasMetaDataString;
 	PLibMCDataBuildJobExecution_GetMetaDataStringPtr m_BuildJobExecution_GetMetaDataString;
+	PLibMCDataBuildJobExecution_CreateDataCapturePtr m_BuildJobExecution_CreateDataCapture;
+	PLibMCDataBuildJobExecution_HasDataCapturePtr m_BuildJobExecution_HasDataCapture;
+	PLibMCDataBuildJobExecution_RetrieveDataCapturePtr m_BuildJobExecution_RetrieveDataCapture;
+	PLibMCDataBuildJobExecution_GetDataCaptureCountPtr m_BuildJobExecution_GetDataCaptureCount;
+	PLibMCDataBuildJobExecution_RetrieveDataCaptureByIndexPtr m_BuildJobExecution_RetrieveDataCaptureByIndex;
 	PLibMCDataBuildJobExecutionIterator_GetCurrentJobExecutionPtr m_BuildJobExecutionIterator_GetCurrentJobExecution;
 	PLibMCDataBuildJob_GetUUIDPtr m_BuildJob_GetUUID;
 	PLibMCDataBuildJob_GetNamePtr m_BuildJob_GetName;
@@ -3952,6 +4364,7 @@ typedef struct {
 	PLibMCDataBuildJobHandler_GetExecutionListHeadIDPtr m_BuildJobHandler_GetExecutionListHeadID;
 	PLibMCDataBuildJobHandler_ListJobsChangedSincePtr m_BuildJobHandler_ListJobsChangedSince;
 	PLibMCDataBuildJobHandler_ListJobExecutionsChangedSincePtr m_BuildJobHandler_ListJobExecutionsChangedSince;
+	PLibMCDataBuildJobHandler_RetrieveDataCapturePtr m_BuildJobHandler_RetrieveDataCapture;
 	PLibMCDataUserList_CountPtr m_UserList_Count;
 	PLibMCDataUserList_GetUserPropertiesPtr m_UserList_GetUserProperties;
 	PLibMCDataLoginHandler_UserExistsPtr m_LoginHandler_UserExists;
diff --git a/Framework/HeadersCore/CppDynamic/libmcdata_dynamic.hpp b/Framework/HeadersCore/CppDynamic/libmcdata_dynamic.hpp
index 3eb1bab75..60b9d84a5 100644
--- a/Framework/HeadersCore/CppDynamic/libmcdata_dynamic.hpp
+++ b/Framework/HeadersCore/CppDynamic/libmcdata_dynamic.hpp
@@ -80,6 +80,7 @@ class CBuildJobData;
 class CBuildJobDataIterator;
 class CBuildJobExecutionData;
 class CBuildJobExecutionDataIterator;
+class CDataCapture;
 class CBuildJobExecution;
 class CBuildJobExecutionIterator;
 class CBuildJob;
@@ -124,6 +125,7 @@ typedef CBuildJobData CLibMCDataBuildJobData;
 typedef CBuildJobDataIterator CLibMCDataBuildJobDataIterator;
 typedef CBuildJobExecutionData CLibMCDataBuildJobExecutionData;
 typedef CBuildJobExecutionDataIterator CLibMCDataBuildJobExecutionDataIterator;
+typedef CDataCapture CLibMCDataDataCapture;
 typedef CBuildJobExecution CLibMCDataBuildJobExecution;
 typedef CBuildJobExecutionIterator CLibMCDataBuildJobExecutionIterator;
 typedef CBuildJob CLibMCDataBuildJob;
@@ -168,6 +170,7 @@ typedef std::shared_ptr<CBuildJobData> PBuildJobData;
 typedef std::shared_ptr<CBuildJobDataIterator> PBuildJobDataIterator;
 typedef std::shared_ptr<CBuildJobExecutionData> PBuildJobExecutionData;
 typedef std::shared_ptr<CBuildJobExecutionDataIterator> PBuildJobExecutionDataIterator;
+typedef std::shared_ptr<CDataCapture> PDataCapture;
 typedef std::shared_ptr<CBuildJobExecution> PBuildJobExecution;
 typedef std::shared_ptr<CBuildJobExecutionIterator> PBuildJobExecutionIterator;
 typedef std::shared_ptr<CBuildJob> PBuildJob;
@@ -212,6 +215,7 @@ typedef PBuildJobData PLibMCDataBuildJobData;
 typedef PBuildJobDataIterator PLibMCDataBuildJobDataIterator;
 typedef PBuildJobExecutionData PLibMCDataBuildJobExecutionData;
 typedef PBuildJobExecutionDataIterator PLibMCDataBuildJobExecutionDataIterator;
+typedef PDataCapture PLibMCDataDataCapture;
 typedef PBuildJobExecution PLibMCDataBuildJobExecution;
 typedef PBuildJobExecutionIterator PLibMCDataBuildJobExecutionIterator;
 typedef PBuildJob PLibMCDataBuildJob;
@@ -691,6 +695,21 @@ class ELibMCDataException : public std::exception {
 			case LIBMCDATA_ERROR_JOBNAMETOOLONG: return "JOBNAMETOOLONG";
 			case LIBMCDATA_ERROR_STRINGPARAMETERTOOLONG: return "STRINGPARAMETERTOOLONG";
 			case LIBMCDATA_ERROR_TELEMETRYSETTINGAFTERINITIALISATION: return "TELEMETRYSETTINGAFTERINITIALISATION";
+			case LIBMCDATA_ERROR_DATACAPTURENOTFOUND: return "DATACAPTURENOTFOUND";
+			case LIBMCDATA_ERROR_DUPLICATEDATACAPTUREIDENTIFIER: return "DUPLICATEDATACAPTUREIDENTIFIER";
+			case LIBMCDATA_ERROR_INVALIDDATACAPTUREIDENTIFIER: return "INVALIDDATACAPTUREIDENTIFIER";
+			case LIBMCDATA_ERROR_INVALIDDATACAPTURENAME: return "INVALIDDATACAPTURENAME";
+			case LIBMCDATA_ERROR_DATACAPTURENOTRECORDING: return "DATACAPTURENOTRECORDING";
+			case LIBMCDATA_ERROR_INVALIDDATACAPTURESTATUS: return "INVALIDDATACAPTURESTATUS";
+			case LIBMCDATA_ERROR_INVALIDDATACAPTURECOLUMNINDEX: return "INVALIDDATACAPTURECOLUMNINDEX";
+			case LIBMCDATA_ERROR_INVALIDDATACAPTURESEGMENTINDEX: return "INVALIDDATACAPTURESEGMENTINDEX";
+			case LIBMCDATA_ERROR_DUPLICATEDATACAPTURESEGMENT: return "DUPLICATEDATACAPTURESEGMENT";
+			case LIBMCDATA_ERROR_DUPLICATEDATACAPTURECOLUMN: return "DUPLICATEDATACAPTURECOLUMN";
+			case LIBMCDATA_ERROR_DATACAPTUREALREADYABORTED: return "DATACAPTUREALREADYABORTED";
+			case LIBMCDATA_ERROR_RANDOMWRITESTREAMNOTFOUND: return "RANDOMWRITESTREAMNOTFOUND";
+			case LIBMCDATA_ERROR_DOWNLOADENTRYNOTFOUND: return "DOWNLOADENTRYNOTFOUND";
+			case LIBMCDATA_ERROR_STREAMHASACTIVEWRITER: return "STREAMHASACTIVEWRITER";
+			case LIBMCDATA_ERROR_ZIPSTREAMALREADYFINISHED: return "ZIPSTREAMALREADYFINISHED";
 		}
 		return "UNKNOWN";
 	}
@@ -1081,6 +1100,21 @@ class ELibMCDataException : public std::exception {
 			case LIBMCDATA_ERROR_JOBNAMETOOLONG: return "Job name exceeds maximum allowed length";
 			case LIBMCDATA_ERROR_STRINGPARAMETERTOOLONG: return "String parameter exceeds maximum allowed length";
 			case LIBMCDATA_ERROR_TELEMETRYSETTINGAFTERINITIALISATION: return "Telemetry setting changed after database initialisation";
+			case LIBMCDATA_ERROR_DATACAPTURENOTFOUND: return "Data capture not found.";
+			case LIBMCDATA_ERROR_DUPLICATEDATACAPTUREIDENTIFIER: return "Duplicate data capture identifier.";
+			case LIBMCDATA_ERROR_INVALIDDATACAPTUREIDENTIFIER: return "Invalid data capture identifier.";
+			case LIBMCDATA_ERROR_INVALIDDATACAPTURENAME: return "Invalid data capture name.";
+			case LIBMCDATA_ERROR_DATACAPTURENOTRECORDING: return "Data capture is not recording.";
+			case LIBMCDATA_ERROR_INVALIDDATACAPTURESTATUS: return "Invalid data capture status.";
+			case LIBMCDATA_ERROR_INVALIDDATACAPTURECOLUMNINDEX: return "Invalid data capture column index.";
+			case LIBMCDATA_ERROR_INVALIDDATACAPTURESEGMENTINDEX: return "Invalid data capture segment index.";
+			case LIBMCDATA_ERROR_DUPLICATEDATACAPTURESEGMENT: return "Duplicate data capture segment.";
+			case LIBMCDATA_ERROR_DUPLICATEDATACAPTURECOLUMN: return "Duplicate data capture column.";
+			case LIBMCDATA_ERROR_DATACAPTUREALREADYABORTED: return "Data capture has already been aborted.";
+			case LIBMCDATA_ERROR_RANDOMWRITESTREAMNOTFOUND: return "Random write stream not found.";
+			case LIBMCDATA_ERROR_DOWNLOADENTRYNOTFOUND: return "Download access log entry not found.";
+			case LIBMCDATA_ERROR_STREAMHASACTIVEWRITER: return "Storage stream is still being written.";
+			case LIBMCDATA_ERROR_ZIPSTREAMALREADYFINISHED: return "ZIP stream has already been finished and can not be discarded.";
 		}
 		return "unknown error";
 	}
@@ -1219,6 +1253,7 @@ class CWrapper {
 	friend class CBuildJobDataIterator;
 	friend class CBuildJobExecutionData;
 	friend class CBuildJobExecutionDataIterator;
+	friend class CDataCapture;
 	friend class CBuildJobExecution;
 	friend class CBuildJobExecutionIterator;
 	friend class CBuildJob;
@@ -1616,6 +1651,7 @@ class CStorageZIPWriter : public CBase {
 	inline LibMCData_uint64 GetZIPStreamSize();
 	inline void Finish();
 	inline bool IsFinished();
+	inline void Discard();
 };
 	
 /*************************************************************************************************************************
@@ -1649,7 +1685,17 @@ class CStorage : public CBase {
 	inline bool StreamIsImage(const std::string & sUUID);
 	inline void CreateDownloadTicket(const std::string & sTicketUUID, const std::string & sStreamUUID, const std::string & sClientFileName, const std::string & sSessionUUID, const std::string & sUserUUID, const LibMCData_uint64 nAbsoluteTimeStamp);
 	inline void RequestDownloadTicket(const std::string & sTicketUUID, const std::string & sIPAddress, const LibMCData_uint64 nAbsoluteTimeStamp, std::string & sStreamUUID, std::string & sClientFileName, std::string & sSessionUUID, std::string & sUserUUID);
+	inline void GetDownloadTicketDetails(const std::string & sTicketUUID, std::string & sStreamUUID, std::string & sClientFileName, std::string & sSessionUUID, std::string & sUserUUID, LibMCData_uint64 & nCreationTimeStamp, bool & bRevoked);
+	inline LibMCData_uint32 RevokeDownloadTicketsOfStream(const std::string & sStreamUUID);
+	inline std::string LogDownloadStart(const std::string & sTicketUUID, const std::string & sIPAddress, const LibMCData_uint64 nAbsoluteTimeStamp);
+	inline void LogDownloadFinish(const std::string & sDownloadUUID, const LibMCData_uint64 nSentBytes, const bool bSuccess, const LibMCData_uint64 nAbsoluteTimeStamp);
+	inline void DeleteStream(const std::string & sUUID);
+	inline LibMCData_uint32 DiscardUnfinishedZIPStreams();
+	inline std::string ListStreamUUIDsByName(const std::string & sName);
 	inline void AttachStreamToJournal(const std::string & sStreamUUID, const std::string & sJournalUUID);
+	inline void DiscardRandomWriteStream(const std::string & sUUID);
+	inline LibMCData_uint64 GetDataCaptureStorageSize();
+	inline LibMCData_uint32 EnforceDataCaptureStorageLimit(const LibMCData_uint64 nLimitInBytes);
 };
 	
 /*************************************************************************************************************************
@@ -1748,6 +1794,39 @@ class CBuildJobExecutionDataIterator : public CIterator {
 	inline PBuildJobExecutionData GetCurrentJobExecutionData();
 };
 	
+/*************************************************************************************************************************
+ Class CDataCapture 
+**************************************************************************************************************************/
+class CDataCapture : public CBase {
+public:
+	
+	/**
+	* CDataCapture::CDataCapture - Constructor for DataCapture class.
+	*/
+	CDataCapture(CWrapper* pWrapper, LibMCDataHandle pHandle)
+		: CBase(pWrapper, pHandle)
+	{
+	}
+	
+	inline std::string GetUUID();
+	inline std::string GetExecutionUUID();
+	inline std::string GetIdentifier();
+	inline std::string GetName();
+	inline eDataCaptureStatus GetStatus();
+	inline std::string GetTimeStamp();
+	inline void AddColumn(const LibMCData_uint32 nColumnIndex, const std::string & sIdentifier, const std::string & sDescription, const LibMCData_uint32 nColumnType);
+	inline LibMCData_uint32 GetColumnCount();
+	inline void GetColumnInformation(const LibMCData_uint32 nColumnIndex, std::string & sIdentifier, std::string & sDescription, LibMCData_uint32 & nColumnType);
+	inline void AddSegment(const LibMCData_uint32 nSegmentIndex, const std::string & sStreamUUID, const LibMCData_uint64 nFirstRow, const LibMCData_uint64 nRowCount, const LibMCData_uint32 nChunkCount, const LibMCData_uint64 nSizeInBytes, const LibMCData_uint64 nStartTimeStamp, const LibMCData_uint64 nEndTimeStamp);
+	inline LibMCData_uint32 GetSegmentCount();
+	inline void GetSegmentInformation(const LibMCData_uint32 nSegmentIndex, std::string & sStreamUUID, LibMCData_uint64 & nFirstRow, LibMCData_uint64 & nRowCount, LibMCData_uint64 & nSizeInBytes, bool & bIsPurged);
+	inline LibMCData_uint32 GetSegmentChunkCount(const LibMCData_uint32 nSegmentIndex);
+	inline LibMCData_uint64 GetRowCount();
+	inline LibMCData_uint64 GetStoredSizeInBytes();
+	inline void Finish(const LibMCData_uint64 nAbsoluteTimeStamp);
+	inline void Abort(const LibMCData_uint64 nAbsoluteTimeStamp);
+};
+	
 /*************************************************************************************************************************
  Class CBuildJobExecution 
 **************************************************************************************************************************/
@@ -1788,6 +1867,11 @@ class CBuildJobExecution : public CBase {
 	inline void StoreMetaDataString(const std::string & sKey, const std::string & sValue, const LibMCData_uint64 nAbsoluteTimeStamp);
 	inline bool HasMetaDataString(const std::string & sKey);
 	inline std::string GetMetaDataString(const std::string & sKey);
+	inline PDataCapture CreateDataCapture(const std::string & sIdentifier, const std::string & sName, const std::string & sUserUUID, const LibMCData_uint64 nAbsoluteTimeStamp);
+	inline bool HasDataCapture(const std::string & sIdentifier);
+	inline PDataCapture RetrieveDataCapture(const std::string & sIdentifier);
+	inline LibMCData_uint32 GetDataCaptureCount();
+	inline PDataCapture RetrieveDataCaptureByIndex(const LibMCData_uint32 nIndex);
 };
 	
 /*************************************************************************************************************************
@@ -1904,6 +1988,7 @@ class CBuildJobHandler : public CBase {
 	inline LibMCData_uint64 GetExecutionListHeadID();
 	inline PBuildJobIterator ListJobsChangedSince(const LibMCData_uint64 nIncrementalID);
 	inline PBuildJobExecutionIterator ListJobExecutionsChangedSince(const LibMCData_uint64 nIncrementalID);
+	inline PDataCapture RetrieveDataCapture(const std::string & sDataCaptureUUID);
 };
 	
 /*************************************************************************************************************************
@@ -2421,6 +2506,7 @@ class CDataModel : public CBase {
 		pWrapperTable->m_StorageZIPWriter_GetZIPStreamSize = nullptr;
 		pWrapperTable->m_StorageZIPWriter_Finish = nullptr;
 		pWrapperTable->m_StorageZIPWriter_IsFinished = nullptr;
+		pWrapperTable->m_StorageZIPWriter_Discard = nullptr;
 		pWrapperTable->m_Storage_StreamIsReady = nullptr;
 		pWrapperTable->m_Storage_RetrieveStream = nullptr;
 		pWrapperTable->m_Storage_StoreNewStream = nullptr;
@@ -2438,7 +2524,17 @@ class CDataModel : public CBase {
 		pWrapperTable->m_Storage_StreamIsImage = nullptr;
 		pWrapperTable->m_Storage_CreateDownloadTicket = nullptr;
 		pWrapperTable->m_Storage_RequestDownloadTicket = nullptr;
+		pWrapperTable->m_Storage_GetDownloadTicketDetails = nullptr;
+		pWrapperTable->m_Storage_RevokeDownloadTicketsOfStream = nullptr;
+		pWrapperTable->m_Storage_LogDownloadStart = nullptr;
+		pWrapperTable->m_Storage_LogDownloadFinish = nullptr;
+		pWrapperTable->m_Storage_DeleteStream = nullptr;
+		pWrapperTable->m_Storage_DiscardUnfinishedZIPStreams = nullptr;
+		pWrapperTable->m_Storage_ListStreamUUIDsByName = nullptr;
 		pWrapperTable->m_Storage_AttachStreamToJournal = nullptr;
+		pWrapperTable->m_Storage_DiscardRandomWriteStream = nullptr;
+		pWrapperTable->m_Storage_GetDataCaptureStorageSize = nullptr;
+		pWrapperTable->m_Storage_EnforceDataCaptureStorageLimit = nullptr;
 		pWrapperTable->m_CustomDataStream_GetDataUUID = nullptr;
 		pWrapperTable->m_CustomDataStream_GetIdentifier = nullptr;
 		pWrapperTable->m_CustomDataStream_GetName = nullptr;
@@ -2455,6 +2551,23 @@ class CDataModel : public CBase {
 		pWrapperTable->m_BuildJobDataIterator_GetCurrentJobData = nullptr;
 		pWrapperTable->m_BuildJobExecutionData_GetExecutionUUID = nullptr;
 		pWrapperTable->m_BuildJobExecutionDataIterator_GetCurrentJobExecutionData = nullptr;
+		pWrapperTable->m_DataCapture_GetUUID = nullptr;
+		pWrapperTable->m_DataCapture_GetExecutionUUID = nullptr;
+		pWrapperTable->m_DataCapture_GetIdentifier = nullptr;
+		pWrapperTable->m_DataCapture_GetName = nullptr;
+		pWrapperTable->m_DataCapture_GetStatus = nullptr;
+		pWrapperTable->m_DataCapture_GetTimeStamp = nullptr;
+		pWrapperTable->m_DataCapture_AddColumn = nullptr;
+		pWrapperTable->m_DataCapture_GetColumnCount = nullptr;
+		pWrapperTable->m_DataCapture_GetColumnInformation = nullptr;
+		pWrapperTable->m_DataCapture_AddSegment = nullptr;
+		pWrapperTable->m_DataCapture_GetSegmentCount = nullptr;
+		pWrapperTable->m_DataCapture_GetSegmentInformation = nullptr;
+		pWrapperTable->m_DataCapture_GetSegmentChunkCount = nullptr;
+		pWrapperTable->m_DataCapture_GetRowCount = nullptr;
+		pWrapperTable->m_DataCapture_GetStoredSizeInBytes = nullptr;
+		pWrapperTable->m_DataCapture_Finish = nullptr;
+		pWrapperTable->m_DataCapture_Abort = nullptr;
 		pWrapperTable->m_BuildJobExecution_GetExecutionUUID = nullptr;
 		pWrapperTable->m_BuildJobExecution_GetJobUUID = nullptr;
 		pWrapperTable->m_BuildJobExecution_GetJobName = nullptr;
@@ -2481,6 +2594,11 @@ class CDataModel : public CBase {
 		pWrapperTable->m_BuildJobExecution_StoreMetaDataString = nullptr;
 		pWrapperTable->m_BuildJobExecution_HasMetaDataString = nullptr;
 		pWrapperTable->m_BuildJobExecution_GetMetaDataString = nullptr;
+		pWrapperTable->m_BuildJobExecution_CreateDataCapture = nullptr;
+		pWrapperTable->m_BuildJobExecution_HasDataCapture = nullptr;
+		pWrapperTable->m_BuildJobExecution_RetrieveDataCapture = nullptr;
+		pWrapperTable->m_BuildJobExecution_GetDataCaptureCount = nullptr;
+		pWrapperTable->m_BuildJobExecution_RetrieveDataCaptureByIndex = nullptr;
 		pWrapperTable->m_BuildJobExecutionIterator_GetCurrentJobExecution = nullptr;
 		pWrapperTable->m_BuildJob_GetUUID = nullptr;
 		pWrapperTable->m_BuildJob_GetName = nullptr;
@@ -2533,6 +2651,7 @@ class CDataModel : public CBase {
 		pWrapperTable->m_BuildJobHandler_GetExecutionListHeadID = nullptr;
 		pWrapperTable->m_BuildJobHandler_ListJobsChangedSince = nullptr;
 		pWrapperTable->m_BuildJobHandler_ListJobExecutionsChangedSince = nullptr;
+		pWrapperTable->m_BuildJobHandler_RetrieveDataCapture = nullptr;
 		pWrapperTable->m_UserList_Count = nullptr;
 		pWrapperTable->m_UserList_GetUserProperties = nullptr;
 		pWrapperTable->m_LoginHandler_UserExists = nullptr;
@@ -3576,6 +3695,15 @@ class CDataModel : public CBase {
 		if (pWrapperTable->m_StorageZIPWriter_IsFinished == nullptr)
 			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
+		#ifdef _WIN32
+		pWrapperTable->m_StorageZIPWriter_Discard = (PLibMCDataStorageZIPWriter_DiscardPtr) GetProcAddress(hLibrary, "libmcdata_storagezipwriter_discard");
+		#else // _WIN32
+		pWrapperTable->m_StorageZIPWriter_Discard = (PLibMCDataStorageZIPWriter_DiscardPtr) dlsym(hLibrary, "libmcdata_storagezipwriter_discard");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_StorageZIPWriter_Discard == nullptr)
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
 		#ifdef _WIN32
 		pWrapperTable->m_Storage_StreamIsReady = (PLibMCDataStorage_StreamIsReadyPtr) GetProcAddress(hLibrary, "libmcdata_storage_streamisready");
 		#else // _WIN32
@@ -3729,6 +3857,69 @@ class CDataModel : public CBase {
 		if (pWrapperTable->m_Storage_RequestDownloadTicket == nullptr)
 			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
+		#ifdef _WIN32
+		pWrapperTable->m_Storage_GetDownloadTicketDetails = (PLibMCDataStorage_GetDownloadTicketDetailsPtr) GetProcAddress(hLibrary, "libmcdata_storage_getdownloadticketdetails");
+		#else // _WIN32
+		pWrapperTable->m_Storage_GetDownloadTicketDetails = (PLibMCDataStorage_GetDownloadTicketDetailsPtr) dlsym(hLibrary, "libmcdata_storage_getdownloadticketdetails");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_Storage_GetDownloadTicketDetails == nullptr)
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_Storage_RevokeDownloadTicketsOfStream = (PLibMCDataStorage_RevokeDownloadTicketsOfStreamPtr) GetProcAddress(hLibrary, "libmcdata_storage_revokedownloadticketsofstream");
+		#else // _WIN32
+		pWrapperTable->m_Storage_RevokeDownloadTicketsOfStream = (PLibMCDataStorage_RevokeDownloadTicketsOfStreamPtr) dlsym(hLibrary, "libmcdata_storage_revokedownloadticketsofstream");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_Storage_RevokeDownloadTicketsOfStream == nullptr)
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_Storage_LogDownloadStart = (PLibMCDataStorage_LogDownloadStartPtr) GetProcAddress(hLibrary, "libmcdata_storage_logdownloadstart");
+		#else // _WIN32
+		pWrapperTable->m_Storage_LogDownloadStart = (PLibMCDataStorage_LogDownloadStartPtr) dlsym(hLibrary, "libmcdata_storage_logdownloadstart");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_Storage_LogDownloadStart == nullptr)
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_Storage_LogDownloadFinish = (PLibMCDataStorage_LogDownloadFinishPtr) GetProcAddress(hLibrary, "libmcdata_storage_logdownloadfinish");
+		#else // _WIN32
+		pWrapperTable->m_Storage_LogDownloadFinish = (PLibMCDataStorage_LogDownloadFinishPtr) dlsym(hLibrary, "libmcdata_storage_logdownloadfinish");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_Storage_LogDownloadFinish == nullptr)
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_Storage_DeleteStream = (PLibMCDataStorage_DeleteStreamPtr) GetProcAddress(hLibrary, "libmcdata_storage_deletestream");
+		#else // _WIN32
+		pWrapperTable->m_Storage_DeleteStream = (PLibMCDataStorage_DeleteStreamPtr) dlsym(hLibrary, "libmcdata_storage_deletestream");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_Storage_DeleteStream == nullptr)
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_Storage_DiscardUnfinishedZIPStreams = (PLibMCDataStorage_DiscardUnfinishedZIPStreamsPtr) GetProcAddress(hLibrary, "libmcdata_storage_discardunfinishedzipstreams");
+		#else // _WIN32
+		pWrapperTable->m_Storage_DiscardUnfinishedZIPStreams = (PLibMCDataStorage_DiscardUnfinishedZIPStreamsPtr) dlsym(hLibrary, "libmcdata_storage_discardunfinishedzipstreams");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_Storage_DiscardUnfinishedZIPStreams == nullptr)
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_Storage_ListStreamUUIDsByName = (PLibMCDataStorage_ListStreamUUIDsByNamePtr) GetProcAddress(hLibrary, "libmcdata_storage_liststreamuuidsbyname");
+		#else // _WIN32
+		pWrapperTable->m_Storage_ListStreamUUIDsByName = (PLibMCDataStorage_ListStreamUUIDsByNamePtr) dlsym(hLibrary, "libmcdata_storage_liststreamuuidsbyname");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_Storage_ListStreamUUIDsByName == nullptr)
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
 		#ifdef _WIN32
 		pWrapperTable->m_Storage_AttachStreamToJournal = (PLibMCDataStorage_AttachStreamToJournalPtr) GetProcAddress(hLibrary, "libmcdata_storage_attachstreamtojournal");
 		#else // _WIN32
@@ -3738,6 +3929,33 @@ class CDataModel : public CBase {
 		if (pWrapperTable->m_Storage_AttachStreamToJournal == nullptr)
 			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
+		#ifdef _WIN32
+		pWrapperTable->m_Storage_DiscardRandomWriteStream = (PLibMCDataStorage_DiscardRandomWriteStreamPtr) GetProcAddress(hLibrary, "libmcdata_storage_discardrandomwritestream");
+		#else // _WIN32
+		pWrapperTable->m_Storage_DiscardRandomWriteStream = (PLibMCDataStorage_DiscardRandomWriteStreamPtr) dlsym(hLibrary, "libmcdata_storage_discardrandomwritestream");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_Storage_DiscardRandomWriteStream == nullptr)
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_Storage_GetDataCaptureStorageSize = (PLibMCDataStorage_GetDataCaptureStorageSizePtr) GetProcAddress(hLibrary, "libmcdata_storage_getdatacapturestoragesize");
+		#else // _WIN32
+		pWrapperTable->m_Storage_GetDataCaptureStorageSize = (PLibMCDataStorage_GetDataCaptureStorageSizePtr) dlsym(hLibrary, "libmcdata_storage_getdatacapturestoragesize");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_Storage_GetDataCaptureStorageSize == nullptr)
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_Storage_EnforceDataCaptureStorageLimit = (PLibMCDataStorage_EnforceDataCaptureStorageLimitPtr) GetProcAddress(hLibrary, "libmcdata_storage_enforcedatacapturestoragelimit");
+		#else // _WIN32
+		pWrapperTable->m_Storage_EnforceDataCaptureStorageLimit = (PLibMCDataStorage_EnforceDataCaptureStorageLimitPtr) dlsym(hLibrary, "libmcdata_storage_enforcedatacapturestoragelimit");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_Storage_EnforceDataCaptureStorageLimit == nullptr)
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
 		#ifdef _WIN32
 		pWrapperTable->m_CustomDataStream_GetDataUUID = (PLibMCDataCustomDataStream_GetDataUUIDPtr) GetProcAddress(hLibrary, "libmcdata_customdatastream_getdatauuid");
 		#else // _WIN32
@@ -3882,6 +4100,159 @@ class CDataModel : public CBase {
 		if (pWrapperTable->m_BuildJobExecutionDataIterator_GetCurrentJobExecutionData == nullptr)
 			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCapture_GetUUID = (PLibMCDataDataCapture_GetUUIDPtr) GetProcAddress(hLibrary, "libmcdata_datacapture_getuuid");
+		#else // _WIN32
+		pWrapperTable->m_DataCapture_GetUUID = (PLibMCDataDataCapture_GetUUIDPtr) dlsym(hLibrary, "libmcdata_datacapture_getuuid");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCapture_GetUUID == nullptr)
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCapture_GetExecutionUUID = (PLibMCDataDataCapture_GetExecutionUUIDPtr) GetProcAddress(hLibrary, "libmcdata_datacapture_getexecutionuuid");
+		#else // _WIN32
+		pWrapperTable->m_DataCapture_GetExecutionUUID = (PLibMCDataDataCapture_GetExecutionUUIDPtr) dlsym(hLibrary, "libmcdata_datacapture_getexecutionuuid");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCapture_GetExecutionUUID == nullptr)
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCapture_GetIdentifier = (PLibMCDataDataCapture_GetIdentifierPtr) GetProcAddress(hLibrary, "libmcdata_datacapture_getidentifier");
+		#else // _WIN32
+		pWrapperTable->m_DataCapture_GetIdentifier = (PLibMCDataDataCapture_GetIdentifierPtr) dlsym(hLibrary, "libmcdata_datacapture_getidentifier");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCapture_GetIdentifier == nullptr)
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCapture_GetName = (PLibMCDataDataCapture_GetNamePtr) GetProcAddress(hLibrary, "libmcdata_datacapture_getname");
+		#else // _WIN32
+		pWrapperTable->m_DataCapture_GetName = (PLibMCDataDataCapture_GetNamePtr) dlsym(hLibrary, "libmcdata_datacapture_getname");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCapture_GetName == nullptr)
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCapture_GetStatus = (PLibMCDataDataCapture_GetStatusPtr) GetProcAddress(hLibrary, "libmcdata_datacapture_getstatus");
+		#else // _WIN32
+		pWrapperTable->m_DataCapture_GetStatus = (PLibMCDataDataCapture_GetStatusPtr) dlsym(hLibrary, "libmcdata_datacapture_getstatus");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCapture_GetStatus == nullptr)
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCapture_GetTimeStamp = (PLibMCDataDataCapture_GetTimeStampPtr) GetProcAddress(hLibrary, "libmcdata_datacapture_gettimestamp");
+		#else // _WIN32
+		pWrapperTable->m_DataCapture_GetTimeStamp = (PLibMCDataDataCapture_GetTimeStampPtr) dlsym(hLibrary, "libmcdata_datacapture_gettimestamp");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCapture_GetTimeStamp == nullptr)
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCapture_AddColumn = (PLibMCDataDataCapture_AddColumnPtr) GetProcAddress(hLibrary, "libmcdata_datacapture_addcolumn");
+		#else // _WIN32
+		pWrapperTable->m_DataCapture_AddColumn = (PLibMCDataDataCapture_AddColumnPtr) dlsym(hLibrary, "libmcdata_datacapture_addcolumn");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCapture_AddColumn == nullptr)
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCapture_GetColumnCount = (PLibMCDataDataCapture_GetColumnCountPtr) GetProcAddress(hLibrary, "libmcdata_datacapture_getcolumncount");
+		#else // _WIN32
+		pWrapperTable->m_DataCapture_GetColumnCount = (PLibMCDataDataCapture_GetColumnCountPtr) dlsym(hLibrary, "libmcdata_datacapture_getcolumncount");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCapture_GetColumnCount == nullptr)
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCapture_GetColumnInformation = (PLibMCDataDataCapture_GetColumnInformationPtr) GetProcAddress(hLibrary, "libmcdata_datacapture_getcolumninformation");
+		#else // _WIN32
+		pWrapperTable->m_DataCapture_GetColumnInformation = (PLibMCDataDataCapture_GetColumnInformationPtr) dlsym(hLibrary, "libmcdata_datacapture_getcolumninformation");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCapture_GetColumnInformation == nullptr)
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCapture_AddSegment = (PLibMCDataDataCapture_AddSegmentPtr) GetProcAddress(hLibrary, "libmcdata_datacapture_addsegment");
+		#else // _WIN32
+		pWrapperTable->m_DataCapture_AddSegment = (PLibMCDataDataCapture_AddSegmentPtr) dlsym(hLibrary, "libmcdata_datacapture_addsegment");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCapture_AddSegment == nullptr)
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCapture_GetSegmentCount = (PLibMCDataDataCapture_GetSegmentCountPtr) GetProcAddress(hLibrary, "libmcdata_datacapture_getsegmentcount");
+		#else // _WIN32
+		pWrapperTable->m_DataCapture_GetSegmentCount = (PLibMCDataDataCapture_GetSegmentCountPtr) dlsym(hLibrary, "libmcdata_datacapture_getsegmentcount");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCapture_GetSegmentCount == nullptr)
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCapture_GetSegmentInformation = (PLibMCDataDataCapture_GetSegmentInformationPtr) GetProcAddress(hLibrary, "libmcdata_datacapture_getsegmentinformation");
+		#else // _WIN32
+		pWrapperTable->m_DataCapture_GetSegmentInformation = (PLibMCDataDataCapture_GetSegmentInformationPtr) dlsym(hLibrary, "libmcdata_datacapture_getsegmentinformation");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCapture_GetSegmentInformation == nullptr)
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCapture_GetSegmentChunkCount = (PLibMCDataDataCapture_GetSegmentChunkCountPtr) GetProcAddress(hLibrary, "libmcdata_datacapture_getsegmentchunkcount");
+		#else // _WIN32
+		pWrapperTable->m_DataCapture_GetSegmentChunkCount = (PLibMCDataDataCapture_GetSegmentChunkCountPtr) dlsym(hLibrary, "libmcdata_datacapture_getsegmentchunkcount");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCapture_GetSegmentChunkCount == nullptr)
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCapture_GetRowCount = (PLibMCDataDataCapture_GetRowCountPtr) GetProcAddress(hLibrary, "libmcdata_datacapture_getrowcount");
+		#else // _WIN32
+		pWrapperTable->m_DataCapture_GetRowCount = (PLibMCDataDataCapture_GetRowCountPtr) dlsym(hLibrary, "libmcdata_datacapture_getrowcount");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCapture_GetRowCount == nullptr)
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCapture_GetStoredSizeInBytes = (PLibMCDataDataCapture_GetStoredSizeInBytesPtr) GetProcAddress(hLibrary, "libmcdata_datacapture_getstoredsizeinbytes");
+		#else // _WIN32
+		pWrapperTable->m_DataCapture_GetStoredSizeInBytes = (PLibMCDataDataCapture_GetStoredSizeInBytesPtr) dlsym(hLibrary, "libmcdata_datacapture_getstoredsizeinbytes");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCapture_GetStoredSizeInBytes == nullptr)
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCapture_Finish = (PLibMCDataDataCapture_FinishPtr) GetProcAddress(hLibrary, "libmcdata_datacapture_finish");
+		#else // _WIN32
+		pWrapperTable->m_DataCapture_Finish = (PLibMCDataDataCapture_FinishPtr) dlsym(hLibrary, "libmcdata_datacapture_finish");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCapture_Finish == nullptr)
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCapture_Abort = (PLibMCDataDataCapture_AbortPtr) GetProcAddress(hLibrary, "libmcdata_datacapture_abort");
+		#else // _WIN32
+		pWrapperTable->m_DataCapture_Abort = (PLibMCDataDataCapture_AbortPtr) dlsym(hLibrary, "libmcdata_datacapture_abort");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCapture_Abort == nullptr)
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
 		#ifdef _WIN32
 		pWrapperTable->m_BuildJobExecution_GetExecutionUUID = (PLibMCDataBuildJobExecution_GetExecutionUUIDPtr) GetProcAddress(hLibrary, "libmcdata_buildjobexecution_getexecutionuuid");
 		#else // _WIN32
@@ -4116,6 +4487,51 @@ class CDataModel : public CBase {
 		if (pWrapperTable->m_BuildJobExecution_GetMetaDataString == nullptr)
 			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
+		#ifdef _WIN32
+		pWrapperTable->m_BuildJobExecution_CreateDataCapture = (PLibMCDataBuildJobExecution_CreateDataCapturePtr) GetProcAddress(hLibrary, "libmcdata_buildjobexecution_createdatacapture");
+		#else // _WIN32
+		pWrapperTable->m_BuildJobExecution_CreateDataCapture = (PLibMCDataBuildJobExecution_CreateDataCapturePtr) dlsym(hLibrary, "libmcdata_buildjobexecution_createdatacapture");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_BuildJobExecution_CreateDataCapture == nullptr)
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_BuildJobExecution_HasDataCapture = (PLibMCDataBuildJobExecution_HasDataCapturePtr) GetProcAddress(hLibrary, "libmcdata_buildjobexecution_hasdatacapture");
+		#else // _WIN32
+		pWrapperTable->m_BuildJobExecution_HasDataCapture = (PLibMCDataBuildJobExecution_HasDataCapturePtr) dlsym(hLibrary, "libmcdata_buildjobexecution_hasdatacapture");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_BuildJobExecution_HasDataCapture == nullptr)
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_BuildJobExecution_RetrieveDataCapture = (PLibMCDataBuildJobExecution_RetrieveDataCapturePtr) GetProcAddress(hLibrary, "libmcdata_buildjobexecution_retrievedatacapture");
+		#else // _WIN32
+		pWrapperTable->m_BuildJobExecution_RetrieveDataCapture = (PLibMCDataBuildJobExecution_RetrieveDataCapturePtr) dlsym(hLibrary, "libmcdata_buildjobexecution_retrievedatacapture");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_BuildJobExecution_RetrieveDataCapture == nullptr)
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_BuildJobExecution_GetDataCaptureCount = (PLibMCDataBuildJobExecution_GetDataCaptureCountPtr) GetProcAddress(hLibrary, "libmcdata_buildjobexecution_getdatacapturecount");
+		#else // _WIN32
+		pWrapperTable->m_BuildJobExecution_GetDataCaptureCount = (PLibMCDataBuildJobExecution_GetDataCaptureCountPtr) dlsym(hLibrary, "libmcdata_buildjobexecution_getdatacapturecount");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_BuildJobExecution_GetDataCaptureCount == nullptr)
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_BuildJobExecution_RetrieveDataCaptureByIndex = (PLibMCDataBuildJobExecution_RetrieveDataCaptureByIndexPtr) GetProcAddress(hLibrary, "libmcdata_buildjobexecution_retrievedatacapturebyindex");
+		#else // _WIN32
+		pWrapperTable->m_BuildJobExecution_RetrieveDataCaptureByIndex = (PLibMCDataBuildJobExecution_RetrieveDataCaptureByIndexPtr) dlsym(hLibrary, "libmcdata_buildjobexecution_retrievedatacapturebyindex");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_BuildJobExecution_RetrieveDataCaptureByIndex == nullptr)
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
 		#ifdef _WIN32
 		pWrapperTable->m_BuildJobExecutionIterator_GetCurrentJobExecution = (PLibMCDataBuildJobExecutionIterator_GetCurrentJobExecutionPtr) GetProcAddress(hLibrary, "libmcdata_buildjobexecutioniterator_getcurrentjobexecution");
 		#else // _WIN32
@@ -4584,6 +5000,15 @@ class CDataModel : public CBase {
 		if (pWrapperTable->m_BuildJobHandler_ListJobExecutionsChangedSince == nullptr)
 			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
+		#ifdef _WIN32
+		pWrapperTable->m_BuildJobHandler_RetrieveDataCapture = (PLibMCDataBuildJobHandler_RetrieveDataCapturePtr) GetProcAddress(hLibrary, "libmcdata_buildjobhandler_retrievedatacapture");
+		#else // _WIN32
+		pWrapperTable->m_BuildJobHandler_RetrieveDataCapture = (PLibMCDataBuildJobHandler_RetrieveDataCapturePtr) dlsym(hLibrary, "libmcdata_buildjobhandler_retrievedatacapture");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_BuildJobHandler_RetrieveDataCapture == nullptr)
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
 		#ifdef _WIN32
 		pWrapperTable->m_UserList_Count = (PLibMCDataUserList_CountPtr) GetProcAddress(hLibrary, "libmcdata_userlist_count");
 		#else // _WIN32
@@ -6068,6 +6493,10 @@ class CDataModel : public CBase {
 		if ( (eLookupError != 0) || (pWrapperTable->m_StorageZIPWriter_IsFinished == nullptr) )
 			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
+		eLookupError = (*pLookup)("libmcdata_storagezipwriter_discard", (void**)&(pWrapperTable->m_StorageZIPWriter_Discard));
+		if ( (eLookupError != 0) || (pWrapperTable->m_StorageZIPWriter_Discard == nullptr) )
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
 		eLookupError = (*pLookup)("libmcdata_storage_streamisready", (void**)&(pWrapperTable->m_Storage_StreamIsReady));
 		if ( (eLookupError != 0) || (pWrapperTable->m_Storage_StreamIsReady == nullptr) )
 			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
@@ -6136,10 +6565,50 @@ class CDataModel : public CBase {
 		if ( (eLookupError != 0) || (pWrapperTable->m_Storage_RequestDownloadTicket == nullptr) )
 			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
+		eLookupError = (*pLookup)("libmcdata_storage_getdownloadticketdetails", (void**)&(pWrapperTable->m_Storage_GetDownloadTicketDetails));
+		if ( (eLookupError != 0) || (pWrapperTable->m_Storage_GetDownloadTicketDetails == nullptr) )
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcdata_storage_revokedownloadticketsofstream", (void**)&(pWrapperTable->m_Storage_RevokeDownloadTicketsOfStream));
+		if ( (eLookupError != 0) || (pWrapperTable->m_Storage_RevokeDownloadTicketsOfStream == nullptr) )
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcdata_storage_logdownloadstart", (void**)&(pWrapperTable->m_Storage_LogDownloadStart));
+		if ( (eLookupError != 0) || (pWrapperTable->m_Storage_LogDownloadStart == nullptr) )
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcdata_storage_logdownloadfinish", (void**)&(pWrapperTable->m_Storage_LogDownloadFinish));
+		if ( (eLookupError != 0) || (pWrapperTable->m_Storage_LogDownloadFinish == nullptr) )
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcdata_storage_deletestream", (void**)&(pWrapperTable->m_Storage_DeleteStream));
+		if ( (eLookupError != 0) || (pWrapperTable->m_Storage_DeleteStream == nullptr) )
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcdata_storage_discardunfinishedzipstreams", (void**)&(pWrapperTable->m_Storage_DiscardUnfinishedZIPStreams));
+		if ( (eLookupError != 0) || (pWrapperTable->m_Storage_DiscardUnfinishedZIPStreams == nullptr) )
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcdata_storage_liststreamuuidsbyname", (void**)&(pWrapperTable->m_Storage_ListStreamUUIDsByName));
+		if ( (eLookupError != 0) || (pWrapperTable->m_Storage_ListStreamUUIDsByName == nullptr) )
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
 		eLookupError = (*pLookup)("libmcdata_storage_attachstreamtojournal", (void**)&(pWrapperTable->m_Storage_AttachStreamToJournal));
 		if ( (eLookupError != 0) || (pWrapperTable->m_Storage_AttachStreamToJournal == nullptr) )
 			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
+		eLookupError = (*pLookup)("libmcdata_storage_discardrandomwritestream", (void**)&(pWrapperTable->m_Storage_DiscardRandomWriteStream));
+		if ( (eLookupError != 0) || (pWrapperTable->m_Storage_DiscardRandomWriteStream == nullptr) )
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcdata_storage_getdatacapturestoragesize", (void**)&(pWrapperTable->m_Storage_GetDataCaptureStorageSize));
+		if ( (eLookupError != 0) || (pWrapperTable->m_Storage_GetDataCaptureStorageSize == nullptr) )
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcdata_storage_enforcedatacapturestoragelimit", (void**)&(pWrapperTable->m_Storage_EnforceDataCaptureStorageLimit));
+		if ( (eLookupError != 0) || (pWrapperTable->m_Storage_EnforceDataCaptureStorageLimit == nullptr) )
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
 		eLookupError = (*pLookup)("libmcdata_customdatastream_getdatauuid", (void**)&(pWrapperTable->m_CustomDataStream_GetDataUUID));
 		if ( (eLookupError != 0) || (pWrapperTable->m_CustomDataStream_GetDataUUID == nullptr) )
 			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
@@ -6204,31 +6673,99 @@ class CDataModel : public CBase {
 		if ( (eLookupError != 0) || (pWrapperTable->m_BuildJobExecutionDataIterator_GetCurrentJobExecutionData == nullptr) )
 			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
-		eLookupError = (*pLookup)("libmcdata_buildjobexecution_getexecutionuuid", (void**)&(pWrapperTable->m_BuildJobExecution_GetExecutionUUID));
-		if ( (eLookupError != 0) || (pWrapperTable->m_BuildJobExecution_GetExecutionUUID == nullptr) )
+		eLookupError = (*pLookup)("libmcdata_datacapture_getuuid", (void**)&(pWrapperTable->m_DataCapture_GetUUID));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCapture_GetUUID == nullptr) )
 			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
-		eLookupError = (*pLookup)("libmcdata_buildjobexecution_getjobuuid", (void**)&(pWrapperTable->m_BuildJobExecution_GetJobUUID));
-		if ( (eLookupError != 0) || (pWrapperTable->m_BuildJobExecution_GetJobUUID == nullptr) )
+		eLookupError = (*pLookup)("libmcdata_datacapture_getexecutionuuid", (void**)&(pWrapperTable->m_DataCapture_GetExecutionUUID));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCapture_GetExecutionUUID == nullptr) )
 			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
-		eLookupError = (*pLookup)("libmcdata_buildjobexecution_getjobname", (void**)&(pWrapperTable->m_BuildJobExecution_GetJobName));
-		if ( (eLookupError != 0) || (pWrapperTable->m_BuildJobExecution_GetJobName == nullptr) )
+		eLookupError = (*pLookup)("libmcdata_datacapture_getidentifier", (void**)&(pWrapperTable->m_DataCapture_GetIdentifier));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCapture_GetIdentifier == nullptr) )
 			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
-		eLookupError = (*pLookup)("libmcdata_buildjobexecution_getjobstatus", (void**)&(pWrapperTable->m_BuildJobExecution_GetJobStatus));
-		if ( (eLookupError != 0) || (pWrapperTable->m_BuildJobExecution_GetJobStatus == nullptr) )
+		eLookupError = (*pLookup)("libmcdata_datacapture_getname", (void**)&(pWrapperTable->m_DataCapture_GetName));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCapture_GetName == nullptr) )
 			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
-		eLookupError = (*pLookup)("libmcdata_buildjobexecution_getjobstatusstring", (void**)&(pWrapperTable->m_BuildJobExecution_GetJobStatusString));
-		if ( (eLookupError != 0) || (pWrapperTable->m_BuildJobExecution_GetJobStatusString == nullptr) )
+		eLookupError = (*pLookup)("libmcdata_datacapture_getstatus", (void**)&(pWrapperTable->m_DataCapture_GetStatus));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCapture_GetStatus == nullptr) )
 			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
-		eLookupError = (*pLookup)("libmcdata_buildjobexecution_getjoblayercount", (void**)&(pWrapperTable->m_BuildJobExecution_GetJobLayerCount));
-		if ( (eLookupError != 0) || (pWrapperTable->m_BuildJobExecution_GetJobLayerCount == nullptr) )
+		eLookupError = (*pLookup)("libmcdata_datacapture_gettimestamp", (void**)&(pWrapperTable->m_DataCapture_GetTimeStamp));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCapture_GetTimeStamp == nullptr) )
 			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
-		eLookupError = (*pLookup)("libmcdata_buildjobexecution_getstatus", (void**)&(pWrapperTable->m_BuildJobExecution_GetStatus));
+		eLookupError = (*pLookup)("libmcdata_datacapture_addcolumn", (void**)&(pWrapperTable->m_DataCapture_AddColumn));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCapture_AddColumn == nullptr) )
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcdata_datacapture_getcolumncount", (void**)&(pWrapperTable->m_DataCapture_GetColumnCount));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCapture_GetColumnCount == nullptr) )
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcdata_datacapture_getcolumninformation", (void**)&(pWrapperTable->m_DataCapture_GetColumnInformation));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCapture_GetColumnInformation == nullptr) )
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcdata_datacapture_addsegment", (void**)&(pWrapperTable->m_DataCapture_AddSegment));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCapture_AddSegment == nullptr) )
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcdata_datacapture_getsegmentcount", (void**)&(pWrapperTable->m_DataCapture_GetSegmentCount));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCapture_GetSegmentCount == nullptr) )
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcdata_datacapture_getsegmentinformation", (void**)&(pWrapperTable->m_DataCapture_GetSegmentInformation));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCapture_GetSegmentInformation == nullptr) )
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcdata_datacapture_getsegmentchunkcount", (void**)&(pWrapperTable->m_DataCapture_GetSegmentChunkCount));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCapture_GetSegmentChunkCount == nullptr) )
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcdata_datacapture_getrowcount", (void**)&(pWrapperTable->m_DataCapture_GetRowCount));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCapture_GetRowCount == nullptr) )
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcdata_datacapture_getstoredsizeinbytes", (void**)&(pWrapperTable->m_DataCapture_GetStoredSizeInBytes));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCapture_GetStoredSizeInBytes == nullptr) )
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcdata_datacapture_finish", (void**)&(pWrapperTable->m_DataCapture_Finish));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCapture_Finish == nullptr) )
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcdata_datacapture_abort", (void**)&(pWrapperTable->m_DataCapture_Abort));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCapture_Abort == nullptr) )
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcdata_buildjobexecution_getexecutionuuid", (void**)&(pWrapperTable->m_BuildJobExecution_GetExecutionUUID));
+		if ( (eLookupError != 0) || (pWrapperTable->m_BuildJobExecution_GetExecutionUUID == nullptr) )
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcdata_buildjobexecution_getjobuuid", (void**)&(pWrapperTable->m_BuildJobExecution_GetJobUUID));
+		if ( (eLookupError != 0) || (pWrapperTable->m_BuildJobExecution_GetJobUUID == nullptr) )
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcdata_buildjobexecution_getjobname", (void**)&(pWrapperTable->m_BuildJobExecution_GetJobName));
+		if ( (eLookupError != 0) || (pWrapperTable->m_BuildJobExecution_GetJobName == nullptr) )
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcdata_buildjobexecution_getjobstatus", (void**)&(pWrapperTable->m_BuildJobExecution_GetJobStatus));
+		if ( (eLookupError != 0) || (pWrapperTable->m_BuildJobExecution_GetJobStatus == nullptr) )
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcdata_buildjobexecution_getjobstatusstring", (void**)&(pWrapperTable->m_BuildJobExecution_GetJobStatusString));
+		if ( (eLookupError != 0) || (pWrapperTable->m_BuildJobExecution_GetJobStatusString == nullptr) )
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcdata_buildjobexecution_getjoblayercount", (void**)&(pWrapperTable->m_BuildJobExecution_GetJobLayerCount));
+		if ( (eLookupError != 0) || (pWrapperTable->m_BuildJobExecution_GetJobLayerCount == nullptr) )
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcdata_buildjobexecution_getstatus", (void**)&(pWrapperTable->m_BuildJobExecution_GetStatus));
 		if ( (eLookupError != 0) || (pWrapperTable->m_BuildJobExecution_GetStatus == nullptr) )
 			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
@@ -6308,6 +6845,26 @@ class CDataModel : public CBase {
 		if ( (eLookupError != 0) || (pWrapperTable->m_BuildJobExecution_GetMetaDataString == nullptr) )
 			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
+		eLookupError = (*pLookup)("libmcdata_buildjobexecution_createdatacapture", (void**)&(pWrapperTable->m_BuildJobExecution_CreateDataCapture));
+		if ( (eLookupError != 0) || (pWrapperTable->m_BuildJobExecution_CreateDataCapture == nullptr) )
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcdata_buildjobexecution_hasdatacapture", (void**)&(pWrapperTable->m_BuildJobExecution_HasDataCapture));
+		if ( (eLookupError != 0) || (pWrapperTable->m_BuildJobExecution_HasDataCapture == nullptr) )
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcdata_buildjobexecution_retrievedatacapture", (void**)&(pWrapperTable->m_BuildJobExecution_RetrieveDataCapture));
+		if ( (eLookupError != 0) || (pWrapperTable->m_BuildJobExecution_RetrieveDataCapture == nullptr) )
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcdata_buildjobexecution_getdatacapturecount", (void**)&(pWrapperTable->m_BuildJobExecution_GetDataCaptureCount));
+		if ( (eLookupError != 0) || (pWrapperTable->m_BuildJobExecution_GetDataCaptureCount == nullptr) )
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcdata_buildjobexecution_retrievedatacapturebyindex", (void**)&(pWrapperTable->m_BuildJobExecution_RetrieveDataCaptureByIndex));
+		if ( (eLookupError != 0) || (pWrapperTable->m_BuildJobExecution_RetrieveDataCaptureByIndex == nullptr) )
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
 		eLookupError = (*pLookup)("libmcdata_buildjobexecutioniterator_getcurrentjobexecution", (void**)&(pWrapperTable->m_BuildJobExecutionIterator_GetCurrentJobExecution));
 		if ( (eLookupError != 0) || (pWrapperTable->m_BuildJobExecutionIterator_GetCurrentJobExecution == nullptr) )
 			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
@@ -6516,6 +7073,10 @@ class CDataModel : public CBase {
 		if ( (eLookupError != 0) || (pWrapperTable->m_BuildJobHandler_ListJobExecutionsChangedSince == nullptr) )
 			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
+		eLookupError = (*pLookup)("libmcdata_buildjobhandler_retrievedatacapture", (void**)&(pWrapperTable->m_BuildJobHandler_RetrieveDataCapture));
+		if ( (eLookupError != 0) || (pWrapperTable->m_BuildJobHandler_RetrieveDataCapture == nullptr) )
+			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
 		eLookupError = (*pLookup)("libmcdata_userlist_count", (void**)&(pWrapperTable->m_UserList_Count));
 		if ( (eLookupError != 0) || (pWrapperTable->m_UserList_Count == nullptr) )
 			return LIBMCDATA_ERROR_COULDNOTFINDLIBRARYEXPORT;
@@ -8418,6 +8979,14 @@ class CDataModel : public CBase {
 		return resultFinished;
 	}
 	
+	/**
+	* CStorageZIPWriter::Discard - Discards an unfinished ZIP stream. The file on disk and the stream entry are deleted. Fails if the stream has been finished already. A ZIP writer that is released without Finish is discarded automatically.
+	*/
+	void CStorageZIPWriter::Discard()
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_StorageZIPWriter_Discard(m_pHandle));
+	}
+	
 	/**
 	 * Method definitions for class CStorage
 	 */
@@ -8659,6 +9228,118 @@ class CDataModel : public CBase {
 		sUserUUID = std::string(&bufferUserUUID[0]);
 	}
 	
+	/**
+	* CStorage::GetDownloadTicketDetails - Returns the details of a download ticket without creating an access log entry. Fails if the ticket does not exist.
+	* @param[in] sTicketUUID - UUID of download ticket.
+	* @param[out] sStreamUUID - UUID of storage stream.
+	* @param[out] sClientFileName - ClientFileName of the ticket.
+	* @param[out] sSessionUUID - UUID of user session.
+	* @param[out] sUserUUID - UUID of user that created the ticket.
+	* @param[out] nCreationTimeStamp - Creation time of the ticket in microseconds since 1970.
+	* @param[out] bRevoked - True if the ticket has been revoked.
+	*/
+	void CStorage::GetDownloadTicketDetails(const std::string & sTicketUUID, std::string & sStreamUUID, std::string & sClientFileName, std::string & sSessionUUID, std::string & sUserUUID, LibMCData_uint64 & nCreationTimeStamp, bool & bRevoked)
+	{
+		LibMCData_uint32 bytesNeededStreamUUID = 0;
+		LibMCData_uint32 bytesWrittenStreamUUID = 0;
+		LibMCData_uint32 bytesNeededClientFileName = 0;
+		LibMCData_uint32 bytesWrittenClientFileName = 0;
+		LibMCData_uint32 bytesNeededSessionUUID = 0;
+		LibMCData_uint32 bytesWrittenSessionUUID = 0;
+		LibMCData_uint32 bytesNeededUserUUID = 0;
+		LibMCData_uint32 bytesWrittenUserUUID = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_Storage_GetDownloadTicketDetails(m_pHandle, sTicketUUID.c_str(), 0, &bytesNeededStreamUUID, nullptr, 0, &bytesNeededClientFileName, nullptr, 0, &bytesNeededSessionUUID, nullptr, 0, &bytesNeededUserUUID, nullptr, &nCreationTimeStamp, &bRevoked));
+		std::vector<char> bufferStreamUUID(bytesNeededStreamUUID);
+		std::vector<char> bufferClientFileName(bytesNeededClientFileName);
+		std::vector<char> bufferSessionUUID(bytesNeededSessionUUID);
+		std::vector<char> bufferUserUUID(bytesNeededUserUUID);
+		CheckError(m_pWrapper->m_WrapperTable.m_Storage_GetDownloadTicketDetails(m_pHandle, sTicketUUID.c_str(), bytesNeededStreamUUID, &bytesWrittenStreamUUID, &bufferStreamUUID[0], bytesNeededClientFileName, &bytesWrittenClientFileName, &bufferClientFileName[0], bytesNeededSessionUUID, &bytesWrittenSessionUUID, &bufferSessionUUID[0], bytesNeededUserUUID, &bytesWrittenUserUUID, &bufferUserUUID[0], &nCreationTimeStamp, &bRevoked));
+		sStreamUUID = std::string(&bufferStreamUUID[0]);
+		sClientFileName = std::string(&bufferClientFileName[0]);
+		sSessionUUID = std::string(&bufferSessionUUID[0]);
+		sUserUUID = std::string(&bufferUserUUID[0]);
+	}
+	
+	/**
+	* CStorage::RevokeDownloadTicketsOfStream - Revokes all download tickets of a stream. Revoked tickets can not be used for downloads anymore.
+	* @param[in] sStreamUUID - UUID of storage stream.
+	* @return Number of tickets that were revoked by this call.
+	*/
+	LibMCData_uint32 CStorage::RevokeDownloadTicketsOfStream(const std::string & sStreamUUID)
+	{
+		LibMCData_uint32 resultRevokedCount = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_Storage_RevokeDownloadTicketsOfStream(m_pHandle, sStreamUUID.c_str(), &resultRevokedCount));
+		
+		return resultRevokedCount;
+	}
+	
+	/**
+	* CStorage::LogDownloadStart - Creates an entry in the download access log of a ticket and returns the UUID of the entry.
+	* @param[in] sTicketUUID - UUID of download ticket.
+	* @param[in] sIPAddress - IP Address where the request came from.
+	* @param[in] nAbsoluteTimeStamp - Absolute Time Stamp in Microseconds since 1970.
+	* @return UUID of the access log entry.
+	*/
+	std::string CStorage::LogDownloadStart(const std::string & sTicketUUID, const std::string & sIPAddress, const LibMCData_uint64 nAbsoluteTimeStamp)
+	{
+		LibMCData_uint32 bytesNeededDownloadUUID = 0;
+		LibMCData_uint32 bytesWrittenDownloadUUID = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_Storage_LogDownloadStart(m_pHandle, sTicketUUID.c_str(), sIPAddress.c_str(), nAbsoluteTimeStamp, 0, &bytesNeededDownloadUUID, nullptr));
+		std::vector<char> bufferDownloadUUID(bytesNeededDownloadUUID);
+		CheckError(m_pWrapper->m_WrapperTable.m_Storage_LogDownloadStart(m_pHandle, sTicketUUID.c_str(), sIPAddress.c_str(), nAbsoluteTimeStamp, bytesNeededDownloadUUID, &bytesWrittenDownloadUUID, &bufferDownloadUUID[0]));
+		
+		return std::string(&bufferDownloadUUID[0]);
+	}
+	
+	/**
+	* CStorage::LogDownloadFinish - Records the result of a download in its access log entry. Fails if the entry does not exist.
+	* @param[in] sDownloadUUID - UUID of the access log entry.
+	* @param[in] nSentBytes - Number of bytes that were sent to the client.
+	* @param[in] bSuccess - True if all requested bytes were sent.
+	* @param[in] nAbsoluteTimeStamp - Absolute Time Stamp in Microseconds since 1970.
+	*/
+	void CStorage::LogDownloadFinish(const std::string & sDownloadUUID, const LibMCData_uint64 nSentBytes, const bool bSuccess, const LibMCData_uint64 nAbsoluteTimeStamp)
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_Storage_LogDownloadFinish(m_pHandle, sDownloadUUID.c_str(), nSentBytes, bSuccess, nAbsoluteTimeStamp));
+	}
+	
+	/**
+	* CStorage::DeleteStream - Deletes a finished stream from disk and database, including its download tickets and journal links. Fails if the stream does not exist or is still being written.
+	* @param[in] sUUID - UUID of storage stream.
+	*/
+	void CStorage::DeleteStream(const std::string & sUUID)
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_Storage_DeleteStream(m_pHandle, sUUID.c_str()));
+	}
+	
+	/**
+	* CStorage::DiscardUnfinishedZIPStreams - Deletes all ZIP streams that were never finished and have no active writer, for example after a crash. Returns the number of deleted streams.
+	* @return Number of deleted streams.
+	*/
+	LibMCData_uint32 CStorage::DiscardUnfinishedZIPStreams()
+	{
+		LibMCData_uint32 resultDeletedCount = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_Storage_DiscardUnfinishedZIPStreams(m_pHandle, &resultDeletedCount));
+		
+		return resultDeletedCount;
+	}
+	
+	/**
+	* CStorage::ListStreamUUIDsByName - Returns the UUIDs of all finished streams with the given name, newest first, separated by commas.
+	* @param[in] sName - Name of the streams.
+	* @return Comma separated list of stream UUIDs. Empty if there is none.
+	*/
+	std::string CStorage::ListStreamUUIDsByName(const std::string & sName)
+	{
+		LibMCData_uint32 bytesNeededUUIDList = 0;
+		LibMCData_uint32 bytesWrittenUUIDList = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_Storage_ListStreamUUIDsByName(m_pHandle, sName.c_str(), 0, &bytesNeededUUIDList, nullptr));
+		std::vector<char> bufferUUIDList(bytesNeededUUIDList);
+		CheckError(m_pWrapper->m_WrapperTable.m_Storage_ListStreamUUIDsByName(m_pHandle, sName.c_str(), bytesNeededUUIDList, &bytesWrittenUUIDList, &bufferUUIDList[0]));
+		
+		return std::string(&bufferUUIDList[0]);
+	}
+	
 	/**
 	* CStorage::AttachStreamToJournal - Attaches a stream to a journal as temporary stream.
 	* @param[in] sStreamUUID - UUID of stream. Call fails if stream does not exist.
@@ -8669,6 +9350,40 @@ class CDataModel : public CBase {
 		CheckError(m_pWrapper->m_WrapperTable.m_Storage_AttachStreamToJournal(m_pHandle, sStreamUUID.c_str(), sJournalUUID.c_str()));
 	}
 	
+	/**
+	* CStorage::DiscardRandomWriteStream - Discards an unfinished random write stream. The data on disk and the stream entry are deleted.
+	* @param[in] sUUID - UUID of storage stream. MUST have been created with BeginRandomWriteStream first and MUST NOT be finished.
+	*/
+	void CStorage::DiscardRandomWriteStream(const std::string & sUUID)
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_Storage_DiscardRandomWriteStream(m_pHandle, sUUID.c_str()));
+	}
+	
+	/**
+	* CStorage::GetDataCaptureStorageSize - Returns the size of all data capture segments that are stored on disk.
+	* @return Size in bytes.
+	*/
+	LibMCData_uint64 CStorage::GetDataCaptureStorageSize()
+	{
+		LibMCData_uint64 resultSizeInBytes = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_Storage_GetDataCaptureStorageSize(m_pHandle, &resultSizeInBytes));
+		
+		return resultSizeInBytes;
+	}
+	
+	/**
+	* CStorage::EnforceDataCaptureStorageLimit - Deletes the oldest stored data capture segments until the total stored size is within the limit.
+	* @param[in] nLimitInBytes - Maximum total size of all stored data capture segments in bytes.
+	* @return Number of segments that have been deleted.
+	*/
+	LibMCData_uint32 CStorage::EnforceDataCaptureStorageLimit(const LibMCData_uint64 nLimitInBytes)
+	{
+		LibMCData_uint32 resultPurgedSegmentCount = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_Storage_EnforceDataCaptureStorageLimit(m_pHandle, nLimitInBytes, &resultPurgedSegmentCount));
+		
+		return resultPurgedSegmentCount;
+	}
+	
 	/**
 	 * Method definitions for class CCustomDataStream
 	 */
@@ -8923,6 +9638,244 @@ class CDataModel : public CBase {
 		return std::make_shared<CBuildJobExecutionData>(m_pWrapper, hCurrentInstance);
 	}
 	
+	/**
+	 * Method definitions for class CDataCapture
+	 */
+	
+	/**
+	* CDataCapture::GetUUID - returns the uuid of the data capture.
+	* @return UUID String
+	*/
+	std::string CDataCapture::GetUUID()
+	{
+		LibMCData_uint32 bytesNeededUUID = 0;
+		LibMCData_uint32 bytesWrittenUUID = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_GetUUID(m_pHandle, 0, &bytesNeededUUID, nullptr));
+		std::vector<char> bufferUUID(bytesNeededUUID);
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_GetUUID(m_pHandle, bytesNeededUUID, &bytesWrittenUUID, &bufferUUID[0]));
+		
+		return std::string(&bufferUUID[0]);
+	}
+	
+	/**
+	* CDataCapture::GetExecutionUUID - returns the uuid of the build job execution the capture belongs to.
+	* @return UUID String
+	*/
+	std::string CDataCapture::GetExecutionUUID()
+	{
+		LibMCData_uint32 bytesNeededExecutionUUID = 0;
+		LibMCData_uint32 bytesWrittenExecutionUUID = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_GetExecutionUUID(m_pHandle, 0, &bytesNeededExecutionUUID, nullptr));
+		std::vector<char> bufferExecutionUUID(bytesNeededExecutionUUID);
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_GetExecutionUUID(m_pHandle, bytesNeededExecutionUUID, &bytesWrittenExecutionUUID, &bufferExecutionUUID[0]));
+		
+		return std::string(&bufferExecutionUUID[0]);
+	}
+	
+	/**
+	* CDataCapture::GetIdentifier - returns the identifier of the data capture. It is unique within the build job execution.
+	* @return Identifier String
+	*/
+	std::string CDataCapture::GetIdentifier()
+	{
+		LibMCData_uint32 bytesNeededIdentifier = 0;
+		LibMCData_uint32 bytesWrittenIdentifier = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_GetIdentifier(m_pHandle, 0, &bytesNeededIdentifier, nullptr));
+		std::vector<char> bufferIdentifier(bytesNeededIdentifier);
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_GetIdentifier(m_pHandle, bytesNeededIdentifier, &bytesWrittenIdentifier, &bufferIdentifier[0]));
+		
+		return std::string(&bufferIdentifier[0]);
+	}
+	
+	/**
+	* CDataCapture::GetName - returns the human readable name of the data capture.
+	* @return Name String
+	*/
+	std::string CDataCapture::GetName()
+	{
+		LibMCData_uint32 bytesNeededName = 0;
+		LibMCData_uint32 bytesWrittenName = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_GetName(m_pHandle, 0, &bytesNeededName, nullptr));
+		std::vector<char> bufferName(bytesNeededName);
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_GetName(m_pHandle, bytesNeededName, &bytesWrittenName, &bufferName[0]));
+		
+		return std::string(&bufferName[0]);
+	}
+	
+	/**
+	* CDataCapture::GetStatus - returns the current status of the data capture.
+	* @return Status Value
+	*/
+	eDataCaptureStatus CDataCapture::GetStatus()
+	{
+		eDataCaptureStatus resultStatus = (eDataCaptureStatus) 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_GetStatus(m_pHandle, &resultStatus));
+		
+		return resultStatus;
+	}
+	
+	/**
+	* CDataCapture::GetTimeStamp - returns the time stamp when the data capture was created.
+	* @return Timestamp in ISO8601 UTC format
+	*/
+	std::string CDataCapture::GetTimeStamp()
+	{
+		LibMCData_uint32 bytesNeededTimeStamp = 0;
+		LibMCData_uint32 bytesWrittenTimeStamp = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_GetTimeStamp(m_pHandle, 0, &bytesNeededTimeStamp, nullptr));
+		std::vector<char> bufferTimeStamp(bytesNeededTimeStamp);
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_GetTimeStamp(m_pHandle, bytesNeededTimeStamp, &bytesWrittenTimeStamp, &bufferTimeStamp[0]));
+		
+		return std::string(&bufferTimeStamp[0]);
+	}
+	
+	/**
+	* CDataCapture::AddColumn - Registers a column of the capture schema. Fails if the capture is not recording or the column index already exists.
+	* @param[in] nColumnIndex - Index of the column. 0-based.
+	* @param[in] sIdentifier - Identifier of the column.
+	* @param[in] sDescription - Description of the column.
+	* @param[in] nColumnType - Data type of the column as numeric data table column type.
+	*/
+	void CDataCapture::AddColumn(const LibMCData_uint32 nColumnIndex, const std::string & sIdentifier, const std::string & sDescription, const LibMCData_uint32 nColumnType)
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_AddColumn(m_pHandle, nColumnIndex, sIdentifier.c_str(), sDescription.c_str(), nColumnType));
+	}
+	
+	/**
+	* CDataCapture::GetColumnCount - returns the number of columns of the capture schema.
+	* @return Number of columns.
+	*/
+	LibMCData_uint32 CDataCapture::GetColumnCount()
+	{
+		LibMCData_uint32 resultColumnCount = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_GetColumnCount(m_pHandle, &resultColumnCount));
+		
+		return resultColumnCount;
+	}
+	
+	/**
+	* CDataCapture::GetColumnInformation - returns the schema information of a column. Fails if the index does not exist.
+	* @param[in] nColumnIndex - Index of the column. 0-based.
+	* @param[out] sIdentifier - Identifier of the column.
+	* @param[out] sDescription - Description of the column.
+	* @param[out] nColumnType - Data type of the column as numeric data table column type.
+	*/
+	void CDataCapture::GetColumnInformation(const LibMCData_uint32 nColumnIndex, std::string & sIdentifier, std::string & sDescription, LibMCData_uint32 & nColumnType)
+	{
+		LibMCData_uint32 bytesNeededIdentifier = 0;
+		LibMCData_uint32 bytesWrittenIdentifier = 0;
+		LibMCData_uint32 bytesNeededDescription = 0;
+		LibMCData_uint32 bytesWrittenDescription = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_GetColumnInformation(m_pHandle, nColumnIndex, 0, &bytesNeededIdentifier, nullptr, 0, &bytesNeededDescription, nullptr, &nColumnType));
+		std::vector<char> bufferIdentifier(bytesNeededIdentifier);
+		std::vector<char> bufferDescription(bytesNeededDescription);
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_GetColumnInformation(m_pHandle, nColumnIndex, bytesNeededIdentifier, &bytesWrittenIdentifier, &bufferIdentifier[0], bytesNeededDescription, &bytesWrittenDescription, &bufferDescription[0], &nColumnType));
+		sIdentifier = std::string(&bufferIdentifier[0]);
+		sDescription = std::string(&bufferDescription[0]);
+	}
+	
+	/**
+	* CDataCapture::AddSegment - Registers a finished segment stream of the capture. Fails if the capture is not recording or the segment index already exists.
+	* @param[in] nSegmentIndex - Index of the segment. 0-based.
+	* @param[in] sStreamUUID - UUID of the storage stream that holds the segment. The stream MUST exist.
+	* @param[in] nFirstRow - Index of the first row of the segment within the capture.
+	* @param[in] nRowCount - Number of rows in the segment.
+	* @param[in] nChunkCount - Number of chunks in the segment.
+	* @param[in] nSizeInBytes - Size of the segment stream in bytes.
+	* @param[in] nStartTimeStamp - Absolute time stamp in microseconds since 1970 when the segment was opened.
+	* @param[in] nEndTimeStamp - Absolute time stamp in microseconds since 1970 when the segment was closed.
+	*/
+	void CDataCapture::AddSegment(const LibMCData_uint32 nSegmentIndex, const std::string & sStreamUUID, const LibMCData_uint64 nFirstRow, const LibMCData_uint64 nRowCount, const LibMCData_uint32 nChunkCount, const LibMCData_uint64 nSizeInBytes, const LibMCData_uint64 nStartTimeStamp, const LibMCData_uint64 nEndTimeStamp)
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_AddSegment(m_pHandle, nSegmentIndex, sStreamUUID.c_str(), nFirstRow, nRowCount, nChunkCount, nSizeInBytes, nStartTimeStamp, nEndTimeStamp));
+	}
+	
+	/**
+	* CDataCapture::GetSegmentCount - returns the number of registered segments, including purged ones.
+	* @return Number of segments.
+	*/
+	LibMCData_uint32 CDataCapture::GetSegmentCount()
+	{
+		LibMCData_uint32 resultSegmentCount = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_GetSegmentCount(m_pHandle, &resultSegmentCount));
+		
+		return resultSegmentCount;
+	}
+	
+	/**
+	* CDataCapture::GetSegmentInformation - returns the manifest entry of a segment. Fails if the index does not exist.
+	* @param[in] nSegmentIndex - Index of the segment. 0-based.
+	* @param[out] sStreamUUID - UUID of the storage stream that holds the segment.
+	* @param[out] nFirstRow - Index of the first row of the segment within the capture.
+	* @param[out] nRowCount - Number of rows in the segment.
+	* @param[out] nSizeInBytes - Size of the segment stream in bytes.
+	* @param[out] bIsPurged - Returns true if the segment data has been deleted by retention or abort.
+	*/
+	void CDataCapture::GetSegmentInformation(const LibMCData_uint32 nSegmentIndex, std::string & sStreamUUID, LibMCData_uint64 & nFirstRow, LibMCData_uint64 & nRowCount, LibMCData_uint64 & nSizeInBytes, bool & bIsPurged)
+	{
+		LibMCData_uint32 bytesNeededStreamUUID = 0;
+		LibMCData_uint32 bytesWrittenStreamUUID = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_GetSegmentInformation(m_pHandle, nSegmentIndex, 0, &bytesNeededStreamUUID, nullptr, &nFirstRow, &nRowCount, &nSizeInBytes, &bIsPurged));
+		std::vector<char> bufferStreamUUID(bytesNeededStreamUUID);
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_GetSegmentInformation(m_pHandle, nSegmentIndex, bytesNeededStreamUUID, &bytesWrittenStreamUUID, &bufferStreamUUID[0], &nFirstRow, &nRowCount, &nSizeInBytes, &bIsPurged));
+		sStreamUUID = std::string(&bufferStreamUUID[0]);
+	}
+	
+	/**
+	* CDataCapture::GetSegmentChunkCount - returns the number of chunks of a segment. Fails if the index does not exist.
+	* @param[in] nSegmentIndex - Index of the segment. 0-based.
+	* @return Number of chunks in the segment.
+	*/
+	LibMCData_uint32 CDataCapture::GetSegmentChunkCount(const LibMCData_uint32 nSegmentIndex)
+	{
+		LibMCData_uint32 resultChunkCount = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_GetSegmentChunkCount(m_pHandle, nSegmentIndex, &resultChunkCount));
+		
+		return resultChunkCount;
+	}
+	
+	/**
+	* CDataCapture::GetRowCount - returns the number of rows in all registered segments, including purged ones.
+	* @return Number of rows.
+	*/
+	LibMCData_uint64 CDataCapture::GetRowCount()
+	{
+		LibMCData_uint64 resultRowCount = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_GetRowCount(m_pHandle, &resultRowCount));
+		
+		return resultRowCount;
+	}
+	
+	/**
+	* CDataCapture::GetStoredSizeInBytes - returns the size of all segments of the capture that are still stored on disk.
+	* @return Size in bytes.
+	*/
+	LibMCData_uint64 CDataCapture::GetStoredSizeInBytes()
+	{
+		LibMCData_uint64 resultSizeInBytes = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_GetStoredSizeInBytes(m_pHandle, &resultSizeInBytes));
+		
+		return resultSizeInBytes;
+	}
+	
+	/**
+	* CDataCapture::Finish - Marks the capture as finished. Fails if the capture is not recording.
+	* @param[in] nAbsoluteTimeStamp - Absolute Time Stamp in Microseconds since 1970.
+	*/
+	void CDataCapture::Finish(const LibMCData_uint64 nAbsoluteTimeStamp)
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_Finish(m_pHandle, nAbsoluteTimeStamp));
+	}
+	
+	/**
+	* CDataCapture::Abort - Deletes all stored segments of the capture and marks it as aborted. Fails if the capture has been aborted before.
+	* @param[in] nAbsoluteTimeStamp - Absolute Time Stamp in Microseconds since 1970.
+	*/
+	void CDataCapture::Abort(const LibMCData_uint64 nAbsoluteTimeStamp)
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_Abort(m_pHandle, nAbsoluteTimeStamp));
+	}
+	
 	/**
 	 * Method definitions for class CBuildJobExecution
 	 */
@@ -9291,6 +10244,82 @@ class CDataModel : public CBase {
 		return std::string(&bufferValue[0]);
 	}
 	
+	/**
+	* CBuildJobExecution::CreateDataCapture - Creates the manifest of a new data capture in recording state. Fails if the identifier already exists in this execution.
+	* @param[in] sIdentifier - Identifier of the capture. MUST be unique within the execution, alphanumeric and not empty.
+	* @param[in] sName - Human readable name of the capture. MUST NOT be empty.
+	* @param[in] sUserUUID - UUID of the user that started the capture. Use 00000000-0000-0000-0000-000000000000 if no user shall be recorded.
+	* @param[in] nAbsoluteTimeStamp - Absolute Time Stamp in Microseconds since 1970.
+	* @return Data capture manifest instance.
+	*/
+	PDataCapture CBuildJobExecution::CreateDataCapture(const std::string & sIdentifier, const std::string & sName, const std::string & sUserUUID, const LibMCData_uint64 nAbsoluteTimeStamp)
+	{
+		LibMCDataHandle hDataCaptureInstance = nullptr;
+		CheckError(m_pWrapper->m_WrapperTable.m_BuildJobExecution_CreateDataCapture(m_pHandle, sIdentifier.c_str(), sName.c_str(), sUserUUID.c_str(), nAbsoluteTimeStamp, &hDataCaptureInstance));
+		
+		if (!hDataCaptureInstance) {
+			CheckError(LIBMCDATA_ERROR_INVALIDPARAM);
+		}
+		return std::make_shared<CDataCapture>(m_pWrapper, hDataCaptureInstance);
+	}
+	
+	/**
+	* CBuildJobExecution::HasDataCapture - Returns if a data capture with a specific identifier exists in this execution.
+	* @param[in] sIdentifier - Identifier of the capture.
+	* @return Returns true, if the data capture exists.
+	*/
+	bool CBuildJobExecution::HasDataCapture(const std::string & sIdentifier)
+	{
+		bool resultHasDataCapture = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_BuildJobExecution_HasDataCapture(m_pHandle, sIdentifier.c_str(), &resultHasDataCapture));
+		
+		return resultHasDataCapture;
+	}
+	
+	/**
+	* CBuildJobExecution::RetrieveDataCapture - Retrieves the manifest of a data capture by its identifier. Fails if the identifier does not exist.
+	* @param[in] sIdentifier - Identifier of the capture.
+	* @return Data capture manifest instance.
+	*/
+	PDataCapture CBuildJobExecution::RetrieveDataCapture(const std::string & sIdentifier)
+	{
+		LibMCDataHandle hDataCaptureInstance = nullptr;
+		CheckError(m_pWrapper->m_WrapperTable.m_BuildJobExecution_RetrieveDataCapture(m_pHandle, sIdentifier.c_str(), &hDataCaptureInstance));
+		
+		if (!hDataCaptureInstance) {
+			CheckError(LIBMCDATA_ERROR_INVALIDPARAM);
+		}
+		return std::make_shared<CDataCapture>(m_pWrapper, hDataCaptureInstance);
+	}
+	
+	/**
+	* CBuildJobExecution::GetDataCaptureCount - Returns the number of data captures of this execution.
+	* @return Number of data captures.
+	*/
+	LibMCData_uint32 CBuildJobExecution::GetDataCaptureCount()
+	{
+		LibMCData_uint32 resultDataCaptureCount = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_BuildJobExecution_GetDataCaptureCount(m_pHandle, &resultDataCaptureCount));
+		
+		return resultDataCaptureCount;
+	}
+	
+	/**
+	* CBuildJobExecution::RetrieveDataCaptureByIndex - Retrieves the manifest of a data capture of this execution by its index. Captures are ordered by their creation time.
+	* @param[in] nIndex - Index of the capture. 0-based. Fails if the index is out of bounds.
+	* @return Data capture manifest instance.
+	*/
+	PDataCapture CBuildJobExecution::RetrieveDataCaptureByIndex(const LibMCData_uint32 nIndex)
+	{
+		LibMCDataHandle hDataCaptureInstance = nullptr;
+		CheckError(m_pWrapper->m_WrapperTable.m_BuildJobExecution_RetrieveDataCaptureByIndex(m_pHandle, nIndex, &hDataCaptureInstance));
+		
+		if (!hDataCaptureInstance) {
+			CheckError(LIBMCDATA_ERROR_INVALIDPARAM);
+		}
+		return std::make_shared<CDataCapture>(m_pWrapper, hDataCaptureInstance);
+	}
+	
 	/**
 	 * Method definitions for class CBuildJobExecutionIterator
 	 */
@@ -10035,6 +11064,22 @@ class CDataModel : public CBase {
 		return std::make_shared<CBuildJobExecutionIterator>(m_pWrapper, hIteratorInstance);
 	}
 	
+	/**
+	* CBuildJobHandler::RetrieveDataCapture - Retrieves the manifest of a data capture by its uuid. Fails if the capture does not exist.
+	* @param[in] sDataCaptureUUID - UUID of the data capture.
+	* @return Data capture manifest instance.
+	*/
+	PDataCapture CBuildJobHandler::RetrieveDataCapture(const std::string & sDataCaptureUUID)
+	{
+		LibMCDataHandle hDataCaptureInstance = nullptr;
+		CheckError(m_pWrapper->m_WrapperTable.m_BuildJobHandler_RetrieveDataCapture(m_pHandle, sDataCaptureUUID.c_str(), &hDataCaptureInstance));
+		
+		if (!hDataCaptureInstance) {
+			CheckError(LIBMCDATA_ERROR_INVALIDPARAM);
+		}
+		return std::make_shared<CDataCapture>(m_pWrapper, hDataCaptureInstance);
+	}
+	
 	/**
 	 * Method definitions for class CUserList
 	 */
diff --git a/Framework/HeadersCore/CppDynamic/libmcdata_types.hpp b/Framework/HeadersCore/CppDynamic/libmcdata_types.hpp
index a2d8e0c67..e08caec01 100644
--- a/Framework/HeadersCore/CppDynamic/libmcdata_types.hpp
+++ b/Framework/HeadersCore/CppDynamic/libmcdata_types.hpp
@@ -478,6 +478,21 @@ typedef void * LibMCData_pvoid;
 #define LIBMCDATA_ERROR_JOBNAMETOOLONG 451 /** Job name exceeds maximum allowed length */
 #define LIBMCDATA_ERROR_STRINGPARAMETERTOOLONG 452 /** String parameter exceeds maximum allowed length */
 #define LIBMCDATA_ERROR_TELEMETRYSETTINGAFTERINITIALISATION 453 /** Telemetry setting changed after database initialisation */
+#define LIBMCDATA_ERROR_DATACAPTURENOTFOUND 454 /** Data capture not found. */
+#define LIBMCDATA_ERROR_DUPLICATEDATACAPTUREIDENTIFIER 455 /** Duplicate data capture identifier. */
+#define LIBMCDATA_ERROR_INVALIDDATACAPTUREIDENTIFIER 456 /** Invalid data capture identifier. */
+#define LIBMCDATA_ERROR_INVALIDDATACAPTURENAME 457 /** Invalid data capture name. */
+#define LIBMCDATA_ERROR_DATACAPTURENOTRECORDING 458 /** Data capture is not recording. */
+#define LIBMCDATA_ERROR_INVALIDDATACAPTURESTATUS 459 /** Invalid data capture status. */
+#define LIBMCDATA_ERROR_INVALIDDATACAPTURECOLUMNINDEX 460 /** Invalid data capture column index. */
+#define LIBMCDATA_ERROR_INVALIDDATACAPTURESEGMENTINDEX 461 /** Invalid data capture segment index. */
+#define LIBMCDATA_ERROR_DUPLICATEDATACAPTURESEGMENT 462 /** Duplicate data capture segment. */
+#define LIBMCDATA_ERROR_DUPLICATEDATACAPTURECOLUMN 463 /** Duplicate data capture column. */
+#define LIBMCDATA_ERROR_DATACAPTUREALREADYABORTED 464 /** Data capture has already been aborted. */
+#define LIBMCDATA_ERROR_RANDOMWRITESTREAMNOTFOUND 465 /** Random write stream not found. */
+#define LIBMCDATA_ERROR_DOWNLOADENTRYNOTFOUND 466 /** Download access log entry not found. */
+#define LIBMCDATA_ERROR_STREAMHASACTIVEWRITER 467 /** Storage stream is still being written. */
+#define LIBMCDATA_ERROR_ZIPSTREAMALREADYFINISHED 468 /** ZIP stream has already been finished and can not be discarded. */
 
 /*************************************************************************************************************************
  Error strings for LibMCData
@@ -868,6 +883,21 @@ inline const char * LIBMCDATA_GETERRORSTRING (LibMCDataResult nErrorCode) {
     case LIBMCDATA_ERROR_JOBNAMETOOLONG: return "Job name exceeds maximum allowed length";
     case LIBMCDATA_ERROR_STRINGPARAMETERTOOLONG: return "String parameter exceeds maximum allowed length";
     case LIBMCDATA_ERROR_TELEMETRYSETTINGAFTERINITIALISATION: return "Telemetry setting changed after database initialisation";
+    case LIBMCDATA_ERROR_DATACAPTURENOTFOUND: return "Data capture not found.";
+    case LIBMCDATA_ERROR_DUPLICATEDATACAPTUREIDENTIFIER: return "Duplicate data capture identifier.";
+    case LIBMCDATA_ERROR_INVALIDDATACAPTUREIDENTIFIER: return "Invalid data capture identifier.";
+    case LIBMCDATA_ERROR_INVALIDDATACAPTURENAME: return "Invalid data capture name.";
+    case LIBMCDATA_ERROR_DATACAPTURENOTRECORDING: return "Data capture is not recording.";
+    case LIBMCDATA_ERROR_INVALIDDATACAPTURESTATUS: return "Invalid data capture status.";
+    case LIBMCDATA_ERROR_INVALIDDATACAPTURECOLUMNINDEX: return "Invalid data capture column index.";
+    case LIBMCDATA_ERROR_INVALIDDATACAPTURESEGMENTINDEX: return "Invalid data capture segment index.";
+    case LIBMCDATA_ERROR_DUPLICATEDATACAPTURESEGMENT: return "Duplicate data capture segment.";
+    case LIBMCDATA_ERROR_DUPLICATEDATACAPTURECOLUMN: return "Duplicate data capture column.";
+    case LIBMCDATA_ERROR_DATACAPTUREALREADYABORTED: return "Data capture has already been aborted.";
+    case LIBMCDATA_ERROR_RANDOMWRITESTREAMNOTFOUND: return "Random write stream not found.";
+    case LIBMCDATA_ERROR_DOWNLOADENTRYNOTFOUND: return "Download access log entry not found.";
+    case LIBMCDATA_ERROR_STREAMHASACTIVEWRITER: return "Storage stream is still being written.";
+    case LIBMCDATA_ERROR_ZIPSTREAMALREADYFINISHED: return "ZIP stream has already been finished and can not be discarded.";
     default: return "unknown error";
   }
 }
@@ -897,6 +927,7 @@ typedef LibMCDataHandle LibMCData_BuildJobData;
 typedef LibMCDataHandle LibMCData_BuildJobDataIterator;
 typedef LibMCDataHandle LibMCData_BuildJobExecutionData;
 typedef LibMCDataHandle LibMCData_BuildJobExecutionDataIterator;
+typedef LibMCDataHandle LibMCData_DataCapture;
 typedef LibMCDataHandle LibMCData_BuildJobExecution;
 typedef LibMCDataHandle LibMCData_BuildJobExecutionIterator;
 typedef LibMCDataHandle LibMCData_BuildJob;
@@ -990,6 +1021,13 @@ namespace LibMCData {
     IntervalEndMarker = 3
   };
   
+  enum class eDataCaptureStatus : LibMCData_int32 {
+    Unknown = 0,
+    Recording = 1,
+    Finished = 2,
+    Aborted = 3
+  };
+  
   enum class eBuildJobExecutionStatus : LibMCData_int32 {
     Unknown = 0,
     InProcess = 1,
@@ -1074,6 +1112,7 @@ typedef LibMCData::eBuildJobStatus eLibMCDataBuildJobStatus;
 typedef LibMCData::eCustomDataType eLibMCDataCustomDataType;
 typedef LibMCData::eTelemetryChannelType eLibMCDataTelemetryChannelType;
 typedef LibMCData::eTelemetryChunkEntryType eLibMCDataTelemetryChunkEntryType;
+typedef LibMCData::eDataCaptureStatus eLibMCDataDataCaptureStatus;
 typedef LibMCData::eBuildJobExecutionStatus eLibMCDataBuildJobExecutionStatus;
 typedef LibMCData::sJournalChunkVariableInfo sLibMCDataJournalChunkVariableInfo;
 typedef LibMCData::sTelemetryChunkEntry sLibMCDataTelemetryChunkEntry;
diff --git a/Framework/HeadersDev/CppDynamic/libmcenv_dynamic.h b/Framework/HeadersDev/CppDynamic/libmcenv_dynamic.h
index efc024a23..fdfd0e4bc 100644
--- a/Framework/HeadersDev/CppDynamic/libmcenv_dynamic.h
+++ b/Framework/HeadersDev/CppDynamic/libmcenv_dynamic.h
@@ -1387,242 +1387,1004 @@ typedef LibMCEnvResult (*PLibMCEnvDataTable_HasColumnPtr) (LibMCEnv_DataTable pD
 */
 typedef LibMCEnvResult (*PLibMCEnvDataTable_GetRowCountPtr) (LibMCEnv_DataTable pDataTable, LibMCEnv_uint32 * pRowCount);
 
+/**
+* Returns the current row count as 64 bit value. GetRowCount is kept for ABI compatibility and truncates large row counts.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[out] pRowCount - Number of rows.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataTable_GetRowCount64Ptr) (LibMCEnv_DataTable pDataTable, LibMCEnv_uint64 * pRowCount);
+
 /**
 * Returns the current column count.
 *
-* @param[in] pDataTable - DataTable instance.
-* @param[out] pColumnCount - Number of columns.
+* @param[in] pDataTable - DataTable instance.
+* @param[out] pColumnCount - Number of columns.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataTable_GetColumnCountPtr) (LibMCEnv_DataTable pDataTable, LibMCEnv_uint32 * pColumnCount);
+
+/**
+* Returns the identifier of a column. Will fail if Index is out of bounds.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] nColumnIndex - Index of column. 0-based.
+* @param[in] nIdentifierBufferSize - size of the buffer (including trailing 0)
+* @param[out] pIdentifierNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pIdentifierBuffer -  buffer of Identifier of the column., may be NULL
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataTable_GetColumnIdentifierPtr) (LibMCEnv_DataTable pDataTable, LibMCEnv_uint32 nColumnIndex, const LibMCEnv_uint32 nIdentifierBufferSize, LibMCEnv_uint32* pIdentifierNeededChars, char * pIdentifierBuffer);
+
+/**
+* Returns the description of a column. Will fail if Index is out of bounds.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] nColumnIndex - Index of column. 0-based.
+* @param[in] nDescriptionBufferSize - size of the buffer (including trailing 0)
+* @param[out] pDescriptionNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pDescriptionBuffer -  buffer of Description of the column., may be NULL
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataTable_GetColumnDescriptionPtr) (LibMCEnv_DataTable pDataTable, LibMCEnv_uint32 nColumnIndex, const LibMCEnv_uint32 nDescriptionBufferSize, LibMCEnv_uint32* pDescriptionNeededChars, char * pDescriptionBuffer);
+
+/**
+* Returns the type of a column. Will fail if Index is out of bounds.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] nColumnIndex - Index of column. 0-based.
+* @param[out] pColumnType - Data type of the column.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataTable_GetColumnTypePtr) (LibMCEnv_DataTable pDataTable, LibMCEnv_uint32 nColumnIndex, LibMCEnv::eDataTableColumnType * pColumnType);
+
+/**
+* Returns the values of a double column. Will fail if column does not exist or type is not double.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nDescriptionBufferSize - size of the buffer (including trailing 0)
+* @param[out] pDescriptionNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pDescriptionBuffer -  buffer of Description of the column., may be NULL
+* @param[out] pColumnType - Data type of the column.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataTable_GetColumnInformationPtr) (LibMCEnv_DataTable pDataTable, const char * pIdentifier, const LibMCEnv_uint32 nDescriptionBufferSize, LibMCEnv_uint32* pDescriptionNeededChars, char * pDescriptionBuffer, LibMCEnv::eDataTableColumnType * pColumnType);
+
+/**
+* Returns the values of a double column. Will fail if column does not exist or type is not double.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[out] pValuesNeededCount - will be filled with the count of the written elements, or needed buffer size.
+* @param[out] pValuesBuffer - double  buffer of Value array of a column.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataTable_GetDoubleColumnValuesPtr) (LibMCEnv_DataTable pDataTable, const char * pIdentifier, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_double * pValuesBuffer);
+
+/**
+* Returns the double columns. Will fail if column does not exist or type is not int32.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[out] pValuesNeededCount - will be filled with the count of the written elements, or needed buffer size.
+* @param[out] pValuesBuffer - int32  buffer of Value array of a column.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataTable_GetInt32ColumnValuesPtr) (LibMCEnv_DataTable pDataTable, const char * pIdentifier, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_int32 * pValuesBuffer);
+
+/**
+* Returns the double columns. Will fail if column does not exist or type is not int64.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[out] pValuesNeededCount - will be filled with the count of the written elements, or needed buffer size.
+* @param[out] pValuesBuffer - int64  buffer of Value array of a column.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataTable_GetInt64ColumnValuesPtr) (LibMCEnv_DataTable pDataTable, const char * pIdentifier, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_int64 * pValuesBuffer);
+
+/**
+* Returns the double columns. Will fail if column does not exist or type is not uint32.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[out] pValuesNeededCount - will be filled with the count of the written elements, or needed buffer size.
+* @param[out] pValuesBuffer - uint32  buffer of Value array of a column.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataTable_GetUint32ColumnValuesPtr) (LibMCEnv_DataTable pDataTable, const char * pIdentifier, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_uint32 * pValuesBuffer);
+
+/**
+* Returns the double columns. Will fail if column does not exist or type is not uint64.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[out] pValuesNeededCount - will be filled with the count of the written elements, or needed buffer size.
+* @param[out] pValuesBuffer - uint64  buffer of Value array of a column.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataTable_GetUint64ColumnValuesPtr) (LibMCEnv_DataTable pDataTable, const char * pIdentifier, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_uint64 * pValuesBuffer);
+
+/**
+* Returns the values of a float (32 bit) column. Will fail if column does not exist or type is not float.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[out] pValuesNeededCount - will be filled with the count of the written elements, or needed buffer size.
+* @param[out] pValuesBuffer - single  buffer of Value array of a column.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataTable_GetFloatColumnValuesPtr) (LibMCEnv_DataTable pDataTable, const char * pIdentifier, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_single * pValuesBuffer);
+
+/**
+* Returns the values of a bool column as bytes (0 = false, 1 = true). Will fail if column does not exist or type is not bool.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[out] pValuesNeededCount - will be filled with the count of the written elements, or needed buffer size.
+* @param[out] pValuesBuffer - uint8  buffer of Value array of a column. Each entry is 0 or 1.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataTable_GetBoolColumnValuesPtr) (LibMCEnv_DataTable pDataTable, const char * pIdentifier, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_uint8 * pValuesBuffer);
+
+/**
+* Returns the values of a timestamp column in microseconds. Will fail if column does not exist or type is not timestamp.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[out] pValuesNeededCount - will be filled with the count of the written elements, or needed buffer size.
+* @param[out] pValuesBuffer - uint64  buffer of Value array of a column. Timestamps in microseconds.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataTable_GetTimestampColumnValuesPtr) (LibMCEnv_DataTable pDataTable, const char * pIdentifier, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_uint64 * pValuesBuffer);
+
+/**
+* Sets the values of a double column. Will fail if column does not exist or type is not double.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[in] pValuesBuffer - double buffer of New Value array of a column. Array length should match RowCount. Values will be filled up with 0, if length is less than RowCount. RowCount will be extended if length is larger than RowCount.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataTable_SetDoubleColumnValuesPtr) (LibMCEnv_DataTable pDataTable, const char * pIdentifier, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_double * pValuesBuffer);
+
+/**
+* Sets the double columns. Will fail if column does not exist or type is not int32.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[in] pValuesBuffer - int32 buffer of New Value array of a column. Array length should match RowCount. Values will be filled up with 0, if length is less than RowCount. RowCount will be extended if length is larger than RowCount.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataTable_SetInt32ColumnValuesPtr) (LibMCEnv_DataTable pDataTable, const char * pIdentifier, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_int32 * pValuesBuffer);
+
+/**
+* Sets the double columns. Will fail if column does not exist or type is not int64.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[in] pValuesBuffer - int64 buffer of New Value array of a column. Array length should match RowCount. Values will be filled up with 0, if length is less than RowCount. RowCount will be extended if length is larger than RowCount.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataTable_SetInt64ColumnValuesPtr) (LibMCEnv_DataTable pDataTable, const char * pIdentifier, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_int64 * pValuesBuffer);
+
+/**
+* Sets the double columns. Will fail if column does not exist or type is not uint32.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[in] pValuesBuffer - uint32 buffer of New Value array of a column. Array length should match RowCount. Values will be filled up with 0, if length is less than RowCount. RowCount will be extended if length is larger than RowCount.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataTable_SetUint32ColumnValuesPtr) (LibMCEnv_DataTable pDataTable, const char * pIdentifier, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint32 * pValuesBuffer);
+
+/**
+* Sets the double columns. Will fail if column does not exist or type is not uint64.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[in] pValuesBuffer - uint64 buffer of New Value array of a column. Array length should match RowCount. Values will be filled up with 0, if length is less than RowCount. RowCount will be extended if length is larger than RowCount.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataTable_SetUint64ColumnValuesPtr) (LibMCEnv_DataTable pDataTable, const char * pIdentifier, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint64 * pValuesBuffer);
+
+/**
+* Sets the values of a float (32 bit) column. Will fail if column does not exist or type is not float.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[in] pValuesBuffer - single buffer of New Value array of a column. Array length should match RowCount. Values will be filled up with 0, if length is less than RowCount. RowCount will be extended if length is larger than RowCount.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataTable_SetFloatColumnValuesPtr) (LibMCEnv_DataTable pDataTable, const char * pIdentifier, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_single * pValuesBuffer);
+
+/**
+* Sets the values of a bool column from bytes (0 = false, nonzero = true). Will fail if column does not exist or type is not bool.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[in] pValuesBuffer - uint8 buffer of New Value array of a column. Array length should match RowCount. Values will be filled up with 0, if length is less than RowCount. RowCount will be extended if length is larger than RowCount.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataTable_SetBoolColumnValuesPtr) (LibMCEnv_DataTable pDataTable, const char * pIdentifier, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint8 * pValuesBuffer);
+
+/**
+* Sets the values of a timestamp column in microseconds. Will fail if column does not exist or type is not timestamp.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[in] pValuesBuffer - uint64 buffer of New Value array of a column. Array length should match RowCount. Values will be filled up with 0, if length is less than RowCount. RowCount will be extended if length is larger than RowCount.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataTable_SetTimestampColumnValuesPtr) (LibMCEnv_DataTable pDataTable, const char * pIdentifier, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint64 * pValuesBuffer);
+
+/**
+* Creates a Write Option.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[out] pOptions - Writer Options Instance to pass on to WriteDataToStream.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataTable_CreateWriteOptionsPtr) (LibMCEnv_DataTable pDataTable, LibMCEnv_DataTableWriteOptions * pOptions);
+
+/**
+* Creates a CSV Write Option.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[out] pOptions - Writer Options Instance to pass on to WriteCSVToStream.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataTable_CreateCSVWriteOptionsPtr) (LibMCEnv_DataTable pDataTable, LibMCEnv_DataTableCSVWriteOptions * pOptions);
+
+/**
+* Writes the data as CSV to a temporary stream.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pWriter - Stream writer to use.
+* @param[in] pOptions - Optional CSV writer options to use.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataTable_WriteCSVToStreamPtr) (LibMCEnv_DataTable pDataTable, LibMCEnv_TempStreamWriter pWriter, LibMCEnv_DataTableCSVWriteOptions pOptions);
+
+/**
+* Writes the data as binary to a temporary stream.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pWriter - Stream writer instance to use.
+* @param[in] pOptions - Optional writer options to use.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataTable_WriteDataToStreamPtr) (LibMCEnv_DataTable pDataTable, LibMCEnv_TempStreamWriter pWriter, LibMCEnv_DataTableWriteOptions pOptions);
+
+/**
+* Loads the data table from a stream. Clears all existing data from the data table.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pStream - Stream read instance to read from.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataTable_LoadFromStreamPtr) (LibMCEnv_DataTable pDataTable, LibMCEnv_StreamReader pStream);
+
+/**
+* Creates an options object for scatter plot computation.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[out] pScatterPlotOptions - DataTableScatterPlotOptions Instance
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataTable_CreateScatterPlotOptionsPtr) (LibMCEnv_DataTable pDataTable, LibMCEnv_DataTableScatterPlotOptions * pScatterPlotOptions);
+
+/**
+* Creates a scatterplot from the data table according to its input parameters.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pScatterPlotOptions - ScatterPlot Options to use
+* @param[out] pScatterPlot - ScatterPlot Instance
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataTable_CalculateScatterPlotPtr) (LibMCEnv_DataTable pDataTable, LibMCEnv_DataTableScatterPlotOptions pScatterPlotOptions, LibMCEnv_ScatterPlot * pScatterPlot);
+
+/*************************************************************************************************************************
+ Class definition for DataCaptureOptions
+**************************************************************************************************************************/
+
+/**
+* Sets the number of rows a chunk can hold. Default is 65536.
+*
+* @param[in] pDataCaptureOptions - DataCaptureOptions instance.
+* @param[in] nChunkRowCount - Rows per chunk. MUST be between 1 and 16777216.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataCaptureOptions_SetChunkRowCountPtr) (LibMCEnv_DataCaptureOptions pDataCaptureOptions, LibMCEnv_uint32 nChunkRowCount);
+
+/**
+* Returns the number of rows a chunk can hold.
+*
+* @param[in] pDataCaptureOptions - DataCaptureOptions instance.
+* @param[out] pChunkRowCount - Rows per chunk.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataCaptureOptions_GetChunkRowCountPtr) (LibMCEnv_DataCaptureOptions pDataCaptureOptions, LibMCEnv_uint32 * pChunkRowCount);
+
+/**
+* Sets the size at which the capture rolls over into a new segment stream. Default is 1 GB.
+*
+* @param[in] pDataCaptureOptions - DataCaptureOptions instance.
+* @param[in] nSegmentSizeInBytes - Maximum segment size in bytes. 0 means the capture never rolls over. A segment always holds at least one chunk.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataCaptureOptions_SetSegmentSizeInBytesPtr) (LibMCEnv_DataCaptureOptions pDataCaptureOptions, LibMCEnv_uint64 nSegmentSizeInBytes);
+
+/**
+* Returns the size at which the capture rolls over into a new segment stream.
+*
+* @param[in] pDataCaptureOptions - DataCaptureOptions instance.
+* @param[out] pSegmentSizeInBytes - Maximum segment size in bytes. 0 means the capture never rolls over.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataCaptureOptions_GetSegmentSizeInBytesPtr) (LibMCEnv_DataCaptureOptions pDataCaptureOptions, LibMCEnv_uint64 * pSegmentSizeInBytes);
+
+/**
+* Sets the maximum number of committed chunks that may wait for the writer thread. Default is 16.
+*
+* @param[in] pDataCaptureOptions - DataCaptureOptions instance.
+* @param[in] nMaxQueuedChunks - Queue depth. MUST be between 1 and 1024.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataCaptureOptions_SetMaxQueuedChunksPtr) (LibMCEnv_DataCaptureOptions pDataCaptureOptions, LibMCEnv_uint32 nMaxQueuedChunks);
+
+/**
+* Returns the maximum number of committed chunks that may wait for the writer thread.
+*
+* @param[in] pDataCaptureOptions - DataCaptureOptions instance.
+* @param[out] pMaxQueuedChunks - Queue depth.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataCaptureOptions_GetMaxQueuedChunksPtr) (LibMCEnv_DataCaptureOptions pDataCaptureOptions, LibMCEnv_uint32 * pMaxQueuedChunks);
+
+/**
+* Sets what happens when the producer is faster than the disk. Default is Block.
+*
+* @param[in] pDataCaptureOptions - DataCaptureOptions instance.
+* @param[in] eBackpressureMode - Block waits for the writer, DropOldest discards the oldest queued chunk, Fail raises an error.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataCaptureOptions_SetBackpressureModePtr) (LibMCEnv_DataCaptureOptions pDataCaptureOptions, LibMCEnv::eDataCaptureBackpressureMode eBackpressureMode);
+
+/**
+* Returns what happens when the producer is faster than the disk.
+*
+* @param[in] pDataCaptureOptions - DataCaptureOptions instance.
+* @param[out] pBackpressureMode - Backpressure mode.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataCaptureOptions_GetBackpressureModePtr) (LibMCEnv_DataCaptureOptions pDataCaptureOptions, LibMCEnv::eDataCaptureBackpressureMode * pBackpressureMode);
+
+/**
+* Sets the retention limit for all data capture segments stored on this machine. When it is exceeded after a segment has been finalized, the oldest stored segments are deleted first. Default is 0.
+*
+* @param[in] pDataCaptureOptions - DataCaptureOptions instance.
+* @param[in] nStorageLimitInBytes - Total size limit in bytes. 0 disables retention.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataCaptureOptions_SetStorageLimitInBytesPtr) (LibMCEnv_DataCaptureOptions pDataCaptureOptions, LibMCEnv_uint64 nStorageLimitInBytes);
+
+/**
+* Returns the retention limit for all data capture segments stored on this machine.
+*
+* @param[in] pDataCaptureOptions - DataCaptureOptions instance.
+* @param[out] pStorageLimitInBytes - Total size limit in bytes. 0 means retention is disabled.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataCaptureOptions_GetStorageLimitInBytesPtr) (LibMCEnv_DataCaptureOptions pDataCaptureOptions, LibMCEnv_uint64 * pStorageLimitInBytes);
+
+/**
+* Sets the codec the pages of the capture are compressed with. Default is LZ4. A page is stored uncompressed if the codec does not make it smaller.
+*
+* @param[in] pDataCaptureOptions - DataCaptureOptions instance.
+* @param[in] eCompression - None, LZ4 or Deflate. Deflate is meant for cold data, it costs considerably more processing time than LZ4.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataCaptureOptions_SetCompressionPtr) (LibMCEnv_DataCaptureOptions pDataCaptureOptions, LibMCEnv::eDataCaptureCompression eCompression);
+
+/**
+* Returns the codec the pages of the capture are compressed with.
+*
+* @param[in] pDataCaptureOptions - DataCaptureOptions instance.
+* @param[out] pCompression - Compression codec.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataCaptureOptions_GetCompressionPtr) (LibMCEnv_DataCaptureOptions pDataCaptureOptions, LibMCEnv::eDataCaptureCompression * pCompression);
+
+/**
+* Sets the encoding of a column. Default is Automatic, which uses Delta for integer and timestamp columns, BitPack for bool columns and Plain for float and double columns. The column MUST exist when the capture starts recording and the encoding MUST fit its type.
+*
+* @param[in] pDataCaptureOptions - DataCaptureOptions instance.
+* @param[in] pColumnIdentifier - Identifier of the column.
+* @param[in] eEncoding - Automatic, Plain, Delta or BitPack.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataCaptureOptions_SetColumnEncodingPtr) (LibMCEnv_DataCaptureOptions pDataCaptureOptions, const char * pColumnIdentifier, LibMCEnv::eDataCaptureEncoding eEncoding);
+
+/**
+* Opts a double column into lossy storage: values are stored as integer multiples of the step with Delta encoding. Columns that are not quantised stay bit-exact. The step is recorded in the capture and the column MUST be a double column.
+*
+* @param[in] pDataCaptureOptions - DataCaptureOptions instance.
+* @param[in] pColumnIdentifier - Identifier of the column.
+* @param[in] dStep - Quantisation step. MUST be positive. 0 removes the quantisation.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataCaptureOptions_SetDoubleQuantizationPtr) (LibMCEnv_DataCaptureOptions pDataCaptureOptions, const char * pColumnIdentifier, LibMCEnv_double dStep);
+
+/*************************************************************************************************************************
+ Class definition for DataCaptureChunk
+**************************************************************************************************************************/
+
+/**
+* Returns the number of rows the chunk can hold.
+*
+* @param[in] pDataCaptureChunk - DataCaptureChunk instance.
+* @param[out] pCapacity - Number of rows.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataCaptureChunk_GetCapacityPtr) (LibMCEnv_DataCaptureChunk pDataCaptureChunk, LibMCEnv_uint32 * pCapacity);
+
+/**
+* Returns the number of rows in the chunk. This is the row count of the longest column.
+*
+* @param[in] pDataCaptureChunk - DataCaptureChunk instance.
+* @param[out] pRowCount - Number of rows.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataCaptureChunk_GetRowCountPtr) (LibMCEnv_DataCaptureChunk pDataCaptureChunk, LibMCEnv_uint32 * pRowCount);
+
+/**
+* Returns if the chunk has reached its capacity.
+*
+* @param[in] pDataCaptureChunk - DataCaptureChunk instance.
+* @param[out] pFull - Returns true if no more rows fit into the chunk.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataCaptureChunk_IsFullPtr) (LibMCEnv_DataCaptureChunk pDataCaptureChunk, bool * pFull);
+
+/**
+* Sets all rows of a double column in this chunk. Fails if the column type does not match or the capacity is exceeded.
+*
+* @param[in] pDataCaptureChunk - DataCaptureChunk instance.
+* @param[in] nColumnIndex - Index of the column. 0-based.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[in] pValuesBuffer - double buffer of Values of the column. All columns of a chunk MUST have the same length on commit.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataCaptureChunk_SetDoubleColumnValuesPtr) (LibMCEnv_DataCaptureChunk pDataCaptureChunk, LibMCEnv_uint32 nColumnIndex, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_double * pValuesBuffer);
+
+/**
+* Sets all rows of an int32 column in this chunk. Fails if the column type does not match or the capacity is exceeded.
+*
+* @param[in] pDataCaptureChunk - DataCaptureChunk instance.
+* @param[in] nColumnIndex - Index of the column. 0-based.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[in] pValuesBuffer - int32 buffer of Values of the column. All columns of a chunk MUST have the same length on commit.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataCaptureChunk_SetInt32ColumnValuesPtr) (LibMCEnv_DataCaptureChunk pDataCaptureChunk, LibMCEnv_uint32 nColumnIndex, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_int32 * pValuesBuffer);
+
+/**
+* Sets all rows of an uint32 column in this chunk. Fails if the column type does not match or the capacity is exceeded.
+*
+* @param[in] pDataCaptureChunk - DataCaptureChunk instance.
+* @param[in] nColumnIndex - Index of the column. 0-based.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[in] pValuesBuffer - uint32 buffer of Values of the column. All columns of a chunk MUST have the same length on commit.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataCaptureChunk_SetUint32ColumnValuesPtr) (LibMCEnv_DataCaptureChunk pDataCaptureChunk, LibMCEnv_uint32 nColumnIndex, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint32 * pValuesBuffer);
+
+/**
+* Sets all rows of an int64 column in this chunk. Fails if the column type does not match or the capacity is exceeded.
+*
+* @param[in] pDataCaptureChunk - DataCaptureChunk instance.
+* @param[in] nColumnIndex - Index of the column. 0-based.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[in] pValuesBuffer - int64 buffer of Values of the column. All columns of a chunk MUST have the same length on commit.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataCaptureChunk_SetInt64ColumnValuesPtr) (LibMCEnv_DataCaptureChunk pDataCaptureChunk, LibMCEnv_uint32 nColumnIndex, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_int64 * pValuesBuffer);
+
+/**
+* Sets all rows of an uint64 column in this chunk. Fails if the column type does not match or the capacity is exceeded.
+*
+* @param[in] pDataCaptureChunk - DataCaptureChunk instance.
+* @param[in] nColumnIndex - Index of the column. 0-based.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[in] pValuesBuffer - uint64 buffer of Values of the column. All columns of a chunk MUST have the same length on commit.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataCaptureChunk_SetUint64ColumnValuesPtr) (LibMCEnv_DataCaptureChunk pDataCaptureChunk, LibMCEnv_uint32 nColumnIndex, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint64 * pValuesBuffer);
+
+/**
+* Sets all rows of a float (32 bit) column in this chunk. Fails if the column type does not match or the capacity is exceeded.
+*
+* @param[in] pDataCaptureChunk - DataCaptureChunk instance.
+* @param[in] nColumnIndex - Index of the column. 0-based.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[in] pValuesBuffer - single buffer of Values of the column. All columns of a chunk MUST have the same length on commit.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataCaptureChunk_SetFloatColumnValuesPtr) (LibMCEnv_DataCaptureChunk pDataCaptureChunk, LibMCEnv_uint32 nColumnIndex, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_single * pValuesBuffer);
+
+/**
+* Sets all rows of a bool column in this chunk from bytes (0 = false, nonzero = true). Fails if the column type does not match or the capacity is exceeded.
+*
+* @param[in] pDataCaptureChunk - DataCaptureChunk instance.
+* @param[in] nColumnIndex - Index of the column. 0-based.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[in] pValuesBuffer - uint8 buffer of Values of the column. All columns of a chunk MUST have the same length on commit.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataCaptureChunk_SetBoolColumnValuesPtr) (LibMCEnv_DataCaptureChunk pDataCaptureChunk, LibMCEnv_uint32 nColumnIndex, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint8 * pValuesBuffer);
+
+/**
+* Sets all rows of a timestamp column in this chunk in microseconds. Fails if the column type does not match or the capacity is exceeded.
+*
+* @param[in] pDataCaptureChunk - DataCaptureChunk instance.
+* @param[in] nColumnIndex - Index of the column. 0-based.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[in] pValuesBuffer - uint64 buffer of Values of the column. All columns of a chunk MUST have the same length on commit.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataCaptureChunk_SetTimestampColumnValuesPtr) (LibMCEnv_DataCaptureChunk pDataCaptureChunk, LibMCEnv_uint32 nColumnIndex, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint64 * pValuesBuffer);
+
+/**
+* Starts a new row at the end of the chunk. This is the convenience path for low-rate producers. Fails if the chunk is full, a row is open or the columns have different row counts.
+*
+* @param[in] pDataCaptureChunk - DataCaptureChunk instance.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataCaptureChunk_BeginRowPtr) (LibMCEnv_DataCaptureChunk pDataCaptureChunk);
+
+/**
+* Sets a value of the open row. The column MUST be of type double or float.
+*
+* @param[in] pDataCaptureChunk - DataCaptureChunk instance.
+* @param[in] nColumnIndex - Index of the column. 0-based.
+* @param[in] dValue - Value to set.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataCaptureChunk_SetRowDoubleValuePtr) (LibMCEnv_DataCaptureChunk pDataCaptureChunk, LibMCEnv_uint32 nColumnIndex, LibMCEnv_double dValue);
+
+/**
+* Sets a value of the open row. The column MUST be of an integer, bool or timestamp type and the value MUST be in its range.
+*
+* @param[in] pDataCaptureChunk - DataCaptureChunk instance.
+* @param[in] nColumnIndex - Index of the column. 0-based.
+* @param[in] nValue - Value to set.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataCaptureChunk_SetRowIntegerValuePtr) (LibMCEnv_DataCaptureChunk pDataCaptureChunk, LibMCEnv_uint32 nColumnIndex, LibMCEnv_int64 nValue);
+
+/**
+* Finishes the open row. Columns that have not been set in this row are zero.
+*
+* @param[in] pDataCaptureChunk - DataCaptureChunk instance.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataCaptureChunk_EndRowPtr) (LibMCEnv_DataCaptureChunk pDataCaptureChunk);
+
+/*************************************************************************************************************************
+ Class definition for DataCapture
+**************************************************************************************************************************/
+
+/**
+* Returns the UUID of the capture.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[in] nUUIDBufferSize - size of the buffer (including trailing 0)
+* @param[out] pUUIDNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pUUIDBuffer -  buffer of UUID of the capture., may be NULL
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataCapture_GetUUIDPtr) (LibMCEnv_DataCapture pDataCapture, const LibMCEnv_uint32 nUUIDBufferSize, LibMCEnv_uint32* pUUIDNeededChars, char * pUUIDBuffer);
+
+/**
+* Returns the identifier of the capture. It is unique within the build execution.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[in] nIdentifierBufferSize - size of the buffer (including trailing 0)
+* @param[out] pIdentifierNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pIdentifierBuffer -  buffer of Identifier of the capture., may be NULL
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataCapture_GetIdentifierPtr) (LibMCEnv_DataCapture pDataCapture, const LibMCEnv_uint32 nIdentifierBufferSize, LibMCEnv_uint32* pIdentifierNeededChars, char * pIdentifierBuffer);
+
+/**
+* Returns the human readable name of the capture.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[in] nNameBufferSize - size of the buffer (including trailing 0)
+* @param[out] pNameNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pNameBuffer -  buffer of Name of the capture., may be NULL
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataCapture_GetNamePtr) (LibMCEnv_DataCapture pDataCapture, const LibMCEnv_uint32 nNameBufferSize, LibMCEnv_uint32* pNameNeededChars, char * pNameBuffer);
+
+/**
+* Returns the status of the capture.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[out] pStatus - Status of the capture.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataCapture_GetStatusPtr) (LibMCEnv_DataCapture pDataCapture, LibMCEnv::eDataCaptureStatus * pStatus);
+
+/**
+* Adds a column to the capture. The schema is frozen with the first call to BeginChunk.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[in] pIdentifier - Identifier of the column. MUST be unique, alphanumeric and not empty.
+* @param[in] pDescription - Description of the column.
+* @param[in] eColumnType - Data type of the column.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataCapture_AddColumnPtr) (LibMCEnv_DataCapture pDataCapture, const char * pIdentifier, const char * pDescription, LibMCEnv::eDataTableColumnType eColumnType);
+
+/**
+* Returns the number of columns of the capture.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[out] pColumnCount - Number of columns.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataCapture_GetColumnCountPtr) (LibMCEnv_DataCapture pDataCapture, LibMCEnv_uint32 * pColumnCount);
+
+/**
+* Borrows an empty chunk from the chunk pool. Freezes the schema on the first call. If no chunk is free, the backpressure mode of the capture applies.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[out] pChunkInstance - Chunk to fill.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataCapture_BeginChunkPtr) (LibMCEnv_DataCapture pDataCapture, LibMCEnv_DataCaptureChunk * pChunkInstance);
+
+/**
+* Hands a filled chunk over to the writer thread and returns immediately. All columns MUST have the same row count. The chunk instance MUST NOT be used afterwards.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[in] pChunkInstance - Chunk that has been returned by BeginChunk.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataCapture_CommitChunkPtr) (LibMCEnv_DataCapture pDataCapture, LibMCEnv_DataCaptureChunk pChunkInstance);
+
+/**
+* Blocks until all committed chunks have been written to storage.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataCapture_FlushPtr) (LibMCEnv_DataCapture pDataCapture);
+
+/**
+* Returns the number of rows that have been committed and not dropped.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[out] pRowCount - Number of rows.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataCapture_GetCapturedRowCountPtr) (LibMCEnv_DataCapture pDataCapture, LibMCEnv_uint64 * pRowCount);
+
+/**
+* Returns the number of bytes that have been written to storage so far.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[out] pSizeInBytes - Size in bytes.
 * @return error code or 0 (success)
 */
-typedef LibMCEnvResult (*PLibMCEnvDataTable_GetColumnCountPtr) (LibMCEnv_DataTable pDataTable, LibMCEnv_uint32 * pColumnCount);
+typedef LibMCEnvResult (*PLibMCEnvDataCapture_GetStorageSizeInBytesPtr) (LibMCEnv_DataCapture pDataCapture, LibMCEnv_uint64 * pSizeInBytes);
 
 /**
-* Returns the identifier of a column. Will fail if Index is out of bounds.
+* Returns the number of segment streams that have been opened so far.
 *
-* @param[in] pDataTable - DataTable instance.
-* @param[in] nColumnIndex - Index of column. 0-based.
-* @param[in] nIdentifierBufferSize - size of the buffer (including trailing 0)
-* @param[out] pIdentifierNeededChars - will be filled with the count of the written bytes, or needed buffer size.
-* @param[out] pIdentifierBuffer -  buffer of Identifier of the column., may be NULL
+* @param[in] pDataCapture - DataCapture instance.
+* @param[out] pSegmentCount - Number of segments.
 * @return error code or 0 (success)
 */
-typedef LibMCEnvResult (*PLibMCEnvDataTable_GetColumnIdentifierPtr) (LibMCEnv_DataTable pDataTable, LibMCEnv_uint32 nColumnIndex, const LibMCEnv_uint32 nIdentifierBufferSize, LibMCEnv_uint32* pIdentifierNeededChars, char * pIdentifierBuffer);
+typedef LibMCEnvResult (*PLibMCEnvDataCapture_GetSegmentCountPtr) (LibMCEnv_DataCapture pDataCapture, LibMCEnv_uint32 * pSegmentCount);
 
 /**
-* Returns the description of a column. Will fail if Index is out of bounds.
+* Returns the number of committed chunks that are waiting for the writer thread.
 *
-* @param[in] pDataTable - DataTable instance.
-* @param[in] nColumnIndex - Index of column. 0-based.
-* @param[in] nDescriptionBufferSize - size of the buffer (including trailing 0)
-* @param[out] pDescriptionNeededChars - will be filled with the count of the written bytes, or needed buffer size.
-* @param[out] pDescriptionBuffer -  buffer of Description of the column., may be NULL
+* @param[in] pDataCapture - DataCapture instance.
+* @param[out] pQueuedChunkCount - Number of queued chunks.
 * @return error code or 0 (success)
 */
-typedef LibMCEnvResult (*PLibMCEnvDataTable_GetColumnDescriptionPtr) (LibMCEnv_DataTable pDataTable, LibMCEnv_uint32 nColumnIndex, const LibMCEnv_uint32 nDescriptionBufferSize, LibMCEnv_uint32* pDescriptionNeededChars, char * pDescriptionBuffer);
+typedef LibMCEnvResult (*PLibMCEnvDataCapture_GetQueuedChunkCountPtr) (LibMCEnv_DataCapture pDataCapture, LibMCEnv_uint32 * pQueuedChunkCount);
 
 /**
-* Returns the type of a column. Will fail if Index is out of bounds.
+* Returns the number of rows that have been discarded by the DropOldest backpressure mode.
 *
-* @param[in] pDataTable - DataTable instance.
-* @param[in] nColumnIndex - Index of column. 0-based.
-* @param[out] pColumnType - Data type of the column.
+* @param[in] pDataCapture - DataCapture instance.
+* @param[out] pDroppedRowCount - Number of dropped rows.
 * @return error code or 0 (success)
 */
-typedef LibMCEnvResult (*PLibMCEnvDataTable_GetColumnTypePtr) (LibMCEnv_DataTable pDataTable, LibMCEnv_uint32 nColumnIndex, LibMCEnv::eDataTableColumnType * pColumnType);
+typedef LibMCEnvResult (*PLibMCEnvDataCapture_GetDroppedRowCountPtr) (LibMCEnv_DataCapture pDataCapture, LibMCEnv_uint64 * pDroppedRowCount);
 
 /**
-* Returns the values of a double column. Will fail if column does not exist or type is not double.
+* Writes all committed chunks, closes the last segment and marks the capture as finished. Fails if a chunk is uncommitted.
 *
-* @param[in] pDataTable - DataTable instance.
-* @param[in] pIdentifier - Identifier of the column.
-* @param[in] nDescriptionBufferSize - size of the buffer (including trailing 0)
-* @param[out] pDescriptionNeededChars - will be filled with the count of the written bytes, or needed buffer size.
-* @param[out] pDescriptionBuffer -  buffer of Description of the column., may be NULL
-* @param[out] pColumnType - Data type of the column.
+* @param[in] pDataCapture - DataCapture instance.
+* @param[in] nCaptureUUIDBufferSize - size of the buffer (including trailing 0)
+* @param[out] pCaptureUUIDNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pCaptureUUIDBuffer -  buffer of UUID of the capture., may be NULL
 * @return error code or 0 (success)
 */
-typedef LibMCEnvResult (*PLibMCEnvDataTable_GetColumnInformationPtr) (LibMCEnv_DataTable pDataTable, const char * pIdentifier, const LibMCEnv_uint32 nDescriptionBufferSize, LibMCEnv_uint32* pDescriptionNeededChars, char * pDescriptionBuffer, LibMCEnv::eDataTableColumnType * pColumnType);
+typedef LibMCEnvResult (*PLibMCEnvDataCapture_FinishPtr) (LibMCEnv_DataCapture pDataCapture, const LibMCEnv_uint32 nCaptureUUIDBufferSize, LibMCEnv_uint32* pCaptureUUIDNeededChars, char * pCaptureUUIDBuffer);
 
 /**
-* Returns the values of a double column. Will fail if column does not exist or type is not double.
+* Stops the capture and deletes all its segments.
 *
-* @param[in] pDataTable - DataTable instance.
-* @param[in] pIdentifier - Identifier of the column.
-* @param[in] nValuesBufferSize - Number of elements in buffer
-* @param[out] pValuesNeededCount - will be filled with the count of the written elements, or needed buffer size.
-* @param[out] pValuesBuffer - double  buffer of Value array of a column.
+* @param[in] pDataCapture - DataCapture instance.
 * @return error code or 0 (success)
 */
-typedef LibMCEnvResult (*PLibMCEnvDataTable_GetDoubleColumnValuesPtr) (LibMCEnv_DataTable pDataTable, const char * pIdentifier, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_double * pValuesBuffer);
+typedef LibMCEnvResult (*PLibMCEnvDataCapture_AbortPtr) (LibMCEnv_DataCapture pDataCapture);
 
 /**
-* Returns the double columns. Will fail if column does not exist or type is not int32.
+* Adds one column to the capture for every column of a data table, with the same identifier, description and type and in the same order. Fails if the schema is frozen or an identifier already exists.
 *
-* @param[in] pDataTable - DataTable instance.
-* @param[in] pIdentifier - Identifier of the column.
-* @param[in] nValuesBufferSize - Number of elements in buffer
-* @param[out] pValuesNeededCount - will be filled with the count of the written elements, or needed buffer size.
-* @param[out] pValuesBuffer - int32  buffer of Value array of a column.
+* @param[in] pDataCapture - DataCapture instance.
+* @param[in] pDataTable - Data table whose columns describe the schema. Its rows are not read.
 * @return error code or 0 (success)
 */
-typedef LibMCEnvResult (*PLibMCEnvDataTable_GetInt32ColumnValuesPtr) (LibMCEnv_DataTable pDataTable, const char * pIdentifier, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_int32 * pValuesBuffer);
+typedef LibMCEnvResult (*PLibMCEnvDataCapture_AddColumnsFromDataTablePtr) (LibMCEnv_DataCapture pDataCapture, LibMCEnv_DataTable pDataTable);
 
 /**
-* Returns the double columns. Will fail if column does not exist or type is not int64.
+* Appends all rows of a data table to the capture and splits them into chunks. Every column of the capture MUST exist in the table with the same identifier and type, and these columns MUST have the same row count. Further columns of the table are ignored. Freezes the schema on the first call. If no chunk is free, the backpressure mode of the capture applies. Fails if a chunk is uncommitted.
 *
-* @param[in] pDataTable - DataTable instance.
-* @param[in] pIdentifier - Identifier of the column.
-* @param[in] nValuesBufferSize - Number of elements in buffer
-* @param[out] pValuesNeededCount - will be filled with the count of the written elements, or needed buffer size.
-* @param[out] pValuesBuffer - int64  buffer of Value array of a column.
+* @param[in] pDataCapture - DataCapture instance.
+* @param[in] pDataTable - Data table that holds the rows to append.
+* @param[out] pRowCount - Number of rows that have been appended.
 * @return error code or 0 (success)
 */
-typedef LibMCEnvResult (*PLibMCEnvDataTable_GetInt64ColumnValuesPtr) (LibMCEnv_DataTable pDataTable, const char * pIdentifier, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_int64 * pValuesBuffer);
+typedef LibMCEnvResult (*PLibMCEnvDataCapture_AppendDataTablePtr) (LibMCEnv_DataCapture pDataCapture, LibMCEnv_DataTable pDataTable, LibMCEnv_uint64 * pRowCount);
+
+/*************************************************************************************************************************
+ Class definition for DataTableReader
+**************************************************************************************************************************/
 
 /**
-* Returns the double columns. Will fail if column does not exist or type is not uint32.
+* Returns the number of rows of the capture, including rows in segments that have been deleted by retention.
 *
-* @param[in] pDataTable - DataTable instance.
-* @param[in] pIdentifier - Identifier of the column.
-* @param[in] nValuesBufferSize - Number of elements in buffer
-* @param[out] pValuesNeededCount - will be filled with the count of the written elements, or needed buffer size.
-* @param[out] pValuesBuffer - uint32  buffer of Value array of a column.
+* @param[in] pDataTableReader - DataTableReader instance.
+* @param[out] pRowCount - Number of rows.
 * @return error code or 0 (success)
 */
-typedef LibMCEnvResult (*PLibMCEnvDataTable_GetUint32ColumnValuesPtr) (LibMCEnv_DataTable pDataTable, const char * pIdentifier, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_uint32 * pValuesBuffer);
+typedef LibMCEnvResult (*PLibMCEnvDataTableReader_GetRowCountPtr) (LibMCEnv_DataTableReader pDataTableReader, LibMCEnv_uint64 * pRowCount);
 
 /**
-* Returns the double columns. Will fail if column does not exist or type is not uint64.
+* Returns the index of the first row that is still stored. Rows before it have been deleted by retention.
 *
-* @param[in] pDataTable - DataTable instance.
-* @param[in] pIdentifier - Identifier of the column.
-* @param[in] nValuesBufferSize - Number of elements in buffer
-* @param[out] pValuesNeededCount - will be filled with the count of the written elements, or needed buffer size.
-* @param[out] pValuesBuffer - uint64  buffer of Value array of a column.
+* @param[in] pDataTableReader - DataTableReader instance.
+* @param[out] pFirstAvailableRow - Row index. Equal to the row count if nothing is stored.
 * @return error code or 0 (success)
 */
-typedef LibMCEnvResult (*PLibMCEnvDataTable_GetUint64ColumnValuesPtr) (LibMCEnv_DataTable pDataTable, const char * pIdentifier, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_uint64 * pValuesBuffer);
+typedef LibMCEnvResult (*PLibMCEnvDataTableReader_GetFirstAvailableRowPtr) (LibMCEnv_DataTableReader pDataTableReader, LibMCEnv_uint64 * pFirstAvailableRow);
 
 /**
-* Sets the values of a double column. Will fail if column does not exist or type is not double.
+* Returns the number of columns.
 *
-* @param[in] pDataTable - DataTable instance.
-* @param[in] pIdentifier - Identifier of the column.
-* @param[in] nValuesBufferSize - Number of elements in buffer
-* @param[in] pValuesBuffer - double buffer of New Value array of a column. Array length should match RowCount. Values will be filled up with 0, if length is less than RowCount. RowCount will be extended if length is larger than RowCount.
+* @param[in] pDataTableReader - DataTableReader instance.
+* @param[out] pColumnCount - Number of columns.
 * @return error code or 0 (success)
 */
-typedef LibMCEnvResult (*PLibMCEnvDataTable_SetDoubleColumnValuesPtr) (LibMCEnv_DataTable pDataTable, const char * pIdentifier, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_double * pValuesBuffer);
+typedef LibMCEnvResult (*PLibMCEnvDataTableReader_GetColumnCountPtr) (LibMCEnv_DataTableReader pDataTableReader, LibMCEnv_uint32 * pColumnCount);
 
 /**
-* Sets the double columns. Will fail if column does not exist or type is not int32.
+* Returns if a column exists.
 *
-* @param[in] pDataTable - DataTable instance.
+* @param[in] pDataTableReader - DataTableReader instance.
 * @param[in] pIdentifier - Identifier of the column.
-* @param[in] nValuesBufferSize - Number of elements in buffer
-* @param[in] pValuesBuffer - int32 buffer of New Value array of a column. Array length should match RowCount. Values will be filled up with 0, if length is less than RowCount. RowCount will be extended if length is larger than RowCount.
+* @param[out] pColumnExists - Returns if the column exists.
 * @return error code or 0 (success)
 */
-typedef LibMCEnvResult (*PLibMCEnvDataTable_SetInt32ColumnValuesPtr) (LibMCEnv_DataTable pDataTable, const char * pIdentifier, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_int32 * pValuesBuffer);
+typedef LibMCEnvResult (*PLibMCEnvDataTableReader_HasColumnPtr) (LibMCEnv_DataTableReader pDataTableReader, const char * pIdentifier, bool * pColumnExists);
 
 /**
-* Sets the double columns. Will fail if column does not exist or type is not int64.
+* Returns the schema information of a column. Fails if the index is out of bounds.
 *
-* @param[in] pDataTable - DataTable instance.
-* @param[in] pIdentifier - Identifier of the column.
-* @param[in] nValuesBufferSize - Number of elements in buffer
-* @param[in] pValuesBuffer - int64 buffer of New Value array of a column. Array length should match RowCount. Values will be filled up with 0, if length is less than RowCount. RowCount will be extended if length is larger than RowCount.
+* @param[in] pDataTableReader - DataTableReader instance.
+* @param[in] nColumnIndex - Index of column. 0-based.
+* @param[in] nIdentifierBufferSize - size of the buffer (including trailing 0)
+* @param[out] pIdentifierNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pIdentifierBuffer -  buffer of Identifier of the column., may be NULL
+* @param[in] nDescriptionBufferSize - size of the buffer (including trailing 0)
+* @param[out] pDescriptionNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pDescriptionBuffer -  buffer of Description of the column., may be NULL
+* @param[out] pColumnType - Data type of the column.
 * @return error code or 0 (success)
 */
-typedef LibMCEnvResult (*PLibMCEnvDataTable_SetInt64ColumnValuesPtr) (LibMCEnv_DataTable pDataTable, const char * pIdentifier, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_int64 * pValuesBuffer);
+typedef LibMCEnvResult (*PLibMCEnvDataTableReader_GetColumnInformationPtr) (LibMCEnv_DataTableReader pDataTableReader, LibMCEnv_uint32 nColumnIndex, const LibMCEnv_uint32 nIdentifierBufferSize, LibMCEnv_uint32* pIdentifierNeededChars, char * pIdentifierBuffer, const LibMCEnv_uint32 nDescriptionBufferSize, LibMCEnv_uint32* pDescriptionNeededChars, char * pDescriptionBuffer, LibMCEnv::eDataTableColumnType * pColumnType);
 
 /**
-* Sets the double columns. Will fail if column does not exist or type is not uint32.
+* Returns the quantisation step of a column. Values of a quantised column are exact to half a step.
 *
-* @param[in] pDataTable - DataTable instance.
+* @param[in] pDataTableReader - DataTableReader instance.
 * @param[in] pIdentifier - Identifier of the column.
-* @param[in] nValuesBufferSize - Number of elements in buffer
-* @param[in] pValuesBuffer - uint32 buffer of New Value array of a column. Array length should match RowCount. Values will be filled up with 0, if length is less than RowCount. RowCount will be extended if length is larger than RowCount.
+* @param[out] pStep - Quantisation step. 0 if the column is not quantised.
 * @return error code or 0 (success)
 */
-typedef LibMCEnvResult (*PLibMCEnvDataTable_SetUint32ColumnValuesPtr) (LibMCEnv_DataTable pDataTable, const char * pIdentifier, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint32 * pValuesBuffer);
+typedef LibMCEnvResult (*PLibMCEnvDataTableReader_GetColumnQuantizationPtr) (LibMCEnv_DataTableReader pDataTableReader, const char * pIdentifier, LibMCEnv_double * pStep);
 
 /**
-* Sets the double columns. Will fail if column does not exist or type is not uint64.
+* Returns the number of segments of the capture, including deleted ones.
 *
-* @param[in] pDataTable - DataTable instance.
+* @param[in] pDataTableReader - DataTableReader instance.
+* @param[out] pSegmentCount - Number of segments.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataTableReader_GetSegmentCountPtr) (LibMCEnv_DataTableReader pDataTableReader, LibMCEnv_uint32 * pSegmentCount);
+
+/**
+* Returns the row range and the size of a segment. Fails if the index is out of bounds.
+*
+* @param[in] pDataTableReader - DataTableReader instance.
+* @param[in] nSegmentIndex - Index of the segment. 0-based.
+* @param[out] pFirstRow - Index of the first row of the segment.
+* @param[out] pRowCount - Number of rows in the segment.
+* @param[out] pSizeInBytes - Size of the segment stream in bytes.
+* @param[out] pIsAvailable - Returns false if the segment has been deleted by retention.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataTableReader_GetSegmentInformationPtr) (LibMCEnv_DataTableReader pDataTableReader, LibMCEnv_uint32 nSegmentIndex, LibMCEnv_uint64 * pFirstRow, LibMCEnv_uint64 * pRowCount, LibMCEnv_uint64 * pSizeInBytes, bool * pIsAvailable);
+
+/**
+* Returns the number of chunks of the capture, including chunks in deleted segments.
+*
+* @param[in] pDataTableReader - DataTableReader instance.
+* @param[out] pChunkCount - Number of chunks.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataTableReader_GetChunkCountPtr) (LibMCEnv_DataTableReader pDataTableReader, LibMCEnv_uint64 * pChunkCount);
+
+/**
+* Returns the position of a chunk. Fails if the index is out of bounds.
+*
+* @param[in] pDataTableReader - DataTableReader instance.
+* @param[in] nChunkIndex - Index of the chunk. 0-based.
+* @param[out] pSegmentIndex - Index of the segment that holds the chunk.
+* @param[out] pFirstRow - Index of the first row of the chunk. For a chunk in a deleted segment this is the first row of the segment.
+* @param[out] pRowCount - Number of rows in the chunk. 0 for a chunk in a deleted segment.
+* @param[out] pIsAvailable - Returns false if the chunk has been deleted by retention.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvDataTableReader_GetChunkInformationPtr) (LibMCEnv_DataTableReader pDataTableReader, LibMCEnv_uint64 nChunkIndex, LibMCEnv_uint32 * pSegmentIndex, LibMCEnv_uint64 * pFirstRow, LibMCEnv_uint64 * pRowCount, bool * pIsAvailable);
+
+/**
+* Returns the minimum and maximum of a column in a chunk from the page directory, without reading the chunk.
+*
+* @param[in] pDataTableReader - DataTableReader instance.
+* @param[in] nChunkIndex - Index of the chunk. 0-based.
 * @param[in] pIdentifier - Identifier of the column.
-* @param[in] nValuesBufferSize - Number of elements in buffer
-* @param[in] pValuesBuffer - uint64 buffer of New Value array of a column. Array length should match RowCount. Values will be filled up with 0, if length is less than RowCount. RowCount will be extended if length is larger than RowCount.
+* @param[out] pMinValue - Minimum value of the column in the chunk.
+* @param[out] pMaxValue - Maximum value of the column in the chunk.
+* @param[out] pHasStatistics - Returns false if the chunk has been deleted or holds no comparable value.
 * @return error code or 0 (success)
 */
-typedef LibMCEnvResult (*PLibMCEnvDataTable_SetUint64ColumnValuesPtr) (LibMCEnv_DataTable pDataTable, const char * pIdentifier, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint64 * pValuesBuffer);
+typedef LibMCEnvResult (*PLibMCEnvDataTableReader_GetChunkStatisticsPtr) (LibMCEnv_DataTableReader pDataTableReader, LibMCEnv_uint64 nChunkIndex, const char * pIdentifier, LibMCEnv_double * pMinValue, LibMCEnv_double * pMaxValue, bool * pHasStatistics);
 
 /**
-* Creates a Write Option.
+* Reads a row range of a column as doubles. Works for every column type. Only the pages that overlap the range are read.
 *
-* @param[in] pDataTable - DataTable instance.
-* @param[out] pOptions - Writer Options Instance to pass on to WriteDataToStream.
+* @param[in] pDataTableReader - DataTableReader instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nFromRow - Index of the first row to read.
+* @param[in] nRowCount - Number of rows to read.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[out] pValuesNeededCount - will be filled with the count of the written elements, or needed buffer size.
+* @param[out] pValuesBuffer - double  buffer of Values of the row range.
 * @return error code or 0 (success)
 */
-typedef LibMCEnvResult (*PLibMCEnvDataTable_CreateWriteOptionsPtr) (LibMCEnv_DataTable pDataTable, LibMCEnv_DataTableWriteOptions * pOptions);
+typedef LibMCEnvResult (*PLibMCEnvDataTableReader_ReadDoubleColumnRangePtr) (LibMCEnv_DataTableReader pDataTableReader, const char * pIdentifier, LibMCEnv_uint64 nFromRow, LibMCEnv_uint64 nRowCount, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_double * pValuesBuffer);
 
 /**
-* Creates a CSV Write Option.
+* Reads a row range of a float or double column as floats.
 *
-* @param[in] pDataTable - DataTable instance.
-* @param[out] pOptions - Writer Options Instance to pass on to WriteCSVToStream.
+* @param[in] pDataTableReader - DataTableReader instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nFromRow - Index of the first row to read.
+* @param[in] nRowCount - Number of rows to read.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[out] pValuesNeededCount - will be filled with the count of the written elements, or needed buffer size.
+* @param[out] pValuesBuffer - single  buffer of Values of the row range.
 * @return error code or 0 (success)
 */
-typedef LibMCEnvResult (*PLibMCEnvDataTable_CreateCSVWriteOptionsPtr) (LibMCEnv_DataTable pDataTable, LibMCEnv_DataTableCSVWriteOptions * pOptions);
+typedef LibMCEnvResult (*PLibMCEnvDataTableReader_ReadFloatColumnRangePtr) (LibMCEnv_DataTableReader pDataTableReader, const char * pIdentifier, LibMCEnv_uint64 nFromRow, LibMCEnv_uint64 nRowCount, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_single * pValuesBuffer);
 
 /**
-* Writes the data as CSV to a temporary stream.
+* Reads a row range of an integer, bool or timestamp column as 64 bit integers.
 *
-* @param[in] pDataTable - DataTable instance.
-* @param[in] pWriter - Stream writer to use.
-* @param[in] pOptions - Optional CSV writer options to use.
+* @param[in] pDataTableReader - DataTableReader instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nFromRow - Index of the first row to read.
+* @param[in] nRowCount - Number of rows to read.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[out] pValuesNeededCount - will be filled with the count of the written elements, or needed buffer size.
+* @param[out] pValuesBuffer - int64  buffer of Values of the row range.
 * @return error code or 0 (success)
 */
-typedef LibMCEnvResult (*PLibMCEnvDataTable_WriteCSVToStreamPtr) (LibMCEnv_DataTable pDataTable, LibMCEnv_TempStreamWriter pWriter, LibMCEnv_DataTableCSVWriteOptions pOptions);
+typedef LibMCEnvResult (*PLibMCEnvDataTableReader_ReadInt64ColumnRangePtr) (LibMCEnv_DataTableReader pDataTableReader, const char * pIdentifier, LibMCEnv_uint64 nFromRow, LibMCEnv_uint64 nRowCount, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_int64 * pValuesBuffer);
 
 /**
-* Writes the data as binary to a temporary stream.
+* Reads a row range of a bool column as bytes (0 = false, 1 = true).
 *
-* @param[in] pDataTable - DataTable instance.
-* @param[in] pWriter - Stream writer instance to use.
-* @param[in] pOptions - Optional writer options to use.
+* @param[in] pDataTableReader - DataTableReader instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nFromRow - Index of the first row to read.
+* @param[in] nRowCount - Number of rows to read.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[out] pValuesNeededCount - will be filled with the count of the written elements, or needed buffer size.
+* @param[out] pValuesBuffer - uint8  buffer of Values of the row range.
 * @return error code or 0 (success)
 */
-typedef LibMCEnvResult (*PLibMCEnvDataTable_WriteDataToStreamPtr) (LibMCEnv_DataTable pDataTable, LibMCEnv_TempStreamWriter pWriter, LibMCEnv_DataTableWriteOptions pOptions);
+typedef LibMCEnvResult (*PLibMCEnvDataTableReader_ReadBoolColumnRangePtr) (LibMCEnv_DataTableReader pDataTableReader, const char * pIdentifier, LibMCEnv_uint64 nFromRow, LibMCEnv_uint64 nRowCount, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_uint8 * pValuesBuffer);
 
 /**
-* Loads the data table from a stream. Clears all existing data from the data table.
+* Reduces a row range of a column to at most TargetPoints buckets without materialising the range. Stride returns the first value of each bucket, Average the mean and MinMax the minimum followed by the maximum of each bucket, which preserves the envelope of the signal.
 *
-* @param[in] pDataTable - DataTable instance.
-* @param[in] pStream - Stream read instance to read from.
+* @param[in] pDataTableReader - DataTableReader instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nFromRow - Index of the first row of the range.
+* @param[in] nRowCount - Number of rows of the range.
+* @param[in] nTargetPoints - Maximum number of buckets. MUST be positive.
+* @param[in] eMode - Stride, MinMax or Average.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[out] pValuesNeededCount - will be filled with the count of the written elements, or needed buffer size.
+* @param[out] pValuesBuffer - double  buffer of One value per bucket, or two values per bucket in MinMax mode. The number of buckets is the smaller of TargetPoints and RowCount.
 * @return error code or 0 (success)
 */
-typedef LibMCEnvResult (*PLibMCEnvDataTable_LoadFromStreamPtr) (LibMCEnv_DataTable pDataTable, LibMCEnv_StreamReader pStream);
+typedef LibMCEnvResult (*PLibMCEnvDataTableReader_ReadColumnDownsampledPtr) (LibMCEnv_DataTableReader pDataTableReader, const char * pIdentifier, LibMCEnv_uint64 nFromRow, LibMCEnv_uint64 nRowCount, LibMCEnv_uint32 nTargetPoints, LibMCEnv::eDataTableDownsampleMode eMode, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_double * pValuesBuffer);
 
 /**
-* Creates an options object for scatter plot computation.
+* Finds the chunks whose value range of a column overlaps a given range. Only the page directory is used, no chunk is read.
 *
-* @param[in] pDataTable - DataTable instance.
-* @param[out] pScatterPlotOptions - DataTableScatterPlotOptions Instance
+* @param[in] pDataTableReader - DataTableReader instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] dMinValue - Lower bound of the value range.
+* @param[in] dMaxValue - Upper bound of the value range.
+* @param[in] nChunkIndicesBufferSize - Number of elements in buffer
+* @param[out] pChunkIndicesNeededCount - will be filled with the count of the written elements, or needed buffer size.
+* @param[out] pChunkIndicesBuffer - uint64  buffer of Indices of the chunks that may hold a value in the range.
 * @return error code or 0 (success)
 */
-typedef LibMCEnvResult (*PLibMCEnvDataTable_CreateScatterPlotOptionsPtr) (LibMCEnv_DataTable pDataTable, LibMCEnv_DataTableScatterPlotOptions * pScatterPlotOptions);
+typedef LibMCEnvResult (*PLibMCEnvDataTableReader_FindChunksInValueRangePtr) (LibMCEnv_DataTableReader pDataTableReader, const char * pIdentifier, LibMCEnv_double dMinValue, LibMCEnv_double dMaxValue, const LibMCEnv_uint64 nChunkIndicesBufferSize, LibMCEnv_uint64* pChunkIndicesNeededCount, LibMCEnv_uint64 * pChunkIndicesBuffer);
 
 /**
-* Creates a scatterplot from the data table according to its input parameters.
+* Materialises a row range as an ordinary in-memory data table.
 *
-* @param[in] pDataTable - DataTable instance.
-* @param[in] pScatterPlotOptions - ScatterPlot Options to use
-* @param[out] pScatterPlot - ScatterPlot Instance
+* @param[in] pDataTableReader - DataTableReader instance.
+* @param[in] nFromRow - Index of the first row of the range.
+* @param[in] nRowCount - Number of rows of the range.
+* @param[in] pColumnIdentifiers - Comma separated identifiers of the columns to extract. An empty string extracts all columns.
+* @param[out] pDataTableInstance - Data table instance.
 * @return error code or 0 (success)
 */
-typedef LibMCEnvResult (*PLibMCEnvDataTable_CalculateScatterPlotPtr) (LibMCEnv_DataTable pDataTable, LibMCEnv_DataTableScatterPlotOptions pScatterPlotOptions, LibMCEnv_ScatterPlot * pScatterPlot);
+typedef LibMCEnvResult (*PLibMCEnvDataTableReader_ExtractDataTablePtr) (LibMCEnv_DataTableReader pDataTableReader, LibMCEnv_uint64 nFromRow, LibMCEnv_uint64 nRowCount, const char * pColumnIdentifiers, LibMCEnv_DataTable * pDataTableInstance);
 
 /*************************************************************************************************************************
  Class definition for DataSeries
@@ -4372,6 +5134,79 @@ typedef LibMCEnvResult (*PLibMCEnvBuildExecution_GetMetaDataStringPtr) (LibMCEnv
 */
 typedef LibMCEnvResult (*PLibMCEnvBuildExecution_LoadAttachedJournalPtr) (LibMCEnv_BuildExecution pBuildExecution, LibMCEnv_uint32 nCacheMemoryQuotaInMegabytes, LibMCEnv_JournalHandler * pJournalHandler);
 
+/**
+* Creates an options object for a data capture with default values.
+*
+* @param[in] pBuildExecution - BuildExecution instance.
+* @param[out] pOptions - Data capture options instance.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvBuildExecution_CreateDataCaptureOptionsPtr) (LibMCEnv_BuildExecution pBuildExecution, LibMCEnv_DataCaptureOptions * pOptions);
+
+/**
+* Creates a streaming data capture in this build execution. The execution MUST be in process.
+*
+* @param[in] pBuildExecution - BuildExecution instance.
+* @param[in] pIdentifier - Unique identifier of the capture in this execution. Fails if the identifier already exists or is invalid.
+* @param[in] pName - Human readable name of the capture.
+* @param[in] pOptions - Data capture options. Defaults are used if not given.
+* @param[in] pUserUUID - User UUID of the user that this data comes from. Empty string means no user attached.
+* @param[out] pDataCaptureInstance - Data capture instance.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvBuildExecution_CreateDataCapturePtr) (LibMCEnv_BuildExecution pBuildExecution, const char * pIdentifier, const char * pName, LibMCEnv_DataCaptureOptions pOptions, const char * pUserUUID, LibMCEnv_DataCapture * pDataCaptureInstance);
+
+/**
+* Returns if the execution has a data capture with a certain identifier.
+*
+* @param[in] pBuildExecution - BuildExecution instance.
+* @param[in] pIdentifier - Identifier of the capture.
+* @param[out] pCaptureExists - Returns true if the capture exists.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvBuildExecution_HasDataCapturePtr) (LibMCEnv_BuildExecution pBuildExecution, const char * pIdentifier, bool * pCaptureExists);
+
+/**
+* Returns the number of rows of a data capture that have been stored in segments. Fails if the capture does not exist.
+*
+* @param[in] pBuildExecution - BuildExecution instance.
+* @param[in] pIdentifier - Identifier of the capture.
+* @param[out] pRowCount - Number of rows.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvBuildExecution_GetDataCaptureRowCountPtr) (LibMCEnv_BuildExecution pBuildExecution, const char * pIdentifier, LibMCEnv_uint64 * pRowCount);
+
+/**
+* Returns the number of stored segments of a data capture. Fails if the capture does not exist.
+*
+* @param[in] pBuildExecution - BuildExecution instance.
+* @param[in] pIdentifier - Identifier of the capture.
+* @param[out] pSegmentCount - Number of segments.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvBuildExecution_GetDataCaptureSegmentCountPtr) (LibMCEnv_BuildExecution pBuildExecution, const char * pIdentifier, LibMCEnv_uint32 * pSegmentCount);
+
+/**
+* Loads one segment of a data capture as in-memory data table. Fails if the capture or the segment does not exist or the segment has been deleted by retention.
+*
+* @param[in] pBuildExecution - BuildExecution instance.
+* @param[in] pIdentifier - Identifier of the capture.
+* @param[in] nSegmentIndex - Index of the segment. 0-based.
+* @param[out] pDataTableInstance - Loaded data table instance.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvBuildExecution_LoadDataCaptureSegmentPtr) (LibMCEnv_BuildExecution pBuildExecution, const char * pIdentifier, LibMCEnv_uint32 nSegmentIndex, LibMCEnv_DataTable * pDataTableInstance);
+
+/**
+* Opens a reader on the stored segments of a data capture. Fails if the capture does not exist.
+*
+* @param[in] pBuildExecution - BuildExecution instance.
+* @param[in] pIdentifier - Identifier of the capture.
+* @param[out] pReaderInstance - Reader instance.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvBuildExecution_OpenDataCaptureReaderPtr) (LibMCEnv_BuildExecution pBuildExecution, const char * pIdentifier, LibMCEnv_DataTableReader * pReaderInstance);
+
 /*************************************************************************************************************************
  Class definition for BuildExecutionIterator
 **************************************************************************************************************************/
@@ -8168,6 +9003,14 @@ typedef LibMCEnvResult (*PLibMCEnvZIPStreamWriter_CreateZIPEntryPtr) (LibMCEnv_Z
 */
 typedef LibMCEnvResult (*PLibMCEnvZIPStreamWriter_CreateZIPEntryFromStreamPtr) (LibMCEnv_ZIPStreamWriter pZIPStreamWriter, const char * pFileName, LibMCEnv_StreamReader pStreamReader);
 
+/**
+* Discards the unfinished ZIP stream. The file on disk and the stream entry are deleted. Fails if the stream has been finished already. A ZIP writer that is released without Finish is discarded automatically.
+*
+* @param[in] pZIPStreamWriter - ZIPStreamWriter instance.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvZIPStreamWriter_DiscardPtr) (LibMCEnv_ZIPStreamWriter pZIPStreamWriter);
+
 /*************************************************************************************************************************
  Class definition for StreamReader
 **************************************************************************************************************************/
@@ -11334,6 +12177,62 @@ typedef LibMCEnvResult (*PLibMCEnvStateEnvironment_EvaluateFormulaAsIntegerPtr)
 */
 typedef LibMCEnvResult (*PLibMCEnvStateEnvironment_EvaluateFormulaAsBoolPtr) (LibMCEnv_StateEnvironment pStateEnvironment, const char * pFormula, bool * pValue);
 
+/**
+* Starts a stream download in the browser of a client session. Creates a download ticket for the user of the session and queues the download action for delivery to the session. Returns false if the session does not exist or is not authorized.
+*
+* @param[in] pStateEnvironment - StateEnvironment instance.
+* @param[in] pSessionUUID - UUID of the client session.
+* @param[in] pStreamUUID - Storage stream. Fails if the stream does not exist or is not finished.
+* @param[in] pFileName - File name offered to the browser. Fails if empty.
+* @param[out] pSuccess - True if the download action was queued for the session.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvStateEnvironment_StartStreamDownloadForSessionPtr) (LibMCEnv_StateEnvironment pStateEnvironment, const char * pSessionUUID, const char * pStreamUUID, const char * pFileName, bool * pSuccess);
+
+/**
+* Returns the delivery progress of all downloads of a storage stream.
+*
+* @param[in] pStateEnvironment - StateEnvironment instance.
+* @param[in] pStreamUUID - Storage stream.
+* @param[out] pActiveConnections - Connections that are sending the stream right now.
+* @param[out] pDeliveredBytes - Bytes from the start of the stream that were sent without a gap.
+* @param[out] pTotalBytes - Size of the stream.
+* @param[out] pCompleted - The last byte was sent and its connection ended successfully.
+* @param[out] pMillisecondsSinceActivity - Time since the last chunk was sent or since the download was handed over.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvStateEnvironment_GetStreamDownloadProgressPtr) (LibMCEnv_StateEnvironment pStateEnvironment, const char * pStreamUUID, LibMCEnv_uint32 * pActiveConnections, LibMCEnv_uint64 * pDeliveredBytes, LibMCEnv_uint64 * pTotalBytes, bool * pCompleted, LibMCEnv_uint64 * pMillisecondsSinceActivity);
+
+/**
+* Stops all running downloads of a storage stream, revokes its download tickets and drops its unclaimed download actions. Does nothing if the stream was already delivered completely.
+*
+* @param[in] pStateEnvironment - StateEnvironment instance.
+* @param[in] pStreamUUID - Storage stream.
+* @param[out] pCancelled - False if the download had already completed and nothing was cancelled.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvStateEnvironment_CancelStreamDownloadsPtr) (LibMCEnv_StateEnvironment pStateEnvironment, const char * pStreamUUID, bool * pCancelled);
+
+/**
+* Deletes a finished storage stream from disk and database, including its download tickets. Fails if the stream does not exist, is still being written or is being downloaded right now.
+*
+* @param[in] pStateEnvironment - StateEnvironment instance.
+* @param[in] pUUID - UUID of the storage stream.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvStateEnvironment_DeleteStorageStreamPtr) (LibMCEnv_StateEnvironment pStateEnvironment, const char * pUUID);
+
+/**
+* Deletes all finished streams with the given name except the newest ones. Streams with running downloads or pending download actions are kept. Returns the number of deleted streams.
+*
+* @param[in] pStateEnvironment - StateEnvironment instance.
+* @param[in] pName - Name of the streams.
+* @param[in] nKeepCount - Number of newest streams to keep.
+* @param[out] pDeletedCount - Number of deleted streams.
+* @return error code or 0 (success)
+*/
+typedef LibMCEnvResult (*PLibMCEnvStateEnvironment_EnforceStreamRetentionPtr) (LibMCEnv_StateEnvironment pStateEnvironment, const char * pName, LibMCEnv_uint32 nKeepCount, LibMCEnv_uint32 * pDeletedCount);
+
 /*************************************************************************************************************************
  Class definition for UIItem
 **************************************************************************************************************************/
@@ -12791,6 +13690,7 @@ typedef struct {
 	PLibMCEnvDataTable_ClearPtr m_DataTable_Clear;
 	PLibMCEnvDataTable_HasColumnPtr m_DataTable_HasColumn;
 	PLibMCEnvDataTable_GetRowCountPtr m_DataTable_GetRowCount;
+	PLibMCEnvDataTable_GetRowCount64Ptr m_DataTable_GetRowCount64;
 	PLibMCEnvDataTable_GetColumnCountPtr m_DataTable_GetColumnCount;
 	PLibMCEnvDataTable_GetColumnIdentifierPtr m_DataTable_GetColumnIdentifier;
 	PLibMCEnvDataTable_GetColumnDescriptionPtr m_DataTable_GetColumnDescription;
@@ -12801,11 +13701,17 @@ typedef struct {
 	PLibMCEnvDataTable_GetInt64ColumnValuesPtr m_DataTable_GetInt64ColumnValues;
 	PLibMCEnvDataTable_GetUint32ColumnValuesPtr m_DataTable_GetUint32ColumnValues;
 	PLibMCEnvDataTable_GetUint64ColumnValuesPtr m_DataTable_GetUint64ColumnValues;
+	PLibMCEnvDataTable_GetFloatColumnValuesPtr m_DataTable_GetFloatColumnValues;
+	PLibMCEnvDataTable_GetBoolColumnValuesPtr m_DataTable_GetBoolColumnValues;
+	PLibMCEnvDataTable_GetTimestampColumnValuesPtr m_DataTable_GetTimestampColumnValues;
 	PLibMCEnvDataTable_SetDoubleColumnValuesPtr m_DataTable_SetDoubleColumnValues;
 	PLibMCEnvDataTable_SetInt32ColumnValuesPtr m_DataTable_SetInt32ColumnValues;
 	PLibMCEnvDataTable_SetInt64ColumnValuesPtr m_DataTable_SetInt64ColumnValues;
 	PLibMCEnvDataTable_SetUint32ColumnValuesPtr m_DataTable_SetUint32ColumnValues;
 	PLibMCEnvDataTable_SetUint64ColumnValuesPtr m_DataTable_SetUint64ColumnValues;
+	PLibMCEnvDataTable_SetFloatColumnValuesPtr m_DataTable_SetFloatColumnValues;
+	PLibMCEnvDataTable_SetBoolColumnValuesPtr m_DataTable_SetBoolColumnValues;
+	PLibMCEnvDataTable_SetTimestampColumnValuesPtr m_DataTable_SetTimestampColumnValues;
 	PLibMCEnvDataTable_CreateWriteOptionsPtr m_DataTable_CreateWriteOptions;
 	PLibMCEnvDataTable_CreateCSVWriteOptionsPtr m_DataTable_CreateCSVWriteOptions;
 	PLibMCEnvDataTable_WriteCSVToStreamPtr m_DataTable_WriteCSVToStream;
@@ -12813,6 +13719,71 @@ typedef struct {
 	PLibMCEnvDataTable_LoadFromStreamPtr m_DataTable_LoadFromStream;
 	PLibMCEnvDataTable_CreateScatterPlotOptionsPtr m_DataTable_CreateScatterPlotOptions;
 	PLibMCEnvDataTable_CalculateScatterPlotPtr m_DataTable_CalculateScatterPlot;
+	PLibMCEnvDataCaptureOptions_SetChunkRowCountPtr m_DataCaptureOptions_SetChunkRowCount;
+	PLibMCEnvDataCaptureOptions_GetChunkRowCountPtr m_DataCaptureOptions_GetChunkRowCount;
+	PLibMCEnvDataCaptureOptions_SetSegmentSizeInBytesPtr m_DataCaptureOptions_SetSegmentSizeInBytes;
+	PLibMCEnvDataCaptureOptions_GetSegmentSizeInBytesPtr m_DataCaptureOptions_GetSegmentSizeInBytes;
+	PLibMCEnvDataCaptureOptions_SetMaxQueuedChunksPtr m_DataCaptureOptions_SetMaxQueuedChunks;
+	PLibMCEnvDataCaptureOptions_GetMaxQueuedChunksPtr m_DataCaptureOptions_GetMaxQueuedChunks;
+	PLibMCEnvDataCaptureOptions_SetBackpressureModePtr m_DataCaptureOptions_SetBackpressureMode;
+	PLibMCEnvDataCaptureOptions_GetBackpressureModePtr m_DataCaptureOptions_GetBackpressureMode;
+	PLibMCEnvDataCaptureOptions_SetStorageLimitInBytesPtr m_DataCaptureOptions_SetStorageLimitInBytes;
+	PLibMCEnvDataCaptureOptions_GetStorageLimitInBytesPtr m_DataCaptureOptions_GetStorageLimitInBytes;
+	PLibMCEnvDataCaptureOptions_SetCompressionPtr m_DataCaptureOptions_SetCompression;
+	PLibMCEnvDataCaptureOptions_GetCompressionPtr m_DataCaptureOptions_GetCompression;
+	PLibMCEnvDataCaptureOptions_SetColumnEncodingPtr m_DataCaptureOptions_SetColumnEncoding;
+	PLibMCEnvDataCaptureOptions_SetDoubleQuantizationPtr m_DataCaptureOptions_SetDoubleQuantization;
+	PLibMCEnvDataCaptureChunk_GetCapacityPtr m_DataCaptureChunk_GetCapacity;
+	PLibMCEnvDataCaptureChunk_GetRowCountPtr m_DataCaptureChunk_GetRowCount;
+	PLibMCEnvDataCaptureChunk_IsFullPtr m_DataCaptureChunk_IsFull;
+	PLibMCEnvDataCaptureChunk_SetDoubleColumnValuesPtr m_DataCaptureChunk_SetDoubleColumnValues;
+	PLibMCEnvDataCaptureChunk_SetInt32ColumnValuesPtr m_DataCaptureChunk_SetInt32ColumnValues;
+	PLibMCEnvDataCaptureChunk_SetUint32ColumnValuesPtr m_DataCaptureChunk_SetUint32ColumnValues;
+	PLibMCEnvDataCaptureChunk_SetInt64ColumnValuesPtr m_DataCaptureChunk_SetInt64ColumnValues;
+	PLibMCEnvDataCaptureChunk_SetUint64ColumnValuesPtr m_DataCaptureChunk_SetUint64ColumnValues;
+	PLibMCEnvDataCaptureChunk_SetFloatColumnValuesPtr m_DataCaptureChunk_SetFloatColumnValues;
+	PLibMCEnvDataCaptureChunk_SetBoolColumnValuesPtr m_DataCaptureChunk_SetBoolColumnValues;
+	PLibMCEnvDataCaptureChunk_SetTimestampColumnValuesPtr m_DataCaptureChunk_SetTimestampColumnValues;
+	PLibMCEnvDataCaptureChunk_BeginRowPtr m_DataCaptureChunk_BeginRow;
+	PLibMCEnvDataCaptureChunk_SetRowDoubleValuePtr m_DataCaptureChunk_SetRowDoubleValue;
+	PLibMCEnvDataCaptureChunk_SetRowIntegerValuePtr m_DataCaptureChunk_SetRowIntegerValue;
+	PLibMCEnvDataCaptureChunk_EndRowPtr m_DataCaptureChunk_EndRow;
+	PLibMCEnvDataCapture_GetUUIDPtr m_DataCapture_GetUUID;
+	PLibMCEnvDataCapture_GetIdentifierPtr m_DataCapture_GetIdentifier;
+	PLibMCEnvDataCapture_GetNamePtr m_DataCapture_GetName;
+	PLibMCEnvDataCapture_GetStatusPtr m_DataCapture_GetStatus;
+	PLibMCEnvDataCapture_AddColumnPtr m_DataCapture_AddColumn;
+	PLibMCEnvDataCapture_GetColumnCountPtr m_DataCapture_GetColumnCount;
+	PLibMCEnvDataCapture_BeginChunkPtr m_DataCapture_BeginChunk;
+	PLibMCEnvDataCapture_CommitChunkPtr m_DataCapture_CommitChunk;
+	PLibMCEnvDataCapture_FlushPtr m_DataCapture_Flush;
+	PLibMCEnvDataCapture_GetCapturedRowCountPtr m_DataCapture_GetCapturedRowCount;
+	PLibMCEnvDataCapture_GetStorageSizeInBytesPtr m_DataCapture_GetStorageSizeInBytes;
+	PLibMCEnvDataCapture_GetSegmentCountPtr m_DataCapture_GetSegmentCount;
+	PLibMCEnvDataCapture_GetQueuedChunkCountPtr m_DataCapture_GetQueuedChunkCount;
+	PLibMCEnvDataCapture_GetDroppedRowCountPtr m_DataCapture_GetDroppedRowCount;
+	PLibMCEnvDataCapture_FinishPtr m_DataCapture_Finish;
+	PLibMCEnvDataCapture_AbortPtr m_DataCapture_Abort;
+	PLibMCEnvDataCapture_AddColumnsFromDataTablePtr m_DataCapture_AddColumnsFromDataTable;
+	PLibMCEnvDataCapture_AppendDataTablePtr m_DataCapture_AppendDataTable;
+	PLibMCEnvDataTableReader_GetRowCountPtr m_DataTableReader_GetRowCount;
+	PLibMCEnvDataTableReader_GetFirstAvailableRowPtr m_DataTableReader_GetFirstAvailableRow;
+	PLibMCEnvDataTableReader_GetColumnCountPtr m_DataTableReader_GetColumnCount;
+	PLibMCEnvDataTableReader_HasColumnPtr m_DataTableReader_HasColumn;
+	PLibMCEnvDataTableReader_GetColumnInformationPtr m_DataTableReader_GetColumnInformation;
+	PLibMCEnvDataTableReader_GetColumnQuantizationPtr m_DataTableReader_GetColumnQuantization;
+	PLibMCEnvDataTableReader_GetSegmentCountPtr m_DataTableReader_GetSegmentCount;
+	PLibMCEnvDataTableReader_GetSegmentInformationPtr m_DataTableReader_GetSegmentInformation;
+	PLibMCEnvDataTableReader_GetChunkCountPtr m_DataTableReader_GetChunkCount;
+	PLibMCEnvDataTableReader_GetChunkInformationPtr m_DataTableReader_GetChunkInformation;
+	PLibMCEnvDataTableReader_GetChunkStatisticsPtr m_DataTableReader_GetChunkStatistics;
+	PLibMCEnvDataTableReader_ReadDoubleColumnRangePtr m_DataTableReader_ReadDoubleColumnRange;
+	PLibMCEnvDataTableReader_ReadFloatColumnRangePtr m_DataTableReader_ReadFloatColumnRange;
+	PLibMCEnvDataTableReader_ReadInt64ColumnRangePtr m_DataTableReader_ReadInt64ColumnRange;
+	PLibMCEnvDataTableReader_ReadBoolColumnRangePtr m_DataTableReader_ReadBoolColumnRange;
+	PLibMCEnvDataTableReader_ReadColumnDownsampledPtr m_DataTableReader_ReadColumnDownsampled;
+	PLibMCEnvDataTableReader_FindChunksInValueRangePtr m_DataTableReader_FindChunksInValueRange;
+	PLibMCEnvDataTableReader_ExtractDataTablePtr m_DataTableReader_ExtractDataTable;
 	PLibMCEnvDataSeries_GetNamePtr m_DataSeries_GetName;
 	PLibMCEnvDataSeries_GetUUIDPtr m_DataSeries_GetUUID;
 	PLibMCEnvDataSeries_ClearPtr m_DataSeries_Clear;
@@ -13075,6 +14046,13 @@ typedef struct {
 	PLibMCEnvBuildExecution_HasMetaDataStringPtr m_BuildExecution_HasMetaDataString;
 	PLibMCEnvBuildExecution_GetMetaDataStringPtr m_BuildExecution_GetMetaDataString;
 	PLibMCEnvBuildExecution_LoadAttachedJournalPtr m_BuildExecution_LoadAttachedJournal;
+	PLibMCEnvBuildExecution_CreateDataCaptureOptionsPtr m_BuildExecution_CreateDataCaptureOptions;
+	PLibMCEnvBuildExecution_CreateDataCapturePtr m_BuildExecution_CreateDataCapture;
+	PLibMCEnvBuildExecution_HasDataCapturePtr m_BuildExecution_HasDataCapture;
+	PLibMCEnvBuildExecution_GetDataCaptureRowCountPtr m_BuildExecution_GetDataCaptureRowCount;
+	PLibMCEnvBuildExecution_GetDataCaptureSegmentCountPtr m_BuildExecution_GetDataCaptureSegmentCount;
+	PLibMCEnvBuildExecution_LoadDataCaptureSegmentPtr m_BuildExecution_LoadDataCaptureSegment;
+	PLibMCEnvBuildExecution_OpenDataCaptureReaderPtr m_BuildExecution_OpenDataCaptureReader;
 	PLibMCEnvBuildExecutionIterator_GetCurrentExecutionPtr m_BuildExecutionIterator_GetCurrentExecution;
 	PLibMCEnvBuildIterator_GetCurrentBuildPtr m_BuildIterator_GetCurrentBuild;
 	PLibMCEnvBuild_GetNamePtr m_Build_GetName;
@@ -13434,6 +14412,7 @@ typedef struct {
 	PLibMCEnvTempStreamWriter_CopyFromPtr m_TempStreamWriter_CopyFrom;
 	PLibMCEnvZIPStreamWriter_CreateZIPEntryPtr m_ZIPStreamWriter_CreateZIPEntry;
 	PLibMCEnvZIPStreamWriter_CreateZIPEntryFromStreamPtr m_ZIPStreamWriter_CreateZIPEntryFromStream;
+	PLibMCEnvZIPStreamWriter_DiscardPtr m_ZIPStreamWriter_Discard;
 	PLibMCEnvStreamReader_GetUUIDPtr m_StreamReader_GetUUID;
 	PLibMCEnvStreamReader_GetNamePtr m_StreamReader_GetName;
 	PLibMCEnvStreamReader_GetMIMETypePtr m_StreamReader_GetMIMEType;
@@ -13725,6 +14704,11 @@ typedef struct {
 	PLibMCEnvStateEnvironment_EvaluateFormulaAsDoublePtr m_StateEnvironment_EvaluateFormulaAsDouble;
 	PLibMCEnvStateEnvironment_EvaluateFormulaAsIntegerPtr m_StateEnvironment_EvaluateFormulaAsInteger;
 	PLibMCEnvStateEnvironment_EvaluateFormulaAsBoolPtr m_StateEnvironment_EvaluateFormulaAsBool;
+	PLibMCEnvStateEnvironment_StartStreamDownloadForSessionPtr m_StateEnvironment_StartStreamDownloadForSession;
+	PLibMCEnvStateEnvironment_GetStreamDownloadProgressPtr m_StateEnvironment_GetStreamDownloadProgress;
+	PLibMCEnvStateEnvironment_CancelStreamDownloadsPtr m_StateEnvironment_CancelStreamDownloads;
+	PLibMCEnvStateEnvironment_DeleteStorageStreamPtr m_StateEnvironment_DeleteStorageStream;
+	PLibMCEnvStateEnvironment_EnforceStreamRetentionPtr m_StateEnvironment_EnforceStreamRetention;
 	PLibMCEnvUIItem_GetNamePtr m_UIItem_GetName;
 	PLibMCEnvUIItem_GetPathPtr m_UIItem_GetPath;
 	PLibMCEnvUIItem_GetUUIDPtr m_UIItem_GetUUID;
diff --git a/Framework/HeadersDev/CppDynamic/libmcenv_dynamic.hpp b/Framework/HeadersDev/CppDynamic/libmcenv_dynamic.hpp
index 8f30e6ad9..4f31a2139 100644
--- a/Framework/HeadersDev/CppDynamic/libmcenv_dynamic.hpp
+++ b/Framework/HeadersDev/CppDynamic/libmcenv_dynamic.hpp
@@ -81,6 +81,10 @@ class CScatterPlotDataChannel;
 class CScatterPlotDataChannelIterator;
 class CDataTableScatterPlotOptions;
 class CDataTable;
+class CDataCaptureOptions;
+class CDataCaptureChunk;
+class CDataCapture;
+class CDataTableReader;
 class CDataSeries;
 class CDateTimeDifference;
 class CDateTime;
@@ -176,6 +180,10 @@ typedef CScatterPlotDataChannel CLibMCEnvScatterPlotDataChannel;
 typedef CScatterPlotDataChannelIterator CLibMCEnvScatterPlotDataChannelIterator;
 typedef CDataTableScatterPlotOptions CLibMCEnvDataTableScatterPlotOptions;
 typedef CDataTable CLibMCEnvDataTable;
+typedef CDataCaptureOptions CLibMCEnvDataCaptureOptions;
+typedef CDataCaptureChunk CLibMCEnvDataCaptureChunk;
+typedef CDataCapture CLibMCEnvDataCapture;
+typedef CDataTableReader CLibMCEnvDataTableReader;
 typedef CDataSeries CLibMCEnvDataSeries;
 typedef CDateTimeDifference CLibMCEnvDateTimeDifference;
 typedef CDateTime CLibMCEnvDateTime;
@@ -271,6 +279,10 @@ typedef std::shared_ptr<CScatterPlotDataChannel> PScatterPlotDataChannel;
 typedef std::shared_ptr<CScatterPlotDataChannelIterator> PScatterPlotDataChannelIterator;
 typedef std::shared_ptr<CDataTableScatterPlotOptions> PDataTableScatterPlotOptions;
 typedef std::shared_ptr<CDataTable> PDataTable;
+typedef std::shared_ptr<CDataCaptureOptions> PDataCaptureOptions;
+typedef std::shared_ptr<CDataCaptureChunk> PDataCaptureChunk;
+typedef std::shared_ptr<CDataCapture> PDataCapture;
+typedef std::shared_ptr<CDataTableReader> PDataTableReader;
 typedef std::shared_ptr<CDataSeries> PDataSeries;
 typedef std::shared_ptr<CDateTimeDifference> PDateTimeDifference;
 typedef std::shared_ptr<CDateTime> PDateTime;
@@ -366,6 +378,10 @@ typedef PScatterPlotDataChannel PLibMCEnvScatterPlotDataChannel;
 typedef PScatterPlotDataChannelIterator PLibMCEnvScatterPlotDataChannelIterator;
 typedef PDataTableScatterPlotOptions PLibMCEnvDataTableScatterPlotOptions;
 typedef PDataTable PLibMCEnvDataTable;
+typedef PDataCaptureOptions PLibMCEnvDataCaptureOptions;
+typedef PDataCaptureChunk PLibMCEnvDataCaptureChunk;
+typedef PDataCapture PLibMCEnvDataCapture;
+typedef PDataTableReader PLibMCEnvDataTableReader;
 typedef PDataSeries PLibMCEnvDataSeries;
 typedef PDateTimeDifference PLibMCEnvDateTimeDifference;
 typedef PDateTime PLibMCEnvDateTime;
@@ -781,6 +797,43 @@ class ELibMCEnvException : public std::exception {
 			case LIBMCENV_ERROR_FORMULAEVALUATIONFAILED: return "FORMULAEVALUATIONFAILED";
 			case LIBMCENV_ERROR_FORMULASESSIONREFERENCESNOTAVAILABLE: return "FORMULASESSIONREFERENCESNOTAVAILABLE";
 			case LIBMCENV_ERROR_INVALIDFORMULAREFERENCEINDEX: return "INVALIDFORMULAREFERENCEINDEX";
+			case LIBMCENV_ERROR_COLUMNISNOTOFTYPEFLOAT: return "COLUMNISNOTOFTYPEFLOAT";
+			case LIBMCENV_ERROR_COLUMNISNOTOFTYPEBOOL: return "COLUMNISNOTOFTYPEBOOL";
+			case LIBMCENV_ERROR_COLUMNISNOTOFTYPETIMESTAMP: return "COLUMNISNOTOFTYPETIMESTAMP";
+			case LIBMCENV_ERROR_UNSUPPORTEDDATATABLEVERSION: return "UNSUPPORTEDDATATABLEVERSION";
+			case LIBMCENV_ERROR_UNSUPPORTEDDATATABLEENCODING: return "UNSUPPORTEDDATATABLEENCODING";
+			case LIBMCENV_ERROR_INVALIDDATATABLECOLUMNHEADER: return "INVALIDDATATABLECOLUMNHEADER";
+			case LIBMCENV_ERROR_DATACAPTURENOTCONFIGURABLE: return "DATACAPTURENOTCONFIGURABLE";
+			case LIBMCENV_ERROR_DATACAPTURENOTRECORDING: return "DATACAPTURENOTRECORDING";
+			case LIBMCENV_ERROR_DATACAPTURECHUNKALREADYOPEN: return "DATACAPTURECHUNKALREADYOPEN";
+			case LIBMCENV_ERROR_DATACAPTURECHUNKINVALID: return "DATACAPTURECHUNKINVALID";
+			case LIBMCENV_ERROR_DATACAPTURECHUNKINCOMPLETE: return "DATACAPTURECHUNKINCOMPLETE";
+			case LIBMCENV_ERROR_DATACAPTURECHUNKOVERFLOW: return "DATACAPTURECHUNKOVERFLOW";
+			case LIBMCENV_ERROR_DATACAPTUREQUEUEFULL: return "DATACAPTUREQUEUEFULL";
+			case LIBMCENV_ERROR_DATACAPTUREWRITERFAILED: return "DATACAPTUREWRITERFAILED";
+			case LIBMCENV_ERROR_INVALIDDATACAPTUREOPTION: return "INVALIDDATACAPTUREOPTION";
+			case LIBMCENV_ERROR_DATACAPTUREROWNOTOPEN: return "DATACAPTUREROWNOTOPEN";
+			case LIBMCENV_ERROR_DATACAPTUREROWALREADYOPEN: return "DATACAPTUREROWALREADYOPEN";
+			case LIBMCENV_ERROR_DATACAPTUREVALUEOUTOFRANGE: return "DATACAPTUREVALUEOUTOFRANGE";
+			case LIBMCENV_ERROR_DATACAPTURESEGMENTPURGED: return "DATACAPTURESEGMENTPURGED";
+			case LIBMCENV_ERROR_EMPTYDATACAPTURENAME: return "EMPTYDATACAPTURENAME";
+			case LIBMCENV_ERROR_EMPTYDATACAPTUREIDENTIFIER: return "EMPTYDATACAPTUREIDENTIFIER";
+			case LIBMCENV_ERROR_INVALIDDATACAPTUREIDENTIFIER: return "INVALIDDATACAPTUREIDENTIFIER";
+			case LIBMCENV_ERROR_DATACAPTUREEXECUTIONNOTINPROCESS: return "DATACAPTUREEXECUTIONNOTINPROCESS";
+			case LIBMCENV_ERROR_DATATABLESEGMENTTRUNCATED: return "DATATABLESEGMENTTRUNCATED";
+			case LIBMCENV_ERROR_UNSUPPORTEDDATATABLECODEC: return "UNSUPPORTEDDATATABLECODEC";
+			case LIBMCENV_ERROR_INVALIDDATATABLESEGMENT: return "INVALIDDATATABLESEGMENT";
+			case LIBMCENV_ERROR_DATACAPTURECHUNKOUTSTANDING: return "DATACAPTURECHUNKOUTSTANDING";
+			case LIBMCENV_ERROR_DATACAPTURECOLUMNTYPEMISMATCH: return "DATACAPTURECOLUMNTYPEMISMATCH";
+			case LIBMCENV_ERROR_INVALIDDATACAPTURESEGMENTINDEX: return "INVALIDDATACAPTURESEGMENTINDEX";
+			case LIBMCENV_ERROR_DATACAPTURECOLUMNNOTFOUND: return "DATACAPTURECOLUMNNOTFOUND";
+			case LIBMCENV_ERROR_INVALIDDATATABLEROWRANGE: return "INVALIDDATATABLEROWRANGE";
+			case LIBMCENV_ERROR_INVALIDDOWNSAMPLEPARAMETERS: return "INVALIDDOWNSAMPLEPARAMETERS";
+			case LIBMCENV_ERROR_DATATABLECOLUMNTYPEMISMATCH: return "DATATABLECOLUMNTYPEMISMATCH";
+			case LIBMCENV_ERROR_INVALIDDATATABLECHUNKINDEX: return "INVALIDDATATABLECHUNKINDEX";
+			case LIBMCENV_ERROR_STREAMHASACTIVEDOWNLOADS: return "STREAMHASACTIVEDOWNLOADS";
+			case LIBMCENV_ERROR_ZIPSTREAMALREADYFINISHED: return "ZIPSTREAMALREADYFINISHED";
+			case LIBMCENV_ERROR_SESSIONHANDLERNOTAVAILABLE: return "SESSIONHANDLERNOTAVAILABLE";
 		}
 		return "UNKNOWN";
 	}
@@ -1057,6 +1110,43 @@ class ELibMCEnvException : public std::exception {
 			case LIBMCENV_ERROR_FORMULAEVALUATIONFAILED: return "Formula evaluation failed.";
 			case LIBMCENV_ERROR_FORMULASESSIONREFERENCESNOTAVAILABLE: return "Session and user references are only available in formulas of the UI environment.";
 			case LIBMCENV_ERROR_INVALIDFORMULAREFERENCEINDEX: return "Invalid formula reference index.";
+			case LIBMCENV_ERROR_COLUMNISNOTOFTYPEFLOAT: return "Column is not of type float.";
+			case LIBMCENV_ERROR_COLUMNISNOTOFTYPEBOOL: return "Column is not of type bool.";
+			case LIBMCENV_ERROR_COLUMNISNOTOFTYPETIMESTAMP: return "Column is not of type timestamp.";
+			case LIBMCENV_ERROR_UNSUPPORTEDDATATABLEVERSION: return "Unsupported datatable format version.";
+			case LIBMCENV_ERROR_UNSUPPORTEDDATATABLEENCODING: return "Unsupported datatable column encoding.";
+			case LIBMCENV_ERROR_INVALIDDATATABLECOLUMNHEADER: return "Invalid datatable column header.";
+			case LIBMCENV_ERROR_DATACAPTURENOTCONFIGURABLE: return "Data capture schema is frozen and can not be changed anymore.";
+			case LIBMCENV_ERROR_DATACAPTURENOTRECORDING: return "Data capture is not recording.";
+			case LIBMCENV_ERROR_DATACAPTURECHUNKALREADYOPEN: return "Data capture has an uncommitted chunk already.";
+			case LIBMCENV_ERROR_DATACAPTURECHUNKINVALID: return "Data capture chunk is invalid or has been committed already.";
+			case LIBMCENV_ERROR_DATACAPTURECHUNKINCOMPLETE: return "Data capture chunk columns have different row counts.";
+			case LIBMCENV_ERROR_DATACAPTURECHUNKOVERFLOW: return "Data capture chunk capacity exceeded.";
+			case LIBMCENV_ERROR_DATACAPTUREQUEUEFULL: return "Data capture queue is full.";
+			case LIBMCENV_ERROR_DATACAPTUREWRITERFAILED: return "Data capture writer failed.";
+			case LIBMCENV_ERROR_INVALIDDATACAPTUREOPTION: return "Invalid data capture option.";
+			case LIBMCENV_ERROR_DATACAPTUREROWNOTOPEN: return "Data capture chunk has no open row.";
+			case LIBMCENV_ERROR_DATACAPTUREROWALREADYOPEN: return "Data capture chunk has an open row already.";
+			case LIBMCENV_ERROR_DATACAPTUREVALUEOUTOFRANGE: return "Data capture value is out of range for the column type.";
+			case LIBMCENV_ERROR_DATACAPTURESEGMENTPURGED: return "Data capture segment has been deleted by retention.";
+			case LIBMCENV_ERROR_EMPTYDATACAPTURENAME: return "Empty data capture name.";
+			case LIBMCENV_ERROR_EMPTYDATACAPTUREIDENTIFIER: return "Empty data capture identifier.";
+			case LIBMCENV_ERROR_INVALIDDATACAPTUREIDENTIFIER: return "Invalid data capture identifier.";
+			case LIBMCENV_ERROR_DATACAPTUREEXECUTIONNOTINPROCESS: return "Data captures can only be created while the build execution is in process.";
+			case LIBMCENV_ERROR_DATATABLESEGMENTTRUNCATED: return "Datatable segment is truncated and has no footer.";
+			case LIBMCENV_ERROR_UNSUPPORTEDDATATABLECODEC: return "Unsupported datatable page codec.";
+			case LIBMCENV_ERROR_INVALIDDATATABLESEGMENT: return "Invalid datatable segment.";
+			case LIBMCENV_ERROR_DATACAPTURECHUNKOUTSTANDING: return "Data capture has an uncommitted chunk.";
+			case LIBMCENV_ERROR_DATACAPTURECOLUMNTYPEMISMATCH: return "Data capture column has a different type.";
+			case LIBMCENV_ERROR_INVALIDDATACAPTURESEGMENTINDEX: return "Invalid data capture segment index.";
+			case LIBMCENV_ERROR_DATACAPTURECOLUMNNOTFOUND: return "Data capture column not found.";
+			case LIBMCENV_ERROR_INVALIDDATATABLEROWRANGE: return "Invalid datatable row range.";
+			case LIBMCENV_ERROR_INVALIDDOWNSAMPLEPARAMETERS: return "Invalid downsample parameters.";
+			case LIBMCENV_ERROR_DATATABLECOLUMNTYPEMISMATCH: return "Datatable column can not be read as the requested type.";
+			case LIBMCENV_ERROR_INVALIDDATATABLECHUNKINDEX: return "Invalid datatable chunk index.";
+			case LIBMCENV_ERROR_STREAMHASACTIVEDOWNLOADS: return "Storage stream has active downloads.";
+			case LIBMCENV_ERROR_ZIPSTREAMALREADYFINISHED: return "ZIP stream has already been finished.";
+			case LIBMCENV_ERROR_SESSIONHANDLERNOTAVAILABLE: return "Session handler is not available.";
 		}
 		return "unknown error";
 	}
@@ -1195,6 +1285,10 @@ class CWrapper {
 	friend class CScatterPlotDataChannelIterator;
 	friend class CDataTableScatterPlotOptions;
 	friend class CDataTable;
+	friend class CDataCaptureOptions;
+	friend class CDataCaptureChunk;
+	friend class CDataCapture;
+	friend class CDataTableReader;
 	friend class CDataSeries;
 	friend class CDateTimeDifference;
 	friend class CDateTime;
@@ -1776,6 +1870,7 @@ class CDataTable : public CBase {
 	inline void Clear();
 	inline bool HasColumn(const std::string & sIdentifier);
 	inline LibMCEnv_uint32 GetRowCount();
+	inline LibMCEnv_uint64 GetRowCount64();
 	inline LibMCEnv_uint32 GetColumnCount();
 	inline std::string GetColumnIdentifier(const LibMCEnv_uint32 nColumnIndex);
 	inline std::string GetColumnDescription(const LibMCEnv_uint32 nColumnIndex);
@@ -1786,11 +1881,17 @@ class CDataTable : public CBase {
 	inline void GetInt64ColumnValues(const std::string & sIdentifier, std::vector<LibMCEnv_int64> & ValuesBuffer);
 	inline void GetUint32ColumnValues(const std::string & sIdentifier, std::vector<LibMCEnv_uint32> & ValuesBuffer);
 	inline void GetUint64ColumnValues(const std::string & sIdentifier, std::vector<LibMCEnv_uint64> & ValuesBuffer);
+	inline void GetFloatColumnValues(const std::string & sIdentifier, std::vector<LibMCEnv_single> & ValuesBuffer);
+	inline void GetBoolColumnValues(const std::string & sIdentifier, std::vector<LibMCEnv_uint8> & ValuesBuffer);
+	inline void GetTimestampColumnValues(const std::string & sIdentifier, std::vector<LibMCEnv_uint64> & ValuesBuffer);
 	inline void SetDoubleColumnValues(const std::string & sIdentifier, const CInputVector<LibMCEnv_double> & ValuesBuffer);
 	inline void SetInt32ColumnValues(const std::string & sIdentifier, const CInputVector<LibMCEnv_int32> & ValuesBuffer);
 	inline void SetInt64ColumnValues(const std::string & sIdentifier, const CInputVector<LibMCEnv_int64> & ValuesBuffer);
 	inline void SetUint32ColumnValues(const std::string & sIdentifier, const CInputVector<LibMCEnv_uint32> & ValuesBuffer);
 	inline void SetUint64ColumnValues(const std::string & sIdentifier, const CInputVector<LibMCEnv_uint64> & ValuesBuffer);
+	inline void SetFloatColumnValues(const std::string & sIdentifier, const CInputVector<LibMCEnv_single> & ValuesBuffer);
+	inline void SetBoolColumnValues(const std::string & sIdentifier, const CInputVector<LibMCEnv_uint8> & ValuesBuffer);
+	inline void SetTimestampColumnValues(const std::string & sIdentifier, const CInputVector<LibMCEnv_uint64> & ValuesBuffer);
 	inline PDataTableWriteOptions CreateWriteOptions();
 	inline PDataTableCSVWriteOptions CreateCSVWriteOptions();
 	inline void WriteCSVToStream(classParam<CTempStreamWriter> pWriter, classParam<CDataTableCSVWriteOptions> pOptions);
@@ -1800,6 +1901,135 @@ class CDataTable : public CBase {
 	inline PScatterPlot CalculateScatterPlot(classParam<CDataTableScatterPlotOptions> pScatterPlotOptions);
 };
 	
+/*************************************************************************************************************************
+ Class CDataCaptureOptions 
+**************************************************************************************************************************/
+class CDataCaptureOptions : public CBase {
+public:
+	
+	/**
+	* CDataCaptureOptions::CDataCaptureOptions - Constructor for DataCaptureOptions class.
+	*/
+	CDataCaptureOptions(CWrapper* pWrapper, LibMCEnvHandle pHandle)
+		: CBase(pWrapper, pHandle)
+	{
+	}
+	
+	inline void SetChunkRowCount(const LibMCEnv_uint32 nChunkRowCount);
+	inline LibMCEnv_uint32 GetChunkRowCount();
+	inline void SetSegmentSizeInBytes(const LibMCEnv_uint64 nSegmentSizeInBytes);
+	inline LibMCEnv_uint64 GetSegmentSizeInBytes();
+	inline void SetMaxQueuedChunks(const LibMCEnv_uint32 nMaxQueuedChunks);
+	inline LibMCEnv_uint32 GetMaxQueuedChunks();
+	inline void SetBackpressureMode(const eDataCaptureBackpressureMode eBackpressureMode);
+	inline eDataCaptureBackpressureMode GetBackpressureMode();
+	inline void SetStorageLimitInBytes(const LibMCEnv_uint64 nStorageLimitInBytes);
+	inline LibMCEnv_uint64 GetStorageLimitInBytes();
+	inline void SetCompression(const eDataCaptureCompression eCompression);
+	inline eDataCaptureCompression GetCompression();
+	inline void SetColumnEncoding(const std::string & sColumnIdentifier, const eDataCaptureEncoding eEncoding);
+	inline void SetDoubleQuantization(const std::string & sColumnIdentifier, const LibMCEnv_double dStep);
+};
+	
+/*************************************************************************************************************************
+ Class CDataCaptureChunk 
+**************************************************************************************************************************/
+class CDataCaptureChunk : public CBase {
+public:
+	
+	/**
+	* CDataCaptureChunk::CDataCaptureChunk - Constructor for DataCaptureChunk class.
+	*/
+	CDataCaptureChunk(CWrapper* pWrapper, LibMCEnvHandle pHandle)
+		: CBase(pWrapper, pHandle)
+	{
+	}
+	
+	inline LibMCEnv_uint32 GetCapacity();
+	inline LibMCEnv_uint32 GetRowCount();
+	inline bool IsFull();
+	inline void SetDoubleColumnValues(const LibMCEnv_uint32 nColumnIndex, const CInputVector<LibMCEnv_double> & ValuesBuffer);
+	inline void SetInt32ColumnValues(const LibMCEnv_uint32 nColumnIndex, const CInputVector<LibMCEnv_int32> & ValuesBuffer);
+	inline void SetUint32ColumnValues(const LibMCEnv_uint32 nColumnIndex, const CInputVector<LibMCEnv_uint32> & ValuesBuffer);
+	inline void SetInt64ColumnValues(const LibMCEnv_uint32 nColumnIndex, const CInputVector<LibMCEnv_int64> & ValuesBuffer);
+	inline void SetUint64ColumnValues(const LibMCEnv_uint32 nColumnIndex, const CInputVector<LibMCEnv_uint64> & ValuesBuffer);
+	inline void SetFloatColumnValues(const LibMCEnv_uint32 nColumnIndex, const CInputVector<LibMCEnv_single> & ValuesBuffer);
+	inline void SetBoolColumnValues(const LibMCEnv_uint32 nColumnIndex, const CInputVector<LibMCEnv_uint8> & ValuesBuffer);
+	inline void SetTimestampColumnValues(const LibMCEnv_uint32 nColumnIndex, const CInputVector<LibMCEnv_uint64> & ValuesBuffer);
+	inline void BeginRow();
+	inline void SetRowDoubleValue(const LibMCEnv_uint32 nColumnIndex, const LibMCEnv_double dValue);
+	inline void SetRowIntegerValue(const LibMCEnv_uint32 nColumnIndex, const LibMCEnv_int64 nValue);
+	inline void EndRow();
+};
+	
+/*************************************************************************************************************************
+ Class CDataCapture 
+**************************************************************************************************************************/
+class CDataCapture : public CBase {
+public:
+	
+	/**
+	* CDataCapture::CDataCapture - Constructor for DataCapture class.
+	*/
+	CDataCapture(CWrapper* pWrapper, LibMCEnvHandle pHandle)
+		: CBase(pWrapper, pHandle)
+	{
+	}
+	
+	inline std::string GetUUID();
+	inline std::string GetIdentifier();
+	inline std::string GetName();
+	inline eDataCaptureStatus GetStatus();
+	inline void AddColumn(const std::string & sIdentifier, const std::string & sDescription, const eDataTableColumnType eColumnType);
+	inline LibMCEnv_uint32 GetColumnCount();
+	inline PDataCaptureChunk BeginChunk();
+	inline void CommitChunk(classParam<CDataCaptureChunk> pChunkInstance);
+	inline void Flush();
+	inline LibMCEnv_uint64 GetCapturedRowCount();
+	inline LibMCEnv_uint64 GetStorageSizeInBytes();
+	inline LibMCEnv_uint32 GetSegmentCount();
+	inline LibMCEnv_uint32 GetQueuedChunkCount();
+	inline LibMCEnv_uint64 GetDroppedRowCount();
+	inline std::string Finish();
+	inline void Abort();
+	inline void AddColumnsFromDataTable(classParam<CDataTable> pDataTable);
+	inline LibMCEnv_uint64 AppendDataTable(classParam<CDataTable> pDataTable);
+};
+	
+/*************************************************************************************************************************
+ Class CDataTableReader 
+**************************************************************************************************************************/
+class CDataTableReader : public CBase {
+public:
+	
+	/**
+	* CDataTableReader::CDataTableReader - Constructor for DataTableReader class.
+	*/
+	CDataTableReader(CWrapper* pWrapper, LibMCEnvHandle pHandle)
+		: CBase(pWrapper, pHandle)
+	{
+	}
+	
+	inline LibMCEnv_uint64 GetRowCount();
+	inline LibMCEnv_uint64 GetFirstAvailableRow();
+	inline LibMCEnv_uint32 GetColumnCount();
+	inline bool HasColumn(const std::string & sIdentifier);
+	inline void GetColumnInformation(const LibMCEnv_uint32 nColumnIndex, std::string & sIdentifier, std::string & sDescription, eDataTableColumnType & eColumnType);
+	inline LibMCEnv_double GetColumnQuantization(const std::string & sIdentifier);
+	inline LibMCEnv_uint32 GetSegmentCount();
+	inline void GetSegmentInformation(const LibMCEnv_uint32 nSegmentIndex, LibMCEnv_uint64 & nFirstRow, LibMCEnv_uint64 & nRowCount, LibMCEnv_uint64 & nSizeInBytes, bool & bIsAvailable);
+	inline LibMCEnv_uint64 GetChunkCount();
+	inline void GetChunkInformation(const LibMCEnv_uint64 nChunkIndex, LibMCEnv_uint32 & nSegmentIndex, LibMCEnv_uint64 & nFirstRow, LibMCEnv_uint64 & nRowCount, bool & bIsAvailable);
+	inline bool GetChunkStatistics(const LibMCEnv_uint64 nChunkIndex, const std::string & sIdentifier, LibMCEnv_double & dMinValue, LibMCEnv_double & dMaxValue);
+	inline void ReadDoubleColumnRange(const std::string & sIdentifier, const LibMCEnv_uint64 nFromRow, const LibMCEnv_uint64 nRowCount, std::vector<LibMCEnv_double> & ValuesBuffer);
+	inline void ReadFloatColumnRange(const std::string & sIdentifier, const LibMCEnv_uint64 nFromRow, const LibMCEnv_uint64 nRowCount, std::vector<LibMCEnv_single> & ValuesBuffer);
+	inline void ReadInt64ColumnRange(const std::string & sIdentifier, const LibMCEnv_uint64 nFromRow, const LibMCEnv_uint64 nRowCount, std::vector<LibMCEnv_int64> & ValuesBuffer);
+	inline void ReadBoolColumnRange(const std::string & sIdentifier, const LibMCEnv_uint64 nFromRow, const LibMCEnv_uint64 nRowCount, std::vector<LibMCEnv_uint8> & ValuesBuffer);
+	inline void ReadColumnDownsampled(const std::string & sIdentifier, const LibMCEnv_uint64 nFromRow, const LibMCEnv_uint64 nRowCount, const LibMCEnv_uint32 nTargetPoints, const eDataTableDownsampleMode eMode, std::vector<LibMCEnv_double> & ValuesBuffer);
+	inline void FindChunksInValueRange(const std::string & sIdentifier, const LibMCEnv_double dMinValue, const LibMCEnv_double dMaxValue, std::vector<LibMCEnv_uint64> & ChunkIndicesBuffer);
+	inline PDataTable ExtractDataTable(const LibMCEnv_uint64 nFromRow, const LibMCEnv_uint64 nRowCount, const std::string & sColumnIdentifiers);
+};
+	
 /*************************************************************************************************************************
  Class CDataSeries 
 **************************************************************************************************************************/
@@ -2300,6 +2530,13 @@ class CBuildExecution : public CBase {
 	inline bool HasMetaDataString(const std::string & sKey);
 	inline std::string GetMetaDataString(const std::string & sKey);
 	inline PJournalHandler LoadAttachedJournal(const LibMCEnv_uint32 nCacheMemoryQuotaInMegabytes);
+	inline PDataCaptureOptions CreateDataCaptureOptions();
+	inline PDataCapture CreateDataCapture(const std::string & sIdentifier, const std::string & sName, classParam<CDataCaptureOptions> pOptions, const std::string & sUserUUID);
+	inline bool HasDataCapture(const std::string & sIdentifier);
+	inline LibMCEnv_uint64 GetDataCaptureRowCount(const std::string & sIdentifier);
+	inline LibMCEnv_uint32 GetDataCaptureSegmentCount(const std::string & sIdentifier);
+	inline PDataTable LoadDataCaptureSegment(const std::string & sIdentifier, const LibMCEnv_uint32 nSegmentIndex);
+	inline PDataTableReader OpenDataCaptureReader(const std::string & sIdentifier);
 };
 	
 /*************************************************************************************************************************
@@ -3075,6 +3312,7 @@ class CZIPStreamWriter : public CBaseTempStreamWriter {
 	
 	inline PTempStreamWriter CreateZIPEntry(const std::string & sFileName);
 	inline void CreateZIPEntryFromStream(const std::string & sFileName, classParam<CStreamReader> pStreamReader);
+	inline void Discard();
 };
 	
 /*************************************************************************************************************************
@@ -3766,6 +4004,11 @@ class CStateEnvironment : public CBase {
 	inline LibMCEnv_double EvaluateFormulaAsDouble(const std::string & sFormula);
 	inline LibMCEnv_int64 EvaluateFormulaAsInteger(const std::string & sFormula);
 	inline bool EvaluateFormulaAsBool(const std::string & sFormula);
+	inline bool StartStreamDownloadForSession(const std::string & sSessionUUID, const std::string & sStreamUUID, const std::string & sFileName);
+	inline void GetStreamDownloadProgress(const std::string & sStreamUUID, LibMCEnv_uint32 & nActiveConnections, LibMCEnv_uint64 & nDeliveredBytes, LibMCEnv_uint64 & nTotalBytes, bool & bCompleted, LibMCEnv_uint64 & nMillisecondsSinceActivity);
+	inline bool CancelStreamDownloads(const std::string & sStreamUUID);
+	inline void DeleteStorageStream(const std::string & sUUID);
+	inline LibMCEnv_uint32 EnforceStreamRetention(const std::string & sName, const LibMCEnv_uint32 nKeepCount);
 };
 	
 /*************************************************************************************************************************
@@ -4119,6 +4362,7 @@ class CUIEnvironment : public CBase {
 		pWrapperTable->m_DataTable_Clear = nullptr;
 		pWrapperTable->m_DataTable_HasColumn = nullptr;
 		pWrapperTable->m_DataTable_GetRowCount = nullptr;
+		pWrapperTable->m_DataTable_GetRowCount64 = nullptr;
 		pWrapperTable->m_DataTable_GetColumnCount = nullptr;
 		pWrapperTable->m_DataTable_GetColumnIdentifier = nullptr;
 		pWrapperTable->m_DataTable_GetColumnDescription = nullptr;
@@ -4129,11 +4373,17 @@ class CUIEnvironment : public CBase {
 		pWrapperTable->m_DataTable_GetInt64ColumnValues = nullptr;
 		pWrapperTable->m_DataTable_GetUint32ColumnValues = nullptr;
 		pWrapperTable->m_DataTable_GetUint64ColumnValues = nullptr;
+		pWrapperTable->m_DataTable_GetFloatColumnValues = nullptr;
+		pWrapperTable->m_DataTable_GetBoolColumnValues = nullptr;
+		pWrapperTable->m_DataTable_GetTimestampColumnValues = nullptr;
 		pWrapperTable->m_DataTable_SetDoubleColumnValues = nullptr;
 		pWrapperTable->m_DataTable_SetInt32ColumnValues = nullptr;
 		pWrapperTable->m_DataTable_SetInt64ColumnValues = nullptr;
 		pWrapperTable->m_DataTable_SetUint32ColumnValues = nullptr;
 		pWrapperTable->m_DataTable_SetUint64ColumnValues = nullptr;
+		pWrapperTable->m_DataTable_SetFloatColumnValues = nullptr;
+		pWrapperTable->m_DataTable_SetBoolColumnValues = nullptr;
+		pWrapperTable->m_DataTable_SetTimestampColumnValues = nullptr;
 		pWrapperTable->m_DataTable_CreateWriteOptions = nullptr;
 		pWrapperTable->m_DataTable_CreateCSVWriteOptions = nullptr;
 		pWrapperTable->m_DataTable_WriteCSVToStream = nullptr;
@@ -4141,6 +4391,71 @@ class CUIEnvironment : public CBase {
 		pWrapperTable->m_DataTable_LoadFromStream = nullptr;
 		pWrapperTable->m_DataTable_CreateScatterPlotOptions = nullptr;
 		pWrapperTable->m_DataTable_CalculateScatterPlot = nullptr;
+		pWrapperTable->m_DataCaptureOptions_SetChunkRowCount = nullptr;
+		pWrapperTable->m_DataCaptureOptions_GetChunkRowCount = nullptr;
+		pWrapperTable->m_DataCaptureOptions_SetSegmentSizeInBytes = nullptr;
+		pWrapperTable->m_DataCaptureOptions_GetSegmentSizeInBytes = nullptr;
+		pWrapperTable->m_DataCaptureOptions_SetMaxQueuedChunks = nullptr;
+		pWrapperTable->m_DataCaptureOptions_GetMaxQueuedChunks = nullptr;
+		pWrapperTable->m_DataCaptureOptions_SetBackpressureMode = nullptr;
+		pWrapperTable->m_DataCaptureOptions_GetBackpressureMode = nullptr;
+		pWrapperTable->m_DataCaptureOptions_SetStorageLimitInBytes = nullptr;
+		pWrapperTable->m_DataCaptureOptions_GetStorageLimitInBytes = nullptr;
+		pWrapperTable->m_DataCaptureOptions_SetCompression = nullptr;
+		pWrapperTable->m_DataCaptureOptions_GetCompression = nullptr;
+		pWrapperTable->m_DataCaptureOptions_SetColumnEncoding = nullptr;
+		pWrapperTable->m_DataCaptureOptions_SetDoubleQuantization = nullptr;
+		pWrapperTable->m_DataCaptureChunk_GetCapacity = nullptr;
+		pWrapperTable->m_DataCaptureChunk_GetRowCount = nullptr;
+		pWrapperTable->m_DataCaptureChunk_IsFull = nullptr;
+		pWrapperTable->m_DataCaptureChunk_SetDoubleColumnValues = nullptr;
+		pWrapperTable->m_DataCaptureChunk_SetInt32ColumnValues = nullptr;
+		pWrapperTable->m_DataCaptureChunk_SetUint32ColumnValues = nullptr;
+		pWrapperTable->m_DataCaptureChunk_SetInt64ColumnValues = nullptr;
+		pWrapperTable->m_DataCaptureChunk_SetUint64ColumnValues = nullptr;
+		pWrapperTable->m_DataCaptureChunk_SetFloatColumnValues = nullptr;
+		pWrapperTable->m_DataCaptureChunk_SetBoolColumnValues = nullptr;
+		pWrapperTable->m_DataCaptureChunk_SetTimestampColumnValues = nullptr;
+		pWrapperTable->m_DataCaptureChunk_BeginRow = nullptr;
+		pWrapperTable->m_DataCaptureChunk_SetRowDoubleValue = nullptr;
+		pWrapperTable->m_DataCaptureChunk_SetRowIntegerValue = nullptr;
+		pWrapperTable->m_DataCaptureChunk_EndRow = nullptr;
+		pWrapperTable->m_DataCapture_GetUUID = nullptr;
+		pWrapperTable->m_DataCapture_GetIdentifier = nullptr;
+		pWrapperTable->m_DataCapture_GetName = nullptr;
+		pWrapperTable->m_DataCapture_GetStatus = nullptr;
+		pWrapperTable->m_DataCapture_AddColumn = nullptr;
+		pWrapperTable->m_DataCapture_GetColumnCount = nullptr;
+		pWrapperTable->m_DataCapture_BeginChunk = nullptr;
+		pWrapperTable->m_DataCapture_CommitChunk = nullptr;
+		pWrapperTable->m_DataCapture_Flush = nullptr;
+		pWrapperTable->m_DataCapture_GetCapturedRowCount = nullptr;
+		pWrapperTable->m_DataCapture_GetStorageSizeInBytes = nullptr;
+		pWrapperTable->m_DataCapture_GetSegmentCount = nullptr;
+		pWrapperTable->m_DataCapture_GetQueuedChunkCount = nullptr;
+		pWrapperTable->m_DataCapture_GetDroppedRowCount = nullptr;
+		pWrapperTable->m_DataCapture_Finish = nullptr;
+		pWrapperTable->m_DataCapture_Abort = nullptr;
+		pWrapperTable->m_DataCapture_AddColumnsFromDataTable = nullptr;
+		pWrapperTable->m_DataCapture_AppendDataTable = nullptr;
+		pWrapperTable->m_DataTableReader_GetRowCount = nullptr;
+		pWrapperTable->m_DataTableReader_GetFirstAvailableRow = nullptr;
+		pWrapperTable->m_DataTableReader_GetColumnCount = nullptr;
+		pWrapperTable->m_DataTableReader_HasColumn = nullptr;
+		pWrapperTable->m_DataTableReader_GetColumnInformation = nullptr;
+		pWrapperTable->m_DataTableReader_GetColumnQuantization = nullptr;
+		pWrapperTable->m_DataTableReader_GetSegmentCount = nullptr;
+		pWrapperTable->m_DataTableReader_GetSegmentInformation = nullptr;
+		pWrapperTable->m_DataTableReader_GetChunkCount = nullptr;
+		pWrapperTable->m_DataTableReader_GetChunkInformation = nullptr;
+		pWrapperTable->m_DataTableReader_GetChunkStatistics = nullptr;
+		pWrapperTable->m_DataTableReader_ReadDoubleColumnRange = nullptr;
+		pWrapperTable->m_DataTableReader_ReadFloatColumnRange = nullptr;
+		pWrapperTable->m_DataTableReader_ReadInt64ColumnRange = nullptr;
+		pWrapperTable->m_DataTableReader_ReadBoolColumnRange = nullptr;
+		pWrapperTable->m_DataTableReader_ReadColumnDownsampled = nullptr;
+		pWrapperTable->m_DataTableReader_FindChunksInValueRange = nullptr;
+		pWrapperTable->m_DataTableReader_ExtractDataTable = nullptr;
 		pWrapperTable->m_DataSeries_GetName = nullptr;
 		pWrapperTable->m_DataSeries_GetUUID = nullptr;
 		pWrapperTable->m_DataSeries_Clear = nullptr;
@@ -4403,6 +4718,13 @@ class CUIEnvironment : public CBase {
 		pWrapperTable->m_BuildExecution_HasMetaDataString = nullptr;
 		pWrapperTable->m_BuildExecution_GetMetaDataString = nullptr;
 		pWrapperTable->m_BuildExecution_LoadAttachedJournal = nullptr;
+		pWrapperTable->m_BuildExecution_CreateDataCaptureOptions = nullptr;
+		pWrapperTable->m_BuildExecution_CreateDataCapture = nullptr;
+		pWrapperTable->m_BuildExecution_HasDataCapture = nullptr;
+		pWrapperTable->m_BuildExecution_GetDataCaptureRowCount = nullptr;
+		pWrapperTable->m_BuildExecution_GetDataCaptureSegmentCount = nullptr;
+		pWrapperTable->m_BuildExecution_LoadDataCaptureSegment = nullptr;
+		pWrapperTable->m_BuildExecution_OpenDataCaptureReader = nullptr;
 		pWrapperTable->m_BuildExecutionIterator_GetCurrentExecution = nullptr;
 		pWrapperTable->m_BuildIterator_GetCurrentBuild = nullptr;
 		pWrapperTable->m_Build_GetName = nullptr;
@@ -4762,6 +5084,7 @@ class CUIEnvironment : public CBase {
 		pWrapperTable->m_TempStreamWriter_CopyFrom = nullptr;
 		pWrapperTable->m_ZIPStreamWriter_CreateZIPEntry = nullptr;
 		pWrapperTable->m_ZIPStreamWriter_CreateZIPEntryFromStream = nullptr;
+		pWrapperTable->m_ZIPStreamWriter_Discard = nullptr;
 		pWrapperTable->m_StreamReader_GetUUID = nullptr;
 		pWrapperTable->m_StreamReader_GetName = nullptr;
 		pWrapperTable->m_StreamReader_GetMIMEType = nullptr;
@@ -5053,6 +5376,11 @@ class CUIEnvironment : public CBase {
 		pWrapperTable->m_StateEnvironment_EvaluateFormulaAsDouble = nullptr;
 		pWrapperTable->m_StateEnvironment_EvaluateFormulaAsInteger = nullptr;
 		pWrapperTable->m_StateEnvironment_EvaluateFormulaAsBool = nullptr;
+		pWrapperTable->m_StateEnvironment_StartStreamDownloadForSession = nullptr;
+		pWrapperTable->m_StateEnvironment_GetStreamDownloadProgress = nullptr;
+		pWrapperTable->m_StateEnvironment_CancelStreamDownloads = nullptr;
+		pWrapperTable->m_StateEnvironment_DeleteStorageStream = nullptr;
+		pWrapperTable->m_StateEnvironment_EnforceStreamRetention = nullptr;
 		pWrapperTable->m_UIItem_GetName = nullptr;
 		pWrapperTable->m_UIItem_GetPath = nullptr;
 		pWrapperTable->m_UIItem_GetUUID = nullptr;
@@ -6298,6 +6626,15 @@ class CUIEnvironment : public CBase {
 		if (pWrapperTable->m_DataTable_GetRowCount == nullptr)
 			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
+		#ifdef _WIN32
+		pWrapperTable->m_DataTable_GetRowCount64 = (PLibMCEnvDataTable_GetRowCount64Ptr) GetProcAddress(hLibrary, "libmcenv_datatable_getrowcount64");
+		#else // _WIN32
+		pWrapperTable->m_DataTable_GetRowCount64 = (PLibMCEnvDataTable_GetRowCount64Ptr) dlsym(hLibrary, "libmcenv_datatable_getrowcount64");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataTable_GetRowCount64 == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
 		#ifdef _WIN32
 		pWrapperTable->m_DataTable_GetColumnCount = (PLibMCEnvDataTable_GetColumnCountPtr) GetProcAddress(hLibrary, "libmcenv_datatable_getcolumncount");
 		#else // _WIN32
@@ -6388,6 +6725,33 @@ class CUIEnvironment : public CBase {
 		if (pWrapperTable->m_DataTable_GetUint64ColumnValues == nullptr)
 			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
+		#ifdef _WIN32
+		pWrapperTable->m_DataTable_GetFloatColumnValues = (PLibMCEnvDataTable_GetFloatColumnValuesPtr) GetProcAddress(hLibrary, "libmcenv_datatable_getfloatcolumnvalues");
+		#else // _WIN32
+		pWrapperTable->m_DataTable_GetFloatColumnValues = (PLibMCEnvDataTable_GetFloatColumnValuesPtr) dlsym(hLibrary, "libmcenv_datatable_getfloatcolumnvalues");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataTable_GetFloatColumnValues == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataTable_GetBoolColumnValues = (PLibMCEnvDataTable_GetBoolColumnValuesPtr) GetProcAddress(hLibrary, "libmcenv_datatable_getboolcolumnvalues");
+		#else // _WIN32
+		pWrapperTable->m_DataTable_GetBoolColumnValues = (PLibMCEnvDataTable_GetBoolColumnValuesPtr) dlsym(hLibrary, "libmcenv_datatable_getboolcolumnvalues");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataTable_GetBoolColumnValues == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataTable_GetTimestampColumnValues = (PLibMCEnvDataTable_GetTimestampColumnValuesPtr) GetProcAddress(hLibrary, "libmcenv_datatable_gettimestampcolumnvalues");
+		#else // _WIN32
+		pWrapperTable->m_DataTable_GetTimestampColumnValues = (PLibMCEnvDataTable_GetTimestampColumnValuesPtr) dlsym(hLibrary, "libmcenv_datatable_gettimestampcolumnvalues");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataTable_GetTimestampColumnValues == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
 		#ifdef _WIN32
 		pWrapperTable->m_DataTable_SetDoubleColumnValues = (PLibMCEnvDataTable_SetDoubleColumnValuesPtr) GetProcAddress(hLibrary, "libmcenv_datatable_setdoublecolumnvalues");
 		#else // _WIN32
@@ -6433,6 +6797,33 @@ class CUIEnvironment : public CBase {
 		if (pWrapperTable->m_DataTable_SetUint64ColumnValues == nullptr)
 			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
+		#ifdef _WIN32
+		pWrapperTable->m_DataTable_SetFloatColumnValues = (PLibMCEnvDataTable_SetFloatColumnValuesPtr) GetProcAddress(hLibrary, "libmcenv_datatable_setfloatcolumnvalues");
+		#else // _WIN32
+		pWrapperTable->m_DataTable_SetFloatColumnValues = (PLibMCEnvDataTable_SetFloatColumnValuesPtr) dlsym(hLibrary, "libmcenv_datatable_setfloatcolumnvalues");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataTable_SetFloatColumnValues == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataTable_SetBoolColumnValues = (PLibMCEnvDataTable_SetBoolColumnValuesPtr) GetProcAddress(hLibrary, "libmcenv_datatable_setboolcolumnvalues");
+		#else // _WIN32
+		pWrapperTable->m_DataTable_SetBoolColumnValues = (PLibMCEnvDataTable_SetBoolColumnValuesPtr) dlsym(hLibrary, "libmcenv_datatable_setboolcolumnvalues");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataTable_SetBoolColumnValues == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataTable_SetTimestampColumnValues = (PLibMCEnvDataTable_SetTimestampColumnValuesPtr) GetProcAddress(hLibrary, "libmcenv_datatable_settimestampcolumnvalues");
+		#else // _WIN32
+		pWrapperTable->m_DataTable_SetTimestampColumnValues = (PLibMCEnvDataTable_SetTimestampColumnValuesPtr) dlsym(hLibrary, "libmcenv_datatable_settimestampcolumnvalues");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataTable_SetTimestampColumnValues == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
 		#ifdef _WIN32
 		pWrapperTable->m_DataTable_CreateWriteOptions = (PLibMCEnvDataTable_CreateWriteOptionsPtr) GetProcAddress(hLibrary, "libmcenv_datatable_createwriteoptions");
 		#else // _WIN32
@@ -6496,6 +6887,591 @@ class CUIEnvironment : public CBase {
 		if (pWrapperTable->m_DataTable_CalculateScatterPlot == nullptr)
 			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCaptureOptions_SetChunkRowCount = (PLibMCEnvDataCaptureOptions_SetChunkRowCountPtr) GetProcAddress(hLibrary, "libmcenv_datacaptureoptions_setchunkrowcount");
+		#else // _WIN32
+		pWrapperTable->m_DataCaptureOptions_SetChunkRowCount = (PLibMCEnvDataCaptureOptions_SetChunkRowCountPtr) dlsym(hLibrary, "libmcenv_datacaptureoptions_setchunkrowcount");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCaptureOptions_SetChunkRowCount == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCaptureOptions_GetChunkRowCount = (PLibMCEnvDataCaptureOptions_GetChunkRowCountPtr) GetProcAddress(hLibrary, "libmcenv_datacaptureoptions_getchunkrowcount");
+		#else // _WIN32
+		pWrapperTable->m_DataCaptureOptions_GetChunkRowCount = (PLibMCEnvDataCaptureOptions_GetChunkRowCountPtr) dlsym(hLibrary, "libmcenv_datacaptureoptions_getchunkrowcount");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCaptureOptions_GetChunkRowCount == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCaptureOptions_SetSegmentSizeInBytes = (PLibMCEnvDataCaptureOptions_SetSegmentSizeInBytesPtr) GetProcAddress(hLibrary, "libmcenv_datacaptureoptions_setsegmentsizeinbytes");
+		#else // _WIN32
+		pWrapperTable->m_DataCaptureOptions_SetSegmentSizeInBytes = (PLibMCEnvDataCaptureOptions_SetSegmentSizeInBytesPtr) dlsym(hLibrary, "libmcenv_datacaptureoptions_setsegmentsizeinbytes");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCaptureOptions_SetSegmentSizeInBytes == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCaptureOptions_GetSegmentSizeInBytes = (PLibMCEnvDataCaptureOptions_GetSegmentSizeInBytesPtr) GetProcAddress(hLibrary, "libmcenv_datacaptureoptions_getsegmentsizeinbytes");
+		#else // _WIN32
+		pWrapperTable->m_DataCaptureOptions_GetSegmentSizeInBytes = (PLibMCEnvDataCaptureOptions_GetSegmentSizeInBytesPtr) dlsym(hLibrary, "libmcenv_datacaptureoptions_getsegmentsizeinbytes");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCaptureOptions_GetSegmentSizeInBytes == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCaptureOptions_SetMaxQueuedChunks = (PLibMCEnvDataCaptureOptions_SetMaxQueuedChunksPtr) GetProcAddress(hLibrary, "libmcenv_datacaptureoptions_setmaxqueuedchunks");
+		#else // _WIN32
+		pWrapperTable->m_DataCaptureOptions_SetMaxQueuedChunks = (PLibMCEnvDataCaptureOptions_SetMaxQueuedChunksPtr) dlsym(hLibrary, "libmcenv_datacaptureoptions_setmaxqueuedchunks");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCaptureOptions_SetMaxQueuedChunks == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCaptureOptions_GetMaxQueuedChunks = (PLibMCEnvDataCaptureOptions_GetMaxQueuedChunksPtr) GetProcAddress(hLibrary, "libmcenv_datacaptureoptions_getmaxqueuedchunks");
+		#else // _WIN32
+		pWrapperTable->m_DataCaptureOptions_GetMaxQueuedChunks = (PLibMCEnvDataCaptureOptions_GetMaxQueuedChunksPtr) dlsym(hLibrary, "libmcenv_datacaptureoptions_getmaxqueuedchunks");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCaptureOptions_GetMaxQueuedChunks == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCaptureOptions_SetBackpressureMode = (PLibMCEnvDataCaptureOptions_SetBackpressureModePtr) GetProcAddress(hLibrary, "libmcenv_datacaptureoptions_setbackpressuremode");
+		#else // _WIN32
+		pWrapperTable->m_DataCaptureOptions_SetBackpressureMode = (PLibMCEnvDataCaptureOptions_SetBackpressureModePtr) dlsym(hLibrary, "libmcenv_datacaptureoptions_setbackpressuremode");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCaptureOptions_SetBackpressureMode == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCaptureOptions_GetBackpressureMode = (PLibMCEnvDataCaptureOptions_GetBackpressureModePtr) GetProcAddress(hLibrary, "libmcenv_datacaptureoptions_getbackpressuremode");
+		#else // _WIN32
+		pWrapperTable->m_DataCaptureOptions_GetBackpressureMode = (PLibMCEnvDataCaptureOptions_GetBackpressureModePtr) dlsym(hLibrary, "libmcenv_datacaptureoptions_getbackpressuremode");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCaptureOptions_GetBackpressureMode == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCaptureOptions_SetStorageLimitInBytes = (PLibMCEnvDataCaptureOptions_SetStorageLimitInBytesPtr) GetProcAddress(hLibrary, "libmcenv_datacaptureoptions_setstoragelimitinbytes");
+		#else // _WIN32
+		pWrapperTable->m_DataCaptureOptions_SetStorageLimitInBytes = (PLibMCEnvDataCaptureOptions_SetStorageLimitInBytesPtr) dlsym(hLibrary, "libmcenv_datacaptureoptions_setstoragelimitinbytes");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCaptureOptions_SetStorageLimitInBytes == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCaptureOptions_GetStorageLimitInBytes = (PLibMCEnvDataCaptureOptions_GetStorageLimitInBytesPtr) GetProcAddress(hLibrary, "libmcenv_datacaptureoptions_getstoragelimitinbytes");
+		#else // _WIN32
+		pWrapperTable->m_DataCaptureOptions_GetStorageLimitInBytes = (PLibMCEnvDataCaptureOptions_GetStorageLimitInBytesPtr) dlsym(hLibrary, "libmcenv_datacaptureoptions_getstoragelimitinbytes");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCaptureOptions_GetStorageLimitInBytes == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCaptureOptions_SetCompression = (PLibMCEnvDataCaptureOptions_SetCompressionPtr) GetProcAddress(hLibrary, "libmcenv_datacaptureoptions_setcompression");
+		#else // _WIN32
+		pWrapperTable->m_DataCaptureOptions_SetCompression = (PLibMCEnvDataCaptureOptions_SetCompressionPtr) dlsym(hLibrary, "libmcenv_datacaptureoptions_setcompression");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCaptureOptions_SetCompression == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCaptureOptions_GetCompression = (PLibMCEnvDataCaptureOptions_GetCompressionPtr) GetProcAddress(hLibrary, "libmcenv_datacaptureoptions_getcompression");
+		#else // _WIN32
+		pWrapperTable->m_DataCaptureOptions_GetCompression = (PLibMCEnvDataCaptureOptions_GetCompressionPtr) dlsym(hLibrary, "libmcenv_datacaptureoptions_getcompression");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCaptureOptions_GetCompression == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCaptureOptions_SetColumnEncoding = (PLibMCEnvDataCaptureOptions_SetColumnEncodingPtr) GetProcAddress(hLibrary, "libmcenv_datacaptureoptions_setcolumnencoding");
+		#else // _WIN32
+		pWrapperTable->m_DataCaptureOptions_SetColumnEncoding = (PLibMCEnvDataCaptureOptions_SetColumnEncodingPtr) dlsym(hLibrary, "libmcenv_datacaptureoptions_setcolumnencoding");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCaptureOptions_SetColumnEncoding == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCaptureOptions_SetDoubleQuantization = (PLibMCEnvDataCaptureOptions_SetDoubleQuantizationPtr) GetProcAddress(hLibrary, "libmcenv_datacaptureoptions_setdoublequantization");
+		#else // _WIN32
+		pWrapperTable->m_DataCaptureOptions_SetDoubleQuantization = (PLibMCEnvDataCaptureOptions_SetDoubleQuantizationPtr) dlsym(hLibrary, "libmcenv_datacaptureoptions_setdoublequantization");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCaptureOptions_SetDoubleQuantization == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCaptureChunk_GetCapacity = (PLibMCEnvDataCaptureChunk_GetCapacityPtr) GetProcAddress(hLibrary, "libmcenv_datacapturechunk_getcapacity");
+		#else // _WIN32
+		pWrapperTable->m_DataCaptureChunk_GetCapacity = (PLibMCEnvDataCaptureChunk_GetCapacityPtr) dlsym(hLibrary, "libmcenv_datacapturechunk_getcapacity");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCaptureChunk_GetCapacity == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCaptureChunk_GetRowCount = (PLibMCEnvDataCaptureChunk_GetRowCountPtr) GetProcAddress(hLibrary, "libmcenv_datacapturechunk_getrowcount");
+		#else // _WIN32
+		pWrapperTable->m_DataCaptureChunk_GetRowCount = (PLibMCEnvDataCaptureChunk_GetRowCountPtr) dlsym(hLibrary, "libmcenv_datacapturechunk_getrowcount");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCaptureChunk_GetRowCount == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCaptureChunk_IsFull = (PLibMCEnvDataCaptureChunk_IsFullPtr) GetProcAddress(hLibrary, "libmcenv_datacapturechunk_isfull");
+		#else // _WIN32
+		pWrapperTable->m_DataCaptureChunk_IsFull = (PLibMCEnvDataCaptureChunk_IsFullPtr) dlsym(hLibrary, "libmcenv_datacapturechunk_isfull");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCaptureChunk_IsFull == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCaptureChunk_SetDoubleColumnValues = (PLibMCEnvDataCaptureChunk_SetDoubleColumnValuesPtr) GetProcAddress(hLibrary, "libmcenv_datacapturechunk_setdoublecolumnvalues");
+		#else // _WIN32
+		pWrapperTable->m_DataCaptureChunk_SetDoubleColumnValues = (PLibMCEnvDataCaptureChunk_SetDoubleColumnValuesPtr) dlsym(hLibrary, "libmcenv_datacapturechunk_setdoublecolumnvalues");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCaptureChunk_SetDoubleColumnValues == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCaptureChunk_SetInt32ColumnValues = (PLibMCEnvDataCaptureChunk_SetInt32ColumnValuesPtr) GetProcAddress(hLibrary, "libmcenv_datacapturechunk_setint32columnvalues");
+		#else // _WIN32
+		pWrapperTable->m_DataCaptureChunk_SetInt32ColumnValues = (PLibMCEnvDataCaptureChunk_SetInt32ColumnValuesPtr) dlsym(hLibrary, "libmcenv_datacapturechunk_setint32columnvalues");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCaptureChunk_SetInt32ColumnValues == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCaptureChunk_SetUint32ColumnValues = (PLibMCEnvDataCaptureChunk_SetUint32ColumnValuesPtr) GetProcAddress(hLibrary, "libmcenv_datacapturechunk_setuint32columnvalues");
+		#else // _WIN32
+		pWrapperTable->m_DataCaptureChunk_SetUint32ColumnValues = (PLibMCEnvDataCaptureChunk_SetUint32ColumnValuesPtr) dlsym(hLibrary, "libmcenv_datacapturechunk_setuint32columnvalues");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCaptureChunk_SetUint32ColumnValues == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCaptureChunk_SetInt64ColumnValues = (PLibMCEnvDataCaptureChunk_SetInt64ColumnValuesPtr) GetProcAddress(hLibrary, "libmcenv_datacapturechunk_setint64columnvalues");
+		#else // _WIN32
+		pWrapperTable->m_DataCaptureChunk_SetInt64ColumnValues = (PLibMCEnvDataCaptureChunk_SetInt64ColumnValuesPtr) dlsym(hLibrary, "libmcenv_datacapturechunk_setint64columnvalues");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCaptureChunk_SetInt64ColumnValues == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCaptureChunk_SetUint64ColumnValues = (PLibMCEnvDataCaptureChunk_SetUint64ColumnValuesPtr) GetProcAddress(hLibrary, "libmcenv_datacapturechunk_setuint64columnvalues");
+		#else // _WIN32
+		pWrapperTable->m_DataCaptureChunk_SetUint64ColumnValues = (PLibMCEnvDataCaptureChunk_SetUint64ColumnValuesPtr) dlsym(hLibrary, "libmcenv_datacapturechunk_setuint64columnvalues");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCaptureChunk_SetUint64ColumnValues == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCaptureChunk_SetFloatColumnValues = (PLibMCEnvDataCaptureChunk_SetFloatColumnValuesPtr) GetProcAddress(hLibrary, "libmcenv_datacapturechunk_setfloatcolumnvalues");
+		#else // _WIN32
+		pWrapperTable->m_DataCaptureChunk_SetFloatColumnValues = (PLibMCEnvDataCaptureChunk_SetFloatColumnValuesPtr) dlsym(hLibrary, "libmcenv_datacapturechunk_setfloatcolumnvalues");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCaptureChunk_SetFloatColumnValues == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCaptureChunk_SetBoolColumnValues = (PLibMCEnvDataCaptureChunk_SetBoolColumnValuesPtr) GetProcAddress(hLibrary, "libmcenv_datacapturechunk_setboolcolumnvalues");
+		#else // _WIN32
+		pWrapperTable->m_DataCaptureChunk_SetBoolColumnValues = (PLibMCEnvDataCaptureChunk_SetBoolColumnValuesPtr) dlsym(hLibrary, "libmcenv_datacapturechunk_setboolcolumnvalues");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCaptureChunk_SetBoolColumnValues == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCaptureChunk_SetTimestampColumnValues = (PLibMCEnvDataCaptureChunk_SetTimestampColumnValuesPtr) GetProcAddress(hLibrary, "libmcenv_datacapturechunk_settimestampcolumnvalues");
+		#else // _WIN32
+		pWrapperTable->m_DataCaptureChunk_SetTimestampColumnValues = (PLibMCEnvDataCaptureChunk_SetTimestampColumnValuesPtr) dlsym(hLibrary, "libmcenv_datacapturechunk_settimestampcolumnvalues");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCaptureChunk_SetTimestampColumnValues == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCaptureChunk_BeginRow = (PLibMCEnvDataCaptureChunk_BeginRowPtr) GetProcAddress(hLibrary, "libmcenv_datacapturechunk_beginrow");
+		#else // _WIN32
+		pWrapperTable->m_DataCaptureChunk_BeginRow = (PLibMCEnvDataCaptureChunk_BeginRowPtr) dlsym(hLibrary, "libmcenv_datacapturechunk_beginrow");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCaptureChunk_BeginRow == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCaptureChunk_SetRowDoubleValue = (PLibMCEnvDataCaptureChunk_SetRowDoubleValuePtr) GetProcAddress(hLibrary, "libmcenv_datacapturechunk_setrowdoublevalue");
+		#else // _WIN32
+		pWrapperTable->m_DataCaptureChunk_SetRowDoubleValue = (PLibMCEnvDataCaptureChunk_SetRowDoubleValuePtr) dlsym(hLibrary, "libmcenv_datacapturechunk_setrowdoublevalue");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCaptureChunk_SetRowDoubleValue == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCaptureChunk_SetRowIntegerValue = (PLibMCEnvDataCaptureChunk_SetRowIntegerValuePtr) GetProcAddress(hLibrary, "libmcenv_datacapturechunk_setrowintegervalue");
+		#else // _WIN32
+		pWrapperTable->m_DataCaptureChunk_SetRowIntegerValue = (PLibMCEnvDataCaptureChunk_SetRowIntegerValuePtr) dlsym(hLibrary, "libmcenv_datacapturechunk_setrowintegervalue");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCaptureChunk_SetRowIntegerValue == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCaptureChunk_EndRow = (PLibMCEnvDataCaptureChunk_EndRowPtr) GetProcAddress(hLibrary, "libmcenv_datacapturechunk_endrow");
+		#else // _WIN32
+		pWrapperTable->m_DataCaptureChunk_EndRow = (PLibMCEnvDataCaptureChunk_EndRowPtr) dlsym(hLibrary, "libmcenv_datacapturechunk_endrow");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCaptureChunk_EndRow == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCapture_GetUUID = (PLibMCEnvDataCapture_GetUUIDPtr) GetProcAddress(hLibrary, "libmcenv_datacapture_getuuid");
+		#else // _WIN32
+		pWrapperTable->m_DataCapture_GetUUID = (PLibMCEnvDataCapture_GetUUIDPtr) dlsym(hLibrary, "libmcenv_datacapture_getuuid");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCapture_GetUUID == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCapture_GetIdentifier = (PLibMCEnvDataCapture_GetIdentifierPtr) GetProcAddress(hLibrary, "libmcenv_datacapture_getidentifier");
+		#else // _WIN32
+		pWrapperTable->m_DataCapture_GetIdentifier = (PLibMCEnvDataCapture_GetIdentifierPtr) dlsym(hLibrary, "libmcenv_datacapture_getidentifier");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCapture_GetIdentifier == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCapture_GetName = (PLibMCEnvDataCapture_GetNamePtr) GetProcAddress(hLibrary, "libmcenv_datacapture_getname");
+		#else // _WIN32
+		pWrapperTable->m_DataCapture_GetName = (PLibMCEnvDataCapture_GetNamePtr) dlsym(hLibrary, "libmcenv_datacapture_getname");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCapture_GetName == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCapture_GetStatus = (PLibMCEnvDataCapture_GetStatusPtr) GetProcAddress(hLibrary, "libmcenv_datacapture_getstatus");
+		#else // _WIN32
+		pWrapperTable->m_DataCapture_GetStatus = (PLibMCEnvDataCapture_GetStatusPtr) dlsym(hLibrary, "libmcenv_datacapture_getstatus");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCapture_GetStatus == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCapture_AddColumn = (PLibMCEnvDataCapture_AddColumnPtr) GetProcAddress(hLibrary, "libmcenv_datacapture_addcolumn");
+		#else // _WIN32
+		pWrapperTable->m_DataCapture_AddColumn = (PLibMCEnvDataCapture_AddColumnPtr) dlsym(hLibrary, "libmcenv_datacapture_addcolumn");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCapture_AddColumn == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCapture_GetColumnCount = (PLibMCEnvDataCapture_GetColumnCountPtr) GetProcAddress(hLibrary, "libmcenv_datacapture_getcolumncount");
+		#else // _WIN32
+		pWrapperTable->m_DataCapture_GetColumnCount = (PLibMCEnvDataCapture_GetColumnCountPtr) dlsym(hLibrary, "libmcenv_datacapture_getcolumncount");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCapture_GetColumnCount == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCapture_BeginChunk = (PLibMCEnvDataCapture_BeginChunkPtr) GetProcAddress(hLibrary, "libmcenv_datacapture_beginchunk");
+		#else // _WIN32
+		pWrapperTable->m_DataCapture_BeginChunk = (PLibMCEnvDataCapture_BeginChunkPtr) dlsym(hLibrary, "libmcenv_datacapture_beginchunk");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCapture_BeginChunk == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCapture_CommitChunk = (PLibMCEnvDataCapture_CommitChunkPtr) GetProcAddress(hLibrary, "libmcenv_datacapture_commitchunk");
+		#else // _WIN32
+		pWrapperTable->m_DataCapture_CommitChunk = (PLibMCEnvDataCapture_CommitChunkPtr) dlsym(hLibrary, "libmcenv_datacapture_commitchunk");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCapture_CommitChunk == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCapture_Flush = (PLibMCEnvDataCapture_FlushPtr) GetProcAddress(hLibrary, "libmcenv_datacapture_flush");
+		#else // _WIN32
+		pWrapperTable->m_DataCapture_Flush = (PLibMCEnvDataCapture_FlushPtr) dlsym(hLibrary, "libmcenv_datacapture_flush");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCapture_Flush == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCapture_GetCapturedRowCount = (PLibMCEnvDataCapture_GetCapturedRowCountPtr) GetProcAddress(hLibrary, "libmcenv_datacapture_getcapturedrowcount");
+		#else // _WIN32
+		pWrapperTable->m_DataCapture_GetCapturedRowCount = (PLibMCEnvDataCapture_GetCapturedRowCountPtr) dlsym(hLibrary, "libmcenv_datacapture_getcapturedrowcount");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCapture_GetCapturedRowCount == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCapture_GetStorageSizeInBytes = (PLibMCEnvDataCapture_GetStorageSizeInBytesPtr) GetProcAddress(hLibrary, "libmcenv_datacapture_getstoragesizeinbytes");
+		#else // _WIN32
+		pWrapperTable->m_DataCapture_GetStorageSizeInBytes = (PLibMCEnvDataCapture_GetStorageSizeInBytesPtr) dlsym(hLibrary, "libmcenv_datacapture_getstoragesizeinbytes");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCapture_GetStorageSizeInBytes == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCapture_GetSegmentCount = (PLibMCEnvDataCapture_GetSegmentCountPtr) GetProcAddress(hLibrary, "libmcenv_datacapture_getsegmentcount");
+		#else // _WIN32
+		pWrapperTable->m_DataCapture_GetSegmentCount = (PLibMCEnvDataCapture_GetSegmentCountPtr) dlsym(hLibrary, "libmcenv_datacapture_getsegmentcount");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCapture_GetSegmentCount == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCapture_GetQueuedChunkCount = (PLibMCEnvDataCapture_GetQueuedChunkCountPtr) GetProcAddress(hLibrary, "libmcenv_datacapture_getqueuedchunkcount");
+		#else // _WIN32
+		pWrapperTable->m_DataCapture_GetQueuedChunkCount = (PLibMCEnvDataCapture_GetQueuedChunkCountPtr) dlsym(hLibrary, "libmcenv_datacapture_getqueuedchunkcount");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCapture_GetQueuedChunkCount == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCapture_GetDroppedRowCount = (PLibMCEnvDataCapture_GetDroppedRowCountPtr) GetProcAddress(hLibrary, "libmcenv_datacapture_getdroppedrowcount");
+		#else // _WIN32
+		pWrapperTable->m_DataCapture_GetDroppedRowCount = (PLibMCEnvDataCapture_GetDroppedRowCountPtr) dlsym(hLibrary, "libmcenv_datacapture_getdroppedrowcount");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCapture_GetDroppedRowCount == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCapture_Finish = (PLibMCEnvDataCapture_FinishPtr) GetProcAddress(hLibrary, "libmcenv_datacapture_finish");
+		#else // _WIN32
+		pWrapperTable->m_DataCapture_Finish = (PLibMCEnvDataCapture_FinishPtr) dlsym(hLibrary, "libmcenv_datacapture_finish");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCapture_Finish == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCapture_Abort = (PLibMCEnvDataCapture_AbortPtr) GetProcAddress(hLibrary, "libmcenv_datacapture_abort");
+		#else // _WIN32
+		pWrapperTable->m_DataCapture_Abort = (PLibMCEnvDataCapture_AbortPtr) dlsym(hLibrary, "libmcenv_datacapture_abort");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCapture_Abort == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCapture_AddColumnsFromDataTable = (PLibMCEnvDataCapture_AddColumnsFromDataTablePtr) GetProcAddress(hLibrary, "libmcenv_datacapture_addcolumnsfromdatatable");
+		#else // _WIN32
+		pWrapperTable->m_DataCapture_AddColumnsFromDataTable = (PLibMCEnvDataCapture_AddColumnsFromDataTablePtr) dlsym(hLibrary, "libmcenv_datacapture_addcolumnsfromdatatable");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCapture_AddColumnsFromDataTable == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataCapture_AppendDataTable = (PLibMCEnvDataCapture_AppendDataTablePtr) GetProcAddress(hLibrary, "libmcenv_datacapture_appenddatatable");
+		#else // _WIN32
+		pWrapperTable->m_DataCapture_AppendDataTable = (PLibMCEnvDataCapture_AppendDataTablePtr) dlsym(hLibrary, "libmcenv_datacapture_appenddatatable");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataCapture_AppendDataTable == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataTableReader_GetRowCount = (PLibMCEnvDataTableReader_GetRowCountPtr) GetProcAddress(hLibrary, "libmcenv_datatablereader_getrowcount");
+		#else // _WIN32
+		pWrapperTable->m_DataTableReader_GetRowCount = (PLibMCEnvDataTableReader_GetRowCountPtr) dlsym(hLibrary, "libmcenv_datatablereader_getrowcount");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataTableReader_GetRowCount == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataTableReader_GetFirstAvailableRow = (PLibMCEnvDataTableReader_GetFirstAvailableRowPtr) GetProcAddress(hLibrary, "libmcenv_datatablereader_getfirstavailablerow");
+		#else // _WIN32
+		pWrapperTable->m_DataTableReader_GetFirstAvailableRow = (PLibMCEnvDataTableReader_GetFirstAvailableRowPtr) dlsym(hLibrary, "libmcenv_datatablereader_getfirstavailablerow");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataTableReader_GetFirstAvailableRow == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataTableReader_GetColumnCount = (PLibMCEnvDataTableReader_GetColumnCountPtr) GetProcAddress(hLibrary, "libmcenv_datatablereader_getcolumncount");
+		#else // _WIN32
+		pWrapperTable->m_DataTableReader_GetColumnCount = (PLibMCEnvDataTableReader_GetColumnCountPtr) dlsym(hLibrary, "libmcenv_datatablereader_getcolumncount");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataTableReader_GetColumnCount == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataTableReader_HasColumn = (PLibMCEnvDataTableReader_HasColumnPtr) GetProcAddress(hLibrary, "libmcenv_datatablereader_hascolumn");
+		#else // _WIN32
+		pWrapperTable->m_DataTableReader_HasColumn = (PLibMCEnvDataTableReader_HasColumnPtr) dlsym(hLibrary, "libmcenv_datatablereader_hascolumn");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataTableReader_HasColumn == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataTableReader_GetColumnInformation = (PLibMCEnvDataTableReader_GetColumnInformationPtr) GetProcAddress(hLibrary, "libmcenv_datatablereader_getcolumninformation");
+		#else // _WIN32
+		pWrapperTable->m_DataTableReader_GetColumnInformation = (PLibMCEnvDataTableReader_GetColumnInformationPtr) dlsym(hLibrary, "libmcenv_datatablereader_getcolumninformation");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataTableReader_GetColumnInformation == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataTableReader_GetColumnQuantization = (PLibMCEnvDataTableReader_GetColumnQuantizationPtr) GetProcAddress(hLibrary, "libmcenv_datatablereader_getcolumnquantization");
+		#else // _WIN32
+		pWrapperTable->m_DataTableReader_GetColumnQuantization = (PLibMCEnvDataTableReader_GetColumnQuantizationPtr) dlsym(hLibrary, "libmcenv_datatablereader_getcolumnquantization");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataTableReader_GetColumnQuantization == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataTableReader_GetSegmentCount = (PLibMCEnvDataTableReader_GetSegmentCountPtr) GetProcAddress(hLibrary, "libmcenv_datatablereader_getsegmentcount");
+		#else // _WIN32
+		pWrapperTable->m_DataTableReader_GetSegmentCount = (PLibMCEnvDataTableReader_GetSegmentCountPtr) dlsym(hLibrary, "libmcenv_datatablereader_getsegmentcount");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataTableReader_GetSegmentCount == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataTableReader_GetSegmentInformation = (PLibMCEnvDataTableReader_GetSegmentInformationPtr) GetProcAddress(hLibrary, "libmcenv_datatablereader_getsegmentinformation");
+		#else // _WIN32
+		pWrapperTable->m_DataTableReader_GetSegmentInformation = (PLibMCEnvDataTableReader_GetSegmentInformationPtr) dlsym(hLibrary, "libmcenv_datatablereader_getsegmentinformation");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataTableReader_GetSegmentInformation == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataTableReader_GetChunkCount = (PLibMCEnvDataTableReader_GetChunkCountPtr) GetProcAddress(hLibrary, "libmcenv_datatablereader_getchunkcount");
+		#else // _WIN32
+		pWrapperTable->m_DataTableReader_GetChunkCount = (PLibMCEnvDataTableReader_GetChunkCountPtr) dlsym(hLibrary, "libmcenv_datatablereader_getchunkcount");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataTableReader_GetChunkCount == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataTableReader_GetChunkInformation = (PLibMCEnvDataTableReader_GetChunkInformationPtr) GetProcAddress(hLibrary, "libmcenv_datatablereader_getchunkinformation");
+		#else // _WIN32
+		pWrapperTable->m_DataTableReader_GetChunkInformation = (PLibMCEnvDataTableReader_GetChunkInformationPtr) dlsym(hLibrary, "libmcenv_datatablereader_getchunkinformation");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataTableReader_GetChunkInformation == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataTableReader_GetChunkStatistics = (PLibMCEnvDataTableReader_GetChunkStatisticsPtr) GetProcAddress(hLibrary, "libmcenv_datatablereader_getchunkstatistics");
+		#else // _WIN32
+		pWrapperTable->m_DataTableReader_GetChunkStatistics = (PLibMCEnvDataTableReader_GetChunkStatisticsPtr) dlsym(hLibrary, "libmcenv_datatablereader_getchunkstatistics");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataTableReader_GetChunkStatistics == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataTableReader_ReadDoubleColumnRange = (PLibMCEnvDataTableReader_ReadDoubleColumnRangePtr) GetProcAddress(hLibrary, "libmcenv_datatablereader_readdoublecolumnrange");
+		#else // _WIN32
+		pWrapperTable->m_DataTableReader_ReadDoubleColumnRange = (PLibMCEnvDataTableReader_ReadDoubleColumnRangePtr) dlsym(hLibrary, "libmcenv_datatablereader_readdoublecolumnrange");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataTableReader_ReadDoubleColumnRange == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataTableReader_ReadFloatColumnRange = (PLibMCEnvDataTableReader_ReadFloatColumnRangePtr) GetProcAddress(hLibrary, "libmcenv_datatablereader_readfloatcolumnrange");
+		#else // _WIN32
+		pWrapperTable->m_DataTableReader_ReadFloatColumnRange = (PLibMCEnvDataTableReader_ReadFloatColumnRangePtr) dlsym(hLibrary, "libmcenv_datatablereader_readfloatcolumnrange");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataTableReader_ReadFloatColumnRange == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataTableReader_ReadInt64ColumnRange = (PLibMCEnvDataTableReader_ReadInt64ColumnRangePtr) GetProcAddress(hLibrary, "libmcenv_datatablereader_readint64columnrange");
+		#else // _WIN32
+		pWrapperTable->m_DataTableReader_ReadInt64ColumnRange = (PLibMCEnvDataTableReader_ReadInt64ColumnRangePtr) dlsym(hLibrary, "libmcenv_datatablereader_readint64columnrange");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataTableReader_ReadInt64ColumnRange == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataTableReader_ReadBoolColumnRange = (PLibMCEnvDataTableReader_ReadBoolColumnRangePtr) GetProcAddress(hLibrary, "libmcenv_datatablereader_readboolcolumnrange");
+		#else // _WIN32
+		pWrapperTable->m_DataTableReader_ReadBoolColumnRange = (PLibMCEnvDataTableReader_ReadBoolColumnRangePtr) dlsym(hLibrary, "libmcenv_datatablereader_readboolcolumnrange");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataTableReader_ReadBoolColumnRange == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataTableReader_ReadColumnDownsampled = (PLibMCEnvDataTableReader_ReadColumnDownsampledPtr) GetProcAddress(hLibrary, "libmcenv_datatablereader_readcolumndownsampled");
+		#else // _WIN32
+		pWrapperTable->m_DataTableReader_ReadColumnDownsampled = (PLibMCEnvDataTableReader_ReadColumnDownsampledPtr) dlsym(hLibrary, "libmcenv_datatablereader_readcolumndownsampled");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataTableReader_ReadColumnDownsampled == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataTableReader_FindChunksInValueRange = (PLibMCEnvDataTableReader_FindChunksInValueRangePtr) GetProcAddress(hLibrary, "libmcenv_datatablereader_findchunksinvaluerange");
+		#else // _WIN32
+		pWrapperTable->m_DataTableReader_FindChunksInValueRange = (PLibMCEnvDataTableReader_FindChunksInValueRangePtr) dlsym(hLibrary, "libmcenv_datatablereader_findchunksinvaluerange");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataTableReader_FindChunksInValueRange == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_DataTableReader_ExtractDataTable = (PLibMCEnvDataTableReader_ExtractDataTablePtr) GetProcAddress(hLibrary, "libmcenv_datatablereader_extractdatatable");
+		#else // _WIN32
+		pWrapperTable->m_DataTableReader_ExtractDataTable = (PLibMCEnvDataTableReader_ExtractDataTablePtr) dlsym(hLibrary, "libmcenv_datatablereader_extractdatatable");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_DataTableReader_ExtractDataTable == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
 		#ifdef _WIN32
 		pWrapperTable->m_DataSeries_GetName = (PLibMCEnvDataSeries_GetNamePtr) GetProcAddress(hLibrary, "libmcenv_dataseries_getname");
 		#else // _WIN32
@@ -8854,6 +9830,69 @@ class CUIEnvironment : public CBase {
 		if (pWrapperTable->m_BuildExecution_LoadAttachedJournal == nullptr)
 			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
+		#ifdef _WIN32
+		pWrapperTable->m_BuildExecution_CreateDataCaptureOptions = (PLibMCEnvBuildExecution_CreateDataCaptureOptionsPtr) GetProcAddress(hLibrary, "libmcenv_buildexecution_createdatacaptureoptions");
+		#else // _WIN32
+		pWrapperTable->m_BuildExecution_CreateDataCaptureOptions = (PLibMCEnvBuildExecution_CreateDataCaptureOptionsPtr) dlsym(hLibrary, "libmcenv_buildexecution_createdatacaptureoptions");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_BuildExecution_CreateDataCaptureOptions == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_BuildExecution_CreateDataCapture = (PLibMCEnvBuildExecution_CreateDataCapturePtr) GetProcAddress(hLibrary, "libmcenv_buildexecution_createdatacapture");
+		#else // _WIN32
+		pWrapperTable->m_BuildExecution_CreateDataCapture = (PLibMCEnvBuildExecution_CreateDataCapturePtr) dlsym(hLibrary, "libmcenv_buildexecution_createdatacapture");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_BuildExecution_CreateDataCapture == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_BuildExecution_HasDataCapture = (PLibMCEnvBuildExecution_HasDataCapturePtr) GetProcAddress(hLibrary, "libmcenv_buildexecution_hasdatacapture");
+		#else // _WIN32
+		pWrapperTable->m_BuildExecution_HasDataCapture = (PLibMCEnvBuildExecution_HasDataCapturePtr) dlsym(hLibrary, "libmcenv_buildexecution_hasdatacapture");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_BuildExecution_HasDataCapture == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_BuildExecution_GetDataCaptureRowCount = (PLibMCEnvBuildExecution_GetDataCaptureRowCountPtr) GetProcAddress(hLibrary, "libmcenv_buildexecution_getdatacapturerowcount");
+		#else // _WIN32
+		pWrapperTable->m_BuildExecution_GetDataCaptureRowCount = (PLibMCEnvBuildExecution_GetDataCaptureRowCountPtr) dlsym(hLibrary, "libmcenv_buildexecution_getdatacapturerowcount");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_BuildExecution_GetDataCaptureRowCount == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_BuildExecution_GetDataCaptureSegmentCount = (PLibMCEnvBuildExecution_GetDataCaptureSegmentCountPtr) GetProcAddress(hLibrary, "libmcenv_buildexecution_getdatacapturesegmentcount");
+		#else // _WIN32
+		pWrapperTable->m_BuildExecution_GetDataCaptureSegmentCount = (PLibMCEnvBuildExecution_GetDataCaptureSegmentCountPtr) dlsym(hLibrary, "libmcenv_buildexecution_getdatacapturesegmentcount");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_BuildExecution_GetDataCaptureSegmentCount == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_BuildExecution_LoadDataCaptureSegment = (PLibMCEnvBuildExecution_LoadDataCaptureSegmentPtr) GetProcAddress(hLibrary, "libmcenv_buildexecution_loaddatacapturesegment");
+		#else // _WIN32
+		pWrapperTable->m_BuildExecution_LoadDataCaptureSegment = (PLibMCEnvBuildExecution_LoadDataCaptureSegmentPtr) dlsym(hLibrary, "libmcenv_buildexecution_loaddatacapturesegment");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_BuildExecution_LoadDataCaptureSegment == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_BuildExecution_OpenDataCaptureReader = (PLibMCEnvBuildExecution_OpenDataCaptureReaderPtr) GetProcAddress(hLibrary, "libmcenv_buildexecution_opendatacapturereader");
+		#else // _WIN32
+		pWrapperTable->m_BuildExecution_OpenDataCaptureReader = (PLibMCEnvBuildExecution_OpenDataCaptureReaderPtr) dlsym(hLibrary, "libmcenv_buildexecution_opendatacapturereader");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_BuildExecution_OpenDataCaptureReader == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
 		#ifdef _WIN32
 		pWrapperTable->m_BuildExecutionIterator_GetCurrentExecution = (PLibMCEnvBuildExecutionIterator_GetCurrentExecutionPtr) GetProcAddress(hLibrary, "libmcenv_buildexecutioniterator_getcurrentexecution");
 		#else // _WIN32
@@ -12085,6 +13124,15 @@ class CUIEnvironment : public CBase {
 		if (pWrapperTable->m_ZIPStreamWriter_CreateZIPEntryFromStream == nullptr)
 			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
+		#ifdef _WIN32
+		pWrapperTable->m_ZIPStreamWriter_Discard = (PLibMCEnvZIPStreamWriter_DiscardPtr) GetProcAddress(hLibrary, "libmcenv_zipstreamwriter_discard");
+		#else // _WIN32
+		pWrapperTable->m_ZIPStreamWriter_Discard = (PLibMCEnvZIPStreamWriter_DiscardPtr) dlsym(hLibrary, "libmcenv_zipstreamwriter_discard");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_ZIPStreamWriter_Discard == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
 		#ifdef _WIN32
 		pWrapperTable->m_StreamReader_GetUUID = (PLibMCEnvStreamReader_GetUUIDPtr) GetProcAddress(hLibrary, "libmcenv_streamreader_getuuid");
 		#else // _WIN32
@@ -14704,6 +15752,51 @@ class CUIEnvironment : public CBase {
 		if (pWrapperTable->m_StateEnvironment_EvaluateFormulaAsBool == nullptr)
 			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
+		#ifdef _WIN32
+		pWrapperTable->m_StateEnvironment_StartStreamDownloadForSession = (PLibMCEnvStateEnvironment_StartStreamDownloadForSessionPtr) GetProcAddress(hLibrary, "libmcenv_stateenvironment_startstreamdownloadforsession");
+		#else // _WIN32
+		pWrapperTable->m_StateEnvironment_StartStreamDownloadForSession = (PLibMCEnvStateEnvironment_StartStreamDownloadForSessionPtr) dlsym(hLibrary, "libmcenv_stateenvironment_startstreamdownloadforsession");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_StateEnvironment_StartStreamDownloadForSession == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_StateEnvironment_GetStreamDownloadProgress = (PLibMCEnvStateEnvironment_GetStreamDownloadProgressPtr) GetProcAddress(hLibrary, "libmcenv_stateenvironment_getstreamdownloadprogress");
+		#else // _WIN32
+		pWrapperTable->m_StateEnvironment_GetStreamDownloadProgress = (PLibMCEnvStateEnvironment_GetStreamDownloadProgressPtr) dlsym(hLibrary, "libmcenv_stateenvironment_getstreamdownloadprogress");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_StateEnvironment_GetStreamDownloadProgress == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_StateEnvironment_CancelStreamDownloads = (PLibMCEnvStateEnvironment_CancelStreamDownloadsPtr) GetProcAddress(hLibrary, "libmcenv_stateenvironment_cancelstreamdownloads");
+		#else // _WIN32
+		pWrapperTable->m_StateEnvironment_CancelStreamDownloads = (PLibMCEnvStateEnvironment_CancelStreamDownloadsPtr) dlsym(hLibrary, "libmcenv_stateenvironment_cancelstreamdownloads");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_StateEnvironment_CancelStreamDownloads == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_StateEnvironment_DeleteStorageStream = (PLibMCEnvStateEnvironment_DeleteStorageStreamPtr) GetProcAddress(hLibrary, "libmcenv_stateenvironment_deletestoragestream");
+		#else // _WIN32
+		pWrapperTable->m_StateEnvironment_DeleteStorageStream = (PLibMCEnvStateEnvironment_DeleteStorageStreamPtr) dlsym(hLibrary, "libmcenv_stateenvironment_deletestoragestream");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_StateEnvironment_DeleteStorageStream == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		#ifdef _WIN32
+		pWrapperTable->m_StateEnvironment_EnforceStreamRetention = (PLibMCEnvStateEnvironment_EnforceStreamRetentionPtr) GetProcAddress(hLibrary, "libmcenv_stateenvironment_enforcestreamretention");
+		#else // _WIN32
+		pWrapperTable->m_StateEnvironment_EnforceStreamRetention = (PLibMCEnvStateEnvironment_EnforceStreamRetentionPtr) dlsym(hLibrary, "libmcenv_stateenvironment_enforcestreamretention");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_StateEnvironment_EnforceStreamRetention == nullptr)
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
 		#ifdef _WIN32
 		pWrapperTable->m_UIItem_GetName = (PLibMCEnvUIItem_GetNamePtr) GetProcAddress(hLibrary, "libmcenv_uiitem_getname");
 		#else // _WIN32
@@ -16312,6 +17405,10 @@ class CUIEnvironment : public CBase {
 		if ( (eLookupError != 0) || (pWrapperTable->m_DataTable_GetRowCount == nullptr) )
 			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
+		eLookupError = (*pLookup)("libmcenv_datatable_getrowcount64", (void**)&(pWrapperTable->m_DataTable_GetRowCount64));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataTable_GetRowCount64 == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
 		eLookupError = (*pLookup)("libmcenv_datatable_getcolumncount", (void**)&(pWrapperTable->m_DataTable_GetColumnCount));
 		if ( (eLookupError != 0) || (pWrapperTable->m_DataTable_GetColumnCount == nullptr) )
 			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
@@ -16352,6 +17449,18 @@ class CUIEnvironment : public CBase {
 		if ( (eLookupError != 0) || (pWrapperTable->m_DataTable_GetUint64ColumnValues == nullptr) )
 			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
+		eLookupError = (*pLookup)("libmcenv_datatable_getfloatcolumnvalues", (void**)&(pWrapperTable->m_DataTable_GetFloatColumnValues));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataTable_GetFloatColumnValues == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datatable_getboolcolumnvalues", (void**)&(pWrapperTable->m_DataTable_GetBoolColumnValues));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataTable_GetBoolColumnValues == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datatable_gettimestampcolumnvalues", (void**)&(pWrapperTable->m_DataTable_GetTimestampColumnValues));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataTable_GetTimestampColumnValues == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
 		eLookupError = (*pLookup)("libmcenv_datatable_setdoublecolumnvalues", (void**)&(pWrapperTable->m_DataTable_SetDoubleColumnValues));
 		if ( (eLookupError != 0) || (pWrapperTable->m_DataTable_SetDoubleColumnValues == nullptr) )
 			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
@@ -16372,6 +17481,18 @@ class CUIEnvironment : public CBase {
 		if ( (eLookupError != 0) || (pWrapperTable->m_DataTable_SetUint64ColumnValues == nullptr) )
 			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
+		eLookupError = (*pLookup)("libmcenv_datatable_setfloatcolumnvalues", (void**)&(pWrapperTable->m_DataTable_SetFloatColumnValues));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataTable_SetFloatColumnValues == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datatable_setboolcolumnvalues", (void**)&(pWrapperTable->m_DataTable_SetBoolColumnValues));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataTable_SetBoolColumnValues == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datatable_settimestampcolumnvalues", (void**)&(pWrapperTable->m_DataTable_SetTimestampColumnValues));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataTable_SetTimestampColumnValues == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
 		eLookupError = (*pLookup)("libmcenv_datatable_createwriteoptions", (void**)&(pWrapperTable->m_DataTable_CreateWriteOptions));
 		if ( (eLookupError != 0) || (pWrapperTable->m_DataTable_CreateWriteOptions == nullptr) )
 			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
@@ -16400,6 +17521,266 @@ class CUIEnvironment : public CBase {
 		if ( (eLookupError != 0) || (pWrapperTable->m_DataTable_CalculateScatterPlot == nullptr) )
 			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
+		eLookupError = (*pLookup)("libmcenv_datacaptureoptions_setchunkrowcount", (void**)&(pWrapperTable->m_DataCaptureOptions_SetChunkRowCount));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCaptureOptions_SetChunkRowCount == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacaptureoptions_getchunkrowcount", (void**)&(pWrapperTable->m_DataCaptureOptions_GetChunkRowCount));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCaptureOptions_GetChunkRowCount == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacaptureoptions_setsegmentsizeinbytes", (void**)&(pWrapperTable->m_DataCaptureOptions_SetSegmentSizeInBytes));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCaptureOptions_SetSegmentSizeInBytes == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacaptureoptions_getsegmentsizeinbytes", (void**)&(pWrapperTable->m_DataCaptureOptions_GetSegmentSizeInBytes));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCaptureOptions_GetSegmentSizeInBytes == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacaptureoptions_setmaxqueuedchunks", (void**)&(pWrapperTable->m_DataCaptureOptions_SetMaxQueuedChunks));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCaptureOptions_SetMaxQueuedChunks == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacaptureoptions_getmaxqueuedchunks", (void**)&(pWrapperTable->m_DataCaptureOptions_GetMaxQueuedChunks));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCaptureOptions_GetMaxQueuedChunks == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacaptureoptions_setbackpressuremode", (void**)&(pWrapperTable->m_DataCaptureOptions_SetBackpressureMode));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCaptureOptions_SetBackpressureMode == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacaptureoptions_getbackpressuremode", (void**)&(pWrapperTable->m_DataCaptureOptions_GetBackpressureMode));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCaptureOptions_GetBackpressureMode == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacaptureoptions_setstoragelimitinbytes", (void**)&(pWrapperTable->m_DataCaptureOptions_SetStorageLimitInBytes));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCaptureOptions_SetStorageLimitInBytes == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacaptureoptions_getstoragelimitinbytes", (void**)&(pWrapperTable->m_DataCaptureOptions_GetStorageLimitInBytes));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCaptureOptions_GetStorageLimitInBytes == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacaptureoptions_setcompression", (void**)&(pWrapperTable->m_DataCaptureOptions_SetCompression));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCaptureOptions_SetCompression == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacaptureoptions_getcompression", (void**)&(pWrapperTable->m_DataCaptureOptions_GetCompression));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCaptureOptions_GetCompression == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacaptureoptions_setcolumnencoding", (void**)&(pWrapperTable->m_DataCaptureOptions_SetColumnEncoding));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCaptureOptions_SetColumnEncoding == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacaptureoptions_setdoublequantization", (void**)&(pWrapperTable->m_DataCaptureOptions_SetDoubleQuantization));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCaptureOptions_SetDoubleQuantization == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacapturechunk_getcapacity", (void**)&(pWrapperTable->m_DataCaptureChunk_GetCapacity));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCaptureChunk_GetCapacity == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacapturechunk_getrowcount", (void**)&(pWrapperTable->m_DataCaptureChunk_GetRowCount));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCaptureChunk_GetRowCount == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacapturechunk_isfull", (void**)&(pWrapperTable->m_DataCaptureChunk_IsFull));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCaptureChunk_IsFull == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacapturechunk_setdoublecolumnvalues", (void**)&(pWrapperTable->m_DataCaptureChunk_SetDoubleColumnValues));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCaptureChunk_SetDoubleColumnValues == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacapturechunk_setint32columnvalues", (void**)&(pWrapperTable->m_DataCaptureChunk_SetInt32ColumnValues));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCaptureChunk_SetInt32ColumnValues == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacapturechunk_setuint32columnvalues", (void**)&(pWrapperTable->m_DataCaptureChunk_SetUint32ColumnValues));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCaptureChunk_SetUint32ColumnValues == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacapturechunk_setint64columnvalues", (void**)&(pWrapperTable->m_DataCaptureChunk_SetInt64ColumnValues));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCaptureChunk_SetInt64ColumnValues == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacapturechunk_setuint64columnvalues", (void**)&(pWrapperTable->m_DataCaptureChunk_SetUint64ColumnValues));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCaptureChunk_SetUint64ColumnValues == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacapturechunk_setfloatcolumnvalues", (void**)&(pWrapperTable->m_DataCaptureChunk_SetFloatColumnValues));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCaptureChunk_SetFloatColumnValues == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacapturechunk_setboolcolumnvalues", (void**)&(pWrapperTable->m_DataCaptureChunk_SetBoolColumnValues));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCaptureChunk_SetBoolColumnValues == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacapturechunk_settimestampcolumnvalues", (void**)&(pWrapperTable->m_DataCaptureChunk_SetTimestampColumnValues));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCaptureChunk_SetTimestampColumnValues == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacapturechunk_beginrow", (void**)&(pWrapperTable->m_DataCaptureChunk_BeginRow));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCaptureChunk_BeginRow == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacapturechunk_setrowdoublevalue", (void**)&(pWrapperTable->m_DataCaptureChunk_SetRowDoubleValue));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCaptureChunk_SetRowDoubleValue == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacapturechunk_setrowintegervalue", (void**)&(pWrapperTable->m_DataCaptureChunk_SetRowIntegerValue));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCaptureChunk_SetRowIntegerValue == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacapturechunk_endrow", (void**)&(pWrapperTable->m_DataCaptureChunk_EndRow));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCaptureChunk_EndRow == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacapture_getuuid", (void**)&(pWrapperTable->m_DataCapture_GetUUID));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCapture_GetUUID == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacapture_getidentifier", (void**)&(pWrapperTable->m_DataCapture_GetIdentifier));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCapture_GetIdentifier == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacapture_getname", (void**)&(pWrapperTable->m_DataCapture_GetName));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCapture_GetName == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacapture_getstatus", (void**)&(pWrapperTable->m_DataCapture_GetStatus));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCapture_GetStatus == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacapture_addcolumn", (void**)&(pWrapperTable->m_DataCapture_AddColumn));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCapture_AddColumn == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacapture_getcolumncount", (void**)&(pWrapperTable->m_DataCapture_GetColumnCount));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCapture_GetColumnCount == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacapture_beginchunk", (void**)&(pWrapperTable->m_DataCapture_BeginChunk));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCapture_BeginChunk == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacapture_commitchunk", (void**)&(pWrapperTable->m_DataCapture_CommitChunk));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCapture_CommitChunk == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacapture_flush", (void**)&(pWrapperTable->m_DataCapture_Flush));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCapture_Flush == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacapture_getcapturedrowcount", (void**)&(pWrapperTable->m_DataCapture_GetCapturedRowCount));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCapture_GetCapturedRowCount == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacapture_getstoragesizeinbytes", (void**)&(pWrapperTable->m_DataCapture_GetStorageSizeInBytes));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCapture_GetStorageSizeInBytes == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacapture_getsegmentcount", (void**)&(pWrapperTable->m_DataCapture_GetSegmentCount));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCapture_GetSegmentCount == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacapture_getqueuedchunkcount", (void**)&(pWrapperTable->m_DataCapture_GetQueuedChunkCount));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCapture_GetQueuedChunkCount == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacapture_getdroppedrowcount", (void**)&(pWrapperTable->m_DataCapture_GetDroppedRowCount));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCapture_GetDroppedRowCount == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacapture_finish", (void**)&(pWrapperTable->m_DataCapture_Finish));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCapture_Finish == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacapture_abort", (void**)&(pWrapperTable->m_DataCapture_Abort));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCapture_Abort == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacapture_addcolumnsfromdatatable", (void**)&(pWrapperTable->m_DataCapture_AddColumnsFromDataTable));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCapture_AddColumnsFromDataTable == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datacapture_appenddatatable", (void**)&(pWrapperTable->m_DataCapture_AppendDataTable));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataCapture_AppendDataTable == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datatablereader_getrowcount", (void**)&(pWrapperTable->m_DataTableReader_GetRowCount));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataTableReader_GetRowCount == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datatablereader_getfirstavailablerow", (void**)&(pWrapperTable->m_DataTableReader_GetFirstAvailableRow));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataTableReader_GetFirstAvailableRow == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datatablereader_getcolumncount", (void**)&(pWrapperTable->m_DataTableReader_GetColumnCount));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataTableReader_GetColumnCount == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datatablereader_hascolumn", (void**)&(pWrapperTable->m_DataTableReader_HasColumn));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataTableReader_HasColumn == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datatablereader_getcolumninformation", (void**)&(pWrapperTable->m_DataTableReader_GetColumnInformation));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataTableReader_GetColumnInformation == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datatablereader_getcolumnquantization", (void**)&(pWrapperTable->m_DataTableReader_GetColumnQuantization));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataTableReader_GetColumnQuantization == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datatablereader_getsegmentcount", (void**)&(pWrapperTable->m_DataTableReader_GetSegmentCount));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataTableReader_GetSegmentCount == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datatablereader_getsegmentinformation", (void**)&(pWrapperTable->m_DataTableReader_GetSegmentInformation));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataTableReader_GetSegmentInformation == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datatablereader_getchunkcount", (void**)&(pWrapperTable->m_DataTableReader_GetChunkCount));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataTableReader_GetChunkCount == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datatablereader_getchunkinformation", (void**)&(pWrapperTable->m_DataTableReader_GetChunkInformation));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataTableReader_GetChunkInformation == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datatablereader_getchunkstatistics", (void**)&(pWrapperTable->m_DataTableReader_GetChunkStatistics));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataTableReader_GetChunkStatistics == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datatablereader_readdoublecolumnrange", (void**)&(pWrapperTable->m_DataTableReader_ReadDoubleColumnRange));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataTableReader_ReadDoubleColumnRange == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datatablereader_readfloatcolumnrange", (void**)&(pWrapperTable->m_DataTableReader_ReadFloatColumnRange));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataTableReader_ReadFloatColumnRange == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datatablereader_readint64columnrange", (void**)&(pWrapperTable->m_DataTableReader_ReadInt64ColumnRange));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataTableReader_ReadInt64ColumnRange == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datatablereader_readboolcolumnrange", (void**)&(pWrapperTable->m_DataTableReader_ReadBoolColumnRange));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataTableReader_ReadBoolColumnRange == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datatablereader_readcolumndownsampled", (void**)&(pWrapperTable->m_DataTableReader_ReadColumnDownsampled));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataTableReader_ReadColumnDownsampled == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datatablereader_findchunksinvaluerange", (void**)&(pWrapperTable->m_DataTableReader_FindChunksInValueRange));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataTableReader_FindChunksInValueRange == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_datatablereader_extractdatatable", (void**)&(pWrapperTable->m_DataTableReader_ExtractDataTable));
+		if ( (eLookupError != 0) || (pWrapperTable->m_DataTableReader_ExtractDataTable == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
 		eLookupError = (*pLookup)("libmcenv_dataseries_getname", (void**)&(pWrapperTable->m_DataSeries_GetName));
 		if ( (eLookupError != 0) || (pWrapperTable->m_DataSeries_GetName == nullptr) )
 			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
@@ -17448,6 +18829,34 @@ class CUIEnvironment : public CBase {
 		if ( (eLookupError != 0) || (pWrapperTable->m_BuildExecution_LoadAttachedJournal == nullptr) )
 			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
+		eLookupError = (*pLookup)("libmcenv_buildexecution_createdatacaptureoptions", (void**)&(pWrapperTable->m_BuildExecution_CreateDataCaptureOptions));
+		if ( (eLookupError != 0) || (pWrapperTable->m_BuildExecution_CreateDataCaptureOptions == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_buildexecution_createdatacapture", (void**)&(pWrapperTable->m_BuildExecution_CreateDataCapture));
+		if ( (eLookupError != 0) || (pWrapperTable->m_BuildExecution_CreateDataCapture == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_buildexecution_hasdatacapture", (void**)&(pWrapperTable->m_BuildExecution_HasDataCapture));
+		if ( (eLookupError != 0) || (pWrapperTable->m_BuildExecution_HasDataCapture == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_buildexecution_getdatacapturerowcount", (void**)&(pWrapperTable->m_BuildExecution_GetDataCaptureRowCount));
+		if ( (eLookupError != 0) || (pWrapperTable->m_BuildExecution_GetDataCaptureRowCount == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_buildexecution_getdatacapturesegmentcount", (void**)&(pWrapperTable->m_BuildExecution_GetDataCaptureSegmentCount));
+		if ( (eLookupError != 0) || (pWrapperTable->m_BuildExecution_GetDataCaptureSegmentCount == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_buildexecution_loaddatacapturesegment", (void**)&(pWrapperTable->m_BuildExecution_LoadDataCaptureSegment));
+		if ( (eLookupError != 0) || (pWrapperTable->m_BuildExecution_LoadDataCaptureSegment == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_buildexecution_opendatacapturereader", (void**)&(pWrapperTable->m_BuildExecution_OpenDataCaptureReader));
+		if ( (eLookupError != 0) || (pWrapperTable->m_BuildExecution_OpenDataCaptureReader == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
 		eLookupError = (*pLookup)("libmcenv_buildexecutioniterator_getcurrentexecution", (void**)&(pWrapperTable->m_BuildExecutionIterator_GetCurrentExecution));
 		if ( (eLookupError != 0) || (pWrapperTable->m_BuildExecutionIterator_GetCurrentExecution == nullptr) )
 			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
@@ -18884,6 +20293,10 @@ class CUIEnvironment : public CBase {
 		if ( (eLookupError != 0) || (pWrapperTable->m_ZIPStreamWriter_CreateZIPEntryFromStream == nullptr) )
 			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
+		eLookupError = (*pLookup)("libmcenv_zipstreamwriter_discard", (void**)&(pWrapperTable->m_ZIPStreamWriter_Discard));
+		if ( (eLookupError != 0) || (pWrapperTable->m_ZIPStreamWriter_Discard == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
 		eLookupError = (*pLookup)("libmcenv_streamreader_getuuid", (void**)&(pWrapperTable->m_StreamReader_GetUUID));
 		if ( (eLookupError != 0) || (pWrapperTable->m_StreamReader_GetUUID == nullptr) )
 			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
@@ -20048,6 +21461,26 @@ class CUIEnvironment : public CBase {
 		if ( (eLookupError != 0) || (pWrapperTable->m_StateEnvironment_EvaluateFormulaAsBool == nullptr) )
 			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
 		
+		eLookupError = (*pLookup)("libmcenv_stateenvironment_startstreamdownloadforsession", (void**)&(pWrapperTable->m_StateEnvironment_StartStreamDownloadForSession));
+		if ( (eLookupError != 0) || (pWrapperTable->m_StateEnvironment_StartStreamDownloadForSession == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_stateenvironment_getstreamdownloadprogress", (void**)&(pWrapperTable->m_StateEnvironment_GetStreamDownloadProgress));
+		if ( (eLookupError != 0) || (pWrapperTable->m_StateEnvironment_GetStreamDownloadProgress == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_stateenvironment_cancelstreamdownloads", (void**)&(pWrapperTable->m_StateEnvironment_CancelStreamDownloads));
+		if ( (eLookupError != 0) || (pWrapperTable->m_StateEnvironment_CancelStreamDownloads == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_stateenvironment_deletestoragestream", (void**)&(pWrapperTable->m_StateEnvironment_DeleteStorageStream));
+		if ( (eLookupError != 0) || (pWrapperTable->m_StateEnvironment_DeleteStorageStream == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("libmcenv_stateenvironment_enforcestreamretention", (void**)&(pWrapperTable->m_StateEnvironment_EnforceStreamRetention));
+		if ( (eLookupError != 0) || (pWrapperTable->m_StateEnvironment_EnforceStreamRetention == nullptr) )
+			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
 		eLookupError = (*pLookup)("libmcenv_uiitem_getname", (void**)&(pWrapperTable->m_UIItem_GetName));
 		if ( (eLookupError != 0) || (pWrapperTable->m_UIItem_GetName == nullptr) )
 			return LIBMCENV_ERROR_COULDNOTFINDLIBRARYEXPORT;
@@ -22167,6 +23600,18 @@ class CUIEnvironment : public CBase {
 		return resultRowCount;
 	}
 	
+	/**
+	* CDataTable::GetRowCount64 - Returns the current row count as 64 bit value. GetRowCount is kept for ABI compatibility and truncates large row counts.
+	* @return Number of rows.
+	*/
+	LibMCEnv_uint64 CDataTable::GetRowCount64()
+	{
+		LibMCEnv_uint64 resultRowCount = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataTable_GetRowCount64(m_pHandle, &resultRowCount));
+		
+		return resultRowCount;
+	}
+	
 	/**
 	* CDataTable::GetColumnCount - Returns the current column count.
 	* @return Number of columns.
@@ -22310,6 +23755,48 @@ class CUIEnvironment : public CBase {
 		CheckError(m_pWrapper->m_WrapperTable.m_DataTable_GetUint64ColumnValues(m_pHandle, sIdentifier.c_str(), elementsNeededValues, &elementsWrittenValues, ValuesBuffer.data()));
 	}
 	
+	/**
+	* CDataTable::GetFloatColumnValues - Returns the values of a float (32 bit) column. Will fail if column does not exist or type is not float.
+	* @param[in] sIdentifier - Identifier of the column.
+	* @param[out] ValuesBuffer - Value array of a column.
+	*/
+	void CDataTable::GetFloatColumnValues(const std::string & sIdentifier, std::vector<LibMCEnv_single> & ValuesBuffer)
+	{
+		LibMCEnv_uint64 elementsNeededValues = 0;
+		LibMCEnv_uint64 elementsWrittenValues = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataTable_GetFloatColumnValues(m_pHandle, sIdentifier.c_str(), 0, &elementsNeededValues, nullptr));
+		ValuesBuffer.resize((size_t) elementsNeededValues);
+		CheckError(m_pWrapper->m_WrapperTable.m_DataTable_GetFloatColumnValues(m_pHandle, sIdentifier.c_str(), elementsNeededValues, &elementsWrittenValues, ValuesBuffer.data()));
+	}
+	
+	/**
+	* CDataTable::GetBoolColumnValues - Returns the values of a bool column as bytes (0 = false, 1 = true). Will fail if column does not exist or type is not bool.
+	* @param[in] sIdentifier - Identifier of the column.
+	* @param[out] ValuesBuffer - Value array of a column. Each entry is 0 or 1.
+	*/
+	void CDataTable::GetBoolColumnValues(const std::string & sIdentifier, std::vector<LibMCEnv_uint8> & ValuesBuffer)
+	{
+		LibMCEnv_uint64 elementsNeededValues = 0;
+		LibMCEnv_uint64 elementsWrittenValues = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataTable_GetBoolColumnValues(m_pHandle, sIdentifier.c_str(), 0, &elementsNeededValues, nullptr));
+		ValuesBuffer.resize((size_t) elementsNeededValues);
+		CheckError(m_pWrapper->m_WrapperTable.m_DataTable_GetBoolColumnValues(m_pHandle, sIdentifier.c_str(), elementsNeededValues, &elementsWrittenValues, ValuesBuffer.data()));
+	}
+	
+	/**
+	* CDataTable::GetTimestampColumnValues - Returns the values of a timestamp column in microseconds. Will fail if column does not exist or type is not timestamp.
+	* @param[in] sIdentifier - Identifier of the column.
+	* @param[out] ValuesBuffer - Value array of a column. Timestamps in microseconds.
+	*/
+	void CDataTable::GetTimestampColumnValues(const std::string & sIdentifier, std::vector<LibMCEnv_uint64> & ValuesBuffer)
+	{
+		LibMCEnv_uint64 elementsNeededValues = 0;
+		LibMCEnv_uint64 elementsWrittenValues = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataTable_GetTimestampColumnValues(m_pHandle, sIdentifier.c_str(), 0, &elementsNeededValues, nullptr));
+		ValuesBuffer.resize((size_t) elementsNeededValues);
+		CheckError(m_pWrapper->m_WrapperTable.m_DataTable_GetTimestampColumnValues(m_pHandle, sIdentifier.c_str(), elementsNeededValues, &elementsWrittenValues, ValuesBuffer.data()));
+	}
+	
 	/**
 	* CDataTable::SetDoubleColumnValues - Sets the values of a double column. Will fail if column does not exist or type is not double.
 	* @param[in] sIdentifier - Identifier of the column.
@@ -22360,6 +23847,36 @@ class CUIEnvironment : public CBase {
 		CheckError(m_pWrapper->m_WrapperTable.m_DataTable_SetUint64ColumnValues(m_pHandle, sIdentifier.c_str(), (LibMCEnv_uint64)ValuesBuffer.size(), ValuesBuffer.data()));
 	}
 	
+	/**
+	* CDataTable::SetFloatColumnValues - Sets the values of a float (32 bit) column. Will fail if column does not exist or type is not float.
+	* @param[in] sIdentifier - Identifier of the column.
+	* @param[in] ValuesBuffer - New Value array of a column. Array length should match RowCount. Values will be filled up with 0, if length is less than RowCount. RowCount will be extended if length is larger than RowCount.
+	*/
+	void CDataTable::SetFloatColumnValues(const std::string & sIdentifier, const CInputVector<LibMCEnv_single> & ValuesBuffer)
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_DataTable_SetFloatColumnValues(m_pHandle, sIdentifier.c_str(), (LibMCEnv_uint64)ValuesBuffer.size(), ValuesBuffer.data()));
+	}
+	
+	/**
+	* CDataTable::SetBoolColumnValues - Sets the values of a bool column from bytes (0 = false, nonzero = true). Will fail if column does not exist or type is not bool.
+	* @param[in] sIdentifier - Identifier of the column.
+	* @param[in] ValuesBuffer - New Value array of a column. Array length should match RowCount. Values will be filled up with 0, if length is less than RowCount. RowCount will be extended if length is larger than RowCount.
+	*/
+	void CDataTable::SetBoolColumnValues(const std::string & sIdentifier, const CInputVector<LibMCEnv_uint8> & ValuesBuffer)
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_DataTable_SetBoolColumnValues(m_pHandle, sIdentifier.c_str(), (LibMCEnv_uint64)ValuesBuffer.size(), ValuesBuffer.data()));
+	}
+	
+	/**
+	* CDataTable::SetTimestampColumnValues - Sets the values of a timestamp column in microseconds. Will fail if column does not exist or type is not timestamp.
+	* @param[in] sIdentifier - Identifier of the column.
+	* @param[in] ValuesBuffer - New Value array of a column. Array length should match RowCount. Values will be filled up with 0, if length is less than RowCount. RowCount will be extended if length is larger than RowCount.
+	*/
+	void CDataTable::SetTimestampColumnValues(const std::string & sIdentifier, const CInputVector<LibMCEnv_uint64> & ValuesBuffer)
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_DataTable_SetTimestampColumnValues(m_pHandle, sIdentifier.c_str(), (LibMCEnv_uint64)ValuesBuffer.size(), ValuesBuffer.data()));
+	}
+	
 	/**
 	* CDataTable::CreateWriteOptions - Creates a Write Option.
 	* @return Writer Options Instance to pass on to WriteDataToStream.
@@ -22456,6 +23973,805 @@ class CUIEnvironment : public CBase {
 		return std::make_shared<CScatterPlot>(m_pWrapper, hScatterPlot);
 	}
 	
+	/**
+	 * Method definitions for class CDataCaptureOptions
+	 */
+	
+	/**
+	* CDataCaptureOptions::SetChunkRowCount - Sets the number of rows a chunk can hold. Default is 65536.
+	* @param[in] nChunkRowCount - Rows per chunk. MUST be between 1 and 16777216.
+	*/
+	void CDataCaptureOptions::SetChunkRowCount(const LibMCEnv_uint32 nChunkRowCount)
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCaptureOptions_SetChunkRowCount(m_pHandle, nChunkRowCount));
+	}
+	
+	/**
+	* CDataCaptureOptions::GetChunkRowCount - Returns the number of rows a chunk can hold.
+	* @return Rows per chunk.
+	*/
+	LibMCEnv_uint32 CDataCaptureOptions::GetChunkRowCount()
+	{
+		LibMCEnv_uint32 resultChunkRowCount = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCaptureOptions_GetChunkRowCount(m_pHandle, &resultChunkRowCount));
+		
+		return resultChunkRowCount;
+	}
+	
+	/**
+	* CDataCaptureOptions::SetSegmentSizeInBytes - Sets the size at which the capture rolls over into a new segment stream. Default is 1 GB.
+	* @param[in] nSegmentSizeInBytes - Maximum segment size in bytes. 0 means the capture never rolls over. A segment always holds at least one chunk.
+	*/
+	void CDataCaptureOptions::SetSegmentSizeInBytes(const LibMCEnv_uint64 nSegmentSizeInBytes)
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCaptureOptions_SetSegmentSizeInBytes(m_pHandle, nSegmentSizeInBytes));
+	}
+	
+	/**
+	* CDataCaptureOptions::GetSegmentSizeInBytes - Returns the size at which the capture rolls over into a new segment stream.
+	* @return Maximum segment size in bytes. 0 means the capture never rolls over.
+	*/
+	LibMCEnv_uint64 CDataCaptureOptions::GetSegmentSizeInBytes()
+	{
+		LibMCEnv_uint64 resultSegmentSizeInBytes = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCaptureOptions_GetSegmentSizeInBytes(m_pHandle, &resultSegmentSizeInBytes));
+		
+		return resultSegmentSizeInBytes;
+	}
+	
+	/**
+	* CDataCaptureOptions::SetMaxQueuedChunks - Sets the maximum number of committed chunks that may wait for the writer thread. Default is 16.
+	* @param[in] nMaxQueuedChunks - Queue depth. MUST be between 1 and 1024.
+	*/
+	void CDataCaptureOptions::SetMaxQueuedChunks(const LibMCEnv_uint32 nMaxQueuedChunks)
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCaptureOptions_SetMaxQueuedChunks(m_pHandle, nMaxQueuedChunks));
+	}
+	
+	/**
+	* CDataCaptureOptions::GetMaxQueuedChunks - Returns the maximum number of committed chunks that may wait for the writer thread.
+	* @return Queue depth.
+	*/
+	LibMCEnv_uint32 CDataCaptureOptions::GetMaxQueuedChunks()
+	{
+		LibMCEnv_uint32 resultMaxQueuedChunks = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCaptureOptions_GetMaxQueuedChunks(m_pHandle, &resultMaxQueuedChunks));
+		
+		return resultMaxQueuedChunks;
+	}
+	
+	/**
+	* CDataCaptureOptions::SetBackpressureMode - Sets what happens when the producer is faster than the disk. Default is Block.
+	* @param[in] eBackpressureMode - Block waits for the writer, DropOldest discards the oldest queued chunk, Fail raises an error.
+	*/
+	void CDataCaptureOptions::SetBackpressureMode(const eDataCaptureBackpressureMode eBackpressureMode)
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCaptureOptions_SetBackpressureMode(m_pHandle, eBackpressureMode));
+	}
+	
+	/**
+	* CDataCaptureOptions::GetBackpressureMode - Returns what happens when the producer is faster than the disk.
+	* @return Backpressure mode.
+	*/
+	eDataCaptureBackpressureMode CDataCaptureOptions::GetBackpressureMode()
+	{
+		eDataCaptureBackpressureMode resultBackpressureMode = (eDataCaptureBackpressureMode) 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCaptureOptions_GetBackpressureMode(m_pHandle, &resultBackpressureMode));
+		
+		return resultBackpressureMode;
+	}
+	
+	/**
+	* CDataCaptureOptions::SetStorageLimitInBytes - Sets the retention limit for all data capture segments stored on this machine. When it is exceeded after a segment has been finalized, the oldest stored segments are deleted first. Default is 0.
+	* @param[in] nStorageLimitInBytes - Total size limit in bytes. 0 disables retention.
+	*/
+	void CDataCaptureOptions::SetStorageLimitInBytes(const LibMCEnv_uint64 nStorageLimitInBytes)
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCaptureOptions_SetStorageLimitInBytes(m_pHandle, nStorageLimitInBytes));
+	}
+	
+	/**
+	* CDataCaptureOptions::GetStorageLimitInBytes - Returns the retention limit for all data capture segments stored on this machine.
+	* @return Total size limit in bytes. 0 means retention is disabled.
+	*/
+	LibMCEnv_uint64 CDataCaptureOptions::GetStorageLimitInBytes()
+	{
+		LibMCEnv_uint64 resultStorageLimitInBytes = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCaptureOptions_GetStorageLimitInBytes(m_pHandle, &resultStorageLimitInBytes));
+		
+		return resultStorageLimitInBytes;
+	}
+	
+	/**
+	* CDataCaptureOptions::SetCompression - Sets the codec the pages of the capture are compressed with. Default is LZ4. A page is stored uncompressed if the codec does not make it smaller.
+	* @param[in] eCompression - None, LZ4 or Deflate. Deflate is meant for cold data, it costs considerably more processing time than LZ4.
+	*/
+	void CDataCaptureOptions::SetCompression(const eDataCaptureCompression eCompression)
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCaptureOptions_SetCompression(m_pHandle, eCompression));
+	}
+	
+	/**
+	* CDataCaptureOptions::GetCompression - Returns the codec the pages of the capture are compressed with.
+	* @return Compression codec.
+	*/
+	eDataCaptureCompression CDataCaptureOptions::GetCompression()
+	{
+		eDataCaptureCompression resultCompression = (eDataCaptureCompression) 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCaptureOptions_GetCompression(m_pHandle, &resultCompression));
+		
+		return resultCompression;
+	}
+	
+	/**
+	* CDataCaptureOptions::SetColumnEncoding - Sets the encoding of a column. Default is Automatic, which uses Delta for integer and timestamp columns, BitPack for bool columns and Plain for float and double columns. The column MUST exist when the capture starts recording and the encoding MUST fit its type.
+	* @param[in] sColumnIdentifier - Identifier of the column.
+	* @param[in] eEncoding - Automatic, Plain, Delta or BitPack.
+	*/
+	void CDataCaptureOptions::SetColumnEncoding(const std::string & sColumnIdentifier, const eDataCaptureEncoding eEncoding)
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCaptureOptions_SetColumnEncoding(m_pHandle, sColumnIdentifier.c_str(), eEncoding));
+	}
+	
+	/**
+	* CDataCaptureOptions::SetDoubleQuantization - Opts a double column into lossy storage: values are stored as integer multiples of the step with Delta encoding. Columns that are not quantised stay bit-exact. The step is recorded in the capture and the column MUST be a double column.
+	* @param[in] sColumnIdentifier - Identifier of the column.
+	* @param[in] dStep - Quantisation step. MUST be positive. 0 removes the quantisation.
+	*/
+	void CDataCaptureOptions::SetDoubleQuantization(const std::string & sColumnIdentifier, const LibMCEnv_double dStep)
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCaptureOptions_SetDoubleQuantization(m_pHandle, sColumnIdentifier.c_str(), dStep));
+	}
+	
+	/**
+	 * Method definitions for class CDataCaptureChunk
+	 */
+	
+	/**
+	* CDataCaptureChunk::GetCapacity - Returns the number of rows the chunk can hold.
+	* @return Number of rows.
+	*/
+	LibMCEnv_uint32 CDataCaptureChunk::GetCapacity()
+	{
+		LibMCEnv_uint32 resultCapacity = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCaptureChunk_GetCapacity(m_pHandle, &resultCapacity));
+		
+		return resultCapacity;
+	}
+	
+	/**
+	* CDataCaptureChunk::GetRowCount - Returns the number of rows in the chunk. This is the row count of the longest column.
+	* @return Number of rows.
+	*/
+	LibMCEnv_uint32 CDataCaptureChunk::GetRowCount()
+	{
+		LibMCEnv_uint32 resultRowCount = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCaptureChunk_GetRowCount(m_pHandle, &resultRowCount));
+		
+		return resultRowCount;
+	}
+	
+	/**
+	* CDataCaptureChunk::IsFull - Returns if the chunk has reached its capacity.
+	* @return Returns true if no more rows fit into the chunk.
+	*/
+	bool CDataCaptureChunk::IsFull()
+	{
+		bool resultFull = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCaptureChunk_IsFull(m_pHandle, &resultFull));
+		
+		return resultFull;
+	}
+	
+	/**
+	* CDataCaptureChunk::SetDoubleColumnValues - Sets all rows of a double column in this chunk. Fails if the column type does not match or the capacity is exceeded.
+	* @param[in] nColumnIndex - Index of the column. 0-based.
+	* @param[in] ValuesBuffer - Values of the column. All columns of a chunk MUST have the same length on commit.
+	*/
+	void CDataCaptureChunk::SetDoubleColumnValues(const LibMCEnv_uint32 nColumnIndex, const CInputVector<LibMCEnv_double> & ValuesBuffer)
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCaptureChunk_SetDoubleColumnValues(m_pHandle, nColumnIndex, (LibMCEnv_uint64)ValuesBuffer.size(), ValuesBuffer.data()));
+	}
+	
+	/**
+	* CDataCaptureChunk::SetInt32ColumnValues - Sets all rows of an int32 column in this chunk. Fails if the column type does not match or the capacity is exceeded.
+	* @param[in] nColumnIndex - Index of the column. 0-based.
+	* @param[in] ValuesBuffer - Values of the column. All columns of a chunk MUST have the same length on commit.
+	*/
+	void CDataCaptureChunk::SetInt32ColumnValues(const LibMCEnv_uint32 nColumnIndex, const CInputVector<LibMCEnv_int32> & ValuesBuffer)
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCaptureChunk_SetInt32ColumnValues(m_pHandle, nColumnIndex, (LibMCEnv_uint64)ValuesBuffer.size(), ValuesBuffer.data()));
+	}
+	
+	/**
+	* CDataCaptureChunk::SetUint32ColumnValues - Sets all rows of an uint32 column in this chunk. Fails if the column type does not match or the capacity is exceeded.
+	* @param[in] nColumnIndex - Index of the column. 0-based.
+	* @param[in] ValuesBuffer - Values of the column. All columns of a chunk MUST have the same length on commit.
+	*/
+	void CDataCaptureChunk::SetUint32ColumnValues(const LibMCEnv_uint32 nColumnIndex, const CInputVector<LibMCEnv_uint32> & ValuesBuffer)
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCaptureChunk_SetUint32ColumnValues(m_pHandle, nColumnIndex, (LibMCEnv_uint64)ValuesBuffer.size(), ValuesBuffer.data()));
+	}
+	
+	/**
+	* CDataCaptureChunk::SetInt64ColumnValues - Sets all rows of an int64 column in this chunk. Fails if the column type does not match or the capacity is exceeded.
+	* @param[in] nColumnIndex - Index of the column. 0-based.
+	* @param[in] ValuesBuffer - Values of the column. All columns of a chunk MUST have the same length on commit.
+	*/
+	void CDataCaptureChunk::SetInt64ColumnValues(const LibMCEnv_uint32 nColumnIndex, const CInputVector<LibMCEnv_int64> & ValuesBuffer)
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCaptureChunk_SetInt64ColumnValues(m_pHandle, nColumnIndex, (LibMCEnv_uint64)ValuesBuffer.size(), ValuesBuffer.data()));
+	}
+	
+	/**
+	* CDataCaptureChunk::SetUint64ColumnValues - Sets all rows of an uint64 column in this chunk. Fails if the column type does not match or the capacity is exceeded.
+	* @param[in] nColumnIndex - Index of the column. 0-based.
+	* @param[in] ValuesBuffer - Values of the column. All columns of a chunk MUST have the same length on commit.
+	*/
+	void CDataCaptureChunk::SetUint64ColumnValues(const LibMCEnv_uint32 nColumnIndex, const CInputVector<LibMCEnv_uint64> & ValuesBuffer)
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCaptureChunk_SetUint64ColumnValues(m_pHandle, nColumnIndex, (LibMCEnv_uint64)ValuesBuffer.size(), ValuesBuffer.data()));
+	}
+	
+	/**
+	* CDataCaptureChunk::SetFloatColumnValues - Sets all rows of a float (32 bit) column in this chunk. Fails if the column type does not match or the capacity is exceeded.
+	* @param[in] nColumnIndex - Index of the column. 0-based.
+	* @param[in] ValuesBuffer - Values of the column. All columns of a chunk MUST have the same length on commit.
+	*/
+	void CDataCaptureChunk::SetFloatColumnValues(const LibMCEnv_uint32 nColumnIndex, const CInputVector<LibMCEnv_single> & ValuesBuffer)
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCaptureChunk_SetFloatColumnValues(m_pHandle, nColumnIndex, (LibMCEnv_uint64)ValuesBuffer.size(), ValuesBuffer.data()));
+	}
+	
+	/**
+	* CDataCaptureChunk::SetBoolColumnValues - Sets all rows of a bool column in this chunk from bytes (0 = false, nonzero = true). Fails if the column type does not match or the capacity is exceeded.
+	* @param[in] nColumnIndex - Index of the column. 0-based.
+	* @param[in] ValuesBuffer - Values of the column. All columns of a chunk MUST have the same length on commit.
+	*/
+	void CDataCaptureChunk::SetBoolColumnValues(const LibMCEnv_uint32 nColumnIndex, const CInputVector<LibMCEnv_uint8> & ValuesBuffer)
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCaptureChunk_SetBoolColumnValues(m_pHandle, nColumnIndex, (LibMCEnv_uint64)ValuesBuffer.size(), ValuesBuffer.data()));
+	}
+	
+	/**
+	* CDataCaptureChunk::SetTimestampColumnValues - Sets all rows of a timestamp column in this chunk in microseconds. Fails if the column type does not match or the capacity is exceeded.
+	* @param[in] nColumnIndex - Index of the column. 0-based.
+	* @param[in] ValuesBuffer - Values of the column. All columns of a chunk MUST have the same length on commit.
+	*/
+	void CDataCaptureChunk::SetTimestampColumnValues(const LibMCEnv_uint32 nColumnIndex, const CInputVector<LibMCEnv_uint64> & ValuesBuffer)
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCaptureChunk_SetTimestampColumnValues(m_pHandle, nColumnIndex, (LibMCEnv_uint64)ValuesBuffer.size(), ValuesBuffer.data()));
+	}
+	
+	/**
+	* CDataCaptureChunk::BeginRow - Starts a new row at the end of the chunk. This is the convenience path for low-rate producers. Fails if the chunk is full, a row is open or the columns have different row counts.
+	*/
+	void CDataCaptureChunk::BeginRow()
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCaptureChunk_BeginRow(m_pHandle));
+	}
+	
+	/**
+	* CDataCaptureChunk::SetRowDoubleValue - Sets a value of the open row. The column MUST be of type double or float.
+	* @param[in] nColumnIndex - Index of the column. 0-based.
+	* @param[in] dValue - Value to set.
+	*/
+	void CDataCaptureChunk::SetRowDoubleValue(const LibMCEnv_uint32 nColumnIndex, const LibMCEnv_double dValue)
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCaptureChunk_SetRowDoubleValue(m_pHandle, nColumnIndex, dValue));
+	}
+	
+	/**
+	* CDataCaptureChunk::SetRowIntegerValue - Sets a value of the open row. The column MUST be of an integer, bool or timestamp type and the value MUST be in its range.
+	* @param[in] nColumnIndex - Index of the column. 0-based.
+	* @param[in] nValue - Value to set.
+	*/
+	void CDataCaptureChunk::SetRowIntegerValue(const LibMCEnv_uint32 nColumnIndex, const LibMCEnv_int64 nValue)
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCaptureChunk_SetRowIntegerValue(m_pHandle, nColumnIndex, nValue));
+	}
+	
+	/**
+	* CDataCaptureChunk::EndRow - Finishes the open row. Columns that have not been set in this row are zero.
+	*/
+	void CDataCaptureChunk::EndRow()
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCaptureChunk_EndRow(m_pHandle));
+	}
+	
+	/**
+	 * Method definitions for class CDataCapture
+	 */
+	
+	/**
+	* CDataCapture::GetUUID - Returns the UUID of the capture.
+	* @return UUID of the capture.
+	*/
+	std::string CDataCapture::GetUUID()
+	{
+		LibMCEnv_uint32 bytesNeededUUID = 0;
+		LibMCEnv_uint32 bytesWrittenUUID = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_GetUUID(m_pHandle, 0, &bytesNeededUUID, nullptr));
+		std::vector<char> bufferUUID(bytesNeededUUID);
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_GetUUID(m_pHandle, bytesNeededUUID, &bytesWrittenUUID, &bufferUUID[0]));
+		
+		return std::string(&bufferUUID[0]);
+	}
+	
+	/**
+	* CDataCapture::GetIdentifier - Returns the identifier of the capture. It is unique within the build execution.
+	* @return Identifier of the capture.
+	*/
+	std::string CDataCapture::GetIdentifier()
+	{
+		LibMCEnv_uint32 bytesNeededIdentifier = 0;
+		LibMCEnv_uint32 bytesWrittenIdentifier = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_GetIdentifier(m_pHandle, 0, &bytesNeededIdentifier, nullptr));
+		std::vector<char> bufferIdentifier(bytesNeededIdentifier);
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_GetIdentifier(m_pHandle, bytesNeededIdentifier, &bytesWrittenIdentifier, &bufferIdentifier[0]));
+		
+		return std::string(&bufferIdentifier[0]);
+	}
+	
+	/**
+	* CDataCapture::GetName - Returns the human readable name of the capture.
+	* @return Name of the capture.
+	*/
+	std::string CDataCapture::GetName()
+	{
+		LibMCEnv_uint32 bytesNeededName = 0;
+		LibMCEnv_uint32 bytesWrittenName = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_GetName(m_pHandle, 0, &bytesNeededName, nullptr));
+		std::vector<char> bufferName(bytesNeededName);
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_GetName(m_pHandle, bytesNeededName, &bytesWrittenName, &bufferName[0]));
+		
+		return std::string(&bufferName[0]);
+	}
+	
+	/**
+	* CDataCapture::GetStatus - Returns the status of the capture.
+	* @return Status of the capture.
+	*/
+	eDataCaptureStatus CDataCapture::GetStatus()
+	{
+		eDataCaptureStatus resultStatus = (eDataCaptureStatus) 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_GetStatus(m_pHandle, &resultStatus));
+		
+		return resultStatus;
+	}
+	
+	/**
+	* CDataCapture::AddColumn - Adds a column to the capture. The schema is frozen with the first call to BeginChunk.
+	* @param[in] sIdentifier - Identifier of the column. MUST be unique, alphanumeric and not empty.
+	* @param[in] sDescription - Description of the column.
+	* @param[in] eColumnType - Data type of the column.
+	*/
+	void CDataCapture::AddColumn(const std::string & sIdentifier, const std::string & sDescription, const eDataTableColumnType eColumnType)
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_AddColumn(m_pHandle, sIdentifier.c_str(), sDescription.c_str(), eColumnType));
+	}
+	
+	/**
+	* CDataCapture::GetColumnCount - Returns the number of columns of the capture.
+	* @return Number of columns.
+	*/
+	LibMCEnv_uint32 CDataCapture::GetColumnCount()
+	{
+		LibMCEnv_uint32 resultColumnCount = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_GetColumnCount(m_pHandle, &resultColumnCount));
+		
+		return resultColumnCount;
+	}
+	
+	/**
+	* CDataCapture::BeginChunk - Borrows an empty chunk from the chunk pool. Freezes the schema on the first call. If no chunk is free, the backpressure mode of the capture applies.
+	* @return Chunk to fill.
+	*/
+	PDataCaptureChunk CDataCapture::BeginChunk()
+	{
+		LibMCEnvHandle hChunkInstance = nullptr;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_BeginChunk(m_pHandle, &hChunkInstance));
+		
+		if (!hChunkInstance) {
+			CheckError(LIBMCENV_ERROR_INVALIDPARAM);
+		}
+		return std::make_shared<CDataCaptureChunk>(m_pWrapper, hChunkInstance);
+	}
+	
+	/**
+	* CDataCapture::CommitChunk - Hands a filled chunk over to the writer thread and returns immediately. All columns MUST have the same row count. The chunk instance MUST NOT be used afterwards.
+	* @param[in] pChunkInstance - Chunk that has been returned by BeginChunk.
+	*/
+	void CDataCapture::CommitChunk(classParam<CDataCaptureChunk> pChunkInstance)
+	{
+		LibMCEnvHandle hChunkInstance = pChunkInstance.GetHandle();
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_CommitChunk(m_pHandle, hChunkInstance));
+	}
+	
+	/**
+	* CDataCapture::Flush - Blocks until all committed chunks have been written to storage.
+	*/
+	void CDataCapture::Flush()
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_Flush(m_pHandle));
+	}
+	
+	/**
+	* CDataCapture::GetCapturedRowCount - Returns the number of rows that have been committed and not dropped.
+	* @return Number of rows.
+	*/
+	LibMCEnv_uint64 CDataCapture::GetCapturedRowCount()
+	{
+		LibMCEnv_uint64 resultRowCount = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_GetCapturedRowCount(m_pHandle, &resultRowCount));
+		
+		return resultRowCount;
+	}
+	
+	/**
+	* CDataCapture::GetStorageSizeInBytes - Returns the number of bytes that have been written to storage so far.
+	* @return Size in bytes.
+	*/
+	LibMCEnv_uint64 CDataCapture::GetStorageSizeInBytes()
+	{
+		LibMCEnv_uint64 resultSizeInBytes = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_GetStorageSizeInBytes(m_pHandle, &resultSizeInBytes));
+		
+		return resultSizeInBytes;
+	}
+	
+	/**
+	* CDataCapture::GetSegmentCount - Returns the number of segment streams that have been opened so far.
+	* @return Number of segments.
+	*/
+	LibMCEnv_uint32 CDataCapture::GetSegmentCount()
+	{
+		LibMCEnv_uint32 resultSegmentCount = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_GetSegmentCount(m_pHandle, &resultSegmentCount));
+		
+		return resultSegmentCount;
+	}
+	
+	/**
+	* CDataCapture::GetQueuedChunkCount - Returns the number of committed chunks that are waiting for the writer thread.
+	* @return Number of queued chunks.
+	*/
+	LibMCEnv_uint32 CDataCapture::GetQueuedChunkCount()
+	{
+		LibMCEnv_uint32 resultQueuedChunkCount = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_GetQueuedChunkCount(m_pHandle, &resultQueuedChunkCount));
+		
+		return resultQueuedChunkCount;
+	}
+	
+	/**
+	* CDataCapture::GetDroppedRowCount - Returns the number of rows that have been discarded by the DropOldest backpressure mode.
+	* @return Number of dropped rows.
+	*/
+	LibMCEnv_uint64 CDataCapture::GetDroppedRowCount()
+	{
+		LibMCEnv_uint64 resultDroppedRowCount = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_GetDroppedRowCount(m_pHandle, &resultDroppedRowCount));
+		
+		return resultDroppedRowCount;
+	}
+	
+	/**
+	* CDataCapture::Finish - Writes all committed chunks, closes the last segment and marks the capture as finished. Fails if a chunk is uncommitted.
+	* @return UUID of the capture.
+	*/
+	std::string CDataCapture::Finish()
+	{
+		LibMCEnv_uint32 bytesNeededCaptureUUID = 0;
+		LibMCEnv_uint32 bytesWrittenCaptureUUID = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_Finish(m_pHandle, 0, &bytesNeededCaptureUUID, nullptr));
+		std::vector<char> bufferCaptureUUID(bytesNeededCaptureUUID);
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_Finish(m_pHandle, bytesNeededCaptureUUID, &bytesWrittenCaptureUUID, &bufferCaptureUUID[0]));
+		
+		return std::string(&bufferCaptureUUID[0]);
+	}
+	
+	/**
+	* CDataCapture::Abort - Stops the capture and deletes all its segments.
+	*/
+	void CDataCapture::Abort()
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_Abort(m_pHandle));
+	}
+	
+	/**
+	* CDataCapture::AddColumnsFromDataTable - Adds one column to the capture for every column of a data table, with the same identifier, description and type and in the same order. Fails if the schema is frozen or an identifier already exists.
+	* @param[in] pDataTable - Data table whose columns describe the schema. Its rows are not read.
+	*/
+	void CDataCapture::AddColumnsFromDataTable(classParam<CDataTable> pDataTable)
+	{
+		LibMCEnvHandle hDataTable = pDataTable.GetHandle();
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_AddColumnsFromDataTable(m_pHandle, hDataTable));
+	}
+	
+	/**
+	* CDataCapture::AppendDataTable - Appends all rows of a data table to the capture and splits them into chunks. Every column of the capture MUST exist in the table with the same identifier and type, and these columns MUST have the same row count. Further columns of the table are ignored. Freezes the schema on the first call. If no chunk is free, the backpressure mode of the capture applies. Fails if a chunk is uncommitted.
+	* @param[in] pDataTable - Data table that holds the rows to append.
+	* @return Number of rows that have been appended.
+	*/
+	LibMCEnv_uint64 CDataCapture::AppendDataTable(classParam<CDataTable> pDataTable)
+	{
+		LibMCEnvHandle hDataTable = pDataTable.GetHandle();
+		LibMCEnv_uint64 resultRowCount = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataCapture_AppendDataTable(m_pHandle, hDataTable, &resultRowCount));
+		
+		return resultRowCount;
+	}
+	
+	/**
+	 * Method definitions for class CDataTableReader
+	 */
+	
+	/**
+	* CDataTableReader::GetRowCount - Returns the number of rows of the capture, including rows in segments that have been deleted by retention.
+	* @return Number of rows.
+	*/
+	LibMCEnv_uint64 CDataTableReader::GetRowCount()
+	{
+		LibMCEnv_uint64 resultRowCount = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataTableReader_GetRowCount(m_pHandle, &resultRowCount));
+		
+		return resultRowCount;
+	}
+	
+	/**
+	* CDataTableReader::GetFirstAvailableRow - Returns the index of the first row that is still stored. Rows before it have been deleted by retention.
+	* @return Row index. Equal to the row count if nothing is stored.
+	*/
+	LibMCEnv_uint64 CDataTableReader::GetFirstAvailableRow()
+	{
+		LibMCEnv_uint64 resultFirstAvailableRow = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataTableReader_GetFirstAvailableRow(m_pHandle, &resultFirstAvailableRow));
+		
+		return resultFirstAvailableRow;
+	}
+	
+	/**
+	* CDataTableReader::GetColumnCount - Returns the number of columns.
+	* @return Number of columns.
+	*/
+	LibMCEnv_uint32 CDataTableReader::GetColumnCount()
+	{
+		LibMCEnv_uint32 resultColumnCount = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataTableReader_GetColumnCount(m_pHandle, &resultColumnCount));
+		
+		return resultColumnCount;
+	}
+	
+	/**
+	* CDataTableReader::HasColumn - Returns if a column exists.
+	* @param[in] sIdentifier - Identifier of the column.
+	* @return Returns if the column exists.
+	*/
+	bool CDataTableReader::HasColumn(const std::string & sIdentifier)
+	{
+		bool resultColumnExists = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataTableReader_HasColumn(m_pHandle, sIdentifier.c_str(), &resultColumnExists));
+		
+		return resultColumnExists;
+	}
+	
+	/**
+	* CDataTableReader::GetColumnInformation - Returns the schema information of a column. Fails if the index is out of bounds.
+	* @param[in] nColumnIndex - Index of column. 0-based.
+	* @param[out] sIdentifier - Identifier of the column.
+	* @param[out] sDescription - Description of the column.
+	* @param[out] eColumnType - Data type of the column.
+	*/
+	void CDataTableReader::GetColumnInformation(const LibMCEnv_uint32 nColumnIndex, std::string & sIdentifier, std::string & sDescription, eDataTableColumnType & eColumnType)
+	{
+		LibMCEnv_uint32 bytesNeededIdentifier = 0;
+		LibMCEnv_uint32 bytesWrittenIdentifier = 0;
+		LibMCEnv_uint32 bytesNeededDescription = 0;
+		LibMCEnv_uint32 bytesWrittenDescription = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataTableReader_GetColumnInformation(m_pHandle, nColumnIndex, 0, &bytesNeededIdentifier, nullptr, 0, &bytesNeededDescription, nullptr, &eColumnType));
+		std::vector<char> bufferIdentifier(bytesNeededIdentifier);
+		std::vector<char> bufferDescription(bytesNeededDescription);
+		CheckError(m_pWrapper->m_WrapperTable.m_DataTableReader_GetColumnInformation(m_pHandle, nColumnIndex, bytesNeededIdentifier, &bytesWrittenIdentifier, &bufferIdentifier[0], bytesNeededDescription, &bytesWrittenDescription, &bufferDescription[0], &eColumnType));
+		sIdentifier = std::string(&bufferIdentifier[0]);
+		sDescription = std::string(&bufferDescription[0]);
+	}
+	
+	/**
+	* CDataTableReader::GetColumnQuantization - Returns the quantisation step of a column. Values of a quantised column are exact to half a step.
+	* @param[in] sIdentifier - Identifier of the column.
+	* @return Quantisation step. 0 if the column is not quantised.
+	*/
+	LibMCEnv_double CDataTableReader::GetColumnQuantization(const std::string & sIdentifier)
+	{
+		LibMCEnv_double resultStep = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataTableReader_GetColumnQuantization(m_pHandle, sIdentifier.c_str(), &resultStep));
+		
+		return resultStep;
+	}
+	
+	/**
+	* CDataTableReader::GetSegmentCount - Returns the number of segments of the capture, including deleted ones.
+	* @return Number of segments.
+	*/
+	LibMCEnv_uint32 CDataTableReader::GetSegmentCount()
+	{
+		LibMCEnv_uint32 resultSegmentCount = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataTableReader_GetSegmentCount(m_pHandle, &resultSegmentCount));
+		
+		return resultSegmentCount;
+	}
+	
+	/**
+	* CDataTableReader::GetSegmentInformation - Returns the row range and the size of a segment. Fails if the index is out of bounds.
+	* @param[in] nSegmentIndex - Index of the segment. 0-based.
+	* @param[out] nFirstRow - Index of the first row of the segment.
+	* @param[out] nRowCount - Number of rows in the segment.
+	* @param[out] nSizeInBytes - Size of the segment stream in bytes.
+	* @param[out] bIsAvailable - Returns false if the segment has been deleted by retention.
+	*/
+	void CDataTableReader::GetSegmentInformation(const LibMCEnv_uint32 nSegmentIndex, LibMCEnv_uint64 & nFirstRow, LibMCEnv_uint64 & nRowCount, LibMCEnv_uint64 & nSizeInBytes, bool & bIsAvailable)
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_DataTableReader_GetSegmentInformation(m_pHandle, nSegmentIndex, &nFirstRow, &nRowCount, &nSizeInBytes, &bIsAvailable));
+	}
+	
+	/**
+	* CDataTableReader::GetChunkCount - Returns the number of chunks of the capture, including chunks in deleted segments.
+	* @return Number of chunks.
+	*/
+	LibMCEnv_uint64 CDataTableReader::GetChunkCount()
+	{
+		LibMCEnv_uint64 resultChunkCount = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataTableReader_GetChunkCount(m_pHandle, &resultChunkCount));
+		
+		return resultChunkCount;
+	}
+	
+	/**
+	* CDataTableReader::GetChunkInformation - Returns the position of a chunk. Fails if the index is out of bounds.
+	* @param[in] nChunkIndex - Index of the chunk. 0-based.
+	* @param[out] nSegmentIndex - Index of the segment that holds the chunk.
+	* @param[out] nFirstRow - Index of the first row of the chunk. For a chunk in a deleted segment this is the first row of the segment.
+	* @param[out] nRowCount - Number of rows in the chunk. 0 for a chunk in a deleted segment.
+	* @param[out] bIsAvailable - Returns false if the chunk has been deleted by retention.
+	*/
+	void CDataTableReader::GetChunkInformation(const LibMCEnv_uint64 nChunkIndex, LibMCEnv_uint32 & nSegmentIndex, LibMCEnv_uint64 & nFirstRow, LibMCEnv_uint64 & nRowCount, bool & bIsAvailable)
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_DataTableReader_GetChunkInformation(m_pHandle, nChunkIndex, &nSegmentIndex, &nFirstRow, &nRowCount, &bIsAvailable));
+	}
+	
+	/**
+	* CDataTableReader::GetChunkStatistics - Returns the minimum and maximum of a column in a chunk from the page directory, without reading the chunk.
+	* @param[in] nChunkIndex - Index of the chunk. 0-based.
+	* @param[in] sIdentifier - Identifier of the column.
+	* @param[out] dMinValue - Minimum value of the column in the chunk.
+	* @param[out] dMaxValue - Maximum value of the column in the chunk.
+	* @return Returns false if the chunk has been deleted or holds no comparable value.
+	*/
+	bool CDataTableReader::GetChunkStatistics(const LibMCEnv_uint64 nChunkIndex, const std::string & sIdentifier, LibMCEnv_double & dMinValue, LibMCEnv_double & dMaxValue)
+	{
+		bool resultHasStatistics = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataTableReader_GetChunkStatistics(m_pHandle, nChunkIndex, sIdentifier.c_str(), &dMinValue, &dMaxValue, &resultHasStatistics));
+		
+		return resultHasStatistics;
+	}
+	
+	/**
+	* CDataTableReader::ReadDoubleColumnRange - Reads a row range of a column as doubles. Works for every column type. Only the pages that overlap the range are read.
+	* @param[in] sIdentifier - Identifier of the column.
+	* @param[in] nFromRow - Index of the first row to read.
+	* @param[in] nRowCount - Number of rows to read.
+	* @param[out] ValuesBuffer - Values of the row range.
+	*/
+	void CDataTableReader::ReadDoubleColumnRange(const std::string & sIdentifier, const LibMCEnv_uint64 nFromRow, const LibMCEnv_uint64 nRowCount, std::vector<LibMCEnv_double> & ValuesBuffer)
+	{
+		LibMCEnv_uint64 elementsNeededValues = 0;
+		LibMCEnv_uint64 elementsWrittenValues = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataTableReader_ReadDoubleColumnRange(m_pHandle, sIdentifier.c_str(), nFromRow, nRowCount, 0, &elementsNeededValues, nullptr));
+		ValuesBuffer.resize((size_t) elementsNeededValues);
+		CheckError(m_pWrapper->m_WrapperTable.m_DataTableReader_ReadDoubleColumnRange(m_pHandle, sIdentifier.c_str(), nFromRow, nRowCount, elementsNeededValues, &elementsWrittenValues, ValuesBuffer.data()));
+	}
+	
+	/**
+	* CDataTableReader::ReadFloatColumnRange - Reads a row range of a float or double column as floats.
+	* @param[in] sIdentifier - Identifier of the column.
+	* @param[in] nFromRow - Index of the first row to read.
+	* @param[in] nRowCount - Number of rows to read.
+	* @param[out] ValuesBuffer - Values of the row range.
+	*/
+	void CDataTableReader::ReadFloatColumnRange(const std::string & sIdentifier, const LibMCEnv_uint64 nFromRow, const LibMCEnv_uint64 nRowCount, std::vector<LibMCEnv_single> & ValuesBuffer)
+	{
+		LibMCEnv_uint64 elementsNeededValues = 0;
+		LibMCEnv_uint64 elementsWrittenValues = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataTableReader_ReadFloatColumnRange(m_pHandle, sIdentifier.c_str(), nFromRow, nRowCount, 0, &elementsNeededValues, nullptr));
+		ValuesBuffer.resize((size_t) elementsNeededValues);
+		CheckError(m_pWrapper->m_WrapperTable.m_DataTableReader_ReadFloatColumnRange(m_pHandle, sIdentifier.c_str(), nFromRow, nRowCount, elementsNeededValues, &elementsWrittenValues, ValuesBuffer.data()));
+	}
+	
+	/**
+	* CDataTableReader::ReadInt64ColumnRange - Reads a row range of an integer, bool or timestamp column as 64 bit integers.
+	* @param[in] sIdentifier - Identifier of the column.
+	* @param[in] nFromRow - Index of the first row to read.
+	* @param[in] nRowCount - Number of rows to read.
+	* @param[out] ValuesBuffer - Values of the row range.
+	*/
+	void CDataTableReader::ReadInt64ColumnRange(const std::string & sIdentifier, const LibMCEnv_uint64 nFromRow, const LibMCEnv_uint64 nRowCount, std::vector<LibMCEnv_int64> & ValuesBuffer)
+	{
+		LibMCEnv_uint64 elementsNeededValues = 0;
+		LibMCEnv_uint64 elementsWrittenValues = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataTableReader_ReadInt64ColumnRange(m_pHandle, sIdentifier.c_str(), nFromRow, nRowCount, 0, &elementsNeededValues, nullptr));
+		ValuesBuffer.resize((size_t) elementsNeededValues);
+		CheckError(m_pWrapper->m_WrapperTable.m_DataTableReader_ReadInt64ColumnRange(m_pHandle, sIdentifier.c_str(), nFromRow, nRowCount, elementsNeededValues, &elementsWrittenValues, ValuesBuffer.data()));
+	}
+	
+	/**
+	* CDataTableReader::ReadBoolColumnRange - Reads a row range of a bool column as bytes (0 = false, 1 = true).
+	* @param[in] sIdentifier - Identifier of the column.
+	* @param[in] nFromRow - Index of the first row to read.
+	* @param[in] nRowCount - Number of rows to read.
+	* @param[out] ValuesBuffer - Values of the row range.
+	*/
+	void CDataTableReader::ReadBoolColumnRange(const std::string & sIdentifier, const LibMCEnv_uint64 nFromRow, const LibMCEnv_uint64 nRowCount, std::vector<LibMCEnv_uint8> & ValuesBuffer)
+	{
+		LibMCEnv_uint64 elementsNeededValues = 0;
+		LibMCEnv_uint64 elementsWrittenValues = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataTableReader_ReadBoolColumnRange(m_pHandle, sIdentifier.c_str(), nFromRow, nRowCount, 0, &elementsNeededValues, nullptr));
+		ValuesBuffer.resize((size_t) elementsNeededValues);
+		CheckError(m_pWrapper->m_WrapperTable.m_DataTableReader_ReadBoolColumnRange(m_pHandle, sIdentifier.c_str(), nFromRow, nRowCount, elementsNeededValues, &elementsWrittenValues, ValuesBuffer.data()));
+	}
+	
+	/**
+	* CDataTableReader::ReadColumnDownsampled - Reduces a row range of a column to at most TargetPoints buckets without materialising the range. Stride returns the first value of each bucket, Average the mean and MinMax the minimum followed by the maximum of each bucket, which preserves the envelope of the signal.
+	* @param[in] sIdentifier - Identifier of the column.
+	* @param[in] nFromRow - Index of the first row of the range.
+	* @param[in] nRowCount - Number of rows of the range.
+	* @param[in] nTargetPoints - Maximum number of buckets. MUST be positive.
+	* @param[in] eMode - Stride, MinMax or Average.
+	* @param[out] ValuesBuffer - One value per bucket, or two values per bucket in MinMax mode. The number of buckets is the smaller of TargetPoints and RowCount.
+	*/
+	void CDataTableReader::ReadColumnDownsampled(const std::string & sIdentifier, const LibMCEnv_uint64 nFromRow, const LibMCEnv_uint64 nRowCount, const LibMCEnv_uint32 nTargetPoints, const eDataTableDownsampleMode eMode, std::vector<LibMCEnv_double> & ValuesBuffer)
+	{
+		LibMCEnv_uint64 elementsNeededValues = 0;
+		LibMCEnv_uint64 elementsWrittenValues = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataTableReader_ReadColumnDownsampled(m_pHandle, sIdentifier.c_str(), nFromRow, nRowCount, nTargetPoints, eMode, 0, &elementsNeededValues, nullptr));
+		ValuesBuffer.resize((size_t) elementsNeededValues);
+		CheckError(m_pWrapper->m_WrapperTable.m_DataTableReader_ReadColumnDownsampled(m_pHandle, sIdentifier.c_str(), nFromRow, nRowCount, nTargetPoints, eMode, elementsNeededValues, &elementsWrittenValues, ValuesBuffer.data()));
+	}
+	
+	/**
+	* CDataTableReader::FindChunksInValueRange - Finds the chunks whose value range of a column overlaps a given range. Only the page directory is used, no chunk is read.
+	* @param[in] sIdentifier - Identifier of the column.
+	* @param[in] dMinValue - Lower bound of the value range.
+	* @param[in] dMaxValue - Upper bound of the value range.
+	* @param[out] ChunkIndicesBuffer - Indices of the chunks that may hold a value in the range.
+	*/
+	void CDataTableReader::FindChunksInValueRange(const std::string & sIdentifier, const LibMCEnv_double dMinValue, const LibMCEnv_double dMaxValue, std::vector<LibMCEnv_uint64> & ChunkIndicesBuffer)
+	{
+		LibMCEnv_uint64 elementsNeededChunkIndices = 0;
+		LibMCEnv_uint64 elementsWrittenChunkIndices = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataTableReader_FindChunksInValueRange(m_pHandle, sIdentifier.c_str(), dMinValue, dMaxValue, 0, &elementsNeededChunkIndices, nullptr));
+		ChunkIndicesBuffer.resize((size_t) elementsNeededChunkIndices);
+		CheckError(m_pWrapper->m_WrapperTable.m_DataTableReader_FindChunksInValueRange(m_pHandle, sIdentifier.c_str(), dMinValue, dMaxValue, elementsNeededChunkIndices, &elementsWrittenChunkIndices, ChunkIndicesBuffer.data()));
+	}
+	
+	/**
+	* CDataTableReader::ExtractDataTable - Materialises a row range as an ordinary in-memory data table.
+	* @param[in] nFromRow - Index of the first row of the range.
+	* @param[in] nRowCount - Number of rows of the range.
+	* @param[in] sColumnIdentifiers - Comma separated identifiers of the columns to extract. An empty string extracts all columns.
+	* @return Data table instance.
+	*/
+	PDataTable CDataTableReader::ExtractDataTable(const LibMCEnv_uint64 nFromRow, const LibMCEnv_uint64 nRowCount, const std::string & sColumnIdentifiers)
+	{
+		LibMCEnvHandle hDataTableInstance = nullptr;
+		CheckError(m_pWrapper->m_WrapperTable.m_DataTableReader_ExtractDataTable(m_pHandle, nFromRow, nRowCount, sColumnIdentifiers.c_str(), &hDataTableInstance));
+		
+		if (!hDataTableInstance) {
+			CheckError(LIBMCENV_ERROR_INVALIDPARAM);
+		}
+		return std::make_shared<CDataTable>(m_pWrapper, hDataTableInstance);
+	}
+	
 	/**
 	 * Method definitions for class CDataSeries
 	 */
@@ -25987,6 +28303,113 @@ class CUIEnvironment : public CBase {
 		return std::make_shared<CJournalHandler>(m_pWrapper, hJournalHandler);
 	}
 	
+	/**
+	* CBuildExecution::CreateDataCaptureOptions - Creates an options object for a data capture with default values.
+	* @return Data capture options instance.
+	*/
+	PDataCaptureOptions CBuildExecution::CreateDataCaptureOptions()
+	{
+		LibMCEnvHandle hOptions = nullptr;
+		CheckError(m_pWrapper->m_WrapperTable.m_BuildExecution_CreateDataCaptureOptions(m_pHandle, &hOptions));
+		
+		if (!hOptions) {
+			CheckError(LIBMCENV_ERROR_INVALIDPARAM);
+		}
+		return std::make_shared<CDataCaptureOptions>(m_pWrapper, hOptions);
+	}
+	
+	/**
+	* CBuildExecution::CreateDataCapture - Creates a streaming data capture in this build execution. The execution MUST be in process.
+	* @param[in] sIdentifier - Unique identifier of the capture in this execution. Fails if the identifier already exists or is invalid.
+	* @param[in] sName - Human readable name of the capture.
+	* @param[in] pOptions - Data capture options. Defaults are used if not given.
+	* @param[in] sUserUUID - User UUID of the user that this data comes from. Empty string means no user attached.
+	* @return Data capture instance.
+	*/
+	PDataCapture CBuildExecution::CreateDataCapture(const std::string & sIdentifier, const std::string & sName, classParam<CDataCaptureOptions> pOptions, const std::string & sUserUUID)
+	{
+		LibMCEnvHandle hOptions = pOptions.GetHandle();
+		LibMCEnvHandle hDataCaptureInstance = nullptr;
+		CheckError(m_pWrapper->m_WrapperTable.m_BuildExecution_CreateDataCapture(m_pHandle, sIdentifier.c_str(), sName.c_str(), hOptions, sUserUUID.c_str(), &hDataCaptureInstance));
+		
+		if (!hDataCaptureInstance) {
+			CheckError(LIBMCENV_ERROR_INVALIDPARAM);
+		}
+		return std::make_shared<CDataCapture>(m_pWrapper, hDataCaptureInstance);
+	}
+	
+	/**
+	* CBuildExecution::HasDataCapture - Returns if the execution has a data capture with a certain identifier.
+	* @param[in] sIdentifier - Identifier of the capture.
+	* @return Returns true if the capture exists.
+	*/
+	bool CBuildExecution::HasDataCapture(const std::string & sIdentifier)
+	{
+		bool resultCaptureExists = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_BuildExecution_HasDataCapture(m_pHandle, sIdentifier.c_str(), &resultCaptureExists));
+		
+		return resultCaptureExists;
+	}
+	
+	/**
+	* CBuildExecution::GetDataCaptureRowCount - Returns the number of rows of a data capture that have been stored in segments. Fails if the capture does not exist.
+	* @param[in] sIdentifier - Identifier of the capture.
+	* @return Number of rows.
+	*/
+	LibMCEnv_uint64 CBuildExecution::GetDataCaptureRowCount(const std::string & sIdentifier)
+	{
+		LibMCEnv_uint64 resultRowCount = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_BuildExecution_GetDataCaptureRowCount(m_pHandle, sIdentifier.c_str(), &resultRowCount));
+		
+		return resultRowCount;
+	}
+	
+	/**
+	* CBuildExecution::GetDataCaptureSegmentCount - Returns the number of stored segments of a data capture. Fails if the capture does not exist.
+	* @param[in] sIdentifier - Identifier of the capture.
+	* @return Number of segments.
+	*/
+	LibMCEnv_uint32 CBuildExecution::GetDataCaptureSegmentCount(const std::string & sIdentifier)
+	{
+		LibMCEnv_uint32 resultSegmentCount = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_BuildExecution_GetDataCaptureSegmentCount(m_pHandle, sIdentifier.c_str(), &resultSegmentCount));
+		
+		return resultSegmentCount;
+	}
+	
+	/**
+	* CBuildExecution::LoadDataCaptureSegment - Loads one segment of a data capture as in-memory data table. Fails if the capture or the segment does not exist or the segment has been deleted by retention.
+	* @param[in] sIdentifier - Identifier of the capture.
+	* @param[in] nSegmentIndex - Index of the segment. 0-based.
+	* @return Loaded data table instance.
+	*/
+	PDataTable CBuildExecution::LoadDataCaptureSegment(const std::string & sIdentifier, const LibMCEnv_uint32 nSegmentIndex)
+	{
+		LibMCEnvHandle hDataTableInstance = nullptr;
+		CheckError(m_pWrapper->m_WrapperTable.m_BuildExecution_LoadDataCaptureSegment(m_pHandle, sIdentifier.c_str(), nSegmentIndex, &hDataTableInstance));
+		
+		if (!hDataTableInstance) {
+			CheckError(LIBMCENV_ERROR_INVALIDPARAM);
+		}
+		return std::make_shared<CDataTable>(m_pWrapper, hDataTableInstance);
+	}
+	
+	/**
+	* CBuildExecution::OpenDataCaptureReader - Opens a reader on the stored segments of a data capture. Fails if the capture does not exist.
+	* @param[in] sIdentifier - Identifier of the capture.
+	* @return Reader instance.
+	*/
+	PDataTableReader CBuildExecution::OpenDataCaptureReader(const std::string & sIdentifier)
+	{
+		LibMCEnvHandle hReaderInstance = nullptr;
+		CheckError(m_pWrapper->m_WrapperTable.m_BuildExecution_OpenDataCaptureReader(m_pHandle, sIdentifier.c_str(), &hReaderInstance));
+		
+		if (!hReaderInstance) {
+			CheckError(LIBMCENV_ERROR_INVALIDPARAM);
+		}
+		return std::make_shared<CDataTableReader>(m_pWrapper, hReaderInstance);
+	}
+	
 	/**
 	 * Method definitions for class CBuildExecutionIterator
 	 */
@@ -30873,6 +33296,14 @@ class CUIEnvironment : public CBase {
 		CheckError(m_pWrapper->m_WrapperTable.m_ZIPStreamWriter_CreateZIPEntryFromStream(m_pHandle, sFileName.c_str(), hStreamReader));
 	}
 	
+	/**
+	* CZIPStreamWriter::Discard - Discards the unfinished ZIP stream. The file on disk and the stream entry are deleted. Fails if the stream has been finished already. A ZIP writer that is released without Finish is discarded automatically.
+	*/
+	void CZIPStreamWriter::Discard()
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_ZIPStreamWriter_Discard(m_pHandle));
+	}
+	
 	/**
 	 * Method definitions for class CStreamReader
 	 */
@@ -35176,6 +37607,71 @@ class CUIEnvironment : public CBase {
 		return resultValue;
 	}
 	
+	/**
+	* CStateEnvironment::StartStreamDownloadForSession - Starts a stream download in the browser of a client session. Creates a download ticket for the user of the session and queues the download action for delivery to the session. Returns false if the session does not exist or is not authorized.
+	* @param[in] sSessionUUID - UUID of the client session.
+	* @param[in] sStreamUUID - Storage stream. Fails if the stream does not exist or is not finished.
+	* @param[in] sFileName - File name offered to the browser. Fails if empty.
+	* @return True if the download action was queued for the session.
+	*/
+	bool CStateEnvironment::StartStreamDownloadForSession(const std::string & sSessionUUID, const std::string & sStreamUUID, const std::string & sFileName)
+	{
+		bool resultSuccess = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_StateEnvironment_StartStreamDownloadForSession(m_pHandle, sSessionUUID.c_str(), sStreamUUID.c_str(), sFileName.c_str(), &resultSuccess));
+		
+		return resultSuccess;
+	}
+	
+	/**
+	* CStateEnvironment::GetStreamDownloadProgress - Returns the delivery progress of all downloads of a storage stream.
+	* @param[in] sStreamUUID - Storage stream.
+	* @param[out] nActiveConnections - Connections that are sending the stream right now.
+	* @param[out] nDeliveredBytes - Bytes from the start of the stream that were sent without a gap.
+	* @param[out] nTotalBytes - Size of the stream.
+	* @param[out] bCompleted - The last byte was sent and its connection ended successfully.
+	* @param[out] nMillisecondsSinceActivity - Time since the last chunk was sent or since the download was handed over.
+	*/
+	void CStateEnvironment::GetStreamDownloadProgress(const std::string & sStreamUUID, LibMCEnv_uint32 & nActiveConnections, LibMCEnv_uint64 & nDeliveredBytes, LibMCEnv_uint64 & nTotalBytes, bool & bCompleted, LibMCEnv_uint64 & nMillisecondsSinceActivity)
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_StateEnvironment_GetStreamDownloadProgress(m_pHandle, sStreamUUID.c_str(), &nActiveConnections, &nDeliveredBytes, &nTotalBytes, &bCompleted, &nMillisecondsSinceActivity));
+	}
+	
+	/**
+	* CStateEnvironment::CancelStreamDownloads - Stops all running downloads of a storage stream, revokes its download tickets and drops its unclaimed download actions. Does nothing if the stream was already delivered completely.
+	* @param[in] sStreamUUID - Storage stream.
+	* @return False if the download had already completed and nothing was cancelled.
+	*/
+	bool CStateEnvironment::CancelStreamDownloads(const std::string & sStreamUUID)
+	{
+		bool resultCancelled = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_StateEnvironment_CancelStreamDownloads(m_pHandle, sStreamUUID.c_str(), &resultCancelled));
+		
+		return resultCancelled;
+	}
+	
+	/**
+	* CStateEnvironment::DeleteStorageStream - Deletes a finished storage stream from disk and database, including its download tickets. Fails if the stream does not exist, is still being written or is being downloaded right now.
+	* @param[in] sUUID - UUID of the storage stream.
+	*/
+	void CStateEnvironment::DeleteStorageStream(const std::string & sUUID)
+	{
+		CheckError(m_pWrapper->m_WrapperTable.m_StateEnvironment_DeleteStorageStream(m_pHandle, sUUID.c_str()));
+	}
+	
+	/**
+	* CStateEnvironment::EnforceStreamRetention - Deletes all finished streams with the given name except the newest ones. Streams with running downloads or pending download actions are kept. Returns the number of deleted streams.
+	* @param[in] sName - Name of the streams.
+	* @param[in] nKeepCount - Number of newest streams to keep.
+	* @return Number of deleted streams.
+	*/
+	LibMCEnv_uint32 CStateEnvironment::EnforceStreamRetention(const std::string & sName, const LibMCEnv_uint32 nKeepCount)
+	{
+		LibMCEnv_uint32 resultDeletedCount = 0;
+		CheckError(m_pWrapper->m_WrapperTable.m_StateEnvironment_EnforceStreamRetention(m_pHandle, sName.c_str(), nKeepCount, &resultDeletedCount));
+		
+		return resultDeletedCount;
+	}
+	
 	/**
 	 * Method definitions for class CUIItem
 	 */
diff --git a/Framework/HeadersDev/CppDynamic/libmcenv_types.hpp b/Framework/HeadersDev/CppDynamic/libmcenv_types.hpp
index da7f6da02..1afb4cd64 100644
--- a/Framework/HeadersDev/CppDynamic/libmcenv_types.hpp
+++ b/Framework/HeadersDev/CppDynamic/libmcenv_types.hpp
@@ -364,6 +364,43 @@ typedef void * LibMCEnv_pvoid;
 #define LIBMCENV_ERROR_FORMULAEVALUATIONFAILED 10267 /** Formula evaluation failed. */
 #define LIBMCENV_ERROR_FORMULASESSIONREFERENCESNOTAVAILABLE 10268 /** Session and user references are only available in formulas of the UI environment. */
 #define LIBMCENV_ERROR_INVALIDFORMULAREFERENCEINDEX 10269 /** Invalid formula reference index. */
+#define LIBMCENV_ERROR_COLUMNISNOTOFTYPEFLOAT 10270 /** Column is not of type float. */
+#define LIBMCENV_ERROR_COLUMNISNOTOFTYPEBOOL 10271 /** Column is not of type bool. */
+#define LIBMCENV_ERROR_COLUMNISNOTOFTYPETIMESTAMP 10272 /** Column is not of type timestamp. */
+#define LIBMCENV_ERROR_UNSUPPORTEDDATATABLEVERSION 10273 /** Unsupported datatable format version. */
+#define LIBMCENV_ERROR_UNSUPPORTEDDATATABLEENCODING 10274 /** Unsupported datatable column encoding. */
+#define LIBMCENV_ERROR_INVALIDDATATABLECOLUMNHEADER 10275 /** Invalid datatable column header. */
+#define LIBMCENV_ERROR_DATACAPTURENOTCONFIGURABLE 10276 /** Data capture schema is frozen and can not be changed anymore. */
+#define LIBMCENV_ERROR_DATACAPTURENOTRECORDING 10277 /** Data capture is not recording. */
+#define LIBMCENV_ERROR_DATACAPTURECHUNKALREADYOPEN 10278 /** Data capture has an uncommitted chunk already. */
+#define LIBMCENV_ERROR_DATACAPTURECHUNKINVALID 10279 /** Data capture chunk is invalid or has been committed already. */
+#define LIBMCENV_ERROR_DATACAPTURECHUNKINCOMPLETE 10280 /** Data capture chunk columns have different row counts. */
+#define LIBMCENV_ERROR_DATACAPTURECHUNKOVERFLOW 10281 /** Data capture chunk capacity exceeded. */
+#define LIBMCENV_ERROR_DATACAPTUREQUEUEFULL 10282 /** Data capture queue is full. */
+#define LIBMCENV_ERROR_DATACAPTUREWRITERFAILED 10283 /** Data capture writer failed. */
+#define LIBMCENV_ERROR_INVALIDDATACAPTUREOPTION 10284 /** Invalid data capture option. */
+#define LIBMCENV_ERROR_DATACAPTUREROWNOTOPEN 10285 /** Data capture chunk has no open row. */
+#define LIBMCENV_ERROR_DATACAPTUREROWALREADYOPEN 10286 /** Data capture chunk has an open row already. */
+#define LIBMCENV_ERROR_DATACAPTUREVALUEOUTOFRANGE 10287 /** Data capture value is out of range for the column type. */
+#define LIBMCENV_ERROR_DATACAPTURESEGMENTPURGED 10288 /** Data capture segment has been deleted by retention. */
+#define LIBMCENV_ERROR_EMPTYDATACAPTURENAME 10289 /** Empty data capture name. */
+#define LIBMCENV_ERROR_EMPTYDATACAPTUREIDENTIFIER 10290 /** Empty data capture identifier. */
+#define LIBMCENV_ERROR_INVALIDDATACAPTUREIDENTIFIER 10291 /** Invalid data capture identifier. */
+#define LIBMCENV_ERROR_DATACAPTUREEXECUTIONNOTINPROCESS 10292 /** Data captures can only be created while the build execution is in process. */
+#define LIBMCENV_ERROR_DATATABLESEGMENTTRUNCATED 10293 /** Datatable segment is truncated and has no footer. */
+#define LIBMCENV_ERROR_UNSUPPORTEDDATATABLECODEC 10294 /** Unsupported datatable page codec. */
+#define LIBMCENV_ERROR_INVALIDDATATABLESEGMENT 10295 /** Invalid datatable segment. */
+#define LIBMCENV_ERROR_DATACAPTURECHUNKOUTSTANDING 10296 /** Data capture has an uncommitted chunk. */
+#define LIBMCENV_ERROR_DATACAPTURECOLUMNTYPEMISMATCH 10297 /** Data capture column has a different type. */
+#define LIBMCENV_ERROR_INVALIDDATACAPTURESEGMENTINDEX 10298 /** Invalid data capture segment index. */
+#define LIBMCENV_ERROR_DATACAPTURECOLUMNNOTFOUND 10299 /** Data capture column not found. */
+#define LIBMCENV_ERROR_INVALIDDATATABLEROWRANGE 10300 /** Invalid datatable row range. */
+#define LIBMCENV_ERROR_INVALIDDOWNSAMPLEPARAMETERS 10301 /** Invalid downsample parameters. */
+#define LIBMCENV_ERROR_DATATABLECOLUMNTYPEMISMATCH 10302 /** Datatable column can not be read as the requested type. */
+#define LIBMCENV_ERROR_INVALIDDATATABLECHUNKINDEX 10303 /** Invalid datatable chunk index. */
+#define LIBMCENV_ERROR_STREAMHASACTIVEDOWNLOADS 10304 /** Storage stream has active downloads. */
+#define LIBMCENV_ERROR_ZIPSTREAMALREADYFINISHED 10305 /** ZIP stream has already been finished. */
+#define LIBMCENV_ERROR_SESSIONHANDLERNOTAVAILABLE 10306 /** Session handler is not available. */
 
 /*************************************************************************************************************************
  Error strings for LibMCEnv
@@ -640,6 +677,43 @@ inline const char * LIBMCENV_GETERRORSTRING (LibMCEnvResult nErrorCode) {
     case LIBMCENV_ERROR_FORMULAEVALUATIONFAILED: return "Formula evaluation failed.";
     case LIBMCENV_ERROR_FORMULASESSIONREFERENCESNOTAVAILABLE: return "Session and user references are only available in formulas of the UI environment.";
     case LIBMCENV_ERROR_INVALIDFORMULAREFERENCEINDEX: return "Invalid formula reference index.";
+    case LIBMCENV_ERROR_COLUMNISNOTOFTYPEFLOAT: return "Column is not of type float.";
+    case LIBMCENV_ERROR_COLUMNISNOTOFTYPEBOOL: return "Column is not of type bool.";
+    case LIBMCENV_ERROR_COLUMNISNOTOFTYPETIMESTAMP: return "Column is not of type timestamp.";
+    case LIBMCENV_ERROR_UNSUPPORTEDDATATABLEVERSION: return "Unsupported datatable format version.";
+    case LIBMCENV_ERROR_UNSUPPORTEDDATATABLEENCODING: return "Unsupported datatable column encoding.";
+    case LIBMCENV_ERROR_INVALIDDATATABLECOLUMNHEADER: return "Invalid datatable column header.";
+    case LIBMCENV_ERROR_DATACAPTURENOTCONFIGURABLE: return "Data capture schema is frozen and can not be changed anymore.";
+    case LIBMCENV_ERROR_DATACAPTURENOTRECORDING: return "Data capture is not recording.";
+    case LIBMCENV_ERROR_DATACAPTURECHUNKALREADYOPEN: return "Data capture has an uncommitted chunk already.";
+    case LIBMCENV_ERROR_DATACAPTURECHUNKINVALID: return "Data capture chunk is invalid or has been committed already.";
+    case LIBMCENV_ERROR_DATACAPTURECHUNKINCOMPLETE: return "Data capture chunk columns have different row counts.";
+    case LIBMCENV_ERROR_DATACAPTURECHUNKOVERFLOW: return "Data capture chunk capacity exceeded.";
+    case LIBMCENV_ERROR_DATACAPTUREQUEUEFULL: return "Data capture queue is full.";
+    case LIBMCENV_ERROR_DATACAPTUREWRITERFAILED: return "Data capture writer failed.";
+    case LIBMCENV_ERROR_INVALIDDATACAPTUREOPTION: return "Invalid data capture option.";
+    case LIBMCENV_ERROR_DATACAPTUREROWNOTOPEN: return "Data capture chunk has no open row.";
+    case LIBMCENV_ERROR_DATACAPTUREROWALREADYOPEN: return "Data capture chunk has an open row already.";
+    case LIBMCENV_ERROR_DATACAPTUREVALUEOUTOFRANGE: return "Data capture value is out of range for the column type.";
+    case LIBMCENV_ERROR_DATACAPTURESEGMENTPURGED: return "Data capture segment has been deleted by retention.";
+    case LIBMCENV_ERROR_EMPTYDATACAPTURENAME: return "Empty data capture name.";
+    case LIBMCENV_ERROR_EMPTYDATACAPTUREIDENTIFIER: return "Empty data capture identifier.";
+    case LIBMCENV_ERROR_INVALIDDATACAPTUREIDENTIFIER: return "Invalid data capture identifier.";
+    case LIBMCENV_ERROR_DATACAPTUREEXECUTIONNOTINPROCESS: return "Data captures can only be created while the build execution is in process.";
+    case LIBMCENV_ERROR_DATATABLESEGMENTTRUNCATED: return "Datatable segment is truncated and has no footer.";
+    case LIBMCENV_ERROR_UNSUPPORTEDDATATABLECODEC: return "Unsupported datatable page codec.";
+    case LIBMCENV_ERROR_INVALIDDATATABLESEGMENT: return "Invalid datatable segment.";
+    case LIBMCENV_ERROR_DATACAPTURECHUNKOUTSTANDING: return "Data capture has an uncommitted chunk.";
+    case LIBMCENV_ERROR_DATACAPTURECOLUMNTYPEMISMATCH: return "Data capture column has a different type.";
+    case LIBMCENV_ERROR_INVALIDDATACAPTURESEGMENTINDEX: return "Invalid data capture segment index.";
+    case LIBMCENV_ERROR_DATACAPTURECOLUMNNOTFOUND: return "Data capture column not found.";
+    case LIBMCENV_ERROR_INVALIDDATATABLEROWRANGE: return "Invalid datatable row range.";
+    case LIBMCENV_ERROR_INVALIDDOWNSAMPLEPARAMETERS: return "Invalid downsample parameters.";
+    case LIBMCENV_ERROR_DATATABLECOLUMNTYPEMISMATCH: return "Datatable column can not be read as the requested type.";
+    case LIBMCENV_ERROR_INVALIDDATATABLECHUNKINDEX: return "Invalid datatable chunk index.";
+    case LIBMCENV_ERROR_STREAMHASACTIVEDOWNLOADS: return "Storage stream has active downloads.";
+    case LIBMCENV_ERROR_ZIPSTREAMALREADYFINISHED: return "ZIP stream has already been finished.";
+    case LIBMCENV_ERROR_SESSIONHANDLERNOTAVAILABLE: return "Session handler is not available.";
     default: return "unknown error";
   }
 }
@@ -670,6 +744,10 @@ typedef LibMCEnvHandle LibMCEnv_ScatterPlotDataChannel;
 typedef LibMCEnvHandle LibMCEnv_ScatterPlotDataChannelIterator;
 typedef LibMCEnvHandle LibMCEnv_DataTableScatterPlotOptions;
 typedef LibMCEnvHandle LibMCEnv_DataTable;
+typedef LibMCEnvHandle LibMCEnv_DataCaptureOptions;
+typedef LibMCEnvHandle LibMCEnv_DataCaptureChunk;
+typedef LibMCEnvHandle LibMCEnv_DataCapture;
+typedef LibMCEnvHandle LibMCEnv_DataTableReader;
 typedef LibMCEnvHandle LibMCEnv_DataSeries;
 typedef LibMCEnvHandle LibMCEnv_DateTimeDifference;
 typedef LibMCEnvHandle LibMCEnv_DateTime;
@@ -885,7 +963,48 @@ namespace LibMCEnv {
     Int32Column = 2,
     Uint32Column = 3,
     Int64Column = 4,
-    Uint64Column = 5
+    Uint64Column = 5,
+    FloatColumn = 6,
+    BoolColumn = 7,
+    TimestampColumn = 8
+  };
+  
+  enum class eDataCaptureBackpressureMode : LibMCEnv_int32 {
+    Unknown = 0,
+    Block = 1,
+    DropOldest = 2,
+    Fail = 3
+  };
+  
+  enum class eDataCaptureCompression : LibMCEnv_int32 {
+    Unknown = 0,
+    None = 1,
+    LZ4 = 2,
+    Deflate = 3
+  };
+  
+  enum class eDataCaptureEncoding : LibMCEnv_int32 {
+    Unknown = 0,
+    Automatic = 1,
+    Plain = 2,
+    Delta = 3,
+    BitPack = 4
+  };
+  
+  enum class eDataTableDownsampleMode : LibMCEnv_int32 {
+    Unknown = 0,
+    Stride = 1,
+    MinMax = 2,
+    Average = 3
+  };
+  
+  enum class eDataCaptureStatus : LibMCEnv_int32 {
+    Unknown = 0,
+    Configuring = 1,
+    Recording = 2,
+    Finished = 3,
+    Aborted = 4,
+    Failed = 5
   };
   
   enum class eTelemetryChannelType : LibMCEnv_int32 {
@@ -1014,6 +1133,11 @@ typedef LibMCEnv::eMessageDialogType eLibMCEnvMessageDialogType;
 typedef LibMCEnv::eWorkingFileProcessStatus eLibMCEnvWorkingFileProcessStatus;
 typedef LibMCEnv::eBuildExecutionStatus eLibMCEnvBuildExecutionStatus;
 typedef LibMCEnv::eDataTableColumnType eLibMCEnvDataTableColumnType;
+typedef LibMCEnv::eDataCaptureBackpressureMode eLibMCEnvDataCaptureBackpressureMode;
+typedef LibMCEnv::eDataCaptureCompression eLibMCEnvDataCaptureCompression;
+typedef LibMCEnv::eDataCaptureEncoding eLibMCEnvDataCaptureEncoding;
+typedef LibMCEnv::eDataTableDownsampleMode eLibMCEnvDataTableDownsampleMode;
+typedef LibMCEnv::eDataCaptureStatus eLibMCEnvDataCaptureStatus;
 typedef LibMCEnv::eTelemetryChannelType eLibMCEnvTelemetryChannelType;
 typedef LibMCEnv::eSignalPhase eLibMCEnvSignalPhase;
 typedef LibMCEnv::sPosition2D sLibMCEnvPosition2D;
diff --git a/Framework/InterfacesCore/libmc_abi.hpp b/Framework/InterfacesCore/libmc_abi.hpp
index 262c2efd8..0e3419341 100644
--- a/Framework/InterfacesCore/libmc_abi.hpp
+++ b/Framework/InterfacesCore/libmc_abi.hpp
@@ -240,6 +240,61 @@ LIBMC_DECLSPEC LibMCResult libmc_apirequesthandler_getresultdata(LibMC_APIReques
 */
 LIBMC_DECLSPEC LibMCResult libmc_apirequesthandler_getcontentdispositionname(LibMC_APIRequestHandler pAPIRequestHandler, const LibMC_uint32 nContentDispositionNameBufferSize, LibMC_uint32* pContentDispositionNameNeededChars, char * pContentDispositionNameBuffer);
 
+/**
+* Sets the network address of the client that sent the request. Call before Handle().
+*
+* @param[in] pAPIRequestHandler - APIRequestHandler instance.
+* @param[in] pAddress - Network address of the client.
+* @return error code or 0 (success)
+*/
+LIBMC_DECLSPEC LibMCResult libmc_apirequesthandler_setclientaddress(LibMC_APIRequestHandler pAPIRequestHandler, const char * pAddress);
+
+/**
+* Returns true if the result is a storage stream that must be sent in chunks with ReadResultStreamChunk instead of a buffer. Call only after Handle().
+*
+* @param[in] pAPIRequestHandler - APIRequestHandler instance.
+* @param[out] pHasStream - Result is a stream.
+* @return error code or 0 (success)
+*/
+LIBMC_DECLSPEC LibMCResult libmc_apirequesthandler_hasstreamresult(LibMC_APIRequestHandler pAPIRequestHandler, bool * pHasStream);
+
+/**
+* Returns size and validators of the result stream. Fails if the result is not a stream.
+*
+* @param[in] pAPIRequestHandler - APIRequestHandler instance.
+* @param[out] pSize - Stream size in bytes.
+* @param[in] nETagBufferSize - size of the buffer (including trailing 0)
+* @param[out] pETagNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pETagBuffer -  buffer of Strong entity tag of the stream, without quotes., may be NULL
+* @param[in] nLastModifiedBufferSize - size of the buffer (including trailing 0)
+* @param[out] pLastModifiedNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pLastModifiedBuffer -  buffer of Creation time of the stream as HTTP date., may be NULL
+* @return error code or 0 (success)
+*/
+LIBMC_DECLSPEC LibMCResult libmc_apirequesthandler_getresultstreaminfo(LibMC_APIRequestHandler pAPIRequestHandler, LibMC_uint64 * pSize, const LibMC_uint32 nETagBufferSize, LibMC_uint32* pETagNeededChars, char * pETagBuffer, const LibMC_uint32 nLastModifiedBufferSize, LibMC_uint32* pLastModifiedNeededChars, char * pLastModifiedBuffer);
+
+/**
+* Reads a part of the result stream and records it as sent. Fails if the range is outside the stream, the length exceeds 16 MiB or the download was cancelled.
+*
+* @param[in] pAPIRequestHandler - APIRequestHandler instance.
+* @param[in] nOffset - Start position in bytes.
+* @param[in] nLength - Number of bytes to read.
+* @param[in] nDataBufferSize - Number of elements in buffer
+* @param[out] pDataNeededCount - will be filled with the count of the written elements, or needed buffer size.
+* @param[out] pDataBuffer - uint8  buffer of Data that was read.
+* @return error code or 0 (success)
+*/
+LIBMC_DECLSPEC LibMCResult libmc_apirequesthandler_readresultstreamchunk(LibMC_APIRequestHandler pAPIRequestHandler, LibMC_uint64 nOffset, LibMC_uint64 nLength, const LibMC_uint64 nDataBufferSize, LibMC_uint64* pDataNeededCount, LibMC_uint8 * pDataBuffer);
+
+/**
+* Reports that sending the result stream has ended. May be called more than once and without any chunk having been read.
+*
+* @param[in] pAPIRequestHandler - APIRequestHandler instance.
+* @param[in] bSuccess - All requested bytes were sent.
+* @return error code or 0 (success)
+*/
+LIBMC_DECLSPEC LibMCResult libmc_apirequesthandler_finishstreamresult(LibMC_APIRequestHandler pAPIRequestHandler, bool bSuccess);
+
 /*************************************************************************************************************************
  Class definition for MCContext
 **************************************************************************************************************************/
diff --git a/Framework/InterfacesCore/libmc_interfaces.hpp b/Framework/InterfacesCore/libmc_interfaces.hpp
index 620097c17..8859890c9 100644
--- a/Framework/InterfacesCore/libmc_interfaces.hpp
+++ b/Framework/InterfacesCore/libmc_interfaces.hpp
@@ -379,6 +379,42 @@ class IAPIRequestHandler : public virtual IBase {
 	*/
 	virtual std::string GetContentDispositionName() = 0;
 
+	/**
+	* IAPIRequestHandler::SetClientAddress - Sets the network address of the client that sent the request. Call before Handle().
+	* @param[in] sAddress - Network address of the client.
+	*/
+	virtual void SetClientAddress(const std::string & sAddress) = 0;
+
+	/**
+	* IAPIRequestHandler::HasStreamResult - Returns true if the result is a storage stream that must be sent in chunks with ReadResultStreamChunk instead of a buffer. Call only after Handle().
+	* @return Result is a stream.
+	*/
+	virtual bool HasStreamResult() = 0;
+
+	/**
+	* IAPIRequestHandler::GetResultStreamInfo - Returns size and validators of the result stream. Fails if the result is not a stream.
+	* @param[out] nSize - Stream size in bytes.
+	* @param[out] sETag - Strong entity tag of the stream, without quotes.
+	* @param[out] sLastModified - Creation time of the stream as HTTP date.
+	*/
+	virtual void GetResultStreamInfo(LibMC_uint64 & nSize, std::string & sETag, std::string & sLastModified) = 0;
+
+	/**
+	* IAPIRequestHandler::ReadResultStreamChunk - Reads a part of the result stream and records it as sent. Fails if the range is outside the stream, the length exceeds 16 MiB or the download was cancelled.
+	* @param[in] nOffset - Start position in bytes.
+	* @param[in] nLength - Number of bytes to read.
+	* @param[in] nDataBufferSize - Number of elements in buffer
+	* @param[out] pDataNeededCount - will be filled with the count of the written structs, or needed buffer size.
+	* @param[out] pDataBuffer - uint8 buffer of Data that was read.
+	*/
+	virtual void ReadResultStreamChunk(const LibMC_uint64 nOffset, const LibMC_uint64 nLength, LibMC_uint64 nDataBufferSize, LibMC_uint64* pDataNeededCount, LibMC_uint8 * pDataBuffer) = 0;
+
+	/**
+	* IAPIRequestHandler::FinishStreamResult - Reports that sending the result stream has ended. May be called more than once and without any chunk having been read.
+	* @param[in] bSuccess - All requested bytes were sent.
+	*/
+	virtual void FinishStreamResult(const bool bSuccess) = 0;
+
 };
 
 typedef IBaseSharedPtr<IAPIRequestHandler> PIAPIRequestHandler;
diff --git a/Framework/InterfacesCore/libmc_interfacewrapper.cpp b/Framework/InterfacesCore/libmc_interfacewrapper.cpp
index ba210bdcd..df3ace599 100644
--- a/Framework/InterfacesCore/libmc_interfacewrapper.cpp
+++ b/Framework/InterfacesCore/libmc_interfacewrapper.cpp
@@ -616,6 +616,171 @@ LibMCResult libmc_apirequesthandler_getcontentdispositionname(LibMC_APIRequestHa
 	}
 }
 
+LibMCResult libmc_apirequesthandler_setclientaddress(LibMC_APIRequestHandler pAPIRequestHandler, const char * pAddress)
+{
+	IBase* pIBaseClass = (IBase *)pAPIRequestHandler;
+
+	try {
+		if (pAddress == nullptr)
+			throw ELibMCInterfaceException (LIBMC_ERROR_INVALIDPARAM);
+		std::string sAddress(pAddress);
+		IAPIRequestHandler* pIAPIRequestHandler = dynamic_cast<IAPIRequestHandler*>(pIBaseClass);
+		if (!pIAPIRequestHandler)
+			throw ELibMCInterfaceException(LIBMC_ERROR_INVALIDCAST);
+		
+		pIAPIRequestHandler->SetClientAddress(sAddress);
+
+		return LIBMC_SUCCESS;
+	}
+	catch (ELibMCInterfaceException & Exception) {
+		return handleLibMCException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCResult libmc_apirequesthandler_hasstreamresult(LibMC_APIRequestHandler pAPIRequestHandler, bool * pHasStream)
+{
+	IBase* pIBaseClass = (IBase *)pAPIRequestHandler;
+
+	try {
+		if (pHasStream == nullptr)
+			throw ELibMCInterfaceException (LIBMC_ERROR_INVALIDPARAM);
+		IAPIRequestHandler* pIAPIRequestHandler = dynamic_cast<IAPIRequestHandler*>(pIBaseClass);
+		if (!pIAPIRequestHandler)
+			throw ELibMCInterfaceException(LIBMC_ERROR_INVALIDCAST);
+		
+		*pHasStream = pIAPIRequestHandler->HasStreamResult();
+
+		return LIBMC_SUCCESS;
+	}
+	catch (ELibMCInterfaceException & Exception) {
+		return handleLibMCException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCResult libmc_apirequesthandler_getresultstreaminfo(LibMC_APIRequestHandler pAPIRequestHandler, LibMC_uint64 * pSize, const LibMC_uint32 nETagBufferSize, LibMC_uint32* pETagNeededChars, char * pETagBuffer, const LibMC_uint32 nLastModifiedBufferSize, LibMC_uint32* pLastModifiedNeededChars, char * pLastModifiedBuffer)
+{
+	IBase* pIBaseClass = (IBase *)pAPIRequestHandler;
+
+	try {
+		if (!pSize)
+			throw ELibMCInterfaceException (LIBMC_ERROR_INVALIDPARAM);
+		if ( (!pETagBuffer) && !(pETagNeededChars) )
+			throw ELibMCInterfaceException (LIBMC_ERROR_INVALIDPARAM);
+		if ( (!pLastModifiedBuffer) && !(pLastModifiedNeededChars) )
+			throw ELibMCInterfaceException (LIBMC_ERROR_INVALIDPARAM);
+		std::string sETag("");
+		std::string sLastModified("");
+		IAPIRequestHandler* pIAPIRequestHandler = dynamic_cast<IAPIRequestHandler*>(pIBaseClass);
+		if (!pIAPIRequestHandler)
+			throw ELibMCInterfaceException(LIBMC_ERROR_INVALIDCAST);
+		
+		bool isCacheCall = (pETagBuffer == nullptr) || (pLastModifiedBuffer == nullptr);
+		if (isCacheCall) {
+			pIAPIRequestHandler->GetResultStreamInfo(*pSize, sETag, sLastModified);
+
+			pIAPIRequestHandler->_setCache (new ParameterCache_3<LibMC_uint64, std::string, std::string> (*pSize, sETag, sLastModified));
+		}
+		else {
+			auto cache = dynamic_cast<ParameterCache_3<LibMC_uint64, std::string, std::string>*> (pIAPIRequestHandler->_getCache ());
+			if (cache == nullptr)
+				throw ELibMCInterfaceException(LIBMC_ERROR_INVALIDCAST);
+			cache->retrieveData (*pSize, sETag, sLastModified);
+			pIAPIRequestHandler->_setCache (nullptr);
+		}
+		
+		if (pETagNeededChars)
+			*pETagNeededChars = (LibMC_uint32) (sETag.size()+1);
+		if (pETagBuffer) {
+			if (sETag.size() >= nETagBufferSize)
+				throw ELibMCInterfaceException (LIBMC_ERROR_BUFFERTOOSMALL);
+			for (size_t iETag = 0; iETag < sETag.size(); iETag++)
+				pETagBuffer[iETag] = sETag[iETag];
+			pETagBuffer[sETag.size()] = 0;
+		}
+		if (pLastModifiedNeededChars)
+			*pLastModifiedNeededChars = (LibMC_uint32) (sLastModified.size()+1);
+		if (pLastModifiedBuffer) {
+			if (sLastModified.size() >= nLastModifiedBufferSize)
+				throw ELibMCInterfaceException (LIBMC_ERROR_BUFFERTOOSMALL);
+			for (size_t iLastModified = 0; iLastModified < sLastModified.size(); iLastModified++)
+				pLastModifiedBuffer[iLastModified] = sLastModified[iLastModified];
+			pLastModifiedBuffer[sLastModified.size()] = 0;
+		}
+		return LIBMC_SUCCESS;
+	}
+	catch (ELibMCInterfaceException & Exception) {
+		return handleLibMCException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCResult libmc_apirequesthandler_readresultstreamchunk(LibMC_APIRequestHandler pAPIRequestHandler, LibMC_uint64 nOffset, LibMC_uint64 nLength, const LibMC_uint64 nDataBufferSize, LibMC_uint64* pDataNeededCount, LibMC_uint8 * pDataBuffer)
+{
+	IBase* pIBaseClass = (IBase *)pAPIRequestHandler;
+
+	try {
+		if ((!pDataBuffer) && !(pDataNeededCount))
+			throw ELibMCInterfaceException (LIBMC_ERROR_INVALIDPARAM);
+		IAPIRequestHandler* pIAPIRequestHandler = dynamic_cast<IAPIRequestHandler*>(pIBaseClass);
+		if (!pIAPIRequestHandler)
+			throw ELibMCInterfaceException(LIBMC_ERROR_INVALIDCAST);
+		
+		pIAPIRequestHandler->ReadResultStreamChunk(nOffset, nLength, nDataBufferSize, pDataNeededCount, pDataBuffer);
+
+		return LIBMC_SUCCESS;
+	}
+	catch (ELibMCInterfaceException & Exception) {
+		return handleLibMCException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCResult libmc_apirequesthandler_finishstreamresult(LibMC_APIRequestHandler pAPIRequestHandler, bool bSuccess)
+{
+	IBase* pIBaseClass = (IBase *)pAPIRequestHandler;
+
+	try {
+		IAPIRequestHandler* pIAPIRequestHandler = dynamic_cast<IAPIRequestHandler*>(pIBaseClass);
+		if (!pIAPIRequestHandler)
+			throw ELibMCInterfaceException(LIBMC_ERROR_INVALIDCAST);
+		
+		pIAPIRequestHandler->FinishStreamResult(bSuccess);
+
+		return LIBMC_SUCCESS;
+	}
+	catch (ELibMCInterfaceException & Exception) {
+		return handleLibMCException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
 
 /*************************************************************************************************************************
  Class implementation for MCContext
@@ -1093,6 +1258,16 @@ LibMCResult LibMC::Impl::LibMC_GetProcAddress (const char * pProcName, void ** p
 		*ppProcAddress = (void*) &libmc_apirequesthandler_getresultdata;
 	if (sProcName == "libmc_apirequesthandler_getcontentdispositionname") 
 		*ppProcAddress = (void*) &libmc_apirequesthandler_getcontentdispositionname;
+	if (sProcName == "libmc_apirequesthandler_setclientaddress") 
+		*ppProcAddress = (void*) &libmc_apirequesthandler_setclientaddress;
+	if (sProcName == "libmc_apirequesthandler_hasstreamresult") 
+		*ppProcAddress = (void*) &libmc_apirequesthandler_hasstreamresult;
+	if (sProcName == "libmc_apirequesthandler_getresultstreaminfo") 
+		*ppProcAddress = (void*) &libmc_apirequesthandler_getresultstreaminfo;
+	if (sProcName == "libmc_apirequesthandler_readresultstreamchunk") 
+		*ppProcAddress = (void*) &libmc_apirequesthandler_readresultstreamchunk;
+	if (sProcName == "libmc_apirequesthandler_finishstreamresult") 
+		*ppProcAddress = (void*) &libmc_apirequesthandler_finishstreamresult;
 	if (sProcName == "libmc_mccontext_registerlibrarypath") 
 		*ppProcAddress = (void*) &libmc_mccontext_registerlibrarypath;
 	if (sProcName == "libmc_mccontext_settempbasepath") 
diff --git a/Framework/InterfacesCore/libmc_types.hpp b/Framework/InterfacesCore/libmc_types.hpp
index 3166875d8..a3453bd14 100644
--- a/Framework/InterfacesCore/libmc_types.hpp
+++ b/Framework/InterfacesCore/libmc_types.hpp
@@ -734,6 +734,15 @@ typedef void * LibMC_pvoid;
 #define LIBMC_ERROR_INVALIDTELEMETRYSETTING 718 /** Invalid telemetry setting. */
 #define LIBMC_ERROR_INVALIDTOOLPATHPROFILEINDEX 719 /** Invalid toolpath profile index. */
 #define LIBMC_ERROR_INVALIDTOOLPATHMODIFIERINDEX 720 /** Invalid toolpath modifier index. */
+#define LIBMC_ERROR_NOSTREAMRESULT 721 /** API response is not a stream. */
+#define LIBMC_ERROR_DOWNLOADCANCELLED 722 /** Download was cancelled. */
+#define LIBMC_ERROR_INVALIDSTREAMCHUNK 723 /** Invalid stream chunk range. */
+#define LIBMC_ERROR_DOWNLOADTICKETEXPIRED 724 /** Download ticket has expired or has been revoked. */
+#define LIBMC_ERROR_TOOMANYDOWNLOADS 725 /** Too many concurrent downloads. */
+#define LIBMC_ERROR_CLIENTACTIONNOTFOUND 726 /** Client action not found. */
+#define LIBMC_ERROR_CLIENTACTIONALREADYCLAIMED 727 /** Client action has already been claimed. */
+#define LIBMC_ERROR_STREAMHASACTIVEDOWNLOADS 728 /** Storage stream has active downloads. */
+#define LIBMC_ERROR_SESSIONHANDLERNOTAVAILABLE 729 /** Session handler is not available. */
 
 /*************************************************************************************************************************
  Error strings for LibMC
@@ -1380,6 +1389,15 @@ inline const char * LIBMC_GETERRORSTRING (LibMCResult nErrorCode) {
     case LIBMC_ERROR_INVALIDTELEMETRYSETTING: return "Invalid telemetry setting.";
     case LIBMC_ERROR_INVALIDTOOLPATHPROFILEINDEX: return "Invalid toolpath profile index.";
     case LIBMC_ERROR_INVALIDTOOLPATHMODIFIERINDEX: return "Invalid toolpath modifier index.";
+    case LIBMC_ERROR_NOSTREAMRESULT: return "API response is not a stream.";
+    case LIBMC_ERROR_DOWNLOADCANCELLED: return "Download was cancelled.";
+    case LIBMC_ERROR_INVALIDSTREAMCHUNK: return "Invalid stream chunk range.";
+    case LIBMC_ERROR_DOWNLOADTICKETEXPIRED: return "Download ticket has expired or has been revoked.";
+    case LIBMC_ERROR_TOOMANYDOWNLOADS: return "Too many concurrent downloads.";
+    case LIBMC_ERROR_CLIENTACTIONNOTFOUND: return "Client action not found.";
+    case LIBMC_ERROR_CLIENTACTIONALREADYCLAIMED: return "Client action has already been claimed.";
+    case LIBMC_ERROR_STREAMHASACTIVEDOWNLOADS: return "Storage stream has active downloads.";
+    case LIBMC_ERROR_SESSIONHANDLERNOTAVAILABLE: return "Session handler is not available.";
     default: return "unknown error";
   }
 }
diff --git a/Framework/InterfacesCore/libmcdata_abi.hpp b/Framework/InterfacesCore/libmcdata_abi.hpp
index 98e1f41ee..e3b72d21d 100644
--- a/Framework/InterfacesCore/libmcdata_abi.hpp
+++ b/Framework/InterfacesCore/libmcdata_abi.hpp
@@ -1169,6 +1169,14 @@ LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_storagezipwriter_finish(LibMCData_S
 */
 LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_storagezipwriter_isfinished(LibMCData_StorageZIPWriter pStorageZIPWriter, bool * pFinished);
 
+/**
+* Discards an unfinished ZIP stream. The file on disk and the stream entry are deleted. Fails if the stream has been finished already. A ZIP writer that is released without Finish is discarded automatically.
+*
+* @param[in] pStorageZIPWriter - StorageZIPWriter instance.
+* @return error code or 0 (success)
+*/
+LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_storagezipwriter_discard(LibMCData_StorageZIPWriter pStorageZIPWriter);
+
 /*************************************************************************************************************************
  Class definition for Storage
 **************************************************************************************************************************/
@@ -1377,6 +1385,95 @@ LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_storage_createdownloadticket(LibMCD
 */
 LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_storage_requestdownloadticket(LibMCData_Storage pStorage, const char * pTicketUUID, const char * pIPAddress, LibMCData_uint64 nAbsoluteTimeStamp, const LibMCData_uint32 nStreamUUIDBufferSize, LibMCData_uint32* pStreamUUIDNeededChars, char * pStreamUUIDBuffer, const LibMCData_uint32 nClientFileNameBufferSize, LibMCData_uint32* pClientFileNameNeededChars, char * pClientFileNameBuffer, const LibMCData_uint32 nSessionUUIDBufferSize, LibMCData_uint32* pSessionUUIDNeededChars, char * pSessionUUIDBuffer, const LibMCData_uint32 nUserUUIDBufferSize, LibMCData_uint32* pUserUUIDNeededChars, char * pUserUUIDBuffer);
 
+/**
+* Returns the details of a download ticket without creating an access log entry. Fails if the ticket does not exist.
+*
+* @param[in] pStorage - Storage instance.
+* @param[in] pTicketUUID - UUID of download ticket.
+* @param[in] nStreamUUIDBufferSize - size of the buffer (including trailing 0)
+* @param[out] pStreamUUIDNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pStreamUUIDBuffer -  buffer of UUID of storage stream., may be NULL
+* @param[in] nClientFileNameBufferSize - size of the buffer (including trailing 0)
+* @param[out] pClientFileNameNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pClientFileNameBuffer -  buffer of ClientFileName of the ticket., may be NULL
+* @param[in] nSessionUUIDBufferSize - size of the buffer (including trailing 0)
+* @param[out] pSessionUUIDNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pSessionUUIDBuffer -  buffer of UUID of user session., may be NULL
+* @param[in] nUserUUIDBufferSize - size of the buffer (including trailing 0)
+* @param[out] pUserUUIDNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pUserUUIDBuffer -  buffer of UUID of user that created the ticket., may be NULL
+* @param[out] pCreationTimeStamp - Creation time of the ticket in microseconds since 1970.
+* @param[out] pRevoked - True if the ticket has been revoked.
+* @return error code or 0 (success)
+*/
+LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_storage_getdownloadticketdetails(LibMCData_Storage pStorage, const char * pTicketUUID, const LibMCData_uint32 nStreamUUIDBufferSize, LibMCData_uint32* pStreamUUIDNeededChars, char * pStreamUUIDBuffer, const LibMCData_uint32 nClientFileNameBufferSize, LibMCData_uint32* pClientFileNameNeededChars, char * pClientFileNameBuffer, const LibMCData_uint32 nSessionUUIDBufferSize, LibMCData_uint32* pSessionUUIDNeededChars, char * pSessionUUIDBuffer, const LibMCData_uint32 nUserUUIDBufferSize, LibMCData_uint32* pUserUUIDNeededChars, char * pUserUUIDBuffer, LibMCData_uint64 * pCreationTimeStamp, bool * pRevoked);
+
+/**
+* Revokes all download tickets of a stream. Revoked tickets can not be used for downloads anymore.
+*
+* @param[in] pStorage - Storage instance.
+* @param[in] pStreamUUID - UUID of storage stream.
+* @param[out] pRevokedCount - Number of tickets that were revoked by this call.
+* @return error code or 0 (success)
+*/
+LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_storage_revokedownloadticketsofstream(LibMCData_Storage pStorage, const char * pStreamUUID, LibMCData_uint32 * pRevokedCount);
+
+/**
+* Creates an entry in the download access log of a ticket and returns the UUID of the entry.
+*
+* @param[in] pStorage - Storage instance.
+* @param[in] pTicketUUID - UUID of download ticket.
+* @param[in] pIPAddress - IP Address where the request came from.
+* @param[in] nAbsoluteTimeStamp - Absolute Time Stamp in Microseconds since 1970.
+* @param[in] nDownloadUUIDBufferSize - size of the buffer (including trailing 0)
+* @param[out] pDownloadUUIDNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pDownloadUUIDBuffer -  buffer of UUID of the access log entry., may be NULL
+* @return error code or 0 (success)
+*/
+LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_storage_logdownloadstart(LibMCData_Storage pStorage, const char * pTicketUUID, const char * pIPAddress, LibMCData_uint64 nAbsoluteTimeStamp, const LibMCData_uint32 nDownloadUUIDBufferSize, LibMCData_uint32* pDownloadUUIDNeededChars, char * pDownloadUUIDBuffer);
+
+/**
+* Records the result of a download in its access log entry. Fails if the entry does not exist.
+*
+* @param[in] pStorage - Storage instance.
+* @param[in] pDownloadUUID - UUID of the access log entry.
+* @param[in] nSentBytes - Number of bytes that were sent to the client.
+* @param[in] bSuccess - True if all requested bytes were sent.
+* @param[in] nAbsoluteTimeStamp - Absolute Time Stamp in Microseconds since 1970.
+* @return error code or 0 (success)
+*/
+LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_storage_logdownloadfinish(LibMCData_Storage pStorage, const char * pDownloadUUID, LibMCData_uint64 nSentBytes, bool bSuccess, LibMCData_uint64 nAbsoluteTimeStamp);
+
+/**
+* Deletes a finished stream from disk and database, including its download tickets and journal links. Fails if the stream does not exist or is still being written.
+*
+* @param[in] pStorage - Storage instance.
+* @param[in] pUUID - UUID of storage stream.
+* @return error code or 0 (success)
+*/
+LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_storage_deletestream(LibMCData_Storage pStorage, const char * pUUID);
+
+/**
+* Deletes all ZIP streams that were never finished and have no active writer, for example after a crash. Returns the number of deleted streams.
+*
+* @param[in] pStorage - Storage instance.
+* @param[out] pDeletedCount - Number of deleted streams.
+* @return error code or 0 (success)
+*/
+LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_storage_discardunfinishedzipstreams(LibMCData_Storage pStorage, LibMCData_uint32 * pDeletedCount);
+
+/**
+* Returns the UUIDs of all finished streams with the given name, newest first, separated by commas.
+*
+* @param[in] pStorage - Storage instance.
+* @param[in] pName - Name of the streams.
+* @param[in] nUUIDListBufferSize - size of the buffer (including trailing 0)
+* @param[out] pUUIDListNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pUUIDListBuffer -  buffer of Comma separated list of stream UUIDs. Empty if there is none., may be NULL
+* @return error code or 0 (success)
+*/
+LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_storage_liststreamuuidsbyname(LibMCData_Storage pStorage, const char * pName, const LibMCData_uint32 nUUIDListBufferSize, LibMCData_uint32* pUUIDListNeededChars, char * pUUIDListBuffer);
+
 /**
 * Attaches a stream to a journal as temporary stream.
 *
@@ -1387,6 +1484,34 @@ LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_storage_requestdownloadticket(LibMC
 */
 LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_storage_attachstreamtojournal(LibMCData_Storage pStorage, const char * pStreamUUID, const char * pJournalUUID);
 
+/**
+* Discards an unfinished random write stream. The data on disk and the stream entry are deleted.
+*
+* @param[in] pStorage - Storage instance.
+* @param[in] pUUID - UUID of storage stream. MUST have been created with BeginRandomWriteStream first and MUST NOT be finished.
+* @return error code or 0 (success)
+*/
+LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_storage_discardrandomwritestream(LibMCData_Storage pStorage, const char * pUUID);
+
+/**
+* Returns the size of all data capture segments that are stored on disk.
+*
+* @param[in] pStorage - Storage instance.
+* @param[out] pSizeInBytes - Size in bytes.
+* @return error code or 0 (success)
+*/
+LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_storage_getdatacapturestoragesize(LibMCData_Storage pStorage, LibMCData_uint64 * pSizeInBytes);
+
+/**
+* Deletes the oldest stored data capture segments until the total stored size is within the limit.
+*
+* @param[in] pStorage - Storage instance.
+* @param[in] nLimitInBytes - Maximum total size of all stored data capture segments in bytes.
+* @param[out] pPurgedSegmentCount - Number of segments that have been deleted.
+* @return error code or 0 (success)
+*/
+LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_storage_enforcedatacapturestoragelimit(LibMCData_Storage pStorage, LibMCData_uint64 nLimitInBytes, LibMCData_uint32 * pPurgedSegmentCount);
+
 /*************************************************************************************************************************
  Class definition for CustomDataStream
 **************************************************************************************************************************/
@@ -1573,6 +1698,198 @@ LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_buildjobexecutiondata_getexecutionu
 */
 LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_buildjobexecutiondataiterator_getcurrentjobexecutiondata(LibMCData_BuildJobExecutionDataIterator pBuildJobExecutionDataIterator, LibMCData_BuildJobExecutionData * pCurrentInstance);
 
+/*************************************************************************************************************************
+ Class definition for DataCapture
+**************************************************************************************************************************/
+
+/**
+* returns the uuid of the data capture.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[in] nUUIDBufferSize - size of the buffer (including trailing 0)
+* @param[out] pUUIDNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pUUIDBuffer -  buffer of UUID String, may be NULL
+* @return error code or 0 (success)
+*/
+LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_datacapture_getuuid(LibMCData_DataCapture pDataCapture, const LibMCData_uint32 nUUIDBufferSize, LibMCData_uint32* pUUIDNeededChars, char * pUUIDBuffer);
+
+/**
+* returns the uuid of the build job execution the capture belongs to.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[in] nExecutionUUIDBufferSize - size of the buffer (including trailing 0)
+* @param[out] pExecutionUUIDNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pExecutionUUIDBuffer -  buffer of UUID String, may be NULL
+* @return error code or 0 (success)
+*/
+LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_datacapture_getexecutionuuid(LibMCData_DataCapture pDataCapture, const LibMCData_uint32 nExecutionUUIDBufferSize, LibMCData_uint32* pExecutionUUIDNeededChars, char * pExecutionUUIDBuffer);
+
+/**
+* returns the identifier of the data capture. It is unique within the build job execution.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[in] nIdentifierBufferSize - size of the buffer (including trailing 0)
+* @param[out] pIdentifierNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pIdentifierBuffer -  buffer of Identifier String, may be NULL
+* @return error code or 0 (success)
+*/
+LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_datacapture_getidentifier(LibMCData_DataCapture pDataCapture, const LibMCData_uint32 nIdentifierBufferSize, LibMCData_uint32* pIdentifierNeededChars, char * pIdentifierBuffer);
+
+/**
+* returns the human readable name of the data capture.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[in] nNameBufferSize - size of the buffer (including trailing 0)
+* @param[out] pNameNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pNameBuffer -  buffer of Name String, may be NULL
+* @return error code or 0 (success)
+*/
+LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_datacapture_getname(LibMCData_DataCapture pDataCapture, const LibMCData_uint32 nNameBufferSize, LibMCData_uint32* pNameNeededChars, char * pNameBuffer);
+
+/**
+* returns the current status of the data capture.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[out] pStatus - Status Value
+* @return error code or 0 (success)
+*/
+LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_datacapture_getstatus(LibMCData_DataCapture pDataCapture, LibMCData::eDataCaptureStatus * pStatus);
+
+/**
+* returns the time stamp when the data capture was created.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[in] nTimeStampBufferSize - size of the buffer (including trailing 0)
+* @param[out] pTimeStampNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pTimeStampBuffer -  buffer of Timestamp in ISO8601 UTC format, may be NULL
+* @return error code or 0 (success)
+*/
+LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_datacapture_gettimestamp(LibMCData_DataCapture pDataCapture, const LibMCData_uint32 nTimeStampBufferSize, LibMCData_uint32* pTimeStampNeededChars, char * pTimeStampBuffer);
+
+/**
+* Registers a column of the capture schema. Fails if the capture is not recording or the column index already exists.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[in] nColumnIndex - Index of the column. 0-based.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] pDescription - Description of the column.
+* @param[in] nColumnType - Data type of the column as numeric data table column type.
+* @return error code or 0 (success)
+*/
+LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_datacapture_addcolumn(LibMCData_DataCapture pDataCapture, LibMCData_uint32 nColumnIndex, const char * pIdentifier, const char * pDescription, LibMCData_uint32 nColumnType);
+
+/**
+* returns the number of columns of the capture schema.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[out] pColumnCount - Number of columns.
+* @return error code or 0 (success)
+*/
+LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_datacapture_getcolumncount(LibMCData_DataCapture pDataCapture, LibMCData_uint32 * pColumnCount);
+
+/**
+* returns the schema information of a column. Fails if the index does not exist.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[in] nColumnIndex - Index of the column. 0-based.
+* @param[in] nIdentifierBufferSize - size of the buffer (including trailing 0)
+* @param[out] pIdentifierNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pIdentifierBuffer -  buffer of Identifier of the column., may be NULL
+* @param[in] nDescriptionBufferSize - size of the buffer (including trailing 0)
+* @param[out] pDescriptionNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pDescriptionBuffer -  buffer of Description of the column., may be NULL
+* @param[out] pColumnType - Data type of the column as numeric data table column type.
+* @return error code or 0 (success)
+*/
+LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_datacapture_getcolumninformation(LibMCData_DataCapture pDataCapture, LibMCData_uint32 nColumnIndex, const LibMCData_uint32 nIdentifierBufferSize, LibMCData_uint32* pIdentifierNeededChars, char * pIdentifierBuffer, const LibMCData_uint32 nDescriptionBufferSize, LibMCData_uint32* pDescriptionNeededChars, char * pDescriptionBuffer, LibMCData_uint32 * pColumnType);
+
+/**
+* Registers a finished segment stream of the capture. Fails if the capture is not recording or the segment index already exists.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[in] nSegmentIndex - Index of the segment. 0-based.
+* @param[in] pStreamUUID - UUID of the storage stream that holds the segment. The stream MUST exist.
+* @param[in] nFirstRow - Index of the first row of the segment within the capture.
+* @param[in] nRowCount - Number of rows in the segment.
+* @param[in] nChunkCount - Number of chunks in the segment.
+* @param[in] nSizeInBytes - Size of the segment stream in bytes.
+* @param[in] nStartTimeStamp - Absolute time stamp in microseconds since 1970 when the segment was opened.
+* @param[in] nEndTimeStamp - Absolute time stamp in microseconds since 1970 when the segment was closed.
+* @return error code or 0 (success)
+*/
+LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_datacapture_addsegment(LibMCData_DataCapture pDataCapture, LibMCData_uint32 nSegmentIndex, const char * pStreamUUID, LibMCData_uint64 nFirstRow, LibMCData_uint64 nRowCount, LibMCData_uint32 nChunkCount, LibMCData_uint64 nSizeInBytes, LibMCData_uint64 nStartTimeStamp, LibMCData_uint64 nEndTimeStamp);
+
+/**
+* returns the number of registered segments, including purged ones.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[out] pSegmentCount - Number of segments.
+* @return error code or 0 (success)
+*/
+LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_datacapture_getsegmentcount(LibMCData_DataCapture pDataCapture, LibMCData_uint32 * pSegmentCount);
+
+/**
+* returns the manifest entry of a segment. Fails if the index does not exist.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[in] nSegmentIndex - Index of the segment. 0-based.
+* @param[in] nStreamUUIDBufferSize - size of the buffer (including trailing 0)
+* @param[out] pStreamUUIDNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pStreamUUIDBuffer -  buffer of UUID of the storage stream that holds the segment., may be NULL
+* @param[out] pFirstRow - Index of the first row of the segment within the capture.
+* @param[out] pRowCount - Number of rows in the segment.
+* @param[out] pSizeInBytes - Size of the segment stream in bytes.
+* @param[out] pIsPurged - Returns true if the segment data has been deleted by retention or abort.
+* @return error code or 0 (success)
+*/
+LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_datacapture_getsegmentinformation(LibMCData_DataCapture pDataCapture, LibMCData_uint32 nSegmentIndex, const LibMCData_uint32 nStreamUUIDBufferSize, LibMCData_uint32* pStreamUUIDNeededChars, char * pStreamUUIDBuffer, LibMCData_uint64 * pFirstRow, LibMCData_uint64 * pRowCount, LibMCData_uint64 * pSizeInBytes, bool * pIsPurged);
+
+/**
+* returns the number of chunks of a segment. Fails if the index does not exist.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[in] nSegmentIndex - Index of the segment. 0-based.
+* @param[out] pChunkCount - Number of chunks in the segment.
+* @return error code or 0 (success)
+*/
+LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_datacapture_getsegmentchunkcount(LibMCData_DataCapture pDataCapture, LibMCData_uint32 nSegmentIndex, LibMCData_uint32 * pChunkCount);
+
+/**
+* returns the number of rows in all registered segments, including purged ones.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[out] pRowCount - Number of rows.
+* @return error code or 0 (success)
+*/
+LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_datacapture_getrowcount(LibMCData_DataCapture pDataCapture, LibMCData_uint64 * pRowCount);
+
+/**
+* returns the size of all segments of the capture that are still stored on disk.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[out] pSizeInBytes - Size in bytes.
+* @return error code or 0 (success)
+*/
+LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_datacapture_getstoredsizeinbytes(LibMCData_DataCapture pDataCapture, LibMCData_uint64 * pSizeInBytes);
+
+/**
+* Marks the capture as finished. Fails if the capture is not recording.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[in] nAbsoluteTimeStamp - Absolute Time Stamp in Microseconds since 1970.
+* @return error code or 0 (success)
+*/
+LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_datacapture_finish(LibMCData_DataCapture pDataCapture, LibMCData_uint64 nAbsoluteTimeStamp);
+
+/**
+* Deletes all stored segments of the capture and marks it as aborted. Fails if the capture has been aborted before.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[in] nAbsoluteTimeStamp - Absolute Time Stamp in Microseconds since 1970.
+* @return error code or 0 (success)
+*/
+LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_datacapture_abort(LibMCData_DataCapture pDataCapture, LibMCData_uint64 nAbsoluteTimeStamp);
+
 /*************************************************************************************************************************
  Class definition for BuildJobExecution
 **************************************************************************************************************************/
@@ -1849,6 +2166,58 @@ LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_buildjobexecution_hasmetadatastring
 */
 LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_buildjobexecution_getmetadatastring(LibMCData_BuildJobExecution pBuildJobExecution, const char * pKey, const LibMCData_uint32 nValueBufferSize, LibMCData_uint32* pValueNeededChars, char * pValueBuffer);
 
+/**
+* Creates the manifest of a new data capture in recording state. Fails if the identifier already exists in this execution.
+*
+* @param[in] pBuildJobExecution - BuildJobExecution instance.
+* @param[in] pIdentifier - Identifier of the capture. MUST be unique within the execution, alphanumeric and not empty.
+* @param[in] pName - Human readable name of the capture. MUST NOT be empty.
+* @param[in] pUserUUID - UUID of the user that started the capture. Use 00000000-0000-0000-0000-000000000000 if no user shall be recorded.
+* @param[in] nAbsoluteTimeStamp - Absolute Time Stamp in Microseconds since 1970.
+* @param[out] pDataCaptureInstance - Data capture manifest instance.
+* @return error code or 0 (success)
+*/
+LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_buildjobexecution_createdatacapture(LibMCData_BuildJobExecution pBuildJobExecution, const char * pIdentifier, const char * pName, const char * pUserUUID, LibMCData_uint64 nAbsoluteTimeStamp, LibMCData_DataCapture * pDataCaptureInstance);
+
+/**
+* Returns if a data capture with a specific identifier exists in this execution.
+*
+* @param[in] pBuildJobExecution - BuildJobExecution instance.
+* @param[in] pIdentifier - Identifier of the capture.
+* @param[out] pHasDataCapture - Returns true, if the data capture exists.
+* @return error code or 0 (success)
+*/
+LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_buildjobexecution_hasdatacapture(LibMCData_BuildJobExecution pBuildJobExecution, const char * pIdentifier, bool * pHasDataCapture);
+
+/**
+* Retrieves the manifest of a data capture by its identifier. Fails if the identifier does not exist.
+*
+* @param[in] pBuildJobExecution - BuildJobExecution instance.
+* @param[in] pIdentifier - Identifier of the capture.
+* @param[out] pDataCaptureInstance - Data capture manifest instance.
+* @return error code or 0 (success)
+*/
+LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_buildjobexecution_retrievedatacapture(LibMCData_BuildJobExecution pBuildJobExecution, const char * pIdentifier, LibMCData_DataCapture * pDataCaptureInstance);
+
+/**
+* Returns the number of data captures of this execution.
+*
+* @param[in] pBuildJobExecution - BuildJobExecution instance.
+* @param[out] pDataCaptureCount - Number of data captures.
+* @return error code or 0 (success)
+*/
+LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_buildjobexecution_getdatacapturecount(LibMCData_BuildJobExecution pBuildJobExecution, LibMCData_uint32 * pDataCaptureCount);
+
+/**
+* Retrieves the manifest of a data capture of this execution by its index. Captures are ordered by their creation time.
+*
+* @param[in] pBuildJobExecution - BuildJobExecution instance.
+* @param[in] nIndex - Index of the capture. 0-based. Fails if the index is out of bounds.
+* @param[out] pDataCaptureInstance - Data capture manifest instance.
+* @return error code or 0 (success)
+*/
+LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_buildjobexecution_retrievedatacapturebyindex(LibMCData_BuildJobExecution pBuildJobExecution, LibMCData_uint32 nIndex, LibMCData_DataCapture * pDataCaptureInstance);
+
 /*************************************************************************************************************************
  Class definition for BuildJobExecutionIterator
 **************************************************************************************************************************/
@@ -2390,6 +2759,16 @@ LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_buildjobhandler_listjobschangedsinc
 */
 LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_buildjobhandler_listjobexecutionschangedsince(LibMCData_BuildJobHandler pBuildJobHandler, LibMCData_uint64 nIncrementalID, LibMCData_BuildJobExecutionIterator * pIteratorInstance);
 
+/**
+* Retrieves the manifest of a data capture by its uuid. Fails if the capture does not exist.
+*
+* @param[in] pBuildJobHandler - BuildJobHandler instance.
+* @param[in] pDataCaptureUUID - UUID of the data capture.
+* @param[out] pDataCaptureInstance - Data capture manifest instance.
+* @return error code or 0 (success)
+*/
+LIBMCDATA_DECLSPEC LibMCDataResult libmcdata_buildjobhandler_retrievedatacapture(LibMCData_BuildJobHandler pBuildJobHandler, const char * pDataCaptureUUID, LibMCData_DataCapture * pDataCaptureInstance);
+
 /*************************************************************************************************************************
  Class definition for UserList
 **************************************************************************************************************************/
diff --git a/Framework/InterfacesCore/libmcdata_interfaces.hpp b/Framework/InterfacesCore/libmcdata_interfaces.hpp
index 5d52dca6e..f58eb9ac2 100644
--- a/Framework/InterfacesCore/libmcdata_interfaces.hpp
+++ b/Framework/InterfacesCore/libmcdata_interfaces.hpp
@@ -75,6 +75,7 @@ class IBuildJobData;
 class IBuildJobDataIterator;
 class IBuildJobExecutionData;
 class IBuildJobExecutionDataIterator;
+class IDataCapture;
 class IBuildJobExecution;
 class IBuildJobExecutionIterator;
 class IBuildJob;
@@ -1183,6 +1184,11 @@ class IStorageZIPWriter : public virtual IBase {
 	*/
 	virtual bool IsFinished() = 0;
 
+	/**
+	* IStorageZIPWriter::Discard - Discards an unfinished ZIP stream. The file on disk and the stream entry are deleted. Fails if the stream has been finished already. A ZIP writer that is released without Finish is discarded automatically.
+	*/
+	virtual void Discard() = 0;
+
 };
 
 typedef IBaseSharedPtr<IStorageZIPWriter> PIStorageZIPWriter;
@@ -1339,6 +1345,62 @@ class IStorage : public virtual IBase {
 	*/
 	virtual void RequestDownloadTicket(const std::string & sTicketUUID, const std::string & sIPAddress, const LibMCData_uint64 nAbsoluteTimeStamp, std::string & sStreamUUID, std::string & sClientFileName, std::string & sSessionUUID, std::string & sUserUUID) = 0;
 
+	/**
+	* IStorage::GetDownloadTicketDetails - Returns the details of a download ticket without creating an access log entry. Fails if the ticket does not exist.
+	* @param[in] sTicketUUID - UUID of download ticket.
+	* @param[out] sStreamUUID - UUID of storage stream.
+	* @param[out] sClientFileName - ClientFileName of the ticket.
+	* @param[out] sSessionUUID - UUID of user session.
+	* @param[out] sUserUUID - UUID of user that created the ticket.
+	* @param[out] nCreationTimeStamp - Creation time of the ticket in microseconds since 1970.
+	* @param[out] bRevoked - True if the ticket has been revoked.
+	*/
+	virtual void GetDownloadTicketDetails(const std::string & sTicketUUID, std::string & sStreamUUID, std::string & sClientFileName, std::string & sSessionUUID, std::string & sUserUUID, LibMCData_uint64 & nCreationTimeStamp, bool & bRevoked) = 0;
+
+	/**
+	* IStorage::RevokeDownloadTicketsOfStream - Revokes all download tickets of a stream. Revoked tickets can not be used for downloads anymore.
+	* @param[in] sStreamUUID - UUID of storage stream.
+	* @return Number of tickets that were revoked by this call.
+	*/
+	virtual LibMCData_uint32 RevokeDownloadTicketsOfStream(const std::string & sStreamUUID) = 0;
+
+	/**
+	* IStorage::LogDownloadStart - Creates an entry in the download access log of a ticket and returns the UUID of the entry.
+	* @param[in] sTicketUUID - UUID of download ticket.
+	* @param[in] sIPAddress - IP Address where the request came from.
+	* @param[in] nAbsoluteTimeStamp - Absolute Time Stamp in Microseconds since 1970.
+	* @return UUID of the access log entry.
+	*/
+	virtual std::string LogDownloadStart(const std::string & sTicketUUID, const std::string & sIPAddress, const LibMCData_uint64 nAbsoluteTimeStamp) = 0;
+
+	/**
+	* IStorage::LogDownloadFinish - Records the result of a download in its access log entry. Fails if the entry does not exist.
+	* @param[in] sDownloadUUID - UUID of the access log entry.
+	* @param[in] nSentBytes - Number of bytes that were sent to the client.
+	* @param[in] bSuccess - True if all requested bytes were sent.
+	* @param[in] nAbsoluteTimeStamp - Absolute Time Stamp in Microseconds since 1970.
+	*/
+	virtual void LogDownloadFinish(const std::string & sDownloadUUID, const LibMCData_uint64 nSentBytes, const bool bSuccess, const LibMCData_uint64 nAbsoluteTimeStamp) = 0;
+
+	/**
+	* IStorage::DeleteStream - Deletes a finished stream from disk and database, including its download tickets and journal links. Fails if the stream does not exist or is still being written.
+	* @param[in] sUUID - UUID of storage stream.
+	*/
+	virtual void DeleteStream(const std::string & sUUID) = 0;
+
+	/**
+	* IStorage::DiscardUnfinishedZIPStreams - Deletes all ZIP streams that were never finished and have no active writer, for example after a crash. Returns the number of deleted streams.
+	* @return Number of deleted streams.
+	*/
+	virtual LibMCData_uint32 DiscardUnfinishedZIPStreams() = 0;
+
+	/**
+	* IStorage::ListStreamUUIDsByName - Returns the UUIDs of all finished streams with the given name, newest first, separated by commas.
+	* @param[in] sName - Name of the streams.
+	* @return Comma separated list of stream UUIDs. Empty if there is none.
+	*/
+	virtual std::string ListStreamUUIDsByName(const std::string & sName) = 0;
+
 	/**
 	* IStorage::AttachStreamToJournal - Attaches a stream to a journal as temporary stream.
 	* @param[in] sStreamUUID - UUID of stream. Call fails if stream does not exist.
@@ -1346,6 +1408,25 @@ class IStorage : public virtual IBase {
 	*/
 	virtual void AttachStreamToJournal(const std::string & sStreamUUID, const std::string & sJournalUUID) = 0;
 
+	/**
+	* IStorage::DiscardRandomWriteStream - Discards an unfinished random write stream. The data on disk and the stream entry are deleted.
+	* @param[in] sUUID - UUID of storage stream. MUST have been created with BeginRandomWriteStream first and MUST NOT be finished.
+	*/
+	virtual void DiscardRandomWriteStream(const std::string & sUUID) = 0;
+
+	/**
+	* IStorage::GetDataCaptureStorageSize - Returns the size of all data capture segments that are stored on disk.
+	* @return Size in bytes.
+	*/
+	virtual LibMCData_uint64 GetDataCaptureStorageSize() = 0;
+
+	/**
+	* IStorage::EnforceDataCaptureStorageLimit - Deletes the oldest stored data capture segments until the total stored size is within the limit.
+	* @param[in] nLimitInBytes - Maximum total size of all stored data capture segments in bytes.
+	* @return Number of segments that have been deleted.
+	*/
+	virtual LibMCData_uint32 EnforceDataCaptureStorageLimit(const LibMCData_uint64 nLimitInBytes) = 0;
+
 };
 
 typedef IBaseSharedPtr<IStorage> PIStorage;
@@ -1502,6 +1583,138 @@ class IBuildJobExecutionDataIterator : public virtual IIterator {
 typedef IBaseSharedPtr<IBuildJobExecutionDataIterator> PIBuildJobExecutionDataIterator;
 
 
+/*************************************************************************************************************************
+ Class interface for DataCapture 
+**************************************************************************************************************************/
+
+class IDataCapture : public virtual IBase {
+public:
+	/**
+	* IDataCapture::GetUUID - returns the uuid of the data capture.
+	* @return UUID String
+	*/
+	virtual std::string GetUUID() = 0;
+
+	/**
+	* IDataCapture::GetExecutionUUID - returns the uuid of the build job execution the capture belongs to.
+	* @return UUID String
+	*/
+	virtual std::string GetExecutionUUID() = 0;
+
+	/**
+	* IDataCapture::GetIdentifier - returns the identifier of the data capture. It is unique within the build job execution.
+	* @return Identifier String
+	*/
+	virtual std::string GetIdentifier() = 0;
+
+	/**
+	* IDataCapture::GetName - returns the human readable name of the data capture.
+	* @return Name String
+	*/
+	virtual std::string GetName() = 0;
+
+	/**
+	* IDataCapture::GetStatus - returns the current status of the data capture.
+	* @return Status Value
+	*/
+	virtual LibMCData::eDataCaptureStatus GetStatus() = 0;
+
+	/**
+	* IDataCapture::GetTimeStamp - returns the time stamp when the data capture was created.
+	* @return Timestamp in ISO8601 UTC format
+	*/
+	virtual std::string GetTimeStamp() = 0;
+
+	/**
+	* IDataCapture::AddColumn - Registers a column of the capture schema. Fails if the capture is not recording or the column index already exists.
+	* @param[in] nColumnIndex - Index of the column. 0-based.
+	* @param[in] sIdentifier - Identifier of the column.
+	* @param[in] sDescription - Description of the column.
+	* @param[in] nColumnType - Data type of the column as numeric data table column type.
+	*/
+	virtual void AddColumn(const LibMCData_uint32 nColumnIndex, const std::string & sIdentifier, const std::string & sDescription, const LibMCData_uint32 nColumnType) = 0;
+
+	/**
+	* IDataCapture::GetColumnCount - returns the number of columns of the capture schema.
+	* @return Number of columns.
+	*/
+	virtual LibMCData_uint32 GetColumnCount() = 0;
+
+	/**
+	* IDataCapture::GetColumnInformation - returns the schema information of a column. Fails if the index does not exist.
+	* @param[in] nColumnIndex - Index of the column. 0-based.
+	* @param[out] sIdentifier - Identifier of the column.
+	* @param[out] sDescription - Description of the column.
+	* @param[out] nColumnType - Data type of the column as numeric data table column type.
+	*/
+	virtual void GetColumnInformation(const LibMCData_uint32 nColumnIndex, std::string & sIdentifier, std::string & sDescription, LibMCData_uint32 & nColumnType) = 0;
+
+	/**
+	* IDataCapture::AddSegment - Registers a finished segment stream of the capture. Fails if the capture is not recording or the segment index already exists.
+	* @param[in] nSegmentIndex - Index of the segment. 0-based.
+	* @param[in] sStreamUUID - UUID of the storage stream that holds the segment. The stream MUST exist.
+	* @param[in] nFirstRow - Index of the first row of the segment within the capture.
+	* @param[in] nRowCount - Number of rows in the segment.
+	* @param[in] nChunkCount - Number of chunks in the segment.
+	* @param[in] nSizeInBytes - Size of the segment stream in bytes.
+	* @param[in] nStartTimeStamp - Absolute time stamp in microseconds since 1970 when the segment was opened.
+	* @param[in] nEndTimeStamp - Absolute time stamp in microseconds since 1970 when the segment was closed.
+	*/
+	virtual void AddSegment(const LibMCData_uint32 nSegmentIndex, const std::string & sStreamUUID, const LibMCData_uint64 nFirstRow, const LibMCData_uint64 nRowCount, const LibMCData_uint32 nChunkCount, const LibMCData_uint64 nSizeInBytes, const LibMCData_uint64 nStartTimeStamp, const LibMCData_uint64 nEndTimeStamp) = 0;
+
+	/**
+	* IDataCapture::GetSegmentCount - returns the number of registered segments, including purged ones.
+	* @return Number of segments.
+	*/
+	virtual LibMCData_uint32 GetSegmentCount() = 0;
+
+	/**
+	* IDataCapture::GetSegmentInformation - returns the manifest entry of a segment. Fails if the index does not exist.
+	* @param[in] nSegmentIndex - Index of the segment. 0-based.
+	* @param[out] sStreamUUID - UUID of the storage stream that holds the segment.
+	* @param[out] nFirstRow - Index of the first row of the segment within the capture.
+	* @param[out] nRowCount - Number of rows in the segment.
+	* @param[out] nSizeInBytes - Size of the segment stream in bytes.
+	* @param[out] bIsPurged - Returns true if the segment data has been deleted by retention or abort.
+	*/
+	virtual void GetSegmentInformation(const LibMCData_uint32 nSegmentIndex, std::string & sStreamUUID, LibMCData_uint64 & nFirstRow, LibMCData_uint64 & nRowCount, LibMCData_uint64 & nSizeInBytes, bool & bIsPurged) = 0;
+
+	/**
+	* IDataCapture::GetSegmentChunkCount - returns the number of chunks of a segment. Fails if the index does not exist.
+	* @param[in] nSegmentIndex - Index of the segment. 0-based.
+	* @return Number of chunks in the segment.
+	*/
+	virtual LibMCData_uint32 GetSegmentChunkCount(const LibMCData_uint32 nSegmentIndex) = 0;
+
+	/**
+	* IDataCapture::GetRowCount - returns the number of rows in all registered segments, including purged ones.
+	* @return Number of rows.
+	*/
+	virtual LibMCData_uint64 GetRowCount() = 0;
+
+	/**
+	* IDataCapture::GetStoredSizeInBytes - returns the size of all segments of the capture that are still stored on disk.
+	* @return Size in bytes.
+	*/
+	virtual LibMCData_uint64 GetStoredSizeInBytes() = 0;
+
+	/**
+	* IDataCapture::Finish - Marks the capture as finished. Fails if the capture is not recording.
+	* @param[in] nAbsoluteTimeStamp - Absolute Time Stamp in Microseconds since 1970.
+	*/
+	virtual void Finish(const LibMCData_uint64 nAbsoluteTimeStamp) = 0;
+
+	/**
+	* IDataCapture::Abort - Deletes all stored segments of the capture and marks it as aborted. Fails if the capture has been aborted before.
+	* @param[in] nAbsoluteTimeStamp - Absolute Time Stamp in Microseconds since 1970.
+	*/
+	virtual void Abort(const LibMCData_uint64 nAbsoluteTimeStamp) = 0;
+
+};
+
+typedef IBaseSharedPtr<IDataCapture> PIDataCapture;
+
+
 /*************************************************************************************************************************
  Class interface for BuildJobExecution 
 **************************************************************************************************************************/
@@ -1682,6 +1895,43 @@ class IBuildJobExecution : public virtual IBase {
 	*/
 	virtual std::string GetMetaDataString(const std::string & sKey) = 0;
 
+	/**
+	* IBuildJobExecution::CreateDataCapture - Creates the manifest of a new data capture in recording state. Fails if the identifier already exists in this execution.
+	* @param[in] sIdentifier - Identifier of the capture. MUST be unique within the execution, alphanumeric and not empty.
+	* @param[in] sName - Human readable name of the capture. MUST NOT be empty.
+	* @param[in] sUserUUID - UUID of the user that started the capture. Use 00000000-0000-0000-0000-000000000000 if no user shall be recorded.
+	* @param[in] nAbsoluteTimeStamp - Absolute Time Stamp in Microseconds since 1970.
+	* @return Data capture manifest instance.
+	*/
+	virtual IDataCapture * CreateDataCapture(const std::string & sIdentifier, const std::string & sName, const std::string & sUserUUID, const LibMCData_uint64 nAbsoluteTimeStamp) = 0;
+
+	/**
+	* IBuildJobExecution::HasDataCapture - Returns if a data capture with a specific identifier exists in this execution.
+	* @param[in] sIdentifier - Identifier of the capture.
+	* @return Returns true, if the data capture exists.
+	*/
+	virtual bool HasDataCapture(const std::string & sIdentifier) = 0;
+
+	/**
+	* IBuildJobExecution::RetrieveDataCapture - Retrieves the manifest of a data capture by its identifier. Fails if the identifier does not exist.
+	* @param[in] sIdentifier - Identifier of the capture.
+	* @return Data capture manifest instance.
+	*/
+	virtual IDataCapture * RetrieveDataCapture(const std::string & sIdentifier) = 0;
+
+	/**
+	* IBuildJobExecution::GetDataCaptureCount - Returns the number of data captures of this execution.
+	* @return Number of data captures.
+	*/
+	virtual LibMCData_uint32 GetDataCaptureCount() = 0;
+
+	/**
+	* IBuildJobExecution::RetrieveDataCaptureByIndex - Retrieves the manifest of a data capture of this execution by its index. Captures are ordered by their creation time.
+	* @param[in] nIndex - Index of the capture. 0-based. Fails if the index is out of bounds.
+	* @return Data capture manifest instance.
+	*/
+	virtual IDataCapture * RetrieveDataCaptureByIndex(const LibMCData_uint32 nIndex) = 0;
+
 };
 
 typedef IBaseSharedPtr<IBuildJobExecution> PIBuildJobExecution;
@@ -2073,6 +2323,13 @@ class IBuildJobHandler : public virtual IBase {
 	*/
 	virtual IBuildJobExecutionIterator * ListJobExecutionsChangedSince(const LibMCData_uint64 nIncrementalID) = 0;
 
+	/**
+	* IBuildJobHandler::RetrieveDataCapture - Retrieves the manifest of a data capture by its uuid. Fails if the capture does not exist.
+	* @param[in] sDataCaptureUUID - UUID of the data capture.
+	* @return Data capture manifest instance.
+	*/
+	virtual IDataCapture * RetrieveDataCapture(const std::string & sDataCaptureUUID) = 0;
+
 };
 
 typedef IBaseSharedPtr<IBuildJobHandler> PIBuildJobHandler;
diff --git a/Framework/InterfacesCore/libmcdata_interfacewrapper.cpp b/Framework/InterfacesCore/libmcdata_interfacewrapper.cpp
index 92ad92f6b..23d690705 100644
--- a/Framework/InterfacesCore/libmcdata_interfacewrapper.cpp
+++ b/Framework/InterfacesCore/libmcdata_interfacewrapper.cpp
@@ -3452,6 +3452,30 @@ LibMCDataResult libmcdata_storagezipwriter_isfinished(LibMCData_StorageZIPWriter
 	}
 }
 
+LibMCDataResult libmcdata_storagezipwriter_discard(LibMCData_StorageZIPWriter pStorageZIPWriter)
+{
+	IBase* pIBaseClass = (IBase *)pStorageZIPWriter;
+
+	try {
+		IStorageZIPWriter* pIStorageZIPWriter = dynamic_cast<IStorageZIPWriter*>(pIBaseClass);
+		if (!pIStorageZIPWriter)
+			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+		
+		pIStorageZIPWriter->Discard();
+
+		return LIBMCDATA_SUCCESS;
+	}
+	catch (ELibMCDataInterfaceException & Exception) {
+		return handleLibMCDataException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
 
 /*************************************************************************************************************************
  Class implementation for Storage
@@ -4050,23 +4074,84 @@ LibMCDataResult libmcdata_storage_requestdownloadticket(LibMCData_Storage pStora
 	}
 }
 
-LibMCDataResult libmcdata_storage_attachstreamtojournal(LibMCData_Storage pStorage, const char * pStreamUUID, const char * pJournalUUID)
+LibMCDataResult libmcdata_storage_getdownloadticketdetails(LibMCData_Storage pStorage, const char * pTicketUUID, const LibMCData_uint32 nStreamUUIDBufferSize, LibMCData_uint32* pStreamUUIDNeededChars, char * pStreamUUIDBuffer, const LibMCData_uint32 nClientFileNameBufferSize, LibMCData_uint32* pClientFileNameNeededChars, char * pClientFileNameBuffer, const LibMCData_uint32 nSessionUUIDBufferSize, LibMCData_uint32* pSessionUUIDNeededChars, char * pSessionUUIDBuffer, const LibMCData_uint32 nUserUUIDBufferSize, LibMCData_uint32* pUserUUIDNeededChars, char * pUserUUIDBuffer, LibMCData_uint64 * pCreationTimeStamp, bool * pRevoked)
 {
 	IBase* pIBaseClass = (IBase *)pStorage;
 
 	try {
-		if (pStreamUUID == nullptr)
+		if (pTicketUUID == nullptr)
 			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
-		if (pJournalUUID == nullptr)
+		if ( (!pStreamUUIDBuffer) && !(pStreamUUIDNeededChars) )
 			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
-		std::string sStreamUUID(pStreamUUID);
-		std::string sJournalUUID(pJournalUUID);
+		if ( (!pClientFileNameBuffer) && !(pClientFileNameNeededChars) )
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		if ( (!pSessionUUIDBuffer) && !(pSessionUUIDNeededChars) )
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		if ( (!pUserUUIDBuffer) && !(pUserUUIDNeededChars) )
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		if (!pCreationTimeStamp)
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		if (!pRevoked)
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		std::string sTicketUUID(pTicketUUID);
+		std::string sStreamUUID("");
+		std::string sClientFileName("");
+		std::string sSessionUUID("");
+		std::string sUserUUID("");
 		IStorage* pIStorage = dynamic_cast<IStorage*>(pIBaseClass);
 		if (!pIStorage)
 			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
 		
-		pIStorage->AttachStreamToJournal(sStreamUUID, sJournalUUID);
+		bool isCacheCall = (pStreamUUIDBuffer == nullptr) || (pClientFileNameBuffer == nullptr) || (pSessionUUIDBuffer == nullptr) || (pUserUUIDBuffer == nullptr);
+		if (isCacheCall) {
+			pIStorage->GetDownloadTicketDetails(sTicketUUID, sStreamUUID, sClientFileName, sSessionUUID, sUserUUID, *pCreationTimeStamp, *pRevoked);
 
+			pIStorage->_setCache (new ParameterCache_6<std::string, std::string, std::string, std::string, LibMCData_uint64, bool> (sStreamUUID, sClientFileName, sSessionUUID, sUserUUID, *pCreationTimeStamp, *pRevoked));
+		}
+		else {
+			auto cache = dynamic_cast<ParameterCache_6<std::string, std::string, std::string, std::string, LibMCData_uint64, bool>*> (pIStorage->_getCache ());
+			if (cache == nullptr)
+				throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+			cache->retrieveData (sStreamUUID, sClientFileName, sSessionUUID, sUserUUID, *pCreationTimeStamp, *pRevoked);
+			pIStorage->_setCache (nullptr);
+		}
+		
+		if (pStreamUUIDNeededChars)
+			*pStreamUUIDNeededChars = (LibMCData_uint32) (sStreamUUID.size()+1);
+		if (pStreamUUIDBuffer) {
+			if (sStreamUUID.size() >= nStreamUUIDBufferSize)
+				throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_BUFFERTOOSMALL);
+			for (size_t iStreamUUID = 0; iStreamUUID < sStreamUUID.size(); iStreamUUID++)
+				pStreamUUIDBuffer[iStreamUUID] = sStreamUUID[iStreamUUID];
+			pStreamUUIDBuffer[sStreamUUID.size()] = 0;
+		}
+		if (pClientFileNameNeededChars)
+			*pClientFileNameNeededChars = (LibMCData_uint32) (sClientFileName.size()+1);
+		if (pClientFileNameBuffer) {
+			if (sClientFileName.size() >= nClientFileNameBufferSize)
+				throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_BUFFERTOOSMALL);
+			for (size_t iClientFileName = 0; iClientFileName < sClientFileName.size(); iClientFileName++)
+				pClientFileNameBuffer[iClientFileName] = sClientFileName[iClientFileName];
+			pClientFileNameBuffer[sClientFileName.size()] = 0;
+		}
+		if (pSessionUUIDNeededChars)
+			*pSessionUUIDNeededChars = (LibMCData_uint32) (sSessionUUID.size()+1);
+		if (pSessionUUIDBuffer) {
+			if (sSessionUUID.size() >= nSessionUUIDBufferSize)
+				throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_BUFFERTOOSMALL);
+			for (size_t iSessionUUID = 0; iSessionUUID < sSessionUUID.size(); iSessionUUID++)
+				pSessionUUIDBuffer[iSessionUUID] = sSessionUUID[iSessionUUID];
+			pSessionUUIDBuffer[sSessionUUID.size()] = 0;
+		}
+		if (pUserUUIDNeededChars)
+			*pUserUUIDNeededChars = (LibMCData_uint32) (sUserUUID.size()+1);
+		if (pUserUUIDBuffer) {
+			if (sUserUUID.size() >= nUserUUIDBufferSize)
+				throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_BUFFERTOOSMALL);
+			for (size_t iUserUUID = 0; iUserUUID < sUserUUID.size(); iUserUUID++)
+				pUserUUIDBuffer[iUserUUID] = sUserUUID[iUserUUID];
+			pUserUUIDBuffer[sUserUUID.size()] = 0;
+		}
 		return LIBMCDATA_SUCCESS;
 	}
 	catch (ELibMCDataInterfaceException & Exception) {
@@ -4080,45 +4165,22 @@ LibMCDataResult libmcdata_storage_attachstreamtojournal(LibMCData_Storage pStora
 	}
 }
 
-
-/*************************************************************************************************************************
- Class implementation for CustomDataStream
-**************************************************************************************************************************/
-LibMCDataResult libmcdata_customdatastream_getdatauuid(LibMCData_CustomDataStream pCustomDataStream, const LibMCData_uint32 nUUIDBufferSize, LibMCData_uint32* pUUIDNeededChars, char * pUUIDBuffer)
+LibMCDataResult libmcdata_storage_revokedownloadticketsofstream(LibMCData_Storage pStorage, const char * pStreamUUID, LibMCData_uint32 * pRevokedCount)
 {
-	IBase* pIBaseClass = (IBase *)pCustomDataStream;
+	IBase* pIBaseClass = (IBase *)pStorage;
 
 	try {
-		if ( (!pUUIDBuffer) && !(pUUIDNeededChars) )
+		if (pStreamUUID == nullptr)
 			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
-		std::string sUUID("");
-		ICustomDataStream* pICustomDataStream = dynamic_cast<ICustomDataStream*>(pIBaseClass);
-		if (!pICustomDataStream)
+		if (pRevokedCount == nullptr)
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		std::string sStreamUUID(pStreamUUID);
+		IStorage* pIStorage = dynamic_cast<IStorage*>(pIBaseClass);
+		if (!pIStorage)
 			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
 		
-		bool isCacheCall = (pUUIDBuffer == nullptr);
-		if (isCacheCall) {
-			sUUID = pICustomDataStream->GetDataUUID();
+		*pRevokedCount = pIStorage->RevokeDownloadTicketsOfStream(sStreamUUID);
 
-			pICustomDataStream->_setCache (new ParameterCache_1<std::string> (sUUID));
-		}
-		else {
-			auto cache = dynamic_cast<ParameterCache_1<std::string>*> (pICustomDataStream->_getCache ());
-			if (cache == nullptr)
-				throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
-			cache->retrieveData (sUUID);
-			pICustomDataStream->_setCache (nullptr);
-		}
-		
-		if (pUUIDNeededChars)
-			*pUUIDNeededChars = (LibMCData_uint32) (sUUID.size()+1);
-		if (pUUIDBuffer) {
-			if (sUUID.size() >= nUUIDBufferSize)
-				throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_BUFFERTOOSMALL);
-			for (size_t iUUID = 0; iUUID < sUUID.size(); iUUID++)
-				pUUIDBuffer[iUUID] = sUUID[iUUID];
-			pUUIDBuffer[sUUID.size()] = 0;
-		}
 		return LIBMCDATA_SUCCESS;
 	}
 	catch (ELibMCDataInterfaceException & Exception) {
@@ -4132,40 +4194,46 @@ LibMCDataResult libmcdata_customdatastream_getdatauuid(LibMCData_CustomDataStrea
 	}
 }
 
-LibMCDataResult libmcdata_customdatastream_getidentifier(LibMCData_CustomDataStream pCustomDataStream, const LibMCData_uint32 nIdentifierBufferSize, LibMCData_uint32* pIdentifierNeededChars, char * pIdentifierBuffer)
+LibMCDataResult libmcdata_storage_logdownloadstart(LibMCData_Storage pStorage, const char * pTicketUUID, const char * pIPAddress, LibMCData_uint64 nAbsoluteTimeStamp, const LibMCData_uint32 nDownloadUUIDBufferSize, LibMCData_uint32* pDownloadUUIDNeededChars, char * pDownloadUUIDBuffer)
 {
-	IBase* pIBaseClass = (IBase *)pCustomDataStream;
+	IBase* pIBaseClass = (IBase *)pStorage;
 
 	try {
-		if ( (!pIdentifierBuffer) && !(pIdentifierNeededChars) )
+		if (pTicketUUID == nullptr)
 			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
-		std::string sIdentifier("");
-		ICustomDataStream* pICustomDataStream = dynamic_cast<ICustomDataStream*>(pIBaseClass);
-		if (!pICustomDataStream)
+		if (pIPAddress == nullptr)
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		if ( (!pDownloadUUIDBuffer) && !(pDownloadUUIDNeededChars) )
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		std::string sTicketUUID(pTicketUUID);
+		std::string sIPAddress(pIPAddress);
+		std::string sDownloadUUID("");
+		IStorage* pIStorage = dynamic_cast<IStorage*>(pIBaseClass);
+		if (!pIStorage)
 			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
 		
-		bool isCacheCall = (pIdentifierBuffer == nullptr);
+		bool isCacheCall = (pDownloadUUIDBuffer == nullptr);
 		if (isCacheCall) {
-			sIdentifier = pICustomDataStream->GetIdentifier();
+			sDownloadUUID = pIStorage->LogDownloadStart(sTicketUUID, sIPAddress, nAbsoluteTimeStamp);
 
-			pICustomDataStream->_setCache (new ParameterCache_1<std::string> (sIdentifier));
+			pIStorage->_setCache (new ParameterCache_1<std::string> (sDownloadUUID));
 		}
 		else {
-			auto cache = dynamic_cast<ParameterCache_1<std::string>*> (pICustomDataStream->_getCache ());
+			auto cache = dynamic_cast<ParameterCache_1<std::string>*> (pIStorage->_getCache ());
 			if (cache == nullptr)
 				throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
-			cache->retrieveData (sIdentifier);
-			pICustomDataStream->_setCache (nullptr);
+			cache->retrieveData (sDownloadUUID);
+			pIStorage->_setCache (nullptr);
 		}
 		
-		if (pIdentifierNeededChars)
-			*pIdentifierNeededChars = (LibMCData_uint32) (sIdentifier.size()+1);
-		if (pIdentifierBuffer) {
-			if (sIdentifier.size() >= nIdentifierBufferSize)
+		if (pDownloadUUIDNeededChars)
+			*pDownloadUUIDNeededChars = (LibMCData_uint32) (sDownloadUUID.size()+1);
+		if (pDownloadUUIDBuffer) {
+			if (sDownloadUUID.size() >= nDownloadUUIDBufferSize)
 				throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_BUFFERTOOSMALL);
-			for (size_t iIdentifier = 0; iIdentifier < sIdentifier.size(); iIdentifier++)
-				pIdentifierBuffer[iIdentifier] = sIdentifier[iIdentifier];
-			pIdentifierBuffer[sIdentifier.size()] = 0;
+			for (size_t iDownloadUUID = 0; iDownloadUUID < sDownloadUUID.size(); iDownloadUUID++)
+				pDownloadUUIDBuffer[iDownloadUUID] = sDownloadUUID[iDownloadUUID];
+			pDownloadUUIDBuffer[sDownloadUUID.size()] = 0;
 		}
 		return LIBMCDATA_SUCCESS;
 	}
@@ -4180,41 +4248,20 @@ LibMCDataResult libmcdata_customdatastream_getidentifier(LibMCData_CustomDataStr
 	}
 }
 
-LibMCDataResult libmcdata_customdatastream_getname(LibMCData_CustomDataStream pCustomDataStream, const LibMCData_uint32 nNameBufferSize, LibMCData_uint32* pNameNeededChars, char * pNameBuffer)
+LibMCDataResult libmcdata_storage_logdownloadfinish(LibMCData_Storage pStorage, const char * pDownloadUUID, LibMCData_uint64 nSentBytes, bool bSuccess, LibMCData_uint64 nAbsoluteTimeStamp)
 {
-	IBase* pIBaseClass = (IBase *)pCustomDataStream;
+	IBase* pIBaseClass = (IBase *)pStorage;
 
 	try {
-		if ( (!pNameBuffer) && !(pNameNeededChars) )
+		if (pDownloadUUID == nullptr)
 			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
-		std::string sName("");
-		ICustomDataStream* pICustomDataStream = dynamic_cast<ICustomDataStream*>(pIBaseClass);
-		if (!pICustomDataStream)
+		std::string sDownloadUUID(pDownloadUUID);
+		IStorage* pIStorage = dynamic_cast<IStorage*>(pIBaseClass);
+		if (!pIStorage)
 			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
 		
-		bool isCacheCall = (pNameBuffer == nullptr);
-		if (isCacheCall) {
-			sName = pICustomDataStream->GetName();
+		pIStorage->LogDownloadFinish(sDownloadUUID, nSentBytes, bSuccess, nAbsoluteTimeStamp);
 
-			pICustomDataStream->_setCache (new ParameterCache_1<std::string> (sName));
-		}
-		else {
-			auto cache = dynamic_cast<ParameterCache_1<std::string>*> (pICustomDataStream->_getCache ());
-			if (cache == nullptr)
-				throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
-			cache->retrieveData (sName);
-			pICustomDataStream->_setCache (nullptr);
-		}
-		
-		if (pNameNeededChars)
-			*pNameNeededChars = (LibMCData_uint32) (sName.size()+1);
-		if (pNameBuffer) {
-			if (sName.size() >= nNameBufferSize)
-				throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_BUFFERTOOSMALL);
-			for (size_t iName = 0; iName < sName.size(); iName++)
-				pNameBuffer[iName] = sName[iName];
-			pNameBuffer[sName.size()] = 0;
-		}
 		return LIBMCDATA_SUCCESS;
 	}
 	catch (ELibMCDataInterfaceException & Exception) {
@@ -4228,41 +4275,20 @@ LibMCDataResult libmcdata_customdatastream_getname(LibMCData_CustomDataStream pC
 	}
 }
 
-LibMCDataResult libmcdata_customdatastream_gettimestamp(LibMCData_CustomDataStream pCustomDataStream, const LibMCData_uint32 nTimestampBufferSize, LibMCData_uint32* pTimestampNeededChars, char * pTimestampBuffer)
+LibMCDataResult libmcdata_storage_deletestream(LibMCData_Storage pStorage, const char * pUUID)
 {
-	IBase* pIBaseClass = (IBase *)pCustomDataStream;
+	IBase* pIBaseClass = (IBase *)pStorage;
 
 	try {
-		if ( (!pTimestampBuffer) && !(pTimestampNeededChars) )
+		if (pUUID == nullptr)
 			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
-		std::string sTimestamp("");
-		ICustomDataStream* pICustomDataStream = dynamic_cast<ICustomDataStream*>(pIBaseClass);
-		if (!pICustomDataStream)
+		std::string sUUID(pUUID);
+		IStorage* pIStorage = dynamic_cast<IStorage*>(pIBaseClass);
+		if (!pIStorage)
 			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
 		
-		bool isCacheCall = (pTimestampBuffer == nullptr);
-		if (isCacheCall) {
-			sTimestamp = pICustomDataStream->GetTimeStamp();
+		pIStorage->DeleteStream(sUUID);
 
-			pICustomDataStream->_setCache (new ParameterCache_1<std::string> (sTimestamp));
-		}
-		else {
-			auto cache = dynamic_cast<ParameterCache_1<std::string>*> (pICustomDataStream->_getCache ());
-			if (cache == nullptr)
-				throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
-			cache->retrieveData (sTimestamp);
-			pICustomDataStream->_setCache (nullptr);
-		}
-		
-		if (pTimestampNeededChars)
-			*pTimestampNeededChars = (LibMCData_uint32) (sTimestamp.size()+1);
-		if (pTimestampBuffer) {
-			if (sTimestamp.size() >= nTimestampBufferSize)
-				throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_BUFFERTOOSMALL);
-			for (size_t iTimestamp = 0; iTimestamp < sTimestamp.size(); iTimestamp++)
-				pTimestampBuffer[iTimestamp] = sTimestamp[iTimestamp];
-			pTimestampBuffer[sTimestamp.size()] = 0;
-		}
 		return LIBMCDATA_SUCCESS;
 	}
 	catch (ELibMCDataInterfaceException & Exception) {
@@ -4276,21 +4302,19 @@ LibMCDataResult libmcdata_customdatastream_gettimestamp(LibMCData_CustomDataStre
 	}
 }
 
-LibMCDataResult libmcdata_customdatastream_getstoragestream(LibMCData_CustomDataStream pCustomDataStream, LibMCData_StorageStream * pStreamInstance)
+LibMCDataResult libmcdata_storage_discardunfinishedzipstreams(LibMCData_Storage pStorage, LibMCData_uint32 * pDeletedCount)
 {
-	IBase* pIBaseClass = (IBase *)pCustomDataStream;
+	IBase* pIBaseClass = (IBase *)pStorage;
 
 	try {
-		if (pStreamInstance == nullptr)
+		if (pDeletedCount == nullptr)
 			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
-		IBase* pBaseStreamInstance(nullptr);
-		ICustomDataStream* pICustomDataStream = dynamic_cast<ICustomDataStream*>(pIBaseClass);
-		if (!pICustomDataStream)
+		IStorage* pIStorage = dynamic_cast<IStorage*>(pIBaseClass);
+		if (!pIStorage)
 			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
 		
-		pBaseStreamInstance = pICustomDataStream->GetStorageStream();
+		*pDeletedCount = pIStorage->DiscardUnfinishedZIPStreams();
 
-		*pStreamInstance = (IBase*)(pBaseStreamInstance);
 		return LIBMCDATA_SUCCESS;
 	}
 	catch (ELibMCDataInterfaceException & Exception) {
@@ -4304,40 +4328,43 @@ LibMCDataResult libmcdata_customdatastream_getstoragestream(LibMCData_CustomData
 	}
 }
 
-LibMCDataResult libmcdata_customdatastream_getstoragestreamuuid(LibMCData_CustomDataStream pCustomDataStream, const LibMCData_uint32 nSHA2BufferSize, LibMCData_uint32* pSHA2NeededChars, char * pSHA2Buffer)
+LibMCDataResult libmcdata_storage_liststreamuuidsbyname(LibMCData_Storage pStorage, const char * pName, const LibMCData_uint32 nUUIDListBufferSize, LibMCData_uint32* pUUIDListNeededChars, char * pUUIDListBuffer)
 {
-	IBase* pIBaseClass = (IBase *)pCustomDataStream;
+	IBase* pIBaseClass = (IBase *)pStorage;
 
 	try {
-		if ( (!pSHA2Buffer) && !(pSHA2NeededChars) )
+		if (pName == nullptr)
 			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
-		std::string sSHA2("");
-		ICustomDataStream* pICustomDataStream = dynamic_cast<ICustomDataStream*>(pIBaseClass);
-		if (!pICustomDataStream)
+		if ( (!pUUIDListBuffer) && !(pUUIDListNeededChars) )
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		std::string sName(pName);
+		std::string sUUIDList("");
+		IStorage* pIStorage = dynamic_cast<IStorage*>(pIBaseClass);
+		if (!pIStorage)
 			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
 		
-		bool isCacheCall = (pSHA2Buffer == nullptr);
+		bool isCacheCall = (pUUIDListBuffer == nullptr);
 		if (isCacheCall) {
-			sSHA2 = pICustomDataStream->GetStorageStreamUUID();
+			sUUIDList = pIStorage->ListStreamUUIDsByName(sName);
 
-			pICustomDataStream->_setCache (new ParameterCache_1<std::string> (sSHA2));
+			pIStorage->_setCache (new ParameterCache_1<std::string> (sUUIDList));
 		}
 		else {
-			auto cache = dynamic_cast<ParameterCache_1<std::string>*> (pICustomDataStream->_getCache ());
+			auto cache = dynamic_cast<ParameterCache_1<std::string>*> (pIStorage->_getCache ());
 			if (cache == nullptr)
 				throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
-			cache->retrieveData (sSHA2);
-			pICustomDataStream->_setCache (nullptr);
+			cache->retrieveData (sUUIDList);
+			pIStorage->_setCache (nullptr);
 		}
 		
-		if (pSHA2NeededChars)
-			*pSHA2NeededChars = (LibMCData_uint32) (sSHA2.size()+1);
-		if (pSHA2Buffer) {
-			if (sSHA2.size() >= nSHA2BufferSize)
+		if (pUUIDListNeededChars)
+			*pUUIDListNeededChars = (LibMCData_uint32) (sUUIDList.size()+1);
+		if (pUUIDListBuffer) {
+			if (sUUIDList.size() >= nUUIDListBufferSize)
 				throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_BUFFERTOOSMALL);
-			for (size_t iSHA2 = 0; iSHA2 < sSHA2.size(); iSHA2++)
-				pSHA2Buffer[iSHA2] = sSHA2[iSHA2];
-			pSHA2Buffer[sSHA2.size()] = 0;
+			for (size_t iUUIDList = 0; iUUIDList < sUUIDList.size(); iUUIDList++)
+				pUUIDListBuffer[iUUIDList] = sUUIDList[iUUIDList];
+			pUUIDListBuffer[sUUIDList.size()] = 0;
 		}
 		return LIBMCDATA_SUCCESS;
 	}
@@ -4352,41 +4379,50 @@ LibMCDataResult libmcdata_customdatastream_getstoragestreamuuid(LibMCData_Custom
 	}
 }
 
-LibMCDataResult libmcdata_customdatastream_getstoragestreamsha2(LibMCData_CustomDataStream pCustomDataStream, const LibMCData_uint32 nSHA2BufferSize, LibMCData_uint32* pSHA2NeededChars, char * pSHA2Buffer)
+LibMCDataResult libmcdata_storage_attachstreamtojournal(LibMCData_Storage pStorage, const char * pStreamUUID, const char * pJournalUUID)
 {
-	IBase* pIBaseClass = (IBase *)pCustomDataStream;
+	IBase* pIBaseClass = (IBase *)pStorage;
 
 	try {
-		if ( (!pSHA2Buffer) && !(pSHA2NeededChars) )
+		if (pStreamUUID == nullptr)
 			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
-		std::string sSHA2("");
-		ICustomDataStream* pICustomDataStream = dynamic_cast<ICustomDataStream*>(pIBaseClass);
-		if (!pICustomDataStream)
+		if (pJournalUUID == nullptr)
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		std::string sStreamUUID(pStreamUUID);
+		std::string sJournalUUID(pJournalUUID);
+		IStorage* pIStorage = dynamic_cast<IStorage*>(pIBaseClass);
+		if (!pIStorage)
 			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
 		
-		bool isCacheCall = (pSHA2Buffer == nullptr);
-		if (isCacheCall) {
-			sSHA2 = pICustomDataStream->GetStorageStreamSHA2();
+		pIStorage->AttachStreamToJournal(sStreamUUID, sJournalUUID);
 
-			pICustomDataStream->_setCache (new ParameterCache_1<std::string> (sSHA2));
-		}
-		else {
-			auto cache = dynamic_cast<ParameterCache_1<std::string>*> (pICustomDataStream->_getCache ());
-			if (cache == nullptr)
-				throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
-			cache->retrieveData (sSHA2);
-			pICustomDataStream->_setCache (nullptr);
-		}
+		return LIBMCDATA_SUCCESS;
+	}
+	catch (ELibMCDataInterfaceException & Exception) {
+		return handleLibMCDataException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCDataResult libmcdata_storage_discardrandomwritestream(LibMCData_Storage pStorage, const char * pUUID)
+{
+	IBase* pIBaseClass = (IBase *)pStorage;
+
+	try {
+		if (pUUID == nullptr)
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		std::string sUUID(pUUID);
+		IStorage* pIStorage = dynamic_cast<IStorage*>(pIBaseClass);
+		if (!pIStorage)
+			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
 		
-		if (pSHA2NeededChars)
-			*pSHA2NeededChars = (LibMCData_uint32) (sSHA2.size()+1);
-		if (pSHA2Buffer) {
-			if (sSHA2.size() >= nSHA2BufferSize)
-				throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_BUFFERTOOSMALL);
-			for (size_t iSHA2 = 0; iSHA2 < sSHA2.size(); iSHA2++)
-				pSHA2Buffer[iSHA2] = sSHA2[iSHA2];
-			pSHA2Buffer[sSHA2.size()] = 0;
-		}
+		pIStorage->DiscardRandomWriteStream(sUUID);
+
 		return LIBMCDATA_SUCCESS;
 	}
 	catch (ELibMCDataInterfaceException & Exception) {
@@ -4400,18 +4436,18 @@ LibMCDataResult libmcdata_customdatastream_getstoragestreamsha2(LibMCData_Custom
 	}
 }
 
-LibMCDataResult libmcdata_customdatastream_getstoragestreamsize(LibMCData_CustomDataStream pCustomDataStream, LibMCData_uint64 * pSize)
+LibMCDataResult libmcdata_storage_getdatacapturestoragesize(LibMCData_Storage pStorage, LibMCData_uint64 * pSizeInBytes)
 {
-	IBase* pIBaseClass = (IBase *)pCustomDataStream;
+	IBase* pIBaseClass = (IBase *)pStorage;
 
 	try {
-		if (pSize == nullptr)
+		if (pSizeInBytes == nullptr)
 			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
-		ICustomDataStream* pICustomDataStream = dynamic_cast<ICustomDataStream*>(pIBaseClass);
-		if (!pICustomDataStream)
+		IStorage* pIStorage = dynamic_cast<IStorage*>(pIBaseClass);
+		if (!pIStorage)
 			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
 		
-		*pSize = pICustomDataStream->GetStorageStreamSize();
+		*pSizeInBytes = pIStorage->GetDataCaptureStorageSize();
 
 		return LIBMCDATA_SUCCESS;
 	}
@@ -4426,40 +4462,70 @@ LibMCDataResult libmcdata_customdatastream_getstoragestreamsize(LibMCData_Custom
 	}
 }
 
-LibMCDataResult libmcdata_customdatastream_getuseruuid(LibMCData_CustomDataStream pCustomDataStream, const LibMCData_uint32 nUserUUIDBufferSize, LibMCData_uint32* pUserUUIDNeededChars, char * pUserUUIDBuffer)
+LibMCDataResult libmcdata_storage_enforcedatacapturestoragelimit(LibMCData_Storage pStorage, LibMCData_uint64 nLimitInBytes, LibMCData_uint32 * pPurgedSegmentCount)
+{
+	IBase* pIBaseClass = (IBase *)pStorage;
+
+	try {
+		if (pPurgedSegmentCount == nullptr)
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		IStorage* pIStorage = dynamic_cast<IStorage*>(pIBaseClass);
+		if (!pIStorage)
+			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+		
+		*pPurgedSegmentCount = pIStorage->EnforceDataCaptureStorageLimit(nLimitInBytes);
+
+		return LIBMCDATA_SUCCESS;
+	}
+	catch (ELibMCDataInterfaceException & Exception) {
+		return handleLibMCDataException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+
+/*************************************************************************************************************************
+ Class implementation for CustomDataStream
+**************************************************************************************************************************/
+LibMCDataResult libmcdata_customdatastream_getdatauuid(LibMCData_CustomDataStream pCustomDataStream, const LibMCData_uint32 nUUIDBufferSize, LibMCData_uint32* pUUIDNeededChars, char * pUUIDBuffer)
 {
 	IBase* pIBaseClass = (IBase *)pCustomDataStream;
 
 	try {
-		if ( (!pUserUUIDBuffer) && !(pUserUUIDNeededChars) )
+		if ( (!pUUIDBuffer) && !(pUUIDNeededChars) )
 			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
-		std::string sUserUUID("");
+		std::string sUUID("");
 		ICustomDataStream* pICustomDataStream = dynamic_cast<ICustomDataStream*>(pIBaseClass);
 		if (!pICustomDataStream)
 			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
 		
-		bool isCacheCall = (pUserUUIDBuffer == nullptr);
+		bool isCacheCall = (pUUIDBuffer == nullptr);
 		if (isCacheCall) {
-			sUserUUID = pICustomDataStream->GetUserUUID();
+			sUUID = pICustomDataStream->GetDataUUID();
 
-			pICustomDataStream->_setCache (new ParameterCache_1<std::string> (sUserUUID));
+			pICustomDataStream->_setCache (new ParameterCache_1<std::string> (sUUID));
 		}
 		else {
 			auto cache = dynamic_cast<ParameterCache_1<std::string>*> (pICustomDataStream->_getCache ());
 			if (cache == nullptr)
 				throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
-			cache->retrieveData (sUserUUID);
+			cache->retrieveData (sUUID);
 			pICustomDataStream->_setCache (nullptr);
 		}
 		
-		if (pUserUUIDNeededChars)
-			*pUserUUIDNeededChars = (LibMCData_uint32) (sUserUUID.size()+1);
-		if (pUserUUIDBuffer) {
-			if (sUserUUID.size() >= nUserUUIDBufferSize)
+		if (pUUIDNeededChars)
+			*pUUIDNeededChars = (LibMCData_uint32) (sUUID.size()+1);
+		if (pUUIDBuffer) {
+			if (sUUID.size() >= nUUIDBufferSize)
 				throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_BUFFERTOOSMALL);
-			for (size_t iUserUUID = 0; iUserUUID < sUserUUID.size(); iUserUUID++)
-				pUserUUIDBuffer[iUserUUID] = sUserUUID[iUserUUID];
-			pUserUUIDBuffer[sUserUUID.size()] = 0;
+			for (size_t iUUID = 0; iUUID < sUUID.size(); iUUID++)
+				pUUIDBuffer[iUUID] = sUUID[iUUID];
+			pUUIDBuffer[sUUID.size()] = 0;
 		}
 		return LIBMCDATA_SUCCESS;
 	}
@@ -4474,19 +4540,41 @@ LibMCDataResult libmcdata_customdatastream_getuseruuid(LibMCData_CustomDataStrea
 	}
 }
 
-LibMCDataResult libmcdata_customdatastream_getdatatype(LibMCData_CustomDataStream pCustomDataStream, eLibMCDataCustomDataType * pDataType)
+LibMCDataResult libmcdata_customdatastream_getidentifier(LibMCData_CustomDataStream pCustomDataStream, const LibMCData_uint32 nIdentifierBufferSize, LibMCData_uint32* pIdentifierNeededChars, char * pIdentifierBuffer)
 {
 	IBase* pIBaseClass = (IBase *)pCustomDataStream;
 
 	try {
-		if (pDataType == nullptr)
+		if ( (!pIdentifierBuffer) && !(pIdentifierNeededChars) )
 			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		std::string sIdentifier("");
 		ICustomDataStream* pICustomDataStream = dynamic_cast<ICustomDataStream*>(pIBaseClass);
 		if (!pICustomDataStream)
 			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
 		
-		*pDataType = pICustomDataStream->GetDataType();
+		bool isCacheCall = (pIdentifierBuffer == nullptr);
+		if (isCacheCall) {
+			sIdentifier = pICustomDataStream->GetIdentifier();
 
+			pICustomDataStream->_setCache (new ParameterCache_1<std::string> (sIdentifier));
+		}
+		else {
+			auto cache = dynamic_cast<ParameterCache_1<std::string>*> (pICustomDataStream->_getCache ());
+			if (cache == nullptr)
+				throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+			cache->retrieveData (sIdentifier);
+			pICustomDataStream->_setCache (nullptr);
+		}
+		
+		if (pIdentifierNeededChars)
+			*pIdentifierNeededChars = (LibMCData_uint32) (sIdentifier.size()+1);
+		if (pIdentifierBuffer) {
+			if (sIdentifier.size() >= nIdentifierBufferSize)
+				throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_BUFFERTOOSMALL);
+			for (size_t iIdentifier = 0; iIdentifier < sIdentifier.size(); iIdentifier++)
+				pIdentifierBuffer[iIdentifier] = sIdentifier[iIdentifier];
+			pIdentifierBuffer[sIdentifier.size()] = 0;
+		}
 		return LIBMCDATA_SUCCESS;
 	}
 	catch (ELibMCDataInterfaceException & Exception) {
@@ -4500,40 +4588,40 @@ LibMCDataResult libmcdata_customdatastream_getdatatype(LibMCData_CustomDataStrea
 	}
 }
 
-LibMCDataResult libmcdata_customdatastream_getdatatypeasstring(LibMCData_CustomDataStream pCustomDataStream, const LibMCData_uint32 nDataTypeBufferSize, LibMCData_uint32* pDataTypeNeededChars, char * pDataTypeBuffer)
+LibMCDataResult libmcdata_customdatastream_getname(LibMCData_CustomDataStream pCustomDataStream, const LibMCData_uint32 nNameBufferSize, LibMCData_uint32* pNameNeededChars, char * pNameBuffer)
 {
 	IBase* pIBaseClass = (IBase *)pCustomDataStream;
 
 	try {
-		if ( (!pDataTypeBuffer) && !(pDataTypeNeededChars) )
+		if ( (!pNameBuffer) && !(pNameNeededChars) )
 			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
-		std::string sDataType("");
+		std::string sName("");
 		ICustomDataStream* pICustomDataStream = dynamic_cast<ICustomDataStream*>(pIBaseClass);
 		if (!pICustomDataStream)
 			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
 		
-		bool isCacheCall = (pDataTypeBuffer == nullptr);
+		bool isCacheCall = (pNameBuffer == nullptr);
 		if (isCacheCall) {
-			sDataType = pICustomDataStream->GetDataTypeAsString();
+			sName = pICustomDataStream->GetName();
 
-			pICustomDataStream->_setCache (new ParameterCache_1<std::string> (sDataType));
+			pICustomDataStream->_setCache (new ParameterCache_1<std::string> (sName));
 		}
 		else {
 			auto cache = dynamic_cast<ParameterCache_1<std::string>*> (pICustomDataStream->_getCache ());
 			if (cache == nullptr)
 				throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
-			cache->retrieveData (sDataType);
+			cache->retrieveData (sName);
 			pICustomDataStream->_setCache (nullptr);
 		}
 		
-		if (pDataTypeNeededChars)
-			*pDataTypeNeededChars = (LibMCData_uint32) (sDataType.size()+1);
-		if (pDataTypeBuffer) {
-			if (sDataType.size() >= nDataTypeBufferSize)
+		if (pNameNeededChars)
+			*pNameNeededChars = (LibMCData_uint32) (sName.size()+1);
+		if (pNameBuffer) {
+			if (sName.size() >= nNameBufferSize)
 				throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_BUFFERTOOSMALL);
-			for (size_t iDataType = 0; iDataType < sDataType.size(); iDataType++)
-				pDataTypeBuffer[iDataType] = sDataType[iDataType];
-			pDataTypeBuffer[sDataType.size()] = 0;
+			for (size_t iName = 0; iName < sName.size(); iName++)
+				pNameBuffer[iName] = sName[iName];
+			pNameBuffer[sName.size()] = 0;
 		}
 		return LIBMCDATA_SUCCESS;
 	}
@@ -4548,41 +4636,1052 @@ LibMCDataResult libmcdata_customdatastream_getdatatypeasstring(LibMCData_CustomD
 	}
 }
 
-LibMCDataResult libmcdata_customdatastream_getmimetype(LibMCData_CustomDataStream pCustomDataStream, const LibMCData_uint32 nMimeTypeBufferSize, LibMCData_uint32* pMimeTypeNeededChars, char * pMimeTypeBuffer)
+LibMCDataResult libmcdata_customdatastream_gettimestamp(LibMCData_CustomDataStream pCustomDataStream, const LibMCData_uint32 nTimestampBufferSize, LibMCData_uint32* pTimestampNeededChars, char * pTimestampBuffer)
 {
 	IBase* pIBaseClass = (IBase *)pCustomDataStream;
 
 	try {
-		if ( (!pMimeTypeBuffer) && !(pMimeTypeNeededChars) )
+		if ( (!pTimestampBuffer) && !(pTimestampNeededChars) )
 			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
-		std::string sMimeType("");
+		std::string sTimestamp("");
 		ICustomDataStream* pICustomDataStream = dynamic_cast<ICustomDataStream*>(pIBaseClass);
 		if (!pICustomDataStream)
 			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
 		
-		bool isCacheCall = (pMimeTypeBuffer == nullptr);
+		bool isCacheCall = (pTimestampBuffer == nullptr);
 		if (isCacheCall) {
-			sMimeType = pICustomDataStream->GetMIMEType();
+			sTimestamp = pICustomDataStream->GetTimeStamp();
 
-			pICustomDataStream->_setCache (new ParameterCache_1<std::string> (sMimeType));
+			pICustomDataStream->_setCache (new ParameterCache_1<std::string> (sTimestamp));
 		}
 		else {
 			auto cache = dynamic_cast<ParameterCache_1<std::string>*> (pICustomDataStream->_getCache ());
 			if (cache == nullptr)
 				throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
-			cache->retrieveData (sMimeType);
+			cache->retrieveData (sTimestamp);
 			pICustomDataStream->_setCache (nullptr);
 		}
 		
-		if (pMimeTypeNeededChars)
-			*pMimeTypeNeededChars = (LibMCData_uint32) (sMimeType.size()+1);
-		if (pMimeTypeBuffer) {
-			if (sMimeType.size() >= nMimeTypeBufferSize)
-				throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_BUFFERTOOSMALL);
-			for (size_t iMimeType = 0; iMimeType < sMimeType.size(); iMimeType++)
-				pMimeTypeBuffer[iMimeType] = sMimeType[iMimeType];
-			pMimeTypeBuffer[sMimeType.size()] = 0;
-		}
+		if (pTimestampNeededChars)
+			*pTimestampNeededChars = (LibMCData_uint32) (sTimestamp.size()+1);
+		if (pTimestampBuffer) {
+			if (sTimestamp.size() >= nTimestampBufferSize)
+				throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_BUFFERTOOSMALL);
+			for (size_t iTimestamp = 0; iTimestamp < sTimestamp.size(); iTimestamp++)
+				pTimestampBuffer[iTimestamp] = sTimestamp[iTimestamp];
+			pTimestampBuffer[sTimestamp.size()] = 0;
+		}
+		return LIBMCDATA_SUCCESS;
+	}
+	catch (ELibMCDataInterfaceException & Exception) {
+		return handleLibMCDataException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCDataResult libmcdata_customdatastream_getstoragestream(LibMCData_CustomDataStream pCustomDataStream, LibMCData_StorageStream * pStreamInstance)
+{
+	IBase* pIBaseClass = (IBase *)pCustomDataStream;
+
+	try {
+		if (pStreamInstance == nullptr)
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		IBase* pBaseStreamInstance(nullptr);
+		ICustomDataStream* pICustomDataStream = dynamic_cast<ICustomDataStream*>(pIBaseClass);
+		if (!pICustomDataStream)
+			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+		
+		pBaseStreamInstance = pICustomDataStream->GetStorageStream();
+
+		*pStreamInstance = (IBase*)(pBaseStreamInstance);
+		return LIBMCDATA_SUCCESS;
+	}
+	catch (ELibMCDataInterfaceException & Exception) {
+		return handleLibMCDataException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCDataResult libmcdata_customdatastream_getstoragestreamuuid(LibMCData_CustomDataStream pCustomDataStream, const LibMCData_uint32 nSHA2BufferSize, LibMCData_uint32* pSHA2NeededChars, char * pSHA2Buffer)
+{
+	IBase* pIBaseClass = (IBase *)pCustomDataStream;
+
+	try {
+		if ( (!pSHA2Buffer) && !(pSHA2NeededChars) )
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		std::string sSHA2("");
+		ICustomDataStream* pICustomDataStream = dynamic_cast<ICustomDataStream*>(pIBaseClass);
+		if (!pICustomDataStream)
+			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+		
+		bool isCacheCall = (pSHA2Buffer == nullptr);
+		if (isCacheCall) {
+			sSHA2 = pICustomDataStream->GetStorageStreamUUID();
+
+			pICustomDataStream->_setCache (new ParameterCache_1<std::string> (sSHA2));
+		}
+		else {
+			auto cache = dynamic_cast<ParameterCache_1<std::string>*> (pICustomDataStream->_getCache ());
+			if (cache == nullptr)
+				throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+			cache->retrieveData (sSHA2);
+			pICustomDataStream->_setCache (nullptr);
+		}
+		
+		if (pSHA2NeededChars)
+			*pSHA2NeededChars = (LibMCData_uint32) (sSHA2.size()+1);
+		if (pSHA2Buffer) {
+			if (sSHA2.size() >= nSHA2BufferSize)
+				throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_BUFFERTOOSMALL);
+			for (size_t iSHA2 = 0; iSHA2 < sSHA2.size(); iSHA2++)
+				pSHA2Buffer[iSHA2] = sSHA2[iSHA2];
+			pSHA2Buffer[sSHA2.size()] = 0;
+		}
+		return LIBMCDATA_SUCCESS;
+	}
+	catch (ELibMCDataInterfaceException & Exception) {
+		return handleLibMCDataException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCDataResult libmcdata_customdatastream_getstoragestreamsha2(LibMCData_CustomDataStream pCustomDataStream, const LibMCData_uint32 nSHA2BufferSize, LibMCData_uint32* pSHA2NeededChars, char * pSHA2Buffer)
+{
+	IBase* pIBaseClass = (IBase *)pCustomDataStream;
+
+	try {
+		if ( (!pSHA2Buffer) && !(pSHA2NeededChars) )
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		std::string sSHA2("");
+		ICustomDataStream* pICustomDataStream = dynamic_cast<ICustomDataStream*>(pIBaseClass);
+		if (!pICustomDataStream)
+			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+		
+		bool isCacheCall = (pSHA2Buffer == nullptr);
+		if (isCacheCall) {
+			sSHA2 = pICustomDataStream->GetStorageStreamSHA2();
+
+			pICustomDataStream->_setCache (new ParameterCache_1<std::string> (sSHA2));
+		}
+		else {
+			auto cache = dynamic_cast<ParameterCache_1<std::string>*> (pICustomDataStream->_getCache ());
+			if (cache == nullptr)
+				throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+			cache->retrieveData (sSHA2);
+			pICustomDataStream->_setCache (nullptr);
+		}
+		
+		if (pSHA2NeededChars)
+			*pSHA2NeededChars = (LibMCData_uint32) (sSHA2.size()+1);
+		if (pSHA2Buffer) {
+			if (sSHA2.size() >= nSHA2BufferSize)
+				throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_BUFFERTOOSMALL);
+			for (size_t iSHA2 = 0; iSHA2 < sSHA2.size(); iSHA2++)
+				pSHA2Buffer[iSHA2] = sSHA2[iSHA2];
+			pSHA2Buffer[sSHA2.size()] = 0;
+		}
+		return LIBMCDATA_SUCCESS;
+	}
+	catch (ELibMCDataInterfaceException & Exception) {
+		return handleLibMCDataException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCDataResult libmcdata_customdatastream_getstoragestreamsize(LibMCData_CustomDataStream pCustomDataStream, LibMCData_uint64 * pSize)
+{
+	IBase* pIBaseClass = (IBase *)pCustomDataStream;
+
+	try {
+		if (pSize == nullptr)
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		ICustomDataStream* pICustomDataStream = dynamic_cast<ICustomDataStream*>(pIBaseClass);
+		if (!pICustomDataStream)
+			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+		
+		*pSize = pICustomDataStream->GetStorageStreamSize();
+
+		return LIBMCDATA_SUCCESS;
+	}
+	catch (ELibMCDataInterfaceException & Exception) {
+		return handleLibMCDataException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCDataResult libmcdata_customdatastream_getuseruuid(LibMCData_CustomDataStream pCustomDataStream, const LibMCData_uint32 nUserUUIDBufferSize, LibMCData_uint32* pUserUUIDNeededChars, char * pUserUUIDBuffer)
+{
+	IBase* pIBaseClass = (IBase *)pCustomDataStream;
+
+	try {
+		if ( (!pUserUUIDBuffer) && !(pUserUUIDNeededChars) )
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		std::string sUserUUID("");
+		ICustomDataStream* pICustomDataStream = dynamic_cast<ICustomDataStream*>(pIBaseClass);
+		if (!pICustomDataStream)
+			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+		
+		bool isCacheCall = (pUserUUIDBuffer == nullptr);
+		if (isCacheCall) {
+			sUserUUID = pICustomDataStream->GetUserUUID();
+
+			pICustomDataStream->_setCache (new ParameterCache_1<std::string> (sUserUUID));
+		}
+		else {
+			auto cache = dynamic_cast<ParameterCache_1<std::string>*> (pICustomDataStream->_getCache ());
+			if (cache == nullptr)
+				throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+			cache->retrieveData (sUserUUID);
+			pICustomDataStream->_setCache (nullptr);
+		}
+		
+		if (pUserUUIDNeededChars)
+			*pUserUUIDNeededChars = (LibMCData_uint32) (sUserUUID.size()+1);
+		if (pUserUUIDBuffer) {
+			if (sUserUUID.size() >= nUserUUIDBufferSize)
+				throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_BUFFERTOOSMALL);
+			for (size_t iUserUUID = 0; iUserUUID < sUserUUID.size(); iUserUUID++)
+				pUserUUIDBuffer[iUserUUID] = sUserUUID[iUserUUID];
+			pUserUUIDBuffer[sUserUUID.size()] = 0;
+		}
+		return LIBMCDATA_SUCCESS;
+	}
+	catch (ELibMCDataInterfaceException & Exception) {
+		return handleLibMCDataException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCDataResult libmcdata_customdatastream_getdatatype(LibMCData_CustomDataStream pCustomDataStream, eLibMCDataCustomDataType * pDataType)
+{
+	IBase* pIBaseClass = (IBase *)pCustomDataStream;
+
+	try {
+		if (pDataType == nullptr)
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		ICustomDataStream* pICustomDataStream = dynamic_cast<ICustomDataStream*>(pIBaseClass);
+		if (!pICustomDataStream)
+			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+		
+		*pDataType = pICustomDataStream->GetDataType();
+
+		return LIBMCDATA_SUCCESS;
+	}
+	catch (ELibMCDataInterfaceException & Exception) {
+		return handleLibMCDataException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCDataResult libmcdata_customdatastream_getdatatypeasstring(LibMCData_CustomDataStream pCustomDataStream, const LibMCData_uint32 nDataTypeBufferSize, LibMCData_uint32* pDataTypeNeededChars, char * pDataTypeBuffer)
+{
+	IBase* pIBaseClass = (IBase *)pCustomDataStream;
+
+	try {
+		if ( (!pDataTypeBuffer) && !(pDataTypeNeededChars) )
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		std::string sDataType("");
+		ICustomDataStream* pICustomDataStream = dynamic_cast<ICustomDataStream*>(pIBaseClass);
+		if (!pICustomDataStream)
+			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+		
+		bool isCacheCall = (pDataTypeBuffer == nullptr);
+		if (isCacheCall) {
+			sDataType = pICustomDataStream->GetDataTypeAsString();
+
+			pICustomDataStream->_setCache (new ParameterCache_1<std::string> (sDataType));
+		}
+		else {
+			auto cache = dynamic_cast<ParameterCache_1<std::string>*> (pICustomDataStream->_getCache ());
+			if (cache == nullptr)
+				throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+			cache->retrieveData (sDataType);
+			pICustomDataStream->_setCache (nullptr);
+		}
+		
+		if (pDataTypeNeededChars)
+			*pDataTypeNeededChars = (LibMCData_uint32) (sDataType.size()+1);
+		if (pDataTypeBuffer) {
+			if (sDataType.size() >= nDataTypeBufferSize)
+				throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_BUFFERTOOSMALL);
+			for (size_t iDataType = 0; iDataType < sDataType.size(); iDataType++)
+				pDataTypeBuffer[iDataType] = sDataType[iDataType];
+			pDataTypeBuffer[sDataType.size()] = 0;
+		}
+		return LIBMCDATA_SUCCESS;
+	}
+	catch (ELibMCDataInterfaceException & Exception) {
+		return handleLibMCDataException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCDataResult libmcdata_customdatastream_getmimetype(LibMCData_CustomDataStream pCustomDataStream, const LibMCData_uint32 nMimeTypeBufferSize, LibMCData_uint32* pMimeTypeNeededChars, char * pMimeTypeBuffer)
+{
+	IBase* pIBaseClass = (IBase *)pCustomDataStream;
+
+	try {
+		if ( (!pMimeTypeBuffer) && !(pMimeTypeNeededChars) )
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		std::string sMimeType("");
+		ICustomDataStream* pICustomDataStream = dynamic_cast<ICustomDataStream*>(pIBaseClass);
+		if (!pICustomDataStream)
+			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+		
+		bool isCacheCall = (pMimeTypeBuffer == nullptr);
+		if (isCacheCall) {
+			sMimeType = pICustomDataStream->GetMIMEType();
+
+			pICustomDataStream->_setCache (new ParameterCache_1<std::string> (sMimeType));
+		}
+		else {
+			auto cache = dynamic_cast<ParameterCache_1<std::string>*> (pICustomDataStream->_getCache ());
+			if (cache == nullptr)
+				throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+			cache->retrieveData (sMimeType);
+			pICustomDataStream->_setCache (nullptr);
+		}
+		
+		if (pMimeTypeNeededChars)
+			*pMimeTypeNeededChars = (LibMCData_uint32) (sMimeType.size()+1);
+		if (pMimeTypeBuffer) {
+			if (sMimeType.size() >= nMimeTypeBufferSize)
+				throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_BUFFERTOOSMALL);
+			for (size_t iMimeType = 0; iMimeType < sMimeType.size(); iMimeType++)
+				pMimeTypeBuffer[iMimeType] = sMimeType[iMimeType];
+			pMimeTypeBuffer[sMimeType.size()] = 0;
+		}
+		return LIBMCDATA_SUCCESS;
+	}
+	catch (ELibMCDataInterfaceException & Exception) {
+		return handleLibMCDataException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+
+/*************************************************************************************************************************
+ Class implementation for BuildJobData
+**************************************************************************************************************************/
+LibMCDataResult libmcdata_buildjobdata_getjobuuid(LibMCData_BuildJobData pBuildJobData, const LibMCData_uint32 nUUIDBufferSize, LibMCData_uint32* pUUIDNeededChars, char * pUUIDBuffer)
+{
+	IBase* pIBaseClass = (IBase *)pBuildJobData;
+
+	try {
+		if ( (!pUUIDBuffer) && !(pUUIDNeededChars) )
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		std::string sUUID("");
+		IBuildJobData* pIBuildJobData = dynamic_cast<IBuildJobData*>(pIBaseClass);
+		if (!pIBuildJobData)
+			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+		
+		bool isCacheCall = (pUUIDBuffer == nullptr);
+		if (isCacheCall) {
+			sUUID = pIBuildJobData->GetJobUUID();
+
+			pIBuildJobData->_setCache (new ParameterCache_1<std::string> (sUUID));
+		}
+		else {
+			auto cache = dynamic_cast<ParameterCache_1<std::string>*> (pIBuildJobData->_getCache ());
+			if (cache == nullptr)
+				throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+			cache->retrieveData (sUUID);
+			pIBuildJobData->_setCache (nullptr);
+		}
+		
+		if (pUUIDNeededChars)
+			*pUUIDNeededChars = (LibMCData_uint32) (sUUID.size()+1);
+		if (pUUIDBuffer) {
+			if (sUUID.size() >= nUUIDBufferSize)
+				throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_BUFFERTOOSMALL);
+			for (size_t iUUID = 0; iUUID < sUUID.size(); iUUID++)
+				pUUIDBuffer[iUUID] = sUUID[iUUID];
+			pUUIDBuffer[sUUID.size()] = 0;
+		}
+		return LIBMCDATA_SUCCESS;
+	}
+	catch (ELibMCDataInterfaceException & Exception) {
+		return handleLibMCDataException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+
+/*************************************************************************************************************************
+ Class implementation for BuildJobDataIterator
+**************************************************************************************************************************/
+LibMCDataResult libmcdata_buildjobdataiterator_getcurrentjobdata(LibMCData_BuildJobDataIterator pBuildJobDataIterator, LibMCData_BuildJobData * pCurrentInstance)
+{
+	IBase* pIBaseClass = (IBase *)pBuildJobDataIterator;
+
+	try {
+		if (pCurrentInstance == nullptr)
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		IBase* pBaseCurrentInstance(nullptr);
+		IBuildJobDataIterator* pIBuildJobDataIterator = dynamic_cast<IBuildJobDataIterator*>(pIBaseClass);
+		if (!pIBuildJobDataIterator)
+			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+		
+		pBaseCurrentInstance = pIBuildJobDataIterator->GetCurrentJobData();
+
+		*pCurrentInstance = (IBase*)(pBaseCurrentInstance);
+		return LIBMCDATA_SUCCESS;
+	}
+	catch (ELibMCDataInterfaceException & Exception) {
+		return handleLibMCDataException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+
+/*************************************************************************************************************************
+ Class implementation for BuildJobExecutionData
+**************************************************************************************************************************/
+LibMCDataResult libmcdata_buildjobexecutiondata_getexecutionuuid(LibMCData_BuildJobExecutionData pBuildJobExecutionData, const LibMCData_uint32 nUUIDBufferSize, LibMCData_uint32* pUUIDNeededChars, char * pUUIDBuffer)
+{
+	IBase* pIBaseClass = (IBase *)pBuildJobExecutionData;
+
+	try {
+		if ( (!pUUIDBuffer) && !(pUUIDNeededChars) )
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		std::string sUUID("");
+		IBuildJobExecutionData* pIBuildJobExecutionData = dynamic_cast<IBuildJobExecutionData*>(pIBaseClass);
+		if (!pIBuildJobExecutionData)
+			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+		
+		bool isCacheCall = (pUUIDBuffer == nullptr);
+		if (isCacheCall) {
+			sUUID = pIBuildJobExecutionData->GetExecutionUUID();
+
+			pIBuildJobExecutionData->_setCache (new ParameterCache_1<std::string> (sUUID));
+		}
+		else {
+			auto cache = dynamic_cast<ParameterCache_1<std::string>*> (pIBuildJobExecutionData->_getCache ());
+			if (cache == nullptr)
+				throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+			cache->retrieveData (sUUID);
+			pIBuildJobExecutionData->_setCache (nullptr);
+		}
+		
+		if (pUUIDNeededChars)
+			*pUUIDNeededChars = (LibMCData_uint32) (sUUID.size()+1);
+		if (pUUIDBuffer) {
+			if (sUUID.size() >= nUUIDBufferSize)
+				throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_BUFFERTOOSMALL);
+			for (size_t iUUID = 0; iUUID < sUUID.size(); iUUID++)
+				pUUIDBuffer[iUUID] = sUUID[iUUID];
+			pUUIDBuffer[sUUID.size()] = 0;
+		}
+		return LIBMCDATA_SUCCESS;
+	}
+	catch (ELibMCDataInterfaceException & Exception) {
+		return handleLibMCDataException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+
+/*************************************************************************************************************************
+ Class implementation for BuildJobExecutionDataIterator
+**************************************************************************************************************************/
+LibMCDataResult libmcdata_buildjobexecutiondataiterator_getcurrentjobexecutiondata(LibMCData_BuildJobExecutionDataIterator pBuildJobExecutionDataIterator, LibMCData_BuildJobExecutionData * pCurrentInstance)
+{
+	IBase* pIBaseClass = (IBase *)pBuildJobExecutionDataIterator;
+
+	try {
+		if (pCurrentInstance == nullptr)
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		IBase* pBaseCurrentInstance(nullptr);
+		IBuildJobExecutionDataIterator* pIBuildJobExecutionDataIterator = dynamic_cast<IBuildJobExecutionDataIterator*>(pIBaseClass);
+		if (!pIBuildJobExecutionDataIterator)
+			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+		
+		pBaseCurrentInstance = pIBuildJobExecutionDataIterator->GetCurrentJobExecutionData();
+
+		*pCurrentInstance = (IBase*)(pBaseCurrentInstance);
+		return LIBMCDATA_SUCCESS;
+	}
+	catch (ELibMCDataInterfaceException & Exception) {
+		return handleLibMCDataException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+
+/*************************************************************************************************************************
+ Class implementation for DataCapture
+**************************************************************************************************************************/
+LibMCDataResult libmcdata_datacapture_getuuid(LibMCData_DataCapture pDataCapture, const LibMCData_uint32 nUUIDBufferSize, LibMCData_uint32* pUUIDNeededChars, char * pUUIDBuffer)
+{
+	IBase* pIBaseClass = (IBase *)pDataCapture;
+
+	try {
+		if ( (!pUUIDBuffer) && !(pUUIDNeededChars) )
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		std::string sUUID("");
+		IDataCapture* pIDataCapture = dynamic_cast<IDataCapture*>(pIBaseClass);
+		if (!pIDataCapture)
+			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+		
+		bool isCacheCall = (pUUIDBuffer == nullptr);
+		if (isCacheCall) {
+			sUUID = pIDataCapture->GetUUID();
+
+			pIDataCapture->_setCache (new ParameterCache_1<std::string> (sUUID));
+		}
+		else {
+			auto cache = dynamic_cast<ParameterCache_1<std::string>*> (pIDataCapture->_getCache ());
+			if (cache == nullptr)
+				throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+			cache->retrieveData (sUUID);
+			pIDataCapture->_setCache (nullptr);
+		}
+		
+		if (pUUIDNeededChars)
+			*pUUIDNeededChars = (LibMCData_uint32) (sUUID.size()+1);
+		if (pUUIDBuffer) {
+			if (sUUID.size() >= nUUIDBufferSize)
+				throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_BUFFERTOOSMALL);
+			for (size_t iUUID = 0; iUUID < sUUID.size(); iUUID++)
+				pUUIDBuffer[iUUID] = sUUID[iUUID];
+			pUUIDBuffer[sUUID.size()] = 0;
+		}
+		return LIBMCDATA_SUCCESS;
+	}
+	catch (ELibMCDataInterfaceException & Exception) {
+		return handleLibMCDataException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCDataResult libmcdata_datacapture_getexecutionuuid(LibMCData_DataCapture pDataCapture, const LibMCData_uint32 nExecutionUUIDBufferSize, LibMCData_uint32* pExecutionUUIDNeededChars, char * pExecutionUUIDBuffer)
+{
+	IBase* pIBaseClass = (IBase *)pDataCapture;
+
+	try {
+		if ( (!pExecutionUUIDBuffer) && !(pExecutionUUIDNeededChars) )
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		std::string sExecutionUUID("");
+		IDataCapture* pIDataCapture = dynamic_cast<IDataCapture*>(pIBaseClass);
+		if (!pIDataCapture)
+			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+		
+		bool isCacheCall = (pExecutionUUIDBuffer == nullptr);
+		if (isCacheCall) {
+			sExecutionUUID = pIDataCapture->GetExecutionUUID();
+
+			pIDataCapture->_setCache (new ParameterCache_1<std::string> (sExecutionUUID));
+		}
+		else {
+			auto cache = dynamic_cast<ParameterCache_1<std::string>*> (pIDataCapture->_getCache ());
+			if (cache == nullptr)
+				throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+			cache->retrieveData (sExecutionUUID);
+			pIDataCapture->_setCache (nullptr);
+		}
+		
+		if (pExecutionUUIDNeededChars)
+			*pExecutionUUIDNeededChars = (LibMCData_uint32) (sExecutionUUID.size()+1);
+		if (pExecutionUUIDBuffer) {
+			if (sExecutionUUID.size() >= nExecutionUUIDBufferSize)
+				throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_BUFFERTOOSMALL);
+			for (size_t iExecutionUUID = 0; iExecutionUUID < sExecutionUUID.size(); iExecutionUUID++)
+				pExecutionUUIDBuffer[iExecutionUUID] = sExecutionUUID[iExecutionUUID];
+			pExecutionUUIDBuffer[sExecutionUUID.size()] = 0;
+		}
+		return LIBMCDATA_SUCCESS;
+	}
+	catch (ELibMCDataInterfaceException & Exception) {
+		return handleLibMCDataException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCDataResult libmcdata_datacapture_getidentifier(LibMCData_DataCapture pDataCapture, const LibMCData_uint32 nIdentifierBufferSize, LibMCData_uint32* pIdentifierNeededChars, char * pIdentifierBuffer)
+{
+	IBase* pIBaseClass = (IBase *)pDataCapture;
+
+	try {
+		if ( (!pIdentifierBuffer) && !(pIdentifierNeededChars) )
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		std::string sIdentifier("");
+		IDataCapture* pIDataCapture = dynamic_cast<IDataCapture*>(pIBaseClass);
+		if (!pIDataCapture)
+			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+		
+		bool isCacheCall = (pIdentifierBuffer == nullptr);
+		if (isCacheCall) {
+			sIdentifier = pIDataCapture->GetIdentifier();
+
+			pIDataCapture->_setCache (new ParameterCache_1<std::string> (sIdentifier));
+		}
+		else {
+			auto cache = dynamic_cast<ParameterCache_1<std::string>*> (pIDataCapture->_getCache ());
+			if (cache == nullptr)
+				throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+			cache->retrieveData (sIdentifier);
+			pIDataCapture->_setCache (nullptr);
+		}
+		
+		if (pIdentifierNeededChars)
+			*pIdentifierNeededChars = (LibMCData_uint32) (sIdentifier.size()+1);
+		if (pIdentifierBuffer) {
+			if (sIdentifier.size() >= nIdentifierBufferSize)
+				throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_BUFFERTOOSMALL);
+			for (size_t iIdentifier = 0; iIdentifier < sIdentifier.size(); iIdentifier++)
+				pIdentifierBuffer[iIdentifier] = sIdentifier[iIdentifier];
+			pIdentifierBuffer[sIdentifier.size()] = 0;
+		}
+		return LIBMCDATA_SUCCESS;
+	}
+	catch (ELibMCDataInterfaceException & Exception) {
+		return handleLibMCDataException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCDataResult libmcdata_datacapture_getname(LibMCData_DataCapture pDataCapture, const LibMCData_uint32 nNameBufferSize, LibMCData_uint32* pNameNeededChars, char * pNameBuffer)
+{
+	IBase* pIBaseClass = (IBase *)pDataCapture;
+
+	try {
+		if ( (!pNameBuffer) && !(pNameNeededChars) )
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		std::string sName("");
+		IDataCapture* pIDataCapture = dynamic_cast<IDataCapture*>(pIBaseClass);
+		if (!pIDataCapture)
+			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+		
+		bool isCacheCall = (pNameBuffer == nullptr);
+		if (isCacheCall) {
+			sName = pIDataCapture->GetName();
+
+			pIDataCapture->_setCache (new ParameterCache_1<std::string> (sName));
+		}
+		else {
+			auto cache = dynamic_cast<ParameterCache_1<std::string>*> (pIDataCapture->_getCache ());
+			if (cache == nullptr)
+				throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+			cache->retrieveData (sName);
+			pIDataCapture->_setCache (nullptr);
+		}
+		
+		if (pNameNeededChars)
+			*pNameNeededChars = (LibMCData_uint32) (sName.size()+1);
+		if (pNameBuffer) {
+			if (sName.size() >= nNameBufferSize)
+				throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_BUFFERTOOSMALL);
+			for (size_t iName = 0; iName < sName.size(); iName++)
+				pNameBuffer[iName] = sName[iName];
+			pNameBuffer[sName.size()] = 0;
+		}
+		return LIBMCDATA_SUCCESS;
+	}
+	catch (ELibMCDataInterfaceException & Exception) {
+		return handleLibMCDataException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCDataResult libmcdata_datacapture_getstatus(LibMCData_DataCapture pDataCapture, eLibMCDataDataCaptureStatus * pStatus)
+{
+	IBase* pIBaseClass = (IBase *)pDataCapture;
+
+	try {
+		if (pStatus == nullptr)
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		IDataCapture* pIDataCapture = dynamic_cast<IDataCapture*>(pIBaseClass);
+		if (!pIDataCapture)
+			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+		
+		*pStatus = pIDataCapture->GetStatus();
+
+		return LIBMCDATA_SUCCESS;
+	}
+	catch (ELibMCDataInterfaceException & Exception) {
+		return handleLibMCDataException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCDataResult libmcdata_datacapture_gettimestamp(LibMCData_DataCapture pDataCapture, const LibMCData_uint32 nTimeStampBufferSize, LibMCData_uint32* pTimeStampNeededChars, char * pTimeStampBuffer)
+{
+	IBase* pIBaseClass = (IBase *)pDataCapture;
+
+	try {
+		if ( (!pTimeStampBuffer) && !(pTimeStampNeededChars) )
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		std::string sTimeStamp("");
+		IDataCapture* pIDataCapture = dynamic_cast<IDataCapture*>(pIBaseClass);
+		if (!pIDataCapture)
+			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+		
+		bool isCacheCall = (pTimeStampBuffer == nullptr);
+		if (isCacheCall) {
+			sTimeStamp = pIDataCapture->GetTimeStamp();
+
+			pIDataCapture->_setCache (new ParameterCache_1<std::string> (sTimeStamp));
+		}
+		else {
+			auto cache = dynamic_cast<ParameterCache_1<std::string>*> (pIDataCapture->_getCache ());
+			if (cache == nullptr)
+				throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+			cache->retrieveData (sTimeStamp);
+			pIDataCapture->_setCache (nullptr);
+		}
+		
+		if (pTimeStampNeededChars)
+			*pTimeStampNeededChars = (LibMCData_uint32) (sTimeStamp.size()+1);
+		if (pTimeStampBuffer) {
+			if (sTimeStamp.size() >= nTimeStampBufferSize)
+				throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_BUFFERTOOSMALL);
+			for (size_t iTimeStamp = 0; iTimeStamp < sTimeStamp.size(); iTimeStamp++)
+				pTimeStampBuffer[iTimeStamp] = sTimeStamp[iTimeStamp];
+			pTimeStampBuffer[sTimeStamp.size()] = 0;
+		}
+		return LIBMCDATA_SUCCESS;
+	}
+	catch (ELibMCDataInterfaceException & Exception) {
+		return handleLibMCDataException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCDataResult libmcdata_datacapture_addcolumn(LibMCData_DataCapture pDataCapture, LibMCData_uint32 nColumnIndex, const char * pIdentifier, const char * pDescription, LibMCData_uint32 nColumnType)
+{
+	IBase* pIBaseClass = (IBase *)pDataCapture;
+
+	try {
+		if (pIdentifier == nullptr)
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		if (pDescription == nullptr)
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		std::string sIdentifier(pIdentifier);
+		std::string sDescription(pDescription);
+		IDataCapture* pIDataCapture = dynamic_cast<IDataCapture*>(pIBaseClass);
+		if (!pIDataCapture)
+			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+		
+		pIDataCapture->AddColumn(nColumnIndex, sIdentifier, sDescription, nColumnType);
+
+		return LIBMCDATA_SUCCESS;
+	}
+	catch (ELibMCDataInterfaceException & Exception) {
+		return handleLibMCDataException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCDataResult libmcdata_datacapture_getcolumncount(LibMCData_DataCapture pDataCapture, LibMCData_uint32 * pColumnCount)
+{
+	IBase* pIBaseClass = (IBase *)pDataCapture;
+
+	try {
+		if (pColumnCount == nullptr)
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		IDataCapture* pIDataCapture = dynamic_cast<IDataCapture*>(pIBaseClass);
+		if (!pIDataCapture)
+			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+		
+		*pColumnCount = pIDataCapture->GetColumnCount();
+
+		return LIBMCDATA_SUCCESS;
+	}
+	catch (ELibMCDataInterfaceException & Exception) {
+		return handleLibMCDataException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCDataResult libmcdata_datacapture_getcolumninformation(LibMCData_DataCapture pDataCapture, LibMCData_uint32 nColumnIndex, const LibMCData_uint32 nIdentifierBufferSize, LibMCData_uint32* pIdentifierNeededChars, char * pIdentifierBuffer, const LibMCData_uint32 nDescriptionBufferSize, LibMCData_uint32* pDescriptionNeededChars, char * pDescriptionBuffer, LibMCData_uint32 * pColumnType)
+{
+	IBase* pIBaseClass = (IBase *)pDataCapture;
+
+	try {
+		if ( (!pIdentifierBuffer) && !(pIdentifierNeededChars) )
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		if ( (!pDescriptionBuffer) && !(pDescriptionNeededChars) )
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		if (!pColumnType)
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		std::string sIdentifier("");
+		std::string sDescription("");
+		IDataCapture* pIDataCapture = dynamic_cast<IDataCapture*>(pIBaseClass);
+		if (!pIDataCapture)
+			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+		
+		bool isCacheCall = (pIdentifierBuffer == nullptr) || (pDescriptionBuffer == nullptr);
+		if (isCacheCall) {
+			pIDataCapture->GetColumnInformation(nColumnIndex, sIdentifier, sDescription, *pColumnType);
+
+			pIDataCapture->_setCache (new ParameterCache_3<std::string, std::string, LibMCData_uint32> (sIdentifier, sDescription, *pColumnType));
+		}
+		else {
+			auto cache = dynamic_cast<ParameterCache_3<std::string, std::string, LibMCData_uint32>*> (pIDataCapture->_getCache ());
+			if (cache == nullptr)
+				throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+			cache->retrieveData (sIdentifier, sDescription, *pColumnType);
+			pIDataCapture->_setCache (nullptr);
+		}
+		
+		if (pIdentifierNeededChars)
+			*pIdentifierNeededChars = (LibMCData_uint32) (sIdentifier.size()+1);
+		if (pIdentifierBuffer) {
+			if (sIdentifier.size() >= nIdentifierBufferSize)
+				throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_BUFFERTOOSMALL);
+			for (size_t iIdentifier = 0; iIdentifier < sIdentifier.size(); iIdentifier++)
+				pIdentifierBuffer[iIdentifier] = sIdentifier[iIdentifier];
+			pIdentifierBuffer[sIdentifier.size()] = 0;
+		}
+		if (pDescriptionNeededChars)
+			*pDescriptionNeededChars = (LibMCData_uint32) (sDescription.size()+1);
+		if (pDescriptionBuffer) {
+			if (sDescription.size() >= nDescriptionBufferSize)
+				throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_BUFFERTOOSMALL);
+			for (size_t iDescription = 0; iDescription < sDescription.size(); iDescription++)
+				pDescriptionBuffer[iDescription] = sDescription[iDescription];
+			pDescriptionBuffer[sDescription.size()] = 0;
+		}
+		return LIBMCDATA_SUCCESS;
+	}
+	catch (ELibMCDataInterfaceException & Exception) {
+		return handleLibMCDataException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCDataResult libmcdata_datacapture_addsegment(LibMCData_DataCapture pDataCapture, LibMCData_uint32 nSegmentIndex, const char * pStreamUUID, LibMCData_uint64 nFirstRow, LibMCData_uint64 nRowCount, LibMCData_uint32 nChunkCount, LibMCData_uint64 nSizeInBytes, LibMCData_uint64 nStartTimeStamp, LibMCData_uint64 nEndTimeStamp)
+{
+	IBase* pIBaseClass = (IBase *)pDataCapture;
+
+	try {
+		if (pStreamUUID == nullptr)
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		std::string sStreamUUID(pStreamUUID);
+		IDataCapture* pIDataCapture = dynamic_cast<IDataCapture*>(pIBaseClass);
+		if (!pIDataCapture)
+			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+		
+		pIDataCapture->AddSegment(nSegmentIndex, sStreamUUID, nFirstRow, nRowCount, nChunkCount, nSizeInBytes, nStartTimeStamp, nEndTimeStamp);
+
+		return LIBMCDATA_SUCCESS;
+	}
+	catch (ELibMCDataInterfaceException & Exception) {
+		return handleLibMCDataException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCDataResult libmcdata_datacapture_getsegmentcount(LibMCData_DataCapture pDataCapture, LibMCData_uint32 * pSegmentCount)
+{
+	IBase* pIBaseClass = (IBase *)pDataCapture;
+
+	try {
+		if (pSegmentCount == nullptr)
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		IDataCapture* pIDataCapture = dynamic_cast<IDataCapture*>(pIBaseClass);
+		if (!pIDataCapture)
+			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+		
+		*pSegmentCount = pIDataCapture->GetSegmentCount();
+
+		return LIBMCDATA_SUCCESS;
+	}
+	catch (ELibMCDataInterfaceException & Exception) {
+		return handleLibMCDataException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCDataResult libmcdata_datacapture_getsegmentinformation(LibMCData_DataCapture pDataCapture, LibMCData_uint32 nSegmentIndex, const LibMCData_uint32 nStreamUUIDBufferSize, LibMCData_uint32* pStreamUUIDNeededChars, char * pStreamUUIDBuffer, LibMCData_uint64 * pFirstRow, LibMCData_uint64 * pRowCount, LibMCData_uint64 * pSizeInBytes, bool * pIsPurged)
+{
+	IBase* pIBaseClass = (IBase *)pDataCapture;
+
+	try {
+		if ( (!pStreamUUIDBuffer) && !(pStreamUUIDNeededChars) )
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		if (!pFirstRow)
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		if (!pRowCount)
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		if (!pSizeInBytes)
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		if (!pIsPurged)
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		std::string sStreamUUID("");
+		IDataCapture* pIDataCapture = dynamic_cast<IDataCapture*>(pIBaseClass);
+		if (!pIDataCapture)
+			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+		
+		bool isCacheCall = (pStreamUUIDBuffer == nullptr);
+		if (isCacheCall) {
+			pIDataCapture->GetSegmentInformation(nSegmentIndex, sStreamUUID, *pFirstRow, *pRowCount, *pSizeInBytes, *pIsPurged);
+
+			pIDataCapture->_setCache (new ParameterCache_5<std::string, LibMCData_uint64, LibMCData_uint64, LibMCData_uint64, bool> (sStreamUUID, *pFirstRow, *pRowCount, *pSizeInBytes, *pIsPurged));
+		}
+		else {
+			auto cache = dynamic_cast<ParameterCache_5<std::string, LibMCData_uint64, LibMCData_uint64, LibMCData_uint64, bool>*> (pIDataCapture->_getCache ());
+			if (cache == nullptr)
+				throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+			cache->retrieveData (sStreamUUID, *pFirstRow, *pRowCount, *pSizeInBytes, *pIsPurged);
+			pIDataCapture->_setCache (nullptr);
+		}
+		
+		if (pStreamUUIDNeededChars)
+			*pStreamUUIDNeededChars = (LibMCData_uint32) (sStreamUUID.size()+1);
+		if (pStreamUUIDBuffer) {
+			if (sStreamUUID.size() >= nStreamUUIDBufferSize)
+				throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_BUFFERTOOSMALL);
+			for (size_t iStreamUUID = 0; iStreamUUID < sStreamUUID.size(); iStreamUUID++)
+				pStreamUUIDBuffer[iStreamUUID] = sStreamUUID[iStreamUUID];
+			pStreamUUIDBuffer[sStreamUUID.size()] = 0;
+		}
+		return LIBMCDATA_SUCCESS;
+	}
+	catch (ELibMCDataInterfaceException & Exception) {
+		return handleLibMCDataException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCDataResult libmcdata_datacapture_getsegmentchunkcount(LibMCData_DataCapture pDataCapture, LibMCData_uint32 nSegmentIndex, LibMCData_uint32 * pChunkCount)
+{
+	IBase* pIBaseClass = (IBase *)pDataCapture;
+
+	try {
+		if (pChunkCount == nullptr)
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		IDataCapture* pIDataCapture = dynamic_cast<IDataCapture*>(pIBaseClass);
+		if (!pIDataCapture)
+			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+		
+		*pChunkCount = pIDataCapture->GetSegmentChunkCount(nSegmentIndex);
+
 		return LIBMCDATA_SUCCESS;
 	}
 	catch (ELibMCDataInterfaceException & Exception) {
@@ -4596,45 +5695,19 @@ LibMCDataResult libmcdata_customdatastream_getmimetype(LibMCData_CustomDataStrea
 	}
 }
 
-
-/*************************************************************************************************************************
- Class implementation for BuildJobData
-**************************************************************************************************************************/
-LibMCDataResult libmcdata_buildjobdata_getjobuuid(LibMCData_BuildJobData pBuildJobData, const LibMCData_uint32 nUUIDBufferSize, LibMCData_uint32* pUUIDNeededChars, char * pUUIDBuffer)
+LibMCDataResult libmcdata_datacapture_getrowcount(LibMCData_DataCapture pDataCapture, LibMCData_uint64 * pRowCount)
 {
-	IBase* pIBaseClass = (IBase *)pBuildJobData;
+	IBase* pIBaseClass = (IBase *)pDataCapture;
 
 	try {
-		if ( (!pUUIDBuffer) && !(pUUIDNeededChars) )
+		if (pRowCount == nullptr)
 			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
-		std::string sUUID("");
-		IBuildJobData* pIBuildJobData = dynamic_cast<IBuildJobData*>(pIBaseClass);
-		if (!pIBuildJobData)
+		IDataCapture* pIDataCapture = dynamic_cast<IDataCapture*>(pIBaseClass);
+		if (!pIDataCapture)
 			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
 		
-		bool isCacheCall = (pUUIDBuffer == nullptr);
-		if (isCacheCall) {
-			sUUID = pIBuildJobData->GetJobUUID();
+		*pRowCount = pIDataCapture->GetRowCount();
 
-			pIBuildJobData->_setCache (new ParameterCache_1<std::string> (sUUID));
-		}
-		else {
-			auto cache = dynamic_cast<ParameterCache_1<std::string>*> (pIBuildJobData->_getCache ());
-			if (cache == nullptr)
-				throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
-			cache->retrieveData (sUUID);
-			pIBuildJobData->_setCache (nullptr);
-		}
-		
-		if (pUUIDNeededChars)
-			*pUUIDNeededChars = (LibMCData_uint32) (sUUID.size()+1);
-		if (pUUIDBuffer) {
-			if (sUUID.size() >= nUUIDBufferSize)
-				throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_BUFFERTOOSMALL);
-			for (size_t iUUID = 0; iUUID < sUUID.size(); iUUID++)
-				pUUIDBuffer[iUUID] = sUUID[iUUID];
-			pUUIDBuffer[sUUID.size()] = 0;
-		}
 		return LIBMCDATA_SUCCESS;
 	}
 	catch (ELibMCDataInterfaceException & Exception) {
@@ -4648,25 +5721,19 @@ LibMCDataResult libmcdata_buildjobdata_getjobuuid(LibMCData_BuildJobData pBuildJ
 	}
 }
 
-
-/*************************************************************************************************************************
- Class implementation for BuildJobDataIterator
-**************************************************************************************************************************/
-LibMCDataResult libmcdata_buildjobdataiterator_getcurrentjobdata(LibMCData_BuildJobDataIterator pBuildJobDataIterator, LibMCData_BuildJobData * pCurrentInstance)
+LibMCDataResult libmcdata_datacapture_getstoredsizeinbytes(LibMCData_DataCapture pDataCapture, LibMCData_uint64 * pSizeInBytes)
 {
-	IBase* pIBaseClass = (IBase *)pBuildJobDataIterator;
+	IBase* pIBaseClass = (IBase *)pDataCapture;
 
 	try {
-		if (pCurrentInstance == nullptr)
+		if (pSizeInBytes == nullptr)
 			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
-		IBase* pBaseCurrentInstance(nullptr);
-		IBuildJobDataIterator* pIBuildJobDataIterator = dynamic_cast<IBuildJobDataIterator*>(pIBaseClass);
-		if (!pIBuildJobDataIterator)
+		IDataCapture* pIDataCapture = dynamic_cast<IDataCapture*>(pIBaseClass);
+		if (!pIDataCapture)
 			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
 		
-		pBaseCurrentInstance = pIBuildJobDataIterator->GetCurrentJobData();
+		*pSizeInBytes = pIDataCapture->GetStoredSizeInBytes();
 
-		*pCurrentInstance = (IBase*)(pBaseCurrentInstance);
 		return LIBMCDATA_SUCCESS;
 	}
 	catch (ELibMCDataInterfaceException & Exception) {
@@ -4680,45 +5747,17 @@ LibMCDataResult libmcdata_buildjobdataiterator_getcurrentjobdata(LibMCData_Build
 	}
 }
 
-
-/*************************************************************************************************************************
- Class implementation for BuildJobExecutionData
-**************************************************************************************************************************/
-LibMCDataResult libmcdata_buildjobexecutiondata_getexecutionuuid(LibMCData_BuildJobExecutionData pBuildJobExecutionData, const LibMCData_uint32 nUUIDBufferSize, LibMCData_uint32* pUUIDNeededChars, char * pUUIDBuffer)
+LibMCDataResult libmcdata_datacapture_finish(LibMCData_DataCapture pDataCapture, LibMCData_uint64 nAbsoluteTimeStamp)
 {
-	IBase* pIBaseClass = (IBase *)pBuildJobExecutionData;
+	IBase* pIBaseClass = (IBase *)pDataCapture;
 
 	try {
-		if ( (!pUUIDBuffer) && !(pUUIDNeededChars) )
-			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
-		std::string sUUID("");
-		IBuildJobExecutionData* pIBuildJobExecutionData = dynamic_cast<IBuildJobExecutionData*>(pIBaseClass);
-		if (!pIBuildJobExecutionData)
+		IDataCapture* pIDataCapture = dynamic_cast<IDataCapture*>(pIBaseClass);
+		if (!pIDataCapture)
 			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
 		
-		bool isCacheCall = (pUUIDBuffer == nullptr);
-		if (isCacheCall) {
-			sUUID = pIBuildJobExecutionData->GetExecutionUUID();
+		pIDataCapture->Finish(nAbsoluteTimeStamp);
 
-			pIBuildJobExecutionData->_setCache (new ParameterCache_1<std::string> (sUUID));
-		}
-		else {
-			auto cache = dynamic_cast<ParameterCache_1<std::string>*> (pIBuildJobExecutionData->_getCache ());
-			if (cache == nullptr)
-				throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
-			cache->retrieveData (sUUID);
-			pIBuildJobExecutionData->_setCache (nullptr);
-		}
-		
-		if (pUUIDNeededChars)
-			*pUUIDNeededChars = (LibMCData_uint32) (sUUID.size()+1);
-		if (pUUIDBuffer) {
-			if (sUUID.size() >= nUUIDBufferSize)
-				throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_BUFFERTOOSMALL);
-			for (size_t iUUID = 0; iUUID < sUUID.size(); iUUID++)
-				pUUIDBuffer[iUUID] = sUUID[iUUID];
-			pUUIDBuffer[sUUID.size()] = 0;
-		}
 		return LIBMCDATA_SUCCESS;
 	}
 	catch (ELibMCDataInterfaceException & Exception) {
@@ -4732,25 +5771,17 @@ LibMCDataResult libmcdata_buildjobexecutiondata_getexecutionuuid(LibMCData_Build
 	}
 }
 
-
-/*************************************************************************************************************************
- Class implementation for BuildJobExecutionDataIterator
-**************************************************************************************************************************/
-LibMCDataResult libmcdata_buildjobexecutiondataiterator_getcurrentjobexecutiondata(LibMCData_BuildJobExecutionDataIterator pBuildJobExecutionDataIterator, LibMCData_BuildJobExecutionData * pCurrentInstance)
+LibMCDataResult libmcdata_datacapture_abort(LibMCData_DataCapture pDataCapture, LibMCData_uint64 nAbsoluteTimeStamp)
 {
-	IBase* pIBaseClass = (IBase *)pBuildJobExecutionDataIterator;
+	IBase* pIBaseClass = (IBase *)pDataCapture;
 
 	try {
-		if (pCurrentInstance == nullptr)
-			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
-		IBase* pBaseCurrentInstance(nullptr);
-		IBuildJobExecutionDataIterator* pIBuildJobExecutionDataIterator = dynamic_cast<IBuildJobExecutionDataIterator*>(pIBaseClass);
-		if (!pIBuildJobExecutionDataIterator)
+		IDataCapture* pIDataCapture = dynamic_cast<IDataCapture*>(pIBaseClass);
+		if (!pIDataCapture)
 			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
 		
-		pBaseCurrentInstance = pIBuildJobExecutionDataIterator->GetCurrentJobExecutionData();
+		pIDataCapture->Abort(nAbsoluteTimeStamp);
 
-		*pCurrentInstance = (IBase*)(pBaseCurrentInstance);
 		return LIBMCDATA_SUCCESS;
 	}
 	catch (ELibMCDataInterfaceException & Exception) {
@@ -5707,6 +6738,157 @@ LibMCDataResult libmcdata_buildjobexecution_getmetadatastring(LibMCData_BuildJob
 	}
 }
 
+LibMCDataResult libmcdata_buildjobexecution_createdatacapture(LibMCData_BuildJobExecution pBuildJobExecution, const char * pIdentifier, const char * pName, const char * pUserUUID, LibMCData_uint64 nAbsoluteTimeStamp, LibMCData_DataCapture * pDataCaptureInstance)
+{
+	IBase* pIBaseClass = (IBase *)pBuildJobExecution;
+
+	try {
+		if (pIdentifier == nullptr)
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		if (pName == nullptr)
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		if (pUserUUID == nullptr)
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		if (pDataCaptureInstance == nullptr)
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		std::string sIdentifier(pIdentifier);
+		std::string sName(pName);
+		std::string sUserUUID(pUserUUID);
+		IBase* pBaseDataCaptureInstance(nullptr);
+		IBuildJobExecution* pIBuildJobExecution = dynamic_cast<IBuildJobExecution*>(pIBaseClass);
+		if (!pIBuildJobExecution)
+			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+		
+		pBaseDataCaptureInstance = pIBuildJobExecution->CreateDataCapture(sIdentifier, sName, sUserUUID, nAbsoluteTimeStamp);
+
+		*pDataCaptureInstance = (IBase*)(pBaseDataCaptureInstance);
+		return LIBMCDATA_SUCCESS;
+	}
+	catch (ELibMCDataInterfaceException & Exception) {
+		return handleLibMCDataException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCDataResult libmcdata_buildjobexecution_hasdatacapture(LibMCData_BuildJobExecution pBuildJobExecution, const char * pIdentifier, bool * pHasDataCapture)
+{
+	IBase* pIBaseClass = (IBase *)pBuildJobExecution;
+
+	try {
+		if (pIdentifier == nullptr)
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		if (pHasDataCapture == nullptr)
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		std::string sIdentifier(pIdentifier);
+		IBuildJobExecution* pIBuildJobExecution = dynamic_cast<IBuildJobExecution*>(pIBaseClass);
+		if (!pIBuildJobExecution)
+			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+		
+		*pHasDataCapture = pIBuildJobExecution->HasDataCapture(sIdentifier);
+
+		return LIBMCDATA_SUCCESS;
+	}
+	catch (ELibMCDataInterfaceException & Exception) {
+		return handleLibMCDataException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCDataResult libmcdata_buildjobexecution_retrievedatacapture(LibMCData_BuildJobExecution pBuildJobExecution, const char * pIdentifier, LibMCData_DataCapture * pDataCaptureInstance)
+{
+	IBase* pIBaseClass = (IBase *)pBuildJobExecution;
+
+	try {
+		if (pIdentifier == nullptr)
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		if (pDataCaptureInstance == nullptr)
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		std::string sIdentifier(pIdentifier);
+		IBase* pBaseDataCaptureInstance(nullptr);
+		IBuildJobExecution* pIBuildJobExecution = dynamic_cast<IBuildJobExecution*>(pIBaseClass);
+		if (!pIBuildJobExecution)
+			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+		
+		pBaseDataCaptureInstance = pIBuildJobExecution->RetrieveDataCapture(sIdentifier);
+
+		*pDataCaptureInstance = (IBase*)(pBaseDataCaptureInstance);
+		return LIBMCDATA_SUCCESS;
+	}
+	catch (ELibMCDataInterfaceException & Exception) {
+		return handleLibMCDataException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCDataResult libmcdata_buildjobexecution_getdatacapturecount(LibMCData_BuildJobExecution pBuildJobExecution, LibMCData_uint32 * pDataCaptureCount)
+{
+	IBase* pIBaseClass = (IBase *)pBuildJobExecution;
+
+	try {
+		if (pDataCaptureCount == nullptr)
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		IBuildJobExecution* pIBuildJobExecution = dynamic_cast<IBuildJobExecution*>(pIBaseClass);
+		if (!pIBuildJobExecution)
+			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+		
+		*pDataCaptureCount = pIBuildJobExecution->GetDataCaptureCount();
+
+		return LIBMCDATA_SUCCESS;
+	}
+	catch (ELibMCDataInterfaceException & Exception) {
+		return handleLibMCDataException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCDataResult libmcdata_buildjobexecution_retrievedatacapturebyindex(LibMCData_BuildJobExecution pBuildJobExecution, LibMCData_uint32 nIndex, LibMCData_DataCapture * pDataCaptureInstance)
+{
+	IBase* pIBaseClass = (IBase *)pBuildJobExecution;
+
+	try {
+		if (pDataCaptureInstance == nullptr)
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		IBase* pBaseDataCaptureInstance(nullptr);
+		IBuildJobExecution* pIBuildJobExecution = dynamic_cast<IBuildJobExecution*>(pIBaseClass);
+		if (!pIBuildJobExecution)
+			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+		
+		pBaseDataCaptureInstance = pIBuildJobExecution->RetrieveDataCaptureByIndex(nIndex);
+
+		*pDataCaptureInstance = (IBase*)(pBaseDataCaptureInstance);
+		return LIBMCDATA_SUCCESS;
+	}
+	catch (ELibMCDataInterfaceException & Exception) {
+		return handleLibMCDataException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
 
 /*************************************************************************************************************************
  Class implementation for BuildJobExecutionIterator
@@ -7434,6 +8616,37 @@ LibMCDataResult libmcdata_buildjobhandler_listjobexecutionschangedsince(LibMCDat
 	}
 }
 
+LibMCDataResult libmcdata_buildjobhandler_retrievedatacapture(LibMCData_BuildJobHandler pBuildJobHandler, const char * pDataCaptureUUID, LibMCData_DataCapture * pDataCaptureInstance)
+{
+	IBase* pIBaseClass = (IBase *)pBuildJobHandler;
+
+	try {
+		if (pDataCaptureUUID == nullptr)
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		if (pDataCaptureInstance == nullptr)
+			throw ELibMCDataInterfaceException (LIBMCDATA_ERROR_INVALIDPARAM);
+		std::string sDataCaptureUUID(pDataCaptureUUID);
+		IBase* pBaseDataCaptureInstance(nullptr);
+		IBuildJobHandler* pIBuildJobHandler = dynamic_cast<IBuildJobHandler*>(pIBaseClass);
+		if (!pIBuildJobHandler)
+			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDCAST);
+		
+		pBaseDataCaptureInstance = pIBuildJobHandler->RetrieveDataCapture(sDataCaptureUUID);
+
+		*pDataCaptureInstance = (IBase*)(pBaseDataCaptureInstance);
+		return LIBMCDATA_SUCCESS;
+	}
+	catch (ELibMCDataInterfaceException & Exception) {
+		return handleLibMCDataException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
 
 /*************************************************************************************************************************
  Class implementation for UserList
@@ -11959,6 +13172,8 @@ LibMCDataResult LibMCData::Impl::LibMCData_GetProcAddress (const char * pProcNam
 		*ppProcAddress = (void*) &libmcdata_storagezipwriter_finish;
 	if (sProcName == "libmcdata_storagezipwriter_isfinished") 
 		*ppProcAddress = (void*) &libmcdata_storagezipwriter_isfinished;
+	if (sProcName == "libmcdata_storagezipwriter_discard") 
+		*ppProcAddress = (void*) &libmcdata_storagezipwriter_discard;
 	if (sProcName == "libmcdata_storage_streamisready") 
 		*ppProcAddress = (void*) &libmcdata_storage_streamisready;
 	if (sProcName == "libmcdata_storage_retrievestream") 
@@ -11993,8 +13208,28 @@ LibMCDataResult LibMCData::Impl::LibMCData_GetProcAddress (const char * pProcNam
 		*ppProcAddress = (void*) &libmcdata_storage_createdownloadticket;
 	if (sProcName == "libmcdata_storage_requestdownloadticket") 
 		*ppProcAddress = (void*) &libmcdata_storage_requestdownloadticket;
+	if (sProcName == "libmcdata_storage_getdownloadticketdetails") 
+		*ppProcAddress = (void*) &libmcdata_storage_getdownloadticketdetails;
+	if (sProcName == "libmcdata_storage_revokedownloadticketsofstream") 
+		*ppProcAddress = (void*) &libmcdata_storage_revokedownloadticketsofstream;
+	if (sProcName == "libmcdata_storage_logdownloadstart") 
+		*ppProcAddress = (void*) &libmcdata_storage_logdownloadstart;
+	if (sProcName == "libmcdata_storage_logdownloadfinish") 
+		*ppProcAddress = (void*) &libmcdata_storage_logdownloadfinish;
+	if (sProcName == "libmcdata_storage_deletestream") 
+		*ppProcAddress = (void*) &libmcdata_storage_deletestream;
+	if (sProcName == "libmcdata_storage_discardunfinishedzipstreams") 
+		*ppProcAddress = (void*) &libmcdata_storage_discardunfinishedzipstreams;
+	if (sProcName == "libmcdata_storage_liststreamuuidsbyname") 
+		*ppProcAddress = (void*) &libmcdata_storage_liststreamuuidsbyname;
 	if (sProcName == "libmcdata_storage_attachstreamtojournal") 
 		*ppProcAddress = (void*) &libmcdata_storage_attachstreamtojournal;
+	if (sProcName == "libmcdata_storage_discardrandomwritestream") 
+		*ppProcAddress = (void*) &libmcdata_storage_discardrandomwritestream;
+	if (sProcName == "libmcdata_storage_getdatacapturestoragesize") 
+		*ppProcAddress = (void*) &libmcdata_storage_getdatacapturestoragesize;
+	if (sProcName == "libmcdata_storage_enforcedatacapturestoragelimit") 
+		*ppProcAddress = (void*) &libmcdata_storage_enforcedatacapturestoragelimit;
 	if (sProcName == "libmcdata_customdatastream_getdatauuid") 
 		*ppProcAddress = (void*) &libmcdata_customdatastream_getdatauuid;
 	if (sProcName == "libmcdata_customdatastream_getidentifier") 
@@ -12027,6 +13262,40 @@ LibMCDataResult LibMCData::Impl::LibMCData_GetProcAddress (const char * pProcNam
 		*ppProcAddress = (void*) &libmcdata_buildjobexecutiondata_getexecutionuuid;
 	if (sProcName == "libmcdata_buildjobexecutiondataiterator_getcurrentjobexecutiondata") 
 		*ppProcAddress = (void*) &libmcdata_buildjobexecutiondataiterator_getcurrentjobexecutiondata;
+	if (sProcName == "libmcdata_datacapture_getuuid") 
+		*ppProcAddress = (void*) &libmcdata_datacapture_getuuid;
+	if (sProcName == "libmcdata_datacapture_getexecutionuuid") 
+		*ppProcAddress = (void*) &libmcdata_datacapture_getexecutionuuid;
+	if (sProcName == "libmcdata_datacapture_getidentifier") 
+		*ppProcAddress = (void*) &libmcdata_datacapture_getidentifier;
+	if (sProcName == "libmcdata_datacapture_getname") 
+		*ppProcAddress = (void*) &libmcdata_datacapture_getname;
+	if (sProcName == "libmcdata_datacapture_getstatus") 
+		*ppProcAddress = (void*) &libmcdata_datacapture_getstatus;
+	if (sProcName == "libmcdata_datacapture_gettimestamp") 
+		*ppProcAddress = (void*) &libmcdata_datacapture_gettimestamp;
+	if (sProcName == "libmcdata_datacapture_addcolumn") 
+		*ppProcAddress = (void*) &libmcdata_datacapture_addcolumn;
+	if (sProcName == "libmcdata_datacapture_getcolumncount") 
+		*ppProcAddress = (void*) &libmcdata_datacapture_getcolumncount;
+	if (sProcName == "libmcdata_datacapture_getcolumninformation") 
+		*ppProcAddress = (void*) &libmcdata_datacapture_getcolumninformation;
+	if (sProcName == "libmcdata_datacapture_addsegment") 
+		*ppProcAddress = (void*) &libmcdata_datacapture_addsegment;
+	if (sProcName == "libmcdata_datacapture_getsegmentcount") 
+		*ppProcAddress = (void*) &libmcdata_datacapture_getsegmentcount;
+	if (sProcName == "libmcdata_datacapture_getsegmentinformation") 
+		*ppProcAddress = (void*) &libmcdata_datacapture_getsegmentinformation;
+	if (sProcName == "libmcdata_datacapture_getsegmentchunkcount") 
+		*ppProcAddress = (void*) &libmcdata_datacapture_getsegmentchunkcount;
+	if (sProcName == "libmcdata_datacapture_getrowcount") 
+		*ppProcAddress = (void*) &libmcdata_datacapture_getrowcount;
+	if (sProcName == "libmcdata_datacapture_getstoredsizeinbytes") 
+		*ppProcAddress = (void*) &libmcdata_datacapture_getstoredsizeinbytes;
+	if (sProcName == "libmcdata_datacapture_finish") 
+		*ppProcAddress = (void*) &libmcdata_datacapture_finish;
+	if (sProcName == "libmcdata_datacapture_abort") 
+		*ppProcAddress = (void*) &libmcdata_datacapture_abort;
 	if (sProcName == "libmcdata_buildjobexecution_getexecutionuuid") 
 		*ppProcAddress = (void*) &libmcdata_buildjobexecution_getexecutionuuid;
 	if (sProcName == "libmcdata_buildjobexecution_getjobuuid") 
@@ -12079,6 +13348,16 @@ LibMCDataResult LibMCData::Impl::LibMCData_GetProcAddress (const char * pProcNam
 		*ppProcAddress = (void*) &libmcdata_buildjobexecution_hasmetadatastring;
 	if (sProcName == "libmcdata_buildjobexecution_getmetadatastring") 
 		*ppProcAddress = (void*) &libmcdata_buildjobexecution_getmetadatastring;
+	if (sProcName == "libmcdata_buildjobexecution_createdatacapture") 
+		*ppProcAddress = (void*) &libmcdata_buildjobexecution_createdatacapture;
+	if (sProcName == "libmcdata_buildjobexecution_hasdatacapture") 
+		*ppProcAddress = (void*) &libmcdata_buildjobexecution_hasdatacapture;
+	if (sProcName == "libmcdata_buildjobexecution_retrievedatacapture") 
+		*ppProcAddress = (void*) &libmcdata_buildjobexecution_retrievedatacapture;
+	if (sProcName == "libmcdata_buildjobexecution_getdatacapturecount") 
+		*ppProcAddress = (void*) &libmcdata_buildjobexecution_getdatacapturecount;
+	if (sProcName == "libmcdata_buildjobexecution_retrievedatacapturebyindex") 
+		*ppProcAddress = (void*) &libmcdata_buildjobexecution_retrievedatacapturebyindex;
 	if (sProcName == "libmcdata_buildjobexecutioniterator_getcurrentjobexecution") 
 		*ppProcAddress = (void*) &libmcdata_buildjobexecutioniterator_getcurrentjobexecution;
 	if (sProcName == "libmcdata_buildjob_getuuid") 
@@ -12183,6 +13462,8 @@ LibMCDataResult LibMCData::Impl::LibMCData_GetProcAddress (const char * pProcNam
 		*ppProcAddress = (void*) &libmcdata_buildjobhandler_listjobschangedsince;
 	if (sProcName == "libmcdata_buildjobhandler_listjobexecutionschangedsince") 
 		*ppProcAddress = (void*) &libmcdata_buildjobhandler_listjobexecutionschangedsince;
+	if (sProcName == "libmcdata_buildjobhandler_retrievedatacapture") 
+		*ppProcAddress = (void*) &libmcdata_buildjobhandler_retrievedatacapture;
 	if (sProcName == "libmcdata_userlist_count") 
 		*ppProcAddress = (void*) &libmcdata_userlist_count;
 	if (sProcName == "libmcdata_userlist_getuserproperties") 
diff --git a/Framework/InterfacesCore/libmcdata_types.hpp b/Framework/InterfacesCore/libmcdata_types.hpp
index a2d8e0c67..e08caec01 100644
--- a/Framework/InterfacesCore/libmcdata_types.hpp
+++ b/Framework/InterfacesCore/libmcdata_types.hpp
@@ -478,6 +478,21 @@ typedef void * LibMCData_pvoid;
 #define LIBMCDATA_ERROR_JOBNAMETOOLONG 451 /** Job name exceeds maximum allowed length */
 #define LIBMCDATA_ERROR_STRINGPARAMETERTOOLONG 452 /** String parameter exceeds maximum allowed length */
 #define LIBMCDATA_ERROR_TELEMETRYSETTINGAFTERINITIALISATION 453 /** Telemetry setting changed after database initialisation */
+#define LIBMCDATA_ERROR_DATACAPTURENOTFOUND 454 /** Data capture not found. */
+#define LIBMCDATA_ERROR_DUPLICATEDATACAPTUREIDENTIFIER 455 /** Duplicate data capture identifier. */
+#define LIBMCDATA_ERROR_INVALIDDATACAPTUREIDENTIFIER 456 /** Invalid data capture identifier. */
+#define LIBMCDATA_ERROR_INVALIDDATACAPTURENAME 457 /** Invalid data capture name. */
+#define LIBMCDATA_ERROR_DATACAPTURENOTRECORDING 458 /** Data capture is not recording. */
+#define LIBMCDATA_ERROR_INVALIDDATACAPTURESTATUS 459 /** Invalid data capture status. */
+#define LIBMCDATA_ERROR_INVALIDDATACAPTURECOLUMNINDEX 460 /** Invalid data capture column index. */
+#define LIBMCDATA_ERROR_INVALIDDATACAPTURESEGMENTINDEX 461 /** Invalid data capture segment index. */
+#define LIBMCDATA_ERROR_DUPLICATEDATACAPTURESEGMENT 462 /** Duplicate data capture segment. */
+#define LIBMCDATA_ERROR_DUPLICATEDATACAPTURECOLUMN 463 /** Duplicate data capture column. */
+#define LIBMCDATA_ERROR_DATACAPTUREALREADYABORTED 464 /** Data capture has already been aborted. */
+#define LIBMCDATA_ERROR_RANDOMWRITESTREAMNOTFOUND 465 /** Random write stream not found. */
+#define LIBMCDATA_ERROR_DOWNLOADENTRYNOTFOUND 466 /** Download access log entry not found. */
+#define LIBMCDATA_ERROR_STREAMHASACTIVEWRITER 467 /** Storage stream is still being written. */
+#define LIBMCDATA_ERROR_ZIPSTREAMALREADYFINISHED 468 /** ZIP stream has already been finished and can not be discarded. */
 
 /*************************************************************************************************************************
  Error strings for LibMCData
@@ -868,6 +883,21 @@ inline const char * LIBMCDATA_GETERRORSTRING (LibMCDataResult nErrorCode) {
     case LIBMCDATA_ERROR_JOBNAMETOOLONG: return "Job name exceeds maximum allowed length";
     case LIBMCDATA_ERROR_STRINGPARAMETERTOOLONG: return "String parameter exceeds maximum allowed length";
     case LIBMCDATA_ERROR_TELEMETRYSETTINGAFTERINITIALISATION: return "Telemetry setting changed after database initialisation";
+    case LIBMCDATA_ERROR_DATACAPTURENOTFOUND: return "Data capture not found.";
+    case LIBMCDATA_ERROR_DUPLICATEDATACAPTUREIDENTIFIER: return "Duplicate data capture identifier.";
+    case LIBMCDATA_ERROR_INVALIDDATACAPTUREIDENTIFIER: return "Invalid data capture identifier.";
+    case LIBMCDATA_ERROR_INVALIDDATACAPTURENAME: return "Invalid data capture name.";
+    case LIBMCDATA_ERROR_DATACAPTURENOTRECORDING: return "Data capture is not recording.";
+    case LIBMCDATA_ERROR_INVALIDDATACAPTURESTATUS: return "Invalid data capture status.";
+    case LIBMCDATA_ERROR_INVALIDDATACAPTURECOLUMNINDEX: return "Invalid data capture column index.";
+    case LIBMCDATA_ERROR_INVALIDDATACAPTURESEGMENTINDEX: return "Invalid data capture segment index.";
+    case LIBMCDATA_ERROR_DUPLICATEDATACAPTURESEGMENT: return "Duplicate data capture segment.";
+    case LIBMCDATA_ERROR_DUPLICATEDATACAPTURECOLUMN: return "Duplicate data capture column.";
+    case LIBMCDATA_ERROR_DATACAPTUREALREADYABORTED: return "Data capture has already been aborted.";
+    case LIBMCDATA_ERROR_RANDOMWRITESTREAMNOTFOUND: return "Random write stream not found.";
+    case LIBMCDATA_ERROR_DOWNLOADENTRYNOTFOUND: return "Download access log entry not found.";
+    case LIBMCDATA_ERROR_STREAMHASACTIVEWRITER: return "Storage stream is still being written.";
+    case LIBMCDATA_ERROR_ZIPSTREAMALREADYFINISHED: return "ZIP stream has already been finished and can not be discarded.";
     default: return "unknown error";
   }
 }
@@ -897,6 +927,7 @@ typedef LibMCDataHandle LibMCData_BuildJobData;
 typedef LibMCDataHandle LibMCData_BuildJobDataIterator;
 typedef LibMCDataHandle LibMCData_BuildJobExecutionData;
 typedef LibMCDataHandle LibMCData_BuildJobExecutionDataIterator;
+typedef LibMCDataHandle LibMCData_DataCapture;
 typedef LibMCDataHandle LibMCData_BuildJobExecution;
 typedef LibMCDataHandle LibMCData_BuildJobExecutionIterator;
 typedef LibMCDataHandle LibMCData_BuildJob;
@@ -990,6 +1021,13 @@ namespace LibMCData {
     IntervalEndMarker = 3
   };
   
+  enum class eDataCaptureStatus : LibMCData_int32 {
+    Unknown = 0,
+    Recording = 1,
+    Finished = 2,
+    Aborted = 3
+  };
+  
   enum class eBuildJobExecutionStatus : LibMCData_int32 {
     Unknown = 0,
     InProcess = 1,
@@ -1074,6 +1112,7 @@ typedef LibMCData::eBuildJobStatus eLibMCDataBuildJobStatus;
 typedef LibMCData::eCustomDataType eLibMCDataCustomDataType;
 typedef LibMCData::eTelemetryChannelType eLibMCDataTelemetryChannelType;
 typedef LibMCData::eTelemetryChunkEntryType eLibMCDataTelemetryChunkEntryType;
+typedef LibMCData::eDataCaptureStatus eLibMCDataDataCaptureStatus;
 typedef LibMCData::eBuildJobExecutionStatus eLibMCDataBuildJobExecutionStatus;
 typedef LibMCData::sJournalChunkVariableInfo sLibMCDataJournalChunkVariableInfo;
 typedef LibMCData::sTelemetryChunkEntry sLibMCDataTelemetryChunkEntry;
diff --git a/Framework/InterfacesCore/libmcenv_abi.hpp b/Framework/InterfacesCore/libmcenv_abi.hpp
index 38f37c0d4..ad852f291 100644
--- a/Framework/InterfacesCore/libmcenv_abi.hpp
+++ b/Framework/InterfacesCore/libmcenv_abi.hpp
@@ -1400,242 +1400,1004 @@ LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_hascolumn(LibMCEnv_DataTable
 */
 LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_getrowcount(LibMCEnv_DataTable pDataTable, LibMCEnv_uint32 * pRowCount);
 
+/**
+* Returns the current row count as 64 bit value. GetRowCount is kept for ABI compatibility and truncates large row counts.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[out] pRowCount - Number of rows.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_getrowcount64(LibMCEnv_DataTable pDataTable, LibMCEnv_uint64 * pRowCount);
+
 /**
 * Returns the current column count.
 *
-* @param[in] pDataTable - DataTable instance.
-* @param[out] pColumnCount - Number of columns.
+* @param[in] pDataTable - DataTable instance.
+* @param[out] pColumnCount - Number of columns.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_getcolumncount(LibMCEnv_DataTable pDataTable, LibMCEnv_uint32 * pColumnCount);
+
+/**
+* Returns the identifier of a column. Will fail if Index is out of bounds.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] nColumnIndex - Index of column. 0-based.
+* @param[in] nIdentifierBufferSize - size of the buffer (including trailing 0)
+* @param[out] pIdentifierNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pIdentifierBuffer -  buffer of Identifier of the column., may be NULL
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_getcolumnidentifier(LibMCEnv_DataTable pDataTable, LibMCEnv_uint32 nColumnIndex, const LibMCEnv_uint32 nIdentifierBufferSize, LibMCEnv_uint32* pIdentifierNeededChars, char * pIdentifierBuffer);
+
+/**
+* Returns the description of a column. Will fail if Index is out of bounds.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] nColumnIndex - Index of column. 0-based.
+* @param[in] nDescriptionBufferSize - size of the buffer (including trailing 0)
+* @param[out] pDescriptionNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pDescriptionBuffer -  buffer of Description of the column., may be NULL
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_getcolumndescription(LibMCEnv_DataTable pDataTable, LibMCEnv_uint32 nColumnIndex, const LibMCEnv_uint32 nDescriptionBufferSize, LibMCEnv_uint32* pDescriptionNeededChars, char * pDescriptionBuffer);
+
+/**
+* Returns the type of a column. Will fail if Index is out of bounds.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] nColumnIndex - Index of column. 0-based.
+* @param[out] pColumnType - Data type of the column.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_getcolumntype(LibMCEnv_DataTable pDataTable, LibMCEnv_uint32 nColumnIndex, LibMCEnv::eDataTableColumnType * pColumnType);
+
+/**
+* Returns the values of a double column. Will fail if column does not exist or type is not double.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nDescriptionBufferSize - size of the buffer (including trailing 0)
+* @param[out] pDescriptionNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pDescriptionBuffer -  buffer of Description of the column., may be NULL
+* @param[out] pColumnType - Data type of the column.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_getcolumninformation(LibMCEnv_DataTable pDataTable, const char * pIdentifier, const LibMCEnv_uint32 nDescriptionBufferSize, LibMCEnv_uint32* pDescriptionNeededChars, char * pDescriptionBuffer, LibMCEnv::eDataTableColumnType * pColumnType);
+
+/**
+* Returns the values of a double column. Will fail if column does not exist or type is not double.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[out] pValuesNeededCount - will be filled with the count of the written elements, or needed buffer size.
+* @param[out] pValuesBuffer - double  buffer of Value array of a column.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_getdoublecolumnvalues(LibMCEnv_DataTable pDataTable, const char * pIdentifier, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_double * pValuesBuffer);
+
+/**
+* Returns the double columns. Will fail if column does not exist or type is not int32.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[out] pValuesNeededCount - will be filled with the count of the written elements, or needed buffer size.
+* @param[out] pValuesBuffer - int32  buffer of Value array of a column.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_getint32columnvalues(LibMCEnv_DataTable pDataTable, const char * pIdentifier, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_int32 * pValuesBuffer);
+
+/**
+* Returns the double columns. Will fail if column does not exist or type is not int64.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[out] pValuesNeededCount - will be filled with the count of the written elements, or needed buffer size.
+* @param[out] pValuesBuffer - int64  buffer of Value array of a column.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_getint64columnvalues(LibMCEnv_DataTable pDataTable, const char * pIdentifier, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_int64 * pValuesBuffer);
+
+/**
+* Returns the double columns. Will fail if column does not exist or type is not uint32.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[out] pValuesNeededCount - will be filled with the count of the written elements, or needed buffer size.
+* @param[out] pValuesBuffer - uint32  buffer of Value array of a column.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_getuint32columnvalues(LibMCEnv_DataTable pDataTable, const char * pIdentifier, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_uint32 * pValuesBuffer);
+
+/**
+* Returns the double columns. Will fail if column does not exist or type is not uint64.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[out] pValuesNeededCount - will be filled with the count of the written elements, or needed buffer size.
+* @param[out] pValuesBuffer - uint64  buffer of Value array of a column.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_getuint64columnvalues(LibMCEnv_DataTable pDataTable, const char * pIdentifier, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_uint64 * pValuesBuffer);
+
+/**
+* Returns the values of a float (32 bit) column. Will fail if column does not exist or type is not float.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[out] pValuesNeededCount - will be filled with the count of the written elements, or needed buffer size.
+* @param[out] pValuesBuffer - single  buffer of Value array of a column.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_getfloatcolumnvalues(LibMCEnv_DataTable pDataTable, const char * pIdentifier, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_single * pValuesBuffer);
+
+/**
+* Returns the values of a bool column as bytes (0 = false, 1 = true). Will fail if column does not exist or type is not bool.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[out] pValuesNeededCount - will be filled with the count of the written elements, or needed buffer size.
+* @param[out] pValuesBuffer - uint8  buffer of Value array of a column. Each entry is 0 or 1.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_getboolcolumnvalues(LibMCEnv_DataTable pDataTable, const char * pIdentifier, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_uint8 * pValuesBuffer);
+
+/**
+* Returns the values of a timestamp column in microseconds. Will fail if column does not exist or type is not timestamp.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[out] pValuesNeededCount - will be filled with the count of the written elements, or needed buffer size.
+* @param[out] pValuesBuffer - uint64  buffer of Value array of a column. Timestamps in microseconds.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_gettimestampcolumnvalues(LibMCEnv_DataTable pDataTable, const char * pIdentifier, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_uint64 * pValuesBuffer);
+
+/**
+* Sets the values of a double column. Will fail if column does not exist or type is not double.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[in] pValuesBuffer - double buffer of New Value array of a column. Array length should match RowCount. Values will be filled up with 0, if length is less than RowCount. RowCount will be extended if length is larger than RowCount.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_setdoublecolumnvalues(LibMCEnv_DataTable pDataTable, const char * pIdentifier, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_double * pValuesBuffer);
+
+/**
+* Sets the double columns. Will fail if column does not exist or type is not int32.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[in] pValuesBuffer - int32 buffer of New Value array of a column. Array length should match RowCount. Values will be filled up with 0, if length is less than RowCount. RowCount will be extended if length is larger than RowCount.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_setint32columnvalues(LibMCEnv_DataTable pDataTable, const char * pIdentifier, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_int32 * pValuesBuffer);
+
+/**
+* Sets the double columns. Will fail if column does not exist or type is not int64.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[in] pValuesBuffer - int64 buffer of New Value array of a column. Array length should match RowCount. Values will be filled up with 0, if length is less than RowCount. RowCount will be extended if length is larger than RowCount.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_setint64columnvalues(LibMCEnv_DataTable pDataTable, const char * pIdentifier, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_int64 * pValuesBuffer);
+
+/**
+* Sets the double columns. Will fail if column does not exist or type is not uint32.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[in] pValuesBuffer - uint32 buffer of New Value array of a column. Array length should match RowCount. Values will be filled up with 0, if length is less than RowCount. RowCount will be extended if length is larger than RowCount.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_setuint32columnvalues(LibMCEnv_DataTable pDataTable, const char * pIdentifier, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint32 * pValuesBuffer);
+
+/**
+* Sets the double columns. Will fail if column does not exist or type is not uint64.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[in] pValuesBuffer - uint64 buffer of New Value array of a column. Array length should match RowCount. Values will be filled up with 0, if length is less than RowCount. RowCount will be extended if length is larger than RowCount.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_setuint64columnvalues(LibMCEnv_DataTable pDataTable, const char * pIdentifier, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint64 * pValuesBuffer);
+
+/**
+* Sets the values of a float (32 bit) column. Will fail if column does not exist or type is not float.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[in] pValuesBuffer - single buffer of New Value array of a column. Array length should match RowCount. Values will be filled up with 0, if length is less than RowCount. RowCount will be extended if length is larger than RowCount.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_setfloatcolumnvalues(LibMCEnv_DataTable pDataTable, const char * pIdentifier, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_single * pValuesBuffer);
+
+/**
+* Sets the values of a bool column from bytes (0 = false, nonzero = true). Will fail if column does not exist or type is not bool.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[in] pValuesBuffer - uint8 buffer of New Value array of a column. Array length should match RowCount. Values will be filled up with 0, if length is less than RowCount. RowCount will be extended if length is larger than RowCount.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_setboolcolumnvalues(LibMCEnv_DataTable pDataTable, const char * pIdentifier, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint8 * pValuesBuffer);
+
+/**
+* Sets the values of a timestamp column in microseconds. Will fail if column does not exist or type is not timestamp.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[in] pValuesBuffer - uint64 buffer of New Value array of a column. Array length should match RowCount. Values will be filled up with 0, if length is less than RowCount. RowCount will be extended if length is larger than RowCount.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_settimestampcolumnvalues(LibMCEnv_DataTable pDataTable, const char * pIdentifier, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint64 * pValuesBuffer);
+
+/**
+* Creates a Write Option.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[out] pOptions - Writer Options Instance to pass on to WriteDataToStream.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_createwriteoptions(LibMCEnv_DataTable pDataTable, LibMCEnv_DataTableWriteOptions * pOptions);
+
+/**
+* Creates a CSV Write Option.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[out] pOptions - Writer Options Instance to pass on to WriteCSVToStream.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_createcsvwriteoptions(LibMCEnv_DataTable pDataTable, LibMCEnv_DataTableCSVWriteOptions * pOptions);
+
+/**
+* Writes the data as CSV to a temporary stream.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pWriter - Stream writer to use.
+* @param[in] pOptions - Optional CSV writer options to use.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_writecsvtostream(LibMCEnv_DataTable pDataTable, LibMCEnv_TempStreamWriter pWriter, LibMCEnv_DataTableCSVWriteOptions pOptions);
+
+/**
+* Writes the data as binary to a temporary stream.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pWriter - Stream writer instance to use.
+* @param[in] pOptions - Optional writer options to use.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_writedatatostream(LibMCEnv_DataTable pDataTable, LibMCEnv_TempStreamWriter pWriter, LibMCEnv_DataTableWriteOptions pOptions);
+
+/**
+* Loads the data table from a stream. Clears all existing data from the data table.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pStream - Stream read instance to read from.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_loadfromstream(LibMCEnv_DataTable pDataTable, LibMCEnv_StreamReader pStream);
+
+/**
+* Creates an options object for scatter plot computation.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[out] pScatterPlotOptions - DataTableScatterPlotOptions Instance
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_createscatterplotoptions(LibMCEnv_DataTable pDataTable, LibMCEnv_DataTableScatterPlotOptions * pScatterPlotOptions);
+
+/**
+* Creates a scatterplot from the data table according to its input parameters.
+*
+* @param[in] pDataTable - DataTable instance.
+* @param[in] pScatterPlotOptions - ScatterPlot Options to use
+* @param[out] pScatterPlot - ScatterPlot Instance
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_calculatescatterplot(LibMCEnv_DataTable pDataTable, LibMCEnv_DataTableScatterPlotOptions pScatterPlotOptions, LibMCEnv_ScatterPlot * pScatterPlot);
+
+/*************************************************************************************************************************
+ Class definition for DataCaptureOptions
+**************************************************************************************************************************/
+
+/**
+* Sets the number of rows a chunk can hold. Default is 65536.
+*
+* @param[in] pDataCaptureOptions - DataCaptureOptions instance.
+* @param[in] nChunkRowCount - Rows per chunk. MUST be between 1 and 16777216.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacaptureoptions_setchunkrowcount(LibMCEnv_DataCaptureOptions pDataCaptureOptions, LibMCEnv_uint32 nChunkRowCount);
+
+/**
+* Returns the number of rows a chunk can hold.
+*
+* @param[in] pDataCaptureOptions - DataCaptureOptions instance.
+* @param[out] pChunkRowCount - Rows per chunk.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacaptureoptions_getchunkrowcount(LibMCEnv_DataCaptureOptions pDataCaptureOptions, LibMCEnv_uint32 * pChunkRowCount);
+
+/**
+* Sets the size at which the capture rolls over into a new segment stream. Default is 1 GB.
+*
+* @param[in] pDataCaptureOptions - DataCaptureOptions instance.
+* @param[in] nSegmentSizeInBytes - Maximum segment size in bytes. 0 means the capture never rolls over. A segment always holds at least one chunk.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacaptureoptions_setsegmentsizeinbytes(LibMCEnv_DataCaptureOptions pDataCaptureOptions, LibMCEnv_uint64 nSegmentSizeInBytes);
+
+/**
+* Returns the size at which the capture rolls over into a new segment stream.
+*
+* @param[in] pDataCaptureOptions - DataCaptureOptions instance.
+* @param[out] pSegmentSizeInBytes - Maximum segment size in bytes. 0 means the capture never rolls over.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacaptureoptions_getsegmentsizeinbytes(LibMCEnv_DataCaptureOptions pDataCaptureOptions, LibMCEnv_uint64 * pSegmentSizeInBytes);
+
+/**
+* Sets the maximum number of committed chunks that may wait for the writer thread. Default is 16.
+*
+* @param[in] pDataCaptureOptions - DataCaptureOptions instance.
+* @param[in] nMaxQueuedChunks - Queue depth. MUST be between 1 and 1024.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacaptureoptions_setmaxqueuedchunks(LibMCEnv_DataCaptureOptions pDataCaptureOptions, LibMCEnv_uint32 nMaxQueuedChunks);
+
+/**
+* Returns the maximum number of committed chunks that may wait for the writer thread.
+*
+* @param[in] pDataCaptureOptions - DataCaptureOptions instance.
+* @param[out] pMaxQueuedChunks - Queue depth.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacaptureoptions_getmaxqueuedchunks(LibMCEnv_DataCaptureOptions pDataCaptureOptions, LibMCEnv_uint32 * pMaxQueuedChunks);
+
+/**
+* Sets what happens when the producer is faster than the disk. Default is Block.
+*
+* @param[in] pDataCaptureOptions - DataCaptureOptions instance.
+* @param[in] eBackpressureMode - Block waits for the writer, DropOldest discards the oldest queued chunk, Fail raises an error.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacaptureoptions_setbackpressuremode(LibMCEnv_DataCaptureOptions pDataCaptureOptions, LibMCEnv::eDataCaptureBackpressureMode eBackpressureMode);
+
+/**
+* Returns what happens when the producer is faster than the disk.
+*
+* @param[in] pDataCaptureOptions - DataCaptureOptions instance.
+* @param[out] pBackpressureMode - Backpressure mode.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacaptureoptions_getbackpressuremode(LibMCEnv_DataCaptureOptions pDataCaptureOptions, LibMCEnv::eDataCaptureBackpressureMode * pBackpressureMode);
+
+/**
+* Sets the retention limit for all data capture segments stored on this machine. When it is exceeded after a segment has been finalized, the oldest stored segments are deleted first. Default is 0.
+*
+* @param[in] pDataCaptureOptions - DataCaptureOptions instance.
+* @param[in] nStorageLimitInBytes - Total size limit in bytes. 0 disables retention.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacaptureoptions_setstoragelimitinbytes(LibMCEnv_DataCaptureOptions pDataCaptureOptions, LibMCEnv_uint64 nStorageLimitInBytes);
+
+/**
+* Returns the retention limit for all data capture segments stored on this machine.
+*
+* @param[in] pDataCaptureOptions - DataCaptureOptions instance.
+* @param[out] pStorageLimitInBytes - Total size limit in bytes. 0 means retention is disabled.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacaptureoptions_getstoragelimitinbytes(LibMCEnv_DataCaptureOptions pDataCaptureOptions, LibMCEnv_uint64 * pStorageLimitInBytes);
+
+/**
+* Sets the codec the pages of the capture are compressed with. Default is LZ4. A page is stored uncompressed if the codec does not make it smaller.
+*
+* @param[in] pDataCaptureOptions - DataCaptureOptions instance.
+* @param[in] eCompression - None, LZ4 or Deflate. Deflate is meant for cold data, it costs considerably more processing time than LZ4.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacaptureoptions_setcompression(LibMCEnv_DataCaptureOptions pDataCaptureOptions, LibMCEnv::eDataCaptureCompression eCompression);
+
+/**
+* Returns the codec the pages of the capture are compressed with.
+*
+* @param[in] pDataCaptureOptions - DataCaptureOptions instance.
+* @param[out] pCompression - Compression codec.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacaptureoptions_getcompression(LibMCEnv_DataCaptureOptions pDataCaptureOptions, LibMCEnv::eDataCaptureCompression * pCompression);
+
+/**
+* Sets the encoding of a column. Default is Automatic, which uses Delta for integer and timestamp columns, BitPack for bool columns and Plain for float and double columns. The column MUST exist when the capture starts recording and the encoding MUST fit its type.
+*
+* @param[in] pDataCaptureOptions - DataCaptureOptions instance.
+* @param[in] pColumnIdentifier - Identifier of the column.
+* @param[in] eEncoding - Automatic, Plain, Delta or BitPack.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacaptureoptions_setcolumnencoding(LibMCEnv_DataCaptureOptions pDataCaptureOptions, const char * pColumnIdentifier, LibMCEnv::eDataCaptureEncoding eEncoding);
+
+/**
+* Opts a double column into lossy storage: values are stored as integer multiples of the step with Delta encoding. Columns that are not quantised stay bit-exact. The step is recorded in the capture and the column MUST be a double column.
+*
+* @param[in] pDataCaptureOptions - DataCaptureOptions instance.
+* @param[in] pColumnIdentifier - Identifier of the column.
+* @param[in] dStep - Quantisation step. MUST be positive. 0 removes the quantisation.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacaptureoptions_setdoublequantization(LibMCEnv_DataCaptureOptions pDataCaptureOptions, const char * pColumnIdentifier, LibMCEnv_double dStep);
+
+/*************************************************************************************************************************
+ Class definition for DataCaptureChunk
+**************************************************************************************************************************/
+
+/**
+* Returns the number of rows the chunk can hold.
+*
+* @param[in] pDataCaptureChunk - DataCaptureChunk instance.
+* @param[out] pCapacity - Number of rows.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacapturechunk_getcapacity(LibMCEnv_DataCaptureChunk pDataCaptureChunk, LibMCEnv_uint32 * pCapacity);
+
+/**
+* Returns the number of rows in the chunk. This is the row count of the longest column.
+*
+* @param[in] pDataCaptureChunk - DataCaptureChunk instance.
+* @param[out] pRowCount - Number of rows.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacapturechunk_getrowcount(LibMCEnv_DataCaptureChunk pDataCaptureChunk, LibMCEnv_uint32 * pRowCount);
+
+/**
+* Returns if the chunk has reached its capacity.
+*
+* @param[in] pDataCaptureChunk - DataCaptureChunk instance.
+* @param[out] pFull - Returns true if no more rows fit into the chunk.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacapturechunk_isfull(LibMCEnv_DataCaptureChunk pDataCaptureChunk, bool * pFull);
+
+/**
+* Sets all rows of a double column in this chunk. Fails if the column type does not match or the capacity is exceeded.
+*
+* @param[in] pDataCaptureChunk - DataCaptureChunk instance.
+* @param[in] nColumnIndex - Index of the column. 0-based.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[in] pValuesBuffer - double buffer of Values of the column. All columns of a chunk MUST have the same length on commit.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacapturechunk_setdoublecolumnvalues(LibMCEnv_DataCaptureChunk pDataCaptureChunk, LibMCEnv_uint32 nColumnIndex, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_double * pValuesBuffer);
+
+/**
+* Sets all rows of an int32 column in this chunk. Fails if the column type does not match or the capacity is exceeded.
+*
+* @param[in] pDataCaptureChunk - DataCaptureChunk instance.
+* @param[in] nColumnIndex - Index of the column. 0-based.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[in] pValuesBuffer - int32 buffer of Values of the column. All columns of a chunk MUST have the same length on commit.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacapturechunk_setint32columnvalues(LibMCEnv_DataCaptureChunk pDataCaptureChunk, LibMCEnv_uint32 nColumnIndex, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_int32 * pValuesBuffer);
+
+/**
+* Sets all rows of an uint32 column in this chunk. Fails if the column type does not match or the capacity is exceeded.
+*
+* @param[in] pDataCaptureChunk - DataCaptureChunk instance.
+* @param[in] nColumnIndex - Index of the column. 0-based.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[in] pValuesBuffer - uint32 buffer of Values of the column. All columns of a chunk MUST have the same length on commit.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacapturechunk_setuint32columnvalues(LibMCEnv_DataCaptureChunk pDataCaptureChunk, LibMCEnv_uint32 nColumnIndex, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint32 * pValuesBuffer);
+
+/**
+* Sets all rows of an int64 column in this chunk. Fails if the column type does not match or the capacity is exceeded.
+*
+* @param[in] pDataCaptureChunk - DataCaptureChunk instance.
+* @param[in] nColumnIndex - Index of the column. 0-based.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[in] pValuesBuffer - int64 buffer of Values of the column. All columns of a chunk MUST have the same length on commit.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacapturechunk_setint64columnvalues(LibMCEnv_DataCaptureChunk pDataCaptureChunk, LibMCEnv_uint32 nColumnIndex, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_int64 * pValuesBuffer);
+
+/**
+* Sets all rows of an uint64 column in this chunk. Fails if the column type does not match or the capacity is exceeded.
+*
+* @param[in] pDataCaptureChunk - DataCaptureChunk instance.
+* @param[in] nColumnIndex - Index of the column. 0-based.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[in] pValuesBuffer - uint64 buffer of Values of the column. All columns of a chunk MUST have the same length on commit.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacapturechunk_setuint64columnvalues(LibMCEnv_DataCaptureChunk pDataCaptureChunk, LibMCEnv_uint32 nColumnIndex, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint64 * pValuesBuffer);
+
+/**
+* Sets all rows of a float (32 bit) column in this chunk. Fails if the column type does not match or the capacity is exceeded.
+*
+* @param[in] pDataCaptureChunk - DataCaptureChunk instance.
+* @param[in] nColumnIndex - Index of the column. 0-based.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[in] pValuesBuffer - single buffer of Values of the column. All columns of a chunk MUST have the same length on commit.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacapturechunk_setfloatcolumnvalues(LibMCEnv_DataCaptureChunk pDataCaptureChunk, LibMCEnv_uint32 nColumnIndex, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_single * pValuesBuffer);
+
+/**
+* Sets all rows of a bool column in this chunk from bytes (0 = false, nonzero = true). Fails if the column type does not match or the capacity is exceeded.
+*
+* @param[in] pDataCaptureChunk - DataCaptureChunk instance.
+* @param[in] nColumnIndex - Index of the column. 0-based.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[in] pValuesBuffer - uint8 buffer of Values of the column. All columns of a chunk MUST have the same length on commit.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacapturechunk_setboolcolumnvalues(LibMCEnv_DataCaptureChunk pDataCaptureChunk, LibMCEnv_uint32 nColumnIndex, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint8 * pValuesBuffer);
+
+/**
+* Sets all rows of a timestamp column in this chunk in microseconds. Fails if the column type does not match or the capacity is exceeded.
+*
+* @param[in] pDataCaptureChunk - DataCaptureChunk instance.
+* @param[in] nColumnIndex - Index of the column. 0-based.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[in] pValuesBuffer - uint64 buffer of Values of the column. All columns of a chunk MUST have the same length on commit.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacapturechunk_settimestampcolumnvalues(LibMCEnv_DataCaptureChunk pDataCaptureChunk, LibMCEnv_uint32 nColumnIndex, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint64 * pValuesBuffer);
+
+/**
+* Starts a new row at the end of the chunk. This is the convenience path for low-rate producers. Fails if the chunk is full, a row is open or the columns have different row counts.
+*
+* @param[in] pDataCaptureChunk - DataCaptureChunk instance.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacapturechunk_beginrow(LibMCEnv_DataCaptureChunk pDataCaptureChunk);
+
+/**
+* Sets a value of the open row. The column MUST be of type double or float.
+*
+* @param[in] pDataCaptureChunk - DataCaptureChunk instance.
+* @param[in] nColumnIndex - Index of the column. 0-based.
+* @param[in] dValue - Value to set.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacapturechunk_setrowdoublevalue(LibMCEnv_DataCaptureChunk pDataCaptureChunk, LibMCEnv_uint32 nColumnIndex, LibMCEnv_double dValue);
+
+/**
+* Sets a value of the open row. The column MUST be of an integer, bool or timestamp type and the value MUST be in its range.
+*
+* @param[in] pDataCaptureChunk - DataCaptureChunk instance.
+* @param[in] nColumnIndex - Index of the column. 0-based.
+* @param[in] nValue - Value to set.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacapturechunk_setrowintegervalue(LibMCEnv_DataCaptureChunk pDataCaptureChunk, LibMCEnv_uint32 nColumnIndex, LibMCEnv_int64 nValue);
+
+/**
+* Finishes the open row. Columns that have not been set in this row are zero.
+*
+* @param[in] pDataCaptureChunk - DataCaptureChunk instance.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacapturechunk_endrow(LibMCEnv_DataCaptureChunk pDataCaptureChunk);
+
+/*************************************************************************************************************************
+ Class definition for DataCapture
+**************************************************************************************************************************/
+
+/**
+* Returns the UUID of the capture.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[in] nUUIDBufferSize - size of the buffer (including trailing 0)
+* @param[out] pUUIDNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pUUIDBuffer -  buffer of UUID of the capture., may be NULL
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacapture_getuuid(LibMCEnv_DataCapture pDataCapture, const LibMCEnv_uint32 nUUIDBufferSize, LibMCEnv_uint32* pUUIDNeededChars, char * pUUIDBuffer);
+
+/**
+* Returns the identifier of the capture. It is unique within the build execution.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[in] nIdentifierBufferSize - size of the buffer (including trailing 0)
+* @param[out] pIdentifierNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pIdentifierBuffer -  buffer of Identifier of the capture., may be NULL
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacapture_getidentifier(LibMCEnv_DataCapture pDataCapture, const LibMCEnv_uint32 nIdentifierBufferSize, LibMCEnv_uint32* pIdentifierNeededChars, char * pIdentifierBuffer);
+
+/**
+* Returns the human readable name of the capture.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[in] nNameBufferSize - size of the buffer (including trailing 0)
+* @param[out] pNameNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pNameBuffer -  buffer of Name of the capture., may be NULL
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacapture_getname(LibMCEnv_DataCapture pDataCapture, const LibMCEnv_uint32 nNameBufferSize, LibMCEnv_uint32* pNameNeededChars, char * pNameBuffer);
+
+/**
+* Returns the status of the capture.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[out] pStatus - Status of the capture.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacapture_getstatus(LibMCEnv_DataCapture pDataCapture, LibMCEnv::eDataCaptureStatus * pStatus);
+
+/**
+* Adds a column to the capture. The schema is frozen with the first call to BeginChunk.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[in] pIdentifier - Identifier of the column. MUST be unique, alphanumeric and not empty.
+* @param[in] pDescription - Description of the column.
+* @param[in] eColumnType - Data type of the column.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacapture_addcolumn(LibMCEnv_DataCapture pDataCapture, const char * pIdentifier, const char * pDescription, LibMCEnv::eDataTableColumnType eColumnType);
+
+/**
+* Returns the number of columns of the capture.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[out] pColumnCount - Number of columns.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacapture_getcolumncount(LibMCEnv_DataCapture pDataCapture, LibMCEnv_uint32 * pColumnCount);
+
+/**
+* Borrows an empty chunk from the chunk pool. Freezes the schema on the first call. If no chunk is free, the backpressure mode of the capture applies.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[out] pChunkInstance - Chunk to fill.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacapture_beginchunk(LibMCEnv_DataCapture pDataCapture, LibMCEnv_DataCaptureChunk * pChunkInstance);
+
+/**
+* Hands a filled chunk over to the writer thread and returns immediately. All columns MUST have the same row count. The chunk instance MUST NOT be used afterwards.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[in] pChunkInstance - Chunk that has been returned by BeginChunk.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacapture_commitchunk(LibMCEnv_DataCapture pDataCapture, LibMCEnv_DataCaptureChunk pChunkInstance);
+
+/**
+* Blocks until all committed chunks have been written to storage.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacapture_flush(LibMCEnv_DataCapture pDataCapture);
+
+/**
+* Returns the number of rows that have been committed and not dropped.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[out] pRowCount - Number of rows.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacapture_getcapturedrowcount(LibMCEnv_DataCapture pDataCapture, LibMCEnv_uint64 * pRowCount);
+
+/**
+* Returns the number of bytes that have been written to storage so far.
+*
+* @param[in] pDataCapture - DataCapture instance.
+* @param[out] pSizeInBytes - Size in bytes.
 * @return error code or 0 (success)
 */
-LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_getcolumncount(LibMCEnv_DataTable pDataTable, LibMCEnv_uint32 * pColumnCount);
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacapture_getstoragesizeinbytes(LibMCEnv_DataCapture pDataCapture, LibMCEnv_uint64 * pSizeInBytes);
 
 /**
-* Returns the identifier of a column. Will fail if Index is out of bounds.
+* Returns the number of segment streams that have been opened so far.
 *
-* @param[in] pDataTable - DataTable instance.
-* @param[in] nColumnIndex - Index of column. 0-based.
-* @param[in] nIdentifierBufferSize - size of the buffer (including trailing 0)
-* @param[out] pIdentifierNeededChars - will be filled with the count of the written bytes, or needed buffer size.
-* @param[out] pIdentifierBuffer -  buffer of Identifier of the column., may be NULL
+* @param[in] pDataCapture - DataCapture instance.
+* @param[out] pSegmentCount - Number of segments.
 * @return error code or 0 (success)
 */
-LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_getcolumnidentifier(LibMCEnv_DataTable pDataTable, LibMCEnv_uint32 nColumnIndex, const LibMCEnv_uint32 nIdentifierBufferSize, LibMCEnv_uint32* pIdentifierNeededChars, char * pIdentifierBuffer);
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacapture_getsegmentcount(LibMCEnv_DataCapture pDataCapture, LibMCEnv_uint32 * pSegmentCount);
 
 /**
-* Returns the description of a column. Will fail if Index is out of bounds.
+* Returns the number of committed chunks that are waiting for the writer thread.
 *
-* @param[in] pDataTable - DataTable instance.
-* @param[in] nColumnIndex - Index of column. 0-based.
-* @param[in] nDescriptionBufferSize - size of the buffer (including trailing 0)
-* @param[out] pDescriptionNeededChars - will be filled with the count of the written bytes, or needed buffer size.
-* @param[out] pDescriptionBuffer -  buffer of Description of the column., may be NULL
+* @param[in] pDataCapture - DataCapture instance.
+* @param[out] pQueuedChunkCount - Number of queued chunks.
 * @return error code or 0 (success)
 */
-LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_getcolumndescription(LibMCEnv_DataTable pDataTable, LibMCEnv_uint32 nColumnIndex, const LibMCEnv_uint32 nDescriptionBufferSize, LibMCEnv_uint32* pDescriptionNeededChars, char * pDescriptionBuffer);
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacapture_getqueuedchunkcount(LibMCEnv_DataCapture pDataCapture, LibMCEnv_uint32 * pQueuedChunkCount);
 
 /**
-* Returns the type of a column. Will fail if Index is out of bounds.
+* Returns the number of rows that have been discarded by the DropOldest backpressure mode.
 *
-* @param[in] pDataTable - DataTable instance.
-* @param[in] nColumnIndex - Index of column. 0-based.
-* @param[out] pColumnType - Data type of the column.
+* @param[in] pDataCapture - DataCapture instance.
+* @param[out] pDroppedRowCount - Number of dropped rows.
 * @return error code or 0 (success)
 */
-LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_getcolumntype(LibMCEnv_DataTable pDataTable, LibMCEnv_uint32 nColumnIndex, LibMCEnv::eDataTableColumnType * pColumnType);
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacapture_getdroppedrowcount(LibMCEnv_DataCapture pDataCapture, LibMCEnv_uint64 * pDroppedRowCount);
 
 /**
-* Returns the values of a double column. Will fail if column does not exist or type is not double.
+* Writes all committed chunks, closes the last segment and marks the capture as finished. Fails if a chunk is uncommitted.
 *
-* @param[in] pDataTable - DataTable instance.
-* @param[in] pIdentifier - Identifier of the column.
-* @param[in] nDescriptionBufferSize - size of the buffer (including trailing 0)
-* @param[out] pDescriptionNeededChars - will be filled with the count of the written bytes, or needed buffer size.
-* @param[out] pDescriptionBuffer -  buffer of Description of the column., may be NULL
-* @param[out] pColumnType - Data type of the column.
+* @param[in] pDataCapture - DataCapture instance.
+* @param[in] nCaptureUUIDBufferSize - size of the buffer (including trailing 0)
+* @param[out] pCaptureUUIDNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pCaptureUUIDBuffer -  buffer of UUID of the capture., may be NULL
 * @return error code or 0 (success)
 */
-LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_getcolumninformation(LibMCEnv_DataTable pDataTable, const char * pIdentifier, const LibMCEnv_uint32 nDescriptionBufferSize, LibMCEnv_uint32* pDescriptionNeededChars, char * pDescriptionBuffer, LibMCEnv::eDataTableColumnType * pColumnType);
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacapture_finish(LibMCEnv_DataCapture pDataCapture, const LibMCEnv_uint32 nCaptureUUIDBufferSize, LibMCEnv_uint32* pCaptureUUIDNeededChars, char * pCaptureUUIDBuffer);
 
 /**
-* Returns the values of a double column. Will fail if column does not exist or type is not double.
+* Stops the capture and deletes all its segments.
 *
-* @param[in] pDataTable - DataTable instance.
-* @param[in] pIdentifier - Identifier of the column.
-* @param[in] nValuesBufferSize - Number of elements in buffer
-* @param[out] pValuesNeededCount - will be filled with the count of the written elements, or needed buffer size.
-* @param[out] pValuesBuffer - double  buffer of Value array of a column.
+* @param[in] pDataCapture - DataCapture instance.
 * @return error code or 0 (success)
 */
-LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_getdoublecolumnvalues(LibMCEnv_DataTable pDataTable, const char * pIdentifier, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_double * pValuesBuffer);
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacapture_abort(LibMCEnv_DataCapture pDataCapture);
 
 /**
-* Returns the double columns. Will fail if column does not exist or type is not int32.
+* Adds one column to the capture for every column of a data table, with the same identifier, description and type and in the same order. Fails if the schema is frozen or an identifier already exists.
 *
-* @param[in] pDataTable - DataTable instance.
-* @param[in] pIdentifier - Identifier of the column.
-* @param[in] nValuesBufferSize - Number of elements in buffer
-* @param[out] pValuesNeededCount - will be filled with the count of the written elements, or needed buffer size.
-* @param[out] pValuesBuffer - int32  buffer of Value array of a column.
+* @param[in] pDataCapture - DataCapture instance.
+* @param[in] pDataTable - Data table whose columns describe the schema. Its rows are not read.
 * @return error code or 0 (success)
 */
-LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_getint32columnvalues(LibMCEnv_DataTable pDataTable, const char * pIdentifier, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_int32 * pValuesBuffer);
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacapture_addcolumnsfromdatatable(LibMCEnv_DataCapture pDataCapture, LibMCEnv_DataTable pDataTable);
 
 /**
-* Returns the double columns. Will fail if column does not exist or type is not int64.
+* Appends all rows of a data table to the capture and splits them into chunks. Every column of the capture MUST exist in the table with the same identifier and type, and these columns MUST have the same row count. Further columns of the table are ignored. Freezes the schema on the first call. If no chunk is free, the backpressure mode of the capture applies. Fails if a chunk is uncommitted.
 *
-* @param[in] pDataTable - DataTable instance.
-* @param[in] pIdentifier - Identifier of the column.
-* @param[in] nValuesBufferSize - Number of elements in buffer
-* @param[out] pValuesNeededCount - will be filled with the count of the written elements, or needed buffer size.
-* @param[out] pValuesBuffer - int64  buffer of Value array of a column.
+* @param[in] pDataCapture - DataCapture instance.
+* @param[in] pDataTable - Data table that holds the rows to append.
+* @param[out] pRowCount - Number of rows that have been appended.
 * @return error code or 0 (success)
 */
-LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_getint64columnvalues(LibMCEnv_DataTable pDataTable, const char * pIdentifier, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_int64 * pValuesBuffer);
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datacapture_appenddatatable(LibMCEnv_DataCapture pDataCapture, LibMCEnv_DataTable pDataTable, LibMCEnv_uint64 * pRowCount);
+
+/*************************************************************************************************************************
+ Class definition for DataTableReader
+**************************************************************************************************************************/
 
 /**
-* Returns the double columns. Will fail if column does not exist or type is not uint32.
+* Returns the number of rows of the capture, including rows in segments that have been deleted by retention.
 *
-* @param[in] pDataTable - DataTable instance.
-* @param[in] pIdentifier - Identifier of the column.
-* @param[in] nValuesBufferSize - Number of elements in buffer
-* @param[out] pValuesNeededCount - will be filled with the count of the written elements, or needed buffer size.
-* @param[out] pValuesBuffer - uint32  buffer of Value array of a column.
+* @param[in] pDataTableReader - DataTableReader instance.
+* @param[out] pRowCount - Number of rows.
 * @return error code or 0 (success)
 */
-LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_getuint32columnvalues(LibMCEnv_DataTable pDataTable, const char * pIdentifier, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_uint32 * pValuesBuffer);
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatablereader_getrowcount(LibMCEnv_DataTableReader pDataTableReader, LibMCEnv_uint64 * pRowCount);
 
 /**
-* Returns the double columns. Will fail if column does not exist or type is not uint64.
+* Returns the index of the first row that is still stored. Rows before it have been deleted by retention.
 *
-* @param[in] pDataTable - DataTable instance.
-* @param[in] pIdentifier - Identifier of the column.
-* @param[in] nValuesBufferSize - Number of elements in buffer
-* @param[out] pValuesNeededCount - will be filled with the count of the written elements, or needed buffer size.
-* @param[out] pValuesBuffer - uint64  buffer of Value array of a column.
+* @param[in] pDataTableReader - DataTableReader instance.
+* @param[out] pFirstAvailableRow - Row index. Equal to the row count if nothing is stored.
 * @return error code or 0 (success)
 */
-LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_getuint64columnvalues(LibMCEnv_DataTable pDataTable, const char * pIdentifier, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_uint64 * pValuesBuffer);
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatablereader_getfirstavailablerow(LibMCEnv_DataTableReader pDataTableReader, LibMCEnv_uint64 * pFirstAvailableRow);
 
 /**
-* Sets the values of a double column. Will fail if column does not exist or type is not double.
+* Returns the number of columns.
 *
-* @param[in] pDataTable - DataTable instance.
-* @param[in] pIdentifier - Identifier of the column.
-* @param[in] nValuesBufferSize - Number of elements in buffer
-* @param[in] pValuesBuffer - double buffer of New Value array of a column. Array length should match RowCount. Values will be filled up with 0, if length is less than RowCount. RowCount will be extended if length is larger than RowCount.
+* @param[in] pDataTableReader - DataTableReader instance.
+* @param[out] pColumnCount - Number of columns.
 * @return error code or 0 (success)
 */
-LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_setdoublecolumnvalues(LibMCEnv_DataTable pDataTable, const char * pIdentifier, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_double * pValuesBuffer);
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatablereader_getcolumncount(LibMCEnv_DataTableReader pDataTableReader, LibMCEnv_uint32 * pColumnCount);
 
 /**
-* Sets the double columns. Will fail if column does not exist or type is not int32.
+* Returns if a column exists.
 *
-* @param[in] pDataTable - DataTable instance.
+* @param[in] pDataTableReader - DataTableReader instance.
 * @param[in] pIdentifier - Identifier of the column.
-* @param[in] nValuesBufferSize - Number of elements in buffer
-* @param[in] pValuesBuffer - int32 buffer of New Value array of a column. Array length should match RowCount. Values will be filled up with 0, if length is less than RowCount. RowCount will be extended if length is larger than RowCount.
+* @param[out] pColumnExists - Returns if the column exists.
 * @return error code or 0 (success)
 */
-LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_setint32columnvalues(LibMCEnv_DataTable pDataTable, const char * pIdentifier, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_int32 * pValuesBuffer);
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatablereader_hascolumn(LibMCEnv_DataTableReader pDataTableReader, const char * pIdentifier, bool * pColumnExists);
 
 /**
-* Sets the double columns. Will fail if column does not exist or type is not int64.
+* Returns the schema information of a column. Fails if the index is out of bounds.
 *
-* @param[in] pDataTable - DataTable instance.
-* @param[in] pIdentifier - Identifier of the column.
-* @param[in] nValuesBufferSize - Number of elements in buffer
-* @param[in] pValuesBuffer - int64 buffer of New Value array of a column. Array length should match RowCount. Values will be filled up with 0, if length is less than RowCount. RowCount will be extended if length is larger than RowCount.
+* @param[in] pDataTableReader - DataTableReader instance.
+* @param[in] nColumnIndex - Index of column. 0-based.
+* @param[in] nIdentifierBufferSize - size of the buffer (including trailing 0)
+* @param[out] pIdentifierNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pIdentifierBuffer -  buffer of Identifier of the column., may be NULL
+* @param[in] nDescriptionBufferSize - size of the buffer (including trailing 0)
+* @param[out] pDescriptionNeededChars - will be filled with the count of the written bytes, or needed buffer size.
+* @param[out] pDescriptionBuffer -  buffer of Description of the column., may be NULL
+* @param[out] pColumnType - Data type of the column.
 * @return error code or 0 (success)
 */
-LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_setint64columnvalues(LibMCEnv_DataTable pDataTable, const char * pIdentifier, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_int64 * pValuesBuffer);
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatablereader_getcolumninformation(LibMCEnv_DataTableReader pDataTableReader, LibMCEnv_uint32 nColumnIndex, const LibMCEnv_uint32 nIdentifierBufferSize, LibMCEnv_uint32* pIdentifierNeededChars, char * pIdentifierBuffer, const LibMCEnv_uint32 nDescriptionBufferSize, LibMCEnv_uint32* pDescriptionNeededChars, char * pDescriptionBuffer, LibMCEnv::eDataTableColumnType * pColumnType);
 
 /**
-* Sets the double columns. Will fail if column does not exist or type is not uint32.
+* Returns the quantisation step of a column. Values of a quantised column are exact to half a step.
 *
-* @param[in] pDataTable - DataTable instance.
+* @param[in] pDataTableReader - DataTableReader instance.
 * @param[in] pIdentifier - Identifier of the column.
-* @param[in] nValuesBufferSize - Number of elements in buffer
-* @param[in] pValuesBuffer - uint32 buffer of New Value array of a column. Array length should match RowCount. Values will be filled up with 0, if length is less than RowCount. RowCount will be extended if length is larger than RowCount.
+* @param[out] pStep - Quantisation step. 0 if the column is not quantised.
 * @return error code or 0 (success)
 */
-LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_setuint32columnvalues(LibMCEnv_DataTable pDataTable, const char * pIdentifier, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint32 * pValuesBuffer);
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatablereader_getcolumnquantization(LibMCEnv_DataTableReader pDataTableReader, const char * pIdentifier, LibMCEnv_double * pStep);
 
 /**
-* Sets the double columns. Will fail if column does not exist or type is not uint64.
+* Returns the number of segments of the capture, including deleted ones.
 *
-* @param[in] pDataTable - DataTable instance.
+* @param[in] pDataTableReader - DataTableReader instance.
+* @param[out] pSegmentCount - Number of segments.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatablereader_getsegmentcount(LibMCEnv_DataTableReader pDataTableReader, LibMCEnv_uint32 * pSegmentCount);
+
+/**
+* Returns the row range and the size of a segment. Fails if the index is out of bounds.
+*
+* @param[in] pDataTableReader - DataTableReader instance.
+* @param[in] nSegmentIndex - Index of the segment. 0-based.
+* @param[out] pFirstRow - Index of the first row of the segment.
+* @param[out] pRowCount - Number of rows in the segment.
+* @param[out] pSizeInBytes - Size of the segment stream in bytes.
+* @param[out] pIsAvailable - Returns false if the segment has been deleted by retention.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatablereader_getsegmentinformation(LibMCEnv_DataTableReader pDataTableReader, LibMCEnv_uint32 nSegmentIndex, LibMCEnv_uint64 * pFirstRow, LibMCEnv_uint64 * pRowCount, LibMCEnv_uint64 * pSizeInBytes, bool * pIsAvailable);
+
+/**
+* Returns the number of chunks of the capture, including chunks in deleted segments.
+*
+* @param[in] pDataTableReader - DataTableReader instance.
+* @param[out] pChunkCount - Number of chunks.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatablereader_getchunkcount(LibMCEnv_DataTableReader pDataTableReader, LibMCEnv_uint64 * pChunkCount);
+
+/**
+* Returns the position of a chunk. Fails if the index is out of bounds.
+*
+* @param[in] pDataTableReader - DataTableReader instance.
+* @param[in] nChunkIndex - Index of the chunk. 0-based.
+* @param[out] pSegmentIndex - Index of the segment that holds the chunk.
+* @param[out] pFirstRow - Index of the first row of the chunk. For a chunk in a deleted segment this is the first row of the segment.
+* @param[out] pRowCount - Number of rows in the chunk. 0 for a chunk in a deleted segment.
+* @param[out] pIsAvailable - Returns false if the chunk has been deleted by retention.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatablereader_getchunkinformation(LibMCEnv_DataTableReader pDataTableReader, LibMCEnv_uint64 nChunkIndex, LibMCEnv_uint32 * pSegmentIndex, LibMCEnv_uint64 * pFirstRow, LibMCEnv_uint64 * pRowCount, bool * pIsAvailable);
+
+/**
+* Returns the minimum and maximum of a column in a chunk from the page directory, without reading the chunk.
+*
+* @param[in] pDataTableReader - DataTableReader instance.
+* @param[in] nChunkIndex - Index of the chunk. 0-based.
 * @param[in] pIdentifier - Identifier of the column.
-* @param[in] nValuesBufferSize - Number of elements in buffer
-* @param[in] pValuesBuffer - uint64 buffer of New Value array of a column. Array length should match RowCount. Values will be filled up with 0, if length is less than RowCount. RowCount will be extended if length is larger than RowCount.
+* @param[out] pMinValue - Minimum value of the column in the chunk.
+* @param[out] pMaxValue - Maximum value of the column in the chunk.
+* @param[out] pHasStatistics - Returns false if the chunk has been deleted or holds no comparable value.
 * @return error code or 0 (success)
 */
-LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_setuint64columnvalues(LibMCEnv_DataTable pDataTable, const char * pIdentifier, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint64 * pValuesBuffer);
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatablereader_getchunkstatistics(LibMCEnv_DataTableReader pDataTableReader, LibMCEnv_uint64 nChunkIndex, const char * pIdentifier, LibMCEnv_double * pMinValue, LibMCEnv_double * pMaxValue, bool * pHasStatistics);
 
 /**
-* Creates a Write Option.
+* Reads a row range of a column as doubles. Works for every column type. Only the pages that overlap the range are read.
 *
-* @param[in] pDataTable - DataTable instance.
-* @param[out] pOptions - Writer Options Instance to pass on to WriteDataToStream.
+* @param[in] pDataTableReader - DataTableReader instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nFromRow - Index of the first row to read.
+* @param[in] nRowCount - Number of rows to read.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[out] pValuesNeededCount - will be filled with the count of the written elements, or needed buffer size.
+* @param[out] pValuesBuffer - double  buffer of Values of the row range.
 * @return error code or 0 (success)
 */
-LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_createwriteoptions(LibMCEnv_DataTable pDataTable, LibMCEnv_DataTableWriteOptions * pOptions);
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatablereader_readdoublecolumnrange(LibMCEnv_DataTableReader pDataTableReader, const char * pIdentifier, LibMCEnv_uint64 nFromRow, LibMCEnv_uint64 nRowCount, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_double * pValuesBuffer);
 
 /**
-* Creates a CSV Write Option.
+* Reads a row range of a float or double column as floats.
 *
-* @param[in] pDataTable - DataTable instance.
-* @param[out] pOptions - Writer Options Instance to pass on to WriteCSVToStream.
+* @param[in] pDataTableReader - DataTableReader instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nFromRow - Index of the first row to read.
+* @param[in] nRowCount - Number of rows to read.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[out] pValuesNeededCount - will be filled with the count of the written elements, or needed buffer size.
+* @param[out] pValuesBuffer - single  buffer of Values of the row range.
 * @return error code or 0 (success)
 */
-LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_createcsvwriteoptions(LibMCEnv_DataTable pDataTable, LibMCEnv_DataTableCSVWriteOptions * pOptions);
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatablereader_readfloatcolumnrange(LibMCEnv_DataTableReader pDataTableReader, const char * pIdentifier, LibMCEnv_uint64 nFromRow, LibMCEnv_uint64 nRowCount, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_single * pValuesBuffer);
 
 /**
-* Writes the data as CSV to a temporary stream.
+* Reads a row range of an integer, bool or timestamp column as 64 bit integers.
 *
-* @param[in] pDataTable - DataTable instance.
-* @param[in] pWriter - Stream writer to use.
-* @param[in] pOptions - Optional CSV writer options to use.
+* @param[in] pDataTableReader - DataTableReader instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nFromRow - Index of the first row to read.
+* @param[in] nRowCount - Number of rows to read.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[out] pValuesNeededCount - will be filled with the count of the written elements, or needed buffer size.
+* @param[out] pValuesBuffer - int64  buffer of Values of the row range.
 * @return error code or 0 (success)
 */
-LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_writecsvtostream(LibMCEnv_DataTable pDataTable, LibMCEnv_TempStreamWriter pWriter, LibMCEnv_DataTableCSVWriteOptions pOptions);
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatablereader_readint64columnrange(LibMCEnv_DataTableReader pDataTableReader, const char * pIdentifier, LibMCEnv_uint64 nFromRow, LibMCEnv_uint64 nRowCount, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_int64 * pValuesBuffer);
 
 /**
-* Writes the data as binary to a temporary stream.
+* Reads a row range of a bool column as bytes (0 = false, 1 = true).
 *
-* @param[in] pDataTable - DataTable instance.
-* @param[in] pWriter - Stream writer instance to use.
-* @param[in] pOptions - Optional writer options to use.
+* @param[in] pDataTableReader - DataTableReader instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nFromRow - Index of the first row to read.
+* @param[in] nRowCount - Number of rows to read.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[out] pValuesNeededCount - will be filled with the count of the written elements, or needed buffer size.
+* @param[out] pValuesBuffer - uint8  buffer of Values of the row range.
 * @return error code or 0 (success)
 */
-LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_writedatatostream(LibMCEnv_DataTable pDataTable, LibMCEnv_TempStreamWriter pWriter, LibMCEnv_DataTableWriteOptions pOptions);
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatablereader_readboolcolumnrange(LibMCEnv_DataTableReader pDataTableReader, const char * pIdentifier, LibMCEnv_uint64 nFromRow, LibMCEnv_uint64 nRowCount, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_uint8 * pValuesBuffer);
 
 /**
-* Loads the data table from a stream. Clears all existing data from the data table.
+* Reduces a row range of a column to at most TargetPoints buckets without materialising the range. Stride returns the first value of each bucket, Average the mean and MinMax the minimum followed by the maximum of each bucket, which preserves the envelope of the signal.
 *
-* @param[in] pDataTable - DataTable instance.
-* @param[in] pStream - Stream read instance to read from.
+* @param[in] pDataTableReader - DataTableReader instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] nFromRow - Index of the first row of the range.
+* @param[in] nRowCount - Number of rows of the range.
+* @param[in] nTargetPoints - Maximum number of buckets. MUST be positive.
+* @param[in] eMode - Stride, MinMax or Average.
+* @param[in] nValuesBufferSize - Number of elements in buffer
+* @param[out] pValuesNeededCount - will be filled with the count of the written elements, or needed buffer size.
+* @param[out] pValuesBuffer - double  buffer of One value per bucket, or two values per bucket in MinMax mode. The number of buckets is the smaller of TargetPoints and RowCount.
 * @return error code or 0 (success)
 */
-LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_loadfromstream(LibMCEnv_DataTable pDataTable, LibMCEnv_StreamReader pStream);
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatablereader_readcolumndownsampled(LibMCEnv_DataTableReader pDataTableReader, const char * pIdentifier, LibMCEnv_uint64 nFromRow, LibMCEnv_uint64 nRowCount, LibMCEnv_uint32 nTargetPoints, LibMCEnv::eDataTableDownsampleMode eMode, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_double * pValuesBuffer);
 
 /**
-* Creates an options object for scatter plot computation.
+* Finds the chunks whose value range of a column overlaps a given range. Only the page directory is used, no chunk is read.
 *
-* @param[in] pDataTable - DataTable instance.
-* @param[out] pScatterPlotOptions - DataTableScatterPlotOptions Instance
+* @param[in] pDataTableReader - DataTableReader instance.
+* @param[in] pIdentifier - Identifier of the column.
+* @param[in] dMinValue - Lower bound of the value range.
+* @param[in] dMaxValue - Upper bound of the value range.
+* @param[in] nChunkIndicesBufferSize - Number of elements in buffer
+* @param[out] pChunkIndicesNeededCount - will be filled with the count of the written elements, or needed buffer size.
+* @param[out] pChunkIndicesBuffer - uint64  buffer of Indices of the chunks that may hold a value in the range.
 * @return error code or 0 (success)
 */
-LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_createscatterplotoptions(LibMCEnv_DataTable pDataTable, LibMCEnv_DataTableScatterPlotOptions * pScatterPlotOptions);
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatablereader_findchunksinvaluerange(LibMCEnv_DataTableReader pDataTableReader, const char * pIdentifier, LibMCEnv_double dMinValue, LibMCEnv_double dMaxValue, const LibMCEnv_uint64 nChunkIndicesBufferSize, LibMCEnv_uint64* pChunkIndicesNeededCount, LibMCEnv_uint64 * pChunkIndicesBuffer);
 
 /**
-* Creates a scatterplot from the data table according to its input parameters.
+* Materialises a row range as an ordinary in-memory data table.
 *
-* @param[in] pDataTable - DataTable instance.
-* @param[in] pScatterPlotOptions - ScatterPlot Options to use
-* @param[out] pScatterPlot - ScatterPlot Instance
+* @param[in] pDataTableReader - DataTableReader instance.
+* @param[in] nFromRow - Index of the first row of the range.
+* @param[in] nRowCount - Number of rows of the range.
+* @param[in] pColumnIdentifiers - Comma separated identifiers of the columns to extract. An empty string extracts all columns.
+* @param[out] pDataTableInstance - Data table instance.
 * @return error code or 0 (success)
 */
-LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatable_calculatescatterplot(LibMCEnv_DataTable pDataTable, LibMCEnv_DataTableScatterPlotOptions pScatterPlotOptions, LibMCEnv_ScatterPlot * pScatterPlot);
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_datatablereader_extractdatatable(LibMCEnv_DataTableReader pDataTableReader, LibMCEnv_uint64 nFromRow, LibMCEnv_uint64 nRowCount, const char * pColumnIdentifiers, LibMCEnv_DataTable * pDataTableInstance);
 
 /*************************************************************************************************************************
  Class definition for DataSeries
@@ -4385,6 +5147,79 @@ LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_buildexecution_getmetadatastring(LibMC
 */
 LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_buildexecution_loadattachedjournal(LibMCEnv_BuildExecution pBuildExecution, LibMCEnv_uint32 nCacheMemoryQuotaInMegabytes, LibMCEnv_JournalHandler * pJournalHandler);
 
+/**
+* Creates an options object for a data capture with default values.
+*
+* @param[in] pBuildExecution - BuildExecution instance.
+* @param[out] pOptions - Data capture options instance.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_buildexecution_createdatacaptureoptions(LibMCEnv_BuildExecution pBuildExecution, LibMCEnv_DataCaptureOptions * pOptions);
+
+/**
+* Creates a streaming data capture in this build execution. The execution MUST be in process.
+*
+* @param[in] pBuildExecution - BuildExecution instance.
+* @param[in] pIdentifier - Unique identifier of the capture in this execution. Fails if the identifier already exists or is invalid.
+* @param[in] pName - Human readable name of the capture.
+* @param[in] pOptions - Data capture options. Defaults are used if not given.
+* @param[in] pUserUUID - User UUID of the user that this data comes from. Empty string means no user attached.
+* @param[out] pDataCaptureInstance - Data capture instance.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_buildexecution_createdatacapture(LibMCEnv_BuildExecution pBuildExecution, const char * pIdentifier, const char * pName, LibMCEnv_DataCaptureOptions pOptions, const char * pUserUUID, LibMCEnv_DataCapture * pDataCaptureInstance);
+
+/**
+* Returns if the execution has a data capture with a certain identifier.
+*
+* @param[in] pBuildExecution - BuildExecution instance.
+* @param[in] pIdentifier - Identifier of the capture.
+* @param[out] pCaptureExists - Returns true if the capture exists.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_buildexecution_hasdatacapture(LibMCEnv_BuildExecution pBuildExecution, const char * pIdentifier, bool * pCaptureExists);
+
+/**
+* Returns the number of rows of a data capture that have been stored in segments. Fails if the capture does not exist.
+*
+* @param[in] pBuildExecution - BuildExecution instance.
+* @param[in] pIdentifier - Identifier of the capture.
+* @param[out] pRowCount - Number of rows.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_buildexecution_getdatacapturerowcount(LibMCEnv_BuildExecution pBuildExecution, const char * pIdentifier, LibMCEnv_uint64 * pRowCount);
+
+/**
+* Returns the number of stored segments of a data capture. Fails if the capture does not exist.
+*
+* @param[in] pBuildExecution - BuildExecution instance.
+* @param[in] pIdentifier - Identifier of the capture.
+* @param[out] pSegmentCount - Number of segments.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_buildexecution_getdatacapturesegmentcount(LibMCEnv_BuildExecution pBuildExecution, const char * pIdentifier, LibMCEnv_uint32 * pSegmentCount);
+
+/**
+* Loads one segment of a data capture as in-memory data table. Fails if the capture or the segment does not exist or the segment has been deleted by retention.
+*
+* @param[in] pBuildExecution - BuildExecution instance.
+* @param[in] pIdentifier - Identifier of the capture.
+* @param[in] nSegmentIndex - Index of the segment. 0-based.
+* @param[out] pDataTableInstance - Loaded data table instance.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_buildexecution_loaddatacapturesegment(LibMCEnv_BuildExecution pBuildExecution, const char * pIdentifier, LibMCEnv_uint32 nSegmentIndex, LibMCEnv_DataTable * pDataTableInstance);
+
+/**
+* Opens a reader on the stored segments of a data capture. Fails if the capture does not exist.
+*
+* @param[in] pBuildExecution - BuildExecution instance.
+* @param[in] pIdentifier - Identifier of the capture.
+* @param[out] pReaderInstance - Reader instance.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_buildexecution_opendatacapturereader(LibMCEnv_BuildExecution pBuildExecution, const char * pIdentifier, LibMCEnv_DataTableReader * pReaderInstance);
+
 /*************************************************************************************************************************
  Class definition for BuildExecutionIterator
 **************************************************************************************************************************/
@@ -8181,6 +9016,14 @@ LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_zipstreamwriter_createzipentry(LibMCEn
 */
 LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_zipstreamwriter_createzipentryfromstream(LibMCEnv_ZIPStreamWriter pZIPStreamWriter, const char * pFileName, LibMCEnv_StreamReader pStreamReader);
 
+/**
+* Discards the unfinished ZIP stream. The file on disk and the stream entry are deleted. Fails if the stream has been finished already. A ZIP writer that is released without Finish is discarded automatically.
+*
+* @param[in] pZIPStreamWriter - ZIPStreamWriter instance.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_zipstreamwriter_discard(LibMCEnv_ZIPStreamWriter pZIPStreamWriter);
+
 /*************************************************************************************************************************
  Class definition for StreamReader
 **************************************************************************************************************************/
@@ -11347,6 +12190,62 @@ LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_stateenvironment_evaluateformulaasinte
 */
 LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_stateenvironment_evaluateformulaasbool(LibMCEnv_StateEnvironment pStateEnvironment, const char * pFormula, bool * pValue);
 
+/**
+* Starts a stream download in the browser of a client session. Creates a download ticket for the user of the session and queues the download action for delivery to the session. Returns false if the session does not exist or is not authorized.
+*
+* @param[in] pStateEnvironment - StateEnvironment instance.
+* @param[in] pSessionUUID - UUID of the client session.
+* @param[in] pStreamUUID - Storage stream. Fails if the stream does not exist or is not finished.
+* @param[in] pFileName - File name offered to the browser. Fails if empty.
+* @param[out] pSuccess - True if the download action was queued for the session.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_stateenvironment_startstreamdownloadforsession(LibMCEnv_StateEnvironment pStateEnvironment, const char * pSessionUUID, const char * pStreamUUID, const char * pFileName, bool * pSuccess);
+
+/**
+* Returns the delivery progress of all downloads of a storage stream.
+*
+* @param[in] pStateEnvironment - StateEnvironment instance.
+* @param[in] pStreamUUID - Storage stream.
+* @param[out] pActiveConnections - Connections that are sending the stream right now.
+* @param[out] pDeliveredBytes - Bytes from the start of the stream that were sent without a gap.
+* @param[out] pTotalBytes - Size of the stream.
+* @param[out] pCompleted - The last byte was sent and its connection ended successfully.
+* @param[out] pMillisecondsSinceActivity - Time since the last chunk was sent or since the download was handed over.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_stateenvironment_getstreamdownloadprogress(LibMCEnv_StateEnvironment pStateEnvironment, const char * pStreamUUID, LibMCEnv_uint32 * pActiveConnections, LibMCEnv_uint64 * pDeliveredBytes, LibMCEnv_uint64 * pTotalBytes, bool * pCompleted, LibMCEnv_uint64 * pMillisecondsSinceActivity);
+
+/**
+* Stops all running downloads of a storage stream, revokes its download tickets and drops its unclaimed download actions. Does nothing if the stream was already delivered completely.
+*
+* @param[in] pStateEnvironment - StateEnvironment instance.
+* @param[in] pStreamUUID - Storage stream.
+* @param[out] pCancelled - False if the download had already completed and nothing was cancelled.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_stateenvironment_cancelstreamdownloads(LibMCEnv_StateEnvironment pStateEnvironment, const char * pStreamUUID, bool * pCancelled);
+
+/**
+* Deletes a finished storage stream from disk and database, including its download tickets. Fails if the stream does not exist, is still being written or is being downloaded right now.
+*
+* @param[in] pStateEnvironment - StateEnvironment instance.
+* @param[in] pUUID - UUID of the storage stream.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_stateenvironment_deletestoragestream(LibMCEnv_StateEnvironment pStateEnvironment, const char * pUUID);
+
+/**
+* Deletes all finished streams with the given name except the newest ones. Streams with running downloads or pending download actions are kept. Returns the number of deleted streams.
+*
+* @param[in] pStateEnvironment - StateEnvironment instance.
+* @param[in] pName - Name of the streams.
+* @param[in] nKeepCount - Number of newest streams to keep.
+* @param[out] pDeletedCount - Number of deleted streams.
+* @return error code or 0 (success)
+*/
+LIBMCENV_DECLSPEC LibMCEnvResult libmcenv_stateenvironment_enforcestreamretention(LibMCEnv_StateEnvironment pStateEnvironment, const char * pName, LibMCEnv_uint32 nKeepCount, LibMCEnv_uint32 * pDeletedCount);
+
 /*************************************************************************************************************************
  Class definition for UIItem
 **************************************************************************************************************************/
diff --git a/Framework/InterfacesCore/libmcenv_interfaces.hpp b/Framework/InterfacesCore/libmcenv_interfaces.hpp
index 64a18b227..a4f363531 100644
--- a/Framework/InterfacesCore/libmcenv_interfaces.hpp
+++ b/Framework/InterfacesCore/libmcenv_interfaces.hpp
@@ -76,6 +76,10 @@ class IScatterPlotDataChannel;
 class IScatterPlotDataChannelIterator;
 class IDataTableScatterPlotOptions;
 class IDataTable;
+class IDataCaptureOptions;
+class IDataCaptureChunk;
+class IDataCapture;
+class IDataTableReader;
 class IDataSeries;
 class IDateTimeDifference;
 class IDateTime;
@@ -1492,6 +1496,12 @@ class IDataTable : public virtual IBase {
 	*/
 	virtual LibMCEnv_uint32 GetRowCount() = 0;
 
+	/**
+	* IDataTable::GetRowCount64 - Returns the current row count as 64 bit value. GetRowCount is kept for ABI compatibility and truncates large row counts.
+	* @return Number of rows.
+	*/
+	virtual LibMCEnv_uint64 GetRowCount64() = 0;
+
 	/**
 	* IDataTable::GetColumnCount - Returns the current column count.
 	* @return Number of columns.
@@ -1572,6 +1582,33 @@ class IDataTable : public virtual IBase {
 	*/
 	virtual void GetUint64ColumnValues(const std::string & sIdentifier, LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_uint64 * pValuesBuffer) = 0;
 
+	/**
+	* IDataTable::GetFloatColumnValues - Returns the values of a float (32 bit) column. Will fail if column does not exist or type is not float.
+	* @param[in] sIdentifier - Identifier of the column.
+	* @param[in] nValuesBufferSize - Number of elements in buffer
+	* @param[out] pValuesNeededCount - will be filled with the count of the written structs, or needed buffer size.
+	* @param[out] pValuesBuffer - single buffer of Value array of a column.
+	*/
+	virtual void GetFloatColumnValues(const std::string & sIdentifier, LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_single * pValuesBuffer) = 0;
+
+	/**
+	* IDataTable::GetBoolColumnValues - Returns the values of a bool column as bytes (0 = false, 1 = true). Will fail if column does not exist or type is not bool.
+	* @param[in] sIdentifier - Identifier of the column.
+	* @param[in] nValuesBufferSize - Number of elements in buffer
+	* @param[out] pValuesNeededCount - will be filled with the count of the written structs, or needed buffer size.
+	* @param[out] pValuesBuffer - uint8 buffer of Value array of a column. Each entry is 0 or 1.
+	*/
+	virtual void GetBoolColumnValues(const std::string & sIdentifier, LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_uint8 * pValuesBuffer) = 0;
+
+	/**
+	* IDataTable::GetTimestampColumnValues - Returns the values of a timestamp column in microseconds. Will fail if column does not exist or type is not timestamp.
+	* @param[in] sIdentifier - Identifier of the column.
+	* @param[in] nValuesBufferSize - Number of elements in buffer
+	* @param[out] pValuesNeededCount - will be filled with the count of the written structs, or needed buffer size.
+	* @param[out] pValuesBuffer - uint64 buffer of Value array of a column. Timestamps in microseconds.
+	*/
+	virtual void GetTimestampColumnValues(const std::string & sIdentifier, LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_uint64 * pValuesBuffer) = 0;
+
 	/**
 	* IDataTable::SetDoubleColumnValues - Sets the values of a double column. Will fail if column does not exist or type is not double.
 	* @param[in] sIdentifier - Identifier of the column.
@@ -1612,6 +1649,30 @@ class IDataTable : public virtual IBase {
 	*/
 	virtual void SetUint64ColumnValues(const std::string & sIdentifier, const LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint64 * pValuesBuffer) = 0;
 
+	/**
+	* IDataTable::SetFloatColumnValues - Sets the values of a float (32 bit) column. Will fail if column does not exist or type is not float.
+	* @param[in] sIdentifier - Identifier of the column.
+	* @param[in] nValuesBufferSize - Number of elements in buffer
+	* @param[in] pValuesBuffer - New Value array of a column. Array length should match RowCount. Values will be filled up with 0, if length is less than RowCount. RowCount will be extended if length is larger than RowCount.
+	*/
+	virtual void SetFloatColumnValues(const std::string & sIdentifier, const LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_single * pValuesBuffer) = 0;
+
+	/**
+	* IDataTable::SetBoolColumnValues - Sets the values of a bool column from bytes (0 = false, nonzero = true). Will fail if column does not exist or type is not bool.
+	* @param[in] sIdentifier - Identifier of the column.
+	* @param[in] nValuesBufferSize - Number of elements in buffer
+	* @param[in] pValuesBuffer - New Value array of a column. Array length should match RowCount. Values will be filled up with 0, if length is less than RowCount. RowCount will be extended if length is larger than RowCount.
+	*/
+	virtual void SetBoolColumnValues(const std::string & sIdentifier, const LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint8 * pValuesBuffer) = 0;
+
+	/**
+	* IDataTable::SetTimestampColumnValues - Sets the values of a timestamp column in microseconds. Will fail if column does not exist or type is not timestamp.
+	* @param[in] sIdentifier - Identifier of the column.
+	* @param[in] nValuesBufferSize - Number of elements in buffer
+	* @param[in] pValuesBuffer - New Value array of a column. Array length should match RowCount. Values will be filled up with 0, if length is less than RowCount. RowCount will be extended if length is larger than RowCount.
+	*/
+	virtual void SetTimestampColumnValues(const std::string & sIdentifier, const LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint64 * pValuesBuffer) = 0;
+
 	/**
 	* IDataTable::CreateWriteOptions - Creates a Write Option.
 	* @return Writer Options Instance to pass on to WriteDataToStream.
@@ -1662,6 +1723,511 @@ class IDataTable : public virtual IBase {
 typedef IBaseSharedPtr<IDataTable> PIDataTable;
 
 
+/*************************************************************************************************************************
+ Class interface for DataCaptureOptions 
+**************************************************************************************************************************/
+
+class IDataCaptureOptions : public virtual IBase {
+public:
+	/**
+	* IDataCaptureOptions::SetChunkRowCount - Sets the number of rows a chunk can hold. Default is 65536.
+	* @param[in] nChunkRowCount - Rows per chunk. MUST be between 1 and 16777216.
+	*/
+	virtual void SetChunkRowCount(const LibMCEnv_uint32 nChunkRowCount) = 0;
+
+	/**
+	* IDataCaptureOptions::GetChunkRowCount - Returns the number of rows a chunk can hold.
+	* @return Rows per chunk.
+	*/
+	virtual LibMCEnv_uint32 GetChunkRowCount() = 0;
+
+	/**
+	* IDataCaptureOptions::SetSegmentSizeInBytes - Sets the size at which the capture rolls over into a new segment stream. Default is 1 GB.
+	* @param[in] nSegmentSizeInBytes - Maximum segment size in bytes. 0 means the capture never rolls over. A segment always holds at least one chunk.
+	*/
+	virtual void SetSegmentSizeInBytes(const LibMCEnv_uint64 nSegmentSizeInBytes) = 0;
+
+	/**
+	* IDataCaptureOptions::GetSegmentSizeInBytes - Returns the size at which the capture rolls over into a new segment stream.
+	* @return Maximum segment size in bytes. 0 means the capture never rolls over.
+	*/
+	virtual LibMCEnv_uint64 GetSegmentSizeInBytes() = 0;
+
+	/**
+	* IDataCaptureOptions::SetMaxQueuedChunks - Sets the maximum number of committed chunks that may wait for the writer thread. Default is 16.
+	* @param[in] nMaxQueuedChunks - Queue depth. MUST be between 1 and 1024.
+	*/
+	virtual void SetMaxQueuedChunks(const LibMCEnv_uint32 nMaxQueuedChunks) = 0;
+
+	/**
+	* IDataCaptureOptions::GetMaxQueuedChunks - Returns the maximum number of committed chunks that may wait for the writer thread.
+	* @return Queue depth.
+	*/
+	virtual LibMCEnv_uint32 GetMaxQueuedChunks() = 0;
+
+	/**
+	* IDataCaptureOptions::SetBackpressureMode - Sets what happens when the producer is faster than the disk. Default is Block.
+	* @param[in] eBackpressureMode - Block waits for the writer, DropOldest discards the oldest queued chunk, Fail raises an error.
+	*/
+	virtual void SetBackpressureMode(const LibMCEnv::eDataCaptureBackpressureMode eBackpressureMode) = 0;
+
+	/**
+	* IDataCaptureOptions::GetBackpressureMode - Returns what happens when the producer is faster than the disk.
+	* @return Backpressure mode.
+	*/
+	virtual LibMCEnv::eDataCaptureBackpressureMode GetBackpressureMode() = 0;
+
+	/**
+	* IDataCaptureOptions::SetStorageLimitInBytes - Sets the retention limit for all data capture segments stored on this machine. When it is exceeded after a segment has been finalized, the oldest stored segments are deleted first. Default is 0.
+	* @param[in] nStorageLimitInBytes - Total size limit in bytes. 0 disables retention.
+	*/
+	virtual void SetStorageLimitInBytes(const LibMCEnv_uint64 nStorageLimitInBytes) = 0;
+
+	/**
+	* IDataCaptureOptions::GetStorageLimitInBytes - Returns the retention limit for all data capture segments stored on this machine.
+	* @return Total size limit in bytes. 0 means retention is disabled.
+	*/
+	virtual LibMCEnv_uint64 GetStorageLimitInBytes() = 0;
+
+	/**
+	* IDataCaptureOptions::SetCompression - Sets the codec the pages of the capture are compressed with. Default is LZ4. A page is stored uncompressed if the codec does not make it smaller.
+	* @param[in] eCompression - None, LZ4 or Deflate. Deflate is meant for cold data, it costs considerably more processing time than LZ4.
+	*/
+	virtual void SetCompression(const LibMCEnv::eDataCaptureCompression eCompression) = 0;
+
+	/**
+	* IDataCaptureOptions::GetCompression - Returns the codec the pages of the capture are compressed with.
+	* @return Compression codec.
+	*/
+	virtual LibMCEnv::eDataCaptureCompression GetCompression() = 0;
+
+	/**
+	* IDataCaptureOptions::SetColumnEncoding - Sets the encoding of a column. Default is Automatic, which uses Delta for integer and timestamp columns, BitPack for bool columns and Plain for float and double columns. The column MUST exist when the capture starts recording and the encoding MUST fit its type.
+	* @param[in] sColumnIdentifier - Identifier of the column.
+	* @param[in] eEncoding - Automatic, Plain, Delta or BitPack.
+	*/
+	virtual void SetColumnEncoding(const std::string & sColumnIdentifier, const LibMCEnv::eDataCaptureEncoding eEncoding) = 0;
+
+	/**
+	* IDataCaptureOptions::SetDoubleQuantization - Opts a double column into lossy storage: values are stored as integer multiples of the step with Delta encoding. Columns that are not quantised stay bit-exact. The step is recorded in the capture and the column MUST be a double column.
+	* @param[in] sColumnIdentifier - Identifier of the column.
+	* @param[in] dStep - Quantisation step. MUST be positive. 0 removes the quantisation.
+	*/
+	virtual void SetDoubleQuantization(const std::string & sColumnIdentifier, const LibMCEnv_double dStep) = 0;
+
+};
+
+typedef IBaseSharedPtr<IDataCaptureOptions> PIDataCaptureOptions;
+
+
+/*************************************************************************************************************************
+ Class interface for DataCaptureChunk 
+**************************************************************************************************************************/
+
+class IDataCaptureChunk : public virtual IBase {
+public:
+	/**
+	* IDataCaptureChunk::GetCapacity - Returns the number of rows the chunk can hold.
+	* @return Number of rows.
+	*/
+	virtual LibMCEnv_uint32 GetCapacity() = 0;
+
+	/**
+	* IDataCaptureChunk::GetRowCount - Returns the number of rows in the chunk. This is the row count of the longest column.
+	* @return Number of rows.
+	*/
+	virtual LibMCEnv_uint32 GetRowCount() = 0;
+
+	/**
+	* IDataCaptureChunk::IsFull - Returns if the chunk has reached its capacity.
+	* @return Returns true if no more rows fit into the chunk.
+	*/
+	virtual bool IsFull() = 0;
+
+	/**
+	* IDataCaptureChunk::SetDoubleColumnValues - Sets all rows of a double column in this chunk. Fails if the column type does not match or the capacity is exceeded.
+	* @param[in] nColumnIndex - Index of the column. 0-based.
+	* @param[in] nValuesBufferSize - Number of elements in buffer
+	* @param[in] pValuesBuffer - Values of the column. All columns of a chunk MUST have the same length on commit.
+	*/
+	virtual void SetDoubleColumnValues(const LibMCEnv_uint32 nColumnIndex, const LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_double * pValuesBuffer) = 0;
+
+	/**
+	* IDataCaptureChunk::SetInt32ColumnValues - Sets all rows of an int32 column in this chunk. Fails if the column type does not match or the capacity is exceeded.
+	* @param[in] nColumnIndex - Index of the column. 0-based.
+	* @param[in] nValuesBufferSize - Number of elements in buffer
+	* @param[in] pValuesBuffer - Values of the column. All columns of a chunk MUST have the same length on commit.
+	*/
+	virtual void SetInt32ColumnValues(const LibMCEnv_uint32 nColumnIndex, const LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_int32 * pValuesBuffer) = 0;
+
+	/**
+	* IDataCaptureChunk::SetUint32ColumnValues - Sets all rows of an uint32 column in this chunk. Fails if the column type does not match or the capacity is exceeded.
+	* @param[in] nColumnIndex - Index of the column. 0-based.
+	* @param[in] nValuesBufferSize - Number of elements in buffer
+	* @param[in] pValuesBuffer - Values of the column. All columns of a chunk MUST have the same length on commit.
+	*/
+	virtual void SetUint32ColumnValues(const LibMCEnv_uint32 nColumnIndex, const LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint32 * pValuesBuffer) = 0;
+
+	/**
+	* IDataCaptureChunk::SetInt64ColumnValues - Sets all rows of an int64 column in this chunk. Fails if the column type does not match or the capacity is exceeded.
+	* @param[in] nColumnIndex - Index of the column. 0-based.
+	* @param[in] nValuesBufferSize - Number of elements in buffer
+	* @param[in] pValuesBuffer - Values of the column. All columns of a chunk MUST have the same length on commit.
+	*/
+	virtual void SetInt64ColumnValues(const LibMCEnv_uint32 nColumnIndex, const LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_int64 * pValuesBuffer) = 0;
+
+	/**
+	* IDataCaptureChunk::SetUint64ColumnValues - Sets all rows of an uint64 column in this chunk. Fails if the column type does not match or the capacity is exceeded.
+	* @param[in] nColumnIndex - Index of the column. 0-based.
+	* @param[in] nValuesBufferSize - Number of elements in buffer
+	* @param[in] pValuesBuffer - Values of the column. All columns of a chunk MUST have the same length on commit.
+	*/
+	virtual void SetUint64ColumnValues(const LibMCEnv_uint32 nColumnIndex, const LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint64 * pValuesBuffer) = 0;
+
+	/**
+	* IDataCaptureChunk::SetFloatColumnValues - Sets all rows of a float (32 bit) column in this chunk. Fails if the column type does not match or the capacity is exceeded.
+	* @param[in] nColumnIndex - Index of the column. 0-based.
+	* @param[in] nValuesBufferSize - Number of elements in buffer
+	* @param[in] pValuesBuffer - Values of the column. All columns of a chunk MUST have the same length on commit.
+	*/
+	virtual void SetFloatColumnValues(const LibMCEnv_uint32 nColumnIndex, const LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_single * pValuesBuffer) = 0;
+
+	/**
+	* IDataCaptureChunk::SetBoolColumnValues - Sets all rows of a bool column in this chunk from bytes (0 = false, nonzero = true). Fails if the column type does not match or the capacity is exceeded.
+	* @param[in] nColumnIndex - Index of the column. 0-based.
+	* @param[in] nValuesBufferSize - Number of elements in buffer
+	* @param[in] pValuesBuffer - Values of the column. All columns of a chunk MUST have the same length on commit.
+	*/
+	virtual void SetBoolColumnValues(const LibMCEnv_uint32 nColumnIndex, const LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint8 * pValuesBuffer) = 0;
+
+	/**
+	* IDataCaptureChunk::SetTimestampColumnValues - Sets all rows of a timestamp column in this chunk in microseconds. Fails if the column type does not match or the capacity is exceeded.
+	* @param[in] nColumnIndex - Index of the column. 0-based.
+	* @param[in] nValuesBufferSize - Number of elements in buffer
+	* @param[in] pValuesBuffer - Values of the column. All columns of a chunk MUST have the same length on commit.
+	*/
+	virtual void SetTimestampColumnValues(const LibMCEnv_uint32 nColumnIndex, const LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint64 * pValuesBuffer) = 0;
+
+	/**
+	* IDataCaptureChunk::BeginRow - Starts a new row at the end of the chunk. This is the convenience path for low-rate producers. Fails if the chunk is full, a row is open or the columns have different row counts.
+	*/
+	virtual void BeginRow() = 0;
+
+	/**
+	* IDataCaptureChunk::SetRowDoubleValue - Sets a value of the open row. The column MUST be of type double or float.
+	* @param[in] nColumnIndex - Index of the column. 0-based.
+	* @param[in] dValue - Value to set.
+	*/
+	virtual void SetRowDoubleValue(const LibMCEnv_uint32 nColumnIndex, const LibMCEnv_double dValue) = 0;
+
+	/**
+	* IDataCaptureChunk::SetRowIntegerValue - Sets a value of the open row. The column MUST be of an integer, bool or timestamp type and the value MUST be in its range.
+	* @param[in] nColumnIndex - Index of the column. 0-based.
+	* @param[in] nValue - Value to set.
+	*/
+	virtual void SetRowIntegerValue(const LibMCEnv_uint32 nColumnIndex, const LibMCEnv_int64 nValue) = 0;
+
+	/**
+	* IDataCaptureChunk::EndRow - Finishes the open row. Columns that have not been set in this row are zero.
+	*/
+	virtual void EndRow() = 0;
+
+};
+
+typedef IBaseSharedPtr<IDataCaptureChunk> PIDataCaptureChunk;
+
+
+/*************************************************************************************************************************
+ Class interface for DataCapture 
+**************************************************************************************************************************/
+
+class IDataCapture : public virtual IBase {
+public:
+	/**
+	* IDataCapture::GetUUID - Returns the UUID of the capture.
+	* @return UUID of the capture.
+	*/
+	virtual std::string GetUUID() = 0;
+
+	/**
+	* IDataCapture::GetIdentifier - Returns the identifier of the capture. It is unique within the build execution.
+	* @return Identifier of the capture.
+	*/
+	virtual std::string GetIdentifier() = 0;
+
+	/**
+	* IDataCapture::GetName - Returns the human readable name of the capture.
+	* @return Name of the capture.
+	*/
+	virtual std::string GetName() = 0;
+
+	/**
+	* IDataCapture::GetStatus - Returns the status of the capture.
+	* @return Status of the capture.
+	*/
+	virtual LibMCEnv::eDataCaptureStatus GetStatus() = 0;
+
+	/**
+	* IDataCapture::AddColumn - Adds a column to the capture. The schema is frozen with the first call to BeginChunk.
+	* @param[in] sIdentifier - Identifier of the column. MUST be unique, alphanumeric and not empty.
+	* @param[in] sDescription - Description of the column.
+	* @param[in] eColumnType - Data type of the column.
+	*/
+	virtual void AddColumn(const std::string & sIdentifier, const std::string & sDescription, const LibMCEnv::eDataTableColumnType eColumnType) = 0;
+
+	/**
+	* IDataCapture::GetColumnCount - Returns the number of columns of the capture.
+	* @return Number of columns.
+	*/
+	virtual LibMCEnv_uint32 GetColumnCount() = 0;
+
+	/**
+	* IDataCapture::BeginChunk - Borrows an empty chunk from the chunk pool. Freezes the schema on the first call. If no chunk is free, the backpressure mode of the capture applies.
+	* @return Chunk to fill.
+	*/
+	virtual IDataCaptureChunk * BeginChunk() = 0;
+
+	/**
+	* IDataCapture::CommitChunk - Hands a filled chunk over to the writer thread and returns immediately. All columns MUST have the same row count. The chunk instance MUST NOT be used afterwards.
+	* @param[in] pChunkInstance - Chunk that has been returned by BeginChunk.
+	*/
+	virtual void CommitChunk(IDataCaptureChunk* pChunkInstance) = 0;
+
+	/**
+	* IDataCapture::Flush - Blocks until all committed chunks have been written to storage.
+	*/
+	virtual void Flush() = 0;
+
+	/**
+	* IDataCapture::GetCapturedRowCount - Returns the number of rows that have been committed and not dropped.
+	* @return Number of rows.
+	*/
+	virtual LibMCEnv_uint64 GetCapturedRowCount() = 0;
+
+	/**
+	* IDataCapture::GetStorageSizeInBytes - Returns the number of bytes that have been written to storage so far.
+	* @return Size in bytes.
+	*/
+	virtual LibMCEnv_uint64 GetStorageSizeInBytes() = 0;
+
+	/**
+	* IDataCapture::GetSegmentCount - Returns the number of segment streams that have been opened so far.
+	* @return Number of segments.
+	*/
+	virtual LibMCEnv_uint32 GetSegmentCount() = 0;
+
+	/**
+	* IDataCapture::GetQueuedChunkCount - Returns the number of committed chunks that are waiting for the writer thread.
+	* @return Number of queued chunks.
+	*/
+	virtual LibMCEnv_uint32 GetQueuedChunkCount() = 0;
+
+	/**
+	* IDataCapture::GetDroppedRowCount - Returns the number of rows that have been discarded by the DropOldest backpressure mode.
+	* @return Number of dropped rows.
+	*/
+	virtual LibMCEnv_uint64 GetDroppedRowCount() = 0;
+
+	/**
+	* IDataCapture::Finish - Writes all committed chunks, closes the last segment and marks the capture as finished. Fails if a chunk is uncommitted.
+	* @return UUID of the capture.
+	*/
+	virtual std::string Finish() = 0;
+
+	/**
+	* IDataCapture::Abort - Stops the capture and deletes all its segments.
+	*/
+	virtual void Abort() = 0;
+
+	/**
+	* IDataCapture::AddColumnsFromDataTable - Adds one column to the capture for every column of a data table, with the same identifier, description and type and in the same order. Fails if the schema is frozen or an identifier already exists.
+	* @param[in] pDataTable - Data table whose columns describe the schema. Its rows are not read.
+	*/
+	virtual void AddColumnsFromDataTable(IDataTable* pDataTable) = 0;
+
+	/**
+	* IDataCapture::AppendDataTable - Appends all rows of a data table to the capture and splits them into chunks. Every column of the capture MUST exist in the table with the same identifier and type, and these columns MUST have the same row count. Further columns of the table are ignored. Freezes the schema on the first call. If no chunk is free, the backpressure mode of the capture applies. Fails if a chunk is uncommitted.
+	* @param[in] pDataTable - Data table that holds the rows to append.
+	* @return Number of rows that have been appended.
+	*/
+	virtual LibMCEnv_uint64 AppendDataTable(IDataTable* pDataTable) = 0;
+
+};
+
+typedef IBaseSharedPtr<IDataCapture> PIDataCapture;
+
+
+/*************************************************************************************************************************
+ Class interface for DataTableReader 
+**************************************************************************************************************************/
+
+class IDataTableReader : public virtual IBase {
+public:
+	/**
+	* IDataTableReader::GetRowCount - Returns the number of rows of the capture, including rows in segments that have been deleted by retention.
+	* @return Number of rows.
+	*/
+	virtual LibMCEnv_uint64 GetRowCount() = 0;
+
+	/**
+	* IDataTableReader::GetFirstAvailableRow - Returns the index of the first row that is still stored. Rows before it have been deleted by retention.
+	* @return Row index. Equal to the row count if nothing is stored.
+	*/
+	virtual LibMCEnv_uint64 GetFirstAvailableRow() = 0;
+
+	/**
+	* IDataTableReader::GetColumnCount - Returns the number of columns.
+	* @return Number of columns.
+	*/
+	virtual LibMCEnv_uint32 GetColumnCount() = 0;
+
+	/**
+	* IDataTableReader::HasColumn - Returns if a column exists.
+	* @param[in] sIdentifier - Identifier of the column.
+	* @return Returns if the column exists.
+	*/
+	virtual bool HasColumn(const std::string & sIdentifier) = 0;
+
+	/**
+	* IDataTableReader::GetColumnInformation - Returns the schema information of a column. Fails if the index is out of bounds.
+	* @param[in] nColumnIndex - Index of column. 0-based.
+	* @param[out] sIdentifier - Identifier of the column.
+	* @param[out] sDescription - Description of the column.
+	* @param[out] eColumnType - Data type of the column.
+	*/
+	virtual void GetColumnInformation(const LibMCEnv_uint32 nColumnIndex, std::string & sIdentifier, std::string & sDescription, LibMCEnv::eDataTableColumnType & eColumnType) = 0;
+
+	/**
+	* IDataTableReader::GetColumnQuantization - Returns the quantisation step of a column. Values of a quantised column are exact to half a step.
+	* @param[in] sIdentifier - Identifier of the column.
+	* @return Quantisation step. 0 if the column is not quantised.
+	*/
+	virtual LibMCEnv_double GetColumnQuantization(const std::string & sIdentifier) = 0;
+
+	/**
+	* IDataTableReader::GetSegmentCount - Returns the number of segments of the capture, including deleted ones.
+	* @return Number of segments.
+	*/
+	virtual LibMCEnv_uint32 GetSegmentCount() = 0;
+
+	/**
+	* IDataTableReader::GetSegmentInformation - Returns the row range and the size of a segment. Fails if the index is out of bounds.
+	* @param[in] nSegmentIndex - Index of the segment. 0-based.
+	* @param[out] nFirstRow - Index of the first row of the segment.
+	* @param[out] nRowCount - Number of rows in the segment.
+	* @param[out] nSizeInBytes - Size of the segment stream in bytes.
+	* @param[out] bIsAvailable - Returns false if the segment has been deleted by retention.
+	*/
+	virtual void GetSegmentInformation(const LibMCEnv_uint32 nSegmentIndex, LibMCEnv_uint64 & nFirstRow, LibMCEnv_uint64 & nRowCount, LibMCEnv_uint64 & nSizeInBytes, bool & bIsAvailable) = 0;
+
+	/**
+	* IDataTableReader::GetChunkCount - Returns the number of chunks of the capture, including chunks in deleted segments.
+	* @return Number of chunks.
+	*/
+	virtual LibMCEnv_uint64 GetChunkCount() = 0;
+
+	/**
+	* IDataTableReader::GetChunkInformation - Returns the position of a chunk. Fails if the index is out of bounds.
+	* @param[in] nChunkIndex - Index of the chunk. 0-based.
+	* @param[out] nSegmentIndex - Index of the segment that holds the chunk.
+	* @param[out] nFirstRow - Index of the first row of the chunk. For a chunk in a deleted segment this is the first row of the segment.
+	* @param[out] nRowCount - Number of rows in the chunk. 0 for a chunk in a deleted segment.
+	* @param[out] bIsAvailable - Returns false if the chunk has been deleted by retention.
+	*/
+	virtual void GetChunkInformation(const LibMCEnv_uint64 nChunkIndex, LibMCEnv_uint32 & nSegmentIndex, LibMCEnv_uint64 & nFirstRow, LibMCEnv_uint64 & nRowCount, bool & bIsAvailable) = 0;
+
+	/**
+	* IDataTableReader::GetChunkStatistics - Returns the minimum and maximum of a column in a chunk from the page directory, without reading the chunk.
+	* @param[in] nChunkIndex - Index of the chunk. 0-based.
+	* @param[in] sIdentifier - Identifier of the column.
+	* @param[out] dMinValue - Minimum value of the column in the chunk.
+	* @param[out] dMaxValue - Maximum value of the column in the chunk.
+	* @return Returns false if the chunk has been deleted or holds no comparable value.
+	*/
+	virtual bool GetChunkStatistics(const LibMCEnv_uint64 nChunkIndex, const std::string & sIdentifier, LibMCEnv_double & dMinValue, LibMCEnv_double & dMaxValue) = 0;
+
+	/**
+	* IDataTableReader::ReadDoubleColumnRange - Reads a row range of a column as doubles. Works for every column type. Only the pages that overlap the range are read.
+	* @param[in] sIdentifier - Identifier of the column.
+	* @param[in] nFromRow - Index of the first row to read.
+	* @param[in] nRowCount - Number of rows to read.
+	* @param[in] nValuesBufferSize - Number of elements in buffer
+	* @param[out] pValuesNeededCount - will be filled with the count of the written structs, or needed buffer size.
+	* @param[out] pValuesBuffer - double buffer of Values of the row range.
+	*/
+	virtual void ReadDoubleColumnRange(const std::string & sIdentifier, const LibMCEnv_uint64 nFromRow, const LibMCEnv_uint64 nRowCount, LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_double * pValuesBuffer) = 0;
+
+	/**
+	* IDataTableReader::ReadFloatColumnRange - Reads a row range of a float or double column as floats.
+	* @param[in] sIdentifier - Identifier of the column.
+	* @param[in] nFromRow - Index of the first row to read.
+	* @param[in] nRowCount - Number of rows to read.
+	* @param[in] nValuesBufferSize - Number of elements in buffer
+	* @param[out] pValuesNeededCount - will be filled with the count of the written structs, or needed buffer size.
+	* @param[out] pValuesBuffer - single buffer of Values of the row range.
+	*/
+	virtual void ReadFloatColumnRange(const std::string & sIdentifier, const LibMCEnv_uint64 nFromRow, const LibMCEnv_uint64 nRowCount, LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_single * pValuesBuffer) = 0;
+
+	/**
+	* IDataTableReader::ReadInt64ColumnRange - Reads a row range of an integer, bool or timestamp column as 64 bit integers.
+	* @param[in] sIdentifier - Identifier of the column.
+	* @param[in] nFromRow - Index of the first row to read.
+	* @param[in] nRowCount - Number of rows to read.
+	* @param[in] nValuesBufferSize - Number of elements in buffer
+	* @param[out] pValuesNeededCount - will be filled with the count of the written structs, or needed buffer size.
+	* @param[out] pValuesBuffer - int64 buffer of Values of the row range.
+	*/
+	virtual void ReadInt64ColumnRange(const std::string & sIdentifier, const LibMCEnv_uint64 nFromRow, const LibMCEnv_uint64 nRowCount, LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_int64 * pValuesBuffer) = 0;
+
+	/**
+	* IDataTableReader::ReadBoolColumnRange - Reads a row range of a bool column as bytes (0 = false, 1 = true).
+	* @param[in] sIdentifier - Identifier of the column.
+	* @param[in] nFromRow - Index of the first row to read.
+	* @param[in] nRowCount - Number of rows to read.
+	* @param[in] nValuesBufferSize - Number of elements in buffer
+	* @param[out] pValuesNeededCount - will be filled with the count of the written structs, or needed buffer size.
+	* @param[out] pValuesBuffer - uint8 buffer of Values of the row range.
+	*/
+	virtual void ReadBoolColumnRange(const std::string & sIdentifier, const LibMCEnv_uint64 nFromRow, const LibMCEnv_uint64 nRowCount, LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_uint8 * pValuesBuffer) = 0;
+
+	/**
+	* IDataTableReader::ReadColumnDownsampled - Reduces a row range of a column to at most TargetPoints buckets without materialising the range. Stride returns the first value of each bucket, Average the mean and MinMax the minimum followed by the maximum of each bucket, which preserves the envelope of the signal.
+	* @param[in] sIdentifier - Identifier of the column.
+	* @param[in] nFromRow - Index of the first row of the range.
+	* @param[in] nRowCount - Number of rows of the range.
+	* @param[in] nTargetPoints - Maximum number of buckets. MUST be positive.
+	* @param[in] eMode - Stride, MinMax or Average.
+	* @param[in] nValuesBufferSize - Number of elements in buffer
+	* @param[out] pValuesNeededCount - will be filled with the count of the written structs, or needed buffer size.
+	* @param[out] pValuesBuffer - double buffer of One value per bucket, or two values per bucket in MinMax mode. The number of buckets is the smaller of TargetPoints and RowCount.
+	*/
+	virtual void ReadColumnDownsampled(const std::string & sIdentifier, const LibMCEnv_uint64 nFromRow, const LibMCEnv_uint64 nRowCount, const LibMCEnv_uint32 nTargetPoints, const LibMCEnv::eDataTableDownsampleMode eMode, LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_double * pValuesBuffer) = 0;
+
+	/**
+	* IDataTableReader::FindChunksInValueRange - Finds the chunks whose value range of a column overlaps a given range. Only the page directory is used, no chunk is read.
+	* @param[in] sIdentifier - Identifier of the column.
+	* @param[in] dMinValue - Lower bound of the value range.
+	* @param[in] dMaxValue - Upper bound of the value range.
+	* @param[in] nChunkIndicesBufferSize - Number of elements in buffer
+	* @param[out] pChunkIndicesNeededCount - will be filled with the count of the written structs, or needed buffer size.
+	* @param[out] pChunkIndicesBuffer - uint64 buffer of Indices of the chunks that may hold a value in the range.
+	*/
+	virtual void FindChunksInValueRange(const std::string & sIdentifier, const LibMCEnv_double dMinValue, const LibMCEnv_double dMaxValue, LibMCEnv_uint64 nChunkIndicesBufferSize, LibMCEnv_uint64* pChunkIndicesNeededCount, LibMCEnv_uint64 * pChunkIndicesBuffer) = 0;
+
+	/**
+	* IDataTableReader::ExtractDataTable - Materialises a row range as an ordinary in-memory data table.
+	* @param[in] nFromRow - Index of the first row of the range.
+	* @param[in] nRowCount - Number of rows of the range.
+	* @param[in] sColumnIdentifiers - Comma separated identifiers of the columns to extract. An empty string extracts all columns.
+	* @return Data table instance.
+	*/
+	virtual IDataTable * ExtractDataTable(const LibMCEnv_uint64 nFromRow, const LibMCEnv_uint64 nRowCount, const std::string & sColumnIdentifiers) = 0;
+
+};
+
+typedef IBaseSharedPtr<IDataTableReader> PIDataTableReader;
+
+
 /*************************************************************************************************************************
  Class interface for DataSeries 
 **************************************************************************************************************************/
@@ -3628,6 +4194,58 @@ class IBuildExecution : public virtual IBase {
 	*/
 	virtual IJournalHandler * LoadAttachedJournal(const LibMCEnv_uint32 nCacheMemoryQuotaInMegabytes) = 0;
 
+	/**
+	* IBuildExecution::CreateDataCaptureOptions - Creates an options object for a data capture with default values.
+	* @return Data capture options instance.
+	*/
+	virtual IDataCaptureOptions * CreateDataCaptureOptions() = 0;
+
+	/**
+	* IBuildExecution::CreateDataCapture - Creates a streaming data capture in this build execution. The execution MUST be in process.
+	* @param[in] sIdentifier - Unique identifier of the capture in this execution. Fails if the identifier already exists or is invalid.
+	* @param[in] sName - Human readable name of the capture.
+	* @param[in] pOptions - Data capture options. Defaults are used if not given.
+	* @param[in] sUserUUID - User UUID of the user that this data comes from. Empty string means no user attached.
+	* @return Data capture instance.
+	*/
+	virtual IDataCapture * CreateDataCapture(const std::string & sIdentifier, const std::string & sName, IDataCaptureOptions* pOptions, const std::string & sUserUUID) = 0;
+
+	/**
+	* IBuildExecution::HasDataCapture - Returns if the execution has a data capture with a certain identifier.
+	* @param[in] sIdentifier - Identifier of the capture.
+	* @return Returns true if the capture exists.
+	*/
+	virtual bool HasDataCapture(const std::string & sIdentifier) = 0;
+
+	/**
+	* IBuildExecution::GetDataCaptureRowCount - Returns the number of rows of a data capture that have been stored in segments. Fails if the capture does not exist.
+	* @param[in] sIdentifier - Identifier of the capture.
+	* @return Number of rows.
+	*/
+	virtual LibMCEnv_uint64 GetDataCaptureRowCount(const std::string & sIdentifier) = 0;
+
+	/**
+	* IBuildExecution::GetDataCaptureSegmentCount - Returns the number of stored segments of a data capture. Fails if the capture does not exist.
+	* @param[in] sIdentifier - Identifier of the capture.
+	* @return Number of segments.
+	*/
+	virtual LibMCEnv_uint32 GetDataCaptureSegmentCount(const std::string & sIdentifier) = 0;
+
+	/**
+	* IBuildExecution::LoadDataCaptureSegment - Loads one segment of a data capture as in-memory data table. Fails if the capture or the segment does not exist or the segment has been deleted by retention.
+	* @param[in] sIdentifier - Identifier of the capture.
+	* @param[in] nSegmentIndex - Index of the segment. 0-based.
+	* @return Loaded data table instance.
+	*/
+	virtual IDataTable * LoadDataCaptureSegment(const std::string & sIdentifier, const LibMCEnv_uint32 nSegmentIndex) = 0;
+
+	/**
+	* IBuildExecution::OpenDataCaptureReader - Opens a reader on the stored segments of a data capture. Fails if the capture does not exist.
+	* @param[in] sIdentifier - Identifier of the capture.
+	* @return Reader instance.
+	*/
+	virtual IDataTableReader * OpenDataCaptureReader(const std::string & sIdentifier) = 0;
+
 };
 
 typedef IBaseSharedPtr<IBuildExecution> PIBuildExecution;
@@ -6411,6 +7029,11 @@ class IZIPStreamWriter : public virtual IBaseTempStreamWriter {
 	*/
 	virtual void CreateZIPEntryFromStream(const std::string & sFileName, IStreamReader* pStreamReader) = 0;
 
+	/**
+	* IZIPStreamWriter::Discard - Discards the unfinished ZIP stream. The file on disk and the stream entry are deleted. Fails if the stream has been finished already. A ZIP writer that is released without Finish is discarded automatically.
+	*/
+	virtual void Discard() = 0;
+
 };
 
 typedef IBaseSharedPtr<IZIPStreamWriter> PIZIPStreamWriter;
@@ -8713,6 +9336,47 @@ class IStateEnvironment : public virtual IBase {
 	*/
 	virtual bool EvaluateFormulaAsBool(const std::string & sFormula) = 0;
 
+	/**
+	* IStateEnvironment::StartStreamDownloadForSession - Starts a stream download in the browser of a client session. Creates a download ticket for the user of the session and queues the download action for delivery to the session. Returns false if the session does not exist or is not authorized.
+	* @param[in] sSessionUUID - UUID of the client session.
+	* @param[in] sStreamUUID - Storage stream. Fails if the stream does not exist or is not finished.
+	* @param[in] sFileName - File name offered to the browser. Fails if empty.
+	* @return True if the download action was queued for the session.
+	*/
+	virtual bool StartStreamDownloadForSession(const std::string & sSessionUUID, const std::string & sStreamUUID, const std::string & sFileName) = 0;
+
+	/**
+	* IStateEnvironment::GetStreamDownloadProgress - Returns the delivery progress of all downloads of a storage stream.
+	* @param[in] sStreamUUID - Storage stream.
+	* @param[out] nActiveConnections - Connections that are sending the stream right now.
+	* @param[out] nDeliveredBytes - Bytes from the start of the stream that were sent without a gap.
+	* @param[out] nTotalBytes - Size of the stream.
+	* @param[out] bCompleted - The last byte was sent and its connection ended successfully.
+	* @param[out] nMillisecondsSinceActivity - Time since the last chunk was sent or since the download was handed over.
+	*/
+	virtual void GetStreamDownloadProgress(const std::string & sStreamUUID, LibMCEnv_uint32 & nActiveConnections, LibMCEnv_uint64 & nDeliveredBytes, LibMCEnv_uint64 & nTotalBytes, bool & bCompleted, LibMCEnv_uint64 & nMillisecondsSinceActivity) = 0;
+
+	/**
+	* IStateEnvironment::CancelStreamDownloads - Stops all running downloads of a storage stream, revokes its download tickets and drops its unclaimed download actions. Does nothing if the stream was already delivered completely.
+	* @param[in] sStreamUUID - Storage stream.
+	* @return False if the download had already completed and nothing was cancelled.
+	*/
+	virtual bool CancelStreamDownloads(const std::string & sStreamUUID) = 0;
+
+	/**
+	* IStateEnvironment::DeleteStorageStream - Deletes a finished storage stream from disk and database, including its download tickets. Fails if the stream does not exist, is still being written or is being downloaded right now.
+	* @param[in] sUUID - UUID of the storage stream.
+	*/
+	virtual void DeleteStorageStream(const std::string & sUUID) = 0;
+
+	/**
+	* IStateEnvironment::EnforceStreamRetention - Deletes all finished streams with the given name except the newest ones. Streams with running downloads or pending download actions are kept. Returns the number of deleted streams.
+	* @param[in] sName - Name of the streams.
+	* @param[in] nKeepCount - Number of newest streams to keep.
+	* @return Number of deleted streams.
+	*/
+	virtual LibMCEnv_uint32 EnforceStreamRetention(const std::string & sName, const LibMCEnv_uint32 nKeepCount) = 0;
+
 };
 
 typedef IBaseSharedPtr<IStateEnvironment> PIStateEnvironment;
diff --git a/Framework/InterfacesCore/libmcenv_interfacewrapper.cpp b/Framework/InterfacesCore/libmcenv_interfacewrapper.cpp
index d74d30a87..c8135cb39 100644
--- a/Framework/InterfacesCore/libmcenv_interfacewrapper.cpp
+++ b/Framework/InterfacesCore/libmcenv_interfacewrapper.cpp
@@ -3652,6 +3652,32 @@ LibMCEnvResult libmcenv_datatable_getrowcount(LibMCEnv_DataTable pDataTable, Lib
 	}
 }
 
+LibMCEnvResult libmcenv_datatable_getrowcount64(LibMCEnv_DataTable pDataTable, LibMCEnv_uint64 * pRowCount)
+{
+	IBase* pIBaseClass = (IBase *)pDataTable;
+
+	try {
+		if (pRowCount == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		IDataTable* pIDataTable = dynamic_cast<IDataTable*>(pIBaseClass);
+		if (!pIDataTable)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		*pRowCount = pIDataTable->GetRowCount64();
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
 LibMCEnvResult libmcenv_datatable_getcolumncount(LibMCEnv_DataTable pDataTable, LibMCEnv_uint32 * pColumnCount)
 {
 	IBase* pIBaseClass = (IBase *)pDataTable;
@@ -3998,6 +4024,93 @@ LibMCEnvResult libmcenv_datatable_getuint64columnvalues(LibMCEnv_DataTable pData
 	}
 }
 
+LibMCEnvResult libmcenv_datatable_getfloatcolumnvalues(LibMCEnv_DataTable pDataTable, const char * pIdentifier, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_single * pValuesBuffer)
+{
+	IBase* pIBaseClass = (IBase *)pDataTable;
+
+	try {
+		if (pIdentifier == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if ((!pValuesBuffer) && !(pValuesNeededCount))
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		std::string sIdentifier(pIdentifier);
+		IDataTable* pIDataTable = dynamic_cast<IDataTable*>(pIBaseClass);
+		if (!pIDataTable)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIDataTable->GetFloatColumnValues(sIdentifier, nValuesBufferSize, pValuesNeededCount, pValuesBuffer);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datatable_getboolcolumnvalues(LibMCEnv_DataTable pDataTable, const char * pIdentifier, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_uint8 * pValuesBuffer)
+{
+	IBase* pIBaseClass = (IBase *)pDataTable;
+
+	try {
+		if (pIdentifier == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if ((!pValuesBuffer) && !(pValuesNeededCount))
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		std::string sIdentifier(pIdentifier);
+		IDataTable* pIDataTable = dynamic_cast<IDataTable*>(pIBaseClass);
+		if (!pIDataTable)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIDataTable->GetBoolColumnValues(sIdentifier, nValuesBufferSize, pValuesNeededCount, pValuesBuffer);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datatable_gettimestampcolumnvalues(LibMCEnv_DataTable pDataTable, const char * pIdentifier, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_uint64 * pValuesBuffer)
+{
+	IBase* pIBaseClass = (IBase *)pDataTable;
+
+	try {
+		if (pIdentifier == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if ((!pValuesBuffer) && !(pValuesNeededCount))
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		std::string sIdentifier(pIdentifier);
+		IDataTable* pIDataTable = dynamic_cast<IDataTable*>(pIBaseClass);
+		if (!pIDataTable)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIDataTable->GetTimestampColumnValues(sIdentifier, nValuesBufferSize, pValuesNeededCount, pValuesBuffer);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
 LibMCEnvResult libmcenv_datatable_setdoublecolumnvalues(LibMCEnv_DataTable pDataTable, const char * pIdentifier, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_double * pValuesBuffer)
 {
 	IBase* pIBaseClass = (IBase *)pDataTable;
@@ -4143,6 +4256,93 @@ LibMCEnvResult libmcenv_datatable_setuint64columnvalues(LibMCEnv_DataTable pData
 	}
 }
 
+LibMCEnvResult libmcenv_datatable_setfloatcolumnvalues(LibMCEnv_DataTable pDataTable, const char * pIdentifier, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_single * pValuesBuffer)
+{
+	IBase* pIBaseClass = (IBase *)pDataTable;
+
+	try {
+		if (pIdentifier == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if ( (!pValuesBuffer) && (nValuesBufferSize>0))
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		std::string sIdentifier(pIdentifier);
+		IDataTable* pIDataTable = dynamic_cast<IDataTable*>(pIBaseClass);
+		if (!pIDataTable)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIDataTable->SetFloatColumnValues(sIdentifier, nValuesBufferSize, pValuesBuffer);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datatable_setboolcolumnvalues(LibMCEnv_DataTable pDataTable, const char * pIdentifier, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint8 * pValuesBuffer)
+{
+	IBase* pIBaseClass = (IBase *)pDataTable;
+
+	try {
+		if (pIdentifier == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if ( (!pValuesBuffer) && (nValuesBufferSize>0))
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		std::string sIdentifier(pIdentifier);
+		IDataTable* pIDataTable = dynamic_cast<IDataTable*>(pIBaseClass);
+		if (!pIDataTable)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIDataTable->SetBoolColumnValues(sIdentifier, nValuesBufferSize, pValuesBuffer);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datatable_settimestampcolumnvalues(LibMCEnv_DataTable pDataTable, const char * pIdentifier, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint64 * pValuesBuffer)
+{
+	IBase* pIBaseClass = (IBase *)pDataTable;
+
+	try {
+		if (pIdentifier == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if ( (!pValuesBuffer) && (nValuesBufferSize>0))
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		std::string sIdentifier(pIdentifier);
+		IDataTable* pIDataTable = dynamic_cast<IDataTable*>(pIBaseClass);
+		if (!pIDataTable)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIDataTable->SetTimestampColumnValues(sIdentifier, nValuesBufferSize, pValuesBuffer);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
 LibMCEnvResult libmcenv_datatable_createwriteoptions(LibMCEnv_DataTable pDataTable, LibMCEnv_DataTableWriteOptions * pOptions)
 {
 	IBase* pIBaseClass = (IBase *)pDataTable;
@@ -4352,6 +4552,1879 @@ LibMCEnvResult libmcenv_datatable_calculatescatterplot(LibMCEnv_DataTable pDataT
 }
 
 
+/*************************************************************************************************************************
+ Class implementation for DataCaptureOptions
+**************************************************************************************************************************/
+LibMCEnvResult libmcenv_datacaptureoptions_setchunkrowcount(LibMCEnv_DataCaptureOptions pDataCaptureOptions, LibMCEnv_uint32 nChunkRowCount)
+{
+	IBase* pIBaseClass = (IBase *)pDataCaptureOptions;
+
+	try {
+		IDataCaptureOptions* pIDataCaptureOptions = dynamic_cast<IDataCaptureOptions*>(pIBaseClass);
+		if (!pIDataCaptureOptions)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIDataCaptureOptions->SetChunkRowCount(nChunkRowCount);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacaptureoptions_getchunkrowcount(LibMCEnv_DataCaptureOptions pDataCaptureOptions, LibMCEnv_uint32 * pChunkRowCount)
+{
+	IBase* pIBaseClass = (IBase *)pDataCaptureOptions;
+
+	try {
+		if (pChunkRowCount == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		IDataCaptureOptions* pIDataCaptureOptions = dynamic_cast<IDataCaptureOptions*>(pIBaseClass);
+		if (!pIDataCaptureOptions)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		*pChunkRowCount = pIDataCaptureOptions->GetChunkRowCount();
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacaptureoptions_setsegmentsizeinbytes(LibMCEnv_DataCaptureOptions pDataCaptureOptions, LibMCEnv_uint64 nSegmentSizeInBytes)
+{
+	IBase* pIBaseClass = (IBase *)pDataCaptureOptions;
+
+	try {
+		IDataCaptureOptions* pIDataCaptureOptions = dynamic_cast<IDataCaptureOptions*>(pIBaseClass);
+		if (!pIDataCaptureOptions)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIDataCaptureOptions->SetSegmentSizeInBytes(nSegmentSizeInBytes);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacaptureoptions_getsegmentsizeinbytes(LibMCEnv_DataCaptureOptions pDataCaptureOptions, LibMCEnv_uint64 * pSegmentSizeInBytes)
+{
+	IBase* pIBaseClass = (IBase *)pDataCaptureOptions;
+
+	try {
+		if (pSegmentSizeInBytes == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		IDataCaptureOptions* pIDataCaptureOptions = dynamic_cast<IDataCaptureOptions*>(pIBaseClass);
+		if (!pIDataCaptureOptions)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		*pSegmentSizeInBytes = pIDataCaptureOptions->GetSegmentSizeInBytes();
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacaptureoptions_setmaxqueuedchunks(LibMCEnv_DataCaptureOptions pDataCaptureOptions, LibMCEnv_uint32 nMaxQueuedChunks)
+{
+	IBase* pIBaseClass = (IBase *)pDataCaptureOptions;
+
+	try {
+		IDataCaptureOptions* pIDataCaptureOptions = dynamic_cast<IDataCaptureOptions*>(pIBaseClass);
+		if (!pIDataCaptureOptions)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIDataCaptureOptions->SetMaxQueuedChunks(nMaxQueuedChunks);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacaptureoptions_getmaxqueuedchunks(LibMCEnv_DataCaptureOptions pDataCaptureOptions, LibMCEnv_uint32 * pMaxQueuedChunks)
+{
+	IBase* pIBaseClass = (IBase *)pDataCaptureOptions;
+
+	try {
+		if (pMaxQueuedChunks == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		IDataCaptureOptions* pIDataCaptureOptions = dynamic_cast<IDataCaptureOptions*>(pIBaseClass);
+		if (!pIDataCaptureOptions)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		*pMaxQueuedChunks = pIDataCaptureOptions->GetMaxQueuedChunks();
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacaptureoptions_setbackpressuremode(LibMCEnv_DataCaptureOptions pDataCaptureOptions, eLibMCEnvDataCaptureBackpressureMode eBackpressureMode)
+{
+	IBase* pIBaseClass = (IBase *)pDataCaptureOptions;
+
+	try {
+		IDataCaptureOptions* pIDataCaptureOptions = dynamic_cast<IDataCaptureOptions*>(pIBaseClass);
+		if (!pIDataCaptureOptions)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIDataCaptureOptions->SetBackpressureMode(eBackpressureMode);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacaptureoptions_getbackpressuremode(LibMCEnv_DataCaptureOptions pDataCaptureOptions, eLibMCEnvDataCaptureBackpressureMode * pBackpressureMode)
+{
+	IBase* pIBaseClass = (IBase *)pDataCaptureOptions;
+
+	try {
+		if (pBackpressureMode == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		IDataCaptureOptions* pIDataCaptureOptions = dynamic_cast<IDataCaptureOptions*>(pIBaseClass);
+		if (!pIDataCaptureOptions)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		*pBackpressureMode = pIDataCaptureOptions->GetBackpressureMode();
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacaptureoptions_setstoragelimitinbytes(LibMCEnv_DataCaptureOptions pDataCaptureOptions, LibMCEnv_uint64 nStorageLimitInBytes)
+{
+	IBase* pIBaseClass = (IBase *)pDataCaptureOptions;
+
+	try {
+		IDataCaptureOptions* pIDataCaptureOptions = dynamic_cast<IDataCaptureOptions*>(pIBaseClass);
+		if (!pIDataCaptureOptions)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIDataCaptureOptions->SetStorageLimitInBytes(nStorageLimitInBytes);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacaptureoptions_getstoragelimitinbytes(LibMCEnv_DataCaptureOptions pDataCaptureOptions, LibMCEnv_uint64 * pStorageLimitInBytes)
+{
+	IBase* pIBaseClass = (IBase *)pDataCaptureOptions;
+
+	try {
+		if (pStorageLimitInBytes == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		IDataCaptureOptions* pIDataCaptureOptions = dynamic_cast<IDataCaptureOptions*>(pIBaseClass);
+		if (!pIDataCaptureOptions)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		*pStorageLimitInBytes = pIDataCaptureOptions->GetStorageLimitInBytes();
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacaptureoptions_setcompression(LibMCEnv_DataCaptureOptions pDataCaptureOptions, eLibMCEnvDataCaptureCompression eCompression)
+{
+	IBase* pIBaseClass = (IBase *)pDataCaptureOptions;
+
+	try {
+		IDataCaptureOptions* pIDataCaptureOptions = dynamic_cast<IDataCaptureOptions*>(pIBaseClass);
+		if (!pIDataCaptureOptions)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIDataCaptureOptions->SetCompression(eCompression);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacaptureoptions_getcompression(LibMCEnv_DataCaptureOptions pDataCaptureOptions, eLibMCEnvDataCaptureCompression * pCompression)
+{
+	IBase* pIBaseClass = (IBase *)pDataCaptureOptions;
+
+	try {
+		if (pCompression == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		IDataCaptureOptions* pIDataCaptureOptions = dynamic_cast<IDataCaptureOptions*>(pIBaseClass);
+		if (!pIDataCaptureOptions)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		*pCompression = pIDataCaptureOptions->GetCompression();
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacaptureoptions_setcolumnencoding(LibMCEnv_DataCaptureOptions pDataCaptureOptions, const char * pColumnIdentifier, eLibMCEnvDataCaptureEncoding eEncoding)
+{
+	IBase* pIBaseClass = (IBase *)pDataCaptureOptions;
+
+	try {
+		if (pColumnIdentifier == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		std::string sColumnIdentifier(pColumnIdentifier);
+		IDataCaptureOptions* pIDataCaptureOptions = dynamic_cast<IDataCaptureOptions*>(pIBaseClass);
+		if (!pIDataCaptureOptions)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIDataCaptureOptions->SetColumnEncoding(sColumnIdentifier, eEncoding);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacaptureoptions_setdoublequantization(LibMCEnv_DataCaptureOptions pDataCaptureOptions, const char * pColumnIdentifier, LibMCEnv_double dStep)
+{
+	IBase* pIBaseClass = (IBase *)pDataCaptureOptions;
+
+	try {
+		if (pColumnIdentifier == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		std::string sColumnIdentifier(pColumnIdentifier);
+		IDataCaptureOptions* pIDataCaptureOptions = dynamic_cast<IDataCaptureOptions*>(pIBaseClass);
+		if (!pIDataCaptureOptions)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIDataCaptureOptions->SetDoubleQuantization(sColumnIdentifier, dStep);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+
+/*************************************************************************************************************************
+ Class implementation for DataCaptureChunk
+**************************************************************************************************************************/
+LibMCEnvResult libmcenv_datacapturechunk_getcapacity(LibMCEnv_DataCaptureChunk pDataCaptureChunk, LibMCEnv_uint32 * pCapacity)
+{
+	IBase* pIBaseClass = (IBase *)pDataCaptureChunk;
+
+	try {
+		if (pCapacity == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		IDataCaptureChunk* pIDataCaptureChunk = dynamic_cast<IDataCaptureChunk*>(pIBaseClass);
+		if (!pIDataCaptureChunk)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		*pCapacity = pIDataCaptureChunk->GetCapacity();
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacapturechunk_getrowcount(LibMCEnv_DataCaptureChunk pDataCaptureChunk, LibMCEnv_uint32 * pRowCount)
+{
+	IBase* pIBaseClass = (IBase *)pDataCaptureChunk;
+
+	try {
+		if (pRowCount == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		IDataCaptureChunk* pIDataCaptureChunk = dynamic_cast<IDataCaptureChunk*>(pIBaseClass);
+		if (!pIDataCaptureChunk)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		*pRowCount = pIDataCaptureChunk->GetRowCount();
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacapturechunk_isfull(LibMCEnv_DataCaptureChunk pDataCaptureChunk, bool * pFull)
+{
+	IBase* pIBaseClass = (IBase *)pDataCaptureChunk;
+
+	try {
+		if (pFull == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		IDataCaptureChunk* pIDataCaptureChunk = dynamic_cast<IDataCaptureChunk*>(pIBaseClass);
+		if (!pIDataCaptureChunk)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		*pFull = pIDataCaptureChunk->IsFull();
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacapturechunk_setdoublecolumnvalues(LibMCEnv_DataCaptureChunk pDataCaptureChunk, LibMCEnv_uint32 nColumnIndex, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_double * pValuesBuffer)
+{
+	IBase* pIBaseClass = (IBase *)pDataCaptureChunk;
+
+	try {
+		if ( (!pValuesBuffer) && (nValuesBufferSize>0))
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		IDataCaptureChunk* pIDataCaptureChunk = dynamic_cast<IDataCaptureChunk*>(pIBaseClass);
+		if (!pIDataCaptureChunk)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIDataCaptureChunk->SetDoubleColumnValues(nColumnIndex, nValuesBufferSize, pValuesBuffer);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacapturechunk_setint32columnvalues(LibMCEnv_DataCaptureChunk pDataCaptureChunk, LibMCEnv_uint32 nColumnIndex, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_int32 * pValuesBuffer)
+{
+	IBase* pIBaseClass = (IBase *)pDataCaptureChunk;
+
+	try {
+		if ( (!pValuesBuffer) && (nValuesBufferSize>0))
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		IDataCaptureChunk* pIDataCaptureChunk = dynamic_cast<IDataCaptureChunk*>(pIBaseClass);
+		if (!pIDataCaptureChunk)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIDataCaptureChunk->SetInt32ColumnValues(nColumnIndex, nValuesBufferSize, pValuesBuffer);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacapturechunk_setuint32columnvalues(LibMCEnv_DataCaptureChunk pDataCaptureChunk, LibMCEnv_uint32 nColumnIndex, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint32 * pValuesBuffer)
+{
+	IBase* pIBaseClass = (IBase *)pDataCaptureChunk;
+
+	try {
+		if ( (!pValuesBuffer) && (nValuesBufferSize>0))
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		IDataCaptureChunk* pIDataCaptureChunk = dynamic_cast<IDataCaptureChunk*>(pIBaseClass);
+		if (!pIDataCaptureChunk)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIDataCaptureChunk->SetUint32ColumnValues(nColumnIndex, nValuesBufferSize, pValuesBuffer);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacapturechunk_setint64columnvalues(LibMCEnv_DataCaptureChunk pDataCaptureChunk, LibMCEnv_uint32 nColumnIndex, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_int64 * pValuesBuffer)
+{
+	IBase* pIBaseClass = (IBase *)pDataCaptureChunk;
+
+	try {
+		if ( (!pValuesBuffer) && (nValuesBufferSize>0))
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		IDataCaptureChunk* pIDataCaptureChunk = dynamic_cast<IDataCaptureChunk*>(pIBaseClass);
+		if (!pIDataCaptureChunk)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIDataCaptureChunk->SetInt64ColumnValues(nColumnIndex, nValuesBufferSize, pValuesBuffer);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacapturechunk_setuint64columnvalues(LibMCEnv_DataCaptureChunk pDataCaptureChunk, LibMCEnv_uint32 nColumnIndex, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint64 * pValuesBuffer)
+{
+	IBase* pIBaseClass = (IBase *)pDataCaptureChunk;
+
+	try {
+		if ( (!pValuesBuffer) && (nValuesBufferSize>0))
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		IDataCaptureChunk* pIDataCaptureChunk = dynamic_cast<IDataCaptureChunk*>(pIBaseClass);
+		if (!pIDataCaptureChunk)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIDataCaptureChunk->SetUint64ColumnValues(nColumnIndex, nValuesBufferSize, pValuesBuffer);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacapturechunk_setfloatcolumnvalues(LibMCEnv_DataCaptureChunk pDataCaptureChunk, LibMCEnv_uint32 nColumnIndex, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_single * pValuesBuffer)
+{
+	IBase* pIBaseClass = (IBase *)pDataCaptureChunk;
+
+	try {
+		if ( (!pValuesBuffer) && (nValuesBufferSize>0))
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		IDataCaptureChunk* pIDataCaptureChunk = dynamic_cast<IDataCaptureChunk*>(pIBaseClass);
+		if (!pIDataCaptureChunk)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIDataCaptureChunk->SetFloatColumnValues(nColumnIndex, nValuesBufferSize, pValuesBuffer);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacapturechunk_setboolcolumnvalues(LibMCEnv_DataCaptureChunk pDataCaptureChunk, LibMCEnv_uint32 nColumnIndex, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint8 * pValuesBuffer)
+{
+	IBase* pIBaseClass = (IBase *)pDataCaptureChunk;
+
+	try {
+		if ( (!pValuesBuffer) && (nValuesBufferSize>0))
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		IDataCaptureChunk* pIDataCaptureChunk = dynamic_cast<IDataCaptureChunk*>(pIBaseClass);
+		if (!pIDataCaptureChunk)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIDataCaptureChunk->SetBoolColumnValues(nColumnIndex, nValuesBufferSize, pValuesBuffer);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacapturechunk_settimestampcolumnvalues(LibMCEnv_DataCaptureChunk pDataCaptureChunk, LibMCEnv_uint32 nColumnIndex, LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint64 * pValuesBuffer)
+{
+	IBase* pIBaseClass = (IBase *)pDataCaptureChunk;
+
+	try {
+		if ( (!pValuesBuffer) && (nValuesBufferSize>0))
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		IDataCaptureChunk* pIDataCaptureChunk = dynamic_cast<IDataCaptureChunk*>(pIBaseClass);
+		if (!pIDataCaptureChunk)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIDataCaptureChunk->SetTimestampColumnValues(nColumnIndex, nValuesBufferSize, pValuesBuffer);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacapturechunk_beginrow(LibMCEnv_DataCaptureChunk pDataCaptureChunk)
+{
+	IBase* pIBaseClass = (IBase *)pDataCaptureChunk;
+
+	try {
+		IDataCaptureChunk* pIDataCaptureChunk = dynamic_cast<IDataCaptureChunk*>(pIBaseClass);
+		if (!pIDataCaptureChunk)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIDataCaptureChunk->BeginRow();
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacapturechunk_setrowdoublevalue(LibMCEnv_DataCaptureChunk pDataCaptureChunk, LibMCEnv_uint32 nColumnIndex, LibMCEnv_double dValue)
+{
+	IBase* pIBaseClass = (IBase *)pDataCaptureChunk;
+
+	try {
+		IDataCaptureChunk* pIDataCaptureChunk = dynamic_cast<IDataCaptureChunk*>(pIBaseClass);
+		if (!pIDataCaptureChunk)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIDataCaptureChunk->SetRowDoubleValue(nColumnIndex, dValue);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacapturechunk_setrowintegervalue(LibMCEnv_DataCaptureChunk pDataCaptureChunk, LibMCEnv_uint32 nColumnIndex, LibMCEnv_int64 nValue)
+{
+	IBase* pIBaseClass = (IBase *)pDataCaptureChunk;
+
+	try {
+		IDataCaptureChunk* pIDataCaptureChunk = dynamic_cast<IDataCaptureChunk*>(pIBaseClass);
+		if (!pIDataCaptureChunk)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIDataCaptureChunk->SetRowIntegerValue(nColumnIndex, nValue);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacapturechunk_endrow(LibMCEnv_DataCaptureChunk pDataCaptureChunk)
+{
+	IBase* pIBaseClass = (IBase *)pDataCaptureChunk;
+
+	try {
+		IDataCaptureChunk* pIDataCaptureChunk = dynamic_cast<IDataCaptureChunk*>(pIBaseClass);
+		if (!pIDataCaptureChunk)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIDataCaptureChunk->EndRow();
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+
+/*************************************************************************************************************************
+ Class implementation for DataCapture
+**************************************************************************************************************************/
+LibMCEnvResult libmcenv_datacapture_getuuid(LibMCEnv_DataCapture pDataCapture, const LibMCEnv_uint32 nUUIDBufferSize, LibMCEnv_uint32* pUUIDNeededChars, char * pUUIDBuffer)
+{
+	IBase* pIBaseClass = (IBase *)pDataCapture;
+
+	try {
+		if ( (!pUUIDBuffer) && !(pUUIDNeededChars) )
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		std::string sUUID("");
+		IDataCapture* pIDataCapture = dynamic_cast<IDataCapture*>(pIBaseClass);
+		if (!pIDataCapture)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		bool isCacheCall = (pUUIDBuffer == nullptr);
+		if (isCacheCall) {
+			sUUID = pIDataCapture->GetUUID();
+
+			pIDataCapture->_setCache (new ParameterCache_1<std::string> (sUUID));
+		}
+		else {
+			auto cache = dynamic_cast<ParameterCache_1<std::string>*> (pIDataCapture->_getCache ());
+			if (cache == nullptr)
+				throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+			cache->retrieveData (sUUID);
+			pIDataCapture->_setCache (nullptr);
+		}
+		
+		if (pUUIDNeededChars)
+			*pUUIDNeededChars = (LibMCEnv_uint32) (sUUID.size()+1);
+		if (pUUIDBuffer) {
+			if (sUUID.size() >= nUUIDBufferSize)
+				throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_BUFFERTOOSMALL);
+			for (size_t iUUID = 0; iUUID < sUUID.size(); iUUID++)
+				pUUIDBuffer[iUUID] = sUUID[iUUID];
+			pUUIDBuffer[sUUID.size()] = 0;
+		}
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacapture_getidentifier(LibMCEnv_DataCapture pDataCapture, const LibMCEnv_uint32 nIdentifierBufferSize, LibMCEnv_uint32* pIdentifierNeededChars, char * pIdentifierBuffer)
+{
+	IBase* pIBaseClass = (IBase *)pDataCapture;
+
+	try {
+		if ( (!pIdentifierBuffer) && !(pIdentifierNeededChars) )
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		std::string sIdentifier("");
+		IDataCapture* pIDataCapture = dynamic_cast<IDataCapture*>(pIBaseClass);
+		if (!pIDataCapture)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		bool isCacheCall = (pIdentifierBuffer == nullptr);
+		if (isCacheCall) {
+			sIdentifier = pIDataCapture->GetIdentifier();
+
+			pIDataCapture->_setCache (new ParameterCache_1<std::string> (sIdentifier));
+		}
+		else {
+			auto cache = dynamic_cast<ParameterCache_1<std::string>*> (pIDataCapture->_getCache ());
+			if (cache == nullptr)
+				throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+			cache->retrieveData (sIdentifier);
+			pIDataCapture->_setCache (nullptr);
+		}
+		
+		if (pIdentifierNeededChars)
+			*pIdentifierNeededChars = (LibMCEnv_uint32) (sIdentifier.size()+1);
+		if (pIdentifierBuffer) {
+			if (sIdentifier.size() >= nIdentifierBufferSize)
+				throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_BUFFERTOOSMALL);
+			for (size_t iIdentifier = 0; iIdentifier < sIdentifier.size(); iIdentifier++)
+				pIdentifierBuffer[iIdentifier] = sIdentifier[iIdentifier];
+			pIdentifierBuffer[sIdentifier.size()] = 0;
+		}
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacapture_getname(LibMCEnv_DataCapture pDataCapture, const LibMCEnv_uint32 nNameBufferSize, LibMCEnv_uint32* pNameNeededChars, char * pNameBuffer)
+{
+	IBase* pIBaseClass = (IBase *)pDataCapture;
+
+	try {
+		if ( (!pNameBuffer) && !(pNameNeededChars) )
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		std::string sName("");
+		IDataCapture* pIDataCapture = dynamic_cast<IDataCapture*>(pIBaseClass);
+		if (!pIDataCapture)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		bool isCacheCall = (pNameBuffer == nullptr);
+		if (isCacheCall) {
+			sName = pIDataCapture->GetName();
+
+			pIDataCapture->_setCache (new ParameterCache_1<std::string> (sName));
+		}
+		else {
+			auto cache = dynamic_cast<ParameterCache_1<std::string>*> (pIDataCapture->_getCache ());
+			if (cache == nullptr)
+				throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+			cache->retrieveData (sName);
+			pIDataCapture->_setCache (nullptr);
+		}
+		
+		if (pNameNeededChars)
+			*pNameNeededChars = (LibMCEnv_uint32) (sName.size()+1);
+		if (pNameBuffer) {
+			if (sName.size() >= nNameBufferSize)
+				throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_BUFFERTOOSMALL);
+			for (size_t iName = 0; iName < sName.size(); iName++)
+				pNameBuffer[iName] = sName[iName];
+			pNameBuffer[sName.size()] = 0;
+		}
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacapture_getstatus(LibMCEnv_DataCapture pDataCapture, eLibMCEnvDataCaptureStatus * pStatus)
+{
+	IBase* pIBaseClass = (IBase *)pDataCapture;
+
+	try {
+		if (pStatus == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		IDataCapture* pIDataCapture = dynamic_cast<IDataCapture*>(pIBaseClass);
+		if (!pIDataCapture)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		*pStatus = pIDataCapture->GetStatus();
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacapture_addcolumn(LibMCEnv_DataCapture pDataCapture, const char * pIdentifier, const char * pDescription, eLibMCEnvDataTableColumnType eColumnType)
+{
+	IBase* pIBaseClass = (IBase *)pDataCapture;
+
+	try {
+		if (pIdentifier == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if (pDescription == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		std::string sIdentifier(pIdentifier);
+		std::string sDescription(pDescription);
+		IDataCapture* pIDataCapture = dynamic_cast<IDataCapture*>(pIBaseClass);
+		if (!pIDataCapture)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIDataCapture->AddColumn(sIdentifier, sDescription, eColumnType);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacapture_getcolumncount(LibMCEnv_DataCapture pDataCapture, LibMCEnv_uint32 * pColumnCount)
+{
+	IBase* pIBaseClass = (IBase *)pDataCapture;
+
+	try {
+		if (pColumnCount == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		IDataCapture* pIDataCapture = dynamic_cast<IDataCapture*>(pIBaseClass);
+		if (!pIDataCapture)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		*pColumnCount = pIDataCapture->GetColumnCount();
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacapture_beginchunk(LibMCEnv_DataCapture pDataCapture, LibMCEnv_DataCaptureChunk * pChunkInstance)
+{
+	IBase* pIBaseClass = (IBase *)pDataCapture;
+
+	try {
+		if (pChunkInstance == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		IBase* pBaseChunkInstance(nullptr);
+		IDataCapture* pIDataCapture = dynamic_cast<IDataCapture*>(pIBaseClass);
+		if (!pIDataCapture)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pBaseChunkInstance = pIDataCapture->BeginChunk();
+
+		*pChunkInstance = (IBase*)(pBaseChunkInstance);
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacapture_commitchunk(LibMCEnv_DataCapture pDataCapture, LibMCEnv_DataCaptureChunk pChunkInstance)
+{
+	IBase* pIBaseClass = (IBase *)pDataCapture;
+
+	try {
+		IBase* pIBaseClassChunkInstance = (IBase *)pChunkInstance;
+		IDataCaptureChunk* pIChunkInstance = dynamic_cast<IDataCaptureChunk*>(pIBaseClassChunkInstance);
+		if (!pIChunkInstance)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDCAST);
+		
+		IDataCapture* pIDataCapture = dynamic_cast<IDataCapture*>(pIBaseClass);
+		if (!pIDataCapture)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIDataCapture->CommitChunk(pIChunkInstance);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacapture_flush(LibMCEnv_DataCapture pDataCapture)
+{
+	IBase* pIBaseClass = (IBase *)pDataCapture;
+
+	try {
+		IDataCapture* pIDataCapture = dynamic_cast<IDataCapture*>(pIBaseClass);
+		if (!pIDataCapture)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIDataCapture->Flush();
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacapture_getcapturedrowcount(LibMCEnv_DataCapture pDataCapture, LibMCEnv_uint64 * pRowCount)
+{
+	IBase* pIBaseClass = (IBase *)pDataCapture;
+
+	try {
+		if (pRowCount == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		IDataCapture* pIDataCapture = dynamic_cast<IDataCapture*>(pIBaseClass);
+		if (!pIDataCapture)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		*pRowCount = pIDataCapture->GetCapturedRowCount();
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacapture_getstoragesizeinbytes(LibMCEnv_DataCapture pDataCapture, LibMCEnv_uint64 * pSizeInBytes)
+{
+	IBase* pIBaseClass = (IBase *)pDataCapture;
+
+	try {
+		if (pSizeInBytes == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		IDataCapture* pIDataCapture = dynamic_cast<IDataCapture*>(pIBaseClass);
+		if (!pIDataCapture)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		*pSizeInBytes = pIDataCapture->GetStorageSizeInBytes();
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacapture_getsegmentcount(LibMCEnv_DataCapture pDataCapture, LibMCEnv_uint32 * pSegmentCount)
+{
+	IBase* pIBaseClass = (IBase *)pDataCapture;
+
+	try {
+		if (pSegmentCount == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		IDataCapture* pIDataCapture = dynamic_cast<IDataCapture*>(pIBaseClass);
+		if (!pIDataCapture)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		*pSegmentCount = pIDataCapture->GetSegmentCount();
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacapture_getqueuedchunkcount(LibMCEnv_DataCapture pDataCapture, LibMCEnv_uint32 * pQueuedChunkCount)
+{
+	IBase* pIBaseClass = (IBase *)pDataCapture;
+
+	try {
+		if (pQueuedChunkCount == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		IDataCapture* pIDataCapture = dynamic_cast<IDataCapture*>(pIBaseClass);
+		if (!pIDataCapture)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		*pQueuedChunkCount = pIDataCapture->GetQueuedChunkCount();
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacapture_getdroppedrowcount(LibMCEnv_DataCapture pDataCapture, LibMCEnv_uint64 * pDroppedRowCount)
+{
+	IBase* pIBaseClass = (IBase *)pDataCapture;
+
+	try {
+		if (pDroppedRowCount == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		IDataCapture* pIDataCapture = dynamic_cast<IDataCapture*>(pIBaseClass);
+		if (!pIDataCapture)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		*pDroppedRowCount = pIDataCapture->GetDroppedRowCount();
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacapture_finish(LibMCEnv_DataCapture pDataCapture, const LibMCEnv_uint32 nCaptureUUIDBufferSize, LibMCEnv_uint32* pCaptureUUIDNeededChars, char * pCaptureUUIDBuffer)
+{
+	IBase* pIBaseClass = (IBase *)pDataCapture;
+
+	try {
+		if ( (!pCaptureUUIDBuffer) && !(pCaptureUUIDNeededChars) )
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		std::string sCaptureUUID("");
+		IDataCapture* pIDataCapture = dynamic_cast<IDataCapture*>(pIBaseClass);
+		if (!pIDataCapture)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		bool isCacheCall = (pCaptureUUIDBuffer == nullptr);
+		if (isCacheCall) {
+			sCaptureUUID = pIDataCapture->Finish();
+
+			pIDataCapture->_setCache (new ParameterCache_1<std::string> (sCaptureUUID));
+		}
+		else {
+			auto cache = dynamic_cast<ParameterCache_1<std::string>*> (pIDataCapture->_getCache ());
+			if (cache == nullptr)
+				throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+			cache->retrieveData (sCaptureUUID);
+			pIDataCapture->_setCache (nullptr);
+		}
+		
+		if (pCaptureUUIDNeededChars)
+			*pCaptureUUIDNeededChars = (LibMCEnv_uint32) (sCaptureUUID.size()+1);
+		if (pCaptureUUIDBuffer) {
+			if (sCaptureUUID.size() >= nCaptureUUIDBufferSize)
+				throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_BUFFERTOOSMALL);
+			for (size_t iCaptureUUID = 0; iCaptureUUID < sCaptureUUID.size(); iCaptureUUID++)
+				pCaptureUUIDBuffer[iCaptureUUID] = sCaptureUUID[iCaptureUUID];
+			pCaptureUUIDBuffer[sCaptureUUID.size()] = 0;
+		}
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacapture_abort(LibMCEnv_DataCapture pDataCapture)
+{
+	IBase* pIBaseClass = (IBase *)pDataCapture;
+
+	try {
+		IDataCapture* pIDataCapture = dynamic_cast<IDataCapture*>(pIBaseClass);
+		if (!pIDataCapture)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIDataCapture->Abort();
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacapture_addcolumnsfromdatatable(LibMCEnv_DataCapture pDataCapture, LibMCEnv_DataTable pDataTable)
+{
+	IBase* pIBaseClass = (IBase *)pDataCapture;
+
+	try {
+		IBase* pIBaseClassDataTable = (IBase *)pDataTable;
+		IDataTable* pIDataTable = dynamic_cast<IDataTable*>(pIBaseClassDataTable);
+		if (!pIDataTable)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDCAST);
+		
+		IDataCapture* pIDataCapture = dynamic_cast<IDataCapture*>(pIBaseClass);
+		if (!pIDataCapture)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIDataCapture->AddColumnsFromDataTable(pIDataTable);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datacapture_appenddatatable(LibMCEnv_DataCapture pDataCapture, LibMCEnv_DataTable pDataTable, LibMCEnv_uint64 * pRowCount)
+{
+	IBase* pIBaseClass = (IBase *)pDataCapture;
+
+	try {
+		if (pRowCount == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		IBase* pIBaseClassDataTable = (IBase *)pDataTable;
+		IDataTable* pIDataTable = dynamic_cast<IDataTable*>(pIBaseClassDataTable);
+		if (!pIDataTable)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDCAST);
+		
+		IDataCapture* pIDataCapture = dynamic_cast<IDataCapture*>(pIBaseClass);
+		if (!pIDataCapture)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		*pRowCount = pIDataCapture->AppendDataTable(pIDataTable);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+
+/*************************************************************************************************************************
+ Class implementation for DataTableReader
+**************************************************************************************************************************/
+LibMCEnvResult libmcenv_datatablereader_getrowcount(LibMCEnv_DataTableReader pDataTableReader, LibMCEnv_uint64 * pRowCount)
+{
+	IBase* pIBaseClass = (IBase *)pDataTableReader;
+
+	try {
+		if (pRowCount == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		IDataTableReader* pIDataTableReader = dynamic_cast<IDataTableReader*>(pIBaseClass);
+		if (!pIDataTableReader)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		*pRowCount = pIDataTableReader->GetRowCount();
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datatablereader_getfirstavailablerow(LibMCEnv_DataTableReader pDataTableReader, LibMCEnv_uint64 * pFirstAvailableRow)
+{
+	IBase* pIBaseClass = (IBase *)pDataTableReader;
+
+	try {
+		if (pFirstAvailableRow == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		IDataTableReader* pIDataTableReader = dynamic_cast<IDataTableReader*>(pIBaseClass);
+		if (!pIDataTableReader)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		*pFirstAvailableRow = pIDataTableReader->GetFirstAvailableRow();
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datatablereader_getcolumncount(LibMCEnv_DataTableReader pDataTableReader, LibMCEnv_uint32 * pColumnCount)
+{
+	IBase* pIBaseClass = (IBase *)pDataTableReader;
+
+	try {
+		if (pColumnCount == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		IDataTableReader* pIDataTableReader = dynamic_cast<IDataTableReader*>(pIBaseClass);
+		if (!pIDataTableReader)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		*pColumnCount = pIDataTableReader->GetColumnCount();
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datatablereader_hascolumn(LibMCEnv_DataTableReader pDataTableReader, const char * pIdentifier, bool * pColumnExists)
+{
+	IBase* pIBaseClass = (IBase *)pDataTableReader;
+
+	try {
+		if (pIdentifier == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if (pColumnExists == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		std::string sIdentifier(pIdentifier);
+		IDataTableReader* pIDataTableReader = dynamic_cast<IDataTableReader*>(pIBaseClass);
+		if (!pIDataTableReader)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		*pColumnExists = pIDataTableReader->HasColumn(sIdentifier);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datatablereader_getcolumninformation(LibMCEnv_DataTableReader pDataTableReader, LibMCEnv_uint32 nColumnIndex, const LibMCEnv_uint32 nIdentifierBufferSize, LibMCEnv_uint32* pIdentifierNeededChars, char * pIdentifierBuffer, const LibMCEnv_uint32 nDescriptionBufferSize, LibMCEnv_uint32* pDescriptionNeededChars, char * pDescriptionBuffer, eLibMCEnvDataTableColumnType * pColumnType)
+{
+	IBase* pIBaseClass = (IBase *)pDataTableReader;
+
+	try {
+		if ( (!pIdentifierBuffer) && !(pIdentifierNeededChars) )
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if ( (!pDescriptionBuffer) && !(pDescriptionNeededChars) )
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if (!pColumnType)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		std::string sIdentifier("");
+		std::string sDescription("");
+		IDataTableReader* pIDataTableReader = dynamic_cast<IDataTableReader*>(pIBaseClass);
+		if (!pIDataTableReader)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		bool isCacheCall = (pIdentifierBuffer == nullptr) || (pDescriptionBuffer == nullptr);
+		if (isCacheCall) {
+			pIDataTableReader->GetColumnInformation(nColumnIndex, sIdentifier, sDescription, *pColumnType);
+
+			pIDataTableReader->_setCache (new ParameterCache_3<std::string, std::string, LibMCEnv::eDataTableColumnType> (sIdentifier, sDescription, *pColumnType));
+		}
+		else {
+			auto cache = dynamic_cast<ParameterCache_3<std::string, std::string, LibMCEnv::eDataTableColumnType>*> (pIDataTableReader->_getCache ());
+			if (cache == nullptr)
+				throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+			cache->retrieveData (sIdentifier, sDescription, *pColumnType);
+			pIDataTableReader->_setCache (nullptr);
+		}
+		
+		if (pIdentifierNeededChars)
+			*pIdentifierNeededChars = (LibMCEnv_uint32) (sIdentifier.size()+1);
+		if (pIdentifierBuffer) {
+			if (sIdentifier.size() >= nIdentifierBufferSize)
+				throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_BUFFERTOOSMALL);
+			for (size_t iIdentifier = 0; iIdentifier < sIdentifier.size(); iIdentifier++)
+				pIdentifierBuffer[iIdentifier] = sIdentifier[iIdentifier];
+			pIdentifierBuffer[sIdentifier.size()] = 0;
+		}
+		if (pDescriptionNeededChars)
+			*pDescriptionNeededChars = (LibMCEnv_uint32) (sDescription.size()+1);
+		if (pDescriptionBuffer) {
+			if (sDescription.size() >= nDescriptionBufferSize)
+				throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_BUFFERTOOSMALL);
+			for (size_t iDescription = 0; iDescription < sDescription.size(); iDescription++)
+				pDescriptionBuffer[iDescription] = sDescription[iDescription];
+			pDescriptionBuffer[sDescription.size()] = 0;
+		}
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datatablereader_getcolumnquantization(LibMCEnv_DataTableReader pDataTableReader, const char * pIdentifier, LibMCEnv_double * pStep)
+{
+	IBase* pIBaseClass = (IBase *)pDataTableReader;
+
+	try {
+		if (pIdentifier == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if (pStep == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		std::string sIdentifier(pIdentifier);
+		IDataTableReader* pIDataTableReader = dynamic_cast<IDataTableReader*>(pIBaseClass);
+		if (!pIDataTableReader)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		*pStep = pIDataTableReader->GetColumnQuantization(sIdentifier);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datatablereader_getsegmentcount(LibMCEnv_DataTableReader pDataTableReader, LibMCEnv_uint32 * pSegmentCount)
+{
+	IBase* pIBaseClass = (IBase *)pDataTableReader;
+
+	try {
+		if (pSegmentCount == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		IDataTableReader* pIDataTableReader = dynamic_cast<IDataTableReader*>(pIBaseClass);
+		if (!pIDataTableReader)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		*pSegmentCount = pIDataTableReader->GetSegmentCount();
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datatablereader_getsegmentinformation(LibMCEnv_DataTableReader pDataTableReader, LibMCEnv_uint32 nSegmentIndex, LibMCEnv_uint64 * pFirstRow, LibMCEnv_uint64 * pRowCount, LibMCEnv_uint64 * pSizeInBytes, bool * pIsAvailable)
+{
+	IBase* pIBaseClass = (IBase *)pDataTableReader;
+
+	try {
+		if (!pFirstRow)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if (!pRowCount)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if (!pSizeInBytes)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if (!pIsAvailable)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		IDataTableReader* pIDataTableReader = dynamic_cast<IDataTableReader*>(pIBaseClass);
+		if (!pIDataTableReader)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIDataTableReader->GetSegmentInformation(nSegmentIndex, *pFirstRow, *pRowCount, *pSizeInBytes, *pIsAvailable);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datatablereader_getchunkcount(LibMCEnv_DataTableReader pDataTableReader, LibMCEnv_uint64 * pChunkCount)
+{
+	IBase* pIBaseClass = (IBase *)pDataTableReader;
+
+	try {
+		if (pChunkCount == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		IDataTableReader* pIDataTableReader = dynamic_cast<IDataTableReader*>(pIBaseClass);
+		if (!pIDataTableReader)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		*pChunkCount = pIDataTableReader->GetChunkCount();
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datatablereader_getchunkinformation(LibMCEnv_DataTableReader pDataTableReader, LibMCEnv_uint64 nChunkIndex, LibMCEnv_uint32 * pSegmentIndex, LibMCEnv_uint64 * pFirstRow, LibMCEnv_uint64 * pRowCount, bool * pIsAvailable)
+{
+	IBase* pIBaseClass = (IBase *)pDataTableReader;
+
+	try {
+		if (!pSegmentIndex)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if (!pFirstRow)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if (!pRowCount)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if (!pIsAvailable)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		IDataTableReader* pIDataTableReader = dynamic_cast<IDataTableReader*>(pIBaseClass);
+		if (!pIDataTableReader)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIDataTableReader->GetChunkInformation(nChunkIndex, *pSegmentIndex, *pFirstRow, *pRowCount, *pIsAvailable);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datatablereader_getchunkstatistics(LibMCEnv_DataTableReader pDataTableReader, LibMCEnv_uint64 nChunkIndex, const char * pIdentifier, LibMCEnv_double * pMinValue, LibMCEnv_double * pMaxValue, bool * pHasStatistics)
+{
+	IBase* pIBaseClass = (IBase *)pDataTableReader;
+
+	try {
+		if (pIdentifier == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if (!pMinValue)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if (!pMaxValue)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if (pHasStatistics == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		std::string sIdentifier(pIdentifier);
+		IDataTableReader* pIDataTableReader = dynamic_cast<IDataTableReader*>(pIBaseClass);
+		if (!pIDataTableReader)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		*pHasStatistics = pIDataTableReader->GetChunkStatistics(nChunkIndex, sIdentifier, *pMinValue, *pMaxValue);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datatablereader_readdoublecolumnrange(LibMCEnv_DataTableReader pDataTableReader, const char * pIdentifier, LibMCEnv_uint64 nFromRow, LibMCEnv_uint64 nRowCount, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_double * pValuesBuffer)
+{
+	IBase* pIBaseClass = (IBase *)pDataTableReader;
+
+	try {
+		if (pIdentifier == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if ((!pValuesBuffer) && !(pValuesNeededCount))
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		std::string sIdentifier(pIdentifier);
+		IDataTableReader* pIDataTableReader = dynamic_cast<IDataTableReader*>(pIBaseClass);
+		if (!pIDataTableReader)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIDataTableReader->ReadDoubleColumnRange(sIdentifier, nFromRow, nRowCount, nValuesBufferSize, pValuesNeededCount, pValuesBuffer);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datatablereader_readfloatcolumnrange(LibMCEnv_DataTableReader pDataTableReader, const char * pIdentifier, LibMCEnv_uint64 nFromRow, LibMCEnv_uint64 nRowCount, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_single * pValuesBuffer)
+{
+	IBase* pIBaseClass = (IBase *)pDataTableReader;
+
+	try {
+		if (pIdentifier == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if ((!pValuesBuffer) && !(pValuesNeededCount))
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		std::string sIdentifier(pIdentifier);
+		IDataTableReader* pIDataTableReader = dynamic_cast<IDataTableReader*>(pIBaseClass);
+		if (!pIDataTableReader)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIDataTableReader->ReadFloatColumnRange(sIdentifier, nFromRow, nRowCount, nValuesBufferSize, pValuesNeededCount, pValuesBuffer);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datatablereader_readint64columnrange(LibMCEnv_DataTableReader pDataTableReader, const char * pIdentifier, LibMCEnv_uint64 nFromRow, LibMCEnv_uint64 nRowCount, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_int64 * pValuesBuffer)
+{
+	IBase* pIBaseClass = (IBase *)pDataTableReader;
+
+	try {
+		if (pIdentifier == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if ((!pValuesBuffer) && !(pValuesNeededCount))
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		std::string sIdentifier(pIdentifier);
+		IDataTableReader* pIDataTableReader = dynamic_cast<IDataTableReader*>(pIBaseClass);
+		if (!pIDataTableReader)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIDataTableReader->ReadInt64ColumnRange(sIdentifier, nFromRow, nRowCount, nValuesBufferSize, pValuesNeededCount, pValuesBuffer);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datatablereader_readboolcolumnrange(LibMCEnv_DataTableReader pDataTableReader, const char * pIdentifier, LibMCEnv_uint64 nFromRow, LibMCEnv_uint64 nRowCount, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_uint8 * pValuesBuffer)
+{
+	IBase* pIBaseClass = (IBase *)pDataTableReader;
+
+	try {
+		if (pIdentifier == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if ((!pValuesBuffer) && !(pValuesNeededCount))
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		std::string sIdentifier(pIdentifier);
+		IDataTableReader* pIDataTableReader = dynamic_cast<IDataTableReader*>(pIBaseClass);
+		if (!pIDataTableReader)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIDataTableReader->ReadBoolColumnRange(sIdentifier, nFromRow, nRowCount, nValuesBufferSize, pValuesNeededCount, pValuesBuffer);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datatablereader_readcolumndownsampled(LibMCEnv_DataTableReader pDataTableReader, const char * pIdentifier, LibMCEnv_uint64 nFromRow, LibMCEnv_uint64 nRowCount, LibMCEnv_uint32 nTargetPoints, eLibMCEnvDataTableDownsampleMode eMode, const LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_double * pValuesBuffer)
+{
+	IBase* pIBaseClass = (IBase *)pDataTableReader;
+
+	try {
+		if (pIdentifier == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if ((!pValuesBuffer) && !(pValuesNeededCount))
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		std::string sIdentifier(pIdentifier);
+		IDataTableReader* pIDataTableReader = dynamic_cast<IDataTableReader*>(pIBaseClass);
+		if (!pIDataTableReader)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIDataTableReader->ReadColumnDownsampled(sIdentifier, nFromRow, nRowCount, nTargetPoints, eMode, nValuesBufferSize, pValuesNeededCount, pValuesBuffer);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datatablereader_findchunksinvaluerange(LibMCEnv_DataTableReader pDataTableReader, const char * pIdentifier, LibMCEnv_double dMinValue, LibMCEnv_double dMaxValue, const LibMCEnv_uint64 nChunkIndicesBufferSize, LibMCEnv_uint64* pChunkIndicesNeededCount, LibMCEnv_uint64 * pChunkIndicesBuffer)
+{
+	IBase* pIBaseClass = (IBase *)pDataTableReader;
+
+	try {
+		if (pIdentifier == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if ((!pChunkIndicesBuffer) && !(pChunkIndicesNeededCount))
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		std::string sIdentifier(pIdentifier);
+		IDataTableReader* pIDataTableReader = dynamic_cast<IDataTableReader*>(pIBaseClass);
+		if (!pIDataTableReader)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIDataTableReader->FindChunksInValueRange(sIdentifier, dMinValue, dMaxValue, nChunkIndicesBufferSize, pChunkIndicesNeededCount, pChunkIndicesBuffer);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_datatablereader_extractdatatable(LibMCEnv_DataTableReader pDataTableReader, LibMCEnv_uint64 nFromRow, LibMCEnv_uint64 nRowCount, const char * pColumnIdentifiers, LibMCEnv_DataTable * pDataTableInstance)
+{
+	IBase* pIBaseClass = (IBase *)pDataTableReader;
+
+	try {
+		if (pColumnIdentifiers == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if (pDataTableInstance == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		std::string sColumnIdentifiers(pColumnIdentifiers);
+		IBase* pBaseDataTableInstance(nullptr);
+		IDataTableReader* pIDataTableReader = dynamic_cast<IDataTableReader*>(pIBaseClass);
+		if (!pIDataTableReader)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pBaseDataTableInstance = pIDataTableReader->ExtractDataTable(nFromRow, nRowCount, sColumnIdentifiers);
+
+		*pDataTableInstance = (IBase*)(pBaseDataTableInstance);
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+
 /*************************************************************************************************************************
  Class implementation for DataSeries
 **************************************************************************************************************************/
@@ -12628,6 +14701,222 @@ LibMCEnvResult libmcenv_buildexecution_loadattachedjournal(LibMCEnv_BuildExecuti
 	}
 }
 
+LibMCEnvResult libmcenv_buildexecution_createdatacaptureoptions(LibMCEnv_BuildExecution pBuildExecution, LibMCEnv_DataCaptureOptions * pOptions)
+{
+	IBase* pIBaseClass = (IBase *)pBuildExecution;
+
+	try {
+		if (pOptions == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		IBase* pBaseOptions(nullptr);
+		IBuildExecution* pIBuildExecution = dynamic_cast<IBuildExecution*>(pIBaseClass);
+		if (!pIBuildExecution)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pBaseOptions = pIBuildExecution->CreateDataCaptureOptions();
+
+		*pOptions = (IBase*)(pBaseOptions);
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_buildexecution_createdatacapture(LibMCEnv_BuildExecution pBuildExecution, const char * pIdentifier, const char * pName, LibMCEnv_DataCaptureOptions pOptions, const char * pUserUUID, LibMCEnv_DataCapture * pDataCaptureInstance)
+{
+	IBase* pIBaseClass = (IBase *)pBuildExecution;
+
+	try {
+		if (pIdentifier == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if (pName == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if (pUserUUID == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if (pDataCaptureInstance == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		std::string sIdentifier(pIdentifier);
+		std::string sName(pName);
+		IBase* pIBaseClassOptions = (IBase *)pOptions;
+		IDataCaptureOptions* pIOptions = dynamic_cast<IDataCaptureOptions*>(pIBaseClassOptions);
+		std::string sUserUUID(pUserUUID);
+		IBase* pBaseDataCaptureInstance(nullptr);
+		IBuildExecution* pIBuildExecution = dynamic_cast<IBuildExecution*>(pIBaseClass);
+		if (!pIBuildExecution)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pBaseDataCaptureInstance = pIBuildExecution->CreateDataCapture(sIdentifier, sName, pIOptions, sUserUUID);
+
+		*pDataCaptureInstance = (IBase*)(pBaseDataCaptureInstance);
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_buildexecution_hasdatacapture(LibMCEnv_BuildExecution pBuildExecution, const char * pIdentifier, bool * pCaptureExists)
+{
+	IBase* pIBaseClass = (IBase *)pBuildExecution;
+
+	try {
+		if (pIdentifier == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if (pCaptureExists == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		std::string sIdentifier(pIdentifier);
+		IBuildExecution* pIBuildExecution = dynamic_cast<IBuildExecution*>(pIBaseClass);
+		if (!pIBuildExecution)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		*pCaptureExists = pIBuildExecution->HasDataCapture(sIdentifier);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_buildexecution_getdatacapturerowcount(LibMCEnv_BuildExecution pBuildExecution, const char * pIdentifier, LibMCEnv_uint64 * pRowCount)
+{
+	IBase* pIBaseClass = (IBase *)pBuildExecution;
+
+	try {
+		if (pIdentifier == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if (pRowCount == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		std::string sIdentifier(pIdentifier);
+		IBuildExecution* pIBuildExecution = dynamic_cast<IBuildExecution*>(pIBaseClass);
+		if (!pIBuildExecution)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		*pRowCount = pIBuildExecution->GetDataCaptureRowCount(sIdentifier);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_buildexecution_getdatacapturesegmentcount(LibMCEnv_BuildExecution pBuildExecution, const char * pIdentifier, LibMCEnv_uint32 * pSegmentCount)
+{
+	IBase* pIBaseClass = (IBase *)pBuildExecution;
+
+	try {
+		if (pIdentifier == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if (pSegmentCount == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		std::string sIdentifier(pIdentifier);
+		IBuildExecution* pIBuildExecution = dynamic_cast<IBuildExecution*>(pIBaseClass);
+		if (!pIBuildExecution)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		*pSegmentCount = pIBuildExecution->GetDataCaptureSegmentCount(sIdentifier);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_buildexecution_loaddatacapturesegment(LibMCEnv_BuildExecution pBuildExecution, const char * pIdentifier, LibMCEnv_uint32 nSegmentIndex, LibMCEnv_DataTable * pDataTableInstance)
+{
+	IBase* pIBaseClass = (IBase *)pBuildExecution;
+
+	try {
+		if (pIdentifier == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if (pDataTableInstance == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		std::string sIdentifier(pIdentifier);
+		IBase* pBaseDataTableInstance(nullptr);
+		IBuildExecution* pIBuildExecution = dynamic_cast<IBuildExecution*>(pIBaseClass);
+		if (!pIBuildExecution)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pBaseDataTableInstance = pIBuildExecution->LoadDataCaptureSegment(sIdentifier, nSegmentIndex);
+
+		*pDataTableInstance = (IBase*)(pBaseDataTableInstance);
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_buildexecution_opendatacapturereader(LibMCEnv_BuildExecution pBuildExecution, const char * pIdentifier, LibMCEnv_DataTableReader * pReaderInstance)
+{
+	IBase* pIBaseClass = (IBase *)pBuildExecution;
+
+	try {
+		if (pIdentifier == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if (pReaderInstance == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		std::string sIdentifier(pIdentifier);
+		IBase* pBaseReaderInstance(nullptr);
+		IBuildExecution* pIBuildExecution = dynamic_cast<IBuildExecution*>(pIBaseClass);
+		if (!pIBuildExecution)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pBaseReaderInstance = pIBuildExecution->OpenDataCaptureReader(sIdentifier);
+
+		*pReaderInstance = (IBase*)(pBaseReaderInstance);
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
 
 /*************************************************************************************************************************
  Class implementation for BuildExecutionIterator
@@ -24138,6 +26427,30 @@ LibMCEnvResult libmcenv_zipstreamwriter_createzipentryfromstream(LibMCEnv_ZIPStr
 	}
 }
 
+LibMCEnvResult libmcenv_zipstreamwriter_discard(LibMCEnv_ZIPStreamWriter pZIPStreamWriter)
+{
+	IBase* pIBaseClass = (IBase *)pZIPStreamWriter;
+
+	try {
+		IZIPStreamWriter* pIZIPStreamWriter = dynamic_cast<IZIPStreamWriter*>(pIBaseClass);
+		if (!pIZIPStreamWriter)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIZIPStreamWriter->Discard();
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
 
 /*************************************************************************************************************************
  Class implementation for StreamReader
@@ -34195,6 +36508,163 @@ LibMCEnvResult libmcenv_stateenvironment_evaluateformulaasbool(LibMCEnv_StateEnv
 	}
 }
 
+LibMCEnvResult libmcenv_stateenvironment_startstreamdownloadforsession(LibMCEnv_StateEnvironment pStateEnvironment, const char * pSessionUUID, const char * pStreamUUID, const char * pFileName, bool * pSuccess)
+{
+	IBase* pIBaseClass = (IBase *)pStateEnvironment;
+
+	try {
+		if (pSessionUUID == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if (pStreamUUID == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if (pFileName == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if (pSuccess == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		std::string sSessionUUID(pSessionUUID);
+		std::string sStreamUUID(pStreamUUID);
+		std::string sFileName(pFileName);
+		IStateEnvironment* pIStateEnvironment = dynamic_cast<IStateEnvironment*>(pIBaseClass);
+		if (!pIStateEnvironment)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		*pSuccess = pIStateEnvironment->StartStreamDownloadForSession(sSessionUUID, sStreamUUID, sFileName);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_stateenvironment_getstreamdownloadprogress(LibMCEnv_StateEnvironment pStateEnvironment, const char * pStreamUUID, LibMCEnv_uint32 * pActiveConnections, LibMCEnv_uint64 * pDeliveredBytes, LibMCEnv_uint64 * pTotalBytes, bool * pCompleted, LibMCEnv_uint64 * pMillisecondsSinceActivity)
+{
+	IBase* pIBaseClass = (IBase *)pStateEnvironment;
+
+	try {
+		if (pStreamUUID == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if (!pActiveConnections)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if (!pDeliveredBytes)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if (!pTotalBytes)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if (!pCompleted)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if (!pMillisecondsSinceActivity)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		std::string sStreamUUID(pStreamUUID);
+		IStateEnvironment* pIStateEnvironment = dynamic_cast<IStateEnvironment*>(pIBaseClass);
+		if (!pIStateEnvironment)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIStateEnvironment->GetStreamDownloadProgress(sStreamUUID, *pActiveConnections, *pDeliveredBytes, *pTotalBytes, *pCompleted, *pMillisecondsSinceActivity);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_stateenvironment_cancelstreamdownloads(LibMCEnv_StateEnvironment pStateEnvironment, const char * pStreamUUID, bool * pCancelled)
+{
+	IBase* pIBaseClass = (IBase *)pStateEnvironment;
+
+	try {
+		if (pStreamUUID == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if (pCancelled == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		std::string sStreamUUID(pStreamUUID);
+		IStateEnvironment* pIStateEnvironment = dynamic_cast<IStateEnvironment*>(pIBaseClass);
+		if (!pIStateEnvironment)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		*pCancelled = pIStateEnvironment->CancelStreamDownloads(sStreamUUID);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_stateenvironment_deletestoragestream(LibMCEnv_StateEnvironment pStateEnvironment, const char * pUUID)
+{
+	IBase* pIBaseClass = (IBase *)pStateEnvironment;
+
+	try {
+		if (pUUID == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		std::string sUUID(pUUID);
+		IStateEnvironment* pIStateEnvironment = dynamic_cast<IStateEnvironment*>(pIBaseClass);
+		if (!pIStateEnvironment)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		pIStateEnvironment->DeleteStorageStream(sUUID);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
+LibMCEnvResult libmcenv_stateenvironment_enforcestreamretention(LibMCEnv_StateEnvironment pStateEnvironment, const char * pName, LibMCEnv_uint32 nKeepCount, LibMCEnv_uint32 * pDeletedCount)
+{
+	IBase* pIBaseClass = (IBase *)pStateEnvironment;
+
+	try {
+		if (pName == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		if (pDeletedCount == nullptr)
+			throw ELibMCEnvInterfaceException (LIBMCENV_ERROR_INVALIDPARAM);
+		std::string sName(pName);
+		IStateEnvironment* pIStateEnvironment = dynamic_cast<IStateEnvironment*>(pIBaseClass);
+		if (!pIStateEnvironment)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+		
+		*pDeletedCount = pIStateEnvironment->EnforceStreamRetention(sName, nKeepCount);
+
+		return LIBMCENV_SUCCESS;
+	}
+	catch (ELibMCEnvInterfaceException & Exception) {
+		return handleLibMCEnvException(pIBaseClass, Exception);
+	}
+	catch (std::exception & StdException) {
+		return handleStdException(pIBaseClass, StdException);
+	}
+	catch (...) {
+		return handleUnhandledException(pIBaseClass);
+	}
+}
+
 
 /*************************************************************************************************************************
  Class implementation for UIItem
@@ -38511,6 +40981,8 @@ LibMCEnvResult LibMCEnv::Impl::LibMCEnv_GetProcAddress (const char * pProcName,
 		*ppProcAddress = (void*) &libmcenv_datatable_hascolumn;
 	if (sProcName == "libmcenv_datatable_getrowcount") 
 		*ppProcAddress = (void*) &libmcenv_datatable_getrowcount;
+	if (sProcName == "libmcenv_datatable_getrowcount64") 
+		*ppProcAddress = (void*) &libmcenv_datatable_getrowcount64;
 	if (sProcName == "libmcenv_datatable_getcolumncount") 
 		*ppProcAddress = (void*) &libmcenv_datatable_getcolumncount;
 	if (sProcName == "libmcenv_datatable_getcolumnidentifier") 
@@ -38531,6 +41003,12 @@ LibMCEnvResult LibMCEnv::Impl::LibMCEnv_GetProcAddress (const char * pProcName,
 		*ppProcAddress = (void*) &libmcenv_datatable_getuint32columnvalues;
 	if (sProcName == "libmcenv_datatable_getuint64columnvalues") 
 		*ppProcAddress = (void*) &libmcenv_datatable_getuint64columnvalues;
+	if (sProcName == "libmcenv_datatable_getfloatcolumnvalues") 
+		*ppProcAddress = (void*) &libmcenv_datatable_getfloatcolumnvalues;
+	if (sProcName == "libmcenv_datatable_getboolcolumnvalues") 
+		*ppProcAddress = (void*) &libmcenv_datatable_getboolcolumnvalues;
+	if (sProcName == "libmcenv_datatable_gettimestampcolumnvalues") 
+		*ppProcAddress = (void*) &libmcenv_datatable_gettimestampcolumnvalues;
 	if (sProcName == "libmcenv_datatable_setdoublecolumnvalues") 
 		*ppProcAddress = (void*) &libmcenv_datatable_setdoublecolumnvalues;
 	if (sProcName == "libmcenv_datatable_setint32columnvalues") 
@@ -38541,6 +41019,12 @@ LibMCEnvResult LibMCEnv::Impl::LibMCEnv_GetProcAddress (const char * pProcName,
 		*ppProcAddress = (void*) &libmcenv_datatable_setuint32columnvalues;
 	if (sProcName == "libmcenv_datatable_setuint64columnvalues") 
 		*ppProcAddress = (void*) &libmcenv_datatable_setuint64columnvalues;
+	if (sProcName == "libmcenv_datatable_setfloatcolumnvalues") 
+		*ppProcAddress = (void*) &libmcenv_datatable_setfloatcolumnvalues;
+	if (sProcName == "libmcenv_datatable_setboolcolumnvalues") 
+		*ppProcAddress = (void*) &libmcenv_datatable_setboolcolumnvalues;
+	if (sProcName == "libmcenv_datatable_settimestampcolumnvalues") 
+		*ppProcAddress = (void*) &libmcenv_datatable_settimestampcolumnvalues;
 	if (sProcName == "libmcenv_datatable_createwriteoptions") 
 		*ppProcAddress = (void*) &libmcenv_datatable_createwriteoptions;
 	if (sProcName == "libmcenv_datatable_createcsvwriteoptions") 
@@ -38555,6 +41039,136 @@ LibMCEnvResult LibMCEnv::Impl::LibMCEnv_GetProcAddress (const char * pProcName,
 		*ppProcAddress = (void*) &libmcenv_datatable_createscatterplotoptions;
 	if (sProcName == "libmcenv_datatable_calculatescatterplot") 
 		*ppProcAddress = (void*) &libmcenv_datatable_calculatescatterplot;
+	if (sProcName == "libmcenv_datacaptureoptions_setchunkrowcount") 
+		*ppProcAddress = (void*) &libmcenv_datacaptureoptions_setchunkrowcount;
+	if (sProcName == "libmcenv_datacaptureoptions_getchunkrowcount") 
+		*ppProcAddress = (void*) &libmcenv_datacaptureoptions_getchunkrowcount;
+	if (sProcName == "libmcenv_datacaptureoptions_setsegmentsizeinbytes") 
+		*ppProcAddress = (void*) &libmcenv_datacaptureoptions_setsegmentsizeinbytes;
+	if (sProcName == "libmcenv_datacaptureoptions_getsegmentsizeinbytes") 
+		*ppProcAddress = (void*) &libmcenv_datacaptureoptions_getsegmentsizeinbytes;
+	if (sProcName == "libmcenv_datacaptureoptions_setmaxqueuedchunks") 
+		*ppProcAddress = (void*) &libmcenv_datacaptureoptions_setmaxqueuedchunks;
+	if (sProcName == "libmcenv_datacaptureoptions_getmaxqueuedchunks") 
+		*ppProcAddress = (void*) &libmcenv_datacaptureoptions_getmaxqueuedchunks;
+	if (sProcName == "libmcenv_datacaptureoptions_setbackpressuremode") 
+		*ppProcAddress = (void*) &libmcenv_datacaptureoptions_setbackpressuremode;
+	if (sProcName == "libmcenv_datacaptureoptions_getbackpressuremode") 
+		*ppProcAddress = (void*) &libmcenv_datacaptureoptions_getbackpressuremode;
+	if (sProcName == "libmcenv_datacaptureoptions_setstoragelimitinbytes") 
+		*ppProcAddress = (void*) &libmcenv_datacaptureoptions_setstoragelimitinbytes;
+	if (sProcName == "libmcenv_datacaptureoptions_getstoragelimitinbytes") 
+		*ppProcAddress = (void*) &libmcenv_datacaptureoptions_getstoragelimitinbytes;
+	if (sProcName == "libmcenv_datacaptureoptions_setcompression") 
+		*ppProcAddress = (void*) &libmcenv_datacaptureoptions_setcompression;
+	if (sProcName == "libmcenv_datacaptureoptions_getcompression") 
+		*ppProcAddress = (void*) &libmcenv_datacaptureoptions_getcompression;
+	if (sProcName == "libmcenv_datacaptureoptions_setcolumnencoding") 
+		*ppProcAddress = (void*) &libmcenv_datacaptureoptions_setcolumnencoding;
+	if (sProcName == "libmcenv_datacaptureoptions_setdoublequantization") 
+		*ppProcAddress = (void*) &libmcenv_datacaptureoptions_setdoublequantization;
+	if (sProcName == "libmcenv_datacapturechunk_getcapacity") 
+		*ppProcAddress = (void*) &libmcenv_datacapturechunk_getcapacity;
+	if (sProcName == "libmcenv_datacapturechunk_getrowcount") 
+		*ppProcAddress = (void*) &libmcenv_datacapturechunk_getrowcount;
+	if (sProcName == "libmcenv_datacapturechunk_isfull") 
+		*ppProcAddress = (void*) &libmcenv_datacapturechunk_isfull;
+	if (sProcName == "libmcenv_datacapturechunk_setdoublecolumnvalues") 
+		*ppProcAddress = (void*) &libmcenv_datacapturechunk_setdoublecolumnvalues;
+	if (sProcName == "libmcenv_datacapturechunk_setint32columnvalues") 
+		*ppProcAddress = (void*) &libmcenv_datacapturechunk_setint32columnvalues;
+	if (sProcName == "libmcenv_datacapturechunk_setuint32columnvalues") 
+		*ppProcAddress = (void*) &libmcenv_datacapturechunk_setuint32columnvalues;
+	if (sProcName == "libmcenv_datacapturechunk_setint64columnvalues") 
+		*ppProcAddress = (void*) &libmcenv_datacapturechunk_setint64columnvalues;
+	if (sProcName == "libmcenv_datacapturechunk_setuint64columnvalues") 
+		*ppProcAddress = (void*) &libmcenv_datacapturechunk_setuint64columnvalues;
+	if (sProcName == "libmcenv_datacapturechunk_setfloatcolumnvalues") 
+		*ppProcAddress = (void*) &libmcenv_datacapturechunk_setfloatcolumnvalues;
+	if (sProcName == "libmcenv_datacapturechunk_setboolcolumnvalues") 
+		*ppProcAddress = (void*) &libmcenv_datacapturechunk_setboolcolumnvalues;
+	if (sProcName == "libmcenv_datacapturechunk_settimestampcolumnvalues") 
+		*ppProcAddress = (void*) &libmcenv_datacapturechunk_settimestampcolumnvalues;
+	if (sProcName == "libmcenv_datacapturechunk_beginrow") 
+		*ppProcAddress = (void*) &libmcenv_datacapturechunk_beginrow;
+	if (sProcName == "libmcenv_datacapturechunk_setrowdoublevalue") 
+		*ppProcAddress = (void*) &libmcenv_datacapturechunk_setrowdoublevalue;
+	if (sProcName == "libmcenv_datacapturechunk_setrowintegervalue") 
+		*ppProcAddress = (void*) &libmcenv_datacapturechunk_setrowintegervalue;
+	if (sProcName == "libmcenv_datacapturechunk_endrow") 
+		*ppProcAddress = (void*) &libmcenv_datacapturechunk_endrow;
+	if (sProcName == "libmcenv_datacapture_getuuid") 
+		*ppProcAddress = (void*) &libmcenv_datacapture_getuuid;
+	if (sProcName == "libmcenv_datacapture_getidentifier") 
+		*ppProcAddress = (void*) &libmcenv_datacapture_getidentifier;
+	if (sProcName == "libmcenv_datacapture_getname") 
+		*ppProcAddress = (void*) &libmcenv_datacapture_getname;
+	if (sProcName == "libmcenv_datacapture_getstatus") 
+		*ppProcAddress = (void*) &libmcenv_datacapture_getstatus;
+	if (sProcName == "libmcenv_datacapture_addcolumn") 
+		*ppProcAddress = (void*) &libmcenv_datacapture_addcolumn;
+	if (sProcName == "libmcenv_datacapture_getcolumncount") 
+		*ppProcAddress = (void*) &libmcenv_datacapture_getcolumncount;
+	if (sProcName == "libmcenv_datacapture_beginchunk") 
+		*ppProcAddress = (void*) &libmcenv_datacapture_beginchunk;
+	if (sProcName == "libmcenv_datacapture_commitchunk") 
+		*ppProcAddress = (void*) &libmcenv_datacapture_commitchunk;
+	if (sProcName == "libmcenv_datacapture_flush") 
+		*ppProcAddress = (void*) &libmcenv_datacapture_flush;
+	if (sProcName == "libmcenv_datacapture_getcapturedrowcount") 
+		*ppProcAddress = (void*) &libmcenv_datacapture_getcapturedrowcount;
+	if (sProcName == "libmcenv_datacapture_getstoragesizeinbytes") 
+		*ppProcAddress = (void*) &libmcenv_datacapture_getstoragesizeinbytes;
+	if (sProcName == "libmcenv_datacapture_getsegmentcount") 
+		*ppProcAddress = (void*) &libmcenv_datacapture_getsegmentcount;
+	if (sProcName == "libmcenv_datacapture_getqueuedchunkcount") 
+		*ppProcAddress = (void*) &libmcenv_datacapture_getqueuedchunkcount;
+	if (sProcName == "libmcenv_datacapture_getdroppedrowcount") 
+		*ppProcAddress = (void*) &libmcenv_datacapture_getdroppedrowcount;
+	if (sProcName == "libmcenv_datacapture_finish") 
+		*ppProcAddress = (void*) &libmcenv_datacapture_finish;
+	if (sProcName == "libmcenv_datacapture_abort") 
+		*ppProcAddress = (void*) &libmcenv_datacapture_abort;
+	if (sProcName == "libmcenv_datacapture_addcolumnsfromdatatable") 
+		*ppProcAddress = (void*) &libmcenv_datacapture_addcolumnsfromdatatable;
+	if (sProcName == "libmcenv_datacapture_appenddatatable") 
+		*ppProcAddress = (void*) &libmcenv_datacapture_appenddatatable;
+	if (sProcName == "libmcenv_datatablereader_getrowcount") 
+		*ppProcAddress = (void*) &libmcenv_datatablereader_getrowcount;
+	if (sProcName == "libmcenv_datatablereader_getfirstavailablerow") 
+		*ppProcAddress = (void*) &libmcenv_datatablereader_getfirstavailablerow;
+	if (sProcName == "libmcenv_datatablereader_getcolumncount") 
+		*ppProcAddress = (void*) &libmcenv_datatablereader_getcolumncount;
+	if (sProcName == "libmcenv_datatablereader_hascolumn") 
+		*ppProcAddress = (void*) &libmcenv_datatablereader_hascolumn;
+	if (sProcName == "libmcenv_datatablereader_getcolumninformation") 
+		*ppProcAddress = (void*) &libmcenv_datatablereader_getcolumninformation;
+	if (sProcName == "libmcenv_datatablereader_getcolumnquantization") 
+		*ppProcAddress = (void*) &libmcenv_datatablereader_getcolumnquantization;
+	if (sProcName == "libmcenv_datatablereader_getsegmentcount") 
+		*ppProcAddress = (void*) &libmcenv_datatablereader_getsegmentcount;
+	if (sProcName == "libmcenv_datatablereader_getsegmentinformation") 
+		*ppProcAddress = (void*) &libmcenv_datatablereader_getsegmentinformation;
+	if (sProcName == "libmcenv_datatablereader_getchunkcount") 
+		*ppProcAddress = (void*) &libmcenv_datatablereader_getchunkcount;
+	if (sProcName == "libmcenv_datatablereader_getchunkinformation") 
+		*ppProcAddress = (void*) &libmcenv_datatablereader_getchunkinformation;
+	if (sProcName == "libmcenv_datatablereader_getchunkstatistics") 
+		*ppProcAddress = (void*) &libmcenv_datatablereader_getchunkstatistics;
+	if (sProcName == "libmcenv_datatablereader_readdoublecolumnrange") 
+		*ppProcAddress = (void*) &libmcenv_datatablereader_readdoublecolumnrange;
+	if (sProcName == "libmcenv_datatablereader_readfloatcolumnrange") 
+		*ppProcAddress = (void*) &libmcenv_datatablereader_readfloatcolumnrange;
+	if (sProcName == "libmcenv_datatablereader_readint64columnrange") 
+		*ppProcAddress = (void*) &libmcenv_datatablereader_readint64columnrange;
+	if (sProcName == "libmcenv_datatablereader_readboolcolumnrange") 
+		*ppProcAddress = (void*) &libmcenv_datatablereader_readboolcolumnrange;
+	if (sProcName == "libmcenv_datatablereader_readcolumndownsampled") 
+		*ppProcAddress = (void*) &libmcenv_datatablereader_readcolumndownsampled;
+	if (sProcName == "libmcenv_datatablereader_findchunksinvaluerange") 
+		*ppProcAddress = (void*) &libmcenv_datatablereader_findchunksinvaluerange;
+	if (sProcName == "libmcenv_datatablereader_extractdatatable") 
+		*ppProcAddress = (void*) &libmcenv_datatablereader_extractdatatable;
 	if (sProcName == "libmcenv_dataseries_getname") 
 		*ppProcAddress = (void*) &libmcenv_dataseries_getname;
 	if (sProcName == "libmcenv_dataseries_getuuid") 
@@ -39079,6 +41693,20 @@ LibMCEnvResult LibMCEnv::Impl::LibMCEnv_GetProcAddress (const char * pProcName,
 		*ppProcAddress = (void*) &libmcenv_buildexecution_getmetadatastring;
 	if (sProcName == "libmcenv_buildexecution_loadattachedjournal") 
 		*ppProcAddress = (void*) &libmcenv_buildexecution_loadattachedjournal;
+	if (sProcName == "libmcenv_buildexecution_createdatacaptureoptions") 
+		*ppProcAddress = (void*) &libmcenv_buildexecution_createdatacaptureoptions;
+	if (sProcName == "libmcenv_buildexecution_createdatacapture") 
+		*ppProcAddress = (void*) &libmcenv_buildexecution_createdatacapture;
+	if (sProcName == "libmcenv_buildexecution_hasdatacapture") 
+		*ppProcAddress = (void*) &libmcenv_buildexecution_hasdatacapture;
+	if (sProcName == "libmcenv_buildexecution_getdatacapturerowcount") 
+		*ppProcAddress = (void*) &libmcenv_buildexecution_getdatacapturerowcount;
+	if (sProcName == "libmcenv_buildexecution_getdatacapturesegmentcount") 
+		*ppProcAddress = (void*) &libmcenv_buildexecution_getdatacapturesegmentcount;
+	if (sProcName == "libmcenv_buildexecution_loaddatacapturesegment") 
+		*ppProcAddress = (void*) &libmcenv_buildexecution_loaddatacapturesegment;
+	if (sProcName == "libmcenv_buildexecution_opendatacapturereader") 
+		*ppProcAddress = (void*) &libmcenv_buildexecution_opendatacapturereader;
 	if (sProcName == "libmcenv_buildexecutioniterator_getcurrentexecution") 
 		*ppProcAddress = (void*) &libmcenv_buildexecutioniterator_getcurrentexecution;
 	if (sProcName == "libmcenv_builditerator_getcurrentbuild") 
@@ -39797,6 +42425,8 @@ LibMCEnvResult LibMCEnv::Impl::LibMCEnv_GetProcAddress (const char * pProcName,
 		*ppProcAddress = (void*) &libmcenv_zipstreamwriter_createzipentry;
 	if (sProcName == "libmcenv_zipstreamwriter_createzipentryfromstream") 
 		*ppProcAddress = (void*) &libmcenv_zipstreamwriter_createzipentryfromstream;
+	if (sProcName == "libmcenv_zipstreamwriter_discard") 
+		*ppProcAddress = (void*) &libmcenv_zipstreamwriter_discard;
 	if (sProcName == "libmcenv_streamreader_getuuid") 
 		*ppProcAddress = (void*) &libmcenv_streamreader_getuuid;
 	if (sProcName == "libmcenv_streamreader_getname") 
@@ -40379,6 +43009,16 @@ LibMCEnvResult LibMCEnv::Impl::LibMCEnv_GetProcAddress (const char * pProcName,
 		*ppProcAddress = (void*) &libmcenv_stateenvironment_evaluateformulaasinteger;
 	if (sProcName == "libmcenv_stateenvironment_evaluateformulaasbool") 
 		*ppProcAddress = (void*) &libmcenv_stateenvironment_evaluateformulaasbool;
+	if (sProcName == "libmcenv_stateenvironment_startstreamdownloadforsession") 
+		*ppProcAddress = (void*) &libmcenv_stateenvironment_startstreamdownloadforsession;
+	if (sProcName == "libmcenv_stateenvironment_getstreamdownloadprogress") 
+		*ppProcAddress = (void*) &libmcenv_stateenvironment_getstreamdownloadprogress;
+	if (sProcName == "libmcenv_stateenvironment_cancelstreamdownloads") 
+		*ppProcAddress = (void*) &libmcenv_stateenvironment_cancelstreamdownloads;
+	if (sProcName == "libmcenv_stateenvironment_deletestoragestream") 
+		*ppProcAddress = (void*) &libmcenv_stateenvironment_deletestoragestream;
+	if (sProcName == "libmcenv_stateenvironment_enforcestreamretention") 
+		*ppProcAddress = (void*) &libmcenv_stateenvironment_enforcestreamretention;
 	if (sProcName == "libmcenv_uiitem_getname") 
 		*ppProcAddress = (void*) &libmcenv_uiitem_getname;
 	if (sProcName == "libmcenv_uiitem_getpath") 
diff --git a/Framework/InterfacesCore/libmcenv_types.hpp b/Framework/InterfacesCore/libmcenv_types.hpp
index da7f6da02..1afb4cd64 100644
--- a/Framework/InterfacesCore/libmcenv_types.hpp
+++ b/Framework/InterfacesCore/libmcenv_types.hpp
@@ -364,6 +364,43 @@ typedef void * LibMCEnv_pvoid;
 #define LIBMCENV_ERROR_FORMULAEVALUATIONFAILED 10267 /** Formula evaluation failed. */
 #define LIBMCENV_ERROR_FORMULASESSIONREFERENCESNOTAVAILABLE 10268 /** Session and user references are only available in formulas of the UI environment. */
 #define LIBMCENV_ERROR_INVALIDFORMULAREFERENCEINDEX 10269 /** Invalid formula reference index. */
+#define LIBMCENV_ERROR_COLUMNISNOTOFTYPEFLOAT 10270 /** Column is not of type float. */
+#define LIBMCENV_ERROR_COLUMNISNOTOFTYPEBOOL 10271 /** Column is not of type bool. */
+#define LIBMCENV_ERROR_COLUMNISNOTOFTYPETIMESTAMP 10272 /** Column is not of type timestamp. */
+#define LIBMCENV_ERROR_UNSUPPORTEDDATATABLEVERSION 10273 /** Unsupported datatable format version. */
+#define LIBMCENV_ERROR_UNSUPPORTEDDATATABLEENCODING 10274 /** Unsupported datatable column encoding. */
+#define LIBMCENV_ERROR_INVALIDDATATABLECOLUMNHEADER 10275 /** Invalid datatable column header. */
+#define LIBMCENV_ERROR_DATACAPTURENOTCONFIGURABLE 10276 /** Data capture schema is frozen and can not be changed anymore. */
+#define LIBMCENV_ERROR_DATACAPTURENOTRECORDING 10277 /** Data capture is not recording. */
+#define LIBMCENV_ERROR_DATACAPTURECHUNKALREADYOPEN 10278 /** Data capture has an uncommitted chunk already. */
+#define LIBMCENV_ERROR_DATACAPTURECHUNKINVALID 10279 /** Data capture chunk is invalid or has been committed already. */
+#define LIBMCENV_ERROR_DATACAPTURECHUNKINCOMPLETE 10280 /** Data capture chunk columns have different row counts. */
+#define LIBMCENV_ERROR_DATACAPTURECHUNKOVERFLOW 10281 /** Data capture chunk capacity exceeded. */
+#define LIBMCENV_ERROR_DATACAPTUREQUEUEFULL 10282 /** Data capture queue is full. */
+#define LIBMCENV_ERROR_DATACAPTUREWRITERFAILED 10283 /** Data capture writer failed. */
+#define LIBMCENV_ERROR_INVALIDDATACAPTUREOPTION 10284 /** Invalid data capture option. */
+#define LIBMCENV_ERROR_DATACAPTUREROWNOTOPEN 10285 /** Data capture chunk has no open row. */
+#define LIBMCENV_ERROR_DATACAPTUREROWALREADYOPEN 10286 /** Data capture chunk has an open row already. */
+#define LIBMCENV_ERROR_DATACAPTUREVALUEOUTOFRANGE 10287 /** Data capture value is out of range for the column type. */
+#define LIBMCENV_ERROR_DATACAPTURESEGMENTPURGED 10288 /** Data capture segment has been deleted by retention. */
+#define LIBMCENV_ERROR_EMPTYDATACAPTURENAME 10289 /** Empty data capture name. */
+#define LIBMCENV_ERROR_EMPTYDATACAPTUREIDENTIFIER 10290 /** Empty data capture identifier. */
+#define LIBMCENV_ERROR_INVALIDDATACAPTUREIDENTIFIER 10291 /** Invalid data capture identifier. */
+#define LIBMCENV_ERROR_DATACAPTUREEXECUTIONNOTINPROCESS 10292 /** Data captures can only be created while the build execution is in process. */
+#define LIBMCENV_ERROR_DATATABLESEGMENTTRUNCATED 10293 /** Datatable segment is truncated and has no footer. */
+#define LIBMCENV_ERROR_UNSUPPORTEDDATATABLECODEC 10294 /** Unsupported datatable page codec. */
+#define LIBMCENV_ERROR_INVALIDDATATABLESEGMENT 10295 /** Invalid datatable segment. */
+#define LIBMCENV_ERROR_DATACAPTURECHUNKOUTSTANDING 10296 /** Data capture has an uncommitted chunk. */
+#define LIBMCENV_ERROR_DATACAPTURECOLUMNTYPEMISMATCH 10297 /** Data capture column has a different type. */
+#define LIBMCENV_ERROR_INVALIDDATACAPTURESEGMENTINDEX 10298 /** Invalid data capture segment index. */
+#define LIBMCENV_ERROR_DATACAPTURECOLUMNNOTFOUND 10299 /** Data capture column not found. */
+#define LIBMCENV_ERROR_INVALIDDATATABLEROWRANGE 10300 /** Invalid datatable row range. */
+#define LIBMCENV_ERROR_INVALIDDOWNSAMPLEPARAMETERS 10301 /** Invalid downsample parameters. */
+#define LIBMCENV_ERROR_DATATABLECOLUMNTYPEMISMATCH 10302 /** Datatable column can not be read as the requested type. */
+#define LIBMCENV_ERROR_INVALIDDATATABLECHUNKINDEX 10303 /** Invalid datatable chunk index. */
+#define LIBMCENV_ERROR_STREAMHASACTIVEDOWNLOADS 10304 /** Storage stream has active downloads. */
+#define LIBMCENV_ERROR_ZIPSTREAMALREADYFINISHED 10305 /** ZIP stream has already been finished. */
+#define LIBMCENV_ERROR_SESSIONHANDLERNOTAVAILABLE 10306 /** Session handler is not available. */
 
 /*************************************************************************************************************************
  Error strings for LibMCEnv
@@ -640,6 +677,43 @@ inline const char * LIBMCENV_GETERRORSTRING (LibMCEnvResult nErrorCode) {
     case LIBMCENV_ERROR_FORMULAEVALUATIONFAILED: return "Formula evaluation failed.";
     case LIBMCENV_ERROR_FORMULASESSIONREFERENCESNOTAVAILABLE: return "Session and user references are only available in formulas of the UI environment.";
     case LIBMCENV_ERROR_INVALIDFORMULAREFERENCEINDEX: return "Invalid formula reference index.";
+    case LIBMCENV_ERROR_COLUMNISNOTOFTYPEFLOAT: return "Column is not of type float.";
+    case LIBMCENV_ERROR_COLUMNISNOTOFTYPEBOOL: return "Column is not of type bool.";
+    case LIBMCENV_ERROR_COLUMNISNOTOFTYPETIMESTAMP: return "Column is not of type timestamp.";
+    case LIBMCENV_ERROR_UNSUPPORTEDDATATABLEVERSION: return "Unsupported datatable format version.";
+    case LIBMCENV_ERROR_UNSUPPORTEDDATATABLEENCODING: return "Unsupported datatable column encoding.";
+    case LIBMCENV_ERROR_INVALIDDATATABLECOLUMNHEADER: return "Invalid datatable column header.";
+    case LIBMCENV_ERROR_DATACAPTURENOTCONFIGURABLE: return "Data capture schema is frozen and can not be changed anymore.";
+    case LIBMCENV_ERROR_DATACAPTURENOTRECORDING: return "Data capture is not recording.";
+    case LIBMCENV_ERROR_DATACAPTURECHUNKALREADYOPEN: return "Data capture has an uncommitted chunk already.";
+    case LIBMCENV_ERROR_DATACAPTURECHUNKINVALID: return "Data capture chunk is invalid or has been committed already.";
+    case LIBMCENV_ERROR_DATACAPTURECHUNKINCOMPLETE: return "Data capture chunk columns have different row counts.";
+    case LIBMCENV_ERROR_DATACAPTURECHUNKOVERFLOW: return "Data capture chunk capacity exceeded.";
+    case LIBMCENV_ERROR_DATACAPTUREQUEUEFULL: return "Data capture queue is full.";
+    case LIBMCENV_ERROR_DATACAPTUREWRITERFAILED: return "Data capture writer failed.";
+    case LIBMCENV_ERROR_INVALIDDATACAPTUREOPTION: return "Invalid data capture option.";
+    case LIBMCENV_ERROR_DATACAPTUREROWNOTOPEN: return "Data capture chunk has no open row.";
+    case LIBMCENV_ERROR_DATACAPTUREROWALREADYOPEN: return "Data capture chunk has an open row already.";
+    case LIBMCENV_ERROR_DATACAPTUREVALUEOUTOFRANGE: return "Data capture value is out of range for the column type.";
+    case LIBMCENV_ERROR_DATACAPTURESEGMENTPURGED: return "Data capture segment has been deleted by retention.";
+    case LIBMCENV_ERROR_EMPTYDATACAPTURENAME: return "Empty data capture name.";
+    case LIBMCENV_ERROR_EMPTYDATACAPTUREIDENTIFIER: return "Empty data capture identifier.";
+    case LIBMCENV_ERROR_INVALIDDATACAPTUREIDENTIFIER: return "Invalid data capture identifier.";
+    case LIBMCENV_ERROR_DATACAPTUREEXECUTIONNOTINPROCESS: return "Data captures can only be created while the build execution is in process.";
+    case LIBMCENV_ERROR_DATATABLESEGMENTTRUNCATED: return "Datatable segment is truncated and has no footer.";
+    case LIBMCENV_ERROR_UNSUPPORTEDDATATABLECODEC: return "Unsupported datatable page codec.";
+    case LIBMCENV_ERROR_INVALIDDATATABLESEGMENT: return "Invalid datatable segment.";
+    case LIBMCENV_ERROR_DATACAPTURECHUNKOUTSTANDING: return "Data capture has an uncommitted chunk.";
+    case LIBMCENV_ERROR_DATACAPTURECOLUMNTYPEMISMATCH: return "Data capture column has a different type.";
+    case LIBMCENV_ERROR_INVALIDDATACAPTURESEGMENTINDEX: return "Invalid data capture segment index.";
+    case LIBMCENV_ERROR_DATACAPTURECOLUMNNOTFOUND: return "Data capture column not found.";
+    case LIBMCENV_ERROR_INVALIDDATATABLEROWRANGE: return "Invalid datatable row range.";
+    case LIBMCENV_ERROR_INVALIDDOWNSAMPLEPARAMETERS: return "Invalid downsample parameters.";
+    case LIBMCENV_ERROR_DATATABLECOLUMNTYPEMISMATCH: return "Datatable column can not be read as the requested type.";
+    case LIBMCENV_ERROR_INVALIDDATATABLECHUNKINDEX: return "Invalid datatable chunk index.";
+    case LIBMCENV_ERROR_STREAMHASACTIVEDOWNLOADS: return "Storage stream has active downloads.";
+    case LIBMCENV_ERROR_ZIPSTREAMALREADYFINISHED: return "ZIP stream has already been finished.";
+    case LIBMCENV_ERROR_SESSIONHANDLERNOTAVAILABLE: return "Session handler is not available.";
     default: return "unknown error";
   }
 }
@@ -670,6 +744,10 @@ typedef LibMCEnvHandle LibMCEnv_ScatterPlotDataChannel;
 typedef LibMCEnvHandle LibMCEnv_ScatterPlotDataChannelIterator;
 typedef LibMCEnvHandle LibMCEnv_DataTableScatterPlotOptions;
 typedef LibMCEnvHandle LibMCEnv_DataTable;
+typedef LibMCEnvHandle LibMCEnv_DataCaptureOptions;
+typedef LibMCEnvHandle LibMCEnv_DataCaptureChunk;
+typedef LibMCEnvHandle LibMCEnv_DataCapture;
+typedef LibMCEnvHandle LibMCEnv_DataTableReader;
 typedef LibMCEnvHandle LibMCEnv_DataSeries;
 typedef LibMCEnvHandle LibMCEnv_DateTimeDifference;
 typedef LibMCEnvHandle LibMCEnv_DateTime;
@@ -885,7 +963,48 @@ namespace LibMCEnv {
     Int32Column = 2,
     Uint32Column = 3,
     Int64Column = 4,
-    Uint64Column = 5
+    Uint64Column = 5,
+    FloatColumn = 6,
+    BoolColumn = 7,
+    TimestampColumn = 8
+  };
+  
+  enum class eDataCaptureBackpressureMode : LibMCEnv_int32 {
+    Unknown = 0,
+    Block = 1,
+    DropOldest = 2,
+    Fail = 3
+  };
+  
+  enum class eDataCaptureCompression : LibMCEnv_int32 {
+    Unknown = 0,
+    None = 1,
+    LZ4 = 2,
+    Deflate = 3
+  };
+  
+  enum class eDataCaptureEncoding : LibMCEnv_int32 {
+    Unknown = 0,
+    Automatic = 1,
+    Plain = 2,
+    Delta = 3,
+    BitPack = 4
+  };
+  
+  enum class eDataTableDownsampleMode : LibMCEnv_int32 {
+    Unknown = 0,
+    Stride = 1,
+    MinMax = 2,
+    Average = 3
+  };
+  
+  enum class eDataCaptureStatus : LibMCEnv_int32 {
+    Unknown = 0,
+    Configuring = 1,
+    Recording = 2,
+    Finished = 3,
+    Aborted = 4,
+    Failed = 5
   };
   
   enum class eTelemetryChannelType : LibMCEnv_int32 {
@@ -1014,6 +1133,11 @@ typedef LibMCEnv::eMessageDialogType eLibMCEnvMessageDialogType;
 typedef LibMCEnv::eWorkingFileProcessStatus eLibMCEnvWorkingFileProcessStatus;
 typedef LibMCEnv::eBuildExecutionStatus eLibMCEnvBuildExecutionStatus;
 typedef LibMCEnv::eDataTableColumnType eLibMCEnvDataTableColumnType;
+typedef LibMCEnv::eDataCaptureBackpressureMode eLibMCEnvDataCaptureBackpressureMode;
+typedef LibMCEnv::eDataCaptureCompression eLibMCEnvDataCaptureCompression;
+typedef LibMCEnv::eDataCaptureEncoding eLibMCEnvDataCaptureEncoding;
+typedef LibMCEnv::eDataTableDownsampleMode eLibMCEnvDataTableDownsampleMode;
+typedef LibMCEnv::eDataCaptureStatus eLibMCEnvDataCaptureStatus;
 typedef LibMCEnv::eTelemetryChannelType eLibMCEnvTelemetryChannelType;
 typedef LibMCEnv::eSignalPhase eLibMCEnvSignalPhase;
 typedef LibMCEnv::sPosition2D sLibMCEnvPosition2D;
diff --git a/Implementation/API/amc_api.cpp b/Implementation/API/amc_api.cpp
index edfbb5733..a75f9c199 100644
--- a/Implementation/API/amc_api.cpp
+++ b/Implementation/API/amc_api.cpp
@@ -123,6 +123,8 @@ eAPIRequestType CAPI::getRequestTypeFromString(const std::string& sRequestType)
 		return AMC::eAPIRequestType::rtPost;
 	if (sLowerCaseType == "put")
 		return AMC::eAPIRequestType::rtPut;
+	if (sLowerCaseType == "head")
+		return AMC::eAPIRequestType::rtHead;
 
 	throw ELibMCInterfaceException(LIBMC_ERROR_INVALIDAPIREQUESTTYPE);
 }
diff --git a/Implementation/API/amc_api_constants.hpp b/Implementation/API/amc_api_constants.hpp
index 5f26fec58..09a324d55 100644
--- a/Implementation/API/amc_api_constants.hpp
+++ b/Implementation/API/amc_api_constants.hpp
@@ -40,6 +40,14 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define AMC_API_HTTP_BADREQUEST 400
 #define AMC_API_HTTP_FORBIDDEN 403
 #define AMC_API_HTTP_NOTFOUND 404
+#define AMC_API_HTTP_CONFLICT 409
+#define AMC_API_HTTP_GONE 410
+#define AMC_API_HTTP_SERVICEUNAVAILABLE 503
+
+// Download tickets stay valid this long; the ticket is the only credential of a download link.
+#define AMC_API_DOWNLOADTICKET_LIFETIME_SECONDS (24 * 3600)
+// Largest chunk the HTTP server may read from a streamed response at once.
+#define AMC_API_DOWNLOADCHUNK_MAXLENGTH (16 * 1024 * 1024)
 
 #define AMC_API_PROTOCOL_VERSION "2.0.0"
 #define AMC_API_PROTOCOL_ERROR "com.autodesk.error"
@@ -78,6 +86,9 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define AMC_API_KEY_FRONTEND_STREAMTICKET "ticket"
 #define AMC_API_KEY_FRONTEND_STREAMTICKETLIFETIME "lifetime"
 #define AMC_API_KEY_FRONTEND_STREAMCLIENT "client"
+#define AMC_API_KEY_FRONTEND_PENDINGACTIONS "pendingactions"
+#define AMC_API_KEY_FRONTEND_ACTIONUUID "actionuuid"
+#define AMC_API_KEY_FRONTEND_CLAIMED "claimed"
 #define AMC_API_KEY_UI_PARAMETERLIST_DEFINITIONHASH "definitionhash"
 #define AMC_API_KEY_UI_PARAMETERLIST_VALUESHASH "valueshash"
 #define AMC_API_KEY_UI_PARAMETERLIST_VALUES "values"
@@ -208,6 +219,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define AMC_API_KEY_UI_COMPONENTNAME "component"
 #define AMC_API_KEY_UI_DIALOGNAME "name"
 #define AMC_API_KEY_UI_DIALOGTITLE "title"
+#define AMC_API_KEY_UI_DIALOGACTIVE "active"
+#define AMC_API_KEY_UI_DIALOGCLOSABLE "closable"
 #define AMC_API_KEY_UI_PAGES "pages"
 #define AMC_API_KEY_UI_CUSTOMPAGES "custompages"
 #define AMC_API_KEY_UI_DIALOGS "dialogs"
@@ -316,6 +329,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define AMC_API_KEY_UI_BUTTONVISIBLE "visible"
 #define AMC_API_KEY_UI_BUTTONEVENT "event"
 #define AMC_API_KEY_UI_BUTTONICON "icon"
+#define AMC_API_KEY_UI_BUTTONHINT "hint"
 #define AMC_API_KEY_UI_BUTTONEVENTFORMVALUES "eventformvalues"
 #define AMC_API_KEY_UI_ITEMUPLOADCLASS "uploadclass"
 #define AMC_API_KEY_UI_ITEMUPLOADCAPTION "uploadcaption"
diff --git a/Implementation/API/amc_api_factory.cpp b/Implementation/API/amc_api_factory.cpp
index 5154cee00..da7c24f4d 100644
--- a/Implementation/API/amc_api_factory.cpp
+++ b/Implementation/API/amc_api_factory.cpp
@@ -58,6 +58,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "API/amc_api_handler_widget.hpp"
 #include "API/amc_api_handler_image.hpp"
 #include "API/amc_api_handler_userpreferences.hpp"
+#include "API/amc_api_handler_datatable.hpp"
 
 using namespace AMC;
 CAPIFactory::CAPIFactory(PAPI pAPI, PSystemState pSystemState, std::vector <AMC::PStateMachineInstance>& MachineInstanceList)
@@ -91,6 +92,7 @@ CAPIFactory::CAPIFactory(PAPI pAPI, PSystemState pSystemState, std::vector <AMC:
 	pAPI->registerHandler(std::make_shared <CAPIHandler_Widget>(pSystemState));
 	pAPI->registerHandler(std::make_shared <CAPIHandler_Image>(pSystemState));
 	pAPI->registerHandler(std::make_shared <CAPIHandler_UserPreferences>(pSystemState));
+	pAPI->registerHandler(std::make_shared <CAPIHandler_DataTable>(pSystemState));
 	pAPI->registerHandler(std::make_shared <CAPIHandler_Auth>(pAPI->getSessionHandler (), pSystemState->getDataModelInstance(), pSystemState->getInstallationSecret (), pSystemState->getGitHash (), pSystemState->getClientHash (), pSystemState->getAccessControlInstance ()));
 
 }
diff --git a/Implementation/API/amc_api_frontendeventstream.cpp b/Implementation/API/amc_api_frontendeventstream.cpp
index ae7efe4c3..411ce10b4 100644
--- a/Implementation/API/amc_api_frontendeventstream.cpp
+++ b/Implementation/API/amc_api_frontendeventstream.cpp
@@ -229,6 +229,20 @@ std::string CAPIFrontendEventStream::waitForNextEvent(sJSONEventStreamCursor& cu
 		return "";
 	}
 
+	// Client actions queued by the server for this session (for example a download that a state machine
+	// prepared) are sent to every connection as an "actions" event whenever the queue changes. The event
+	// carries the last status revision as its ID, so that it does not disturb the resume point.
+	auto pFrontendState = pAuth->getFrontendState();
+	if (pFrontendState.get() != nullptr) {
+		uint64_t nActionsRevision = pFrontendState->getClientActionsRevision();
+		if (nActionsRevision != cursor.m_nActionsRevision) {
+			cursor.m_nActionsRevision = nActionsRevision;
+			CJSONWriter actionsWriter;
+			pFrontendState->writePendingClientActionsToJSON(actionsWriter);
+			return formatEvent(AMC_API_FRONTENDEVENTSTREAM_EVENT_ACTIONS, cursor.m_nLastEventID, actionsWriter.saveToString());
+		}
+	}
+
 	// The counter is read before the build, so that a change during the build triggers another one.
 	auto buildStart = std::chrono::steady_clock::now();
 	uint64_t nDataChangeCounter = pSystemState->stateMachineData()->getFrontendChangeCounter()->get();
diff --git a/Implementation/API/amc_api_frontendeventstream.hpp b/Implementation/API/amc_api_frontendeventstream.hpp
index 060249239..197b7ee33 100644
--- a/Implementation/API/amc_api_frontendeventstream.hpp
+++ b/Implementation/API/amc_api_frontendeventstream.hpp
@@ -62,6 +62,7 @@ status as a snapshot event and every later change as a patch event.
 
 #define AMC_API_FRONTENDEVENTSTREAM_EVENT_SNAPSHOT "snapshot"
 #define AMC_API_FRONTENDEVENTSTREAM_EVENT_PATCH "patch"
+#define AMC_API_FRONTENDEVENTSTREAM_EVENT_ACTIONS "actions"
 
 #define AMC_API_FRONTENDEVENTSTREAM_METRICSLABEL "stream"
 
diff --git a/Implementation/API/amc_api_handler.cpp b/Implementation/API/amc_api_handler.cpp
index fc8ea450c..2c5bcf6b8 100644
--- a/Implementation/API/amc_api_handler.cpp
+++ b/Implementation/API/amc_api_handler.cpp
@@ -53,6 +53,16 @@ namespace AMC {
 
 	}
 
+	void CAPIFormFields::setClientAddress(const std::string& sClientAddress)
+	{
+		m_sClientAddress = sClientAddress;
+	}
+
+	std::string CAPIFormFields::getClientAddress()
+	{
+		return m_sClientAddress;
+	}
+
 	void CAPIFormFields::addDataField (const std::string& sName, std::shared_ptr<std::vector<uint8_t>> pData)
 	{
 		m_FileData.insert(std::make_pair (sName, pData));
diff --git a/Implementation/API/amc_api_handler.hpp b/Implementation/API/amc_api_handler.hpp
index 7e66dc733..aff76bd49 100644
--- a/Implementation/API/amc_api_handler.hpp
+++ b/Implementation/API/amc_api_handler.hpp
@@ -67,11 +67,16 @@ namespace AMC {
 		std::map<std::string, std::shared_ptr <std::vector<uint8_t>>> m_FileData;
 		std::map<std::string, std::string> m_StringData;
 		std::map<std::string, std::string> m_RequestParameters;
+		std::string m_sClientAddress;
 
 
 	public:
 		CAPIFormFields();
 
+		// Network address of the client that sent the request, as reported by the HTTP server. May be empty.
+		void setClientAddress(const std::string& sClientAddress);
+		std::string getClientAddress();
+
 		void addDataField(const std::string& sName, std::shared_ptr<std::vector<uint8_t>> pData);
 		bool hasDataField(const std::string& sName);
 		std::shared_ptr<std::vector<uint8_t>> getDataField(const std::string& sName);
diff --git a/Implementation/API/amc_api_handler_datatable.cpp b/Implementation/API/amc_api_handler_datatable.cpp
new file mode 100644
index 000000000..4e4ae66bb
--- /dev/null
+++ b/Implementation/API/amc_api_handler_datatable.cpp
@@ -0,0 +1,304 @@
+/*++
+
+Copyright (C) 2020 Autodesk Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+	* Redistributions of source code must retain the above copyright
+	  notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+	  notice, this list of conditions and the following disclaimer in the
+	  documentation and/or other materials provided with the distribution.
+	* Neither the name of the Autodesk Inc. nor the
+	  names of its contributors may be used to endorse or promote products
+	  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL AUTODESK INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#include "amc_api_handler_datatable.hpp"
+#include "amc_api_constants.hpp"
+#include "amc_datacapturereader.hpp"
+#include "amc_datacapturequery.hpp"
+#include "amc_jsonwriter.hpp"
+
+#include "libmc_interfaceexception.hpp"
+#include "libmcdata_dynamic.hpp"
+#include "common_utils.hpp"
+#include "common_chrono.hpp"
+
+#include <iomanip>
+#include <sstream>
+
+using namespace AMC;
+
+#define AMC_API_PROTOCOL_DATATABLE "com.autodesk.machinecontrol.datatable"
+
+#define DATATABLE_UUIDLENGTH 36
+
+namespace
+{
+	std::string dataCaptureStatusToString(LibMCData::eDataCaptureStatus eStatus)
+	{
+		switch (eStatus) {
+		case LibMCData::eDataCaptureStatus::Recording: return "recording";
+		case LibMCData::eDataCaptureStatus::Finished: return "finished";
+		case LibMCData::eDataCaptureStatus::Aborted: return "aborted";
+		default: return "unknown";
+		}
+	}
+
+	// Parses a row number or count. Anything but decimal digits is an error: a typo must not
+	// silently turn into a request for the whole capture.
+	uint64_t parseUnsignedParameter(const std::string& sName, const std::string& sValue)
+	{
+		if (sValue.empty() || (sValue.length() > 19) || (sValue.find_first_not_of("0123456789") != std::string::npos))
+			throw ELibMCInterfaceException(LIBMC_ERROR_INVALIDPARAM, "invalid value for parameter " + sName + ": " + sValue);
+
+		return std::stoull(sValue);
+	}
+
+	std::vector<std::string> splitCommaSeparated(const std::string& sValue)
+	{
+		std::vector<std::string> result;
+		std::stringstream stream(sValue);
+		std::string sItem;
+		while (std::getline(stream, sItem, ','))
+			result.push_back(AMCCommon::CUtils::trimString(sItem));
+
+		return result;
+	}
+}
+
+CAPIHandler_DataTable::CAPIHandler_DataTable(PSystemState pSystemState)
+	: CAPIHandler(pSystemState->getClientHash()), m_pSystemState(pSystemState)
+{
+	if (pSystemState.get() == nullptr)
+		throw ELibMCInterfaceException(LIBMC_ERROR_INVALIDPARAM);
+}
+
+CAPIHandler_DataTable::~CAPIHandler_DataTable()
+{
+}
+
+std::string CAPIHandler_DataTable::getBaseURI()
+{
+	return "api/datatable";
+}
+
+PAPIResponse CAPIHandler_DataTable::handleExecutionListRequest(const std::string& sExecutionUUID)
+{
+	auto pDataModel = m_pSystemState->getDataModelInstance();
+	auto pBuildJobHandler = pDataModel->CreateBuildJobHandler();
+	auto pExecution = pBuildJobHandler->RetrieveJobExecution(AMCCommon::CUtils::normalizeUUIDString(sExecutionUUID));
+
+	CJSONWriter writer;
+	writeJSONHeader(writer, AMC_API_PROTOCOL_DATATABLE);
+	writer.addString("executionuuid", pExecution->GetExecutionUUID());
+
+	CJSONWriterArray capturesArray(writer);
+
+	uint32_t nCaptureCount = pExecution->GetDataCaptureCount();
+	for (uint32_t nIndex = 0; nIndex < nCaptureCount; nIndex++) {
+		auto pManifest = pExecution->RetrieveDataCaptureByIndex(nIndex);
+
+		CJSONWriterObject captureObject(writer);
+		captureObject.addString("uuid", pManifest->GetUUID());
+		captureObject.addString("identifier", pManifest->GetIdentifier());
+		captureObject.addString("name", pManifest->GetName());
+		captureObject.addString("status", dataCaptureStatusToString(pManifest->GetStatus()));
+		captureObject.addString("timestamp", pManifest->GetTimeStamp());
+		captureObject.addInteger("rowcount", (int64_t)pManifest->GetRowCount());
+		captureObject.addInteger("columncount", (int64_t)pManifest->GetColumnCount());
+		captureObject.addInteger("segmentcount", (int64_t)pManifest->GetSegmentCount());
+		captureObject.addInteger("storedsize", (int64_t)pManifest->GetStoredSizeInBytes());
+		capturesArray.addObject(captureObject);
+	}
+
+	writer.addArray("captures", capturesArray);
+	return std::make_shared<CAPIStringResponse>(AMC_API_HTTP_SUCCESS, AMC_API_CONTENTTYPE, writer.saveToString());
+}
+
+PAPIResponse CAPIHandler_DataTable::handleInfoRequest(const std::string& sCaptureUUID)
+{
+	auto pDataModel = m_pSystemState->getDataModelInstance();
+	auto pManifest = pDataModel->CreateBuildJobHandler()->RetrieveDataCapture(sCaptureUUID);
+
+	auto pReader = std::make_shared<CDataCaptureReader>(pDataModel, pManifest);
+	CDataCaptureQuery query(pReader);
+
+	CJSONWriter writer;
+	writeJSONHeader(writer, AMC_API_PROTOCOL_DATATABLE);
+	writer.addString("status", dataCaptureStatusToString(pManifest->GetStatus()));
+	writer.addString("executionuuid", pManifest->GetExecutionUUID());
+	writer.addString("timestamp", pManifest->GetTimeStamp());
+	writer.addInteger("maxvaluecount", DATACAPTUREQUERY_MAXVALUECOUNT);
+	writer.addInteger("maxtargetpoints", DATACAPTUREQUERY_MAXTARGETPOINTS);
+	query.writeInfo(writer);
+
+	return std::make_shared<CAPIStringResponse>(AMC_API_HTTP_SUCCESS, AMC_API_CONTENTTYPE, writer.saveToString());
+}
+
+PAPIResponse CAPIHandler_DataTable::handleDataRequest(const std::string& sCaptureUUID, CAPIFormFields& pFormFields)
+{
+	sDataCaptureQuery query;
+
+	if (pFormFields.hasRequestParameter("columns"))
+		query.m_ColumnIdentifiers = splitCommaSeparated(pFormFields.getRequestParameter("columns", false));
+
+	if (pFormFields.hasRequestParameter("fromrow")) {
+		query.m_bHasFromRow = true;
+		query.m_nFromRow = parseUnsignedParameter("fromrow", pFormFields.getRequestParameter("fromrow", false));
+	}
+
+	if (pFormFields.hasRequestParameter("rowcount")) {
+		query.m_bHasRowCount = true;
+		query.m_nRowCount = parseUnsignedParameter("rowcount", pFormFields.getRequestParameter("rowcount", false));
+	}
+
+	if (pFormFields.hasRequestParameter("downsample"))
+		query.m_Downsample = CDataCaptureQuery::parseDownsample(pFormFields.getRequestParameter("downsample", false));
+
+	// count is the name of this parameter in the journal envelope request.
+	std::string sTargetPointsName = pFormFields.hasRequestParameter("targetpoints") ? "targetpoints" : "count";
+	if (pFormFields.hasRequestParameter(sTargetPointsName)) {
+		uint64_t nTargetPoints = parseUnsignedParameter(sTargetPointsName, pFormFields.getRequestParameter(sTargetPointsName, false));
+		if (nTargetPoints > DATACAPTUREQUERY_MAXTARGETPOINTS)
+			throw ELibMCInterfaceException(LIBMC_ERROR_INVALIDPARAM, sTargetPointsName + " must be between 1 and " + std::to_string(DATACAPTUREQUERY_MAXTARGETPOINTS));
+		query.m_nTargetPoints = (uint32_t)nTargetPoints;
+	}
+
+	std::string sFormat = "json";
+	if (pFormFields.hasRequestParameter("format"))
+		sFormat = AMCCommon::CUtils::toLowerString(pFormFields.getRequestParameter("format", false));
+
+	if ((sFormat != "json") && (sFormat != "csv") && (sFormat != "bin") && (sFormat != "bin32"))
+		throw ELibMCInterfaceException(LIBMC_ERROR_INVALIDPARAM, "invalid format: " + sFormat + " (expected json, csv, bin or bin32)");
+
+	auto pDataModel = m_pSystemState->getDataModelInstance();
+	auto pManifest = pDataModel->CreateBuildJobHandler()->RetrieveDataCapture(sCaptureUUID);
+
+	auto pReader = std::make_shared<CDataCaptureReader>(pDataModel, pManifest);
+	CDataCaptureQuery captureQuery(pReader);
+
+	if (sFormat == "csv") {
+		auto pResponse = std::make_shared<CAPIStringResponse>(AMC_API_HTTP_SUCCESS, "text/csv", captureQuery.buildCSV(query));
+		pResponse->setContentDispositionName(pManifest->GetIdentifier() + ".csv");
+		return pResponse;
+	}
+
+	if ((sFormat == "bin") || (sFormat == "bin32")) {
+		auto pResponse = std::make_shared<CAPIFixedBufferResponse>("application/octet-stream");
+		captureQuery.buildBinary(query, (sFormat == "bin32"), pResponse->getBuffer());
+		return pResponse;
+	}
+
+	// The data arrays are written directly, because values may be NaN and a capture may hold 64 bit integers.
+	std::string sJSON = "{\"" AMC_API_KEY_PROTOCOL "\":\"" AMC_API_PROTOCOL_DATATABLE "\",\"" AMC_API_KEY_VERSION "\":\"" AMC_API_PROTOCOL_VERSION "\",";
+	captureQuery.appendJSONMembers(query, sJSON);
+	sJSON += "}";
+
+	return std::make_shared<CAPIStringResponse>(AMC_API_HTTP_SUCCESS, AMC_API_CONTENTTYPE, sJSON);
+}
+
+PAPIResponse CAPIHandler_DataTable::handleSegmentTicketRequest(const std::string& sCaptureUUID, const std::string& sSegmentIndex, PAPIAuth pAuth)
+{
+	uint64_t nSegmentIndex = parseUnsignedParameter("segment index", sSegmentIndex);
+
+	auto pDataModel = m_pSystemState->getDataModelInstance();
+	auto pManifest = pDataModel->CreateBuildJobHandler()->RetrieveDataCapture(sCaptureUUID);
+
+	if (nSegmentIndex >= pManifest->GetSegmentCount())
+		throw ELibMCInterfaceException(LIBMC_ERROR_INVALIDPARAM, "invalid segment index: " + sSegmentIndex);
+
+	std::string sStreamUUID;
+	uint64_t nFirstRow = 0;
+	uint64_t nRowCount = 0;
+	uint64_t nSizeInBytes = 0;
+	bool bIsPurged = false;
+	pManifest->GetSegmentInformation((uint32_t)nSegmentIndex, sStreamUUID, nFirstRow, nRowCount, nSizeInBytes, bIsPurged);
+
+	if (bIsPurged)
+		throw ELibMCInterfaceException(LIBMC_ERROR_INVALIDPARAM, "segment " + sSegmentIndex + " has been deleted by retention");
+
+	std::stringstream sFileName;
+	sFileName << pManifest->GetIdentifier() << "_segment" << std::setw(4) << std::setfill('0') << nSegmentIndex << ".datatable";
+
+	// The segment is downloaded through the ticket flow of the download handler.
+	std::string sTicketUUID = pAuth->createStreamDownloadTicket(sStreamUUID, sFileName.str());
+
+	auto pStorage = pDataModel->CreateStorage();
+	pStorage->CreateDownloadTicket(sTicketUUID, sStreamUUID, sFileName.str(), pAuth->getSessionUUID(), pAuth->getUserUUID(), m_pSystemState->globalChrono()->getUTCTimeStampInMicrosecondsSince1970());
+
+	CJSONWriter writer;
+	writeJSONHeader(writer, AMC_API_PROTOCOL_DATATABLE);
+	writer.addString("ticketuuid", sTicketUUID);
+	writer.addString("filename", sFileName.str());
+	writer.addString("url", "api/download/" + sTicketUUID);
+	writer.addInteger("segmentindex", (int64_t)nSegmentIndex);
+	writer.addInteger("firstrow", (int64_t)nFirstRow);
+	writer.addInteger("rowcount", (int64_t)nRowCount);
+	writer.addInteger("size", (int64_t)nSizeInBytes);
+
+	return std::make_shared<CAPIStringResponse>(AMC_API_HTTP_SUCCESS, AMC_API_CONTENTTYPE, writer.saveToString());
+}
+
+PAPIResponse CAPIHandler_DataTable::handleRequest(const std::string& sURI, const eAPIRequestType requestType, CAPIFormFields& pFormFields, const uint8_t* pBodyData, const size_t nBodyDataSize, PAPIAuth pAuth)
+{
+	pBodyData;
+	nBodyDataSize;
+
+	if (pAuth.get() == nullptr)
+		throw ELibMCInterfaceException(LIBMC_ERROR_INVALIDPARAM);
+	if (requestType != eAPIRequestType::rtGet)
+		return nullptr;
+
+	auto sParameterString = sURI.substr(getBaseURI().length());
+
+	// Normalize any trailing slash
+	if (!sParameterString.empty() && (sParameterString.back() == '/'))
+		sParameterString = sParameterString.substr(0, sParameterString.length() - 1);
+
+	// GET api/datatable/execution/{executionuuid}
+	const std::string sExecutionPrefix = "/execution/";
+	if (sParameterString.substr(0, sExecutionPrefix.length()) == sExecutionPrefix) {
+		std::string sExecutionUUID = sParameterString.substr(sExecutionPrefix.length());
+		if (sExecutionUUID.length() != DATATABLE_UUIDLENGTH)
+			return nullptr;
+
+		return handleExecutionListRequest(sExecutionUUID);
+	}
+
+	if ((sParameterString.length() < DATATABLE_UUIDLENGTH + 1) || (sParameterString[0] != '/'))
+		return nullptr;
+
+	std::string sCaptureUUID = AMCCommon::CUtils::normalizeUUIDString(sParameterString.substr(1, DATATABLE_UUIDLENGTH));
+	std::string sSubPath = sParameterString.substr(DATATABLE_UUIDLENGTH + 1);
+
+	// GET api/datatable/{captureuuid}
+	if (sSubPath.empty())
+		return handleDataRequest(sCaptureUUID, pFormFields);
+
+	// GET api/datatable/{captureuuid}/info
+	if (sSubPath == "/info")
+		return handleInfoRequest(sCaptureUUID);
+
+	// GET api/datatable/{captureuuid}/segment/{index}
+	const std::string sSegmentPrefix = "/segment/";
+	if (sSubPath.substr(0, sSegmentPrefix.length()) == sSegmentPrefix)
+		return handleSegmentTicketRequest(sCaptureUUID, sSubPath.substr(sSegmentPrefix.length()), pAuth);
+
+	return nullptr;
+}
diff --git a/Implementation/API/amc_api_handler_datatable.hpp b/Implementation/API/amc_api_handler_datatable.hpp
new file mode 100644
index 000000000..be9ae9123
--- /dev/null
+++ b/Implementation/API/amc_api_handler_datatable.hpp
@@ -0,0 +1,84 @@
+/*++
+
+Copyright (C) 2020 Autodesk Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+	* Redistributions of source code must retain the above copyright
+	  notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+	  notice, this list of conditions and the following disclaimer in the
+	  documentation and/or other materials provided with the distribution.
+	* Neither the name of the Autodesk Inc. nor the
+	  names of its contributors may be used to endorse or promote products
+	  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL AUTODESK INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+
+#ifndef __AMC_API_HANDLER_DATATABLE
+#define __AMC_API_HANDLER_DATATABLE
+
+#include "amc_api_handler.hpp"
+#include "amc_api_response.hpp"
+#include "amc_systemstate.hpp"
+
+#include <vector>
+#include <string>
+
+namespace AMC {
+
+	/*************************************************************************************************************************
+	 Serves streaming data captures to the frontend.
+
+	   GET api/datatable/execution/{executionuuid}      captures of a build execution
+	   GET api/datatable/{captureuuid}/info             schema, row counts, segments and value ranges
+	   GET api/datatable/{captureuuid}                  data, selected by query parameters:
+	         format=json|csv|bin|bin32                   default json; bin is float64, bin32 is float32
+	         columns=a,b                                 default all columns
+	         fromrow=N  rowcount=N                       default everything that is still stored
+	         downsample=none|stride|minmax|average       default none
+	         targetpoints=N                              default 1000; count is accepted as an alias
+	   GET api/datatable/{captureuuid}/segment/{index}  download ticket for one segment stream
+
+	 Responses are buffered as a whole, so the data endpoint enforces a size cap and rejects larger requests
+	 with an error that names the parameters to reduce it. A full capture is exported segment by segment
+	 through download tickets. The handler requires an authorized session, like the build handler.
+	**************************************************************************************************************************/
+
+	class CAPIHandler_DataTable : public CAPIHandler {
+	private:
+		PSystemState m_pSystemState;
+
+		PAPIResponse handleExecutionListRequest(const std::string& sExecutionUUID);
+		PAPIResponse handleInfoRequest(const std::string& sCaptureUUID);
+		PAPIResponse handleDataRequest(const std::string& sCaptureUUID, CAPIFormFields& pFormFields);
+		PAPIResponse handleSegmentTicketRequest(const std::string& sCaptureUUID, const std::string& sSegmentIndex, PAPIAuth pAuth);
+
+	public:
+
+		CAPIHandler_DataTable(PSystemState pSystemState);
+
+		virtual ~CAPIHandler_DataTable();
+
+		virtual std::string getBaseURI() override;
+
+		virtual PAPIResponse handleRequest(const std::string& sURI, const eAPIRequestType requestType, CAPIFormFields& pFormFields, const uint8_t* pBodyData, const size_t nBodyDataSize, PAPIAuth pAuth) override;
+	};
+
+}
+
+#endif //__AMC_API_HANDLER_DATATABLE
diff --git a/Implementation/API/amc_api_handler_download.cpp b/Implementation/API/amc_api_handler_download.cpp
index a4b8993f6..7d9afb537 100644
--- a/Implementation/API/amc_api_handler_download.cpp
+++ b/Implementation/API/amc_api_handler_download.cpp
@@ -34,6 +34,9 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "libmcdata_dynamic.hpp"
 #include "common_utils.hpp"
 #include "common_chrono.hpp"
+#include "amc_api.hpp"
+#include "amc_api_constants.hpp"
+#include "amc_streamdownloadregistry.hpp"
 
 using namespace AMC;
 
@@ -71,7 +74,8 @@ PAPIResponse CAPIHandler_Download::handleRequest(const std::string& sURI, const
 
 	if (pAuth.get() == nullptr)
 		throw ELibMCInterfaceException(LIBMC_ERROR_INVALIDPARAM);
-	if (requestType != eAPIRequestType::rtGet)
+	bool bHeadOnly = (requestType == eAPIRequestType::rtHead);
+	if ((requestType != eAPIRequestType::rtGet) && (!bHeadOnly))
 		throw ELibMCInterfaceException(LIBMC_ERROR_INVALIDPARAM);
 
 	auto sParameterString = sURI.substr(getBaseURI().length());
@@ -82,23 +86,36 @@ PAPIResponse CAPIHandler_Download::handleRequest(const std::string& sURI, const
 
 	auto pDataModel = m_pSystemState->getDataModelInstance();
 	auto pStorage = pDataModel->CreateStorage();
-	auto pGlobalChrono = m_pSystemState->globalChrono();
+	auto pGlobalChrono = m_pSystemState->getGlobalChronoInstance();
+	uint64_t nNow = pGlobalChrono->getUTCTimeStampInMicrosecondsSince1970();
 
-	std::string sIPAddress;
 	std::string sStreamUUID;
 	std::string sSessionUUID;
 	std::string sUserUUID;
 	std::string sDownloadFileName;
+	uint64_t nCreationTimeStamp = 0;
+	bool bRevoked = false;
+	pStorage->GetDownloadTicketDetails(sDownloadTicketUUID, sStreamUUID, sDownloadFileName, sSessionUUID, sUserUUID, nCreationTimeStamp, bRevoked);
 
-	pStorage->RequestDownloadTicket(sDownloadTicketUUID, sIPAddress, pGlobalChrono->getUTCTimeStampInMicrosecondsSince1970(), sStreamUUID, sDownloadFileName, sSessionUUID, sUserUUID);
+	// A revoked ticket (cancelled download) or an old link gets 410, so that a browser never resumes it.
+	uint64_t nLifetime = (uint64_t)AMC_API_DOWNLOADTICKET_LIFETIME_SECONDS * 1000000ULL;
+	if (bRevoked || (nNow > nCreationTimeStamp + nLifetime))
+		return CAPI::makeError(AMC_API_HTTP_GONE, LIBMC_ERROR_DOWNLOADTICKETEXPIRED, "download ticket has expired or has been revoked: " + sDownloadTicketUUID);
 
+	if (!pStorage->StreamIsReady(sStreamUUID))
+		throw ELibMCInterfaceException(LIBMC_ERROR_STORAGESTREAMNOTFOUND, "download stream not found: " + sStreamUUID);
+
+	// Every download holds its own stream object and file handle; the response streams it in chunks.
 	auto pStream = pStorage->RetrieveStream(sStreamUUID);
-	auto sContentType = pStream->GetMIMEType();
+	auto pResponse = std::make_shared<CAPIStorageStreamResponse>(pStorage, pStream, m_pSystemState->getStreamDownloadRegistryInstance(), pGlobalChrono, bHeadOnly);
+	pResponse->setContentDispositionName(sDownloadFileName);
+
+	if (!pResponse->reserveSlot())
+		return CAPI::makeError(AMC_API_HTTP_SERVICEUNAVAILABLE, LIBMC_ERROR_TOOMANYDOWNLOADS, "too many concurrent downloads");
 
-	auto apiResponse = std::make_shared<CAPIFixedBufferResponse>(sContentType);
-	apiResponse->setContentDispositionName(sDownloadFileName);
-	pStream->GetContent(apiResponse->getBuffer());
+	if (!bHeadOnly)
+		pResponse->setDownloadUUID(pStorage->LogDownloadStart(sDownloadTicketUUID, pFormFields.getClientAddress(), nNow));
 
-	return apiResponse;
+	return pResponse;
 }
 
diff --git a/Implementation/API/amc_api_handler_frontend.cpp b/Implementation/API/amc_api_handler_frontend.cpp
index dd78d58ab..e079e92d5 100644
--- a/Implementation/API/amc_api_handler_frontend.cpp
+++ b/Implementation/API/amc_api_handler_frontend.cpp
@@ -30,6 +30,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "amc_api_handler_frontend.hpp"
 #include "amc_api_jsonrequest.hpp"
+#include "amc_api.hpp"
 #include "amc_api_frontendeventstream.hpp"
 #include "amc_streamregistry.hpp"
 #include "amc_statemachinedata.hpp"
@@ -138,6 +139,22 @@ APIHandler_FrontendType CAPIHandler_Frontend::parseRequest(const std::string& sU
 		if ((sParameterString == "/streamscope") || (sParameterString == "/streamscope/"))
 			return APIHandler_FrontendType::ftStreamScope;
 
+		// /actions/{uuid}/claim
+		std::string sActionsPrefix = "/actions/";
+		std::string sClaimSuffix = "/claim";
+		if (sParameterString.rfind(sActionsPrefix, 0) == 0) {
+			std::string sRemainder = sParameterString.substr(sActionsPrefix.length());
+			if ((!sRemainder.empty()) && (sRemainder.back() == '/'))
+				sRemainder.pop_back();
+			if ((sRemainder.length() > sClaimSuffix.length()) && (sRemainder.compare(sRemainder.length() - sClaimSuffix.length(), sClaimSuffix.length(), sClaimSuffix) == 0)) {
+				sRemainder = sRemainder.substr(0, sRemainder.length() - sClaimSuffix.length());
+				if (AMCCommon::CUtils::stringIsUUIDString(sRemainder)) {
+					sParameterUUID = AMCCommon::CUtils::normalizeUUIDString(sRemainder);
+					return APIHandler_FrontendType::ftClaimAction;
+				}
+			}
+		}
+
 	}
 
 	return APIHandler_FrontendType::ftUnknown;
@@ -229,6 +246,8 @@ std::string CAPIHandler_Frontend::handleStatusRequest(CAPIFormFields& pFormField
 		uint64_t nBuildEnd = pGlobalChrono->getUTCTimeStampInMicrosecondsSince1970();
 		double dBuildTimeMS = (double)(nBuildEnd - nBuildStart) / 1000.0;
 		writer.addDouble(AMC_API_KEY_FRONTEND_SERVERTIME, dBuildTimeMS);
+		// Polling clients receive the session's pending client actions with every status.
+		pFrontendState->writePendingClientActionsToJSON(writer);
 	};
 
 	if (publishResult.m_bPatchAvailable) {
@@ -399,6 +418,26 @@ void CAPIHandler_Frontend::handleStreamScopeRequest(CJSONWriter& writer, const u
 	applyStreamScope(pEventStream, pBodyData, nBodyDataSize, true);
 }
 
+PAPIResponse CAPIHandler_Frontend::handleClaimActionRequest(const std::string& sActionUUID, PAPIAuth pAuth)
+{
+	if (pAuth.get() == nullptr)
+		throw ELibMCInterfaceException(LIBMC_ERROR_INVALIDPARAM);
+
+	auto pFrontendState = pAuth->getFrontendState();
+	if (pFrontendState.get() == nullptr)
+		throw ELibMCInterfaceException(LIBMC_ERROR_INVALIDPARAM);
+
+	if (!pFrontendState->claimClientAction(sActionUUID))
+		return CAPI::makeError(AMC_API_HTTP_CONFLICT, LIBMC_ERROR_CLIENTACTIONALREADYCLAIMED, "client action is unknown or has already been claimed: " + sActionUUID);
+
+	CJSONWriter writer;
+	writeJSONHeader(writer, AMC_API_PROTOCOL_FRONTEND);
+	writer.addString(AMC_API_KEY_FRONTEND_ACTIONUUID, sActionUUID);
+	writer.addBoolean(AMC_API_KEY_FRONTEND_CLAIMED, true);
+
+	return std::make_shared<CAPIStringResponse>(AMC_API_HTTP_SUCCESS, AMC_API_CONTENTTYPE, writer.saveToString());
+}
+
 
 PAPIResponse CAPIHandler_Frontend::handleRequest(const std::string& sURI, const eAPIRequestType requestType, CAPIFormFields & pFormFields, const uint8_t* pBodyData, const size_t nBodyDataSize, PAPIAuth pAuth)
 {
@@ -409,6 +448,9 @@ PAPIResponse CAPIHandler_Frontend::handleRequest(const std::string& sURI, const
 	if (uiType == APIHandler_FrontendType::ftStatus)
 		return std::make_shared<CAPIStringResponse>(AMC_API_HTTP_SUCCESS, AMC_API_CONTENTTYPE, handleStatusRequest(pFormFields, pAuth));
 
+	if (uiType == APIHandler_FrontendType::ftClaimAction)
+		return handleClaimActionRequest(sParameterUUID, pAuth);
+
 	CJSONWriter writer;
 	writeJSONHeader(writer, AMC_API_PROTOCOL_FRONTEND);
 
diff --git a/Implementation/API/amc_api_handler_frontend.hpp b/Implementation/API/amc_api_handler_frontend.hpp
index 035523325..bb7bb852a 100644
--- a/Implementation/API/amc_api_handler_frontend.hpp
+++ b/Implementation/API/amc_api_handler_frontend.hpp
@@ -65,6 +65,7 @@ namespace AMC {
 		ftParameterListValues = 11,
 		ftStreamTicket = 12,
 		ftStreamScope = 13,
+		ftClaimAction = 14,
 	};
 
 	class CAPIHandler_Frontend : public CAPIHandler {
@@ -89,6 +90,10 @@ namespace AMC {
 
 		PAPIFrontendEventStream getOrCreateEventStream(PAPIAuth pAuth);
 
+		// Claims a pending client action of the session for the calling browser tab. Returns a 409 response
+		// if another tab was first.
+		PAPIResponse handleClaimActionRequest(const std::string& sActionUUID, PAPIAuth pAuth);
+
 		// Reads the optional "client", "pages" and "dialogs" members of a stream request body and applies the scope
 		// to the event stream. Returns the normalized client ID, or an empty string if the body carries none.
 		std::string applyStreamScope(PAPIFrontendEventStream pEventStream, const uint8_t* pBodyData, const size_t nBodyDataSize, bool bClientIsMandatory);
diff --git a/Implementation/API/amc_api_response.cpp b/Implementation/API/amc_api_response.cpp
index fcfca8ee3..640aa157f 100644
--- a/Implementation/API/amc_api_response.cpp
+++ b/Implementation/API/amc_api_response.cpp
@@ -33,6 +33,11 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "amc_api_response.hpp"
 #include "amc_api_constants.hpp"
 #include "libmc_interfaceexception.hpp"
+#include "amc_streamdownloadregistry.hpp"
+#include "common_httprange.hpp"
+#include "common_utils.hpp"
+
+#include <cstring>
 
 using namespace AMC;
 
@@ -43,6 +48,11 @@ CAPIResponse::CAPIResponse(uint32_t nHTTPCode, const std::string& sContentType)
 
 }
 
+CAPIResponse::~CAPIResponse()
+{
+
+}
+
 size_t CAPIResponse::getStreamSize() const
 {
 	return m_StreamData.size();
@@ -145,3 +155,128 @@ void CAPIFixedFloatBufferResponse::addFloat(float fValue)
 
 
 }
+
+
+CAPIStorageStreamResponse::CAPIStorageStreamResponse(LibMCData::PStorage pStorage, LibMCData::PStorageStream pStream, PStreamDownloadRegistry pRegistry, AMCCommon::PChrono pGlobalChrono, bool bHeadOnly)
+	: CAPIResponse(AMC_API_HTTP_SUCCESS, "application/octet-stream"),
+	m_pStorage(pStorage), m_pStream(pStream), m_pRegistry(pRegistry), m_pGlobalChrono(pGlobalChrono),
+	m_nSize(0), m_bHeadOnly(bHeadOnly), m_bSlotReserved(false), m_bRegistered(false), m_bFinished(false), m_nSentBytes(0)
+{
+	if (pStorage.get() == nullptr)
+		throw ELibMCInterfaceException(LIBMC_ERROR_INVALIDPARAM);
+	if (pStream.get() == nullptr)
+		throw ELibMCInterfaceException(LIBMC_ERROR_INVALIDPARAM);
+	if (pRegistry.get() == nullptr)
+		throw ELibMCInterfaceException(LIBMC_ERROR_INVALIDPARAM);
+	if (pGlobalChrono.get() == nullptr)
+		throw ELibMCInterfaceException(LIBMC_ERROR_INVALIDPARAM);
+
+	m_sStreamUUID = AMCCommon::CUtils::normalizeUUIDString(pStream->GetUUID());
+	m_nSize = pStream->GetSize();
+	m_sContentType = pStream->GetMIMEType();
+	m_sETag = pStream->GetSHA2();
+
+	std::string sTimeStamp = pStream->GetTimeStamp();
+	if (!sTimeStamp.empty())
+		m_sLastModified = AMCCommon::CHTTPRange::formatHTTPDate(AMCCommon::CChrono::parseISO8601TimeUTC(sTimeStamp));
+}
+
+CAPIStorageStreamResponse::~CAPIStorageStreamResponse()
+{
+	if (m_bRegistered && (!m_bFinished))
+		m_pRegistry->connectionEnded(m_sStreamUUID, false);
+
+	if (m_bSlotReserved)
+		m_pRegistry->releaseSlot();
+}
+
+bool CAPIStorageStreamResponse::reserveSlot()
+{
+	if (m_bSlotReserved)
+		return true;
+
+	m_bSlotReserved = m_pRegistry->reserveSlot();
+	return m_bSlotReserved;
+}
+
+void CAPIStorageStreamResponse::setDownloadUUID(const std::string& sDownloadUUID)
+{
+	m_sDownloadUUID = sDownloadUUID;
+}
+
+std::string CAPIStorageStreamResponse::getStreamUUID() const
+{
+	return m_sStreamUUID;
+}
+
+uint64_t CAPIStorageStreamResponse::getSize() const
+{
+	return m_nSize;
+}
+
+std::string CAPIStorageStreamResponse::getETag() const
+{
+	return m_sETag;
+}
+
+std::string CAPIStorageStreamResponse::getLastModified() const
+{
+	return m_sLastModified;
+}
+
+void CAPIStorageStreamResponse::readChunk(uint64_t nOffset, uint64_t nLength, std::vector<uint8_t>& buffer)
+{
+	if (m_bHeadOnly)
+		throw ELibMCInterfaceException(LIBMC_ERROR_INVALIDSTREAMCHUNK, "a HEAD response has no body");
+	if ((nLength == 0) || (nLength > AMC_API_DOWNLOADCHUNK_MAXLENGTH))
+		throw ELibMCInterfaceException(LIBMC_ERROR_INVALIDSTREAMCHUNK, "invalid chunk length: " + std::to_string(nLength));
+	if ((nOffset >= m_nSize) || (nLength > m_nSize - nOffset))
+		throw ELibMCInterfaceException(LIBMC_ERROR_INVALIDSTREAMCHUNK, "chunk outside of stream: " + std::to_string(nOffset) + "+" + std::to_string(nLength));
+
+	if (!m_bRegistered) {
+		m_pRegistry->connectionStarted(m_sStreamUUID, m_nSize);
+		m_bRegistered = true;
+	}
+
+	if (m_pRegistry->isCancelled(m_sStreamUUID))
+		throw ELibMCInterfaceException(LIBMC_ERROR_DOWNLOADCANCELLED, "download cancelled: " + m_sStreamUUID);
+
+	void* pReadCallback = nullptr;
+	void* pSeekCallback = nullptr;
+	void* pStreamHandle = nullptr;
+	m_pStream->GetCallbacks(pReadCallback, pSeekCallback, pStreamHandle);
+	if ((pReadCallback == nullptr) || (pSeekCallback == nullptr) || (pStreamHandle == nullptr))
+		throw ELibMCInterfaceException(LIBMC_ERROR_INTERNALERROR, "storage stream has no read callbacks");
+
+	buffer.resize((size_t)nLength);
+
+	uint32_t nSeekErrorCode = 0;
+	((LibMCData::StreamSeekCallback)pSeekCallback)(nOffset, pStreamHandle, &nSeekErrorCode);
+	if (nSeekErrorCode != 0)
+		throw ELibMCInterfaceException(LIBMC_ERROR_INTERNALERROR, "seeking the storage stream failed with error " + std::to_string(nSeekErrorCode));
+
+	uint32_t nReadErrorCode = 0;
+	((LibMCData::StreamReadCallback)pReadCallback)(buffer.data(), nLength, pStreamHandle, &nReadErrorCode);
+	if (nReadErrorCode != 0)
+		throw ELibMCInterfaceException(LIBMC_ERROR_INTERNALERROR, "reading the storage stream failed with error " + std::to_string(nReadErrorCode));
+
+	// Recorded before the socket write: a chunk that fails to send ends the connection without success,
+	// so the completion flag can not be set by an unsent chunk.
+	if (!m_pRegistry->chunkSent(m_sStreamUUID, nOffset, nLength))
+		throw ELibMCInterfaceException(LIBMC_ERROR_DOWNLOADCANCELLED, "download cancelled: " + m_sStreamUUID);
+
+	m_nSentBytes += nLength;
+}
+
+void CAPIStorageStreamResponse::finish(bool bSuccess)
+{
+	if (m_bFinished)
+		return;
+	m_bFinished = true;
+
+	if (m_bRegistered)
+		m_pRegistry->connectionEnded(m_sStreamUUID, bSuccess);
+
+	if ((!m_bHeadOnly) && (!m_sDownloadUUID.empty()))
+		m_pStorage->LogDownloadFinish(m_sDownloadUUID, m_nSentBytes, bSuccess, m_pGlobalChrono->getUTCTimeStampInMicrosecondsSince1970());
+}
diff --git a/Implementation/API/amc_api_response.hpp b/Implementation/API/amc_api_response.hpp
index 6fc243f80..194d6a2a2 100644
--- a/Implementation/API/amc_api_response.hpp
+++ b/Implementation/API/amc_api_response.hpp
@@ -36,11 +36,17 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "header_protection.hpp"
 
 #include "amc_api_types.hpp"
+#include "libmcdata_dynamic.hpp"
+#include "common_chrono.hpp"
 
 #include <vector>
+#include <memory>
 
 namespace AMC {
 
+	class CStreamDownloadRegistry;
+	typedef std::shared_ptr<CStreamDownloadRegistry> PStreamDownloadRegistry;
+
 	class CAPIResponse {
 	protected:
 
@@ -56,6 +62,8 @@ namespace AMC {
 	public:
 
 		CAPIResponse (uint32_t nHTTPCode, const std::string & sContentType);
+
+		virtual ~CAPIResponse();
 		
 		size_t getStreamSize () const;
 		
@@ -113,6 +121,59 @@ namespace AMC {
 	};
 
 
+	// A response whose body is a storage stream on disk. The HTTP server sends it in chunks through
+	// the request handler instead of loading it into memory, so files larger than the address space
+	// and larger than one socket write can be downloaded. Every response holds its own stream object
+	// and thus its own file handle. Delivery is reported to the download registry.
+	class CAPIStorageStreamResponse : public CAPIResponse {
+	private:
+
+		LibMCData::PStorage m_pStorage;
+		LibMCData::PStorageStream m_pStream;
+		PStreamDownloadRegistry m_pRegistry;
+		AMCCommon::PChrono m_pGlobalChrono;
+
+		std::string m_sStreamUUID;
+		uint64_t m_nSize;
+		std::string m_sETag;
+		std::string m_sLastModified;
+		std::string m_sDownloadUUID;
+
+		bool m_bHeadOnly;
+		bool m_bSlotReserved;
+		bool m_bRegistered;
+		bool m_bFinished;
+		uint64_t m_nSentBytes;
+
+	public:
+
+		CAPIStorageStreamResponse(LibMCData::PStorage pStorage, LibMCData::PStorageStream pStream, PStreamDownloadRegistry pRegistry, AMCCommon::PChrono pGlobalChrono, bool bHeadOnly);
+
+		// Releases the download slot and ends a registered connection that was never finished.
+		virtual ~CAPIStorageStreamResponse();
+
+		// Takes one of the limited download slots. Returns false if none is free.
+		bool reserveSlot();
+
+		// Access log entry of this download, written when the download ends.
+		void setDownloadUUID(const std::string& sDownloadUUID);
+
+		std::string getStreamUUID() const;
+		uint64_t getSize() const;
+		// Strong entity tag without quotes (the SHA-256 of the stream).
+		std::string getETag() const;
+		// Creation time of the stream as HTTP date.
+		std::string getLastModified() const;
+
+		// Reads a chunk and records it as sent. The first chunk registers the connection. Fails if the
+		// range is outside the stream or the download was cancelled.
+		void readChunk(uint64_t nOffset, uint64_t nLength, std::vector<uint8_t>& buffer);
+
+		// Ends the connection in the registry and the access log. Safe to call more than once.
+		void finish(bool bSuccess);
+
+	};
+
 	typedef std::shared_ptr<CAPIResponse> PAPIResponse;
 
 	
diff --git a/Implementation/API/amc_api_sessionhandler.cpp b/Implementation/API/amc_api_sessionhandler.cpp
index 5fab891ba..050edb37c 100644
--- a/Implementation/API/amc_api_sessionhandler.cpp
+++ b/Implementation/API/amc_api_sessionhandler.cpp
@@ -328,3 +328,77 @@ bool CAPISessionHandler::refreshSessionActivity(const std::string& sSessionUUID)
 
 	return true;
 }
+
+
+bool CAPISessionHandler::getAuthorizedUserForSession(const std::string& sSessionUUID, std::string& sUserUUID)
+{
+	std::lock_guard<std::mutex> lockGuard(m_Mutex);
+	auto iIterator = m_SessionMap.find(sSessionUUID);
+	if (iIterator == m_SessionMap.end())
+		return false;
+
+	auto pSession = iIterator->second;
+	if (!pSession->isAuthenticated())
+		return false;
+
+	sUserUUID = pSession->getUserUUID();
+	return true;
+}
+
+bool CAPISessionHandler::enqueueClientActionForSession(const std::string& sSessionUUID, PUIClientAction pAction, const std::string& sStreamUUID)
+{
+	if (pAction.get() == nullptr)
+		throw ELibMCInterfaceException(LIBMC_ERROR_INVALIDPARAM);
+
+	PUIFrontendState pFrontendState;
+	{
+		std::lock_guard<std::mutex> lockGuard(m_Mutex);
+		auto iIterator = m_SessionMap.find(sSessionUUID);
+		if (iIterator == m_SessionMap.end())
+			return false;
+
+		pFrontendState = iIterator->second->getFrontendState();
+	}
+
+	if (pFrontendState.get() == nullptr)
+		return false;
+
+	pFrontendState->enqueueClientAction(pAction, sStreamUUID);
+	return true;
+}
+
+void CAPISessionHandler::removeClientActionsOfStream(const std::string& sStreamUUID)
+{
+	std::vector<PUIFrontendState> frontendStates;
+	{
+		std::lock_guard<std::mutex> lockGuard(m_Mutex);
+		for (auto& iIterator : m_SessionMap) {
+			auto pFrontendState = iIterator.second->getFrontendState();
+			if (pFrontendState.get() != nullptr)
+				frontendStates.push_back(pFrontendState);
+		}
+	}
+
+	for (auto& pFrontendState : frontendStates)
+		pFrontendState->removeClientActionsOfStream(sStreamUUID);
+}
+
+bool CAPISessionHandler::hasUnclaimedClientActionsOfStream(const std::string& sStreamUUID)
+{
+	std::vector<PUIFrontendState> frontendStates;
+	{
+		std::lock_guard<std::mutex> lockGuard(m_Mutex);
+		for (auto& iIterator : m_SessionMap) {
+			auto pFrontendState = iIterator.second->getFrontendState();
+			if (pFrontendState.get() != nullptr)
+				frontendStates.push_back(pFrontendState);
+		}
+	}
+
+	for (auto& pFrontendState : frontendStates) {
+		if (pFrontendState->hasClientActionsOfStream(sStreamUUID))
+			return true;
+	}
+
+	return false;
+}
diff --git a/Implementation/API/amc_api_sessionhandler.hpp b/Implementation/API/amc_api_sessionhandler.hpp
index a36f2164d..3d38202f9 100644
--- a/Implementation/API/amc_api_sessionhandler.hpp
+++ b/Implementation/API/amc_api_sessionhandler.hpp
@@ -49,6 +49,7 @@ namespace AMC {
 	amcDeclareDependingClass(CAPISessionHandler, PAPISessionHandler);
 	amcDeclareDependingClass(CParameterHandler, PParameterHandler);
 	amcDeclareDependingClass(CUIFrontendDefinition, PUIFrontendDefinition);
+	amcDeclareDependingClass(CUIClientAction, PUIClientAction);
 	
 
 	class CAPISessionHandler {
@@ -97,6 +98,18 @@ namespace AMC {
 		// Returns false if the session does not exist anymore.
 		bool refreshSessionActivity(const std::string& sSessionUUID);
 
+		// Returns false if the session does not exist or is not authenticated. sUserUUID receives its user.
+		bool getAuthorizedUserForSession(const std::string& sSessionUUID, std::string& sUserUUID);
+
+		// Queues a client action for the browser tabs of a session. sStreamUUID tags a download action with its
+		// stream, so that a cancelled download can drop it. Returns false if the session does not exist.
+		bool enqueueClientActionForSession(const std::string& sSessionUUID, PUIClientAction pAction, const std::string& sStreamUUID);
+
+		// Drops the unclaimed actions of a stream from all sessions.
+		void removeClientActionsOfStream(const std::string& sStreamUUID);
+
+		bool hasUnclaimedClientActionsOfStream(const std::string& sStreamUUID);
+
 	};
 
 	
diff --git a/Implementation/API/amc_api_types.hpp b/Implementation/API/amc_api_types.hpp
index f69fd1a5f..189cbd10b 100644
--- a/Implementation/API/amc_api_types.hpp
+++ b/Implementation/API/amc_api_types.hpp
@@ -41,7 +41,8 @@ namespace AMC {
 		rtUnknown = 0,
 		rtGet = 1,
 		rtPost = 2,
-		rtPut = 3
+		rtPut = 3,
+		rtHead = 4
 	};
 
 
diff --git a/Implementation/Common/common_httprange.cpp b/Implementation/Common/common_httprange.cpp
new file mode 100644
index 000000000..c798b02eb
--- /dev/null
+++ b/Implementation/Common/common_httprange.cpp
@@ -0,0 +1,119 @@
+/*++
+
+Copyright (C) 2026 Autodesk Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+	* Redistributions of source code must retain the above copyright
+	  notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+	  notice, this list of conditions and the following disclaimer in the
+	  documentation and/or other materials provided with the distribution.
+	* Neither the name of the Autodesk Inc. nor the
+	  names of its contributors may be used to endorse or promote products
+	  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL AUTODESK INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#include "common_httprange.hpp"
+
+#include <ctime>
+#include <cstdio>
+
+using namespace AMCCommon;
+
+bool CHTTPRange::normalizeRanges(std::vector<Range>& ranges, uint64_t nContentLength)
+{
+	if (ranges.size() != 1)
+		return false;
+
+	if (nContentLength == 0)
+		return false;
+
+	int64_t nLength = (int64_t)nContentLength;
+	auto& range = ranges[0];
+	int64_t nFirst = range.first;
+	int64_t nLast = range.second;
+
+	if ((nFirst == -1) && (nLast == -1))
+		return true;
+
+	if (nFirst == -1) {
+		// Suffix range "-N": the last N bytes. N must be positive; a suffix longer than the body is clamped
+		// by the HTTP library.
+		return (nLast > 0);
+	}
+
+	if (nFirst < 0)
+		return false;
+
+	if (nFirst >= nLength)
+		return false;
+
+	if (nLast == -1)
+		return true;
+
+	if (nLast < nFirst)
+		return false;
+
+	if (nLast >= nLength)
+		range.second = nLength - 1;
+
+	return true;
+}
+
+bool CHTTPRange::ifRangeMatches(const std::string& sIfRange, const std::string& sETag, const std::string& sLastModified)
+{
+	if (sIfRange.empty())
+		return true;
+
+	if (sIfRange == "\"" + sETag + "\"")
+		return true;
+
+	if ((!sETag.empty()) && (sIfRange == sETag))
+		return true;
+
+	if ((!sLastModified.empty()) && (sIfRange == sLastModified))
+		return true;
+
+	return false;
+}
+
+std::string CHTTPRange::formatHTTPDate(uint64_t nMicrosecondsSince1970)
+{
+	static const char* pDayNames[] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
+	static const char* pMonthNames[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
+
+	time_t nSeconds = (time_t)(nMicrosecondsSince1970 / 1000000ULL);
+	struct tm timeInfo;
+#ifdef _WIN32
+	if (gmtime_s(&timeInfo, &nSeconds) != 0)
+		return "";
+#else
+	if (gmtime_r(&nSeconds, &timeInfo) == nullptr)
+		return "";
+#endif
+
+	if ((timeInfo.tm_wday < 0) || (timeInfo.tm_wday > 6) || (timeInfo.tm_mon < 0) || (timeInfo.tm_mon > 11))
+		return "";
+
+	char buffer[64];
+	snprintf(buffer, sizeof(buffer), "%s, %02d %s %04d %02d:%02d:%02d GMT",
+		pDayNames[timeInfo.tm_wday], timeInfo.tm_mday, pMonthNames[timeInfo.tm_mon], timeInfo.tm_year + 1900,
+		timeInfo.tm_hour, timeInfo.tm_min, timeInfo.tm_sec);
+
+	return std::string(buffer);
+}
diff --git a/Implementation/Common/common_httprange.hpp b/Implementation/Common/common_httprange.hpp
new file mode 100644
index 000000000..b887dceb8
--- /dev/null
+++ b/Implementation/Common/common_httprange.hpp
@@ -0,0 +1,67 @@
+/*++
+
+Copyright (C) 2026 Autodesk Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+	* Redistributions of source code must retain the above copyright
+	  notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+	  notice, this list of conditions and the following disclaimer in the
+	  documentation and/or other materials provided with the distribution.
+	* Neither the name of the Autodesk Inc. nor the
+	  names of its contributors may be used to endorse or promote products
+	  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL AUTODESK INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef __COMMON_HTTPRANGE
+#define __COMMON_HTTPRANGE
+
+#include <cstdint>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace AMCCommon {
+
+	// Helpers for HTTP range requests on streamed responses. The HTTP library validates byte ranges
+	// only for bodies it holds in memory; for a content provider it passes the parsed ranges through
+	// unchecked, so the server validates and normalizes them before it sets the provider.
+	class CHTTPRange {
+	public:
+
+		// A range as parsed by the HTTP library: first and last byte positions, -1 for an absent value.
+		typedef std::pair<int64_t, int64_t> Range;
+
+		// Returns true if the ranges describe exactly one satisfiable range of a body with nContentLength
+		// bytes, and clamps a last position beyond the end to the last byte. Returns false for an empty
+		// body, for several ranges, for a start at or beyond the end, for a last position before the start
+		// and for a suffix range of zero length. A full range (-1, -1) is satisfiable.
+		static bool normalizeRanges(std::vector<Range>& ranges, uint64_t nContentLength);
+
+		// Returns true if the If-Range validator matches the entity tag (without quotes) or the
+		// Last-Modified date of the response. An empty validator matches.
+		static bool ifRangeMatches(const std::string& sIfRange, const std::string& sETag, const std::string& sLastModified);
+
+		// Formats a time stamp as HTTP date (RFC 7231 IMF-fixdate), e.g. "Sun, 06 Nov 1994 08:49:37 GMT".
+		static std::string formatHTTPDate(uint64_t nMicrosecondsSince1970);
+
+	};
+
+}
+
+#endif //__COMMON_HTTPRANGE
diff --git a/Implementation/Core/amc_constants.hpp b/Implementation/Core/amc_constants.hpp
index 8094c3b62..b4bac896c 100644
--- a/Implementation/Core/amc_constants.hpp
+++ b/Implementation/Core/amc_constants.hpp
@@ -44,6 +44,15 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #define DATATABLE_MAXCOLUMNCOUNT (1024 * 1024)
 #define DATATABLE_HEADERSIGNATURE 0x6A9B23E1
+// Signature of the chunked columnar format (format version 2, see amc_datatableformat.hpp). It is
+// deliberately distinct from the v1 signature: a reader without v2 support must fail cleanly instead
+// of misreading a page directory as column data.
+#define DATATABLE_HEADERSIGNATURE_V2 0x6A9B23E2
+// Version field of the stream header. Files written before the field was populated carry 0 and
+// are treated as format version 1. Readers reject any other value.
+#define DATATABLE_FORMATVERSION_UNVERSIONED 0
+#define DATATABLE_FORMATVERSION_1 1
+#define DATATABLE_CURRENTFORMATVERSION DATATABLE_FORMATVERSION_1
 #define DATATABLE_DEFAULTCSVSEPARATOR ";"
 #define DATATABLE_DEFAULTCSVNEWLINE "\n"
 #define DATATABLE_DEFAULTCSVMAXBYTESPERENTRY 32
@@ -51,8 +60,20 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define DATATABLE_MINCSVSEPARATOR 32
 #define DATATABLE_MAXCSVSEPARATOR 127
 
+// Column encodings. RAW is the only encoding of format version 1; readers reject any other value.
 #define DATATABLE_ENCODINGTYPE_RAW 1
 
+// Streaming data capture defaults and limits
+#define DATACAPTURE_DEFAULTCHUNKROWCOUNT 65536
+#define DATACAPTURE_MINCHUNKROWCOUNT 1
+#define DATACAPTURE_MAXCHUNKROWCOUNT (16 * 1024 * 1024)
+#define DATACAPTURE_DEFAULTSEGMENTSIZE (1024ULL * 1024ULL * 1024ULL)
+#define DATACAPTURE_MINSEGMENTSIZE 1024ULL
+#define DATACAPTURE_DEFAULTMAXQUEUEDCHUNKS 16
+#define DATACAPTURE_MINMAXQUEUEDCHUNKS 1
+#define DATACAPTURE_MAXMAXQUEUEDCHUNKS 1024
+#define DATACAPTURE_SEGMENTMIMETYPE "application/amcf-datatable"
+
 #define MICROSECONDS_PER_MILLISECOND 1000ULL
 #define MICROSECONDS_PER_SECOND (1000ULL * 1000ULL)
 #define MICROSECONDS_PER_MINUTE (60ULL * 1000ULL * 1000ULL)
diff --git a/Implementation/Core/amc_datacapturequery.cpp b/Implementation/Core/amc_datacapturequery.cpp
new file mode 100644
index 000000000..b935a8e73
--- /dev/null
+++ b/Implementation/Core/amc_datacapturequery.cpp
@@ -0,0 +1,486 @@
+/*++
+
+Copyright (C) 2020 Autodesk Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+	* Redistributions of source code must retain the above copyright
+	  notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+	  notice, this list of conditions and the following disclaimer in the
+	  documentation and/or other materials provided with the distribution.
+	* Neither the name of the Autodesk Inc. nor the
+	  names of its contributors may be used to endorse or promote products
+	  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL AUTODESK INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#include "amc_datacapturequery.hpp"
+
+#include <cmath>
+#include <cstdio>
+#include <cstring>
+
+namespace AMC {
+
+	namespace {
+
+		template <typename T>
+		T loadPlainValue(const uint8_t* pData, uint64_t nIndex)
+		{
+			T value;
+			memcpy(&value, pData + nIndex * sizeof(T), sizeof(T));
+			return value;
+		}
+
+		// Appends a floating point number. JSON has no representation for NaN and infinity, they become null.
+		void appendFloatingPoint(std::string& sOutput, double dValue, int nSignificantDigits, bool bJSON)
+		{
+			if (!std::isfinite(dValue)) {
+				if (bJSON)
+					sOutput += "null";
+				else
+					sOutput += std::isnan(dValue) ? "nan" : ((dValue > 0.0) ? "inf" : "-inf");
+				return;
+			}
+
+			char buffer[48];
+			snprintf(buffer, sizeof(buffer), "%.*g", nSignificantDigits, dValue);
+			sOutput += buffer;
+		}
+
+		// Appends one plain value of a column. Integers are written exactly, floating point values
+		// with as many digits as it takes to read them back unchanged.
+		void appendPlainValue(std::string& sOutput, eDataTableV2DataType dataType, const uint8_t* pPlainValues, uint64_t nIndex, bool bJSON)
+		{
+			switch (dataType) {
+			case eDataTableV2DataType::Double:
+				appendFloatingPoint(sOutput, loadPlainValue<double>(pPlainValues, nIndex), 17, bJSON);
+				break;
+			case eDataTableV2DataType::Float:
+				appendFloatingPoint(sOutput, (double)loadPlainValue<float>(pPlainValues, nIndex), 9, bJSON);
+				break;
+			case eDataTableV2DataType::Int32:
+				sOutput += std::to_string(loadPlainValue<int32_t>(pPlainValues, nIndex));
+				break;
+			case eDataTableV2DataType::Uint32:
+				sOutput += std::to_string(loadPlainValue<uint32_t>(pPlainValues, nIndex));
+				break;
+			case eDataTableV2DataType::Int64:
+				sOutput += std::to_string(loadPlainValue<int64_t>(pPlainValues, nIndex));
+				break;
+			case eDataTableV2DataType::Uint64:
+			case eDataTableV2DataType::Timestamp:
+				sOutput += std::to_string(loadPlainValue<uint64_t>(pPlainValues, nIndex));
+				break;
+			case eDataTableV2DataType::Bool:
+				if (bJSON)
+					sOutput += (loadPlainValue<uint8_t>(pPlainValues, nIndex) != 0) ? "true" : "false";
+				else
+					sOutput += (loadPlainValue<uint8_t>(pPlainValues, nIndex) != 0) ? "1" : "0";
+				break;
+			default:
+				throw EDataTableFormatException(eDataTableFormatError::InvalidDataType, "invalid datatable column data type");
+			}
+		}
+
+		void appendJSONString(std::string& sOutput, const std::string& sValue)
+		{
+			sOutput += '"';
+			for (char cChar : sValue) {
+				switch (cChar) {
+				case '"': sOutput += "\\\""; break;
+				case '\\': sOutput += "\\\\"; break;
+				case '\n': sOutput += "\\n"; break;
+				case '\r': sOutput += "\\r"; break;
+				case '\t': sOutput += "\\t"; break;
+				default:
+					if ((unsigned char)cChar < 0x20) {
+						char buffer[8];
+						snprintf(buffer, sizeof(buffer), "\\u%04x", (unsigned int)(unsigned char)cChar);
+						sOutput += buffer;
+					}
+					else {
+						sOutput += cChar;
+					}
+				}
+			}
+			sOutput += '"';
+		}
+
+		template <typename T>
+		void appendBinaryValue(std::vector<uint8_t>& buffer, T value)
+		{
+			const uint8_t* pData = (const uint8_t*)&value;
+			buffer.insert(buffer.end(), pData, pData + sizeof(T));
+		}
+
+	}
+
+
+	CDataCaptureQuery::CDataCaptureQuery(PDataCaptureReader pReader, uint64_t nMaxValueCount)
+		: m_pReader(pReader), m_nMaxValueCount(nMaxValueCount)
+	{
+		if (pReader.get() == nullptr)
+			throw EDataTableFormatException(eDataTableFormatError::InvalidParam, "data capture query has no reader");
+	}
+
+	eDataCaptureQueryDownsample CDataCaptureQuery::parseDownsample(const std::string& sValue)
+	{
+		if (sValue.empty() || (sValue == "none"))
+			return eDataCaptureQueryDownsample::None;
+		if (sValue == "stride")
+			return eDataCaptureQueryDownsample::Stride;
+		if (sValue == "minmax")
+			return eDataCaptureQueryDownsample::MinMax;
+		if (sValue == "average")
+			return eDataCaptureQueryDownsample::Average;
+
+		throw EDataTableFormatException(eDataTableFormatError::InvalidParam, "invalid downsample mode: " + sValue + " (expected none, stride, minmax or average)");
+	}
+
+	std::string CDataCaptureQuery::downsampleToString(eDataCaptureQueryDownsample downsample)
+	{
+		switch (downsample) {
+		case eDataCaptureQueryDownsample::Stride: return "stride";
+		case eDataCaptureQueryDownsample::MinMax: return "minmax";
+		case eDataCaptureQueryDownsample::Average: return "average";
+		default: return "none";
+		}
+	}
+
+	std::string CDataCaptureQuery::columnTypeToString(eDataTableV2DataType dataType)
+	{
+		switch (dataType) {
+		case eDataTableV2DataType::Double: return "double";
+		case eDataTableV2DataType::Int32: return "int32";
+		case eDataTableV2DataType::Uint32: return "uint32";
+		case eDataTableV2DataType::Int64: return "int64";
+		case eDataTableV2DataType::Uint64: return "uint64";
+		case eDataTableV2DataType::Float: return "float";
+		case eDataTableV2DataType::Bool: return "bool";
+		case eDataTableV2DataType::Timestamp: return "timestamp";
+		default: return "unknown";
+		}
+	}
+
+	CDataCaptureQuery::sResolvedQuery CDataCaptureQuery::resolveQuery(const sDataCaptureQuery& query)
+	{
+		sResolvedQuery resolved;
+
+		if (query.m_ColumnIdentifiers.empty()) {
+			for (uint32_t nColumnIndex = 0; nColumnIndex < m_pReader->getColumnCount(); nColumnIndex++)
+				resolved.m_ColumnIndices.push_back(nColumnIndex);
+		}
+		else {
+			for (auto& sIdentifier : query.m_ColumnIdentifiers)
+				resolved.m_ColumnIndices.push_back(m_pReader->getColumnIndex(sIdentifier));
+		}
+
+		uint64_t nTotalRowCount = m_pReader->getRowCount();
+
+		resolved.m_nFromRow = query.m_bHasFromRow ? query.m_nFromRow : m_pReader->getFirstAvailableRow();
+		if (resolved.m_nFromRow > nTotalRowCount)
+			throw EDataTableFormatException(eDataTableFormatError::InvalidRange, "fromrow " + std::to_string(resolved.m_nFromRow) + " exceeds the " + std::to_string(nTotalRowCount) + " rows of the data capture");
+
+		resolved.m_nRowCount = query.m_bHasRowCount ? query.m_nRowCount : (nTotalRowCount - resolved.m_nFromRow);
+		m_pReader->validateRowRange(resolved.m_nFromRow, resolved.m_nRowCount);
+
+		resolved.m_Downsample = query.m_Downsample;
+		resolved.m_nTargetPoints = query.m_nTargetPoints;
+		resolved.m_nBucketCount = 0;
+		resolved.m_nValuesPerColumn = resolved.m_nRowCount;
+
+		if (resolved.m_Downsample != eDataCaptureQueryDownsample::None) {
+			if ((resolved.m_nTargetPoints == 0) || (resolved.m_nTargetPoints > DATACAPTUREQUERY_MAXTARGETPOINTS))
+				throw EDataTableFormatException(eDataTableFormatError::InvalidParam, "targetpoints must be between 1 and " + std::to_string(DATACAPTUREQUERY_MAXTARGETPOINTS));
+
+			resolved.m_nBucketCount = CDataCaptureReader::getDownsampleBucketCount(resolved.m_nRowCount, resolved.m_nTargetPoints);
+			resolved.m_nValuesPerColumn = (resolved.m_Downsample == eDataCaptureQueryDownsample::MinMax) ? (2 * resolved.m_nBucketCount) : resolved.m_nBucketCount;
+		}
+
+		// The size cap. A response is buffered as a whole, so an unbounded request must fail here
+		// instead of trying to allocate the capture.
+		uint64_t nColumnCount = resolved.m_ColumnIndices.size();
+		if ((nColumnCount > 0) && (resolved.m_nValuesPerColumn > m_nMaxValueCount / nColumnCount))
+			throw EDataTableFormatException(eDataTableFormatError::InvalidRange, "the request returns " + std::to_string(resolved.m_nValuesPerColumn) + " values in each of " + std::to_string(nColumnCount) + " columns, the limit is " + std::to_string(m_nMaxValueCount) + " values: reduce rowcount, or set downsample and targetpoints");
+
+		return resolved;
+	}
+
+	uint64_t CDataCaptureQuery::bucketStart(const sResolvedQuery& resolved, uint64_t nBucketIndex)
+	{
+		// The same partition as CDataCaptureReader::readColumnDownsampled.
+		uint64_t nQuotient = resolved.m_nRowCount / resolved.m_nBucketCount;
+		uint64_t nRemainder = resolved.m_nRowCount % resolved.m_nBucketCount;
+		return nBucketIndex * nQuotient + (nBucketIndex * nRemainder) / resolved.m_nBucketCount;
+	}
+
+	void CDataCaptureQuery::readDownsampledColumn(const sResolvedQuery& resolved, uint32_t nColumnIndex, std::vector<double>& values)
+	{
+		values.resize((size_t)resolved.m_nValuesPerColumn);
+		if (values.empty())
+			return;
+
+		eDataCaptureDownsampleMode mode = eDataCaptureDownsampleMode::MinMax;
+		if (resolved.m_Downsample == eDataCaptureQueryDownsample::Stride)
+			mode = eDataCaptureDownsampleMode::Stride;
+		else if (resolved.m_Downsample == eDataCaptureQueryDownsample::Average)
+			mode = eDataCaptureDownsampleMode::Average;
+
+		m_pReader->readColumnDownsampled(nColumnIndex, resolved.m_nFromRow, resolved.m_nRowCount, resolved.m_nTargetPoints, mode, values.data());
+	}
+
+	void CDataCaptureQuery::writeInfo(CJSONWriter& writer)
+	{
+		writer.addString("uuid", m_pReader->getUUID());
+		writer.addString("identifier", m_pReader->getIdentifier());
+		writer.addString("name", m_pReader->getName());
+		writer.addInteger("rowcount", (int64_t)m_pReader->getRowCount());
+		writer.addInteger("firstavailablerow", (int64_t)m_pReader->getFirstAvailableRow());
+		writer.addInteger("columncount", (int64_t)m_pReader->getColumnCount());
+		writer.addInteger("segmentcount", (int64_t)m_pReader->getSegmentCount());
+		writer.addInteger("chunkcount", (int64_t)m_pReader->getChunkCount());
+
+		uint64_t nStoredSize = 0;
+		CJSONWriterArray segmentsArray(writer);
+		for (uint32_t nSegmentIndex = 0; nSegmentIndex < m_pReader->getSegmentCount(); nSegmentIndex++) {
+			auto& segment = m_pReader->getSegment(nSegmentIndex);
+			if (!segment.m_bIsPurged)
+				nStoredSize += segment.m_nSizeInBytes;
+
+			CJSONWriterObject segmentObject(writer);
+			segmentObject.addInteger("index", (int64_t)nSegmentIndex);
+			segmentObject.addInteger("firstrow", (int64_t)segment.m_nFirstRow);
+			segmentObject.addInteger("rowcount", (int64_t)segment.m_nRowCount);
+			segmentObject.addInteger("chunkcount", (int64_t)segment.m_nChunkCount);
+			segmentObject.addInteger("size", (int64_t)segment.m_nSizeInBytes);
+			segmentObject.addBool("available", !segment.m_bIsPurged);
+			segmentsArray.addObject(segmentObject);
+		}
+		writer.addInteger("storedsize", (int64_t)nStoredSize);
+
+		// The value range of a column is the union of its page statistics in the stored segments.
+		uint64_t nChunkCount = m_pReader->getChunkCount();
+		CJSONWriterArray columnsArray(writer);
+		for (uint32_t nColumnIndex = 0; nColumnIndex < m_pReader->getColumnCount(); nColumnIndex++) {
+			auto& column = m_pReader->getColumn(nColumnIndex);
+
+			bool bHasRange = false;
+			double dColumnMin = 0.0;
+			double dColumnMax = 0.0;
+			for (uint64_t nChunkIndex = 0; nChunkIndex < nChunkCount; nChunkIndex++) {
+				double dChunkMin = 0.0;
+				double dChunkMax = 0.0;
+				if (!m_pReader->getChunkStatistics(nChunkIndex, nColumnIndex, dChunkMin, dChunkMax))
+					continue;
+
+				if (!bHasRange || (dChunkMin < dColumnMin))
+					dColumnMin = dChunkMin;
+				if (!bHasRange || (dChunkMax > dColumnMax))
+					dColumnMax = dChunkMax;
+				bHasRange = true;
+			}
+
+			CJSONWriterObject columnObject(writer);
+			columnObject.addString("name", column.m_sIdentifier);
+			columnObject.addString("description", column.m_sDescription);
+			columnObject.addString("type", columnTypeToString(column.m_DataType));
+			columnObject.addDouble("quantization", m_pReader->getColumnQuantization(nColumnIndex));
+			columnObject.addBool("hasrange", bHasRange);
+			columnObject.addDouble("min", dColumnMin);
+			columnObject.addDouble("max", dColumnMax);
+			columnsArray.addObject(columnObject);
+		}
+
+		writer.addArray("columns", columnsArray);
+		writer.addArray("segments", segmentsArray);
+	}
+
+	void CDataCaptureQuery::appendJSONMembers(const sDataCaptureQuery& query, std::string& sJSON)
+	{
+		auto resolved = resolveQuery(query);
+
+		sJSON += "\"uuid\":";
+		appendJSONString(sJSON, m_pReader->getUUID());
+		sJSON += ",\"fromrow\":" + std::to_string(resolved.m_nFromRow);
+		sJSON += ",\"rowcount\":" + std::to_string(resolved.m_nRowCount);
+		sJSON += ",\"downsample\":";
+		appendJSONString(sJSON, downsampleToString(resolved.m_Downsample));
+
+		if (resolved.m_Downsample == eDataCaptureQueryDownsample::None) {
+			sJSON += ",\"columns\":[";
+
+			std::vector<uint8_t> plainValues;
+			for (size_t nIndex = 0; nIndex < resolved.m_ColumnIndices.size(); nIndex++) {
+				uint32_t nColumnIndex = resolved.m_ColumnIndices[nIndex];
+				auto& column = m_pReader->getColumn(nColumnIndex);
+				uint32_t nEntrySize = CDataTableV2::getEntrySize(column.m_DataType);
+
+				plainValues.resize((size_t)(resolved.m_nRowCount * nEntrySize));
+				m_pReader->readColumnPlain(nColumnIndex, resolved.m_nFromRow, resolved.m_nRowCount, plainValues.data(), plainValues.size());
+
+				if (nIndex > 0)
+					sJSON += ',';
+				sJSON += "{\"name\":";
+				appendJSONString(sJSON, column.m_sIdentifier);
+				sJSON += ",\"type\":";
+				appendJSONString(sJSON, columnTypeToString(column.m_DataType));
+				sJSON += ",\"values\":[";
+				for (uint64_t nRow = 0; nRow < resolved.m_nRowCount; nRow++) {
+					if (nRow > 0)
+						sJSON += ',';
+					appendPlainValue(sJSON, column.m_DataType, plainValues.data(), nRow, true);
+				}
+				sJSON += "]}";
+			}
+
+			sJSON += ']';
+			return;
+		}
+
+		// Downsampled: one bucket list per column, in the shape of the journal envelope.
+		sJSON += ",\"count\":" + std::to_string(resolved.m_nBucketCount);
+		sJSON += ",\"series\":[";
+
+		std::vector<double> values;
+		for (size_t nIndex = 0; nIndex < resolved.m_ColumnIndices.size(); nIndex++) {
+			uint32_t nColumnIndex = resolved.m_ColumnIndices[nIndex];
+			auto& column = m_pReader->getColumn(nColumnIndex);
+			readDownsampledColumn(resolved, nColumnIndex, values);
+
+			if (nIndex > 0)
+				sJSON += ',';
+			sJSON += "{\"name\":";
+			appendJSONString(sJSON, column.m_sIdentifier);
+			sJSON += ",\"type\":";
+			appendJSONString(sJSON, columnTypeToString(column.m_DataType));
+			sJSON += ",\"available\":true,\"buckets\":[";
+
+			for (uint64_t nBucketIndex = 0; nBucketIndex < resolved.m_nBucketCount; nBucketIndex++) {
+				if (nBucketIndex > 0)
+					sJSON += ',';
+				sJSON += "{\"row\":" + std::to_string(resolved.m_nFromRow + bucketStart(resolved, nBucketIndex));
+
+				if (resolved.m_Downsample == eDataCaptureQueryDownsample::MinMax) {
+					sJSON += ",\"min\":";
+					appendFloatingPoint(sJSON, values[(size_t)(2 * nBucketIndex)], 17, true);
+					sJSON += ",\"max\":";
+					appendFloatingPoint(sJSON, values[(size_t)(2 * nBucketIndex + 1)], 17, true);
+				}
+				else {
+					sJSON += ",\"value\":";
+					appendFloatingPoint(sJSON, values[(size_t)nBucketIndex], 17, true);
+				}
+				sJSON += '}';
+			}
+
+			sJSON += "]}";
+		}
+
+		sJSON += ']';
+	}
+
+	std::string CDataCaptureQuery::buildCSV(const sDataCaptureQuery& query)
+	{
+		auto resolved = resolveQuery(query);
+		const char cSeparator = ';';
+
+		std::string sCSV;
+		sCSV += "row";
+		for (uint32_t nColumnIndex : resolved.m_ColumnIndices) {
+			auto& sIdentifier = m_pReader->getColumn(nColumnIndex).m_sIdentifier;
+			if (resolved.m_Downsample == eDataCaptureQueryDownsample::MinMax) {
+				sCSV += cSeparator;
+				sCSV += sIdentifier + "_min";
+				sCSV += cSeparator;
+				sCSV += sIdentifier + "_max";
+			}
+			else {
+				sCSV += cSeparator;
+				sCSV += sIdentifier;
+			}
+		}
+		sCSV += '\n';
+
+		if (resolved.m_Downsample == eDataCaptureQueryDownsample::None) {
+			std::vector<std::vector<uint8_t>> columnValues(resolved.m_ColumnIndices.size());
+			for (size_t nIndex = 0; nIndex < resolved.m_ColumnIndices.size(); nIndex++) {
+				uint32_t nColumnIndex = resolved.m_ColumnIndices[nIndex];
+				uint32_t nEntrySize = CDataTableV2::getEntrySize(m_pReader->getColumn(nColumnIndex).m_DataType);
+				columnValues[nIndex].resize((size_t)(resolved.m_nRowCount * nEntrySize));
+				m_pReader->readColumnPlain(nColumnIndex, resolved.m_nFromRow, resolved.m_nRowCount, columnValues[nIndex].data(), columnValues[nIndex].size());
+			}
+
+			for (uint64_t nRow = 0; nRow < resolved.m_nRowCount; nRow++) {
+				sCSV += std::to_string(resolved.m_nFromRow + nRow);
+				for (size_t nIndex = 0; nIndex < resolved.m_ColumnIndices.size(); nIndex++) {
+					sCSV += cSeparator;
+					appendPlainValue(sCSV, m_pReader->getColumn(resolved.m_ColumnIndices[nIndex]).m_DataType, columnValues[nIndex].data(), nRow, false);
+				}
+				sCSV += '\n';
+			}
+
+			return sCSV;
+		}
+
+		std::vector<std::vector<double>> columnValues(resolved.m_ColumnIndices.size());
+		for (size_t nIndex = 0; nIndex < resolved.m_ColumnIndices.size(); nIndex++)
+			readDownsampledColumn(resolved, resolved.m_ColumnIndices[nIndex], columnValues[nIndex]);
+
+		size_t nValuesPerBucket = (resolved.m_Downsample == eDataCaptureQueryDownsample::MinMax) ? 2 : 1;
+		for (uint64_t nBucketIndex = 0; nBucketIndex < resolved.m_nBucketCount; nBucketIndex++) {
+			sCSV += std::to_string(resolved.m_nFromRow + bucketStart(resolved, nBucketIndex));
+			for (size_t nIndex = 0; nIndex < resolved.m_ColumnIndices.size(); nIndex++) {
+				for (size_t nValueIndex = 0; nValueIndex < nValuesPerBucket; nValueIndex++) {
+					sCSV += cSeparator;
+					appendFloatingPoint(sCSV, columnValues[nIndex][(size_t)nBucketIndex * nValuesPerBucket + nValueIndex], 17, false);
+				}
+			}
+			sCSV += '\n';
+		}
+
+		return sCSV;
+	}
+
+	void CDataCaptureQuery::buildBinary(const sDataCaptureQuery& query, bool bFloat32, std::vector<uint8_t>& buffer)
+	{
+		auto resolved = resolveQuery(query);
+
+		buffer.clear();
+		buffer.reserve((size_t)(resolved.m_nValuesPerColumn * resolved.m_ColumnIndices.size() * (bFloat32 ? sizeof(float) : sizeof(double))));
+
+		std::vector<double> values;
+		for (uint32_t nColumnIndex : resolved.m_ColumnIndices) {
+			if (resolved.m_Downsample == eDataCaptureQueryDownsample::None) {
+				values.resize((size_t)resolved.m_nRowCount);
+				if (!values.empty())
+					m_pReader->readColumnAsDouble(nColumnIndex, resolved.m_nFromRow, resolved.m_nRowCount, values.data());
+			}
+			else {
+				readDownsampledColumn(resolved, nColumnIndex, values);
+			}
+
+			for (double dValue : values) {
+				if (bFloat32)
+					appendBinaryValue<float>(buffer, (float)dValue);
+				else
+					appendBinaryValue<double>(buffer, dValue);
+			}
+		}
+	}
+
+}
diff --git a/Implementation/Core/amc_datacapturequery.hpp b/Implementation/Core/amc_datacapturequery.hpp
new file mode 100644
index 000000000..26768e3f1
--- /dev/null
+++ b/Implementation/Core/amc_datacapturequery.hpp
@@ -0,0 +1,141 @@
+/*++
+
+Copyright (C) 2020 Autodesk Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+	* Redistributions of source code must retain the above copyright
+	  notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+	  notice, this list of conditions and the following disclaimer in the
+	  documentation and/or other materials provided with the distribution.
+	* Neither the name of the Autodesk Inc. nor the
+	  names of its contributors may be used to endorse or promote products
+	  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL AUTODESK INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+
+#ifndef __AMC_DATACAPTUREQUERY
+#define __AMC_DATACAPTUREQUERY
+
+#include "amc_datacapturereader.hpp"
+#include "amc_jsonwriter.hpp"
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+// API responses are buffered in memory as a whole. A request that would return more values than
+// this is rejected, so that a capture of tens of GB can not be pulled into one response.
+#define DATACAPTUREQUERY_MAXVALUECOUNT 1000000
+
+#define DATACAPTUREQUERY_DEFAULTTARGETPOINTS 1000
+#define DATACAPTUREQUERY_MAXTARGETPOINTS 20000
+
+namespace AMC {
+
+	enum class eDataCaptureQueryDownsample : uint32_t {
+		None = 0,
+		Stride = 1,
+		MinMax = 2,
+		Average = 3
+	};
+
+	// A request for a part of a data capture.
+	struct sDataCaptureQuery {
+
+		// Identifiers of the columns to return, in this order. Empty means all columns.
+		std::vector<std::string> m_ColumnIdentifiers;
+
+		// First row. Default is the first row that is still stored.
+		bool m_bHasFromRow = false;
+		uint64_t m_nFromRow = 0;
+
+		// Number of rows. Default is everything up to the end of the capture.
+		bool m_bHasRowCount = false;
+		uint64_t m_nRowCount = 0;
+
+		eDataCaptureQueryDownsample m_Downsample = eDataCaptureQueryDownsample::None;
+		uint32_t m_nTargetPoints = DATACAPTUREQUERY_DEFAULTTARGETPOINTS;
+	};
+
+
+	/*************************************************************************************************************************
+	 CDataCaptureQuery turns a request for a part of a data capture into a response body: JSON, CSV or raw
+	 little-endian arrays. It enforces the response size cap. The API handler is a thin layer on top of it.
+	**************************************************************************************************************************/
+
+	class CDataCaptureQuery {
+	private:
+
+		PDataCaptureReader m_pReader;
+		uint64_t m_nMaxValueCount;
+
+		struct sResolvedQuery {
+			std::vector<uint32_t> m_ColumnIndices;
+			uint64_t m_nFromRow;
+			uint64_t m_nRowCount;
+			eDataCaptureQueryDownsample m_Downsample;
+			uint32_t m_nTargetPoints;
+
+			// Number of buckets of a downsampled query, 0 otherwise.
+			uint64_t m_nBucketCount;
+
+			// Number of values per column in the response.
+			uint64_t m_nValuesPerColumn;
+		};
+
+		sResolvedQuery resolveQuery(const sDataCaptureQuery& query);
+
+		// First row of a bucket relative to the first row of the query.
+		static uint64_t bucketStart(const sResolvedQuery& resolved, uint64_t nBucketIndex);
+
+		void readDownsampledColumn(const sResolvedQuery& resolved, uint32_t nColumnIndex, std::vector<double>& values);
+
+	public:
+
+		CDataCaptureQuery(PDataCaptureReader pReader, uint64_t nMaxValueCount = DATACAPTUREQUERY_MAXVALUECOUNT);
+
+		// Parses the downsample parameter of a request: empty, none, stride, minmax or average.
+		static eDataCaptureQueryDownsample parseDownsample(const std::string& sValue);
+
+		static std::string downsampleToString(eDataCaptureQueryDownsample downsample);
+
+		static std::string columnTypeToString(eDataTableV2DataType dataType);
+
+		// Adds schema, row counts, segments and the value range of every column to a JSON document.
+		// Only manifest and segment footers are read.
+		void writeInfo(CJSONWriter& writer);
+
+		// Appends the members of a JSON object that holds the requested data, without the enclosing braces.
+		// Without downsampling: "columns" with one value array per column.
+		// With downsampling: "series" with one bucket list per column, in the shape of the journal envelope.
+		void appendJSONMembers(const sDataCaptureQuery& query, std::string& sJSON);
+
+		// Returns the requested data as CSV with a header line. The first column is the row index.
+		std::string buildCSV(const sDataCaptureQuery& query);
+
+		// Returns the requested data as raw little-endian arrays, one array per column after the other.
+		// All arrays have the same length, which follows from the buffer size and the number of columns.
+		void buildBinary(const sDataCaptureQuery& query, bool bFloat32, std::vector<uint8_t>& buffer);
+
+	};
+
+}
+
+
+#endif //__AMC_DATACAPTUREQUERY
diff --git a/Implementation/Core/amc_datacapturereader.cpp b/Implementation/Core/amc_datacapturereader.cpp
new file mode 100644
index 000000000..3b6ab3012
--- /dev/null
+++ b/Implementation/Core/amc_datacapturereader.cpp
@@ -0,0 +1,766 @@
+/*++
+
+Copyright (C) 2020 Autodesk Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+	* Redistributions of source code must retain the above copyright
+	  notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+	  notice, this list of conditions and the following disclaimer in the
+	  documentation and/or other materials provided with the distribution.
+	* Neither the name of the Autodesk Inc. nor the
+	  names of its contributors may be used to endorse or promote products
+	  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL AUTODESK INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#include "amc_datacapturereader.hpp"
+
+#include <algorithm>
+#include <cmath>
+#include <cstring>
+#include <limits>
+
+namespace AMC {
+
+	namespace {
+
+		template <typename T>
+		T loadPlainValue(const uint8_t* pData, uint64_t nIndex)
+		{
+			T value;
+			memcpy(&value, pData + nIndex * sizeof(T), sizeof(T));
+			return value;
+		}
+
+		template <typename T>
+		void convertRunToDouble(const uint8_t* pData, uint64_t nCount, double* pTarget)
+		{
+			for (uint64_t nIndex = 0; nIndex < nCount; nIndex++)
+				pTarget[nIndex] = (double)loadPlainValue<T>(pData, nIndex);
+		}
+
+		void convertPlainToDouble(eDataTableV2DataType dataType, const uint8_t* pData, uint64_t nCount, double* pTarget)
+		{
+			switch (dataType) {
+			case eDataTableV2DataType::Double: memcpy(pTarget, pData, (size_t)nCount * sizeof(double)); break;
+			case eDataTableV2DataType::Float: convertRunToDouble<float>(pData, nCount, pTarget); break;
+			case eDataTableV2DataType::Int32: convertRunToDouble<int32_t>(pData, nCount, pTarget); break;
+			case eDataTableV2DataType::Uint32: convertRunToDouble<uint32_t>(pData, nCount, pTarget); break;
+			case eDataTableV2DataType::Int64: convertRunToDouble<int64_t>(pData, nCount, pTarget); break;
+			case eDataTableV2DataType::Uint64: convertRunToDouble<uint64_t>(pData, nCount, pTarget); break;
+			case eDataTableV2DataType::Timestamp: convertRunToDouble<uint64_t>(pData, nCount, pTarget); break;
+			case eDataTableV2DataType::Bool: convertRunToDouble<uint8_t>(pData, nCount, pTarget); break;
+			default:
+				throw EDataTableFormatException(eDataTableFormatError::InvalidDataType, "invalid datatable column data type");
+			}
+		}
+
+	}
+
+
+	/*************************************************************************************************************************
+	 One segment stream that is open for reading. The storage stream MUST outlive the segment reader,
+	 because the read callbacks belong to the stream instance.
+	**************************************************************************************************************************/
+
+	class CDataCaptureOpenSegment {
+	public:
+		LibMCData::PStorageStream m_pStream;
+		std::unique_ptr<CDataTableV2SegmentReader> m_pReader;
+
+		// Row index of the first row of each chunk relative to the segment, followed by the segment row count.
+		std::vector<uint64_t> m_ChunkFirstRows;
+
+		CDataCaptureOpenSegment(LibMCData::PStorageStream pStream)
+			: m_pStream(pStream)
+		{
+			void* pReadCallback = nullptr;
+			void* pSeekCallback = nullptr;
+			void* pUserData = nullptr;
+			m_pStream->GetCallbacks(pReadCallback, pSeekCallback, pUserData);
+
+			if ((pReadCallback == nullptr) || (pSeekCallback == nullptr) || (pUserData == nullptr))
+				throw EDataTableFormatException(eDataTableFormatError::InvalidParam, "datatable segment stream has no read access");
+
+			auto readCallback = [pReadCallback, pSeekCallback, pUserData](uint64_t nOffset, uint64_t nSize, uint8_t* pBuffer) {
+				if (nSize == 0)
+					return;
+
+				uint32_t nSeekErrorCode = 0;
+				((LibMCData::StreamSeekCallback)pSeekCallback)(nOffset, pUserData, &nSeekErrorCode);
+				if (nSeekErrorCode != 0)
+					throw EDataTableFormatException(eDataTableFormatError::Corrupt, "could not seek in datatable segment stream, error " + std::to_string(nSeekErrorCode));
+
+				uint32_t nReadErrorCode = 0;
+				((LibMCData::StreamReadCallback)pReadCallback)((void*)pBuffer, nSize, pUserData, &nReadErrorCode);
+				if (nReadErrorCode != 0)
+					throw EDataTableFormatException(eDataTableFormatError::Corrupt, "could not read from datatable segment stream, error " + std::to_string(nReadErrorCode));
+			};
+
+			m_pReader = std::make_unique<CDataTableV2SegmentReader>(readCallback, m_pStream->GetSize());
+
+			uint32_t nChunkCount = m_pReader->getChunkCount();
+			uint64_t nRow = 0;
+			m_ChunkFirstRows.reserve((size_t)nChunkCount + 1);
+			for (uint32_t nChunkIndex = 0; nChunkIndex < nChunkCount; nChunkIndex++) {
+				m_ChunkFirstRows.push_back(nRow);
+				nRow += m_pReader->getChunkRowCount(nChunkIndex);
+			}
+			m_ChunkFirstRows.push_back(nRow);
+		}
+	};
+
+
+	CDataCaptureReader::CDataCaptureReader(LibMCData::PDataModel pDataModel, LibMCData::PDataCapture pManifest)
+		: m_pDataModel(pDataModel), m_nRowCount(0), m_nChunkCount(0), m_nPageReadCount(0),
+		m_bPageCached(false), m_nCachedSegmentIndex(0), m_nCachedChunkIndex(0), m_nCachedColumnIndex(0)
+	{
+		if (pDataModel.get() == nullptr)
+			throw EDataTableFormatException(eDataTableFormatError::InvalidParam, "data capture reader has no data model");
+		if (pManifest.get() == nullptr)
+			throw EDataTableFormatException(eDataTableFormatError::InvalidParam, "data capture reader has no manifest");
+
+		m_pStorage = m_pDataModel->CreateStorage();
+
+		m_sUUID = pManifest->GetUUID();
+		m_sIdentifier = pManifest->GetIdentifier();
+		m_sName = pManifest->GetName();
+
+		uint32_t nColumnCount = pManifest->GetColumnCount();
+		for (uint32_t nColumnIndex = 0; nColumnIndex < nColumnCount; nColumnIndex++) {
+			sDataTableV2Column column;
+			uint32_t nColumnType = 0;
+			pManifest->GetColumnInformation(nColumnIndex, column.m_sIdentifier, column.m_sDescription, nColumnType);
+
+			if (!CDataTableV2::dataTypeIsValid(nColumnType))
+				throw EDataTableFormatException(eDataTableFormatError::InvalidDataType, "invalid data capture column type: " + std::to_string(nColumnType));
+
+			column.m_DataType = (eDataTableV2DataType)nColumnType;
+			m_EntrySizes.push_back(CDataTableV2::getEntrySize(column.m_DataType));
+			m_Columns.push_back(column);
+		}
+
+		uint32_t nSegmentCount = pManifest->GetSegmentCount();
+		for (uint32_t nSegmentIndex = 0; nSegmentIndex < nSegmentCount; nSegmentIndex++) {
+			sDataCaptureSegmentInfo segment;
+			pManifest->GetSegmentInformation(nSegmentIndex, segment.m_sStreamUUID, segment.m_nFirstRow, segment.m_nRowCount, segment.m_nSizeInBytes, segment.m_bIsPurged);
+			segment.m_nChunkCount = pManifest->GetSegmentChunkCount(nSegmentIndex);
+			segment.m_nFirstChunkIndex = m_nChunkCount;
+
+			if (segment.m_nFirstRow != m_nRowCount)
+				throw EDataTableFormatException(eDataTableFormatError::Corrupt, "data capture segments are not contiguous");
+
+			m_nRowCount += segment.m_nRowCount;
+			m_nChunkCount += segment.m_nChunkCount;
+			m_Segments.push_back(segment);
+		}
+	}
+
+	CDataCaptureReader::~CDataCaptureReader()
+	{
+	}
+
+	std::string CDataCaptureReader::getUUID() const
+	{
+		return m_sUUID;
+	}
+
+	std::string CDataCaptureReader::getIdentifier() const
+	{
+		return m_sIdentifier;
+	}
+
+	std::string CDataCaptureReader::getName() const
+	{
+		return m_sName;
+	}
+
+	uint64_t CDataCaptureReader::getRowCount() const
+	{
+		return m_nRowCount;
+	}
+
+	uint64_t CDataCaptureReader::getFirstAvailableRow() const
+	{
+		for (auto& segment : m_Segments) {
+			if (!segment.m_bIsPurged)
+				return segment.m_nFirstRow;
+		}
+
+		return m_nRowCount;
+	}
+
+	uint32_t CDataCaptureReader::getColumnCount() const
+	{
+		return (uint32_t)m_Columns.size();
+	}
+
+	void CDataCaptureReader::checkColumnIndex(uint32_t nColumnIndex) const
+	{
+		if (nColumnIndex >= m_Columns.size())
+			throw EDataTableFormatException(eDataTableFormatError::ColumnNotFound, "invalid data capture column index: " + std::to_string(nColumnIndex));
+	}
+
+	void CDataCaptureReader::checkRowRange(uint64_t nFromRow, uint64_t nRowCount) const
+	{
+		if ((nFromRow > m_nRowCount) || (nRowCount > m_nRowCount - nFromRow))
+			throw EDataTableFormatException(eDataTableFormatError::InvalidRange, "row range " + std::to_string(nFromRow) + " + " + std::to_string(nRowCount) + " exceeds the " + std::to_string(m_nRowCount) + " rows of the data capture");
+	}
+
+	void CDataCaptureReader::validateRowRange(uint64_t nFromRow, uint64_t nRowCount) const
+	{
+		checkRowRange(nFromRow, nRowCount);
+	}
+
+	const sDataTableV2Column& CDataCaptureReader::getColumn(uint32_t nColumnIndex) const
+	{
+		checkColumnIndex(nColumnIndex);
+		return m_Columns[nColumnIndex];
+	}
+
+	bool CDataCaptureReader::findColumn(const std::string& sIdentifier, uint32_t& nColumnIndex) const
+	{
+		for (size_t nIndex = 0; nIndex < m_Columns.size(); nIndex++) {
+			if (m_Columns[nIndex].m_sIdentifier == sIdentifier) {
+				nColumnIndex = (uint32_t)nIndex;
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	uint32_t CDataCaptureReader::getColumnIndex(const std::string& sIdentifier) const
+	{
+		uint32_t nColumnIndex = 0;
+		if (!findColumn(sIdentifier, nColumnIndex))
+			throw EDataTableFormatException(eDataTableFormatError::ColumnNotFound, "data capture column not found: " + sIdentifier);
+
+		return nColumnIndex;
+	}
+
+	double CDataCaptureReader::getColumnQuantization(uint32_t nColumnIndex)
+	{
+		checkColumnIndex(nColumnIndex);
+
+		// The quantisation step is part of the segment schema.
+		for (size_t nSegmentIndex = 0; nSegmentIndex < m_Segments.size(); nSegmentIndex++) {
+			if (!m_Segments[nSegmentIndex].m_bIsPurged)
+				return openSegment((uint32_t)nSegmentIndex)->m_pReader->getColumn(nColumnIndex).m_dQuantizationStep;
+		}
+
+		return 0.0;
+	}
+
+	uint32_t CDataCaptureReader::getSegmentCount() const
+	{
+		return (uint32_t)m_Segments.size();
+	}
+
+	const sDataCaptureSegmentInfo& CDataCaptureReader::getSegment(uint32_t nSegmentIndex) const
+	{
+		if (nSegmentIndex >= m_Segments.size())
+			throw EDataTableFormatException(eDataTableFormatError::InvalidRange, "invalid data capture segment index: " + std::to_string(nSegmentIndex));
+
+		return m_Segments[nSegmentIndex];
+	}
+
+	uint64_t CDataCaptureReader::getChunkCount() const
+	{
+		return m_nChunkCount;
+	}
+
+	uint32_t CDataCaptureReader::findSegmentOfRow(uint64_t nRow) const
+	{
+		// The first segment whose first row is beyond the row, minus one.
+		auto iIter = std::upper_bound(m_Segments.begin(), m_Segments.end(), nRow, [](uint64_t nValue, const sDataCaptureSegmentInfo& segment) {
+			return nValue < segment.m_nFirstRow;
+		});
+
+		if (iIter == m_Segments.begin())
+			throw EDataTableFormatException(eDataTableFormatError::InvalidRange, "row is not part of the data capture: " + std::to_string(nRow));
+
+		return (uint32_t)(iIter - m_Segments.begin()) - 1;
+	}
+
+	CDataCaptureOpenSegment* CDataCaptureReader::openSegment(uint32_t nSegmentIndex)
+	{
+		auto& segment = getSegment(nSegmentIndex);
+
+		auto iIter = m_OpenSegments.find(nSegmentIndex);
+		if (iIter != m_OpenSegments.end()) {
+			m_OpenSegmentOrder.remove(nSegmentIndex);
+			m_OpenSegmentOrder.push_back(nSegmentIndex);
+			return iIter->second.get();
+		}
+
+		if (segment.m_bIsPurged)
+			throw EDataTableFormatException(eDataTableFormatError::SegmentPurged, "data capture segment " + std::to_string(nSegmentIndex) + " has been deleted by retention");
+
+		auto pOpenSegment = std::make_shared<CDataCaptureOpenSegment>(m_pStorage->RetrieveStream(segment.m_sStreamUUID));
+
+		// The segment must be the one the manifest describes.
+		auto pReader = pOpenSegment->m_pReader.get();
+		bool bMatches = (pReader->getRowCount() == segment.m_nRowCount) && (pReader->getChunkCount() == segment.m_nChunkCount) && (pReader->getFirstRowIndex() == segment.m_nFirstRow) && (pReader->getColumnCount() == m_Columns.size());
+		for (uint32_t nColumnIndex = 0; bMatches && (nColumnIndex < m_Columns.size()); nColumnIndex++)
+			bMatches = (pReader->getColumn(nColumnIndex).m_DataType == m_Columns[nColumnIndex].m_DataType);
+		if (!bMatches)
+			throw EDataTableFormatException(eDataTableFormatError::Corrupt, "data capture segment " + std::to_string(nSegmentIndex) + " does not match the manifest");
+
+		// Least recently used segments are closed first.
+		while (m_OpenSegments.size() >= DATACAPTUREREADER_MAXOPENSEGMENTS) {
+			m_OpenSegments.erase(m_OpenSegmentOrder.front());
+			m_OpenSegmentOrder.pop_front();
+		}
+
+		m_OpenSegments.insert(std::make_pair(nSegmentIndex, pOpenSegment));
+		m_OpenSegmentOrder.push_back(nSegmentIndex);
+
+		return pOpenSegment.get();
+	}
+
+	sDataCaptureChunkInfo CDataCaptureReader::getChunkInfo(uint64_t nChunkIndex)
+	{
+		if (nChunkIndex >= m_nChunkCount)
+			throw EDataTableFormatException(eDataTableFormatError::InvalidRange, "invalid data capture chunk index: " + std::to_string(nChunkIndex));
+
+		auto iIter = std::upper_bound(m_Segments.begin(), m_Segments.end(), nChunkIndex, [](uint64_t nValue, const sDataCaptureSegmentInfo& segment) {
+			return nValue < segment.m_nFirstChunkIndex;
+		});
+
+		// Segments without chunks share their first chunk index with the next segment, so step back to the one that holds the chunk.
+		uint32_t nSegmentIndex = (uint32_t)(iIter - m_Segments.begin()) - 1;
+		auto& segment = m_Segments[nSegmentIndex];
+
+		sDataCaptureChunkInfo chunkInfo;
+		chunkInfo.m_nSegmentIndex = nSegmentIndex;
+		chunkInfo.m_nFirstRow = segment.m_nFirstRow;
+		chunkInfo.m_nRowCount = 0;
+		chunkInfo.m_bIsAvailable = !segment.m_bIsPurged;
+
+		if (chunkInfo.m_bIsAvailable) {
+			auto pOpenSegment = openSegment(nSegmentIndex);
+			size_t nChunkInSegment = (size_t)(nChunkIndex - segment.m_nFirstChunkIndex);
+			chunkInfo.m_nFirstRow = segment.m_nFirstRow + pOpenSegment->m_ChunkFirstRows[nChunkInSegment];
+			chunkInfo.m_nRowCount = pOpenSegment->m_ChunkFirstRows[nChunkInSegment + 1] - pOpenSegment->m_ChunkFirstRows[nChunkInSegment];
+		}
+
+		return chunkInfo;
+	}
+
+	bool CDataCaptureReader::getChunkStatistics(uint64_t nChunkIndex, uint32_t nColumnIndex, double& dMinValue, double& dMaxValue)
+	{
+		checkColumnIndex(nColumnIndex);
+
+		dMinValue = 0.0;
+		dMaxValue = 0.0;
+
+		auto chunkInfo = getChunkInfo(nChunkIndex);
+		if (!chunkInfo.m_bIsAvailable)
+			return false;
+
+		auto& segment = m_Segments[chunkInfo.m_nSegmentIndex];
+		auto pOpenSegment = openSegment(chunkInfo.m_nSegmentIndex);
+		auto& entry = pOpenSegment->m_pReader->getPageEntry((uint32_t)(nChunkIndex - segment.m_nFirstChunkIndex), nColumnIndex);
+
+		if ((entry.m_nFlags & DATATABLE_V2_PAGEFLAG_STATISTICSVALID) == 0)
+			return false;
+
+		dMinValue = CDataTableV2::statisticsValueToDouble(m_Columns[nColumnIndex].m_DataType, entry.m_nMinValue);
+		dMaxValue = CDataTableV2::statisticsValueToDouble(m_Columns[nColumnIndex].m_DataType, entry.m_nMaxValue);
+		return true;
+	}
+
+	// Returns the plain values of a page. The last page stays in the scratch buffer, so that
+	// consecutive requests for the same page cost one read.
+	const uint8_t* CDataCaptureReader::loadPage(CDataCaptureOpenSegment* pOpenSegment, uint32_t nSegmentIndex, uint32_t nChunkIndex, uint32_t nColumnIndex, uint64_t nChunkRowCount)
+	{
+		if (m_bPageCached && (m_nCachedSegmentIndex == nSegmentIndex) && (m_nCachedChunkIndex == nChunkIndex) && (m_nCachedColumnIndex == nColumnIndex))
+			return m_PageScratch.data();
+
+		m_bPageCached = false;
+		m_PageScratch.resize((size_t)(nChunkRowCount * m_EntrySizes[nColumnIndex]));
+		pOpenSegment->m_pReader->readPage(nChunkIndex, nColumnIndex, m_PageScratch.data(), m_PageScratch.size());
+		m_nPageReadCount++;
+
+		m_nCachedSegmentIndex = nSegmentIndex;
+		m_nCachedChunkIndex = nChunkIndex;
+		m_nCachedColumnIndex = nColumnIndex;
+		m_bPageCached = true;
+
+		return m_PageScratch.data();
+	}
+
+	void CDataCaptureReader::forEachPageInRange(uint32_t nColumnIndex, uint64_t nFromRow, uint64_t nRowCount, const std::function<void(const uint8_t* pPlainValues, uint64_t nRangeOffset, uint64_t nCount)>& callback)
+	{
+		checkColumnIndex(nColumnIndex);
+		checkRowRange(nFromRow, nRowCount);
+
+		if (nRowCount == 0)
+			return;
+
+		uint32_t nEntrySize = m_EntrySizes[nColumnIndex];
+		uint64_t nRow = nFromRow;
+		uint64_t nEndRow = nFromRow + nRowCount;
+		uint32_t nSegmentIndex = findSegmentOfRow(nRow);
+
+		while (nRow < nEndRow) {
+			auto& segment = m_Segments[nSegmentIndex];
+			uint64_t nSegmentEndRow = segment.m_nFirstRow + segment.m_nRowCount;
+
+			// Skips segments without rows.
+			if (nRow >= nSegmentEndRow) {
+				nSegmentIndex++;
+				continue;
+			}
+
+			if (segment.m_bIsPurged)
+				throw EDataTableFormatException(eDataTableFormatError::SegmentPurged, "rows " + std::to_string(segment.m_nFirstRow) + " to " + std::to_string(nSegmentEndRow - 1) + " of the data capture have been deleted by retention");
+
+			auto pOpenSegment = openSegment(nSegmentIndex);
+			auto& chunkFirstRows = pOpenSegment->m_ChunkFirstRows;
+
+			// The chunk that holds the row: the first chunk that starts beyond it, minus one.
+			uint64_t nRowInSegment = nRow - segment.m_nFirstRow;
+			size_t nChunkIndex = (size_t)(std::upper_bound(chunkFirstRows.begin(), chunkFirstRows.end(), nRowInSegment) - chunkFirstRows.begin()) - 1;
+
+			while ((nRow < nEndRow) && (nRow < nSegmentEndRow)) {
+				uint64_t nChunkRowCount = chunkFirstRows[nChunkIndex + 1] - chunkFirstRows[nChunkIndex];
+				uint64_t nOffsetInChunk = nRow - segment.m_nFirstRow - chunkFirstRows[nChunkIndex];
+				uint64_t nCount = (std::min)(nChunkRowCount - nOffsetInChunk, nEndRow - nRow);
+
+				const uint8_t* pPageData = loadPage(pOpenSegment, nSegmentIndex, (uint32_t)nChunkIndex, nColumnIndex, nChunkRowCount);
+
+				callback(pPageData + nOffsetInChunk * nEntrySize, nRow - nFromRow, nCount);
+
+				nRow += nCount;
+				nChunkIndex++;
+			}
+
+			nSegmentIndex++;
+		}
+	}
+
+	double CDataCaptureReader::plainValueToDouble(uint32_t nColumnIndex, const uint8_t* pPlainValues, uint64_t nIndex) const
+	{
+		double dValue = 0.0;
+		convertPlainToDouble(m_Columns[nColumnIndex].m_DataType, pPlainValues + nIndex * m_EntrySizes[nColumnIndex], 1, &dValue);
+		return dValue;
+	}
+
+	void CDataCaptureReader::readColumnPlain(uint32_t nColumnIndex, uint64_t nFromRow, uint64_t nRowCount, uint8_t* pTarget, uint64_t nTargetSize)
+	{
+		checkColumnIndex(nColumnIndex);
+		checkRowRange(nFromRow, nRowCount);
+
+		if (nRowCount == 0)
+			return;
+
+		uint32_t nEntrySize = m_EntrySizes[nColumnIndex];
+		if ((pTarget == nullptr) || (nTargetSize / nEntrySize < nRowCount))
+			throw EDataTableFormatException(eDataTableFormatError::InvalidParam, "data capture read buffer is too small");
+
+		forEachPageInRange(nColumnIndex, nFromRow, nRowCount, [pTarget, nEntrySize](const uint8_t* pPlainValues, uint64_t nRangeOffset, uint64_t nCount) {
+			memcpy(pTarget + nRangeOffset * nEntrySize, pPlainValues, (size_t)(nCount * nEntrySize));
+		});
+	}
+
+	void CDataCaptureReader::readColumnAsDouble(uint32_t nColumnIndex, uint64_t nFromRow, uint64_t nRowCount, double* pTarget)
+	{
+		checkColumnIndex(nColumnIndex);
+		checkRowRange(nFromRow, nRowCount);
+
+		if (nRowCount == 0)
+			return;
+		if (pTarget == nullptr)
+			throw EDataTableFormatException(eDataTableFormatError::InvalidParam, "data capture read buffer is null");
+
+		auto dataType = m_Columns[nColumnIndex].m_DataType;
+		forEachPageInRange(nColumnIndex, nFromRow, nRowCount, [pTarget, dataType](const uint8_t* pPlainValues, uint64_t nRangeOffset, uint64_t nCount) {
+			convertPlainToDouble(dataType, pPlainValues, nCount, pTarget + nRangeOffset);
+		});
+	}
+
+	void CDataCaptureReader::readColumnAsFloat(uint32_t nColumnIndex, uint64_t nFromRow, uint64_t nRowCount, float* pTarget)
+	{
+		checkColumnIndex(nColumnIndex);
+		checkRowRange(nFromRow, nRowCount);
+
+		auto dataType = m_Columns[nColumnIndex].m_DataType;
+		if ((dataType != eDataTableV2DataType::Float) && (dataType != eDataTableV2DataType::Double))
+			throw EDataTableFormatException(eDataTableFormatError::TypeMismatch, "data capture column " + m_Columns[nColumnIndex].m_sIdentifier + " is not a floating point column");
+
+		if (nRowCount == 0)
+			return;
+		if (pTarget == nullptr)
+			throw EDataTableFormatException(eDataTableFormatError::InvalidParam, "data capture read buffer is null");
+
+		forEachPageInRange(nColumnIndex, nFromRow, nRowCount, [pTarget, dataType](const uint8_t* pPlainValues, uint64_t nRangeOffset, uint64_t nCount) {
+			if (dataType == eDataTableV2DataType::Float) {
+				memcpy(pTarget + nRangeOffset, pPlainValues, (size_t)nCount * sizeof(float));
+			}
+			else {
+				for (uint64_t nIndex = 0; nIndex < nCount; nIndex++)
+					pTarget[nRangeOffset + nIndex] = (float)loadPlainValue<double>(pPlainValues, nIndex);
+			}
+		});
+	}
+
+	void CDataCaptureReader::readColumnAsInt64(uint32_t nColumnIndex, uint64_t nFromRow, uint64_t nRowCount, int64_t* pTarget)
+	{
+		checkColumnIndex(nColumnIndex);
+		checkRowRange(nFromRow, nRowCount);
+
+		auto dataType = m_Columns[nColumnIndex].m_DataType;
+		if ((dataType == eDataTableV2DataType::Float) || (dataType == eDataTableV2DataType::Double))
+			throw EDataTableFormatException(eDataTableFormatError::TypeMismatch, "data capture column " + m_Columns[nColumnIndex].m_sIdentifier + " is not an integer column");
+
+		if (nRowCount == 0)
+			return;
+		if (pTarget == nullptr)
+			throw EDataTableFormatException(eDataTableFormatError::InvalidParam, "data capture read buffer is null");
+
+		std::string sIdentifier = m_Columns[nColumnIndex].m_sIdentifier;
+		forEachPageInRange(nColumnIndex, nFromRow, nRowCount, [pTarget, dataType, &sIdentifier](const uint8_t* pPlainValues, uint64_t nRangeOffset, uint64_t nCount) {
+			int64_t* pRunTarget = pTarget + nRangeOffset;
+
+			switch (dataType) {
+			case eDataTableV2DataType::Int32:
+				for (uint64_t nIndex = 0; nIndex < nCount; nIndex++)
+					pRunTarget[nIndex] = (int64_t)loadPlainValue<int32_t>(pPlainValues, nIndex);
+				break;
+			case eDataTableV2DataType::Uint32:
+				for (uint64_t nIndex = 0; nIndex < nCount; nIndex++)
+					pRunTarget[nIndex] = (int64_t)loadPlainValue<uint32_t>(pPlainValues, nIndex);
+				break;
+			case eDataTableV2DataType::Int64:
+				memcpy(pRunTarget, pPlainValues, (size_t)nCount * sizeof(int64_t));
+				break;
+			case eDataTableV2DataType::Bool:
+				for (uint64_t nIndex = 0; nIndex < nCount; nIndex++)
+					pRunTarget[nIndex] = (int64_t)loadPlainValue<uint8_t>(pPlainValues, nIndex);
+				break;
+			default:
+				// Uint64 and Timestamp: values beyond the signed range can not be returned.
+				for (uint64_t nIndex = 0; nIndex < nCount; nIndex++) {
+					uint64_t nValue = loadPlainValue<uint64_t>(pPlainValues, nIndex);
+					if (nValue > (uint64_t)(std::numeric_limits<int64_t>::max)())
+						throw EDataTableFormatException(eDataTableFormatError::TypeMismatch, "data capture column " + sIdentifier + " holds a value beyond the signed 64 bit range");
+					pRunTarget[nIndex] = (int64_t)nValue;
+				}
+				break;
+			}
+		});
+	}
+
+	uint64_t CDataCaptureReader::getDownsampleBucketCount(uint64_t nRowCount, uint32_t nTargetPoints)
+	{
+		if (nTargetPoints == 0)
+			throw EDataTableFormatException(eDataTableFormatError::InvalidParam, "downsample target point count is zero");
+
+		return (std::min)(nRowCount, (uint64_t)nTargetPoints);
+	}
+
+	uint64_t CDataCaptureReader::getDownsampleValueCount(uint64_t nRowCount, uint32_t nTargetPoints, eDataCaptureDownsampleMode mode)
+	{
+		uint64_t nBucketCount = getDownsampleBucketCount(nRowCount, nTargetPoints);
+
+		switch (mode) {
+		case eDataCaptureDownsampleMode::Stride:
+		case eDataCaptureDownsampleMode::Average:
+			return nBucketCount;
+		case eDataCaptureDownsampleMode::MinMax:
+			return 2 * nBucketCount;
+		default:
+			throw EDataTableFormatException(eDataTableFormatError::InvalidParam, "invalid downsample mode");
+		}
+	}
+
+	void CDataCaptureReader::readColumnDownsampled(uint32_t nColumnIndex, uint64_t nFromRow, uint64_t nRowCount, uint32_t nTargetPoints, eDataCaptureDownsampleMode mode, double* pTarget)
+	{
+		checkColumnIndex(nColumnIndex);
+		checkRowRange(nFromRow, nRowCount);
+
+		// Validates the target point count and the mode.
+		getDownsampleValueCount(nRowCount, nTargetPoints, mode);
+
+		uint64_t nBucketCount = getDownsampleBucketCount(nRowCount, nTargetPoints);
+		if (nBucketCount == 0)
+			return;
+		if (pTarget == nullptr)
+			throw EDataTableFormatException(eDataTableFormatError::InvalidParam, "data capture read buffer is null");
+
+		// Bucket b covers the rows [bucketStart(b), bucketStart(b + 1)) relative to the range.
+		// Every bucket holds at least one row, because there are not more buckets than rows.
+		uint64_t nQuotient = nRowCount / nBucketCount;
+		uint64_t nRemainder = nRowCount % nBucketCount;
+		auto bucketStart = [nQuotient, nRemainder, nBucketCount](uint64_t nBucketIndex) {
+			return nBucketIndex * nQuotient + (nBucketIndex * nRemainder) / nBucketCount;
+		};
+
+		auto dataType = m_Columns[nColumnIndex].m_DataType;
+		uint32_t nEntrySize = m_EntrySizes[nColumnIndex];
+		double dNaN = std::numeric_limits<double>::quiet_NaN();
+
+		if (mode == eDataCaptureDownsampleMode::Stride) {
+			// Only the pages that hold the first row of a bucket are read. Consecutive buckets
+			// that start in the same page share one read through the page cache.
+			for (uint64_t nBucketIndex = 0; nBucketIndex < nBucketCount; nBucketIndex++)
+				readColumnAsDouble(nColumnIndex, nFromRow + bucketStart(nBucketIndex), 1, pTarget + nBucketIndex);
+			return;
+		}
+
+		std::vector<double> bucketMin((size_t)nBucketCount, dNaN);
+		std::vector<double> bucketMax((size_t)nBucketCount, dNaN);
+		std::vector<double> bucketSum((size_t)nBucketCount, 0.0);
+		std::vector<uint64_t> bucketValueCount((size_t)nBucketCount, 0);
+
+		auto accumulate = [&](uint64_t nBucketIndex, double dMinValue, double dMaxValue) {
+			if (std::isnan(bucketMin[(size_t)nBucketIndex]) || (dMinValue < bucketMin[(size_t)nBucketIndex]))
+				bucketMin[(size_t)nBucketIndex] = dMinValue;
+			if (std::isnan(bucketMax[(size_t)nBucketIndex]) || (dMaxValue > bucketMax[(size_t)nBucketIndex]))
+				bucketMax[(size_t)nBucketIndex] = dMaxValue;
+		};
+
+		// Walks the chunks of the range. In MinMax mode a chunk that lies completely inside one bucket
+		// contributes its page statistics and is not read at all.
+		uint64_t nRow = nFromRow;
+		uint64_t nEndRow = nFromRow + nRowCount;
+		uint32_t nSegmentIndex = findSegmentOfRow(nRow);
+		uint64_t nBucketIndex = 0;
+		uint64_t nBucketEnd = bucketStart(1);
+		std::vector<double> runValues;
+
+		while (nRow < nEndRow) {
+			auto& segment = m_Segments[nSegmentIndex];
+			uint64_t nSegmentEndRow = segment.m_nFirstRow + segment.m_nRowCount;
+
+			if (nRow >= nSegmentEndRow) {
+				nSegmentIndex++;
+				continue;
+			}
+
+			if (segment.m_bIsPurged)
+				throw EDataTableFormatException(eDataTableFormatError::SegmentPurged, "rows " + std::to_string(segment.m_nFirstRow) + " to " + std::to_string(nSegmentEndRow - 1) + " of the data capture have been deleted by retention");
+
+			auto pOpenSegment = openSegment(nSegmentIndex);
+			auto& chunkFirstRows = pOpenSegment->m_ChunkFirstRows;
+
+			uint64_t nRowInSegment = nRow - segment.m_nFirstRow;
+			size_t nChunkIndex = (size_t)(std::upper_bound(chunkFirstRows.begin(), chunkFirstRows.end(), nRowInSegment) - chunkFirstRows.begin()) - 1;
+
+			while ((nRow < nEndRow) && (nRow < nSegmentEndRow)) {
+				uint64_t nChunkRowCount = chunkFirstRows[nChunkIndex + 1] - chunkFirstRows[nChunkIndex];
+				uint64_t nOffsetInChunk = nRow - segment.m_nFirstRow - chunkFirstRows[nChunkIndex];
+				uint64_t nCount = (std::min)(nChunkRowCount - nOffsetInChunk, nEndRow - nRow);
+
+				uint64_t nRangeOffset = nRow - nFromRow;
+				while (nRangeOffset >= nBucketEnd) {
+					nBucketIndex++;
+					nBucketEnd = bucketStart(nBucketIndex + 1);
+				}
+
+				bool bWholeChunkInBucket = (nOffsetInChunk == 0) && (nCount == nChunkRowCount) && (nRangeOffset + nCount <= nBucketEnd);
+
+				if ((mode == eDataCaptureDownsampleMode::MinMax) && bWholeChunkInBucket) {
+					auto& entry = pOpenSegment->m_pReader->getPageEntry((uint32_t)nChunkIndex, nColumnIndex);
+
+					// A page without statistics holds no comparable value and contributes nothing.
+					if ((entry.m_nFlags & DATATABLE_V2_PAGEFLAG_STATISTICSVALID) != 0)
+						accumulate(nBucketIndex, CDataTableV2::statisticsValueToDouble(dataType, entry.m_nMinValue), CDataTableV2::statisticsValueToDouble(dataType, entry.m_nMaxValue));
+				}
+				else {
+					const uint8_t* pPageData = loadPage(pOpenSegment, nSegmentIndex, (uint32_t)nChunkIndex, nColumnIndex, nChunkRowCount);
+
+					runValues.resize((size_t)nCount);
+					convertPlainToDouble(dataType, pPageData + nOffsetInChunk * nEntrySize, nCount, runValues.data());
+
+					for (uint64_t nIndex = 0; nIndex < nCount; nIndex++) {
+						while (nRangeOffset + nIndex >= nBucketEnd) {
+							nBucketIndex++;
+							nBucketEnd = bucketStart(nBucketIndex + 1);
+						}
+
+						double dValue = runValues[(size_t)nIndex];
+						if (std::isnan(dValue))
+							continue;
+
+						accumulate(nBucketIndex, dValue, dValue);
+						bucketSum[(size_t)nBucketIndex] += dValue;
+						bucketValueCount[(size_t)nBucketIndex]++;
+					}
+				}
+
+				nRow += nCount;
+				nChunkIndex++;
+			}
+
+			nSegmentIndex++;
+		}
+
+		if (mode == eDataCaptureDownsampleMode::MinMax) {
+			for (uint64_t nIndex = 0; nIndex < nBucketCount; nIndex++) {
+				pTarget[2 * nIndex] = bucketMin[(size_t)nIndex];
+				pTarget[2 * nIndex + 1] = bucketMax[(size_t)nIndex];
+			}
+		}
+		else {
+			for (uint64_t nIndex = 0; nIndex < nBucketCount; nIndex++)
+				pTarget[nIndex] = (bucketValueCount[(size_t)nIndex] > 0) ? (bucketSum[(size_t)nIndex] / (double)bucketValueCount[(size_t)nIndex]) : dNaN;
+		}
+	}
+
+	std::vector<uint64_t> CDataCaptureReader::findChunksInValueRange(uint32_t nColumnIndex, double dMinValue, double dMaxValue)
+	{
+		checkColumnIndex(nColumnIndex);
+
+		std::vector<uint64_t> chunkIndices;
+		if (std::isnan(dMinValue) || std::isnan(dMaxValue) || (dMinValue > dMaxValue))
+			return chunkIndices;
+
+		auto dataType = m_Columns[nColumnIndex].m_DataType;
+
+		for (size_t nSegmentIndex = 0; nSegmentIndex < m_Segments.size(); nSegmentIndex++) {
+			auto& segment = m_Segments[nSegmentIndex];
+			if (segment.m_bIsPurged || (segment.m_nChunkCount == 0))
+				continue;
+
+			auto pOpenSegment = openSegment((uint32_t)nSegmentIndex);
+			for (uint32_t nChunkInSegment = 0; nChunkInSegment < segment.m_nChunkCount; nChunkInSegment++) {
+				auto& entry = pOpenSegment->m_pReader->getPageEntry(nChunkInSegment, nColumnIndex);
+
+				// A page without statistics holds no comparable value and can not match.
+				if ((entry.m_nFlags & DATATABLE_V2_PAGEFLAG_STATISTICSVALID) == 0)
+					continue;
+
+				double dPageMin = CDataTableV2::statisticsValueToDouble(dataType, entry.m_nMinValue);
+				double dPageMax = CDataTableV2::statisticsValueToDouble(dataType, entry.m_nMaxValue);
+				if ((dPageMax >= dMinValue) && (dPageMin <= dMaxValue))
+					chunkIndices.push_back(segment.m_nFirstChunkIndex + nChunkInSegment);
+			}
+		}
+
+		return chunkIndices;
+	}
+
+	uint64_t CDataCaptureReader::getPageReadCount() const
+	{
+		return m_nPageReadCount;
+	}
+
+}
diff --git a/Implementation/Core/amc_datacapturereader.hpp b/Implementation/Core/amc_datacapturereader.hpp
new file mode 100644
index 000000000..495496167
--- /dev/null
+++ b/Implementation/Core/amc_datacapturereader.hpp
@@ -0,0 +1,209 @@
+/*++
+
+Copyright (C) 2020 Autodesk Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+	* Redistributions of source code must retain the above copyright
+	  notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+	  notice, this list of conditions and the following disclaimer in the
+	  documentation and/or other materials provided with the distribution.
+	* Neither the name of the Autodesk Inc. nor the
+	  names of its contributors may be used to endorse or promote products
+	  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL AUTODESK INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+
+#ifndef __AMC_DATACAPTUREREADER
+#define __AMC_DATACAPTUREREADER
+
+#include "amc_datatableformat.hpp"
+#include "libmcdata_dynamic.hpp"
+
+#include <cstdint>
+#include <functional>
+#include <list>
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+// Number of segment streams a reader keeps open at the same time.
+#define DATACAPTUREREADER_MAXOPENSEGMENTS 8
+
+namespace AMC {
+
+	enum class eDataCaptureDownsampleMode : uint32_t {
+		Stride = 1,
+		MinMax = 2,
+		Average = 3
+	};
+
+	struct sDataCaptureSegmentInfo {
+		std::string m_sStreamUUID;
+		uint64_t m_nFirstRow;
+		uint64_t m_nRowCount;
+		uint64_t m_nSizeInBytes;
+		uint32_t m_nChunkCount;
+		uint64_t m_nFirstChunkIndex;
+		bool m_bIsPurged;
+	};
+
+	struct sDataCaptureChunkInfo {
+		uint32_t m_nSegmentIndex;
+		uint64_t m_nFirstRow;
+		uint64_t m_nRowCount;
+		bool m_bIsAvailable;
+	};
+
+	class CDataCaptureOpenSegment;
+	typedef std::shared_ptr<CDataCaptureOpenSegment> PDataCaptureOpenSegment;
+
+
+	/*************************************************************************************************************************
+	 CDataCaptureReader reads a data capture lazily across its segments. The segment list is a snapshot of the
+	 manifest at construction. A request for a column and a row range is resolved to the pages that overlap it;
+	 segment footers are read on demand and a bounded number of segment streams stays open.
+
+	 Errors are reported as EDataTableFormatException. An instance MUST only be used in a single thread.
+	**************************************************************************************************************************/
+
+	class CDataCaptureReader {
+	private:
+
+		LibMCData::PDataModel m_pDataModel;
+		LibMCData::PStorage m_pStorage;
+
+		std::string m_sUUID;
+		std::string m_sIdentifier;
+		std::string m_sName;
+
+		std::vector<sDataTableV2Column> m_Columns;
+		std::vector<uint32_t> m_EntrySizes;
+		std::vector<sDataCaptureSegmentInfo> m_Segments;
+		uint64_t m_nRowCount;
+		uint64_t m_nChunkCount;
+
+		std::map<uint32_t, PDataCaptureOpenSegment> m_OpenSegments;
+		std::list<uint32_t> m_OpenSegmentOrder;
+
+		uint64_t m_nPageReadCount;
+
+		// The page that was read last stays decoded in the scratch buffer.
+		std::vector<uint8_t> m_PageScratch;
+		bool m_bPageCached;
+		uint32_t m_nCachedSegmentIndex;
+		uint32_t m_nCachedChunkIndex;
+		uint32_t m_nCachedColumnIndex;
+
+		const uint8_t* loadPage(CDataCaptureOpenSegment* pOpenSegment, uint32_t nSegmentIndex, uint32_t nChunkIndex, uint32_t nColumnIndex, uint64_t nChunkRowCount);
+
+		void checkColumnIndex(uint32_t nColumnIndex) const;
+		void checkRowRange(uint64_t nFromRow, uint64_t nRowCount) const;
+
+		// Returns the index of the segment that holds the row.
+		uint32_t findSegmentOfRow(uint64_t nRow) const;
+
+		CDataCaptureOpenSegment* openSegment(uint32_t nSegmentIndex);
+
+		// Calls the callback for every page that overlaps the row range, in row order, with the plain values of
+		// the overlapping part: pointer, index of the first row relative to nFromRow and number of rows.
+		void forEachPageInRange(uint32_t nColumnIndex, uint64_t nFromRow, uint64_t nRowCount, const std::function<void(const uint8_t* pPlainValues, uint64_t nRangeOffset, uint64_t nCount)>& callback);
+
+		double plainValueToDouble(uint32_t nColumnIndex, const uint8_t* pPlainValues, uint64_t nIndex) const;
+
+	public:
+
+		CDataCaptureReader(LibMCData::PDataModel pDataModel, LibMCData::PDataCapture pManifest);
+
+		virtual ~CDataCaptureReader();
+
+		std::string getUUID() const;
+
+		std::string getIdentifier() const;
+
+		std::string getName() const;
+
+		uint64_t getRowCount() const;
+
+		// Fails with InvalidRange if the row range is not part of the capture.
+		void validateRowRange(uint64_t nFromRow, uint64_t nRowCount) const;
+
+		// First row that is still stored. Equal to the row count if nothing is stored.
+		uint64_t getFirstAvailableRow() const;
+
+		uint32_t getColumnCount() const;
+
+		const sDataTableV2Column& getColumn(uint32_t nColumnIndex) const;
+
+		bool findColumn(const std::string& sIdentifier, uint32_t& nColumnIndex) const;
+
+		// Fails with ColumnNotFound if the column does not exist.
+		uint32_t getColumnIndex(const std::string& sIdentifier) const;
+
+		// Quantisation step of the column as recorded in the stored segments. 0 if the column is not quantised.
+		double getColumnQuantization(uint32_t nColumnIndex);
+
+		uint32_t getSegmentCount() const;
+
+		const sDataCaptureSegmentInfo& getSegment(uint32_t nSegmentIndex) const;
+
+		uint64_t getChunkCount() const;
+
+		sDataCaptureChunkInfo getChunkInfo(uint64_t nChunkIndex);
+
+		// Minimum and maximum of a column in a chunk from the page directory. Returns false if the chunk
+		// has been deleted or holds no comparable value.
+		bool getChunkStatistics(uint64_t nChunkIndex, uint32_t nColumnIndex, double& dMinValue, double& dMaxValue);
+
+		// Reads a row range as plain values of the column type into pTarget.
+		void readColumnPlain(uint32_t nColumnIndex, uint64_t nFromRow, uint64_t nRowCount, uint8_t* pTarget, uint64_t nTargetSize);
+
+		// Reads a row range of any column as doubles.
+		void readColumnAsDouble(uint32_t nColumnIndex, uint64_t nFromRow, uint64_t nRowCount, double* pTarget);
+
+		// Reads a row range of a Float or Double column as floats.
+		void readColumnAsFloat(uint32_t nColumnIndex, uint64_t nFromRow, uint64_t nRowCount, float* pTarget);
+
+		// Reads a row range of an integer, bool or timestamp column as 64 bit integers.
+		void readColumnAsInt64(uint32_t nColumnIndex, uint64_t nFromRow, uint64_t nRowCount, int64_t* pTarget);
+
+		// Number of buckets a downsampled read of the range produces.
+		static uint64_t getDownsampleBucketCount(uint64_t nRowCount, uint32_t nTargetPoints);
+
+		// Number of values a downsampled read of the range produces: two per bucket in MinMax mode, one otherwise.
+		static uint64_t getDownsampleValueCount(uint64_t nRowCount, uint32_t nTargetPoints, eDataCaptureDownsampleMode mode);
+
+		// Reduces a row range to buckets. pTarget receives getDownsampleValueCount values.
+		// A bucket without a comparable value yields NaN.
+		void readColumnDownsampled(uint32_t nColumnIndex, uint64_t nFromRow, uint64_t nRowCount, uint32_t nTargetPoints, eDataCaptureDownsampleMode mode, double* pTarget);
+
+		// Indices of the stored chunks whose value range of the column overlaps [dMinValue, dMaxValue].
+		std::vector<uint64_t> findChunksInValueRange(uint32_t nColumnIndex, double dMinValue, double dMaxValue);
+
+		// Number of pages that have been read from storage so far.
+		uint64_t getPageReadCount() const;
+
+	};
+
+	typedef std::shared_ptr<CDataCaptureReader> PDataCaptureReader;
+
+}
+
+
+#endif //__AMC_DATACAPTUREREADER
diff --git a/Implementation/Core/amc_datatableencoding.cpp b/Implementation/Core/amc_datatableencoding.cpp
new file mode 100644
index 000000000..ed58a516a
--- /dev/null
+++ b/Implementation/Core/amc_datatableencoding.cpp
@@ -0,0 +1,401 @@
+/*++
+
+Copyright (C) 2020 Autodesk Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+	* Redistributions of source code must retain the above copyright
+	  notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+	  notice, this list of conditions and the following disclaimer in the
+	  documentation and/or other materials provided with the distribution.
+	* Neither the name of the Autodesk Inc. nor the
+	  names of its contributors may be used to endorse or promote products
+	  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL AUTODESK INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#include "amc_datatableencoding.hpp"
+#include "amc_datatableformat.hpp"
+
+#include "Libraries/lz4/lz4.h"
+#include "Libraries/zlib/zlib.h"
+
+#include <cstring>
+
+namespace AMC {
+
+	namespace {
+
+		void writeULEB128(std::vector<uint8_t>& buffer, uint64_t nValue)
+		{
+			while (nValue >= 0x80) {
+				buffer.push_back((uint8_t)(nValue & 0x7F) | 0x80);
+				nValue >>= 7;
+			}
+			buffer.push_back((uint8_t)nValue);
+		}
+
+		uint64_t readULEB128(const uint8_t* pData, size_t nDataSize, size_t& nPosition)
+		{
+			uint64_t nValue = 0;
+			for (uint32_t nShift = 0; nShift < 70; nShift += 7) {
+				if (nPosition >= nDataSize)
+					throw EDataTableFormatException(eDataTableFormatError::Corrupt, "delta encoded page ends inside a number");
+
+				uint8_t nByte = pData[nPosition];
+				nPosition++;
+
+				nValue |= ((uint64_t)(nByte & 0x7F)) << nShift;
+				if ((nByte & 0x80) == 0)
+					return nValue;
+			}
+
+			throw EDataTableFormatException(eDataTableFormatError::Corrupt, "delta encoded page holds an invalid number");
+		}
+
+		uint64_t zigzagEncode(int64_t nValue)
+		{
+			return ((uint64_t)nValue << 1) ^ (uint64_t)(nValue >> 63);
+		}
+
+		int64_t zigzagDecode(uint64_t nValue)
+		{
+			return (int64_t)(nValue >> 1) ^ -(int64_t)(nValue & 1);
+		}
+
+		uint32_t bitWidthOf(uint64_t nValue)
+		{
+			uint32_t nWidth = 0;
+			while (nValue != 0) {
+				nWidth++;
+				nValue >>= 1;
+			}
+			return nWidth;
+		}
+
+		// Packs DATATABLE_DELTA_MINIBLOCKSIZE values with nWidth bits each, least significant bit first.
+		void packMiniblock(const uint64_t* pValues, uint32_t nWidth, std::vector<uint8_t>& buffer)
+		{
+			if (nWidth == 0)
+				return;
+
+			uint64_t nAccumulator = 0;
+			uint32_t nAccumulatedBits = 0;
+
+			for (uint32_t nIndex = 0; nIndex < DATATABLE_DELTA_MINIBLOCKSIZE; nIndex++) {
+				uint64_t nValue = pValues[nIndex];
+				uint32_t nRemainingBits = nWidth;
+
+				while (nRemainingBits > 0) {
+					uint32_t nTakeBits = 64 - nAccumulatedBits;
+					if (nTakeBits > nRemainingBits)
+						nTakeBits = nRemainingBits;
+
+					uint64_t nPart = (nTakeBits == 64) ? nValue : (nValue & ((1ULL << nTakeBits) - 1));
+					nAccumulator |= nPart << nAccumulatedBits;
+					nAccumulatedBits += nTakeBits;
+					nRemainingBits -= nTakeBits;
+					nValue = (nTakeBits == 64) ? 0 : (nValue >> nTakeBits);
+
+					if (nAccumulatedBits == 64) {
+						for (uint32_t nByteIndex = 0; nByteIndex < 8; nByteIndex++)
+							buffer.push_back((uint8_t)(nAccumulator >> (8 * nByteIndex)));
+						nAccumulator = 0;
+						nAccumulatedBits = 0;
+					}
+				}
+			}
+
+			// A miniblock is a whole number of bytes, because its size is a multiple of 8 values.
+			for (uint32_t nByteIndex = 0; nByteIndex * 8 < nAccumulatedBits; nByteIndex++)
+				buffer.push_back((uint8_t)(nAccumulator >> (8 * nByteIndex)));
+		}
+
+		// Reads bit-packed values from a byte range, least significant bit first.
+		class CBitReader {
+		private:
+			const uint8_t* m_pData;
+			size_t m_nBitPosition;
+
+		public:
+			explicit CBitReader(const uint8_t* pData)
+				: m_pData(pData), m_nBitPosition(0)
+			{
+			}
+
+			uint64_t read(uint32_t nWidth)
+			{
+				uint64_t nValue = 0;
+				uint32_t nReadBits = 0;
+
+				while (nReadBits < nWidth) {
+					uint32_t nBitOffset = (uint32_t)(m_nBitPosition & 7);
+					uint32_t nTakeBits = 8 - nBitOffset;
+					if (nTakeBits > nWidth - nReadBits)
+						nTakeBits = nWidth - nReadBits;
+
+					uint64_t nPart = ((uint64_t)m_pData[m_nBitPosition >> 3] >> nBitOffset) & ((1ULL << nTakeBits) - 1);
+					nValue |= nPart << nReadBits;
+
+					nReadBits += nTakeBits;
+					m_nBitPosition += nTakeBits;
+				}
+
+				return nValue;
+			}
+		};
+
+	}
+
+
+	void CDataTableEncoding::encodeDelta(const int64_t* pValues, size_t nValueCount, std::vector<uint8_t>& buffer)
+	{
+		if ((nValueCount > 0) && (pValues == nullptr))
+			throw EDataTableFormatException(eDataTableFormatError::InvalidParam, "delta encoding input is null");
+
+		writeULEB128(buffer, DATATABLE_DELTA_BLOCKSIZE);
+		writeULEB128(buffer, DATATABLE_DELTA_MINIBLOCKCOUNT);
+		writeULEB128(buffer, nValueCount);
+		writeULEB128(buffer, zigzagEncode((nValueCount > 0) ? pValues[0] : 0));
+
+		size_t nDeltaCount = (nValueCount > 0) ? (nValueCount - 1) : 0;
+		size_t nDeltaIndex = 0;
+
+		uint64_t blockDeltas[DATATABLE_DELTA_BLOCKSIZE];
+
+		while (nDeltaIndex < nDeltaCount) {
+			size_t nBlockCount = nDeltaCount - nDeltaIndex;
+			if (nBlockCount > DATATABLE_DELTA_BLOCKSIZE)
+				nBlockCount = DATATABLE_DELTA_BLOCKSIZE;
+
+			// Deltas use wrapping arithmetic, so that every pair of 64 bit values has a delta.
+			int64_t nMinDelta = 0;
+			for (size_t nIndex = 0; nIndex < nBlockCount; nIndex++) {
+				uint64_t nDelta = (uint64_t)pValues[nDeltaIndex + nIndex + 1] - (uint64_t)pValues[nDeltaIndex + nIndex];
+				blockDeltas[nIndex] = nDelta;
+				if ((nIndex == 0) || ((int64_t)nDelta < nMinDelta))
+					nMinDelta = (int64_t)nDelta;
+			}
+
+			writeULEB128(buffer, zigzagEncode(nMinDelta));
+
+			// Missing values of the last block are padded with the minimum delta, which packs as zero.
+			for (size_t nIndex = 0; nIndex < DATATABLE_DELTA_BLOCKSIZE; nIndex++) {
+				if (nIndex < nBlockCount)
+					blockDeltas[nIndex] -= (uint64_t)nMinDelta;
+				else
+					blockDeltas[nIndex] = 0;
+			}
+
+			uint8_t miniblockWidths[DATATABLE_DELTA_MINIBLOCKCOUNT];
+			for (size_t nMiniblockIndex = 0; nMiniblockIndex < DATATABLE_DELTA_MINIBLOCKCOUNT; nMiniblockIndex++) {
+				size_t nStart = nMiniblockIndex * DATATABLE_DELTA_MINIBLOCKSIZE;
+
+				uint64_t nCombinedBits = 0;
+				if (nStart < nBlockCount) {
+					for (size_t nIndex = 0; nIndex < DATATABLE_DELTA_MINIBLOCKSIZE; nIndex++)
+						nCombinedBits |= blockDeltas[nStart + nIndex];
+				}
+
+				miniblockWidths[nMiniblockIndex] = (uint8_t)bitWidthOf(nCombinedBits);
+				buffer.push_back(miniblockWidths[nMiniblockIndex]);
+			}
+
+			// Miniblocks that hold no value at all are not written.
+			for (size_t nMiniblockIndex = 0; nMiniblockIndex < DATATABLE_DELTA_MINIBLOCKCOUNT; nMiniblockIndex++) {
+				size_t nStart = nMiniblockIndex * DATATABLE_DELTA_MINIBLOCKSIZE;
+				if (nStart < nBlockCount)
+					packMiniblock(blockDeltas + nStart, miniblockWidths[nMiniblockIndex], buffer);
+			}
+
+			nDeltaIndex += nBlockCount;
+		}
+	}
+
+	void CDataTableEncoding::decodeDelta(const uint8_t* pData, size_t nDataSize, int64_t* pValues, size_t nValueCount)
+	{
+		if (pData == nullptr)
+			throw EDataTableFormatException(eDataTableFormatError::InvalidParam, "delta decoding input is null");
+		if ((nValueCount > 0) && (pValues == nullptr))
+			throw EDataTableFormatException(eDataTableFormatError::InvalidParam, "delta decoding output is null");
+
+		size_t nPosition = 0;
+		uint64_t nBlockSize = readULEB128(pData, nDataSize, nPosition);
+		uint64_t nMiniblockCount = readULEB128(pData, nDataSize, nPosition);
+		uint64_t nTotalCount = readULEB128(pData, nDataSize, nPosition);
+		int64_t nFirstValue = zigzagDecode(readULEB128(pData, nDataSize, nPosition));
+
+		if ((nBlockSize == 0) || (nBlockSize > 65536) || (nMiniblockCount == 0) || (nMiniblockCount > 256) || ((nBlockSize % nMiniblockCount) != 0))
+			throw EDataTableFormatException(eDataTableFormatError::Corrupt, "delta encoded page has an invalid block layout");
+
+		uint64_t nMiniblockSize = nBlockSize / nMiniblockCount;
+		if ((nMiniblockSize % 8) != 0)
+			throw EDataTableFormatException(eDataTableFormatError::Corrupt, "delta encoded page has an invalid miniblock size");
+
+		if (nTotalCount != nValueCount)
+			throw EDataTableFormatException(eDataTableFormatError::Corrupt, "delta encoded page holds a different number of values");
+
+		if (nValueCount == 0)
+			return;
+
+		pValues[0] = nFirstValue;
+		size_t nProducedCount = 1;
+
+		while (nProducedCount < nValueCount) {
+			int64_t nMinDelta = zigzagDecode(readULEB128(pData, nDataSize, nPosition));
+
+			if (nMiniblockCount > nDataSize - nPosition)
+				throw EDataTableFormatException(eDataTableFormatError::Corrupt, "delta encoded page ends inside a block header");
+			const uint8_t* pWidths = pData + nPosition;
+			nPosition += (size_t)nMiniblockCount;
+
+			for (uint64_t nMiniblockIndex = 0; (nMiniblockIndex < nMiniblockCount) && (nProducedCount < nValueCount); nMiniblockIndex++) {
+				uint32_t nWidth = pWidths[nMiniblockIndex];
+				if (nWidth > 64)
+					throw EDataTableFormatException(eDataTableFormatError::Corrupt, "delta encoded page has an invalid bit width");
+
+				size_t nMiniblockBytes = (size_t)(nMiniblockSize * nWidth / 8);
+				if (nMiniblockBytes > nDataSize - nPosition)
+					throw EDataTableFormatException(eDataTableFormatError::Corrupt, "delta encoded page ends inside a miniblock");
+
+				CBitReader bitReader(pData + nPosition);
+				for (uint64_t nIndex = 0; (nIndex < nMiniblockSize) && (nProducedCount < nValueCount); nIndex++) {
+					uint64_t nRelativeDelta = (nWidth > 0) ? bitReader.read(nWidth) : 0;
+					pValues[nProducedCount] = (int64_t)((uint64_t)pValues[nProducedCount - 1] + (uint64_t)nMinDelta + nRelativeDelta);
+					nProducedCount++;
+				}
+
+				nPosition += nMiniblockBytes;
+			}
+		}
+	}
+
+	size_t CDataTableEncoding::getBitPackSize(size_t nValueCount)
+	{
+		return (nValueCount + 7) / 8;
+	}
+
+	void CDataTableEncoding::encodeBitPack(const uint8_t* pValues, size_t nValueCount, std::vector<uint8_t>& buffer)
+	{
+		if ((nValueCount > 0) && (pValues == nullptr))
+			throw EDataTableFormatException(eDataTableFormatError::InvalidParam, "bit packing input is null");
+
+		size_t nStart = buffer.size();
+		buffer.resize(nStart + getBitPackSize(nValueCount), 0);
+
+		for (size_t nIndex = 0; nIndex < nValueCount; nIndex++) {
+			if (pValues[nIndex] != 0)
+				buffer[nStart + (nIndex >> 3)] |= (uint8_t)(1 << (nIndex & 7));
+		}
+	}
+
+	void CDataTableEncoding::decodeBitPack(const uint8_t* pData, size_t nDataSize, uint8_t* pValues, size_t nValueCount)
+	{
+		if (nDataSize != getBitPackSize(nValueCount))
+			throw EDataTableFormatException(eDataTableFormatError::Corrupt, "bit packed page has an invalid size");
+		if (nValueCount == 0)
+			return;
+		if ((pData == nullptr) || (pValues == nullptr))
+			throw EDataTableFormatException(eDataTableFormatError::InvalidParam, "bit packing buffer is null");
+
+		for (size_t nIndex = 0; nIndex < nValueCount; nIndex++)
+			pValues[nIndex] = (pData[nIndex >> 3] >> (nIndex & 7)) & 1;
+	}
+
+	bool CDataTableEncoding::codecIsValid(uint32_t nCodec)
+	{
+		return (nCodec == DATATABLE_V2_CODEC_NONE) || (nCodec == DATATABLE_V2_CODEC_LZ4) || (nCodec == DATATABLE_V2_CODEC_DEFLATE);
+	}
+
+	bool CDataTableEncoding::compress(uint32_t nCodec, const uint8_t* pData, size_t nDataSize, std::vector<uint8_t>& buffer)
+	{
+		if (!codecIsValid(nCodec))
+			throw EDataTableFormatException(eDataTableFormatError::UnsupportedCodec, "unsupported datatable page codec: " + std::to_string(nCodec));
+
+		if ((nCodec == DATATABLE_V2_CODEC_NONE) || (nDataSize == 0) || (pData == nullptr))
+			return false;
+
+		if (nCodec == DATATABLE_V2_CODEC_LZ4) {
+			if (nDataSize > (size_t)LZ4_MAX_INPUT_SIZE)
+				return false;
+
+			int nBound = LZ4_compressBound((int)nDataSize);
+			if (nBound <= 0)
+				return false;
+
+			buffer.resize((size_t)nBound);
+			int nCompressedSize = LZ4_compress_default((const char*)pData, (char*)buffer.data(), (int)nDataSize, nBound);
+			if ((nCompressedSize <= 0) || ((size_t)nCompressedSize >= nDataSize))
+				return false;
+
+			buffer.resize((size_t)nCompressedSize);
+			return true;
+		}
+
+		// zlib deflate
+		if (nDataSize > 0x7FFFFFFFULL)
+			return false;
+
+		uLongf nCompressedSize = compressBound((uLong)nDataSize);
+		buffer.resize((size_t)nCompressedSize);
+		int nResult = compress2(buffer.data(), &nCompressedSize, pData, (uLong)nDataSize, Z_DEFAULT_COMPRESSION);
+		if ((nResult != Z_OK) || ((size_t)nCompressedSize >= nDataSize))
+			return false;
+
+		buffer.resize((size_t)nCompressedSize);
+		return true;
+	}
+
+	void CDataTableEncoding::decompress(uint32_t nCodec, const uint8_t* pData, size_t nDataSize, uint8_t* pTarget, size_t nTargetSize)
+	{
+		if ((pData == nullptr) || (pTarget == nullptr))
+			throw EDataTableFormatException(eDataTableFormatError::InvalidParam, "decompression buffer is null");
+
+		switch (nCodec) {
+		case DATATABLE_V2_CODEC_NONE:
+			if (nDataSize != nTargetSize)
+				throw EDataTableFormatException(eDataTableFormatError::Corrupt, "uncompressed page has an invalid size");
+			memcpy(pTarget, pData, nDataSize);
+			break;
+
+		case DATATABLE_V2_CODEC_LZ4: {
+			if ((nDataSize > 0x7FFFFFFFULL) || (nTargetSize > 0x7FFFFFFFULL))
+				throw EDataTableFormatException(eDataTableFormatError::Corrupt, "LZ4 page is too large");
+
+			int nDecompressedSize = LZ4_decompress_safe((const char*)pData, (char*)pTarget, (int)nDataSize, (int)nTargetSize);
+			if ((nDecompressedSize < 0) || ((size_t)nDecompressedSize != nTargetSize))
+				throw EDataTableFormatException(eDataTableFormatError::Corrupt, "LZ4 page could not be decompressed");
+			break;
+		}
+
+		case DATATABLE_V2_CODEC_DEFLATE: {
+			if ((nDataSize > 0x7FFFFFFFULL) || (nTargetSize > 0x7FFFFFFFULL))
+				throw EDataTableFormatException(eDataTableFormatError::Corrupt, "deflate page is too large");
+
+			uLongf nDecompressedSize = (uLongf)nTargetSize;
+			int nResult = uncompress(pTarget, &nDecompressedSize, pData, (uLong)nDataSize);
+			if ((nResult != Z_OK) || ((size_t)nDecompressedSize != nTargetSize))
+				throw EDataTableFormatException(eDataTableFormatError::Corrupt, "deflate page could not be decompressed");
+			break;
+		}
+
+		default:
+			throw EDataTableFormatException(eDataTableFormatError::UnsupportedCodec, "unsupported datatable page codec: " + std::to_string(nCodec));
+		}
+	}
+
+}
diff --git a/Implementation/Core/amc_datatableencoding.hpp b/Implementation/Core/amc_datatableencoding.hpp
new file mode 100644
index 000000000..d06aef14d
--- /dev/null
+++ b/Implementation/Core/amc_datatableencoding.hpp
@@ -0,0 +1,93 @@
+/*++
+
+Copyright (C) 2020 Autodesk Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+	* Redistributions of source code must retain the above copyright
+	  notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+	  notice, this list of conditions and the following disclaimer in the
+	  documentation and/or other materials provided with the distribution.
+	* Neither the name of the Autodesk Inc. nor the
+	  names of its contributors may be used to endorse or promote products
+	  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL AUTODESK INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+
+#ifndef __AMC_DATATABLEENCODING
+#define __AMC_DATATABLEENCODING
+
+#include <cstdint>
+#include <cstddef>
+#include <vector>
+
+/*************************************************************************************************************************
+
+ Page encodings and codecs of the chunked data table format (see amc_datatableformat.hpp).
+
+ The encodings are restricted to ones that Parquet also has, so that a future Parquet writer is a
+ serialisation pass without transcoding:
+
+   PLAIN     raw little-endian value array
+   DELTA     Parquet DELTA_BINARY_PACKED over 64 bit integers: blocks of 128 deltas in 4 miniblocks,
+             each miniblock bit-packed with its own bit width after subtracting the minimum delta of the block
+   BITPACK   one bit per value, least significant bit first. This is how Parquet stores PLAIN booleans.
+
+ Codecs compress an encoded page as a whole: LZ4 block format (Parquet LZ4_RAW) and zlib deflate.
+
+**************************************************************************************************************************/
+
+#define DATATABLE_DELTA_BLOCKSIZE 128
+#define DATATABLE_DELTA_MINIBLOCKCOUNT 4
+#define DATATABLE_DELTA_MINIBLOCKSIZE (DATATABLE_DELTA_BLOCKSIZE / DATATABLE_DELTA_MINIBLOCKCOUNT)
+
+namespace AMC {
+
+	class CDataTableEncoding {
+	public:
+
+		// Appends the DELTA_BINARY_PACKED encoding of the values to the buffer.
+		static void encodeDelta(const int64_t* pValues, size_t nValueCount, std::vector<uint8_t>& buffer);
+
+		// Decodes exactly nValueCount values. Fails with an EDataTableFormatException if the data is
+		// corrupt, ends early or holds a different number of values.
+		static void decodeDelta(const uint8_t* pData, size_t nDataSize, int64_t* pValues, size_t nValueCount);
+
+		// Appends one bit per value to the buffer. Any nonzero value is a set bit.
+		static void encodeBitPack(const uint8_t* pValues, size_t nValueCount, std::vector<uint8_t>& buffer);
+
+		// Decodes nValueCount bits into bytes that are 0 or 1.
+		static void decodeBitPack(const uint8_t* pData, size_t nDataSize, uint8_t* pValues, size_t nValueCount);
+
+		static size_t getBitPackSize(size_t nValueCount);
+
+		static bool codecIsValid(uint32_t nCodec);
+
+		// Compresses the data into the buffer, which is replaced. Returns false and leaves the buffer
+		// undefined if the codec is NONE or the compressed data is not smaller than the input.
+		static bool compress(uint32_t nCodec, const uint8_t* pData, size_t nDataSize, std::vector<uint8_t>& buffer);
+
+		// Decompresses into pTarget. The decompressed size MUST be exactly nTargetSize.
+		static void decompress(uint32_t nCodec, const uint8_t* pData, size_t nDataSize, uint8_t* pTarget, size_t nTargetSize);
+
+	};
+
+}
+
+
+#endif //__AMC_DATATABLEENCODING
diff --git a/Implementation/Core/amc_datatableformat.cpp b/Implementation/Core/amc_datatableformat.cpp
new file mode 100644
index 000000000..40136b3ec
--- /dev/null
+++ b/Implementation/Core/amc_datatableformat.cpp
@@ -0,0 +1,904 @@
+/*++
+
+Copyright (C) 2020 Autodesk Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+	* Redistributions of source code must retain the above copyright
+	  notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+	  notice, this list of conditions and the following disclaimer in the
+	  documentation and/or other materials provided with the distribution.
+	* Neither the name of the Autodesk Inc. nor the
+	  names of its contributors may be used to endorse or promote products
+	  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL AUTODESK INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#include "amc_datatableformat.hpp"
+#include "amc_datatableencoding.hpp"
+#include "amc_constants.hpp"
+
+#include <cmath>
+#include <cstring>
+
+namespace AMC {
+
+	namespace {
+
+		template <typename T>
+		void appendStruct(std::vector<uint8_t>& buffer, const T& value)
+		{
+			const uint8_t* pData = (const uint8_t*)&value;
+			buffer.insert(buffer.end(), pData, pData + sizeof(T));
+		}
+
+		void appendBytes(std::vector<uint8_t>& buffer, const uint8_t* pData, size_t nSize)
+		{
+			if (nSize > 0)
+				buffer.insert(buffer.end(), pData, pData + nSize);
+		}
+
+		template <typename T>
+		T loadValue(const uint8_t* pData, size_t nIndex)
+		{
+			T value;
+			memcpy(&value, pData + nIndex * sizeof(T), sizeof(T));
+			return value;
+		}
+
+		template <typename T>
+		bool computeFloatingPointStatistics(const uint8_t* pData, uint32_t nRowCount, uint64_t& nMinValue, uint64_t& nMaxValue)
+		{
+			bool bValid = false;
+			double dMin = 0.0;
+			double dMax = 0.0;
+
+			for (uint32_t nIndex = 0; nIndex < nRowCount; nIndex++) {
+				double dValue = (double)loadValue<T>(pData, nIndex);
+				if (std::isnan(dValue))
+					continue;
+
+				if (!bValid) {
+					dMin = dValue;
+					dMax = dValue;
+					bValid = true;
+				}
+				else {
+					if (dValue < dMin)
+						dMin = dValue;
+					if (dValue > dMax)
+						dMax = dValue;
+				}
+			}
+
+			if (bValid) {
+				memcpy(&nMinValue, &dMin, sizeof(double));
+				memcpy(&nMaxValue, &dMax, sizeof(double));
+			}
+
+			return bValid;
+		}
+
+		template <typename T>
+		bool computeSignedStatistics(const uint8_t* pData, uint32_t nRowCount, uint64_t& nMinValue, uint64_t& nMaxValue)
+		{
+			if (nRowCount == 0)
+				return false;
+
+			int64_t nMin = (int64_t)loadValue<T>(pData, 0);
+			int64_t nMax = nMin;
+			for (uint32_t nIndex = 1; nIndex < nRowCount; nIndex++) {
+				int64_t nValue = (int64_t)loadValue<T>(pData, nIndex);
+				if (nValue < nMin)
+					nMin = nValue;
+				if (nValue > nMax)
+					nMax = nValue;
+			}
+
+			nMinValue = (uint64_t)nMin;
+			nMaxValue = (uint64_t)nMax;
+			return true;
+		}
+
+		template <typename T>
+		bool computeUnsignedStatistics(const uint8_t* pData, uint32_t nRowCount, uint64_t& nMinValue, uint64_t& nMaxValue)
+		{
+			if (nRowCount == 0)
+				return false;
+
+			uint64_t nMin = (uint64_t)loadValue<T>(pData, 0);
+			uint64_t nMax = nMin;
+			for (uint32_t nIndex = 1; nIndex < nRowCount; nIndex++) {
+				uint64_t nValue = (uint64_t)loadValue<T>(pData, nIndex);
+				if (nValue < nMin)
+					nMin = nValue;
+				if (nValue > nMax)
+					nMax = nValue;
+			}
+
+			nMinValue = nMin;
+			nMaxValue = nMax;
+			return true;
+		}
+
+	}
+
+
+	EDataTableFormatException::EDataTableFormatException(eDataTableFormatError error, const std::string& sMessage)
+		: std::runtime_error(sMessage), m_Error(error)
+	{
+	}
+
+	eDataTableFormatError EDataTableFormatException::getError() const
+	{
+		return m_Error;
+	}
+
+
+	uint32_t CDataTableV2::getEntrySize(eDataTableV2DataType dataType)
+	{
+		switch (dataType) {
+		case eDataTableV2DataType::Double: return 8;
+		case eDataTableV2DataType::Int32: return 4;
+		case eDataTableV2DataType::Uint32: return 4;
+		case eDataTableV2DataType::Int64: return 8;
+		case eDataTableV2DataType::Uint64: return 8;
+		case eDataTableV2DataType::Float: return 4;
+		case eDataTableV2DataType::Bool: return 1;
+		case eDataTableV2DataType::Timestamp: return 8;
+		default:
+			throw EDataTableFormatException(eDataTableFormatError::InvalidDataType, "invalid datatable column data type: " + std::to_string((uint32_t)dataType));
+		}
+	}
+
+	bool CDataTableV2::dataTypeIsValid(uint32_t nDataType)
+	{
+		return (nDataType >= (uint32_t)eDataTableV2DataType::Double) && (nDataType <= (uint32_t)eDataTableV2DataType::Timestamp);
+	}
+
+	bool CDataTableV2::computeStatistics(eDataTableV2DataType dataType, const uint8_t* pData, uint32_t nRowCount, uint64_t& nMinValue, uint64_t& nMaxValue)
+	{
+		nMinValue = 0;
+		nMaxValue = 0;
+
+		if ((pData == nullptr) || (nRowCount == 0))
+			return false;
+
+		switch (dataType) {
+		case eDataTableV2DataType::Double: return computeFloatingPointStatistics<double>(pData, nRowCount, nMinValue, nMaxValue);
+		case eDataTableV2DataType::Float: return computeFloatingPointStatistics<float>(pData, nRowCount, nMinValue, nMaxValue);
+		case eDataTableV2DataType::Int32: return computeSignedStatistics<int32_t>(pData, nRowCount, nMinValue, nMaxValue);
+		case eDataTableV2DataType::Int64: return computeSignedStatistics<int64_t>(pData, nRowCount, nMinValue, nMaxValue);
+		case eDataTableV2DataType::Uint32: return computeUnsignedStatistics<uint32_t>(pData, nRowCount, nMinValue, nMaxValue);
+		case eDataTableV2DataType::Uint64: return computeUnsignedStatistics<uint64_t>(pData, nRowCount, nMinValue, nMaxValue);
+		case eDataTableV2DataType::Timestamp: return computeUnsignedStatistics<uint64_t>(pData, nRowCount, nMinValue, nMaxValue);
+		case eDataTableV2DataType::Bool: return computeUnsignedStatistics<uint8_t>(pData, nRowCount, nMinValue, nMaxValue);
+		default:
+			throw EDataTableFormatException(eDataTableFormatError::InvalidDataType, "invalid datatable column data type: " + std::to_string((uint32_t)dataType));
+		}
+	}
+
+	double CDataTableV2::statisticsValueToDouble(eDataTableV2DataType dataType, uint64_t nValue)
+	{
+		switch (dataType) {
+		case eDataTableV2DataType::Double:
+		case eDataTableV2DataType::Float: {
+			double dValue = 0.0;
+			memcpy(&dValue, &nValue, sizeof(dValue));
+			return dValue;
+		}
+		case eDataTableV2DataType::Int32:
+		case eDataTableV2DataType::Int64:
+			return (double)(int64_t)nValue;
+		default:
+			return (double)nValue;
+		}
+	}
+
+	uint32_t CDataTableV2::getDefaultEncoding(eDataTableV2DataType dataType)
+	{
+		switch (dataType) {
+		case eDataTableV2DataType::Int32:
+		case eDataTableV2DataType::Uint32:
+		case eDataTableV2DataType::Int64:
+		case eDataTableV2DataType::Uint64:
+		case eDataTableV2DataType::Timestamp:
+			return DATATABLE_V2_ENCODING_DELTA;
+		case eDataTableV2DataType::Bool:
+			return DATATABLE_V2_ENCODING_BITPACK;
+		default:
+			return DATATABLE_V2_ENCODING_PLAIN;
+		}
+	}
+
+	bool CDataTableV2::encodingIsValidForColumn(eDataTableV2DataType dataType, uint32_t nEncoding, double dQuantizationStep)
+	{
+		switch (nEncoding) {
+		case DATATABLE_V2_ENCODING_PLAIN:
+			return true;
+
+		case DATATABLE_V2_ENCODING_DELTA:
+			switch (dataType) {
+			case eDataTableV2DataType::Int32:
+			case eDataTableV2DataType::Uint32:
+			case eDataTableV2DataType::Int64:
+			case eDataTableV2DataType::Uint64:
+			case eDataTableV2DataType::Timestamp:
+				return true;
+			case eDataTableV2DataType::Double:
+				return (dQuantizationStep > 0.0);
+			default:
+				return false;
+			}
+
+		case DATATABLE_V2_ENCODING_BITPACK:
+			return (dataType == eDataTableV2DataType::Bool);
+
+		default:
+			return false;
+		}
+	}
+
+
+	/*************************************************************************************************************************
+	 CDataTableV2ChunkEncoder
+	**************************************************************************************************************************/
+
+	CDataTableV2ChunkEncoder::CDataTableV2ChunkEncoder(const std::vector<sDataTableV2Column>& columns, uint32_t nCodec)
+		: m_Columns(columns), m_nCodec(nCodec)
+	{
+		if (!CDataTableEncoding::codecIsValid(nCodec))
+			throw EDataTableFormatException(eDataTableFormatError::UnsupportedCodec, "unsupported datatable page codec: " + std::to_string(nCodec));
+
+		for (auto& column : m_Columns) {
+			m_EntrySizes.push_back(CDataTableV2::getEntrySize(column.m_DataType));
+
+			if (!(column.m_dQuantizationStep >= 0.0) || !std::isfinite(column.m_dQuantizationStep))
+				throw EDataTableFormatException(eDataTableFormatError::InvalidParam, "invalid quantisation step of datatable column " + column.m_sIdentifier);
+			if (!CDataTableV2::encodingIsValidForColumn(column.m_DataType, column.m_nEncoding, column.m_dQuantizationStep))
+				throw EDataTableFormatException(eDataTableFormatError::UnsupportedEncoding, "encoding " + std::to_string(column.m_nEncoding) + " is not valid for datatable column " + column.m_sIdentifier);
+		}
+	}
+
+	// Converts doubles to integer multiples of the step. Returns false if a value can not be represented,
+	// in which case the page is stored as plain doubles. m_DoubleScratch receives the values as they will be read back.
+	bool CDataTableV2ChunkEncoder::quantize(const uint8_t* pData, uint32_t nRowCount, double dStep)
+	{
+		m_IntegerScratch.resize(nRowCount);
+		m_DoubleScratch.resize(nRowCount);
+
+		for (uint32_t nIndex = 0; nIndex < nRowCount; nIndex++) {
+			double dValue = loadValue<double>(pData, nIndex);
+			if (!std::isfinite(dValue))
+				return false;
+
+			double dScaled = dValue / dStep;
+			if (!(std::fabs(dScaled) < 4.0e18))
+				return false;
+
+			int64_t nQuantized = std::llround(dScaled);
+			m_IntegerScratch[nIndex] = nQuantized;
+			m_DoubleScratch[nIndex] = (double)nQuantized * dStep;
+		}
+
+		return true;
+	}
+
+	void CDataTableV2ChunkEncoder::widenIntegers(eDataTableV2DataType dataType, const uint8_t* pData, uint32_t nRowCount)
+	{
+		m_IntegerScratch.resize(nRowCount);
+
+		switch (dataType) {
+		case eDataTableV2DataType::Int32:
+			for (uint32_t nIndex = 0; nIndex < nRowCount; nIndex++)
+				m_IntegerScratch[nIndex] = (int64_t)loadValue<int32_t>(pData, nIndex);
+			break;
+		case eDataTableV2DataType::Uint32:
+			for (uint32_t nIndex = 0; nIndex < nRowCount; nIndex++)
+				m_IntegerScratch[nIndex] = (int64_t)loadValue<uint32_t>(pData, nIndex);
+			break;
+		default:
+			// 64 bit integers and timestamps are delta encoded on their bit pattern.
+			memcpy(m_IntegerScratch.data(), pData, (size_t)nRowCount * sizeof(int64_t));
+			break;
+		}
+	}
+
+	void CDataTableV2ChunkEncoder::encodeChunk(const std::vector<const uint8_t*>& columnData, uint32_t nRowCount, sDataTableV2EncodedChunk& chunk)
+	{
+		if (m_Columns.empty())
+			throw EDataTableFormatException(eDataTableFormatError::InvalidParam, "datatable segment without columns can not hold chunks");
+		if (columnData.size() != m_Columns.size())
+			throw EDataTableFormatException(eDataTableFormatError::InvalidParam, "datatable chunk column count mismatch");
+		if (nRowCount == 0)
+			throw EDataTableFormatException(eDataTableFormatError::InvalidParam, "datatable chunk is empty");
+
+		chunk.m_nRowCount = nRowCount;
+		chunk.m_Bytes.clear();
+		chunk.m_Entries.clear();
+
+		for (size_t nColumnIndex = 0; nColumnIndex < m_Columns.size(); nColumnIndex++) {
+			auto& column = m_Columns[nColumnIndex];
+
+			const uint8_t* pPlainData = columnData[nColumnIndex];
+			if (pPlainData == nullptr)
+				throw EDataTableFormatException(eDataTableFormatError::InvalidParam, "datatable chunk column data is null");
+
+			uint64_t nPlainSize = (uint64_t)nRowCount * m_EntrySizes[nColumnIndex];
+			if (nPlainSize > UINT32_MAX)
+				throw EDataTableFormatException(eDataTableFormatError::InvalidParam, "datatable page is too large");
+
+			// Encode. A page stays plain if its encoding does not make it smaller.
+			const uint8_t* pPayload = pPlainData;
+			size_t nPayloadSize = (size_t)nPlainSize;
+			uint32_t nEncoding = DATATABLE_V2_ENCODING_PLAIN;
+			const uint8_t* pStatisticsData = pPlainData;
+
+			if (column.m_nEncoding == DATATABLE_V2_ENCODING_DELTA) {
+				bool bQuantized = (column.m_DataType == eDataTableV2DataType::Double);
+				bool bEncodable = true;
+
+				if (bQuantized)
+					bEncodable = quantize(pPlainData, nRowCount, column.m_dQuantizationStep);
+				else
+					widenIntegers(column.m_DataType, pPlainData, nRowCount);
+
+				if (bEncodable) {
+					m_EncodedScratch.clear();
+					CDataTableEncoding::encodeDelta(m_IntegerScratch.data(), nRowCount, m_EncodedScratch);
+
+					if (m_EncodedScratch.size() < nPlainSize) {
+						pPayload = m_EncodedScratch.data();
+						nPayloadSize = m_EncodedScratch.size();
+						nEncoding = DATATABLE_V2_ENCODING_DELTA;
+
+						// The statistics describe the values as they are read back.
+						if (bQuantized)
+							pStatisticsData = (const uint8_t*)m_DoubleScratch.data();
+					}
+				}
+			}
+			else if (column.m_nEncoding == DATATABLE_V2_ENCODING_BITPACK) {
+				m_EncodedScratch.clear();
+				CDataTableEncoding::encodeBitPack(pPlainData, nRowCount, m_EncodedScratch);
+
+				if (m_EncodedScratch.size() < nPlainSize) {
+					pPayload = m_EncodedScratch.data();
+					nPayloadSize = m_EncodedScratch.size();
+					nEncoding = DATATABLE_V2_ENCODING_BITPACK;
+				}
+			}
+
+			// Compress. A page stays uncompressed if the codec does not make it smaller.
+			const uint8_t* pStoredData = pPayload;
+			size_t nStoredSize = nPayloadSize;
+			uint32_t nCodec = DATATABLE_V2_CODEC_NONE;
+
+			if (CDataTableEncoding::compress(m_nCodec, pPayload, nPayloadSize, m_CompressedScratch)) {
+				pStoredData = m_CompressedScratch.data();
+				nStoredSize = m_CompressedScratch.size();
+				nCodec = m_nCodec;
+			}
+
+			sDataTableV2PageHeader pageHeader;
+			memset(&pageHeader, 0, sizeof(pageHeader));
+			pageHeader.m_nMagic = DATATABLE_V2_PAGEMAGIC;
+			pageHeader.m_nColumnIndex = (uint32_t)nColumnIndex;
+			pageHeader.m_nRowCount = nRowCount;
+			pageHeader.m_nDataType = (uint32_t)column.m_DataType;
+			pageHeader.m_nCodec = nCodec;
+			pageHeader.m_nEncoding = nEncoding;
+			pageHeader.m_nCompressedSize = (uint32_t)nStoredSize;
+			pageHeader.m_nUncompressedSize = (uint32_t)nPayloadSize;
+			appendStruct(chunk.m_Bytes, pageHeader);
+
+			sDataTableV2PageEntry entry;
+			memset(&entry, 0, sizeof(entry));
+			entry.m_nFileOffset = chunk.m_Bytes.size();
+			entry.m_nCompressedSize = (uint32_t)nStoredSize;
+			entry.m_nUncompressedSize = (uint32_t)nPayloadSize;
+			entry.m_nRowCount = nRowCount;
+			entry.m_nCodec = nCodec;
+			entry.m_nEncoding = nEncoding;
+			if (CDataTableV2::computeStatistics(column.m_DataType, pStatisticsData, nRowCount, entry.m_nMinValue, entry.m_nMaxValue))
+				entry.m_nFlags |= DATATABLE_V2_PAGEFLAG_STATISTICSVALID;
+
+			appendBytes(chunk.m_Bytes, pStoredData, nStoredSize);
+			chunk.m_Entries.push_back(entry);
+		}
+	}
+
+
+	/*************************************************************************************************************************
+	 CDataTableV2SegmentBuilder
+	**************************************************************************************************************************/
+
+	CDataTableV2SegmentBuilder::CDataTableV2SegmentBuilder(const std::vector<sDataTableV2Column>& columns, uint32_t nSegmentIndex, uint64_t nFirstRowIndex, uint32_t nChunkRowCapacity)
+		: m_Columns(columns),
+		m_nSegmentIndex(nSegmentIndex),
+		m_nFirstRowIndex(nFirstRowIndex),
+		m_nChunkRowCapacity(nChunkRowCapacity),
+		m_nCurrentSize(0),
+		m_nRowCount(0),
+		m_nChunkCount(0),
+		m_bHeaderWritten(false),
+		m_bFooterWritten(false),
+		m_UncompressedEncoder(columns, DATATABLE_V2_CODEC_NONE)
+	{
+		if (m_Columns.size() >= DATATABLE_MAXCOLUMNCOUNT)
+			throw EDataTableFormatException(eDataTableFormatError::InvalidParam, "datatable segment has too many columns");
+
+		for (auto& column : m_Columns) {
+			if ((column.m_sIdentifier.length() > DATATABLE_V2_MAXSTRINGLENGTH) || (column.m_sDescription.length() > DATATABLE_V2_MAXSTRINGLENGTH))
+				throw EDataTableFormatException(eDataTableFormatError::InvalidParam, "datatable column identifier or description is too long");
+
+			m_EntrySizes.push_back(CDataTableV2::getEntrySize(column.m_DataType));
+		}
+	}
+
+	void CDataTableV2SegmentBuilder::appendHeader(std::vector<uint8_t>& buffer)
+	{
+		if (m_bHeaderWritten)
+			throw EDataTableFormatException(eDataTableFormatError::InvalidParam, "datatable segment header has been written already");
+
+		sDataTableV2SegmentHeader header;
+		memset(&header, 0, sizeof(header));
+		header.m_nSignature = DATATABLE_HEADERSIGNATURE_V2;
+		header.m_nVersion = DATATABLE_FORMATVERSION_2;
+		header.m_nHeaderSize = sizeof(header);
+		header.m_nSegmentIndex = m_nSegmentIndex;
+		header.m_nColumnCount = (uint32_t)m_Columns.size();
+		header.m_nFirstRowIndex = m_nFirstRowIndex;
+		header.m_nChunkRowCapacity = m_nChunkRowCapacity;
+
+		appendStruct(buffer, header);
+
+		m_nCurrentSize += sizeof(header);
+		m_bHeaderWritten = true;
+	}
+
+	void CDataTableV2SegmentBuilder::appendChunk(const std::vector<const uint8_t*>& columnData, uint32_t nRowCount, std::vector<uint8_t>& buffer)
+	{
+		if (!m_bHeaderWritten || m_bFooterWritten)
+			throw EDataTableFormatException(eDataTableFormatError::InvalidParam, "datatable segment is not open for chunks");
+
+		m_UncompressedEncoder.encodeChunk(columnData, nRowCount, m_UncompressedChunk);
+		appendEncodedChunk(m_UncompressedChunk, buffer);
+	}
+
+	void CDataTableV2SegmentBuilder::appendEncodedChunk(const sDataTableV2EncodedChunk& chunk, std::vector<uint8_t>& buffer)
+	{
+		if (!m_bHeaderWritten || m_bFooterWritten)
+			throw EDataTableFormatException(eDataTableFormatError::InvalidParam, "datatable segment is not open for chunks");
+		if (chunk.m_Entries.size() != m_Columns.size())
+			throw EDataTableFormatException(eDataTableFormatError::InvalidParam, "datatable chunk column count mismatch");
+		if (m_Columns.empty() || (chunk.m_nRowCount == 0))
+			throw EDataTableFormatException(eDataTableFormatError::InvalidParam, "datatable chunk is empty");
+		if (m_nChunkCount >= DATATABLE_V2_MAXCHUNKCOUNT)
+			throw EDataTableFormatException(eDataTableFormatError::InvalidParam, "datatable segment has too many chunks");
+
+		// The page offsets of the chunk become absolute offsets of the segment.
+		for (auto entry : chunk.m_Entries) {
+			entry.m_nFileOffset += m_nCurrentSize;
+			m_Directory.push_back(entry);
+		}
+
+		appendBytes(buffer, chunk.m_Bytes.data(), chunk.m_Bytes.size());
+		m_nCurrentSize += chunk.m_Bytes.size();
+
+		m_nRowCount += chunk.m_nRowCount;
+		m_nChunkCount++;
+	}
+
+	uint64_t CDataTableV2SegmentBuilder::getSchemaSizeInBytes() const
+	{
+		uint64_t nSchemaSize = 0;
+		for (auto& column : m_Columns)
+			nSchemaSize += sizeof(sDataTableV2SchemaEntry) + column.m_sIdentifier.length() + column.m_sDescription.length();
+
+		return nSchemaSize;
+	}
+
+	void CDataTableV2SegmentBuilder::appendFooter(std::vector<uint8_t>& buffer)
+	{
+		if (!m_bHeaderWritten || m_bFooterWritten)
+			throw EDataTableFormatException(eDataTableFormatError::InvalidParam, "datatable segment footer can not be written");
+
+		size_t nFooterBegin = buffer.size();
+
+		sDataTableV2FooterHeader footerHeader;
+		memset(&footerHeader, 0, sizeof(footerHeader));
+		footerHeader.m_nMagic = DATATABLE_V2_FOOTERMAGIC;
+		footerHeader.m_nColumnCount = (uint32_t)m_Columns.size();
+		footerHeader.m_nChunkCount = m_nChunkCount;
+		footerHeader.m_nSchemaSize = (uint32_t)getSchemaSizeInBytes();
+		footerHeader.m_nRowCount = m_nRowCount;
+		footerHeader.m_nFirstRowIndex = m_nFirstRowIndex;
+		appendStruct(buffer, footerHeader);
+
+		for (auto& column : m_Columns) {
+			sDataTableV2SchemaEntry schemaEntry;
+			memset(&schemaEntry, 0, sizeof(schemaEntry));
+			schemaEntry.m_nDataType = (uint32_t)column.m_DataType;
+			schemaEntry.m_nDefaultEncoding = column.m_nEncoding;
+			schemaEntry.m_nIdentifierLength = (uint32_t)column.m_sIdentifier.length();
+			schemaEntry.m_nDescriptionLength = (uint32_t)column.m_sDescription.length();
+			schemaEntry.m_dQuantizationScale = column.m_dQuantizationStep;
+			appendStruct(buffer, schemaEntry);
+			appendBytes(buffer, (const uint8_t*)column.m_sIdentifier.data(), column.m_sIdentifier.length());
+			appendBytes(buffer, (const uint8_t*)column.m_sDescription.data(), column.m_sDescription.length());
+		}
+
+		for (auto& entry : m_Directory)
+			appendStruct(buffer, entry);
+
+		sDataTableV2Trailer trailer;
+		memset(&trailer, 0, sizeof(trailer));
+		trailer.m_nFooterLength = buffer.size() - nFooterBegin;
+		trailer.m_nMagic = DATATABLE_V2_TRAILERMAGIC;
+		appendStruct(buffer, trailer);
+
+		m_nCurrentSize += buffer.size() - nFooterBegin;
+		m_bFooterWritten = true;
+	}
+
+	uint64_t CDataTableV2SegmentBuilder::getChunkSizeInBytes(uint32_t nRowCount) const
+	{
+		uint64_t nChunkSize = 0;
+		for (auto nEntrySize : m_EntrySizes)
+			nChunkSize += sizeof(sDataTableV2PageHeader) + (uint64_t)nRowCount * nEntrySize;
+
+		return nChunkSize;
+	}
+
+	uint64_t CDataTableV2SegmentBuilder::getFooterSizeInBytes(uint32_t nChunkCount) const
+	{
+		return sizeof(sDataTableV2FooterHeader) + getSchemaSizeInBytes() + (uint64_t)nChunkCount * m_Columns.size() * sizeof(sDataTableV2PageEntry) + sizeof(sDataTableV2Trailer);
+	}
+
+	uint64_t CDataTableV2SegmentBuilder::getCurrentSize() const
+	{
+		return m_nCurrentSize;
+	}
+
+	uint64_t CDataTableV2SegmentBuilder::getRowCount() const
+	{
+		return m_nRowCount;
+	}
+
+	uint32_t CDataTableV2SegmentBuilder::getChunkCount() const
+	{
+		return m_nChunkCount;
+	}
+
+	uint32_t CDataTableV2SegmentBuilder::getSegmentIndex() const
+	{
+		return m_nSegmentIndex;
+	}
+
+	uint64_t CDataTableV2SegmentBuilder::getFirstRowIndex() const
+	{
+		return m_nFirstRowIndex;
+	}
+
+
+	/*************************************************************************************************************************
+	 CDataTableV2SegmentReader
+	**************************************************************************************************************************/
+
+	CDataTableV2SegmentReader::CDataTableV2SegmentReader(ReadCallback readCallback, uint64_t nStreamSize)
+		: m_ReadCallback(readCallback), m_nStreamSize(nStreamSize), m_nFooterStart(0), m_nPageReadCount(0)
+	{
+		if (!m_ReadCallback)
+			throw EDataTableFormatException(eDataTableFormatError::InvalidParam, "datatable segment read callback is empty");
+
+		memset(&m_Header, 0, sizeof(m_Header));
+		memset(&m_FooterHeader, 0, sizeof(m_FooterHeader));
+
+		// The first two header fields have the same position in all format versions.
+		if (m_nStreamSize < 2 * sizeof(uint32_t))
+			throw EDataTableFormatException(eDataTableFormatError::Truncated, "datatable stream is smaller than its signature");
+
+		m_ReadCallback(0, 2 * sizeof(uint32_t), (uint8_t*)&m_Header);
+		if (m_Header.m_nSignature != DATATABLE_HEADERSIGNATURE_V2)
+			throw EDataTableFormatException(eDataTableFormatError::InvalidSignature, "invalid datatable segment signature");
+		if (m_Header.m_nVersion != DATATABLE_FORMATVERSION_2)
+			throw EDataTableFormatException(eDataTableFormatError::UnsupportedVersion, "unsupported datatable format version: " + std::to_string(m_Header.m_nVersion));
+
+		if (m_nStreamSize < sizeof(m_Header))
+			throw EDataTableFormatException(eDataTableFormatError::Truncated, "datatable segment is smaller than its header");
+
+		m_ReadCallback(0, sizeof(m_Header), (uint8_t*)&m_Header);
+		if (m_Header.m_nHeaderSize != sizeof(m_Header))
+			throw EDataTableFormatException(eDataTableFormatError::Corrupt, "invalid datatable segment header size");
+		if (m_Header.m_nColumnCount >= DATATABLE_MAXCOLUMNCOUNT)
+			throw EDataTableFormatException(eDataTableFormatError::Corrupt, "datatable segment has too many columns");
+
+		// A segment that was interrupted before its footer was written has no trailer.
+		if (m_nStreamSize < sizeof(m_Header) + sizeof(sDataTableV2FooterHeader) + sizeof(sDataTableV2Trailer))
+			throw EDataTableFormatException(eDataTableFormatError::Truncated, "datatable segment has no footer");
+
+		sDataTableV2Trailer trailer;
+		m_ReadCallback(m_nStreamSize - sizeof(trailer), sizeof(trailer), (uint8_t*)&trailer);
+		if (trailer.m_nMagic != DATATABLE_V2_TRAILERMAGIC)
+			throw EDataTableFormatException(eDataTableFormatError::Truncated, "datatable segment has no footer");
+
+		uint64_t nMaxFooterLength = m_nStreamSize - sizeof(m_Header) - sizeof(trailer);
+		if ((trailer.m_nFooterLength < sizeof(sDataTableV2FooterHeader)) || (trailer.m_nFooterLength > nMaxFooterLength))
+			throw EDataTableFormatException(eDataTableFormatError::Corrupt, "invalid datatable segment footer length");
+
+		m_nFooterStart = m_nStreamSize - sizeof(trailer) - trailer.m_nFooterLength;
+
+		std::vector<uint8_t> footer((size_t)trailer.m_nFooterLength);
+		m_ReadCallback(m_nFooterStart, trailer.m_nFooterLength, footer.data());
+
+		parseFooter(footer);
+		validateDirectory();
+	}
+
+	void CDataTableV2SegmentReader::parseFooter(const std::vector<uint8_t>& footer)
+	{
+		memcpy(&m_FooterHeader, footer.data(), sizeof(m_FooterHeader));
+		if (m_FooterHeader.m_nMagic != DATATABLE_V2_FOOTERMAGIC)
+			throw EDataTableFormatException(eDataTableFormatError::Corrupt, "invalid datatable segment footer magic");
+		if (m_FooterHeader.m_nColumnCount != m_Header.m_nColumnCount)
+			throw EDataTableFormatException(eDataTableFormatError::Corrupt, "datatable segment column count mismatch");
+		if (m_FooterHeader.m_nFirstRowIndex != m_Header.m_nFirstRowIndex)
+			throw EDataTableFormatException(eDataTableFormatError::Corrupt, "datatable segment first row mismatch");
+		if (m_FooterHeader.m_nChunkCount > DATATABLE_V2_MAXCHUNKCOUNT)
+			throw EDataTableFormatException(eDataTableFormatError::Corrupt, "datatable segment has too many chunks");
+
+		uint64_t nColumnCount = m_FooterHeader.m_nColumnCount;
+		uint64_t nDirectorySize = (uint64_t)m_FooterHeader.m_nChunkCount * nColumnCount * sizeof(sDataTableV2PageEntry);
+		uint64_t nExpectedSize = sizeof(m_FooterHeader) + (uint64_t)m_FooterHeader.m_nSchemaSize + nDirectorySize;
+		if (nExpectedSize != footer.size())
+			throw EDataTableFormatException(eDataTableFormatError::Corrupt, "datatable segment footer size mismatch");
+
+		// Column schema
+		size_t nPosition = sizeof(m_FooterHeader);
+		size_t nSchemaEnd = nPosition + m_FooterHeader.m_nSchemaSize;
+
+		for (uint64_t nColumnIndex = 0; nColumnIndex < nColumnCount; nColumnIndex++) {
+			if (nPosition + sizeof(sDataTableV2SchemaEntry) > nSchemaEnd)
+				throw EDataTableFormatException(eDataTableFormatError::Corrupt, "datatable segment schema exceeds the footer");
+
+			sDataTableV2SchemaEntry schemaEntry;
+			memcpy(&schemaEntry, footer.data() + nPosition, sizeof(schemaEntry));
+			nPosition += sizeof(schemaEntry);
+
+			if (!CDataTableV2::dataTypeIsValid(schemaEntry.m_nDataType))
+				throw EDataTableFormatException(eDataTableFormatError::InvalidDataType, "invalid datatable column data type: " + std::to_string(schemaEntry.m_nDataType));
+			if ((schemaEntry.m_nIdentifierLength > DATATABLE_V2_MAXSTRINGLENGTH) || (schemaEntry.m_nDescriptionLength > DATATABLE_V2_MAXSTRINGLENGTH))
+				throw EDataTableFormatException(eDataTableFormatError::Corrupt, "datatable column identifier or description is too long");
+			if (nPosition + schemaEntry.m_nIdentifierLength + schemaEntry.m_nDescriptionLength > nSchemaEnd)
+				throw EDataTableFormatException(eDataTableFormatError::Corrupt, "datatable segment schema exceeds the footer");
+
+			if (!(schemaEntry.m_dQuantizationScale >= 0.0) || !std::isfinite(schemaEntry.m_dQuantizationScale))
+				throw EDataTableFormatException(eDataTableFormatError::Corrupt, "invalid datatable column quantisation step");
+			if ((schemaEntry.m_nDefaultEncoding != DATATABLE_V2_ENCODING_PLAIN) && (schemaEntry.m_nDefaultEncoding != DATATABLE_V2_ENCODING_DELTA) && (schemaEntry.m_nDefaultEncoding != DATATABLE_V2_ENCODING_BITPACK))
+				throw EDataTableFormatException(eDataTableFormatError::UnsupportedEncoding, "unsupported datatable column encoding: " + std::to_string(schemaEntry.m_nDefaultEncoding));
+
+			sDataTableV2Column column;
+			column.m_DataType = (eDataTableV2DataType)schemaEntry.m_nDataType;
+			column.m_nEncoding = schemaEntry.m_nDefaultEncoding;
+			column.m_dQuantizationStep = schemaEntry.m_dQuantizationScale;
+			column.m_sIdentifier.assign((const char*)footer.data() + nPosition, schemaEntry.m_nIdentifierLength);
+			nPosition += schemaEntry.m_nIdentifierLength;
+			column.m_sDescription.assign((const char*)footer.data() + nPosition, schemaEntry.m_nDescriptionLength);
+			nPosition += schemaEntry.m_nDescriptionLength;
+
+			m_EntrySizes.push_back(CDataTableV2::getEntrySize(column.m_DataType));
+			m_Columns.push_back(column);
+		}
+
+		if (nPosition != nSchemaEnd)
+			throw EDataTableFormatException(eDataTableFormatError::Corrupt, "datatable segment schema size mismatch");
+
+		// Page directory
+		size_t nEntryCount = (size_t)m_FooterHeader.m_nChunkCount * (size_t)nColumnCount;
+		m_Directory.resize(nEntryCount);
+		if (nEntryCount > 0)
+			memcpy(m_Directory.data(), footer.data() + nSchemaEnd, nEntryCount * sizeof(sDataTableV2PageEntry));
+	}
+
+	void CDataTableV2SegmentReader::validateDirectory()
+	{
+		uint32_t nColumnCount = (uint32_t)m_Columns.size();
+		uint64_t nTotalRowCount = 0;
+
+		for (uint32_t nChunkIndex = 0; nChunkIndex < m_FooterHeader.m_nChunkCount; nChunkIndex++) {
+			uint32_t nChunkRowCount = 0;
+
+			for (uint32_t nColumnIndex = 0; nColumnIndex < nColumnCount; nColumnIndex++) {
+				auto& entry = m_Directory[(size_t)nChunkIndex * nColumnCount + nColumnIndex];
+
+				if (!CDataTableEncoding::codecIsValid(entry.m_nCodec))
+					throw EDataTableFormatException(eDataTableFormatError::UnsupportedCodec, "unsupported datatable page codec: " + std::to_string(entry.m_nCodec));
+
+				auto& column = m_Columns[nColumnIndex];
+				uint64_t nPlainSize = (uint64_t)entry.m_nRowCount * m_EntrySizes[nColumnIndex];
+
+				switch (entry.m_nEncoding) {
+				case DATATABLE_V2_ENCODING_PLAIN:
+					if (entry.m_nUncompressedSize != nPlainSize)
+						throw EDataTableFormatException(eDataTableFormatError::Corrupt, "datatable page size mismatch");
+					break;
+
+				case DATATABLE_V2_ENCODING_DELTA:
+					if (!CDataTableV2::encodingIsValidForColumn(column.m_DataType, DATATABLE_V2_ENCODING_DELTA, column.m_dQuantizationStep))
+						throw EDataTableFormatException(eDataTableFormatError::Corrupt, "delta encoded page in a datatable column that can not be delta encoded");
+					if (entry.m_nUncompressedSize == 0)
+						throw EDataTableFormatException(eDataTableFormatError::Corrupt, "datatable page size mismatch");
+					break;
+
+				case DATATABLE_V2_ENCODING_BITPACK:
+					if (column.m_DataType != eDataTableV2DataType::Bool)
+						throw EDataTableFormatException(eDataTableFormatError::Corrupt, "bit packed page in a datatable column that is not bool");
+					if (entry.m_nUncompressedSize != CDataTableEncoding::getBitPackSize(entry.m_nRowCount))
+						throw EDataTableFormatException(eDataTableFormatError::Corrupt, "datatable page size mismatch");
+					break;
+
+				default:
+					throw EDataTableFormatException(eDataTableFormatError::UnsupportedEncoding, "unsupported datatable page encoding: " + std::to_string(entry.m_nEncoding));
+				}
+
+				if ((entry.m_nCodec == DATATABLE_V2_CODEC_NONE) && (entry.m_nCompressedSize != entry.m_nUncompressedSize))
+					throw EDataTableFormatException(eDataTableFormatError::Corrupt, "datatable page size mismatch");
+				if ((entry.m_nRowCount > 0) && (entry.m_nCompressedSize == 0))
+					throw EDataTableFormatException(eDataTableFormatError::Corrupt, "datatable page size mismatch");
+
+				if ((entry.m_nFileOffset < sizeof(m_Header) + sizeof(sDataTableV2PageHeader)) || (entry.m_nFileOffset > m_nFooterStart) || (entry.m_nCompressedSize > m_nFooterStart - entry.m_nFileOffset))
+					throw EDataTableFormatException(eDataTableFormatError::Corrupt, "datatable page lies outside of the segment data");
+
+				if (nColumnIndex == 0)
+					nChunkRowCount = entry.m_nRowCount;
+				else if (entry.m_nRowCount != nChunkRowCount)
+					throw EDataTableFormatException(eDataTableFormatError::Corrupt, "datatable chunk columns have different row counts");
+			}
+
+			nTotalRowCount += nChunkRowCount;
+		}
+
+		if (nTotalRowCount != m_FooterHeader.m_nRowCount)
+			throw EDataTableFormatException(eDataTableFormatError::Corrupt, "datatable segment row count mismatch");
+	}
+
+	uint32_t CDataTableV2SegmentReader::getSegmentIndex() const
+	{
+		return m_Header.m_nSegmentIndex;
+	}
+
+	uint64_t CDataTableV2SegmentReader::getFirstRowIndex() const
+	{
+		return m_Header.m_nFirstRowIndex;
+	}
+
+	uint64_t CDataTableV2SegmentReader::getRowCount() const
+	{
+		return m_FooterHeader.m_nRowCount;
+	}
+
+	uint32_t CDataTableV2SegmentReader::getChunkCount() const
+	{
+		return m_FooterHeader.m_nChunkCount;
+	}
+
+	uint32_t CDataTableV2SegmentReader::getColumnCount() const
+	{
+		return (uint32_t)m_Columns.size();
+	}
+
+	const sDataTableV2Column& CDataTableV2SegmentReader::getColumn(uint32_t nColumnIndex) const
+	{
+		if (nColumnIndex >= m_Columns.size())
+			throw EDataTableFormatException(eDataTableFormatError::InvalidParam, "invalid datatable column index");
+
+		return m_Columns[nColumnIndex];
+	}
+
+	uint32_t CDataTableV2SegmentReader::getChunkRowCount(uint32_t nChunkIndex) const
+	{
+		if (m_Columns.empty())
+			return 0;
+
+		return getPageEntry(nChunkIndex, 0).m_nRowCount;
+	}
+
+	const sDataTableV2PageEntry& CDataTableV2SegmentReader::getPageEntry(uint32_t nChunkIndex, uint32_t nColumnIndex) const
+	{
+		if ((nChunkIndex >= m_FooterHeader.m_nChunkCount) || (nColumnIndex >= m_Columns.size()))
+			throw EDataTableFormatException(eDataTableFormatError::InvalidParam, "invalid datatable page index");
+
+		return m_Directory[(size_t)nChunkIndex * m_Columns.size() + nColumnIndex];
+	}
+
+	void CDataTableV2SegmentReader::readPage(uint32_t nChunkIndex, uint32_t nColumnIndex, uint8_t* pTarget, uint64_t nTargetSize)
+	{
+		auto& entry = getPageEntry(nChunkIndex, nColumnIndex);
+		auto& column = m_Columns[nColumnIndex];
+
+		size_t nRowCount = entry.m_nRowCount;
+		size_t nPlainSize = nRowCount * m_EntrySizes[nColumnIndex];
+		if (nPlainSize == 0)
+			return;
+
+		if ((pTarget == nullptr) || (nTargetSize < nPlainSize))
+			throw EDataTableFormatException(eDataTableFormatError::InvalidParam, "datatable page target buffer is too small");
+
+		m_nPageReadCount++;
+
+		// The common uncompressed plain page is read straight into the target.
+		if ((entry.m_nCodec == DATATABLE_V2_CODEC_NONE) && (entry.m_nEncoding == DATATABLE_V2_ENCODING_PLAIN)) {
+			m_ReadCallback(entry.m_nFileOffset, entry.m_nCompressedSize, pTarget);
+			return;
+		}
+
+		m_ReadScratch.resize(entry.m_nCompressedSize);
+		m_ReadCallback(entry.m_nFileOffset, entry.m_nCompressedSize, m_ReadScratch.data());
+
+		// A compressed plain page is decompressed straight into the target.
+		if (entry.m_nEncoding == DATATABLE_V2_ENCODING_PLAIN) {
+			CDataTableEncoding::decompress(entry.m_nCodec, m_ReadScratch.data(), m_ReadScratch.size(), pTarget, nPlainSize);
+			return;
+		}
+
+		const uint8_t* pEncodedData = m_ReadScratch.data();
+		size_t nEncodedSize = m_ReadScratch.size();
+		if (entry.m_nCodec != DATATABLE_V2_CODEC_NONE) {
+			m_DecompressScratch.resize(entry.m_nUncompressedSize);
+			CDataTableEncoding::decompress(entry.m_nCodec, m_ReadScratch.data(), m_ReadScratch.size(), m_DecompressScratch.data(), m_DecompressScratch.size());
+			pEncodedData = m_DecompressScratch.data();
+			nEncodedSize = m_DecompressScratch.size();
+		}
+
+		if (entry.m_nEncoding == DATATABLE_V2_ENCODING_BITPACK) {
+			CDataTableEncoding::decodeBitPack(pEncodedData, nEncodedSize, pTarget, nRowCount);
+			return;
+		}
+
+		// DELTA: 64 bit integers, narrowed or dequantised according to the column type.
+		m_IntegerScratch.resize(nRowCount);
+		CDataTableEncoding::decodeDelta(pEncodedData, nEncodedSize, m_IntegerScratch.data(), nRowCount);
+
+		switch (column.m_DataType) {
+		case eDataTableV2DataType::Int32:
+		case eDataTableV2DataType::Uint32:
+			for (size_t nIndex = 0; nIndex < nRowCount; nIndex++) {
+				uint32_t nValue = (uint32_t)m_IntegerScratch[nIndex];
+				memcpy(pTarget + nIndex * sizeof(uint32_t), &nValue, sizeof(uint32_t));
+			}
+			break;
+
+		case eDataTableV2DataType::Double:
+			for (size_t nIndex = 0; nIndex < nRowCount; nIndex++) {
+				double dValue = (double)m_IntegerScratch[nIndex] * column.m_dQuantizationStep;
+				memcpy(pTarget + nIndex * sizeof(double), &dValue, sizeof(double));
+			}
+			break;
+
+		default:
+			memcpy(pTarget, m_IntegerScratch.data(), nRowCount * sizeof(int64_t));
+			break;
+		}
+	}
+
+	uint64_t CDataTableV2SegmentReader::getPageReadCount() const
+	{
+		return m_nPageReadCount;
+	}
+
+}
diff --git a/Implementation/Core/amc_datatableformat.hpp b/Implementation/Core/amc_datatableformat.hpp
new file mode 100644
index 000000000..e1176ea58
--- /dev/null
+++ b/Implementation/Core/amc_datatableformat.hpp
@@ -0,0 +1,402 @@
+/*++
+
+Copyright (C) 2020 Autodesk Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+	* Redistributions of source code must retain the above copyright
+	  notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+	  notice, this list of conditions and the following disclaimer in the
+	  documentation and/or other materials provided with the distribution.
+	* Neither the name of the Autodesk Inc. nor the
+	  names of its contributors may be used to endorse or promote products
+	  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL AUTODESK INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+
+#ifndef __AMC_DATATABLEFORMAT
+#define __AMC_DATATABLEFORMAT
+
+#include <cstdint>
+#include <functional>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+/*************************************************************************************************************************
+
+ Format version 2 of application/amcf-datatable: one chunked columnar segment.
+
+   [ segment header ]   64 bytes, signature DATATABLE_HEADERSIGNATURE_V2
+   [ chunk 0 ]          column 0 page | column 1 page | ... | column N-1 page
+   [ chunk 1 ]          ...
+   [ footer ]           footer header, column schema, page directory (chunk count x column count entries)
+   [ trailer ]          16 bytes: footer length and magic. It locates the footer from the end of the stream.
+
+ A segment is strictly append-only: nothing that has been written is ever rewritten, so a running
+ hash over the stream stays valid and a writer never seeks back. Every page carries a small header
+ with its own type and length, which keeps an interrupted segment recoverable by a forward scan.
+ A segment without trailer is reported as truncated.
+
+ All values are little-endian. Every column is fixed-width.
+
+**************************************************************************************************************************/
+
+#define DATATABLE_FORMATVERSION_2 2
+
+#define DATATABLE_V2_PAGEMAGIC 0x47503244
+#define DATATABLE_V2_FOOTERMAGIC 0x54463244
+#define DATATABLE_V2_TRAILERMAGIC 0x52543244
+
+// Page codecs. A page is stored uncompressed if compression does not make it smaller.
+#define DATATABLE_V2_CODEC_NONE 0
+#define DATATABLE_V2_CODEC_LZ4 1
+#define DATATABLE_V2_CODEC_DEFLATE 2
+
+// Page encodings, see amc_datatableencoding.hpp. PLAIN is a raw value array and has the same value as the
+// RAW encoding of format version 1. A page falls back to PLAIN if its encoding does not make it smaller.
+#define DATATABLE_V2_ENCODING_PLAIN 1
+#define DATATABLE_V2_ENCODING_DELTA 2
+#define DATATABLE_V2_ENCODING_BITPACK 3
+
+#define DATATABLE_V2_PAGEFLAG_STATISTICSVALID 1
+
+#define DATATABLE_V2_MAXCHUNKCOUNT (64 * 1024 * 1024)
+#define DATATABLE_V2_MAXSTRINGLENGTH (1024 * 1024)
+
+namespace AMC {
+
+	// Column data types. The values are identical to LibMCEnv::eDataTableColumnType.
+	enum class eDataTableV2DataType : uint32_t {
+		Unknown = 0,
+		Double = 1,
+		Int32 = 2,
+		Uint32 = 3,
+		Int64 = 4,
+		Uint64 = 5,
+		Float = 6,
+		Bool = 7,
+		Timestamp = 8
+	};
+
+#pragma pack(push)
+#pragma pack(1)
+
+	struct sDataTableV2SegmentHeader {
+		uint32_t m_nSignature;
+		uint32_t m_nVersion;
+		uint32_t m_nHeaderSize;
+		uint32_t m_nFlags;
+		uint32_t m_nSegmentIndex;
+		uint32_t m_nColumnCount;
+		uint64_t m_nFirstRowIndex;
+		uint32_t m_nChunkRowCapacity;
+		uint32_t m_nReserved[7];
+	};
+
+	struct sDataTableV2PageHeader {
+		uint32_t m_nMagic;
+		uint32_t m_nColumnIndex;
+		uint32_t m_nRowCount;
+		uint32_t m_nDataType;
+		uint32_t m_nCodec;
+		uint32_t m_nEncoding;
+		uint32_t m_nCompressedSize;
+		uint32_t m_nUncompressedSize;
+	};
+
+	// Minimum and maximum are 8 bytes typed by the column: the bit pattern of a double for Double and Float
+	// columns, a signed 64 bit integer for Int32 and Int64 columns and an unsigned one for all others.
+	struct sDataTableV2PageEntry {
+		uint64_t m_nFileOffset;
+		uint32_t m_nCompressedSize;
+		uint32_t m_nUncompressedSize;
+		uint32_t m_nRowCount;
+		uint32_t m_nCodec;
+		uint32_t m_nEncoding;
+		uint64_t m_nMinValue;
+		uint64_t m_nMaxValue;
+		uint32_t m_nFlags;
+		uint32_t m_nReserved;
+	};
+
+	struct sDataTableV2FooterHeader {
+		uint32_t m_nMagic;
+		uint32_t m_nColumnCount;
+		uint32_t m_nChunkCount;
+		uint32_t m_nSchemaSize;
+		uint64_t m_nRowCount;
+		uint64_t m_nFirstRowIndex;
+		uint32_t m_nReserved[2];
+	};
+
+	// Followed by the identifier bytes and the description bytes.
+	struct sDataTableV2SchemaEntry {
+		uint32_t m_nDataType;
+		uint32_t m_nDefaultEncoding;
+		uint32_t m_nIdentifierLength;
+		uint32_t m_nDescriptionLength;
+		double m_dQuantizationScale;
+		uint32_t m_nReserved[4];
+	};
+
+	struct sDataTableV2Trailer {
+		uint64_t m_nFooterLength;
+		uint32_t m_nReserved;
+		uint32_t m_nMagic;
+	};
+
+#pragma pack(pop)
+
+	static_assert(sizeof(sDataTableV2SegmentHeader) == 64, "datatable v2 segment header must be 64 bytes");
+	static_assert(sizeof(sDataTableV2PageHeader) == 32, "datatable v2 page header must be 32 bytes");
+	static_assert(sizeof(sDataTableV2PageEntry) == 52, "datatable v2 page directory entry must be 52 bytes");
+	static_assert(sizeof(sDataTableV2FooterHeader) == 40, "datatable v2 footer header must be 40 bytes");
+	static_assert(sizeof(sDataTableV2SchemaEntry) == 40, "datatable v2 schema entry must be 40 bytes");
+	static_assert(sizeof(sDataTableV2Trailer) == 16, "datatable v2 trailer must be 16 bytes");
+
+
+	enum class eDataTableFormatError : uint32_t {
+		InvalidParam = 1,
+		InvalidSignature = 2,
+		UnsupportedVersion = 3,
+		UnsupportedCodec = 4,
+		UnsupportedEncoding = 5,
+		InvalidDataType = 6,
+		Truncated = 7,
+		Corrupt = 8,
+		InvalidRange = 9,
+		SegmentPurged = 10,
+		ColumnNotFound = 11,
+		TypeMismatch = 12
+	};
+
+	class EDataTableFormatException : public std::runtime_error {
+	private:
+		eDataTableFormatError m_Error;
+
+	public:
+		EDataTableFormatException(eDataTableFormatError error, const std::string& sMessage);
+
+		eDataTableFormatError getError() const;
+	};
+
+
+	struct sDataTableV2Column {
+		std::string m_sIdentifier;
+		std::string m_sDescription;
+		eDataTableV2DataType m_DataType;
+
+		// Encoding the pages of the column are written with. Single pages may fall back to PLAIN.
+		uint32_t m_nEncoding = DATATABLE_V2_ENCODING_PLAIN;
+
+		// Quantisation step of a Double column with DELTA encoding: values are stored as integer multiples
+		// of the step. 0 means that the column is not quantised and stays bit-exact.
+		double m_dQuantizationStep = 0.0;
+	};
+
+	// One chunk in its on-disk form: the page headers and payloads of all columns.
+	struct sDataTableV2EncodedChunk {
+		uint32_t m_nRowCount = 0;
+		std::vector<uint8_t> m_Bytes;
+
+		// One entry per column. m_nFileOffset is relative to the start of m_Bytes.
+		std::vector<sDataTableV2PageEntry> m_Entries;
+	};
+
+
+	class CDataTableV2 {
+	public:
+
+		// Returns the width of one value in bytes. Fails for unknown data types.
+		static uint32_t getEntrySize(eDataTableV2DataType dataType);
+
+		static bool dataTypeIsValid(uint32_t nDataType);
+
+		// Computes the typed minimum and maximum of a plain value array. Returns false if there is no
+		// comparable value, which is the case for an empty array or a floating point array of NaNs only.
+		static bool computeStatistics(eDataTableV2DataType dataType, const uint8_t* pData, uint32_t nRowCount, uint64_t& nMinValue, uint64_t& nMaxValue);
+
+		// Converts a typed statistics value of a page directory entry to a double.
+		static double statisticsValueToDouble(eDataTableV2DataType dataType, uint64_t nValue);
+
+		// Returns the encoding a column of the given type is written with by default:
+		// DELTA for integers and timestamps, BITPACK for bools, PLAIN for floating point values.
+		static uint32_t getDefaultEncoding(eDataTableV2DataType dataType);
+
+		// Returns if pages of a column may carry the encoding. DELTA on a Double column requires a quantisation step.
+		static bool encodingIsValidForColumn(eDataTableV2DataType dataType, uint32_t nEncoding, double dQuantizationStep);
+	};
+
+
+	/*************************************************************************************************************************
+	 CDataTableV2ChunkEncoder turns the plain value arrays of a chunk into pages: it applies the encoding of each
+	 column, compresses the result and computes the page statistics. It keeps its scratch buffers between chunks.
+	**************************************************************************************************************************/
+
+	class CDataTableV2ChunkEncoder {
+	private:
+		std::vector<sDataTableV2Column> m_Columns;
+		std::vector<uint32_t> m_EntrySizes;
+		uint32_t m_nCodec;
+
+		std::vector<int64_t> m_IntegerScratch;
+		std::vector<double> m_DoubleScratch;
+		std::vector<uint8_t> m_EncodedScratch;
+		std::vector<uint8_t> m_CompressedScratch;
+
+		bool quantize(const uint8_t* pData, uint32_t nRowCount, double dStep);
+		void widenIntegers(eDataTableV2DataType dataType, const uint8_t* pData, uint32_t nRowCount);
+
+	public:
+
+		CDataTableV2ChunkEncoder(const std::vector<sDataTableV2Column>& columns, uint32_t nCodec);
+
+		// columnData holds one pointer per column to nRowCount plain values of that column.
+		void encodeChunk(const std::vector<const uint8_t*>& columnData, uint32_t nRowCount, sDataTableV2EncodedChunk& chunk);
+
+	};
+
+
+	/*************************************************************************************************************************
+	 CDataTableV2SegmentBuilder serialises one segment. It produces bytes and keeps the directory, but does no I/O:
+	 the caller appends every produced buffer to the segment stream, in the order of the calls.
+	**************************************************************************************************************************/
+
+	class CDataTableV2SegmentBuilder {
+	private:
+		std::vector<sDataTableV2Column> m_Columns;
+		std::vector<uint32_t> m_EntrySizes;
+
+		uint32_t m_nSegmentIndex;
+		uint64_t m_nFirstRowIndex;
+		uint32_t m_nChunkRowCapacity;
+
+		uint64_t m_nCurrentSize;
+		uint64_t m_nRowCount;
+		uint32_t m_nChunkCount;
+		bool m_bHeaderWritten;
+		bool m_bFooterWritten;
+
+		std::vector<sDataTableV2PageEntry> m_Directory;
+
+		// Encoder of appendChunk: the encodings of the columns, no compression.
+		CDataTableV2ChunkEncoder m_UncompressedEncoder;
+		sDataTableV2EncodedChunk m_UncompressedChunk;
+
+		uint64_t getSchemaSizeInBytes() const;
+
+	public:
+
+		CDataTableV2SegmentBuilder(const std::vector<sDataTableV2Column>& columns, uint32_t nSegmentIndex, uint64_t nFirstRowIndex, uint32_t nChunkRowCapacity);
+
+		// Appends the segment header to the buffer. Must be the first call.
+		void appendHeader(std::vector<uint8_t>& buffer);
+
+		// Appends one chunk to the buffer: one page per column. columnData holds one pointer per column
+		// to nRowCount plain values of that column. The pages are encoded, but not compressed.
+		void appendChunk(const std::vector<const uint8_t*>& columnData, uint32_t nRowCount, std::vector<uint8_t>& buffer);
+
+		// Appends a chunk that has been encoded by a CDataTableV2ChunkEncoder for the same columns.
+		void appendEncodedChunk(const sDataTableV2EncodedChunk& chunk, std::vector<uint8_t>& buffer);
+
+		// Appends footer and trailer to the buffer. Must be the last call.
+		void appendFooter(std::vector<uint8_t>& buffer);
+
+		// Size of a chunk of plain pages. No encoded chunk is larger.
+		uint64_t getChunkSizeInBytes(uint32_t nRowCount) const;
+
+		// Size of footer and trailer of a segment that holds nChunkCount chunks.
+		uint64_t getFooterSizeInBytes(uint32_t nChunkCount) const;
+
+		uint64_t getCurrentSize() const;
+
+		uint64_t getRowCount() const;
+
+		uint32_t getChunkCount() const;
+
+		uint32_t getSegmentIndex() const;
+
+		uint64_t getFirstRowIndex() const;
+
+	};
+
+
+	/*************************************************************************************************************************
+	 CDataTableV2SegmentReader parses header, trailer and footer of a segment and reads single pages on request.
+	 The constructor validates the complete directory against the stream size, so that a truncated or corrupted
+	 segment is reported with an EDataTableFormatException and never yields garbage.
+	**************************************************************************************************************************/
+
+	class CDataTableV2SegmentReader {
+	public:
+		// Reads nSize bytes at the absolute stream offset nOffset into pBuffer.
+		typedef std::function<void(uint64_t nOffset, uint64_t nSize, uint8_t* pBuffer)> ReadCallback;
+
+	private:
+		ReadCallback m_ReadCallback;
+		uint64_t m_nStreamSize;
+		uint64_t m_nFooterStart;
+
+		sDataTableV2SegmentHeader m_Header;
+		sDataTableV2FooterHeader m_FooterHeader;
+
+		std::vector<sDataTableV2Column> m_Columns;
+		std::vector<uint32_t> m_EntrySizes;
+		std::vector<sDataTableV2PageEntry> m_Directory;
+
+		std::vector<uint8_t> m_ReadScratch;
+		std::vector<uint8_t> m_DecompressScratch;
+		std::vector<int64_t> m_IntegerScratch;
+		uint64_t m_nPageReadCount;
+
+		void parseFooter(const std::vector<uint8_t>& footer);
+		void validateDirectory();
+
+	public:
+
+		CDataTableV2SegmentReader(ReadCallback readCallback, uint64_t nStreamSize);
+
+		uint32_t getSegmentIndex() const;
+
+		uint64_t getFirstRowIndex() const;
+
+		uint64_t getRowCount() const;
+
+		uint32_t getChunkCount() const;
+
+		uint32_t getColumnCount() const;
+
+		const sDataTableV2Column& getColumn(uint32_t nColumnIndex) const;
+
+		uint32_t getChunkRowCount(uint32_t nChunkIndex) const;
+
+		const sDataTableV2PageEntry& getPageEntry(uint32_t nChunkIndex, uint32_t nColumnIndex) const;
+
+		// Reads, decompresses and decodes one page into pTarget as plain values.
+		void readPage(uint32_t nChunkIndex, uint32_t nColumnIndex, uint8_t* pTarget, uint64_t nTargetSize);
+
+		// Number of pages that have been read from the stream. Reading the footer does not count.
+		uint64_t getPageReadCount() const;
+
+	};
+
+}
+
+
+#endif //__AMC_DATATABLEFORMAT
diff --git a/Implementation/Core/amc_jsoneventstreaminstance.cpp b/Implementation/Core/amc_jsoneventstreaminstance.cpp
index c9e763657..427143ab5 100644
--- a/Implementation/Core/amc_jsoneventstreaminstance.cpp
+++ b/Implementation/Core/amc_jsoneventstreaminstance.cpp
@@ -37,7 +37,7 @@ Abstract: This is the class definition of CJSONEventStreamInstance.
 using namespace AMC;
 
 sJSONEventStreamCursor::sJSONEventStreamCursor()
-	: m_nLastEventID(0), m_nChangeCounter(0), m_bStarted(false), m_nDataChangeCounter(0), m_LastBuildTime(std::chrono::steady_clock::now())
+	: m_nLastEventID(0), m_nChangeCounter(0), m_bStarted(false), m_nDataChangeCounter(0), m_LastBuildTime(std::chrono::steady_clock::now()), m_nActionsRevision(0)
 {
 }
 
diff --git a/Implementation/Core/amc_jsoneventstreaminstance.hpp b/Implementation/Core/amc_jsoneventstreaminstance.hpp
index 8e533fdc6..f6b9c8504 100644
--- a/Implementation/Core/amc_jsoneventstreaminstance.hpp
+++ b/Implementation/Core/amc_jsoneventstreaminstance.hpp
@@ -60,6 +60,8 @@ namespace AMC {
 		// Data change counter the last event was built from, and when it was built.
 		uint64_t m_nDataChangeCounter;
 		std::chrono::steady_clock::time_point m_LastBuildTime;
+		// Revision of the session's pending client actions that the consumer has received.
+		uint64_t m_nActionsRevision;
 
 		sJSONEventStreamCursor();
 	};
diff --git a/Implementation/Core/amc_streamdownloadregistry.cpp b/Implementation/Core/amc_streamdownloadregistry.cpp
new file mode 100644
index 000000000..016542bb9
--- /dev/null
+++ b/Implementation/Core/amc_streamdownloadregistry.cpp
@@ -0,0 +1,253 @@
+/*++
+
+Copyright (C) 2026 Autodesk Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+	* Redistributions of source code must retain the above copyright
+	  notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+	  notice, this list of conditions and the following disclaimer in the
+	  documentation and/or other materials provided with the distribution.
+	* Neither the name of the Autodesk Inc. nor the
+	  names of its contributors may be used to endorse or promote products
+	  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL AUTODESK INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#include "amc_streamdownloadregistry.hpp"
+#include "libmc_exceptiontypes.hpp"
+#include "common_utils.hpp"
+
+using namespace AMC;
+
+sStreamDownloadProgress::sStreamDownloadProgress()
+	: m_nActiveConnections(0), m_nDeliveredBytes(0), m_nTotalBytes(0), m_bCompleted(false), m_bCancelled(false), m_nMillisecondsSinceActivity(0)
+{
+}
+
+CStreamDownloadRegistry::sEntry::sEntry()
+	: m_nSize(0), m_nActiveConnections(0), m_LastActivity(std::chrono::steady_clock::now()), m_bCancelled(false), m_bCompleted(false)
+{
+}
+
+void CStreamDownloadRegistry::sEntry::addRange(uint64_t nOffset, uint64_t nLength)
+{
+	if (nLength == 0)
+		return;
+
+	uint64_t nStart = nOffset;
+	uint64_t nEnd = nOffset + nLength;
+
+	// Merge with every range that touches or overlaps [nStart, nEnd).
+	auto iter = m_SentRanges.lower_bound(nStart);
+	if (iter != m_SentRanges.begin()) {
+		auto iPrev = std::prev(iter);
+		if (iPrev->second >= nStart)
+			iter = iPrev;
+	}
+
+	while ((iter != m_SentRanges.end()) && (iter->first <= nEnd)) {
+		if (iter->first < nStart)
+			nStart = iter->first;
+		if (iter->second > nEnd)
+			nEnd = iter->second;
+		iter = m_SentRanges.erase(iter);
+	}
+
+	m_SentRanges.insert(std::make_pair(nStart, nEnd));
+}
+
+uint64_t CStreamDownloadRegistry::sEntry::contiguousBytes() const
+{
+	auto iter = m_SentRanges.find(0);
+	if (iter == m_SentRanges.end())
+		return 0;
+	return iter->second;
+}
+
+CStreamDownloadRegistry::CStreamDownloadRegistry(uint32_t nMaxDownloads)
+	: m_nActiveDownloads(0), m_nMaxDownloads(nMaxDownloads)
+{
+	if (m_nMaxDownloads == 0)
+		m_nMaxDownloads = 1;
+}
+
+CStreamDownloadRegistry::~CStreamDownloadRegistry()
+{
+}
+
+CStreamDownloadRegistry::sEntry& CStreamDownloadRegistry::findOrCreateNoLock(const std::string& sStreamUUID, uint64_t nSize)
+{
+	auto iter = m_Entries.find(sStreamUUID);
+	if (iter == m_Entries.end()) {
+		sEntry entry;
+		entry.m_nSize = nSize;
+		iter = m_Entries.insert(std::make_pair(sStreamUUID, entry)).first;
+	}
+	else if (nSize > 0) {
+		iter->second.m_nSize = nSize;
+	}
+
+	return iter->second;
+}
+
+void CStreamDownloadRegistry::prepareDownload(const std::string& sStreamUUID, uint64_t nSize)
+{
+	std::string sNormalizedUUID = AMCCommon::CUtils::normalizeUUIDString(sStreamUUID);
+	std::lock_guard<std::mutex> lockGuard(m_Mutex);
+
+	auto& entry = findOrCreateNoLock(sNormalizedUUID, nSize);
+	entry.m_SentRanges.clear();
+	entry.m_bCancelled = false;
+	entry.m_bCompleted = false;
+	entry.m_LastActivity = std::chrono::steady_clock::now();
+}
+
+bool CStreamDownloadRegistry::reserveSlot()
+{
+	std::lock_guard<std::mutex> lockGuard(m_Mutex);
+	if (m_nActiveDownloads >= m_nMaxDownloads)
+		return false;
+
+	m_nActiveDownloads++;
+	return true;
+}
+
+void CStreamDownloadRegistry::releaseSlot()
+{
+	std::lock_guard<std::mutex> lockGuard(m_Mutex);
+	if (m_nActiveDownloads > 0)
+		m_nActiveDownloads--;
+}
+
+uint32_t CStreamDownloadRegistry::getActiveDownloadCount()
+{
+	std::lock_guard<std::mutex> lockGuard(m_Mutex);
+	return m_nActiveDownloads;
+}
+
+uint32_t CStreamDownloadRegistry::getMaxDownloads()
+{
+	std::lock_guard<std::mutex> lockGuard(m_Mutex);
+	return m_nMaxDownloads;
+}
+
+void CStreamDownloadRegistry::connectionStarted(const std::string& sStreamUUID, uint64_t nSize)
+{
+	std::string sNormalizedUUID = AMCCommon::CUtils::normalizeUUIDString(sStreamUUID);
+	std::lock_guard<std::mutex> lockGuard(m_Mutex);
+
+	auto& entry = findOrCreateNoLock(sNormalizedUUID, nSize);
+	entry.m_nActiveConnections++;
+	entry.m_LastActivity = std::chrono::steady_clock::now();
+}
+
+bool CStreamDownloadRegistry::chunkSent(const std::string& sStreamUUID, uint64_t nOffset, uint64_t nLength)
+{
+	std::string sNormalizedUUID = AMCCommon::CUtils::normalizeUUIDString(sStreamUUID);
+	std::lock_guard<std::mutex> lockGuard(m_Mutex);
+
+	auto& entry = findOrCreateNoLock(sNormalizedUUID, 0);
+	if (entry.m_bCancelled)
+		return false;
+
+	entry.addRange(nOffset, nLength);
+	entry.m_LastActivity = std::chrono::steady_clock::now();
+	return true;
+}
+
+void CStreamDownloadRegistry::connectionEnded(const std::string& sStreamUUID, bool bSuccess)
+{
+	std::string sNormalizedUUID = AMCCommon::CUtils::normalizeUUIDString(sStreamUUID);
+	std::lock_guard<std::mutex> lockGuard(m_Mutex);
+
+	auto iter = m_Entries.find(sNormalizedUUID);
+	if (iter == m_Entries.end())
+		return;
+
+	auto& entry = iter->second;
+	if (entry.m_nActiveConnections > 0)
+		entry.m_nActiveConnections--;
+
+	entry.m_LastActivity = std::chrono::steady_clock::now();
+
+	if (bSuccess && (!entry.m_bCancelled) && (entry.m_nSize > 0) && (entry.contiguousBytes() >= entry.m_nSize))
+		entry.m_bCompleted = true;
+}
+
+bool CStreamDownloadRegistry::isCancelled(const std::string& sStreamUUID)
+{
+	std::string sNormalizedUUID = AMCCommon::CUtils::normalizeUUIDString(sStreamUUID);
+	std::lock_guard<std::mutex> lockGuard(m_Mutex);
+
+	auto iter = m_Entries.find(sNormalizedUUID);
+	if (iter == m_Entries.end())
+		return false;
+
+	return iter->second.m_bCancelled;
+}
+
+bool CStreamDownloadRegistry::hasActiveConnections(const std::string& sStreamUUID)
+{
+	std::string sNormalizedUUID = AMCCommon::CUtils::normalizeUUIDString(sStreamUUID);
+	std::lock_guard<std::mutex> lockGuard(m_Mutex);
+
+	auto iter = m_Entries.find(sNormalizedUUID);
+	if (iter == m_Entries.end())
+		return false;
+
+	return (iter->second.m_nActiveConnections > 0);
+}
+
+sStreamDownloadProgress CStreamDownloadRegistry::getProgress(const std::string& sStreamUUID)
+{
+	std::string sNormalizedUUID = AMCCommon::CUtils::normalizeUUIDString(sStreamUUID);
+	std::lock_guard<std::mutex> lockGuard(m_Mutex);
+
+	sStreamDownloadProgress progress;
+
+	auto iter = m_Entries.find(sNormalizedUUID);
+	if (iter == m_Entries.end())
+		return progress;
+
+	auto& entry = iter->second;
+	progress.m_nActiveConnections = entry.m_nActiveConnections;
+	progress.m_nDeliveredBytes = entry.contiguousBytes();
+	progress.m_nTotalBytes = entry.m_nSize;
+	progress.m_bCompleted = entry.m_bCompleted;
+	progress.m_bCancelled = entry.m_bCancelled;
+
+	auto now = std::chrono::steady_clock::now();
+	if (now > entry.m_LastActivity)
+		progress.m_nMillisecondsSinceActivity = (uint64_t)std::chrono::duration_cast<std::chrono::milliseconds>(now - entry.m_LastActivity).count();
+
+	return progress;
+}
+
+bool CStreamDownloadRegistry::cancel(const std::string& sStreamUUID)
+{
+	std::string sNormalizedUUID = AMCCommon::CUtils::normalizeUUIDString(sStreamUUID);
+	std::lock_guard<std::mutex> lockGuard(m_Mutex);
+
+	auto& entry = findOrCreateNoLock(sNormalizedUUID, 0);
+	if (entry.m_bCompleted)
+		return false;
+
+	entry.m_bCancelled = true;
+	entry.m_LastActivity = std::chrono::steady_clock::now();
+	return true;
+}
diff --git a/Implementation/Core/amc_streamdownloadregistry.hpp b/Implementation/Core/amc_streamdownloadregistry.hpp
new file mode 100644
index 000000000..25371107f
--- /dev/null
+++ b/Implementation/Core/amc_streamdownloadregistry.hpp
@@ -0,0 +1,132 @@
+/*++
+
+Copyright (C) 2026 Autodesk Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+	* Redistributions of source code must retain the above copyright
+	  notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+	  notice, this list of conditions and the following disclaimer in the
+	  documentation and/or other materials provided with the distribution.
+	* Neither the name of the Autodesk Inc. nor the
+	  names of its contributors may be used to endorse or promote products
+	  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL AUTODESK INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+
+#ifndef __AMC_STREAMDOWNLOADREGISTRY
+#define __AMC_STREAMDOWNLOADREGISTRY
+
+#include <chrono>
+#include <cstdint>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <string>
+
+// A download is never slower than this many bytes per chunk write before it counts as idle; the
+// server limits the number of downloads that may hold an HTTP worker thread at the same time.
+#define AMC_STREAMDOWNLOADREGISTRY_DEFAULTMAXDOWNLOADS 4
+
+namespace AMC {
+
+	struct sStreamDownloadProgress {
+		uint32_t m_nActiveConnections;
+		// Length of the contiguous start of the stream that has been written to a socket.
+		uint64_t m_nDeliveredBytes;
+		uint64_t m_nTotalBytes;
+		// The last byte was sent and the connection that sent it ended successfully.
+		bool m_bCompleted;
+		bool m_bCancelled;
+		// Time since the last chunk was sent, or since the download was prepared.
+		uint64_t m_nMillisecondsSinceActivity;
+
+		sStreamDownloadProgress();
+	};
+
+	// Tracks the delivery of storage streams to HTTP clients, keyed by stream UUID. The API download
+	// handler reports sent chunks and connection ends; state machines read the progress and cancel.
+	// A connection is registered with its first chunk, so HEAD requests and failures before the first
+	// byte never touch the counters. All methods are thread safe.
+	class CStreamDownloadRegistry {
+	private:
+
+		struct sEntry {
+			uint64_t m_nSize;
+			uint32_t m_nActiveConnections;
+			// Sent byte ranges as start -> end (exclusive), merged and non-overlapping.
+			std::map<uint64_t, uint64_t> m_SentRanges;
+			std::chrono::steady_clock::time_point m_LastActivity;
+			bool m_bCancelled;
+			bool m_bCompleted;
+
+			sEntry();
+			void addRange(uint64_t nOffset, uint64_t nLength);
+			uint64_t contiguousBytes() const;
+		};
+
+		std::mutex m_Mutex;
+		std::map<std::string, sEntry> m_Entries;
+		uint32_t m_nActiveDownloads;
+		uint32_t m_nMaxDownloads;
+
+		sEntry& findOrCreateNoLock(const std::string& sStreamUUID, uint64_t nSize);
+
+	public:
+
+		CStreamDownloadRegistry(uint32_t nMaxDownloads = AMC_STREAMDOWNLOADREGISTRY_DEFAULTMAXDOWNLOADS);
+		virtual ~CStreamDownloadRegistry();
+
+		// Starts a new delivery of a stream: clears sent ranges, completion and cancellation and resets
+		// the activity timer. Running connections of an earlier delivery keep counting until they end.
+		void prepareDownload(const std::string& sStreamUUID, uint64_t nSize);
+
+		// Reserves one of the limited download slots. Returns false if all are in use.
+		bool reserveSlot();
+		void releaseSlot();
+		uint32_t getActiveDownloadCount();
+		uint32_t getMaxDownloads();
+
+		// Called with the first chunk of a connection.
+		void connectionStarted(const std::string& sStreamUUID, uint64_t nSize);
+
+		// Records a chunk as written to the socket. Returns false if the download was cancelled;
+		// the caller then stops sending.
+		bool chunkSent(const std::string& sStreamUUID, uint64_t nOffset, uint64_t nLength);
+
+		// Called once per registered connection when it ends. bSuccess means that all requested bytes
+		// were written.
+		void connectionEnded(const std::string& sStreamUUID, bool bSuccess);
+
+		bool isCancelled(const std::string& sStreamUUID);
+
+		bool hasActiveConnections(const std::string& sStreamUUID);
+
+		sStreamDownloadProgress getProgress(const std::string& sStreamUUID);
+
+		// Marks the stream as cancelled, so that every running connection stops with its next chunk.
+		// Returns false if the stream had already been delivered completely.
+		bool cancel(const std::string& sStreamUUID);
+
+	};
+
+	typedef std::shared_ptr<CStreamDownloadRegistry> PStreamDownloadRegistry;
+
+}
+
+#endif //__AMC_STREAMDOWNLOADREGISTRY
diff --git a/Implementation/Core/amc_systemstate.cpp b/Implementation/Core/amc_systemstate.cpp
index 6201040e2..d5fadb8db 100644
--- a/Implementation/Core/amc_systemstate.cpp
+++ b/Implementation/Core/amc_systemstate.cpp
@@ -30,6 +30,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 
 #include "amc_systemstate.hpp"
+#include "amc_streamdownloadregistry.hpp"
 #include "libmc_exceptiontypes.hpp"
 
 #include "amc_logger.hpp"
@@ -99,6 +100,7 @@ namespace AMC {
 		m_pMeshHandler = std::make_shared<CMeshHandler>();
 		m_pToolpathHandler = std::make_shared<CToolpathHandler>(m_pDataModel);
 		m_pStreamRegistry = std::make_shared<CStreamRegistry>();
+		m_pStreamDownloadRegistry = std::make_shared<CStreamDownloadRegistry>();
 		m_pStateMachineData = std::make_shared<CStateMachineData>();
 		PLogger pWarningLogger = m_pLogger;
 		m_pStateMachineData->setWarningHandler([pWarningLogger](const std::string& sMessage) {
@@ -222,6 +224,21 @@ namespace AMC {
 		return m_pStreamRegistry;
 	}
 
+	std::shared_ptr<CStreamDownloadRegistry> CSystemState::getStreamDownloadRegistryInstance()
+	{
+		return m_pStreamDownloadRegistry;
+	}
+
+	void CSystemState::setSessionHandler(std::shared_ptr<CAPISessionHandler> pSessionHandler)
+	{
+		m_pSessionHandler = pSessionHandler;
+	}
+
+	std::shared_ptr<CAPISessionHandler> CSystemState::getSessionHandler()
+	{
+		return m_pSessionHandler.lock();
+	}
+
 	PLogger CSystemState::getLoggerInstance()
 	{
 		return m_pLogger;
diff --git a/Implementation/Core/amc_systemstate.hpp b/Implementation/Core/amc_systemstate.hpp
index dafedaa1f..88f2b9603 100644
--- a/Implementation/Core/amc_systemstate.hpp
+++ b/Implementation/Core/amc_systemstate.hpp
@@ -73,6 +73,8 @@ namespace AMC {
 	class CAlertHandler;
 	class CTelemetryHandler;
 	class CStreamRegistry;
+	class CStreamDownloadRegistry;
+	class CAPISessionHandler;
 
 	typedef std::shared_ptr<CLogger> PLogger;
 	typedef std::shared_ptr<CStateSignalHandler> PStateSignalHandler;
@@ -115,6 +117,10 @@ namespace AMC {
 		AMC::PParameterGroup m_pSystemMemoryGroup;
 		AMC::PTelemetryHandler m_pTelemetryHandler;
 		AMC::PStreamRegistry m_pStreamRegistry;
+		std::shared_ptr<CStreamDownloadRegistry> m_pStreamDownloadRegistry;
+
+		// Owned by the API; set once the API exists. State machines use it to address client sessions.
+		std::weak_ptr<CAPISessionHandler> m_pSessionHandler;
 
 		AMCCommon::PChrono m_pGlobalChrono;
 
@@ -159,6 +165,11 @@ namespace AMC {
 		PAlertHandler getAlertHandlerInstance();
 		PTelemetryHandler getTelemetryHandlerInstance();
 		PStreamRegistry getStreamRegistryInstance();
+		std::shared_ptr<CStreamDownloadRegistry> getStreamDownloadRegistryInstance();
+
+		void setSessionHandler(std::shared_ptr<CAPISessionHandler> pSessionHandler);
+		// Returns null before the API has been created.
+		std::shared_ptr<CAPISessionHandler> getSessionHandler();
 
 		LibMCData::PDataModel getDataModelInstance ();
 
diff --git a/Implementation/DataModel/amcdata_databasemigrator.cpp b/Implementation/DataModel/amcdata_databasemigrator.cpp
index 2ad2540c5..306bf7034 100644
--- a/Implementation/DataModel/amcdata_databasemigrator.cpp
+++ b/Implementation/DataModel/amcdata_databasemigrator.cpp
@@ -51,7 +51,7 @@ namespace AMCData {
 
 	uint32_t CDatabaseMigrator::getCurrentSchemaVersion()
 	{
-		return 23;
+		return 25;
 	}
 
 	void CDatabaseMigrator::migrateDatabaseSchemas(PSQLHandler pSQLHandler, std::string& sInstallationUUID, std::string& sInstallationSecret)
diff --git a/Implementation/DataModel/amcdata_databasemigrator_buildjobs.cpp b/Implementation/DataModel/amcdata_databasemigrator_buildjobs.cpp
index 5ac3a2268..f67fbfe51 100644
--- a/Implementation/DataModel/amcdata_databasemigrator_buildjobs.cpp
+++ b/Implementation/DataModel/amcdata_databasemigrator_buildjobs.cpp
@@ -165,6 +165,48 @@ namespace AMCData {
 			break;
 		}
 
+		case 23:
+		{
+			// Manifest of streaming data captures. A capture belongs to a build job execution,
+			// its segments are storage streams and are indexed like telemetry_chunks.
+			std::string sDataCapturesQuery = "CREATE TABLE `datacaptures` (";
+			sDataCapturesQuery += "`uuid`  varchar ( 64 ) UNIQUE NOT NULL,";
+			sDataCapturesQuery += "`executionuuid`  varchar ( 64 ) NOT NULL,";
+			sDataCapturesQuery += "`identifier`  varchar ( 256 ) NOT NULL,";
+			sDataCapturesQuery += "`name`  varchar ( 256 ) NOT NULL,";
+			sDataCapturesQuery += "`status`  varchar ( 64 ) NOT NULL,";
+			sDataCapturesQuery += "`useruuid`  varchar ( 64 ) NOT NULL,";
+			sDataCapturesQuery += "`active`  integer DEFAULT 0,";
+			sDataCapturesQuery += "`timestamp`  varchar ( 64 ) NOT NULL,";
+			sDataCapturesQuery += "`endtimestamp`  varchar ( 64 ) NOT NULL)";
+			pTransaction->executeStatement(sDataCapturesQuery);
+
+			std::string sDataCaptureColumnsQuery = "CREATE TABLE `datacapture_columns` (";
+			sDataCaptureColumnsQuery += "`captureuuid`  varchar ( 64 ) NOT NULL,";
+			sDataCaptureColumnsQuery += "`columnindex`  integer NOT NULL,";
+			sDataCaptureColumnsQuery += "`identifier`  varchar ( 256 ) NOT NULL,";
+			sDataCaptureColumnsQuery += "`description`  TEXT NOT NULL,";
+			sDataCaptureColumnsQuery += "`columntype`  integer NOT NULL)";
+			pTransaction->executeStatement(sDataCaptureColumnsQuery);
+
+			std::string sDataCaptureSegmentsQuery = "CREATE TABLE `datacapture_segments` (";
+			sDataCaptureSegmentsQuery += "`uuid`  varchar ( 64 ) UNIQUE NOT NULL,";
+			sDataCaptureSegmentsQuery += "`captureuuid`  varchar ( 64 ) NOT NULL,";
+			sDataCaptureSegmentsQuery += "`segmentindex`  integer NOT NULL,";
+			sDataCaptureSegmentsQuery += "`storagestreamuuid`  varchar ( 64 ) NOT NULL,";
+			sDataCaptureSegmentsQuery += "`firstrow`  integer DEFAULT 0,";
+			sDataCaptureSegmentsQuery += "`rowcount`  integer DEFAULT 0,";
+			sDataCaptureSegmentsQuery += "`chunkcount`  integer DEFAULT 0,";
+			sDataCaptureSegmentsQuery += "`sizeinbytes`  integer DEFAULT 0,";
+			sDataCaptureSegmentsQuery += "`starttimestamp`  integer DEFAULT 0,";
+			sDataCaptureSegmentsQuery += "`endtimestamp`  integer DEFAULT 0,";
+			sDataCaptureSegmentsQuery += "`status`  varchar ( 64 ) NOT NULL,";
+			sDataCaptureSegmentsQuery += "`timestamp`  varchar ( 64 ) NOT NULL)";
+			pTransaction->executeStatement(sDataCaptureSegmentsQuery);
+
+			break;
+		}
+
 		}
 
 		
diff --git a/Implementation/DataModel/amcdata_databasemigrator_storage.cpp b/Implementation/DataModel/amcdata_databasemigrator_storage.cpp
index cafc789ea..534945665 100644
--- a/Implementation/DataModel/amcdata_databasemigrator_storage.cpp
+++ b/Implementation/DataModel/amcdata_databasemigrator_storage.cpp
@@ -108,7 +108,17 @@ namespace AMCData {
 				pTransaction->executeStatement(sStreamsQuery);
 				break;
 			}
-		}
+
+			case 24: {
+				// Download tickets can be revoked (a cancelled download must not be resumable) and the
+				// access log records how a download ended.
+				pTransaction->executeStatement("ALTER TABLE `storage_downloadtickets` ADD `revoked` integer DEFAULT 0;");
+				pTransaction->executeStatement("ALTER TABLE `storage_downloads` ADD `sentbytes` integer DEFAULT 0;");
+				pTransaction->executeStatement("ALTER TABLE `storage_downloads` ADD `success` integer DEFAULT 0;");
+				pTransaction->executeStatement("ALTER TABLE `storage_downloads` ADD `finishedtimestamp` varchar (64) DEFAULT '';");
+				break;
+			}
+}
 	}
 
 
diff --git a/Implementation/LibMC/libmc_apirequesthandler.cpp b/Implementation/LibMC/libmc_apirequesthandler.cpp
index 23d63d314..b087a321c 100644
--- a/Implementation/LibMC/libmc_apirequesthandler.cpp
+++ b/Implementation/LibMC/libmc_apirequesthandler.cpp
@@ -38,6 +38,7 @@ Abstract: This is a stub class definition of CAPIRequestHandler
 #include "amc_api_constants.hpp"
 #include "amc_api_response.hpp"
 // Include custom headers here.
+#include <cstring>
 
 
 using namespace LibMC::Impl;
@@ -47,7 +48,7 @@ using namespace LibMC::Impl;
 **************************************************************************************************************************/
 
 CAPIRequestHandler::CAPIRequestHandler(AMC::PAPI pAPI, const std::string& sURI, const AMC::eAPIRequestType eRequestType, AMC::PAPIAuth pAuth, AMC::PLogger pLogger)
-    : m_RequestType(eRequestType), m_pAPI (pAPI), m_pAuth (pAuth), m_pLogger (pLogger)
+    : m_RequestType(eRequestType), m_pAPI (pAPI), m_pAuth (pAuth), m_pLogger (pLogger), m_nChunkOffset (0)
 {
     if (pAPI.get() == nullptr)
         throw ELibMCInterfaceException(LIBMC_ERROR_INVALIDPARAM);
@@ -158,14 +159,8 @@ void CAPIRequestHandler::GetResultData(LibMC_uint64 nDataBufferSize, LibMC_uint6
 		if (nDataBufferSize < nStreamSize)
 			throw ELibMCInterfaceException(LIBMC_ERROR_BUFFERTOOSMALL);
 
-		if (m_pResponse.get() != nullptr) {
-			const uint8_t* pSrc = m_pResponse->getStreamData();
-			uint8_t* pDst = pDataBuffer;
-
-			for (uint64_t nIndex = 0; nIndex < nStreamSize; nIndex++) {
-				*pDst = *pSrc; pDst++; pSrc++;
-			}
-		}
+		if ((m_pResponse.get() != nullptr) && (nStreamSize > 0))
+			memcpy(pDataBuffer, m_pResponse->getStreamData(), (size_t)nStreamSize);
 	}
 
 }
@@ -180,3 +175,66 @@ std::string CAPIRequestHandler::GetContentDispositionName()
 
 }
 
+void CAPIRequestHandler::SetClientAddress(const std::string& sAddress)
+{
+    m_FormFields.setClientAddress(sAddress);
+}
+
+AMC::CAPIStorageStreamResponse* CAPIRequestHandler::getStreamResponse()
+{
+    if (m_pResponse.get() == nullptr)
+        throw ELibMCInterfaceException(LIBMC_ERROR_APIREQUESTNOTHANDLED);
+
+    auto pStreamResponse = dynamic_cast<AMC::CAPIStorageStreamResponse*> (m_pResponse.get());
+    if (pStreamResponse == nullptr)
+        throw ELibMCInterfaceException(LIBMC_ERROR_NOSTREAMRESULT);
+
+    return pStreamResponse;
+}
+
+bool CAPIRequestHandler::HasStreamResult()
+{
+    if (m_pResponse.get() == nullptr)
+        throw ELibMCInterfaceException(LIBMC_ERROR_APIREQUESTNOTHANDLED);
+
+    return (dynamic_cast<AMC::CAPIStorageStreamResponse*> (m_pResponse.get()) != nullptr);
+}
+
+void CAPIRequestHandler::GetResultStreamInfo(LibMC_uint64& nSize, std::string& sETag, std::string& sLastModified)
+{
+    auto pStreamResponse = getStreamResponse();
+    nSize = pStreamResponse->getSize();
+    sETag = pStreamResponse->getETag();
+    sLastModified = pStreamResponse->getLastModified();
+}
+
+void CAPIRequestHandler::ReadResultStreamChunk(const LibMC_uint64 nOffset, const LibMC_uint64 nLength, LibMC_uint64 nDataBufferSize, LibMC_uint64* pDataNeededCount, LibMC_uint8* pDataBuffer)
+{
+    auto pStreamResponse = getStreamResponse();
+
+    // The binding calls twice: first for the size, then with a buffer. The chunk is read once and cached.
+    if ((m_ChunkBuffer.empty()) || (m_nChunkOffset != nOffset) || (m_ChunkBuffer.size() != nLength)) {
+        m_ChunkBuffer.clear();
+        pStreamResponse->readChunk(nOffset, nLength, m_ChunkBuffer);
+        m_nChunkOffset = nOffset;
+    }
+
+    if (pDataNeededCount != nullptr)
+        *pDataNeededCount = m_ChunkBuffer.size();
+
+    if (pDataBuffer != nullptr) {
+        if (nDataBufferSize < m_ChunkBuffer.size())
+            throw ELibMCInterfaceException(LIBMC_ERROR_BUFFERTOOSMALL);
+
+        if (!m_ChunkBuffer.empty())
+            memcpy(pDataBuffer, m_ChunkBuffer.data(), m_ChunkBuffer.size());
+
+        m_ChunkBuffer.clear();
+    }
+}
+
+void CAPIRequestHandler::FinishStreamResult(const bool bSuccess)
+{
+    getStreamResponse()->finish(bSuccess);
+}
+
diff --git a/Implementation/LibMC/libmc_apirequesthandler.hpp b/Implementation/LibMC/libmc_apirequesthandler.hpp
index 1e5c933f4..7f13ebade 100644
--- a/Implementation/LibMC/libmc_apirequesthandler.hpp
+++ b/Implementation/LibMC/libmc_apirequesthandler.hpp
@@ -51,6 +51,7 @@ Abstract: This is the class declaration of CAPIRequestHandler
 
 // Include custom headers here.
 #include <map>
+#include <vector>
 
 namespace LibMC {
 namespace Impl {
@@ -77,6 +78,12 @@ class CAPIRequestHandler : public virtual IAPIRequestHandler, public virtual CBa
 
 	AMC::PLogger m_pLogger;
 
+	// Chunk read by ReadResultStreamChunk when the caller asked for the size, handed out with the second call.
+	std::vector<uint8_t> m_ChunkBuffer;
+	uint64_t m_nChunkOffset;
+
+	AMC::CAPIStorageStreamResponse* getStreamResponse();
+
 public:
 
 	CAPIRequestHandler(AMC::PAPI pAPI, const std::string& sURI, const AMC::eAPIRequestType eRequestType, AMC::PAPIAuth pAuth, AMC::PLogger pLogger);
@@ -98,7 +105,17 @@ class CAPIRequestHandler : public virtual IAPIRequestHandler, public virtual CBa
 	void SetRequestParameter(const std::string& sName, const std::string& sValue) override;
 
 	std::string GetContentDispositionName() override;
-	
+
+	void SetClientAddress(const std::string& sAddress) override;
+
+	bool HasStreamResult() override;
+
+	void GetResultStreamInfo(LibMC_uint64& nSize, std::string& sETag, std::string& sLastModified) override;
+
+	void ReadResultStreamChunk(const LibMC_uint64 nOffset, const LibMC_uint64 nLength, LibMC_uint64 nDataBufferSize, LibMC_uint64* pDataNeededCount, LibMC_uint8* pDataBuffer) override;
+
+	void FinishStreamResult(const bool bSuccess) override;
+
 };
 
 } // namespace Impl
diff --git a/Implementation/LibMC/libmc_mccontext.cpp b/Implementation/LibMC/libmc_mccontext.cpp
index e77fd90c6..1726ed792 100644
--- a/Implementation/LibMC/libmc_mccontext.cpp
+++ b/Implementation/LibMC/libmc_mccontext.cpp
@@ -101,6 +101,15 @@ CMCContext::CMCContext(LibMCData::PDataModel pDataModel)
     m_pAPI = std::make_shared<AMC::CAPI>(pGlobalChrono, pDataModel);
     CAPIFactory factory (m_pAPI, m_pSystemState, m_InstanceList);
 
+    // State machines address client sessions through the system state, for example to hand a download over.
+    m_pSystemState->setSessionHandler(m_pAPI->getSessionHandler());
+
+    // ZIP streams of exports that a crash or a forced stop interrupted can not be resumed; their files only
+    // hold disk space and are removed before the state machines start.
+    uint32_t nDiscardedZIPStreams = pDataModel->CreateStorage()->DiscardUnfinishedZIPStreams();
+    if (nDiscardedZIPStreams > 0)
+        m_pSystemState->logger()->logMessage("Discarded " + std::to_string(nDiscardedZIPStreams) + " unfinished ZIP stream(s) from an earlier run", "system", AMC::eLogLevel::Message);
+
     // Create API Documentation handler
     m_pAPIDocumentationHandler = std::make_shared <CAPIHandler_APIDocs>(m_pSystemState->getClientHash());
     m_pAPI->registerHandler(m_pAPIDocumentationHandler);
diff --git a/Implementation/LibMCData/libmcdata_buildjobexecution.cpp b/Implementation/LibMCData/libmcdata_buildjobexecution.cpp
index b02387054..7664aabb3 100644
--- a/Implementation/LibMCData/libmcdata_buildjobexecution.cpp
+++ b/Implementation/LibMCData/libmcdata_buildjobexecution.cpp
@@ -38,6 +38,7 @@ Abstract: This is a stub class definition of CBuildJobExecution
 #include "libmcdata_buildjobexecutiondata.hpp"
 #include "libmcdata_buildjobexecutiondataiterator.hpp"
 #include "libmcdata_buildjob.hpp"
+#include "libmcdata_datacapture.hpp"
 #include "common_utils.hpp"
 #include "common_chrono.hpp"
 
@@ -654,3 +655,29 @@ LibMCData::eBuildJobExecutionStatus CBuildJobExecution::convertStringToBuildJobE
 
 	throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDBUILDJOBEXECUTIONSTATUS);
 }
+
+
+IDataCapture* CBuildJobExecution::CreateDataCapture(const std::string& sIdentifier, const std::string& sName, const std::string& sUserUUID, const LibMCData_uint64 nAbsoluteTimeStamp)
+{
+	return CDataCapture::createInDatabase(m_pSQLHandler, m_pStorageState, m_sExecutionUUID, sIdentifier, sName, sUserUUID, nAbsoluteTimeStamp);
+}
+
+bool CBuildJobExecution::HasDataCapture(const std::string& sIdentifier)
+{
+	return CDataCapture::existsInDatabase(m_pSQLHandler, m_sExecutionUUID, sIdentifier);
+}
+
+IDataCapture* CBuildJobExecution::RetrieveDataCapture(const std::string& sIdentifier)
+{
+	return CDataCapture::makeFromDatabase(m_pSQLHandler, m_pStorageState, m_sExecutionUUID, sIdentifier);
+}
+
+LibMCData_uint32 CBuildJobExecution::GetDataCaptureCount()
+{
+	return CDataCapture::countInExecution(m_pSQLHandler, m_sExecutionUUID);
+}
+
+IDataCapture* CBuildJobExecution::RetrieveDataCaptureByIndex(const LibMCData_uint32 nIndex)
+{
+	return CDataCapture::makeFromExecutionIndex(m_pSQLHandler, m_pStorageState, m_sExecutionUUID, nIndex);
+}
diff --git a/Implementation/LibMCData/libmcdata_buildjobexecution.hpp b/Implementation/LibMCData/libmcdata_buildjobexecution.hpp
index 2b0abc5ce..2c5f791b8 100644
--- a/Implementation/LibMCData/libmcdata_buildjobexecution.hpp
+++ b/Implementation/LibMCData/libmcdata_buildjobexecution.hpp
@@ -150,6 +150,16 @@ class CBuildJobExecution : public virtual IBuildJobExecution, public virtual CBa
 
 	std::string GetMetaDataString(const std::string& sKey) override;
 
+	IDataCapture* CreateDataCapture(const std::string& sIdentifier, const std::string& sName, const std::string& sUserUUID, const LibMCData_uint64 nAbsoluteTimeStamp) override;
+
+	bool HasDataCapture(const std::string& sIdentifier) override;
+
+	IDataCapture* RetrieveDataCapture(const std::string& sIdentifier) override;
+
+	LibMCData_uint32 GetDataCaptureCount() override;
+
+	IDataCapture* RetrieveDataCaptureByIndex(const LibMCData_uint32 nIndex) override;
+
 	static std::string convertBuildJobExecutionStatusToString(const LibMCData::eBuildJobExecutionStatus eStatus);
 	static LibMCData::eBuildJobExecutionStatus convertStringToBuildJobExecutionStatus(const std::string& sValue);
 
diff --git a/Implementation/LibMCData/libmcdata_buildjobhandler.cpp b/Implementation/LibMCData/libmcdata_buildjobhandler.cpp
index e8ab9b14f..5995e6d43 100644
--- a/Implementation/LibMCData/libmcdata_buildjobhandler.cpp
+++ b/Implementation/LibMCData/libmcdata_buildjobhandler.cpp
@@ -32,6 +32,7 @@ Abstract: This is a stub class definition of CBuildJobHandler
 */
 
 #include "libmcdata_buildjobhandler.hpp"
+#include "libmcdata_datacapture.hpp"
 #include "libmcdata_interfaceexception.hpp"
 
 // Include custom headers here.
@@ -317,3 +318,8 @@ LibMCData_uint64 CBuildJobHandler::GetExecutionListHeadID()
         return 0;
     return (uint64_t) pStatement->getColumnInt64(1);
 }
+
+IDataCapture* CBuildJobHandler::RetrieveDataCapture(const std::string& sDataCaptureUUID)
+{
+    return CDataCapture::makeFromDatabaseByUUID(m_pSQLHandler, m_pStorageState, sDataCaptureUUID);
+}
diff --git a/Implementation/LibMCData/libmcdata_buildjobhandler.hpp b/Implementation/LibMCData/libmcdata_buildjobhandler.hpp
index 01e2a9604..7ff0ce7c4 100644
--- a/Implementation/LibMCData/libmcdata_buildjobhandler.hpp
+++ b/Implementation/LibMCData/libmcdata_buildjobhandler.hpp
@@ -104,6 +104,8 @@ class CBuildJobHandler : public virtual IBuildJobHandler, public virtual CBase {
 
     LibMCData_uint64 GetExecutionListHeadID() override;
 
+    IDataCapture* RetrieveDataCapture(const std::string& sDataCaptureUUID) override;
+
 };
 
 } // namespace Impl
diff --git a/Implementation/LibMCData/libmcdata_datacapture.cpp b/Implementation/LibMCData/libmcdata_datacapture.cpp
new file mode 100644
index 000000000..0a6fa5cab
--- /dev/null
+++ b/Implementation/LibMCData/libmcdata_datacapture.cpp
@@ -0,0 +1,586 @@
+/*++
+
+Copyright (C) 2020 Autodesk Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Autodesk Inc. nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL AUTODESK INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+Abstract: This is the class definition of CDataCapture
+
+*/
+
+#include "libmcdata_datacapture.hpp"
+#include "libmcdata_interfaceexception.hpp"
+
+// Include custom headers here.
+#include "common_utils.hpp"
+#include "common_chrono.hpp"
+
+#include <vector>
+
+using namespace LibMCData::Impl;
+
+#define DATACAPTURE_SEGMENTSTATUS_STORED "stored"
+#define DATACAPTURE_SEGMENTSTATUS_PURGED "purged"
+
+/*************************************************************************************************************************
+ Class definition of CDataCapture
+**************************************************************************************************************************/
+
+namespace {
+
+	struct sStoredSegment {
+		std::string m_sSegmentUUID;
+		std::string m_sStreamUUID;
+		uint64_t m_nSizeInBytes;
+	};
+
+	// Lists stored segments, oldest first. An empty capture UUID lists the segments of all captures.
+	std::vector<sStoredSegment> listStoredSegments(AMCData::PSQLHandler pSQLHandler, const std::string& sCaptureUUID)
+	{
+		std::vector<sStoredSegment> segments;
+
+		std::string sQuery = "SELECT uuid, storagestreamuuid, sizeinbytes FROM datacapture_segments WHERE status=?";
+		if (!sCaptureUUID.empty())
+			sQuery += " AND captureuuid=?";
+		sQuery += " ORDER BY endtimestamp ASC, segmentindex ASC";
+
+		auto pStatement = pSQLHandler->prepareStatement(sQuery);
+		pStatement->setString(1, DATACAPTURE_SEGMENTSTATUS_STORED);
+		if (!sCaptureUUID.empty())
+			pStatement->setString(2, sCaptureUUID);
+
+		while (pStatement->nextRow()) {
+			sStoredSegment segment;
+			segment.m_sSegmentUUID = pStatement->getColumnString(1);
+			segment.m_sStreamUUID = pStatement->getColumnString(2);
+			segment.m_nSizeInBytes = (uint64_t)pStatement->getColumnInt64(3);
+			segments.push_back(segment);
+		}
+
+		return segments;
+	}
+
+}
+
+
+CDataCapture::CDataCapture(AMCData::PSQLHandler pSQLHandler, AMCData::PStorageState pStorageState, const std::string& sUUID, const std::string& sExecutionUUID, const std::string& sIdentifier, const std::string& sName, const std::string& sTimeStamp)
+	: m_pSQLHandler(pSQLHandler),
+	m_pStorageState(pStorageState),
+	m_sUUID(AMCCommon::CUtils::normalizeUUIDString(sUUID)),
+	m_sExecutionUUID(AMCCommon::CUtils::normalizeUUIDString(sExecutionUUID)),
+	m_sIdentifier(sIdentifier),
+	m_sName(sName),
+	m_sTimeStamp(sTimeStamp)
+{
+	if (pSQLHandler.get() == nullptr)
+		throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDPARAM);
+	if (pStorageState.get() == nullptr)
+		throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDPARAM);
+}
+
+CDataCapture::~CDataCapture()
+{
+
+}
+
+std::string CDataCapture::convertStatusToString(const LibMCData::eDataCaptureStatus eStatus)
+{
+	switch (eStatus) {
+	case LibMCData::eDataCaptureStatus::Recording: return "recording";
+	case LibMCData::eDataCaptureStatus::Finished: return "finished";
+	case LibMCData::eDataCaptureStatus::Aborted: return "aborted";
+	default:
+		throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDDATACAPTURESTATUS);
+	}
+}
+
+LibMCData::eDataCaptureStatus CDataCapture::convertStringToStatus(const std::string& sStatus)
+{
+	if (sStatus == "recording")
+		return LibMCData::eDataCaptureStatus::Recording;
+	if (sStatus == "finished")
+		return LibMCData::eDataCaptureStatus::Finished;
+	if (sStatus == "aborted")
+		return LibMCData::eDataCaptureStatus::Aborted;
+
+	throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDDATACAPTURESTATUS, "invalid data capture status: " + sStatus);
+}
+
+CDataCapture* CDataCapture::createInDatabase(AMCData::PSQLHandler pSQLHandler, AMCData::PStorageState pStorageState, const std::string& sExecutionUUID, const std::string& sIdentifier, const std::string& sName, const std::string& sUserUUID, uint64_t nAbsoluteTimeStamp)
+{
+	if (pSQLHandler.get() == nullptr)
+		throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDPARAM);
+
+	if (sIdentifier.empty() || !AMCCommon::CUtils::stringIsValidAlphanumericNameString(sIdentifier))
+		throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDDATACAPTUREIDENTIFIER, "invalid data capture identifier: " + sIdentifier);
+	if (sName.empty())
+		throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDDATACAPTURENAME);
+
+	std::string sNormalizedExecutionUUID = AMCCommon::CUtils::normalizeUUIDString(sExecutionUUID);
+	std::string sNormalizedUserUUID = AMCCommon::CUtils::normalizeUUIDString(sUserUUID);
+	std::string sUUID = AMCCommon::CUtils::createUUID();
+	std::string sTimeStamp = AMCCommon::CChrono::convertToISO8601TimeUTC(nAbsoluteTimeStamp);
+
+	{
+		auto pTransaction = pSQLHandler->beginTransaction();
+
+		auto pDuplicateStatement = pTransaction->prepareStatement("SELECT uuid FROM datacaptures WHERE executionuuid=? AND identifier=? AND active=?");
+		pDuplicateStatement->setString(1, sNormalizedExecutionUUID);
+		pDuplicateStatement->setString(2, sIdentifier);
+		pDuplicateStatement->setInt(3, 1);
+		if (pDuplicateStatement->nextRow())
+			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_DUPLICATEDATACAPTUREIDENTIFIER, "duplicate data capture identifier: " + sIdentifier);
+		pDuplicateStatement = nullptr;
+
+		auto pInsertStatement = pTransaction->prepareStatement("INSERT INTO datacaptures (uuid, executionuuid, identifier, name, status, useruuid, active, timestamp, endtimestamp) VALUES (?, ?, ?, ?, ?, ?, 1, ?, ?)");
+		pInsertStatement->setString(1, sUUID);
+		pInsertStatement->setString(2, sNormalizedExecutionUUID);
+		pInsertStatement->setString(3, sIdentifier);
+		pInsertStatement->setString(4, sName);
+		pInsertStatement->setString(5, convertStatusToString(LibMCData::eDataCaptureStatus::Recording));
+		pInsertStatement->setString(6, sNormalizedUserUUID);
+		pInsertStatement->setString(7, sTimeStamp);
+		pInsertStatement->setString(8, "");
+		pInsertStatement->execute();
+		pInsertStatement = nullptr;
+
+		pTransaction->commit();
+	}
+
+	return new CDataCapture(pSQLHandler, pStorageState, sUUID, sNormalizedExecutionUUID, sIdentifier, sName, sTimeStamp);
+}
+
+CDataCapture* CDataCapture::makeFromDatabase(AMCData::PSQLHandler pSQLHandler, AMCData::PStorageState pStorageState, const std::string& sExecutionUUID, const std::string& sIdentifier)
+{
+	if (pSQLHandler.get() == nullptr)
+		throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDPARAM);
+
+	std::string sNormalizedExecutionUUID = AMCCommon::CUtils::normalizeUUIDString(sExecutionUUID);
+
+	auto pStatement = pSQLHandler->prepareStatement("SELECT uuid, name, timestamp FROM datacaptures WHERE executionuuid=? AND identifier=? AND active=?");
+	pStatement->setString(1, sNormalizedExecutionUUID);
+	pStatement->setString(2, sIdentifier);
+	pStatement->setInt(3, 1);
+	if (!pStatement->nextRow())
+		throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_DATACAPTURENOTFOUND, "data capture not found: " + sIdentifier);
+
+	std::string sUUID = pStatement->getColumnString(1);
+	std::string sName = pStatement->getColumnString(2);
+	std::string sTimeStamp = pStatement->getColumnString(3);
+	pStatement = nullptr;
+
+	return new CDataCapture(pSQLHandler, pStorageState, sUUID, sNormalizedExecutionUUID, sIdentifier, sName, sTimeStamp);
+}
+
+CDataCapture* CDataCapture::makeFromDatabaseByUUID(AMCData::PSQLHandler pSQLHandler, AMCData::PStorageState pStorageState, const std::string& sCaptureUUID)
+{
+	if (pSQLHandler.get() == nullptr)
+		throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDPARAM);
+
+	std::string sNormalizedCaptureUUID = AMCCommon::CUtils::normalizeUUIDString(sCaptureUUID);
+
+	auto pStatement = pSQLHandler->prepareStatement("SELECT executionuuid, identifier, name, timestamp FROM datacaptures WHERE uuid=? AND active=?");
+	pStatement->setString(1, sNormalizedCaptureUUID);
+	pStatement->setInt(2, 1);
+	if (!pStatement->nextRow())
+		throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_DATACAPTURENOTFOUND, "data capture not found: " + sNormalizedCaptureUUID);
+
+	std::string sExecutionUUID = pStatement->getColumnString(1);
+	std::string sIdentifier = pStatement->getColumnString(2);
+	std::string sName = pStatement->getColumnString(3);
+	std::string sTimeStamp = pStatement->getColumnString(4);
+	pStatement = nullptr;
+
+	return new CDataCapture(pSQLHandler, pStorageState, sNormalizedCaptureUUID, sExecutionUUID, sIdentifier, sName, sTimeStamp);
+}
+
+uint32_t CDataCapture::countInExecution(AMCData::PSQLHandler pSQLHandler, const std::string& sExecutionUUID)
+{
+	if (pSQLHandler.get() == nullptr)
+		throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDPARAM);
+
+	auto pStatement = pSQLHandler->prepareStatement("SELECT COUNT(*) FROM datacaptures WHERE executionuuid=? AND active=?");
+	pStatement->setString(1, AMCCommon::CUtils::normalizeUUIDString(sExecutionUUID));
+	pStatement->setInt(2, 1);
+	if (!pStatement->nextRow())
+		return 0;
+
+	return (uint32_t)pStatement->getColumnInt64(1);
+}
+
+CDataCapture* CDataCapture::makeFromExecutionIndex(AMCData::PSQLHandler pSQLHandler, AMCData::PStorageState pStorageState, const std::string& sExecutionUUID, uint32_t nIndex)
+{
+	if (pSQLHandler.get() == nullptr)
+		throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDPARAM);
+
+	std::string sNormalizedExecutionUUID = AMCCommon::CUtils::normalizeUUIDString(sExecutionUUID);
+
+	auto pStatement = pSQLHandler->prepareStatement("SELECT uuid, identifier, name, timestamp FROM datacaptures WHERE executionuuid=? AND active=? ORDER BY timestamp ASC, identifier ASC");
+	pStatement->setString(1, sNormalizedExecutionUUID);
+	pStatement->setInt(2, 1);
+
+	uint32_t nRowIndex = 0;
+	while (pStatement->nextRow()) {
+		if (nRowIndex == nIndex) {
+			std::string sUUID = pStatement->getColumnString(1);
+			std::string sIdentifier = pStatement->getColumnString(2);
+			std::string sName = pStatement->getColumnString(3);
+			std::string sTimeStamp = pStatement->getColumnString(4);
+			pStatement = nullptr;
+
+			return new CDataCapture(pSQLHandler, pStorageState, sUUID, sNormalizedExecutionUUID, sIdentifier, sName, sTimeStamp);
+		}
+		nRowIndex++;
+	}
+
+	throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_DATACAPTURENOTFOUND, "data capture index out of bounds: " + std::to_string(nIndex));
+}
+
+bool CDataCapture::existsInDatabase(AMCData::PSQLHandler pSQLHandler, const std::string& sExecutionUUID, const std::string& sIdentifier)
+{
+	if (pSQLHandler.get() == nullptr)
+		throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDPARAM);
+
+	auto pStatement = pSQLHandler->prepareStatement("SELECT uuid FROM datacaptures WHERE executionuuid=? AND identifier=? AND active=?");
+	pStatement->setString(1, AMCCommon::CUtils::normalizeUUIDString(sExecutionUUID));
+	pStatement->setString(2, sIdentifier);
+	pStatement->setInt(3, 1);
+	return pStatement->nextRow();
+}
+
+bool CDataCapture::purgeSegment(AMCData::PSQLHandler pSQLHandler, AMCData::PStorageState pStorageState, const std::string& sSegmentUUID, const std::string& sStreamUUID)
+{
+	if (pSQLHandler.get() == nullptr)
+		throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDPARAM);
+	if (pStorageState.get() == nullptr)
+		throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDPARAM);
+
+	std::string sNormalizedStreamUUID = AMCCommon::CUtils::normalizeUUIDString(sStreamUUID);
+	std::string sPath = pStorageState->getStreamPath(sNormalizedStreamUUID);
+
+	// The file goes first: a segment that is still on disk must stay visible in the manifest.
+	if (AMCCommon::CUtils::fileOrPathExistsOnDisk(sPath)) {
+		AMCCommon::CUtils::deleteFileFromDisk(sPath, false);
+		if (AMCCommon::CUtils::fileOrPathExistsOnDisk(sPath))
+			return false;
+	}
+
+	auto pTransaction = pSQLHandler->beginTransaction();
+
+	auto pSegmentStatement = pTransaction->prepareStatement("UPDATE datacapture_segments SET status=? WHERE uuid=?");
+	pSegmentStatement->setString(1, DATACAPTURE_SEGMENTSTATUS_PURGED);
+	pSegmentStatement->setString(2, sSegmentUUID);
+	pSegmentStatement->execute();
+	pSegmentStatement = nullptr;
+
+	auto pLinkStatement = pTransaction->prepareStatement("DELETE FROM journal_tempstreams WHERE streamuuid=?");
+	pLinkStatement->setString(1, sNormalizedStreamUUID);
+	pLinkStatement->execute();
+	pLinkStatement = nullptr;
+
+	auto pStreamStatement = pTransaction->prepareStatement("DELETE FROM storage_streams WHERE uuid=?");
+	pStreamStatement->setString(1, sNormalizedStreamUUID);
+	pStreamStatement->execute();
+	pStreamStatement = nullptr;
+
+	pTransaction->commit();
+
+	return true;
+}
+
+uint64_t CDataCapture::getTotalStoredSize(AMCData::PSQLHandler pSQLHandler)
+{
+	if (pSQLHandler.get() == nullptr)
+		throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDPARAM);
+
+	auto pStatement = pSQLHandler->prepareStatement("SELECT COALESCE(SUM(sizeinbytes), 0) FROM datacapture_segments WHERE status=?");
+	pStatement->setString(1, DATACAPTURE_SEGMENTSTATUS_STORED);
+	if (!pStatement->nextRow())
+		return 0;
+
+	return (uint64_t)pStatement->getColumnInt64(1);
+}
+
+uint32_t CDataCapture::enforceStorageLimit(AMCData::PSQLHandler pSQLHandler, AMCData::PStorageState pStorageState, uint64_t nLimitInBytes)
+{
+	auto segments = listStoredSegments(pSQLHandler, "");
+
+	uint64_t nTotalSize = 0;
+	for (auto& segment : segments)
+		nTotalSize += segment.m_nSizeInBytes;
+
+	uint32_t nPurgedCount = 0;
+	for (auto& segment : segments) {
+		if (nTotalSize <= nLimitInBytes)
+			break;
+
+		// A segment whose file is in use is skipped and tried again on the next enforcement.
+		if (purgeSegment(pSQLHandler, pStorageState, segment.m_sSegmentUUID, segment.m_sStreamUUID)) {
+			nTotalSize -= segment.m_nSizeInBytes;
+			nPurgedCount++;
+		}
+	}
+
+	return nPurgedCount;
+}
+
+LibMCData::eDataCaptureStatus CDataCapture::readStatus(AMCData::CSQLTransaction* pTransaction)
+{
+	AMCData::PSQLStatement pStatement;
+	if (pTransaction != nullptr)
+		pStatement = pTransaction->prepareStatement("SELECT status FROM datacaptures WHERE uuid=?");
+	else
+		pStatement = m_pSQLHandler->prepareStatement("SELECT status FROM datacaptures WHERE uuid=?");
+
+	pStatement->setString(1, m_sUUID);
+	if (!pStatement->nextRow())
+		throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_DATACAPTURENOTFOUND, "data capture not found: " + m_sUUID);
+
+	return convertStringToStatus(pStatement->getColumnString(1));
+}
+
+std::string CDataCapture::GetUUID()
+{
+	return m_sUUID;
+}
+
+std::string CDataCapture::GetExecutionUUID()
+{
+	return m_sExecutionUUID;
+}
+
+std::string CDataCapture::GetIdentifier()
+{
+	return m_sIdentifier;
+}
+
+std::string CDataCapture::GetName()
+{
+	return m_sName;
+}
+
+LibMCData::eDataCaptureStatus CDataCapture::GetStatus()
+{
+	return readStatus(nullptr);
+}
+
+std::string CDataCapture::GetTimeStamp()
+{
+	return m_sTimeStamp;
+}
+
+void CDataCapture::AddColumn(const LibMCData_uint32 nColumnIndex, const std::string & sIdentifier, const std::string & sDescription, const LibMCData_uint32 nColumnType)
+{
+	if (sIdentifier.empty())
+		throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDPARAM);
+
+	auto pTransaction = m_pSQLHandler->beginTransaction();
+
+	if (readStatus(pTransaction.get()) != LibMCData::eDataCaptureStatus::Recording)
+		throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_DATACAPTURENOTRECORDING);
+
+	auto pDuplicateStatement = pTransaction->prepareStatement("SELECT columnindex FROM datacapture_columns WHERE captureuuid=? AND (columnindex=? OR identifier=?)");
+	pDuplicateStatement->setString(1, m_sUUID);
+	pDuplicateStatement->setInt64(2, nColumnIndex);
+	pDuplicateStatement->setString(3, sIdentifier);
+	if (pDuplicateStatement->nextRow())
+		throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_DUPLICATEDATACAPTURECOLUMN, "duplicate data capture column: " + sIdentifier);
+	pDuplicateStatement = nullptr;
+
+	auto pInsertStatement = pTransaction->prepareStatement("INSERT INTO datacapture_columns (captureuuid, columnindex, identifier, description, columntype) VALUES (?, ?, ?, ?, ?)");
+	pInsertStatement->setString(1, m_sUUID);
+	pInsertStatement->setInt64(2, nColumnIndex);
+	pInsertStatement->setString(3, sIdentifier);
+	pInsertStatement->setString(4, sDescription);
+	pInsertStatement->setInt64(5, nColumnType);
+	pInsertStatement->execute();
+	pInsertStatement = nullptr;
+
+	pTransaction->commit();
+}
+
+LibMCData_uint32 CDataCapture::GetColumnCount()
+{
+	auto pStatement = m_pSQLHandler->prepareStatement("SELECT COUNT(*) FROM datacapture_columns WHERE captureuuid=?");
+	pStatement->setString(1, m_sUUID);
+	if (!pStatement->nextRow())
+		return 0;
+
+	return (uint32_t)pStatement->getColumnInt64(1);
+}
+
+void CDataCapture::GetColumnInformation(const LibMCData_uint32 nColumnIndex, std::string & sIdentifier, std::string & sDescription, LibMCData_uint32 & nColumnType)
+{
+	auto pStatement = m_pSQLHandler->prepareStatement("SELECT identifier, description, columntype FROM datacapture_columns WHERE captureuuid=? AND columnindex=?");
+	pStatement->setString(1, m_sUUID);
+	pStatement->setInt64(2, nColumnIndex);
+	if (!pStatement->nextRow())
+		throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDDATACAPTURECOLUMNINDEX, "invalid data capture column index: " + std::to_string(nColumnIndex));
+
+	sIdentifier = pStatement->getColumnString(1);
+	sDescription = pStatement->getColumnString(2);
+	nColumnType = (uint32_t)pStatement->getColumnInt64(3);
+}
+
+void CDataCapture::AddSegment(const LibMCData_uint32 nSegmentIndex, const std::string & sStreamUUID, const LibMCData_uint64 nFirstRow, const LibMCData_uint64 nRowCount, const LibMCData_uint32 nChunkCount, const LibMCData_uint64 nSizeInBytes, const LibMCData_uint64 nStartTimeStamp, const LibMCData_uint64 nEndTimeStamp)
+{
+	std::string sNormalizedStreamUUID = AMCCommon::CUtils::normalizeUUIDString(sStreamUUID);
+	std::string sSegmentUUID = AMCCommon::CUtils::createUUID();
+	std::string sTimeStamp = AMCCommon::CChrono::convertToISO8601TimeUTC(nEndTimeStamp);
+
+	auto pTransaction = m_pSQLHandler->beginTransaction();
+
+	if (readStatus(pTransaction.get()) != LibMCData::eDataCaptureStatus::Recording)
+		throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_DATACAPTURENOTRECORDING);
+
+	auto pStreamStatement = pTransaction->prepareStatement("SELECT uuid FROM storage_streams WHERE uuid=?");
+	pStreamStatement->setString(1, sNormalizedStreamUUID);
+	if (!pStreamStatement->nextRow())
+		throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_STORAGESTREAMNOTFOUND, "storage stream not found for data capture segment: " + sNormalizedStreamUUID);
+	pStreamStatement = nullptr;
+
+	auto pDuplicateStatement = pTransaction->prepareStatement("SELECT uuid FROM datacapture_segments WHERE captureuuid=? AND segmentindex=?");
+	pDuplicateStatement->setString(1, m_sUUID);
+	pDuplicateStatement->setInt64(2, nSegmentIndex);
+	if (pDuplicateStatement->nextRow())
+		throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_DUPLICATEDATACAPTURESEGMENT, "duplicate data capture segment: " + std::to_string(nSegmentIndex));
+	pDuplicateStatement = nullptr;
+
+	auto pInsertStatement = pTransaction->prepareStatement("INSERT INTO datacapture_segments (uuid, captureuuid, segmentindex, storagestreamuuid, firstrow, rowcount, chunkcount, sizeinbytes, starttimestamp, endtimestamp, status, timestamp) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
+	pInsertStatement->setString(1, sSegmentUUID);
+	pInsertStatement->setString(2, m_sUUID);
+	pInsertStatement->setInt64(3, nSegmentIndex);
+	pInsertStatement->setString(4, sNormalizedStreamUUID);
+	pInsertStatement->setInt64(5, (int64_t)nFirstRow);
+	pInsertStatement->setInt64(6, (int64_t)nRowCount);
+	pInsertStatement->setInt64(7, nChunkCount);
+	pInsertStatement->setInt64(8, (int64_t)nSizeInBytes);
+	pInsertStatement->setInt64(9, (int64_t)nStartTimeStamp);
+	pInsertStatement->setInt64(10, (int64_t)nEndTimeStamp);
+	pInsertStatement->setString(11, DATACAPTURE_SEGMENTSTATUS_STORED);
+	pInsertStatement->setString(12, sTimeStamp);
+	pInsertStatement->execute();
+	pInsertStatement = nullptr;
+
+	pTransaction->commit();
+}
+
+LibMCData_uint32 CDataCapture::GetSegmentCount()
+{
+	auto pStatement = m_pSQLHandler->prepareStatement("SELECT COUNT(*) FROM datacapture_segments WHERE captureuuid=?");
+	pStatement->setString(1, m_sUUID);
+	if (!pStatement->nextRow())
+		return 0;
+
+	return (uint32_t)pStatement->getColumnInt64(1);
+}
+
+void CDataCapture::GetSegmentInformation(const LibMCData_uint32 nSegmentIndex, std::string & sStreamUUID, LibMCData_uint64 & nFirstRow, LibMCData_uint64 & nRowCount, LibMCData_uint64 & nSizeInBytes, bool & bIsPurged)
+{
+	auto pStatement = m_pSQLHandler->prepareStatement("SELECT storagestreamuuid, firstrow, rowcount, sizeinbytes, status FROM datacapture_segments WHERE captureuuid=? AND segmentindex=?");
+	pStatement->setString(1, m_sUUID);
+	pStatement->setInt64(2, nSegmentIndex);
+	if (!pStatement->nextRow())
+		throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDDATACAPTURESEGMENTINDEX, "invalid data capture segment index: " + std::to_string(nSegmentIndex));
+
+	sStreamUUID = pStatement->getColumnString(1);
+	nFirstRow = (uint64_t)pStatement->getColumnInt64(2);
+	nRowCount = (uint64_t)pStatement->getColumnInt64(3);
+	nSizeInBytes = (uint64_t)pStatement->getColumnInt64(4);
+	bIsPurged = (pStatement->getColumnString(5) != DATACAPTURE_SEGMENTSTATUS_STORED);
+}
+
+LibMCData_uint32 CDataCapture::GetSegmentChunkCount(const LibMCData_uint32 nSegmentIndex)
+{
+	auto pStatement = m_pSQLHandler->prepareStatement("SELECT chunkcount FROM datacapture_segments WHERE captureuuid=? AND segmentindex=?");
+	pStatement->setString(1, m_sUUID);
+	pStatement->setInt64(2, nSegmentIndex);
+	if (!pStatement->nextRow())
+		throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDDATACAPTURESEGMENTINDEX, "invalid data capture segment index: " + std::to_string(nSegmentIndex));
+
+	return (uint32_t)pStatement->getColumnInt64(1);
+}
+
+LibMCData_uint64 CDataCapture::GetRowCount()
+{
+	auto pStatement = m_pSQLHandler->prepareStatement("SELECT COALESCE(SUM(rowcount), 0) FROM datacapture_segments WHERE captureuuid=?");
+	pStatement->setString(1, m_sUUID);
+	if (!pStatement->nextRow())
+		return 0;
+
+	return (uint64_t)pStatement->getColumnInt64(1);
+}
+
+LibMCData_uint64 CDataCapture::GetStoredSizeInBytes()
+{
+	auto pStatement = m_pSQLHandler->prepareStatement("SELECT COALESCE(SUM(sizeinbytes), 0) FROM datacapture_segments WHERE captureuuid=? AND status=?");
+	pStatement->setString(1, m_sUUID);
+	pStatement->setString(2, DATACAPTURE_SEGMENTSTATUS_STORED);
+	if (!pStatement->nextRow())
+		return 0;
+
+	return (uint64_t)pStatement->getColumnInt64(1);
+}
+
+void CDataCapture::Finish(const LibMCData_uint64 nAbsoluteTimeStamp)
+{
+	std::string sTimeStamp = AMCCommon::CChrono::convertToISO8601TimeUTC(nAbsoluteTimeStamp);
+
+	auto pTransaction = m_pSQLHandler->beginTransaction();
+
+	if (readStatus(pTransaction.get()) != LibMCData::eDataCaptureStatus::Recording)
+		throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_DATACAPTURENOTRECORDING);
+
+	auto pStatement = pTransaction->prepareStatement("UPDATE datacaptures SET status=?, endtimestamp=? WHERE uuid=?");
+	pStatement->setString(1, convertStatusToString(LibMCData::eDataCaptureStatus::Finished));
+	pStatement->setString(2, sTimeStamp);
+	pStatement->setString(3, m_sUUID);
+	pStatement->execute();
+	pStatement = nullptr;
+
+	pTransaction->commit();
+}
+
+void CDataCapture::Abort(const LibMCData_uint64 nAbsoluteTimeStamp)
+{
+	std::string sTimeStamp = AMCCommon::CChrono::convertToISO8601TimeUTC(nAbsoluteTimeStamp);
+
+	if (readStatus(nullptr) == LibMCData::eDataCaptureStatus::Aborted)
+		throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_DATACAPTUREALREADYABORTED);
+
+	// The status changes first, so that no further segment can be registered while the stored ones are deleted.
+	{
+		auto pStatement = m_pSQLHandler->prepareStatement("UPDATE datacaptures SET status=?, endtimestamp=? WHERE uuid=?");
+		pStatement->setString(1, convertStatusToString(LibMCData::eDataCaptureStatus::Aborted));
+		pStatement->setString(2, sTimeStamp);
+		pStatement->setString(3, m_sUUID);
+		pStatement->execute();
+	}
+
+	auto segments = listStoredSegments(m_pSQLHandler, m_sUUID);
+	for (auto& segment : segments)
+		purgeSegment(m_pSQLHandler, m_pStorageState, segment.m_sSegmentUUID, segment.m_sStreamUUID);
+}
diff --git a/Implementation/LibMCData/libmcdata_datacapture.hpp b/Implementation/LibMCData/libmcdata_datacapture.hpp
new file mode 100644
index 000000000..0be85a0a8
--- /dev/null
+++ b/Implementation/LibMCData/libmcdata_datacapture.hpp
@@ -0,0 +1,155 @@
+/*++
+
+Copyright (C) 2020 Autodesk Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Autodesk Inc. nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL AUTODESK INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+Abstract: This is the class declaration of CDataCapture
+
+*/
+
+
+#ifndef __LIBMCDATA_DATACAPTURE
+#define __LIBMCDATA_DATACAPTURE
+
+#include "libmcdata_interfaces.hpp"
+
+// Parent classes
+#include "libmcdata_base.hpp"
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4250)
+#endif
+
+// Include custom headers here.
+#include "amcdata_sqlhandler.hpp"
+#include "amcdata_storagestate.hpp"
+
+namespace LibMCData {
+namespace Impl {
+
+
+/*************************************************************************************************************************
+ Class declaration of CDataCapture
+
+ A data capture manifest lives in three tables of the main database:
+   datacaptures          one row per capture, owned by a build job execution
+   datacapture_columns   the schema of the capture
+   datacapture_segments  one row per finished segment stream, modelled on telemetry_chunks
+ A segment row survives the deletion of its stream: retention marks it as purged instead of removing it,
+ so the manifest keeps telling which row range has existed.
+**************************************************************************************************************************/
+
+class CDataCapture : public virtual IDataCapture, public virtual CBase {
+private:
+
+	AMCData::PSQLHandler m_pSQLHandler;
+	AMCData::PStorageState m_pStorageState;
+
+	std::string m_sUUID;
+	std::string m_sExecutionUUID;
+	std::string m_sIdentifier;
+	std::string m_sName;
+	std::string m_sTimeStamp;
+
+	LibMCData::eDataCaptureStatus readStatus(AMCData::CSQLTransaction* pTransaction);
+
+public:
+
+	static std::string convertStatusToString(const LibMCData::eDataCaptureStatus eStatus);
+
+	static LibMCData::eDataCaptureStatus convertStringToStatus(const std::string& sStatus);
+
+	static CDataCapture* createInDatabase(AMCData::PSQLHandler pSQLHandler, AMCData::PStorageState pStorageState, const std::string& sExecutionUUID, const std::string& sIdentifier, const std::string& sName, const std::string& sUserUUID, uint64_t nAbsoluteTimeStamp);
+
+	static CDataCapture* makeFromDatabase(AMCData::PSQLHandler pSQLHandler, AMCData::PStorageState pStorageState, const std::string& sExecutionUUID, const std::string& sIdentifier);
+
+	static bool existsInDatabase(AMCData::PSQLHandler pSQLHandler, const std::string& sExecutionUUID, const std::string& sIdentifier);
+
+	static CDataCapture* makeFromDatabaseByUUID(AMCData::PSQLHandler pSQLHandler, AMCData::PStorageState pStorageState, const std::string& sCaptureUUID);
+
+	static uint32_t countInExecution(AMCData::PSQLHandler pSQLHandler, const std::string& sExecutionUUID);
+
+	// Captures of an execution are ordered by their creation time.
+	static CDataCapture* makeFromExecutionIndex(AMCData::PSQLHandler pSQLHandler, AMCData::PStorageState pStorageState, const std::string& sExecutionUUID, uint32_t nIndex);
+
+	// Deletes the stream of a stored segment from disk and marks the segment as purged.
+	// Returns false and changes nothing if the file could not be deleted, for example because it is open.
+	static bool purgeSegment(AMCData::PSQLHandler pSQLHandler, AMCData::PStorageState pStorageState, const std::string& sSegmentUUID, const std::string& sStreamUUID);
+
+	// Returns the size of all segments of all captures that are stored on disk.
+	static uint64_t getTotalStoredSize(AMCData::PSQLHandler pSQLHandler);
+
+	// Purges the oldest stored segments of all captures until the total stored size is within the limit.
+	static uint32_t enforceStorageLimit(AMCData::PSQLHandler pSQLHandler, AMCData::PStorageState pStorageState, uint64_t nLimitInBytes);
+
+	CDataCapture(AMCData::PSQLHandler pSQLHandler, AMCData::PStorageState pStorageState, const std::string& sUUID, const std::string& sExecutionUUID, const std::string& sIdentifier, const std::string& sName, const std::string& sTimeStamp);
+
+	virtual ~CDataCapture();
+
+	std::string GetUUID() override;
+
+	std::string GetExecutionUUID() override;
+
+	std::string GetIdentifier() override;
+
+	std::string GetName() override;
+
+	LibMCData::eDataCaptureStatus GetStatus() override;
+
+	std::string GetTimeStamp() override;
+
+	void AddColumn(const LibMCData_uint32 nColumnIndex, const std::string & sIdentifier, const std::string & sDescription, const LibMCData_uint32 nColumnType) override;
+
+	LibMCData_uint32 GetColumnCount() override;
+
+	void GetColumnInformation(const LibMCData_uint32 nColumnIndex, std::string & sIdentifier, std::string & sDescription, LibMCData_uint32 & nColumnType) override;
+
+	void AddSegment(const LibMCData_uint32 nSegmentIndex, const std::string & sStreamUUID, const LibMCData_uint64 nFirstRow, const LibMCData_uint64 nRowCount, const LibMCData_uint32 nChunkCount, const LibMCData_uint64 nSizeInBytes, const LibMCData_uint64 nStartTimeStamp, const LibMCData_uint64 nEndTimeStamp) override;
+
+	LibMCData_uint32 GetSegmentCount() override;
+
+	void GetSegmentInformation(const LibMCData_uint32 nSegmentIndex, std::string & sStreamUUID, LibMCData_uint64 & nFirstRow, LibMCData_uint64 & nRowCount, LibMCData_uint64 & nSizeInBytes, bool & bIsPurged) override;
+
+	LibMCData_uint32 GetSegmentChunkCount(const LibMCData_uint32 nSegmentIndex) override;
+
+	LibMCData_uint64 GetRowCount() override;
+
+	LibMCData_uint64 GetStoredSizeInBytes() override;
+
+	void Finish(const LibMCData_uint64 nAbsoluteTimeStamp) override;
+
+	void Abort(const LibMCData_uint64 nAbsoluteTimeStamp) override;
+
+};
+
+} // namespace Impl
+} // namespace LibMCData
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+#endif // __LIBMCDATA_DATACAPTURE
diff --git a/Implementation/LibMCData/libmcdata_datamodel.cpp b/Implementation/LibMCData/libmcdata_datamodel.cpp
index bca018e7d..270e920a0 100644
--- a/Implementation/LibMCData/libmcdata_datamodel.cpp
+++ b/Implementation/LibMCData/libmcdata_datamodel.cpp
@@ -119,9 +119,7 @@ void CDataModel::InitialiseDatabase(const std::string & sDataDirectory, const Li
     m_pStorageState->addAcceptedContent("image/png");
     m_pStorageState->addAcceptedContent("image/jpeg");
     m_pStorageState->addAcceptedContent("application/amcf-discretefield2d");
-
-    m_pStorageState->addAcceptedContent("image/png");
-    m_pStorageState->addAcceptedContent("image/jpeg");
+    m_pStorageState->addAcceptedContent("application/amcf-datatable");
 
     m_pStorageState->addImageContent("image/png");
     m_pStorageState->addImageContent("image/jpeg");
diff --git a/Implementation/LibMCData/libmcdata_storage.cpp b/Implementation/LibMCData/libmcdata_storage.cpp
index 5f42c98d2..e967c88f9 100644
--- a/Implementation/LibMCData/libmcdata_storage.cpp
+++ b/Implementation/LibMCData/libmcdata_storage.cpp
@@ -36,12 +36,14 @@ Abstract: This is a stub class definition of CStorage
 #include "libmcdata_interfaceexception.hpp"
 
 #include "libmcdata_storagezipwriter.hpp"
+#include "libmcdata_datacapture.hpp"
 
 // Include custom headers here.
 #include "common_utils.hpp"
 #include "amcdata_storagestate.hpp"
 
 #include "common_chrono.hpp"
+#include <vector>
 #include "PicoSHA2/picosha2.h"
 
 using namespace LibMCData::Impl;
@@ -316,7 +318,7 @@ IStorageZIPWriter* CStorage::CreateZIPStream(const std::string& sUUID, const std
         auto pWriter = std::make_shared<AMCData::CStorageWriter_ZIPStream>(sParsedUUID, m_pStorageState->getStreamPath(sUUID));
         m_pStorageState->addPartialWriter(pWriter);
 
-        return new CStorageZIPWriter(pWriter, m_pSQLHandler);
+        return new CStorageZIPWriter(pWriter, m_pSQLHandler, m_pStorageState);
     }
 
 }
@@ -528,3 +530,246 @@ void CStorage::AttachStreamToJournal(const std::string& sStreamUUID, const std::
 
     pTransaction->commit();
 }
+
+
+void CStorage::DiscardRandomWriteStream(const std::string& sUUID)
+{
+    std::string sParsedUUID = AMCCommon::CUtils::normalizeUUIDString(sUUID);
+
+    {
+        auto pWriter = m_pStorageState->findPartialWriter(sParsedUUID, false);
+        if (pWriter == nullptr)
+            throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_RANDOMWRITESTREAMNOTFOUND, "random write stream not found: " + sParsedUUID);
+
+        auto pRandomAccessWriter = dynamic_cast<AMCData::CStorageWriter_RandomAccess*> (pWriter.get());
+        if (pRandomAccessWriter == nullptr)
+            throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_STORAGESTREAMNOTRANDOMACCESS, "storage stream is not random access: " + sParsedUUID);
+
+        m_pStorageState->deletePartialWriter(sParsedUUID);
+
+        // An unfinished writer deletes its file when the last reference is released at the end of this scope.
+    }
+
+    auto pTransaction = m_pSQLHandler->beginTransaction();
+
+    auto pLinkStatement = pTransaction->prepareStatement("DELETE FROM journal_tempstreams WHERE streamuuid=?");
+    pLinkStatement->setString(1, sParsedUUID);
+    pLinkStatement->execute();
+    pLinkStatement = nullptr;
+
+    auto pStreamStatement = pTransaction->prepareStatement("DELETE FROM storage_streams WHERE uuid=? AND status=?");
+    pStreamStatement->setString(1, sParsedUUID);
+    pStreamStatement->setString(2, AMCData::CStorageState::storageStreamStatusToString(AMCData::eStorageStreamStatus::sssNew));
+    pStreamStatement->execute();
+    pStreamStatement = nullptr;
+
+    pTransaction->commit();
+}
+
+LibMCData_uint64 CStorage::GetDataCaptureStorageSize()
+{
+    return CDataCapture::getTotalStoredSize(m_pSQLHandler);
+}
+
+LibMCData_uint32 CStorage::EnforceDataCaptureStorageLimit(const LibMCData_uint64 nLimitInBytes)
+{
+    return CDataCapture::enforceStorageLimit(m_pSQLHandler, m_pStorageState, nLimitInBytes);
+}
+
+void CStorage::GetDownloadTicketDetails(const std::string& sTicketUUID, std::string& sStreamUUID, std::string& sClientFileName, std::string& sSessionUUID, std::string& sUserUUID, LibMCData_uint64& nCreationTimeStamp, bool& bRevoked)
+{
+    std::string sNormalizedTicketUUID = AMCCommon::CUtils::normalizeUUIDString(sTicketUUID);
+
+    std::string sTicketQuery = "SELECT streamuuid, clientfilename, sessionuuid, useruuid, timestamp, revoked FROM storage_downloadtickets WHERE ticketuuid=?";
+    auto pTicketStatement = m_pSQLHandler->prepareStatement(sTicketQuery);
+    pTicketStatement->setString(1, sNormalizedTicketUUID);
+    if (!pTicketStatement->nextRow())
+        throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_DOWNLOADTICKETNOTFOUND, "download ticket not found: " + sNormalizedTicketUUID);
+
+    sStreamUUID = pTicketStatement->getColumnString(1);
+    sClientFileName = pTicketStatement->getColumnString(2);
+    sSessionUUID = pTicketStatement->getColumnString(3);
+    sUserUUID = pTicketStatement->getColumnString(4);
+    std::string sTimestamp = pTicketStatement->getColumnString(5);
+    bRevoked = (pTicketStatement->getColumnInt(6) != 0);
+    pTicketStatement = nullptr;
+
+    nCreationTimeStamp = 0;
+    if (!sTimestamp.empty())
+        nCreationTimeStamp = AMCCommon::CChrono::parseISO8601TimeUTC(sTimestamp);
+}
+
+LibMCData_uint32 CStorage::RevokeDownloadTicketsOfStream(const std::string& sStreamUUID)
+{
+    std::string sNormalizedStreamUUID = AMCCommon::CUtils::normalizeUUIDString(sStreamUUID);
+
+    auto pTransaction = m_pSQLHandler->beginTransaction();
+
+    uint32_t nCount = 0;
+    auto pCountStatement = pTransaction->prepareStatement("SELECT COUNT(*) FROM storage_downloadtickets WHERE streamuuid=? AND revoked=0");
+    pCountStatement->setString(1, sNormalizedStreamUUID);
+    if (pCountStatement->nextRow())
+        nCount = (uint32_t)pCountStatement->getColumnInt64(1);
+    pCountStatement = nullptr;
+
+    auto pUpdateStatement = pTransaction->prepareStatement("UPDATE storage_downloadtickets SET revoked=1 WHERE streamuuid=? AND revoked=0");
+    pUpdateStatement->setString(1, sNormalizedStreamUUID);
+    pUpdateStatement->execute();
+    pUpdateStatement = nullptr;
+
+    pTransaction->commit();
+
+    return nCount;
+}
+
+std::string CStorage::LogDownloadStart(const std::string& sTicketUUID, const std::string& sIPAddress, const LibMCData_uint64 nAbsoluteTimeStamp)
+{
+    std::string sNormalizedTicketUUID = AMCCommon::CUtils::normalizeUUIDString(sTicketUUID);
+    std::string sTimestamp = AMCCommon::CChrono::convertToISO8601TimeUTC(nAbsoluteTimeStamp);
+    std::string sDownloadUUID = AMCCommon::CUtils::createUUID();
+
+    auto pTransaction = m_pSQLHandler->beginTransaction();
+
+    auto pTicketStatement = pTransaction->prepareStatement("SELECT ticketuuid FROM storage_downloadtickets WHERE ticketuuid=?");
+    pTicketStatement->setString(1, sNormalizedTicketUUID);
+    if (!pTicketStatement->nextRow())
+        throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_DOWNLOADTICKETNOTFOUND, "download ticket not found: " + sNormalizedTicketUUID);
+    pTicketStatement = nullptr;
+
+    auto pDownloadStatement = pTransaction->prepareStatement("INSERT INTO storage_downloads (downloaduuid, ticketuuid, ipaddress, timestamp) VALUES (?, ?, ?, ?)");
+    pDownloadStatement->setString(1, sDownloadUUID);
+    pDownloadStatement->setString(2, sNormalizedTicketUUID);
+    pDownloadStatement->setString(3, sIPAddress);
+    pDownloadStatement->setString(4, sTimestamp);
+    pDownloadStatement->execute();
+    pDownloadStatement = nullptr;
+
+    pTransaction->commit();
+
+    return sDownloadUUID;
+}
+
+void CStorage::LogDownloadFinish(const std::string& sDownloadUUID, const LibMCData_uint64 nSentBytes, const bool bSuccess, const LibMCData_uint64 nAbsoluteTimeStamp)
+{
+    std::string sNormalizedDownloadUUID = AMCCommon::CUtils::normalizeUUIDString(sDownloadUUID);
+    std::string sTimestamp = AMCCommon::CChrono::convertToISO8601TimeUTC(nAbsoluteTimeStamp);
+
+    auto pTransaction = m_pSQLHandler->beginTransaction();
+
+    auto pSelectStatement = pTransaction->prepareStatement("SELECT downloaduuid FROM storage_downloads WHERE downloaduuid=?");
+    pSelectStatement->setString(1, sNormalizedDownloadUUID);
+    if (!pSelectStatement->nextRow())
+        throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_DOWNLOADENTRYNOTFOUND, "download entry not found: " + sNormalizedDownloadUUID);
+    pSelectStatement = nullptr;
+
+    auto pUpdateStatement = pTransaction->prepareStatement("UPDATE storage_downloads SET sentbytes=?, success=?, finishedtimestamp=? WHERE downloaduuid=?");
+    pUpdateStatement->setInt64(1, (int64_t)nSentBytes);
+    pUpdateStatement->setInt(2, bSuccess ? 1 : 0);
+    pUpdateStatement->setString(3, sTimestamp);
+    pUpdateStatement->setString(4, sNormalizedDownloadUUID);
+    pUpdateStatement->execute();
+    pUpdateStatement = nullptr;
+
+    pTransaction->commit();
+}
+
+void CStorage::deleteStreamInternal(const std::string& sNormalizedUUID, bool bOnlyIfNew)
+{
+    auto pTransaction = m_pSQLHandler->beginTransaction();
+
+    auto pLinkStatement = pTransaction->prepareStatement("DELETE FROM journal_tempstreams WHERE streamuuid=?");
+    pLinkStatement->setString(1, sNormalizedUUID);
+    pLinkStatement->execute();
+    pLinkStatement = nullptr;
+
+    auto pTicketStatement = pTransaction->prepareStatement("UPDATE storage_downloadtickets SET revoked=1 WHERE streamuuid=?");
+    pTicketStatement->setString(1, sNormalizedUUID);
+    pTicketStatement->execute();
+    pTicketStatement = nullptr;
+
+    if (bOnlyIfNew) {
+        auto pStreamStatement = pTransaction->prepareStatement("DELETE FROM storage_streams WHERE uuid=? AND status=?");
+        pStreamStatement->setString(1, sNormalizedUUID);
+        pStreamStatement->setString(2, AMCData::CStorageState::storageStreamStatusToString(AMCData::eStorageStreamStatus::sssNew));
+        pStreamStatement->execute();
+        pStreamStatement = nullptr;
+    }
+    else {
+        auto pStreamStatement = pTransaction->prepareStatement("DELETE FROM storage_streams WHERE uuid=?");
+        pStreamStatement->setString(1, sNormalizedUUID);
+        pStreamStatement->execute();
+        pStreamStatement = nullptr;
+    }
+
+    pTransaction->commit();
+
+    AMCCommon::CUtils::deleteFileFromDisk(m_pStorageState->getStreamPath(sNormalizedUUID), false);
+}
+
+void CStorage::DeleteStream(const std::string& sUUID)
+{
+    std::string sParsedUUID = AMCCommon::CUtils::normalizeUUIDString(sUUID);
+
+    if (m_pStorageState->hasPartialWriter(sParsedUUID))
+        throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_STREAMHASACTIVEWRITER, "storage stream is still being written: " + sParsedUUID);
+
+    auto pStreamStatement = m_pSQLHandler->prepareStatement("SELECT uuid FROM storage_streams WHERE uuid=?");
+    pStreamStatement->setString(1, sParsedUUID);
+    if (!pStreamStatement->nextRow())
+        throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_STORAGESTREAMNOTFOUND, "storage stream not found: " + sParsedUUID);
+    pStreamStatement = nullptr;
+
+    // Streams that belong to a build job or a build execution are part of that data and are never deleted here.
+    auto pJobDataStatement = m_pSQLHandler->prepareStatement("SELECT uuid FROM buildjobdata WHERE storagestreamuuid=?");
+    pJobDataStatement->setString(1, sParsedUUID);
+    if (pJobDataStatement->nextRow())
+        throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDPARAM, "storage stream is attached to a build job: " + sParsedUUID);
+    pJobDataStatement = nullptr;
+
+    auto pExecutionDataStatement = m_pSQLHandler->prepareStatement("SELECT uuid FROM buildjobexecutiondata WHERE storagestreamuuid=?");
+    pExecutionDataStatement->setString(1, sParsedUUID);
+    if (pExecutionDataStatement->nextRow())
+        throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDPARAM, "storage stream is attached to a build execution: " + sParsedUUID);
+    pExecutionDataStatement = nullptr;
+
+    deleteStreamInternal(sParsedUUID, false);
+}
+
+LibMCData_uint32 CStorage::DiscardUnfinishedZIPStreams()
+{
+    std::vector<std::string> streamUUIDs;
+
+    auto pStatement = m_pSQLHandler->prepareStatement("SELECT uuid FROM storage_streams WHERE mimetype=? AND status=?");
+    pStatement->setString(1, "application/zip");
+    pStatement->setString(2, AMCData::CStorageState::storageStreamStatusToString(AMCData::eStorageStreamStatus::sssNew));
+    while (pStatement->nextRow()) {
+        std::string sStreamUUID = pStatement->getColumnString(1);
+        if (!m_pStorageState->hasPartialWriter(sStreamUUID))
+            streamUUIDs.push_back(sStreamUUID);
+    }
+    pStatement = nullptr;
+
+    for (auto& sStreamUUID : streamUUIDs)
+        deleteStreamInternal(sStreamUUID, true);
+
+    return (uint32_t)streamUUIDs.size();
+}
+
+std::string CStorage::ListStreamUUIDsByName(const std::string& sName)
+{
+    if (sName.empty())
+        throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDPARAM);
+
+    std::string sResult;
+
+    auto pStatement = m_pSQLHandler->prepareStatement("SELECT uuid FROM storage_streams WHERE name=? AND status=? ORDER BY timestamp DESC");
+    pStatement->setString(1, sName);
+    pStatement->setString(2, AMCData::CStorageState::storageStreamStatusToString(AMCData::eStorageStreamStatus::sssValidated));
+    while (pStatement->nextRow()) {
+        if (!sResult.empty())
+            sResult += ",";
+        sResult += pStatement->getColumnString(1);
+    }
+
+    return sResult;
+}
diff --git a/Implementation/LibMCData/libmcdata_storage.hpp b/Implementation/LibMCData/libmcdata_storage.hpp
index 601972efe..1a4850656 100644
--- a/Implementation/LibMCData/libmcdata_storage.hpp
+++ b/Implementation/LibMCData/libmcdata_storage.hpp
@@ -115,6 +115,31 @@ class CStorage : public virtual IStorage, public virtual CBase {
     void RequestDownloadTicket(const std::string& sTicketUUID, const std::string& sIPAddress, const LibMCData_uint64 nAbsoluteTimeStamp, std::string& sStreamUUID, std::string& sClientFileName, std::string& sSessionUUID, std::string& sUserUUID) override;
 
     void AttachStreamToJournal(const std::string& sStreamUUID, const std::string& sJournalUUID) override;
+
+    void DiscardRandomWriteStream(const std::string& sUUID) override;
+
+    LibMCData_uint64 GetDataCaptureStorageSize() override;
+
+    LibMCData_uint32 EnforceDataCaptureStorageLimit(const LibMCData_uint64 nLimitInBytes) override;
+
+    void GetDownloadTicketDetails(const std::string& sTicketUUID, std::string& sStreamUUID, std::string& sClientFileName, std::string& sSessionUUID, std::string& sUserUUID, LibMCData_uint64& nCreationTimeStamp, bool& bRevoked) override;
+
+    LibMCData_uint32 RevokeDownloadTicketsOfStream(const std::string& sStreamUUID) override;
+
+    std::string LogDownloadStart(const std::string& sTicketUUID, const std::string& sIPAddress, const LibMCData_uint64 nAbsoluteTimeStamp) override;
+
+    void LogDownloadFinish(const std::string& sDownloadUUID, const LibMCData_uint64 nSentBytes, const bool bSuccess, const LibMCData_uint64 nAbsoluteTimeStamp) override;
+
+    void DeleteStream(const std::string& sUUID) override;
+
+    LibMCData_uint32 DiscardUnfinishedZIPStreams() override;
+
+    std::string ListStreamUUIDsByName(const std::string& sName) override;
+
+private:
+
+    // Removes the database entries of a stream and its file. The caller has checked that no writer is active.
+    void deleteStreamInternal(const std::string& sNormalizedUUID, bool bOnlyIfNew);
 };
 
 } // namespace Impl
diff --git a/Implementation/LibMCData/libmcdata_storagestream.cpp b/Implementation/LibMCData/libmcdata_storagestream.cpp
index 7c6254cc3..abce569bb 100644
--- a/Implementation/LibMCData/libmcdata_storagestream.cpp
+++ b/Implementation/LibMCData/libmcdata_storagestream.cpp
@@ -44,8 +44,11 @@ using namespace LibMCData::Impl;
  Class definition of CStorageStream 
 **************************************************************************************************************************/
 
-uint32_t storageStream_ReadCallback(void* pBuffer, uint64_t nSize, void* pUserData)
+// The signatures match LibMCData::StreamReadCallback and StreamSeekCallback: the error code is
+// returned through the pointer argument, so that callers see read failures instead of silent success.
+void storageStream_ReadCallback(void* pBuffer, uint64_t nSize, void* pUserData, uint32_t* pErrorCode)
 {
+	uint32_t nErrorCode = LIBMCDATA_SUCCESS;
 	try {
 		if (pBuffer == nullptr)
 			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDPARAM);
@@ -61,20 +64,21 @@ uint32_t storageStream_ReadCallback(void* pBuffer, uint64_t nSize, void* pUserDa
 		auto pImportStream = pCallbackRecord->m_pStream->getImportStream();
 		pImportStream->readBuffer((uint8_t*) pBuffer, nSize, true);
 
-		return LIBMCDATA_SUCCESS;
-
 	}
 	catch (ELibMCDataInterfaceException& E) {
-		return E.getErrorCode();
+		nErrorCode = E.getErrorCode();
 	}
 	catch (...) {
-		return LIBMCDATA_ERROR_GENERICEXCEPTION;
+		nErrorCode = LIBMCDATA_ERROR_GENERICEXCEPTION;
 	}
-		
+
+	if (pErrorCode != nullptr)
+		*pErrorCode = nErrorCode;
 }
 
-uint32_t storageStream_SeekCallback(uint64_t nPosition, void* pUserData)
+void storageStream_SeekCallback(uint64_t nPosition, void* pUserData, uint32_t* pErrorCode)
 {
+	uint32_t nErrorCode = LIBMCDATA_SUCCESS;
 	try {
 		if (pUserData == nullptr)
 			throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDPARAM);
@@ -87,16 +91,16 @@ uint32_t storageStream_SeekCallback(uint64_t nPosition, void* pUserData)
 
 		auto pImportStream = pCallbackRecord->m_pStream->getImportStream();
 		pImportStream->seekPosition(nPosition, true);
-
-		return LIBMCDATA_SUCCESS;
 	}
 	catch (ELibMCDataInterfaceException& E) {
-		return E.getErrorCode();
+		nErrorCode = E.getErrorCode();
 	}
 	catch (...) {
-		return LIBMCDATA_ERROR_GENERICEXCEPTION;
+		nErrorCode = LIBMCDATA_ERROR_GENERICEXCEPTION;
 	}
 
+	if (pErrorCode != nullptr)
+		*pErrorCode = nErrorCode;
 }
 
 
diff --git a/Implementation/LibMCData/libmcdata_storagezipwriter.cpp b/Implementation/LibMCData/libmcdata_storagezipwriter.cpp
index 4411e5ae3..105f4818e 100644
--- a/Implementation/LibMCData/libmcdata_storagezipwriter.cpp
+++ b/Implementation/LibMCData/libmcdata_storagezipwriter.cpp
@@ -32,6 +32,7 @@ Abstract: This is a stub class definition of CStorageZIPWriter
 */
 
 #include "libmcdata_storagezipwriter.hpp"
+#include "common_utils.hpp"
 #include "libmcdata_interfaceexception.hpp"
 
 // Include custom headers here.
@@ -44,44 +45,88 @@ using namespace LibMCData::Impl;
 **************************************************************************************************************************/
 
 
-CStorageZIPWriter::CStorageZIPWriter(AMCData::PStorageWriter_ZIPStream pStorageWriter, AMCData::PSQLHandler pSQLHandler)
-	: m_pStorageWriter (pStorageWriter), m_pSQLHandler (pSQLHandler)
+CStorageZIPWriter::CStorageZIPWriter(AMCData::PStorageWriter_ZIPStream pStorageWriter, AMCData::PSQLHandler pSQLHandler, AMCData::PStorageState pStorageState)
+	: m_pStorageWriter (pStorageWriter), m_pSQLHandler (pSQLHandler), m_pStorageState (pStorageState)
 {
 	if (pStorageWriter.get () == nullptr)
 		throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDPARAM);
 	if (pSQLHandler.get() == nullptr)
-		throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDPARAM);	
+		throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDPARAM);
+	if (pStorageState.get() == nullptr)
+		throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_INVALIDPARAM);
 
 }
 
 CStorageZIPWriter::~CStorageZIPWriter()
 {
+	if ((m_pStorageWriter.get() != nullptr) && (!m_pStorageWriter->isFinalized()))
+		m_pStorageState->deletePartialWriter(m_pStorageWriter->getUUID());
+
+	m_pStorageWriter = nullptr;
+}
+
+AMCData::CStorageWriter_ZIPStream* CStorageZIPWriter::getWriter()
+{
+	if (m_pStorageWriter.get() == nullptr)
+		throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_ZIPWRITINGALREADYFINISHED, "ZIP stream has been discarded");
+
+	return m_pStorageWriter.get();
+}
+
+void CStorageZIPWriter::Discard()
+{
+	if (m_pStorageWriter.get() == nullptr)
+		return;
+
+	if (m_pStorageWriter->isFinalized())
+		throw ELibMCDataInterfaceException(LIBMCDATA_ERROR_ZIPSTREAMALREADYFINISHED, "ZIP stream has already been finished: " + m_pStorageWriter->getUUID());
+
+	std::string sUUID = m_pStorageWriter->getUUID();
+	m_pStorageState->deletePartialWriter(sUUID);
+
+	// The last reference closes the file; an unfinished writer deletes it.
 	m_pStorageWriter = nullptr;
+	AMCCommon::CUtils::deleteFileFromDisk(m_pStorageState->getStreamPath(sUUID), false);
+
+	auto pTransaction = m_pSQLHandler->beginTransaction();
+
+	auto pLinkStatement = pTransaction->prepareStatement("DELETE FROM journal_tempstreams WHERE streamuuid=?");
+	pLinkStatement->setString(1, sUUID);
+	pLinkStatement->execute();
+	pLinkStatement = nullptr;
+
+	auto pStreamStatement = pTransaction->prepareStatement("DELETE FROM storage_streams WHERE uuid=? AND status=?");
+	pStreamStatement->setString(1, sUUID);
+	pStreamStatement->setString(2, AMCData::CStorageState::storageStreamStatusToString(AMCData::eStorageStreamStatus::sssNew));
+	pStreamStatement->execute();
+	pStreamStatement = nullptr;
+
+	pTransaction->commit();
 }
 
 LibMCData_uint32 CStorageZIPWriter::StartNewEntry(const std::string & sFileName, const LibMCData_uint64 nAbsoluteTimeStamp)
 {
-	return m_pStorageWriter->startNewEntry(sFileName, nAbsoluteTimeStamp);
+	return getWriter()->startNewEntry(sFileName, nAbsoluteTimeStamp);
 }
 
 void CStorageZIPWriter::FinishCurrentEntry()
 {
-	m_pStorageWriter->finishCurrentEntry();
+	getWriter()->finishCurrentEntry();
 }
 
 LibMCData_uint32 CStorageZIPWriter::GetOpenEntryID()
 {
-	return m_pStorageWriter->getOpenEntryID();
+	return getWriter()->getOpenEntryID();
 }
 
 void CStorageZIPWriter::WriteData(const LibMCData_uint32 nEntryID, const LibMCData_uint64 nDataBufferSize, const LibMCData_uint8 * pDataBuffer)
 {
-	m_pStorageWriter->writeToCurrentEntry(nEntryID, pDataBuffer, nDataBufferSize);
+	getWriter()->writeToCurrentEntry(nEntryID, pDataBuffer, nDataBufferSize);
 }
 
 LibMCData_uint64 CStorageZIPWriter::GetEntrySize(const LibMCData_uint32 nEntryID)
 {
-	return m_pStorageWriter->getEntrySize(nEntryID);
+	return getWriter()->getEntrySize(nEntryID);
 }
 
 void CStorageZIPWriter::Finish()
@@ -89,9 +134,9 @@ void CStorageZIPWriter::Finish()
 	std::string sCalculatedSHA256;
 	std::string sCalculatedBlockSHA256;
 	
-	m_pStorageWriter->finalize (sCalculatedSHA256, sCalculatedBlockSHA256);
+	getWriter()->finalize (sCalculatedSHA256, sCalculatedBlockSHA256);
 
-	uint64_t nSize = m_pStorageWriter->getZIPStreamSize();
+	uint64_t nSize = getWriter()->getZIPStreamSize();
 
 	std::string sUpdateQuery = "UPDATE storage_streams SET size=?, status=?, sha2=?, sha256_block64k=? WHERE uuid=? AND status=?";
 	auto pUpdateStatement = m_pSQLHandler->prepareStatement(sUpdateQuery);
@@ -99,19 +144,21 @@ void CStorageZIPWriter::Finish()
 	pUpdateStatement->setString(2, AMCData::CStorageState::storageStreamStatusToString(AMCData::eStorageStreamStatus::sssValidated));
 	pUpdateStatement->setString(3, sCalculatedSHA256);
 	pUpdateStatement->setString(4, sCalculatedBlockSHA256);
-	pUpdateStatement->setString(5, m_pStorageWriter->getUUID ());
+	pUpdateStatement->setString(5, getWriter()->getUUID ());
 	pUpdateStatement->setString(6, AMCData::CStorageState::storageStreamStatusToString(AMCData::eStorageStreamStatus::sssNew));
 	pUpdateStatement->execute();
 	pUpdateStatement = nullptr;
 
+	// The finished writer is no longer a partial writer; keeping it would hold the file reference forever.
+	m_pStorageState->deletePartialWriter(m_pStorageWriter->getUUID());
 }
 
 bool CStorageZIPWriter::IsFinished()
 {
-	return m_pStorageWriter->isFinalized ();
+	return getWriter()->isFinalized ();
 }
 
 LibMCData_uint64 CStorageZIPWriter::GetZIPStreamSize()
 {
-	return m_pStorageWriter->getZIPStreamSize();
+	return getWriter()->getZIPStreamSize();
 }
\ No newline at end of file
diff --git a/Implementation/LibMCData/libmcdata_storagezipwriter.hpp b/Implementation/LibMCData/libmcdata_storagezipwriter.hpp
index a9f0a57d2..6a9ed9749 100644
--- a/Implementation/LibMCData/libmcdata_storagezipwriter.hpp
+++ b/Implementation/LibMCData/libmcdata_storagezipwriter.hpp
@@ -47,6 +47,7 @@ Abstract: This is the class declaration of CStorageZIPWriter
 
 // Include custom headers here.
 #include "amcdata_storagewriter.hpp"
+#include "amcdata_storagestate.hpp"
 #include "amcdata_sqlhandler.hpp"
 
 namespace LibMCData {
@@ -62,13 +63,21 @@ class CStorageZIPWriter : public virtual IStorageZIPWriter, public virtual CBase
 
 	AMCData::PStorageWriter_ZIPStream m_pStorageWriter;
 	AMCData::PSQLHandler m_pSQLHandler;
+	AMCData::PStorageState m_pStorageState;
+
+	// Fails if the stream has been discarded.
+	AMCData::CStorageWriter_ZIPStream* getWriter();
 
 public:
 
-	CStorageZIPWriter(AMCData::PStorageWriter_ZIPStream pStorageWriter, AMCData::PSQLHandler pSQLHandler);
+	CStorageZIPWriter(AMCData::PStorageWriter_ZIPStream pStorageWriter, AMCData::PSQLHandler pSQLHandler, AMCData::PStorageState pStorageState);
 
+	// An unfinished writer is removed from the storage state, so that its file is deleted with the last
+	// reference. The database entry of such a stream is removed by DiscardUnfinishedZIPStreams.
 	virtual ~CStorageZIPWriter();
 
+	void Discard() override;
+
 	LibMCData_uint32 StartNewEntry(const std::string & sFileName, const LibMCData_uint64 nAbsoluteTimeStamp) override;
 
 	void FinishCurrentEntry() override;
diff --git a/Implementation/LibMCEnv/libmcenv_buildexecution.cpp b/Implementation/LibMCEnv/libmcenv_buildexecution.cpp
index 1623e5d73..e945569f8 100644
--- a/Implementation/LibMCEnv/libmcenv_buildexecution.cpp
+++ b/Implementation/LibMCEnv/libmcenv_buildexecution.cpp
@@ -41,6 +41,9 @@ Abstract: This is a stub class definition of CBuildExecution
 #include "libmcenv_streamreader.hpp"
 #include "libmcenv_datatable.hpp"
 #include "libmcenv_tempstreamwriter.hpp"
+#include "libmcenv_datacapture.hpp"
+#include "libmcenv_datacaptureoptions.hpp"
+#include "libmcenv_datatablereader.hpp"
 #include "libmcenv_journalhandler_historic.hpp"
 #include "libmcenv_journalhandler_current.hpp"
 
@@ -527,3 +530,92 @@ IJournalHandler* CBuildExecution::LoadAttachedJournal(const LibMCEnv_uint32 nCac
 	}
 
 }
+
+
+IDataCaptureOptions* CBuildExecution::CreateDataCaptureOptions()
+{
+	return new CDataCaptureOptions();
+}
+
+IDataCapture* CBuildExecution::CreateDataCapture(const std::string& sIdentifier, const std::string& sName, IDataCaptureOptions* pOptions, const std::string& sUserUUID)
+{
+	if (sName.empty())
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_EMPTYDATACAPTURENAME);
+	if (sIdentifier.empty())
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_EMPTYDATACAPTUREIDENTIFIER);
+	if (!AMCCommon::CUtils::stringIsValidAlphanumericNameString(sIdentifier))
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDDATACAPTUREIDENTIFIER, "invalid data capture identifier: " + sIdentifier);
+
+	// A capture belongs to a running execution and ends with it.
+	if (m_pExecution->GetStatus() != LibMCData::eBuildJobExecutionStatus::InProcess)
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DATACAPTUREEXECUTIONNOTINPROCESS);
+
+	sDataCaptureSettings settings;
+	if (pOptions != nullptr) {
+		auto pOptionsImpl = dynamic_cast<CDataCaptureOptions*> (pOptions);
+		if (pOptionsImpl == nullptr)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+
+		settings = pOptionsImpl->getSettings();
+	}
+
+	std::string sNormalizedUserUUID;
+	if (!sUserUUID.empty())
+		sNormalizedUserUUID = AMCCommon::CUtils::normalizeUUIDString(sUserUUID);
+	else
+		sNormalizedUserUUID = AMCCommon::CUtils::createEmptyUUID();
+
+	auto nAbsoluteTimeStamp = m_pGlobalChrono->getUTCTimeStampInMicrosecondsSince1970();
+
+	auto pManifest = m_pExecution->CreateDataCapture(sIdentifier, sName, sNormalizedUserUUID, nAbsoluteTimeStamp);
+	auto pInstance = std::make_shared<CDataCaptureInstance>(m_pDataModel, pManifest, settings, m_pGlobalChrono, sNormalizedUserUUID);
+
+	return new CDataCapture(pInstance);
+}
+
+bool CBuildExecution::HasDataCapture(const std::string& sIdentifier)
+{
+	return m_pExecution->HasDataCapture(sIdentifier);
+}
+
+LibMCEnv_uint64 CBuildExecution::GetDataCaptureRowCount(const std::string& sIdentifier)
+{
+	auto pManifest = m_pExecution->RetrieveDataCapture(sIdentifier);
+	return pManifest->GetRowCount();
+}
+
+LibMCEnv_uint32 CBuildExecution::GetDataCaptureSegmentCount(const std::string& sIdentifier)
+{
+	auto pManifest = m_pExecution->RetrieveDataCapture(sIdentifier);
+	return pManifest->GetSegmentCount();
+}
+
+IDataTable* CBuildExecution::LoadDataCaptureSegment(const std::string& sIdentifier, const LibMCEnv_uint32 nSegmentIndex)
+{
+	auto pManifest = m_pExecution->RetrieveDataCapture(sIdentifier);
+
+	if (nSegmentIndex >= pManifest->GetSegmentCount())
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDDATACAPTURESEGMENTINDEX, "invalid data capture segment index: " + std::to_string(nSegmentIndex));
+
+	std::string sStreamUUID;
+	uint64_t nFirstRow = 0;
+	uint64_t nRowCount = 0;
+	uint64_t nSizeInBytes = 0;
+	bool bIsPurged = false;
+	pManifest->GetSegmentInformation(nSegmentIndex, sStreamUUID, nFirstRow, nRowCount, nSizeInBytes, bIsPurged);
+
+	if (bIsPurged)
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DATACAPTURESEGMENTPURGED, "data capture segment has been deleted by retention: " + std::to_string(nSegmentIndex));
+
+	auto pStorage = m_pDataModel->CreateStorage();
+	auto pStorageStream = pStorage->RetrieveStream(sStreamUUID);
+
+	auto pStreamReader = std::make_unique<CStreamReader>(pStorage, pStorageStream);
+	return CDataTable::makeFromStream(pStreamReader.get(), m_pToolpathHandler);
+}
+
+IDataTableReader* CBuildExecution::OpenDataCaptureReader(const std::string& sIdentifier)
+{
+	auto pManifest = m_pExecution->RetrieveDataCapture(sIdentifier);
+	return CDataTableReader::makeFromManifest(m_pDataModel, pManifest, m_pToolpathHandler);
+}
diff --git a/Implementation/LibMCEnv/libmcenv_buildexecution.hpp b/Implementation/LibMCEnv/libmcenv_buildexecution.hpp
index 659362337..02aa5935e 100644
--- a/Implementation/LibMCEnv/libmcenv_buildexecution.hpp
+++ b/Implementation/LibMCEnv/libmcenv_buildexecution.hpp
@@ -160,6 +160,20 @@ class CBuildExecution : public virtual IBuildExecution, public virtual CBase {
 
 	IJournalHandler* LoadAttachedJournal(const LibMCEnv_uint32 nCacheMemoryQuotaInMegabytes) override;
 
+	IDataCaptureOptions* CreateDataCaptureOptions() override;
+
+	IDataCapture* CreateDataCapture(const std::string& sIdentifier, const std::string& sName, IDataCaptureOptions* pOptions, const std::string& sUserUUID) override;
+
+	bool HasDataCapture(const std::string& sIdentifier) override;
+
+	LibMCEnv_uint64 GetDataCaptureRowCount(const std::string& sIdentifier) override;
+
+	LibMCEnv_uint32 GetDataCaptureSegmentCount(const std::string& sIdentifier) override;
+
+	IDataTable* LoadDataCaptureSegment(const std::string& sIdentifier, const LibMCEnv_uint32 nSegmentIndex) override;
+
+	IDataTableReader* OpenDataCaptureReader(const std::string& sIdentifier) override;
+
 };
 
 } // namespace Impl
diff --git a/Implementation/LibMCEnv/libmcenv_datacapture.cpp b/Implementation/LibMCEnv/libmcenv_datacapture.cpp
new file mode 100644
index 000000000..17cf57491
--- /dev/null
+++ b/Implementation/LibMCEnv/libmcenv_datacapture.cpp
@@ -0,0 +1,223 @@
+/*++
+
+Copyright (C) 2020 Autodesk Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Autodesk Inc. nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL AUTODESK INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+Abstract: This is the class definition of CDataCapture
+
+*/
+
+#include "libmcenv_datacapture.hpp"
+#include "libmcenv_interfaceexception.hpp"
+
+// Include custom headers here.
+#include "libmcenv_datacapturechunk.hpp"
+#include "libmcenv_datatable.hpp"
+
+using namespace LibMCEnv::Impl;
+
+/*************************************************************************************************************************
+ Class definition of CDataCapture
+**************************************************************************************************************************/
+
+CDataCapture::CDataCapture(PDataCaptureInstance pInstance)
+	: m_pInstance(pInstance)
+{
+	if (pInstance.get() == nullptr)
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDPARAM);
+}
+
+CDataCapture::~CDataCapture()
+{
+
+}
+
+std::string CDataCapture::GetUUID()
+{
+	return m_pInstance->getUUID();
+}
+
+std::string CDataCapture::GetIdentifier()
+{
+	return m_pInstance->getIdentifier();
+}
+
+std::string CDataCapture::GetName()
+{
+	return m_pInstance->getName();
+}
+
+LibMCEnv::eDataCaptureStatus CDataCapture::GetStatus()
+{
+	return m_pInstance->getStatus();
+}
+
+void CDataCapture::AddColumn(const std::string & sIdentifier, const std::string & sDescription, const LibMCEnv::eDataTableColumnType eColumnType)
+{
+	m_pInstance->addColumn(sIdentifier, sDescription, eColumnType);
+}
+
+LibMCEnv_uint32 CDataCapture::GetColumnCount()
+{
+	return m_pInstance->getColumnCount();
+}
+
+IDataCaptureChunk * CDataCapture::BeginChunk()
+{
+	auto pBuffer = m_pInstance->beginChunk();
+	return new CDataCaptureChunk(m_pInstance, pBuffer);
+}
+
+void CDataCapture::CommitChunk(IDataCaptureChunk* pChunkInstance)
+{
+	auto pChunk = dynamic_cast<CDataCaptureChunk*> (pChunkInstance);
+	if (pChunk == nullptr)
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DATACAPTURECHUNKINVALID);
+
+	if (!pChunk->belongsTo(m_pInstance.get()))
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DATACAPTURECHUNKINVALID, "data capture chunk belongs to another capture");
+
+	// The chunk object stays valid if the commit is rejected, so that the producer can complete it.
+	m_pInstance->commitChunk(pChunk->getBuffer());
+	pChunk->invalidate();
+}
+
+void CDataCapture::Flush()
+{
+	m_pInstance->flush();
+}
+
+LibMCEnv_uint64 CDataCapture::GetCapturedRowCount()
+{
+	return m_pInstance->getCapturedRowCount();
+}
+
+LibMCEnv_uint64 CDataCapture::GetStorageSizeInBytes()
+{
+	return m_pInstance->getStorageSizeInBytes();
+}
+
+LibMCEnv_uint32 CDataCapture::GetSegmentCount()
+{
+	return m_pInstance->getSegmentCount();
+}
+
+LibMCEnv_uint32 CDataCapture::GetQueuedChunkCount()
+{
+	return m_pInstance->getQueuedChunkCount();
+}
+
+LibMCEnv_uint64 CDataCapture::GetDroppedRowCount()
+{
+	return m_pInstance->getDroppedRowCount();
+}
+
+std::string CDataCapture::Finish()
+{
+	return m_pInstance->finish();
+}
+
+void CDataCapture::Abort()
+{
+	m_pInstance->abort();
+}
+
+void CDataCapture::AddColumnsFromDataTable(IDataTable* pDataTable)
+{
+	auto pTable = dynamic_cast<CDataTable*> (pDataTable);
+	if (pTable == nullptr)
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+
+	uint32_t nTableColumnCount = pTable->GetColumnCount();
+
+	// Check for clashes first, so that the schema is not left half extended.
+	auto existingColumns = m_pInstance->getColumns();
+	for (uint32_t nIndex = 0; nIndex < nTableColumnCount; nIndex++) {
+		std::string sIdentifier = pTable->getColumnByIndex(nIndex)->getIdentifier();
+		for (auto& existingColumn : existingColumns) {
+			if (existingColumn.m_sIdentifier == sIdentifier)
+				throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DUPLICATECOLUMNIDENTIFIER, "duplicate column identifier: " + sIdentifier);
+		}
+	}
+
+	for (uint32_t nIndex = 0; nIndex < nTableColumnCount; nIndex++) {
+		auto pColumn = pTable->getColumnByIndex(nIndex);
+		m_pInstance->addColumn(pColumn->getIdentifier(), pColumn->getDescription(), pColumn->getColumnType());
+	}
+}
+
+LibMCEnv_uint64 CDataCapture::AppendDataTable(IDataTable* pDataTable)
+{
+	auto pTable = dynamic_cast<CDataTable*> (pDataTable);
+	if (pTable == nullptr)
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCAST);
+
+	auto columns = m_pInstance->getColumns();
+	if (columns.empty())
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DATACAPTURECOLUMNNOTFOUND, "data capture has no columns");
+
+	// Resolve every capture column to a table column before anything is written.
+	std::vector<const uint8_t*> columnData(columns.size(), nullptr);
+	std::vector<size_t> entrySizes(columns.size(), 0);
+	uint64_t nRowCount = 0;
+
+	for (size_t nColumnIndex = 0; nColumnIndex < columns.size(); nColumnIndex++) {
+		auto& column = columns[nColumnIndex];
+
+		auto pTableColumn = pTable->findColumnByIdentifier(column.m_sIdentifier);
+		if (pTableColumn == nullptr)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DATACAPTURECOLUMNNOTFOUND, "data table has no column " + column.m_sIdentifier);
+		if ((uint32_t)pTableColumn->getColumnType() != (uint32_t)column.m_DataType)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DATACAPTURECOLUMNTYPEMISMATCH, "data table column has a different type: " + column.m_sIdentifier);
+
+		uint64_t nColumnRowCount = pTableColumn->getRowCount();
+		if (nColumnIndex == 0)
+			nRowCount = nColumnRowCount;
+		else if (nColumnRowCount != nRowCount)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DATACAPTURECHUNKINCOMPLETE, "data table columns have different row counts: " + column.m_sIdentifier);
+
+		columnData[nColumnIndex] = pTableColumn->getRawData();
+		entrySizes[nColumnIndex] = pTableColumn->getEntrySizeInBytes();
+	}
+
+	uint64_t nRowIndex = 0;
+	while (nRowIndex < nRowCount) {
+		auto pBuffer = m_pInstance->beginChunk();
+
+		uint64_t nChunkRows = nRowCount - nRowIndex;
+		if (nChunkRows > pBuffer->getCapacity())
+			nChunkRows = pBuffer->getCapacity();
+
+		for (size_t nColumnIndex = 0; nColumnIndex < columns.size(); nColumnIndex++)
+			pBuffer->setColumnValues((uint32_t)nColumnIndex, columns[nColumnIndex].m_DataType, columnData[nColumnIndex] + (size_t)nRowIndex * entrySizes[nColumnIndex], nChunkRows);
+
+		m_pInstance->commitChunk(pBuffer);
+		nRowIndex += nChunkRows;
+	}
+
+	return nRowCount;
+}
diff --git a/Implementation/LibMCEnv/libmcenv_datacapture.hpp b/Implementation/LibMCEnv/libmcenv_datacapture.hpp
new file mode 100644
index 000000000..1fbdec684
--- /dev/null
+++ b/Implementation/LibMCEnv/libmcenv_datacapture.hpp
@@ -0,0 +1,113 @@
+/*++
+
+Copyright (C) 2020 Autodesk Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Autodesk Inc. nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL AUTODESK INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+Abstract: This is the class declaration of CDataCapture
+
+*/
+
+
+#ifndef __LIBMCENV_DATACAPTURE
+#define __LIBMCENV_DATACAPTURE
+
+#include "libmcenv_interfaces.hpp"
+
+// Parent classes
+#include "libmcenv_base.hpp"
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4250)
+#endif
+
+// Include custom headers here.
+#include "libmcenv_datacaptureinstance.hpp"
+
+namespace LibMCEnv {
+namespace Impl {
+
+
+/*************************************************************************************************************************
+ Class declaration of CDataCapture
+**************************************************************************************************************************/
+
+class CDataCapture : public virtual IDataCapture, public virtual CBase {
+private:
+
+	PDataCaptureInstance m_pInstance;
+
+public:
+
+	CDataCapture(PDataCaptureInstance pInstance);
+
+	virtual ~CDataCapture();
+
+	std::string GetUUID() override;
+
+	std::string GetIdentifier() override;
+
+	std::string GetName() override;
+
+	LibMCEnv::eDataCaptureStatus GetStatus() override;
+
+	void AddColumn(const std::string & sIdentifier, const std::string & sDescription, const LibMCEnv::eDataTableColumnType eColumnType) override;
+
+	LibMCEnv_uint32 GetColumnCount() override;
+
+	IDataCaptureChunk * BeginChunk() override;
+
+	void CommitChunk(IDataCaptureChunk* pChunkInstance) override;
+
+	void Flush() override;
+
+	LibMCEnv_uint64 GetCapturedRowCount() override;
+
+	LibMCEnv_uint64 GetStorageSizeInBytes() override;
+
+	LibMCEnv_uint32 GetSegmentCount() override;
+
+	LibMCEnv_uint32 GetQueuedChunkCount() override;
+
+	LibMCEnv_uint64 GetDroppedRowCount() override;
+
+	std::string Finish() override;
+
+	void Abort() override;
+
+	void AddColumnsFromDataTable(IDataTable* pDataTable) override;
+
+	LibMCEnv_uint64 AppendDataTable(IDataTable* pDataTable) override;
+
+};
+
+} // namespace Impl
+} // namespace LibMCEnv
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+#endif // __LIBMCENV_DATACAPTURE
diff --git a/Implementation/LibMCEnv/libmcenv_datacapturechunk.cpp b/Implementation/LibMCEnv/libmcenv_datacapturechunk.cpp
new file mode 100644
index 000000000..3bacc247e
--- /dev/null
+++ b/Implementation/LibMCEnv/libmcenv_datacapturechunk.cpp
@@ -0,0 +1,157 @@
+/*++
+
+Copyright (C) 2020 Autodesk Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Autodesk Inc. nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL AUTODESK INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+Abstract: This is the class definition of CDataCaptureChunk
+
+*/
+
+#include "libmcenv_datacapturechunk.hpp"
+#include "libmcenv_interfaceexception.hpp"
+
+// Include custom headers here.
+
+
+using namespace LibMCEnv::Impl;
+
+/*************************************************************************************************************************
+ Class definition of CDataCaptureChunk
+**************************************************************************************************************************/
+
+CDataCaptureChunk::CDataCaptureChunk(PDataCaptureInstance pInstance, PDataCaptureChunkBuffer pBuffer)
+	: m_pInstance(pInstance), m_pBuffer(pBuffer)
+{
+	if (pInstance.get() == nullptr)
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDPARAM);
+	if (pBuffer.get() == nullptr)
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDPARAM);
+}
+
+CDataCaptureChunk::~CDataCaptureChunk()
+{
+
+}
+
+CDataCaptureChunkBuffer* CDataCaptureChunk::getValidBuffer()
+{
+	if (m_pBuffer.get() == nullptr)
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DATACAPTURECHUNKINVALID);
+
+	return m_pBuffer.get();
+}
+
+bool CDataCaptureChunk::belongsTo(CDataCaptureInstance* pInstance)
+{
+	return (m_pInstance.get() == pInstance);
+}
+
+PDataCaptureChunkBuffer CDataCaptureChunk::getBuffer()
+{
+	getValidBuffer();
+	return m_pBuffer;
+}
+
+void CDataCaptureChunk::invalidate()
+{
+	m_pBuffer = nullptr;
+}
+
+LibMCEnv_uint32 CDataCaptureChunk::GetCapacity()
+{
+	return getValidBuffer()->getCapacity();
+}
+
+LibMCEnv_uint32 CDataCaptureChunk::GetRowCount()
+{
+	return getValidBuffer()->getRowCount();
+}
+
+bool CDataCaptureChunk::IsFull()
+{
+	return getValidBuffer()->isFull();
+}
+
+void CDataCaptureChunk::SetDoubleColumnValues(const LibMCEnv_uint32 nColumnIndex, const LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_double * pValuesBuffer)
+{
+	getValidBuffer()->setColumnValues(nColumnIndex, AMC::eDataTableV2DataType::Double, (const uint8_t*)pValuesBuffer, nValuesBufferSize);
+}
+
+void CDataCaptureChunk::SetInt32ColumnValues(const LibMCEnv_uint32 nColumnIndex, const LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_int32 * pValuesBuffer)
+{
+	getValidBuffer()->setColumnValues(nColumnIndex, AMC::eDataTableV2DataType::Int32, (const uint8_t*)pValuesBuffer, nValuesBufferSize);
+}
+
+void CDataCaptureChunk::SetUint32ColumnValues(const LibMCEnv_uint32 nColumnIndex, const LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint32 * pValuesBuffer)
+{
+	getValidBuffer()->setColumnValues(nColumnIndex, AMC::eDataTableV2DataType::Uint32, (const uint8_t*)pValuesBuffer, nValuesBufferSize);
+}
+
+void CDataCaptureChunk::SetInt64ColumnValues(const LibMCEnv_uint32 nColumnIndex, const LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_int64 * pValuesBuffer)
+{
+	getValidBuffer()->setColumnValues(nColumnIndex, AMC::eDataTableV2DataType::Int64, (const uint8_t*)pValuesBuffer, nValuesBufferSize);
+}
+
+void CDataCaptureChunk::SetUint64ColumnValues(const LibMCEnv_uint32 nColumnIndex, const LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint64 * pValuesBuffer)
+{
+	getValidBuffer()->setColumnValues(nColumnIndex, AMC::eDataTableV2DataType::Uint64, (const uint8_t*)pValuesBuffer, nValuesBufferSize);
+}
+
+void CDataCaptureChunk::SetFloatColumnValues(const LibMCEnv_uint32 nColumnIndex, const LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_single * pValuesBuffer)
+{
+	getValidBuffer()->setColumnValues(nColumnIndex, AMC::eDataTableV2DataType::Float, (const uint8_t*)pValuesBuffer, nValuesBufferSize);
+}
+
+void CDataCaptureChunk::SetBoolColumnValues(const LibMCEnv_uint32 nColumnIndex, const LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint8 * pValuesBuffer)
+{
+	getValidBuffer()->setColumnValues(nColumnIndex, AMC::eDataTableV2DataType::Bool, (const uint8_t*)pValuesBuffer, nValuesBufferSize);
+}
+
+void CDataCaptureChunk::SetTimestampColumnValues(const LibMCEnv_uint32 nColumnIndex, const LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint64 * pValuesBuffer)
+{
+	getValidBuffer()->setColumnValues(nColumnIndex, AMC::eDataTableV2DataType::Timestamp, (const uint8_t*)pValuesBuffer, nValuesBufferSize);
+}
+
+void CDataCaptureChunk::BeginRow()
+{
+	getValidBuffer()->beginRow();
+}
+
+void CDataCaptureChunk::SetRowDoubleValue(const LibMCEnv_uint32 nColumnIndex, const LibMCEnv_double dValue)
+{
+	getValidBuffer()->setRowDoubleValue(nColumnIndex, dValue);
+}
+
+void CDataCaptureChunk::SetRowIntegerValue(const LibMCEnv_uint32 nColumnIndex, const LibMCEnv_int64 nValue)
+{
+	getValidBuffer()->setRowIntegerValue(nColumnIndex, nValue);
+}
+
+void CDataCaptureChunk::EndRow()
+{
+	getValidBuffer()->endRow();
+}
diff --git a/Implementation/LibMCEnv/libmcenv_datacapturechunk.hpp b/Implementation/LibMCEnv/libmcenv_datacapturechunk.hpp
new file mode 100644
index 000000000..a0dd8602d
--- /dev/null
+++ b/Implementation/LibMCEnv/libmcenv_datacapturechunk.hpp
@@ -0,0 +1,122 @@
+/*++
+
+Copyright (C) 2020 Autodesk Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Autodesk Inc. nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL AUTODESK INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+Abstract: This is the class declaration of CDataCaptureChunk
+
+*/
+
+
+#ifndef __LIBMCENV_DATACAPTURECHUNK
+#define __LIBMCENV_DATACAPTURECHUNK
+
+#include "libmcenv_interfaces.hpp"
+
+// Parent classes
+#include "libmcenv_base.hpp"
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4250)
+#endif
+
+// Include custom headers here.
+#include "libmcenv_datacaptureinstance.hpp"
+
+namespace LibMCEnv {
+namespace Impl {
+
+
+/*************************************************************************************************************************
+ Class declaration of CDataCaptureChunk
+**************************************************************************************************************************/
+
+class CDataCaptureChunk : public virtual IDataCaptureChunk, public virtual CBase {
+private:
+
+	// Keeps the capture alive as long as the producer holds the chunk.
+	PDataCaptureInstance m_pInstance;
+
+	// Released when the chunk has been committed.
+	PDataCaptureChunkBuffer m_pBuffer;
+
+	CDataCaptureChunkBuffer* getValidBuffer();
+
+public:
+
+	CDataCaptureChunk(PDataCaptureInstance pInstance, PDataCaptureChunkBuffer pBuffer);
+
+	virtual ~CDataCaptureChunk();
+
+	// Returns if the chunk has been borrowed from the given capture.
+	bool belongsTo(CDataCaptureInstance* pInstance);
+
+	// Returns the buffer of a chunk that has not been committed yet.
+	PDataCaptureChunkBuffer getBuffer();
+
+	// Marks the chunk as committed. All further calls fail.
+	void invalidate();
+
+	LibMCEnv_uint32 GetCapacity() override;
+
+	LibMCEnv_uint32 GetRowCount() override;
+
+	bool IsFull() override;
+
+	void SetDoubleColumnValues(const LibMCEnv_uint32 nColumnIndex, const LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_double * pValuesBuffer) override;
+
+	void SetInt32ColumnValues(const LibMCEnv_uint32 nColumnIndex, const LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_int32 * pValuesBuffer) override;
+
+	void SetUint32ColumnValues(const LibMCEnv_uint32 nColumnIndex, const LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint32 * pValuesBuffer) override;
+
+	void SetInt64ColumnValues(const LibMCEnv_uint32 nColumnIndex, const LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_int64 * pValuesBuffer) override;
+
+	void SetUint64ColumnValues(const LibMCEnv_uint32 nColumnIndex, const LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint64 * pValuesBuffer) override;
+
+	void SetFloatColumnValues(const LibMCEnv_uint32 nColumnIndex, const LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_single * pValuesBuffer) override;
+
+	void SetBoolColumnValues(const LibMCEnv_uint32 nColumnIndex, const LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint8 * pValuesBuffer) override;
+
+	void SetTimestampColumnValues(const LibMCEnv_uint32 nColumnIndex, const LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint64 * pValuesBuffer) override;
+
+	void BeginRow() override;
+
+	void SetRowDoubleValue(const LibMCEnv_uint32 nColumnIndex, const LibMCEnv_double dValue) override;
+
+	void SetRowIntegerValue(const LibMCEnv_uint32 nColumnIndex, const LibMCEnv_int64 nValue) override;
+
+	void EndRow() override;
+
+};
+
+} // namespace Impl
+} // namespace LibMCEnv
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+#endif // __LIBMCENV_DATACAPTURECHUNK
diff --git a/Implementation/LibMCEnv/libmcenv_datacaptureinstance.cpp b/Implementation/LibMCEnv/libmcenv_datacaptureinstance.cpp
new file mode 100644
index 000000000..4ef9dc1b1
--- /dev/null
+++ b/Implementation/LibMCEnv/libmcenv_datacaptureinstance.cpp
@@ -0,0 +1,1011 @@
+/*++
+
+Copyright (C) 2020 Autodesk Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Autodesk Inc. nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL AUTODESK INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+Abstract: Internal engine of a streaming data capture.
+
+*/
+
+#include "libmcenv_datacaptureinstance.hpp"
+#include "libmcenv_interfaceexception.hpp"
+#include "libmcenv_tempstreamwriter.hpp"
+
+#include "amc_constants.hpp"
+#include "common_utils.hpp"
+
+#include <cstring>
+#include <iomanip>
+#include <limits>
+#include <sstream>
+
+using namespace LibMCEnv::Impl;
+
+
+sDataCaptureSettings::sDataCaptureSettings()
+	: m_nChunkRowCount(DATACAPTURE_DEFAULTCHUNKROWCOUNT),
+	m_nSegmentSizeInBytes(DATACAPTURE_DEFAULTSEGMENTSIZE),
+	m_nMaxQueuedChunks(DATACAPTURE_DEFAULTMAXQUEUEDCHUNKS),
+	m_BackpressureMode(LibMCEnv::eDataCaptureBackpressureMode::Block),
+	m_nStorageLimitInBytes(0),
+	m_nCodec(DATATABLE_V2_CODEC_LZ4)
+{
+}
+
+
+/*************************************************************************************************************************
+ Class definition of CDataCaptureChunkBuffer
+**************************************************************************************************************************/
+
+CDataCaptureChunkBuffer::CDataCaptureChunkBuffer(const std::vector<AMC::sDataTableV2Column>& columns, uint32_t nCapacity)
+	: m_nCapacity(nCapacity), m_bRowOpen(false), m_nOpenRowIndex(0)
+{
+	if (nCapacity == 0)
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDPARAM);
+
+	for (auto& column : columns) {
+		uint32_t nEntrySize = AMC::CDataTableV2::getEntrySize(column.m_DataType);
+		m_DataTypes.push_back(column.m_DataType);
+		m_EntrySizes.push_back(nEntrySize);
+		m_ColumnData.push_back(std::vector<uint8_t>((size_t)nCapacity * nEntrySize));
+		m_ColumnRowCounts.push_back(0);
+	}
+}
+
+void CDataCaptureChunkBuffer::checkColumnIndex(uint32_t nColumnIndex) const
+{
+	if (nColumnIndex >= m_ColumnData.size())
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCOLUMNINDEX, "invalid data capture column index: " + std::to_string(nColumnIndex));
+}
+
+void CDataCaptureChunkBuffer::reset()
+{
+	for (auto& nRowCount : m_ColumnRowCounts)
+		nRowCount = 0;
+
+	m_bRowOpen = false;
+	m_nOpenRowIndex = 0;
+}
+
+uint32_t CDataCaptureChunkBuffer::getCapacity() const
+{
+	return m_nCapacity;
+}
+
+uint32_t CDataCaptureChunkBuffer::getColumnCount() const
+{
+	return (uint32_t)m_ColumnData.size();
+}
+
+uint32_t CDataCaptureChunkBuffer::getRowCount() const
+{
+	uint32_t nMaxRowCount = 0;
+	for (auto nRowCount : m_ColumnRowCounts) {
+		if (nRowCount > nMaxRowCount)
+			nMaxRowCount = nRowCount;
+	}
+
+	return nMaxRowCount;
+}
+
+bool CDataCaptureChunkBuffer::isFull() const
+{
+	return getRowCount() >= m_nCapacity;
+}
+
+void CDataCaptureChunkBuffer::setColumnValues(uint32_t nColumnIndex, AMC::eDataTableV2DataType expectedType, const uint8_t* pValues, uint64_t nValueCount)
+{
+	checkColumnIndex(nColumnIndex);
+
+	if (m_bRowOpen)
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DATACAPTUREROWALREADYOPEN);
+	if (m_DataTypes[nColumnIndex] != expectedType)
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DATACAPTURECOLUMNTYPEMISMATCH, "data capture column has a different type: " + std::to_string(nColumnIndex));
+	if (nValueCount > m_nCapacity)
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DATACAPTURECHUNKOVERFLOW, "data capture chunk capacity exceeded: " + std::to_string(nValueCount) + " > " + std::to_string(m_nCapacity));
+
+	if (nValueCount > 0) {
+		if (pValues == nullptr)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDPARAM);
+
+		auto& columnData = m_ColumnData[nColumnIndex];
+		size_t nByteCount = (size_t)nValueCount * m_EntrySizes[nColumnIndex];
+		memcpy(columnData.data(), pValues, nByteCount);
+
+		// Bool values cross the ABI as bytes; any nonzero byte is true and is stored as 1.
+		if (expectedType == AMC::eDataTableV2DataType::Bool) {
+			for (size_t nIndex = 0; nIndex < nByteCount; nIndex++)
+				columnData[nIndex] = (columnData[nIndex] != 0) ? 1 : 0;
+		}
+	}
+
+	m_ColumnRowCounts[nColumnIndex] = (uint32_t)nValueCount;
+}
+
+void CDataCaptureChunkBuffer::beginRow()
+{
+	if (m_bRowOpen)
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DATACAPTUREROWALREADYOPEN);
+	if (m_ColumnData.empty())
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDPARAM, "data capture has no columns");
+
+	uint32_t nRowIndex = validateForCommit();
+	if (nRowIndex >= m_nCapacity)
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DATACAPTURECHUNKOVERFLOW, "data capture chunk is full");
+
+	// Columns that are not set in this row are zero.
+	for (size_t nColumnIndex = 0; nColumnIndex < m_ColumnData.size(); nColumnIndex++) {
+		uint32_t nEntrySize = m_EntrySizes[nColumnIndex];
+		memset(m_ColumnData[nColumnIndex].data() + (size_t)nRowIndex * nEntrySize, 0, nEntrySize);
+	}
+
+	m_nOpenRowIndex = nRowIndex;
+	m_bRowOpen = true;
+}
+
+void CDataCaptureChunkBuffer::setRowDoubleValue(uint32_t nColumnIndex, double dValue)
+{
+	checkColumnIndex(nColumnIndex);
+
+	if (!m_bRowOpen)
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DATACAPTUREROWNOTOPEN);
+
+	uint8_t* pTarget = m_ColumnData[nColumnIndex].data() + (size_t)m_nOpenRowIndex * m_EntrySizes[nColumnIndex];
+
+	switch (m_DataTypes[nColumnIndex]) {
+	case AMC::eDataTableV2DataType::Double:
+		memcpy(pTarget, &dValue, sizeof(double));
+		break;
+	case AMC::eDataTableV2DataType::Float: {
+		float fValue = (float)dValue;
+		memcpy(pTarget, &fValue, sizeof(float));
+		break;
+	}
+	default:
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DATACAPTURECOLUMNTYPEMISMATCH, "data capture column is not a floating point column: " + std::to_string(nColumnIndex));
+	}
+}
+
+void CDataCaptureChunkBuffer::setRowIntegerValue(uint32_t nColumnIndex, int64_t nValue)
+{
+	checkColumnIndex(nColumnIndex);
+
+	if (!m_bRowOpen)
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DATACAPTUREROWNOTOPEN);
+
+	uint8_t* pTarget = m_ColumnData[nColumnIndex].data() + (size_t)m_nOpenRowIndex * m_EntrySizes[nColumnIndex];
+
+	switch (m_DataTypes[nColumnIndex]) {
+	case AMC::eDataTableV2DataType::Int32: {
+		if ((nValue < (int64_t)(std::numeric_limits<int32_t>::min)()) || (nValue > (int64_t)(std::numeric_limits<int32_t>::max)()))
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DATACAPTUREVALUEOUTOFRANGE, "value is out of range for an int32 column: " + std::to_string(nValue));
+		int32_t nTypedValue = (int32_t)nValue;
+		memcpy(pTarget, &nTypedValue, sizeof(nTypedValue));
+		break;
+	}
+	case AMC::eDataTableV2DataType::Uint32: {
+		if ((nValue < 0) || (nValue > (int64_t)(std::numeric_limits<uint32_t>::max)()))
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DATACAPTUREVALUEOUTOFRANGE, "value is out of range for an uint32 column: " + std::to_string(nValue));
+		uint32_t nTypedValue = (uint32_t)nValue;
+		memcpy(pTarget, &nTypedValue, sizeof(nTypedValue));
+		break;
+	}
+	case AMC::eDataTableV2DataType::Int64:
+		memcpy(pTarget, &nValue, sizeof(nValue));
+		break;
+	case AMC::eDataTableV2DataType::Uint64:
+	case AMC::eDataTableV2DataType::Timestamp: {
+		if (nValue < 0)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DATACAPTUREVALUEOUTOFRANGE, "value is out of range for an unsigned column: " + std::to_string(nValue));
+		uint64_t nTypedValue = (uint64_t)nValue;
+		memcpy(pTarget, &nTypedValue, sizeof(nTypedValue));
+		break;
+	}
+	case AMC::eDataTableV2DataType::Bool:
+		*pTarget = (nValue != 0) ? 1 : 0;
+		break;
+	default:
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DATACAPTURECOLUMNTYPEMISMATCH, "data capture column is not an integer column: " + std::to_string(nColumnIndex));
+	}
+}
+
+void CDataCaptureChunkBuffer::endRow()
+{
+	if (!m_bRowOpen)
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DATACAPTUREROWNOTOPEN);
+
+	for (auto& nRowCount : m_ColumnRowCounts)
+		nRowCount = m_nOpenRowIndex + 1;
+
+	m_bRowOpen = false;
+}
+
+uint32_t CDataCaptureChunkBuffer::validateForCommit() const
+{
+	if (m_bRowOpen)
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DATACAPTUREROWALREADYOPEN, "data capture chunk has an open row");
+
+	if (m_ColumnRowCounts.empty())
+		return 0;
+
+	uint32_t nRowCount = m_ColumnRowCounts[0];
+	for (size_t nColumnIndex = 1; nColumnIndex < m_ColumnRowCounts.size(); nColumnIndex++) {
+		if (m_ColumnRowCounts[nColumnIndex] != nRowCount)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DATACAPTURECHUNKINCOMPLETE, "data capture chunk column " + std::to_string(nColumnIndex) + " has " + std::to_string(m_ColumnRowCounts[nColumnIndex]) + " rows, expected " + std::to_string(nRowCount));
+	}
+
+	return nRowCount;
+}
+
+const uint8_t* CDataCaptureChunkBuffer::getColumnData(uint32_t nColumnIndex) const
+{
+	checkColumnIndex(nColumnIndex);
+	return m_ColumnData[nColumnIndex].data();
+}
+
+
+/*************************************************************************************************************************
+ Class CDataCaptureSegment: one segment stream of the capture.
+ Segments are written through CTempStreamWriter, which stores them as random write streams.
+ Only WriteData is used and the writer never seeks, so the segment is strictly append-only.
+**************************************************************************************************************************/
+
+namespace LibMCEnv {
+namespace Impl {
+
+class CDataCaptureSegment {
+private:
+
+	std::unique_ptr<CTempStreamWriter> m_pStream;
+	AMC::CDataTableV2SegmentBuilder m_Builder;
+	uint64_t m_nStartTimeStamp;
+	uint64_t m_nEndTimeStamp;
+	bool m_bStreamFinished;
+	bool m_bDiscarded;
+
+	uint64_t writeBuffer(std::vector<uint8_t>& buffer)
+	{
+		if (!buffer.empty())
+			m_pStream->WriteData(buffer.size(), buffer.data());
+
+		return buffer.size();
+	}
+
+public:
+
+	CDataCaptureSegment(LibMCData::PDataModel pDataModel, const std::string& sStreamName, const std::string& sUserUUID, AMCCommon::PChrono pGlobalChrono, const std::vector<AMC::sDataTableV2Column>& columns, uint32_t nSegmentIndex, uint64_t nFirstRowIndex, uint32_t nChunkRowCapacity)
+		: m_Builder(columns, nSegmentIndex, nFirstRowIndex, nChunkRowCapacity),
+		m_nStartTimeStamp(pGlobalChrono->getUTCTimeStampInMicrosecondsSince1970()),
+		m_nEndTimeStamp(0),
+		m_bStreamFinished(false),
+		m_bDiscarded(false)
+	{
+		m_pStream = std::make_unique<CTempStreamWriter>(pDataModel, sStreamName, DATACAPTURE_SEGMENTMIMETYPE, sUserUUID, pGlobalChrono);
+	}
+
+	// Writes the segment header. Returns the number of bytes written.
+	uint64_t open(std::vector<uint8_t>& buffer)
+	{
+		buffer.clear();
+		m_Builder.appendHeader(buffer);
+		return writeBuffer(buffer);
+	}
+
+	// Writes one encoded chunk. Returns the number of bytes written.
+	uint64_t writeChunk(const AMC::sDataTableV2EncodedChunk& encodedChunk, std::vector<uint8_t>& buffer)
+	{
+		buffer.clear();
+		m_Builder.appendEncodedChunk(encodedChunk, buffer);
+		return writeBuffer(buffer);
+	}
+
+	// Writes footer and trailer. Returns the number of bytes written.
+	uint64_t close(std::vector<uint8_t>& buffer, uint64_t nEndTimeStamp)
+	{
+		buffer.clear();
+		m_Builder.appendFooter(buffer);
+		m_nEndTimeStamp = nEndTimeStamp;
+		return writeBuffer(buffer);
+	}
+
+	const AMC::CDataTableV2SegmentBuilder& getBuilder() const
+	{
+		return m_Builder;
+	}
+
+	std::string getStreamUUID()
+	{
+		return m_pStream->GetUUID();
+	}
+
+	uint64_t getStartTimeStamp() const
+	{
+		return m_nStartTimeStamp;
+	}
+
+	uint64_t getEndTimeStamp() const
+	{
+		return m_nEndTimeStamp;
+	}
+
+	// Finishes the storage stream. The storage layer hashes the complete file here.
+	void finishStream()
+	{
+		m_pStream->Finish();
+		m_bStreamFinished = true;
+	}
+
+	// Deletes the data of a segment whose stream has not been finished.
+	void discard()
+	{
+		if (!m_bStreamFinished && !m_bDiscarded)
+			m_pStream->Discard();
+
+		m_bDiscarded = true;
+	}
+
+};
+
+} // namespace Impl
+} // namespace LibMCEnv
+
+
+/*************************************************************************************************************************
+ Class definition of CDataCaptureInstance
+**************************************************************************************************************************/
+
+CDataCaptureInstance::CDataCaptureInstance(LibMCData::PDataModel pDataModel, LibMCData::PDataCapture pManifest, const sDataCaptureSettings& settings, AMCCommon::PChrono pGlobalChrono, const std::string& sUserUUID)
+	: m_pDataModel(pDataModel),
+	m_pManifest(pManifest),
+	m_pGlobalChrono(pGlobalChrono),
+	m_sUserUUID(sUserUUID),
+	m_Settings(settings),
+	m_bWriterBusy(false),
+	m_StopRequest(eStopRequest::None),
+	m_Status(LibMCEnv::eDataCaptureStatus::Configuring),
+	m_bFailed(false),
+	m_nCommittedRows(0),
+	m_nDroppedRows(0),
+	m_nStorageSize(0),
+	m_nSegmentCount(0),
+	m_nWrittenRows(0),
+	m_bWriterDone(false)
+{
+	if (pDataModel.get() == nullptr)
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDPARAM);
+	if (pManifest.get() == nullptr)
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDPARAM);
+	if (pGlobalChrono.get() == nullptr)
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDPARAM);
+
+	m_sUUID = pManifest->GetUUID();
+	m_sIdentifier = pManifest->GetIdentifier();
+	m_sName = pManifest->GetName();
+
+	m_pRetentionStorage = pDataModel->CreateStorage();
+}
+
+CDataCaptureInstance::~CDataCaptureInstance()
+{
+	requestStopAndJoin(eStopRequest::Finish);
+}
+
+std::string CDataCaptureInstance::getUUID() const
+{
+	return m_sUUID;
+}
+
+std::string CDataCaptureInstance::getIdentifier() const
+{
+	return m_sIdentifier;
+}
+
+std::string CDataCaptureInstance::getName() const
+{
+	return m_sName;
+}
+
+LibMCEnv::eDataCaptureStatus CDataCaptureInstance::getStatus()
+{
+	std::lock_guard<std::mutex> lock(m_Mutex);
+
+	if (m_bFailed && (m_Status == LibMCEnv::eDataCaptureStatus::Recording))
+		return LibMCEnv::eDataCaptureStatus::Failed;
+
+	return m_Status;
+}
+
+void CDataCaptureInstance::throwFailure()
+{
+	throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DATACAPTUREWRITERFAILED, "data capture writer failed: " + m_sFailureMessage);
+}
+
+void CDataCaptureInstance::ensureRecording()
+{
+	if (m_bFailed)
+		throwFailure();
+
+	if ((m_Status != LibMCEnv::eDataCaptureStatus::Recording) || (m_StopRequest != eStopRequest::None))
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DATACAPTURENOTRECORDING);
+}
+
+void CDataCaptureInstance::recordFailure(const std::string& sMessage)
+{
+	{
+		std::lock_guard<std::mutex> lock(m_Mutex);
+		if (!m_bFailed) {
+			m_bFailed = true;
+			m_sFailureMessage = sMessage;
+		}
+	}
+
+	// Wake everybody: the producer must not wait for a writer that has stopped, and vice versa.
+	m_WriterCondition.notify_all();
+	m_ProducerCondition.notify_all();
+}
+
+bool CDataCaptureInstance::stopRequestIsAbortOrFailed()
+{
+	std::lock_guard<std::mutex> lock(m_Mutex);
+	return m_bFailed || (m_StopRequest == eStopRequest::Abort);
+}
+
+void CDataCaptureInstance::addColumn(const std::string& sIdentifier, const std::string& sDescription, const LibMCEnv::eDataTableColumnType eColumnType)
+{
+	if (sIdentifier.empty())
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_COLUMNIDENTIFIEREMPTY);
+	if (!AMCCommon::CUtils::stringIsValidAlphanumericNameString(sIdentifier))
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCOLUMNIDENTIFIER, "invalid column identifier: " + sIdentifier);
+	if (!AMC::CDataTableV2::dataTypeIsValid((uint32_t)eColumnType))
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCOLUMNDATATYPE);
+
+	std::lock_guard<std::mutex> lock(m_Mutex);
+
+	if (m_Status != LibMCEnv::eDataCaptureStatus::Configuring)
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DATACAPTURENOTCONFIGURABLE);
+
+	for (auto& column : m_Columns) {
+		if (column.m_sIdentifier == sIdentifier)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DUPLICATECOLUMNIDENTIFIER, "duplicate column identifier: " + sIdentifier);
+	}
+
+	if (m_Columns.size() >= DATATABLE_MAXCOLUMNCOUNT)
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DATATABLEHASTOOMANYCOLUMS);
+
+	AMC::sDataTableV2Column column;
+	column.m_sIdentifier = sIdentifier;
+	column.m_sDescription = sDescription;
+	column.m_DataType = (AMC::eDataTableV2DataType)eColumnType;
+	m_Columns.push_back(column);
+}
+
+uint32_t CDataCaptureInstance::getColumnCount()
+{
+	std::lock_guard<std::mutex> lock(m_Mutex);
+	return (uint32_t)m_Columns.size();
+}
+
+std::vector<AMC::sDataTableV2Column> CDataCaptureInstance::getColumns()
+{
+	std::lock_guard<std::mutex> lock(m_Mutex);
+	return m_Columns;
+}
+
+// Decides how each column is encoded: the default of its type, unless the options say otherwise.
+// Fails before anything is written if an option names a column that does not exist or does not fit.
+void CDataCaptureInstance::resolveColumnEncodings()
+{
+	for (auto& column : m_Columns) {
+		column.m_nEncoding = AMC::CDataTableV2::getDefaultEncoding(column.m_DataType);
+		column.m_dQuantizationStep = 0.0;
+
+		auto iQuantization = m_Settings.m_ColumnQuantization.find(column.m_sIdentifier);
+		if (iQuantization != m_Settings.m_ColumnQuantization.end()) {
+			if (column.m_DataType != AMC::eDataTableV2DataType::Double)
+				throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDDATACAPTUREOPTION, "quantisation requires a double column: " + column.m_sIdentifier);
+
+			column.m_dQuantizationStep = iQuantization->second;
+			column.m_nEncoding = DATATABLE_V2_ENCODING_DELTA;
+		}
+
+		auto iEncoding = m_Settings.m_ColumnEncodings.find(column.m_sIdentifier);
+		if (iEncoding != m_Settings.m_ColumnEncodings.end()) {
+			if ((column.m_dQuantizationStep > 0.0) && (iEncoding->second != DATATABLE_V2_ENCODING_DELTA))
+				throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDDATACAPTUREOPTION, "a quantised column is delta encoded: " + column.m_sIdentifier);
+			if (!AMC::CDataTableV2::encodingIsValidForColumn(column.m_DataType, iEncoding->second, column.m_dQuantizationStep))
+				throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDDATACAPTUREOPTION, "encoding does not fit the type of column " + column.m_sIdentifier);
+
+			column.m_nEncoding = iEncoding->second;
+		}
+	}
+
+	auto columnExists = [this](const std::string& sIdentifier) {
+		for (auto& column : m_Columns) {
+			if (column.m_sIdentifier == sIdentifier)
+				return true;
+		}
+		return false;
+	};
+
+	for (auto& encodingOption : m_Settings.m_ColumnEncodings) {
+		if (!columnExists(encodingOption.first))
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DATACAPTURECOLUMNNOTFOUND, "encoding option names an unknown column: " + encodingOption.first);
+	}
+	for (auto& quantizationOption : m_Settings.m_ColumnQuantization) {
+		if (!columnExists(quantizationOption.first))
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DATACAPTURECOLUMNNOTFOUND, "quantisation option names an unknown column: " + quantizationOption.first);
+	}
+}
+
+// Freezes the schema, allocates the chunk pool and starts the threads. m_Mutex MUST be held by the caller.
+void CDataCaptureInstance::startRecording()
+{
+	resolveColumnEncodings();
+	m_pEncoder = std::make_unique<AMC::CDataTableV2ChunkEncoder>(m_Columns, m_Settings.m_nCodec);
+
+	for (size_t nColumnIndex = 0; nColumnIndex < m_Columns.size(); nColumnIndex++) {
+		auto& column = m_Columns[nColumnIndex];
+		m_pManifest->AddColumn((uint32_t)nColumnIndex, column.m_sIdentifier, column.m_sDescription, (uint32_t)column.m_DataType);
+	}
+
+	// The queue holds at most MaxQueuedChunks buffers and the writer thread holds one more. The producer
+	// only gets a buffer while the queue is not full, so one buffer on top of the queue depth is enough.
+	size_t nPoolDepth = (size_t)m_Settings.m_nMaxQueuedChunks + 1;
+	for (size_t nIndex = 0; nIndex < nPoolDepth; nIndex++)
+		m_FreeBuffers.push_back(std::make_shared<CDataCaptureChunkBuffer>(m_Columns, m_Settings.m_nChunkRowCount));
+
+	m_Status = LibMCEnv::eDataCaptureStatus::Recording;
+
+	m_WriterThread = std::thread(&CDataCaptureInstance::writerThreadMain, this);
+	m_FinalizerThread = std::thread(&CDataCaptureInstance::finalizerThreadMain, this);
+}
+
+PDataCaptureChunkBuffer CDataCaptureInstance::beginChunk()
+{
+	std::unique_lock<std::mutex> lock(m_Mutex);
+
+	if (m_Status == LibMCEnv::eDataCaptureStatus::Configuring)
+		startRecording();
+
+	ensureRecording();
+
+	if (m_pOutstandingChunk.get() != nullptr)
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DATACAPTURECHUNKALREADYOPEN);
+
+	// Backpressure: the producer only gets a chunk while the queue is not full.
+	while (m_Queue.size() >= m_Settings.m_nMaxQueuedChunks) {
+
+		switch (m_Settings.m_BackpressureMode) {
+		case LibMCEnv::eDataCaptureBackpressureMode::Fail:
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DATACAPTUREQUEUEFULL);
+
+		case LibMCEnv::eDataCaptureBackpressureMode::DropOldest: {
+			auto pDroppedChunk = m_Queue.front();
+			m_Queue.pop_front();
+			m_nDroppedRows += pDroppedChunk->getRowCount();
+			m_FreeBuffers.push_back(pDroppedChunk);
+			break;
+		}
+
+		default:
+			m_ProducerCondition.wait(lock);
+			break;
+		}
+
+		ensureRecording();
+	}
+
+	// Follows from the pool depth: a queue that is not full always leaves a buffer for the producer.
+	if (m_FreeBuffers.empty())
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DATACAPTUREQUEUEFULL, "data capture chunk pool is exhausted");
+
+	auto pChunk = m_FreeBuffers.back();
+	m_FreeBuffers.pop_back();
+	pChunk->reset();
+
+	m_pOutstandingChunk = pChunk;
+	return pChunk;
+}
+
+void CDataCaptureInstance::commitChunk(PDataCaptureChunkBuffer pChunk)
+{
+	{
+		std::lock_guard<std::mutex> lock(m_Mutex);
+
+		ensureRecording();
+
+		if ((pChunk.get() == nullptr) || (pChunk != m_pOutstandingChunk))
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DATACAPTURECHUNKINVALID);
+
+		// The chunk stays with the producer if it is not consistent, so that it can be completed.
+		uint32_t nRowCount = pChunk->validateForCommit();
+
+		m_pOutstandingChunk = nullptr;
+
+		if (nRowCount == 0) {
+			m_FreeBuffers.push_back(pChunk);
+			return;
+		}
+
+		m_Queue.push_back(pChunk);
+		m_nCommittedRows += nRowCount;
+	}
+
+	m_WriterCondition.notify_one();
+}
+
+void CDataCaptureInstance::flush()
+{
+	std::unique_lock<std::mutex> lock(m_Mutex);
+
+	if (m_Status == LibMCEnv::eDataCaptureStatus::Configuring)
+		return;
+
+	m_ProducerCondition.wait(lock, [this]() {
+		return m_bFailed || (m_Status != LibMCEnv::eDataCaptureStatus::Recording) || (m_Queue.empty() && !m_bWriterBusy);
+	});
+
+	if (m_bFailed)
+		throwFailure();
+}
+
+uint64_t CDataCaptureInstance::getCapturedRowCount()
+{
+	std::lock_guard<std::mutex> lock(m_Mutex);
+	return m_nCommittedRows - m_nDroppedRows;
+}
+
+uint64_t CDataCaptureInstance::getStorageSizeInBytes()
+{
+	return m_nStorageSize.load();
+}
+
+uint32_t CDataCaptureInstance::getSegmentCount()
+{
+	return m_nSegmentCount.load();
+}
+
+uint32_t CDataCaptureInstance::getQueuedChunkCount()
+{
+	std::lock_guard<std::mutex> lock(m_Mutex);
+	return (uint32_t)m_Queue.size();
+}
+
+uint64_t CDataCaptureInstance::getDroppedRowCount()
+{
+	std::lock_guard<std::mutex> lock(m_Mutex);
+	return m_nDroppedRows;
+}
+
+void CDataCaptureInstance::requestStopAndJoin(eStopRequest stopRequest)
+{
+	{
+		std::lock_guard<std::mutex> lock(m_Mutex);
+		if ((m_StopRequest == eStopRequest::None) || (stopRequest == eStopRequest::Abort))
+			m_StopRequest = stopRequest;
+	}
+
+	m_WriterCondition.notify_all();
+	m_ProducerCondition.notify_all();
+
+	if (m_WriterThread.joinable())
+		m_WriterThread.join();
+	if (m_FinalizerThread.joinable())
+		m_FinalizerThread.join();
+}
+
+std::string CDataCaptureInstance::finish()
+{
+	{
+		std::lock_guard<std::mutex> lock(m_Mutex);
+
+		if (m_Status == LibMCEnv::eDataCaptureStatus::Finished)
+			return m_sUUID;
+
+		if (m_bFailed)
+			throwFailure();
+
+		if ((m_Status != LibMCEnv::eDataCaptureStatus::Configuring) && (m_Status != LibMCEnv::eDataCaptureStatus::Recording))
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DATACAPTURENOTRECORDING);
+
+		if (m_pOutstandingChunk.get() != nullptr)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DATACAPTURECHUNKOUTSTANDING);
+
+		// A capture without any chunk still stores its schema in one empty segment.
+		if (m_Status == LibMCEnv::eDataCaptureStatus::Configuring)
+			startRecording();
+	}
+
+	requestStopAndJoin(eStopRequest::Finish);
+
+	std::lock_guard<std::mutex> lock(m_Mutex);
+	if (m_bFailed)
+		throwFailure();
+
+	m_Status = LibMCEnv::eDataCaptureStatus::Finished;
+	return m_sUUID;
+}
+
+void CDataCaptureInstance::abort()
+{
+	{
+		std::lock_guard<std::mutex> lock(m_Mutex);
+
+		if (m_Status == LibMCEnv::eDataCaptureStatus::Aborted)
+			return;
+
+		if (m_Status == LibMCEnv::eDataCaptureStatus::Finished)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DATACAPTURENOTRECORDING);
+
+		if (m_Status == LibMCEnv::eDataCaptureStatus::Configuring) {
+			// Nothing has been written yet and no thread is running.
+			m_pManifest->Abort(m_pGlobalChrono->getUTCTimeStampInMicrosecondsSince1970());
+			m_Status = LibMCEnv::eDataCaptureStatus::Aborted;
+			return;
+		}
+	}
+
+	requestStopAndJoin(eStopRequest::Abort);
+
+	bool bFailed = false;
+	{
+		std::lock_guard<std::mutex> lock(m_Mutex);
+		bFailed = m_bFailed;
+	}
+
+	// A thread that has failed did not clean up. Both threads have ended, so it is done here.
+	if (bFailed)
+		cleanupAfterAbort();
+
+	std::lock_guard<std::mutex> lock(m_Mutex);
+	m_pOutstandingChunk = nullptr;
+	m_Status = LibMCEnv::eDataCaptureStatus::Aborted;
+}
+
+
+/*************************************************************************************************************************
+ Writer thread
+**************************************************************************************************************************/
+
+void CDataCaptureInstance::writerThreadMain()
+{
+	try {
+		runWriter();
+	}
+	catch (const std::exception& writerException) {
+		recordFailure(writerException.what());
+	}
+
+	// Tell the finalizer that no further segment will arrive.
+	{
+		std::lock_guard<std::mutex> lock(m_FinalizerMutex);
+		m_bWriterDone = true;
+	}
+	m_FinalizerCondition.notify_all();
+}
+
+void CDataCaptureInstance::runWriter()
+{
+	// The first segment is opened immediately. Nothing is accumulated waiting for the end of the capture.
+	openSegment();
+
+	for (;;) {
+		PDataCaptureChunkBuffer pChunk;
+
+		{
+			std::unique_lock<std::mutex> lock(m_Mutex);
+			m_WriterCondition.wait(lock, [this]() {
+				return !m_Queue.empty() || (m_StopRequest != eStopRequest::None) || m_bFailed;
+			});
+
+			// On abort or failure the open segment is left to the cleanup.
+			if (m_bFailed || (m_StopRequest == eStopRequest::Abort))
+				return;
+
+			// Finish has been requested and the queue has drained.
+			if (m_Queue.empty())
+				break;
+
+			pChunk = m_Queue.front();
+			m_Queue.pop_front();
+			m_bWriterBusy = true;
+		}
+
+		// The queue has room again.
+		m_ProducerCondition.notify_all();
+
+		// Returns the buffer to the pool when the chunk has been written or writing has failed.
+		struct CBufferReturn {
+			CDataCaptureInstance* m_pInstance;
+			PDataCaptureChunkBuffer m_pChunk;
+			~CBufferReturn()
+			{
+				{
+					std::lock_guard<std::mutex> lock(m_pInstance->m_Mutex);
+					m_pInstance->m_FreeBuffers.push_back(m_pChunk);
+					m_pInstance->m_bWriterBusy = false;
+				}
+				m_pInstance->m_ProducerCondition.notify_all();
+			}
+		} bufferReturn{ this, pChunk };
+
+		writeChunk(pChunk.get());
+	}
+
+	closeSegment();
+}
+
+void CDataCaptureInstance::openSegment()
+{
+	uint32_t nSegmentIndex = m_nSegmentCount.load();
+
+	std::stringstream sStreamName;
+	sStreamName << m_sIdentifier << "_segment" << std::setw(4) << std::setfill('0') << nSegmentIndex;
+
+	auto pSegment = std::make_shared<CDataCaptureSegment>(m_pDataModel, sStreamName.str(), m_sUserUUID, m_pGlobalChrono, m_Columns, nSegmentIndex, m_nWrittenRows, m_Settings.m_nChunkRowCount);
+
+	m_pOpenSegment = pSegment;
+	m_nSegmentCount++;
+
+	m_nStorageSize += pSegment->open(m_WriteBuffer);
+}
+
+void CDataCaptureInstance::closeSegment()
+{
+	m_nStorageSize += m_pOpenSegment->close(m_WriteBuffer, m_pGlobalChrono->getUTCTimeStampInMicrosecondsSince1970());
+	m_nWrittenRows += m_pOpenSegment->getBuilder().getRowCount();
+
+	{
+		std::lock_guard<std::mutex> lock(m_FinalizerMutex);
+		m_FinalizerQueue.push_back(m_pOpenSegment);
+	}
+	m_pOpenSegment = nullptr;
+
+	m_FinalizerCondition.notify_all();
+}
+
+void CDataCaptureInstance::writeChunk(CDataCaptureChunkBuffer* pChunk)
+{
+	// Encode and compress the chunk first, so that its size on disk is known.
+	uint32_t nColumnCount = pChunk->getColumnCount();
+	std::vector<const uint8_t*> columnData(nColumnCount);
+	for (uint32_t nColumnIndex = 0; nColumnIndex < nColumnCount; nColumnIndex++)
+		columnData[nColumnIndex] = pChunk->getColumnData(nColumnIndex);
+
+	m_pEncoder->encodeChunk(columnData, pChunk->getRowCount(), m_EncodedChunk);
+
+	// Roll over before a chunk that would exceed the segment size. A chunk is never split
+	// and a segment always holds at least one chunk.
+	if (m_Settings.m_nSegmentSizeInBytes > 0) {
+		auto& builder = m_pOpenSegment->getBuilder();
+		if (builder.getChunkCount() > 0) {
+			uint64_t nProjectedSize = builder.getCurrentSize() + m_EncodedChunk.m_Bytes.size() + builder.getFooterSizeInBytes(builder.getChunkCount() + 1);
+			if (nProjectedSize > m_Settings.m_nSegmentSizeInBytes) {
+				closeSegment();
+				openSegment();
+			}
+		}
+	}
+
+	m_nStorageSize += m_pOpenSegment->writeChunk(m_EncodedChunk, m_WriteBuffer);
+}
+
+
+/*************************************************************************************************************************
+ Finalizer thread
+**************************************************************************************************************************/
+
+void CDataCaptureInstance::finalizerThreadMain()
+{
+	try {
+		runFinalizer();
+	}
+	catch (const std::exception& finalizerException) {
+		recordFailure(finalizerException.what());
+	}
+}
+
+void CDataCaptureInstance::runFinalizer()
+{
+	for (;;) {
+		PDataCaptureSegment pSegment;
+
+		{
+			std::unique_lock<std::mutex> lock(m_FinalizerMutex);
+			m_FinalizerCondition.wait(lock, [this]() {
+				return !m_FinalizerQueue.empty() || m_bWriterDone;
+			});
+
+			// The writer has ended and everything it closed has been handled.
+			if (m_FinalizerQueue.empty())
+				break;
+
+			pSegment = m_FinalizerQueue.front();
+			m_FinalizerQueue.pop_front();
+		}
+
+		if (stopRequestIsAbortOrFailed())
+			m_LeftoverSegments.push_back(pSegment);
+		else
+			finalizeSegment(pSegment);
+	}
+
+	bool bFailed = false;
+	bool bAbort = false;
+	{
+		std::lock_guard<std::mutex> lock(m_Mutex);
+		bFailed = m_bFailed;
+		bAbort = (m_StopRequest == eStopRequest::Abort);
+	}
+
+	// After a failure the capture stays as it is. Abort cleans it up.
+	if (bFailed)
+		return;
+
+	if (bAbort)
+		cleanupAfterAbort();
+	else
+		m_pManifest->Finish(m_pGlobalChrono->getUTCTimeStampInMicrosecondsSince1970());
+}
+
+void CDataCaptureInstance::finalizeSegment(PDataCaptureSegment pSegment)
+{
+	auto& builder = pSegment->getBuilder();
+
+	// The segment is registered before its stream is finished: a segment that is known to the manifest
+	// can always be purged, so a failure in between does not leave an orphaned file behind.
+	m_pManifest->AddSegment(builder.getSegmentIndex(), pSegment->getStreamUUID(), builder.getFirstRowIndex(), builder.getRowCount(), builder.getChunkCount(), builder.getCurrentSize(), pSegment->getStartTimeStamp(), pSegment->getEndTimeStamp());
+
+	pSegment->finishStream();
+
+	if (m_Settings.m_nStorageLimitInBytes > 0)
+		m_pRetentionStorage->EnforceDataCaptureStorageLimit(m_Settings.m_nStorageLimitInBytes);
+}
+
+// Discards everything that has not been finalized and deletes the registered segments.
+// Runs on the finalizer thread, or on the thread that calls abort after both threads have ended.
+void CDataCaptureInstance::cleanupAfterAbort()
+{
+	{
+		std::lock_guard<std::mutex> lock(m_FinalizerMutex);
+		for (auto& pSegment : m_FinalizerQueue)
+			m_LeftoverSegments.push_back(pSegment);
+		m_FinalizerQueue.clear();
+	}
+
+	if (m_pOpenSegment.get() != nullptr) {
+		m_LeftoverSegments.push_back(m_pOpenSegment);
+		m_pOpenSegment = nullptr;
+	}
+
+	for (auto& pSegment : m_LeftoverSegments)
+		pSegment->discard();
+	m_LeftoverSegments.clear();
+
+	if (m_pManifest->GetStatus() != LibMCData::eDataCaptureStatus::Aborted)
+		m_pManifest->Abort(m_pGlobalChrono->getUTCTimeStampInMicrosecondsSince1970());
+}
diff --git a/Implementation/LibMCEnv/libmcenv_datacaptureinstance.hpp b/Implementation/LibMCEnv/libmcenv_datacaptureinstance.hpp
new file mode 100644
index 000000000..86dc07cbc
--- /dev/null
+++ b/Implementation/LibMCEnv/libmcenv_datacaptureinstance.hpp
@@ -0,0 +1,288 @@
+/*++
+
+Copyright (C) 2020 Autodesk Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Autodesk Inc. nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL AUTODESK INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+Abstract: Internal engine of a streaming data capture. It is shared by the
+CDataCapture and CDataCaptureChunk interface classes and is not part of the
+external API.
+
+*/
+
+
+#ifndef __LIBMCENV_DATACAPTUREINSTANCE
+#define __LIBMCENV_DATACAPTUREINSTANCE
+
+#include "libmcenv_interfaces.hpp"
+
+#include "libmcdata_dynamic.hpp"
+#include "common_chrono.hpp"
+#include "amc_datatableformat.hpp"
+
+#include <atomic>
+#include <condition_variable>
+#include <deque>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <thread>
+#include <vector>
+
+namespace LibMCEnv {
+namespace Impl {
+
+
+struct sDataCaptureSettings {
+	uint32_t m_nChunkRowCount;
+	uint64_t m_nSegmentSizeInBytes;
+	uint32_t m_nMaxQueuedChunks;
+	LibMCEnv::eDataCaptureBackpressureMode m_BackpressureMode;
+	uint64_t m_nStorageLimitInBytes;
+
+	// Page codec of the capture as DATATABLE_V2_CODEC value.
+	uint32_t m_nCodec;
+
+	// Explicit encodings by column identifier as DATATABLE_V2_ENCODING value. Columns that are not listed use the default of their type.
+	std::map<std::string, uint32_t> m_ColumnEncodings;
+
+	// Quantisation steps by column identifier. Columns that are not listed are not quantised.
+	std::map<std::string, double> m_ColumnQuantization;
+
+	// Initialises the settings with the defaults.
+	sDataCaptureSettings();
+};
+
+
+/*************************************************************************************************************************
+ CDataCaptureChunkBuffer holds the rows of one chunk: one fixed-size value array per column.
+ Buffers are allocated once when the schema is frozen and are recycled through the pool of the capture.
+**************************************************************************************************************************/
+
+class CDataCaptureChunkBuffer {
+private:
+
+	uint32_t m_nCapacity;
+	std::vector<AMC::eDataTableV2DataType> m_DataTypes;
+	std::vector<uint32_t> m_EntrySizes;
+	std::vector<std::vector<uint8_t>> m_ColumnData;
+	std::vector<uint32_t> m_ColumnRowCounts;
+
+	bool m_bRowOpen;
+	uint32_t m_nOpenRowIndex;
+
+	void checkColumnIndex(uint32_t nColumnIndex) const;
+
+public:
+
+	CDataCaptureChunkBuffer(const std::vector<AMC::sDataTableV2Column>& columns, uint32_t nCapacity);
+
+	void reset();
+
+	uint32_t getCapacity() const;
+
+	uint32_t getColumnCount() const;
+
+	// Row count of the longest column.
+	uint32_t getRowCount() const;
+
+	bool isFull() const;
+
+	// Replaces the rows of a column. pValues holds nValueCount plain values of the expected type.
+	void setColumnValues(uint32_t nColumnIndex, AMC::eDataTableV2DataType expectedType, const uint8_t* pValues, uint64_t nValueCount);
+
+	void beginRow();
+
+	void setRowDoubleValue(uint32_t nColumnIndex, double dValue);
+
+	void setRowIntegerValue(uint32_t nColumnIndex, int64_t nValue);
+
+	void endRow();
+
+	// Verifies that no row is open and all columns have the same row count. Returns that row count.
+	uint32_t validateForCommit() const;
+
+	const uint8_t* getColumnData(uint32_t nColumnIndex) const;
+
+};
+
+typedef std::shared_ptr<CDataCaptureChunkBuffer> PDataCaptureChunkBuffer;
+
+
+class CDataCaptureSegment;
+typedef std::shared_ptr<CDataCaptureSegment> PDataCaptureSegment;
+
+
+/*************************************************************************************************************************
+ CDataCaptureInstance is the capture session.
+
+ Threading model:
+   - One producer. It borrows a chunk buffer from the pool, fills it and commits it. The producer never
+     touches the disk while recording.
+   - One writer thread. It takes committed chunks from a bounded queue, serialises them into the open
+     segment and rolls over into a new segment when the segment size is reached.
+   - One finalizer thread. It registers closed segments in the manifest, finishes their storage streams
+     (which hashes the file) and enforces the retention limit. Finalizing is kept off the writer thread,
+     so that a segment rollover does not stall the queue.
+
+ Memory is bounded by the pool: (MaxQueuedChunks + 1) buffers exist for the life of the capture.
+**************************************************************************************************************************/
+
+class CDataCaptureInstance {
+private:
+
+	enum class eStopRequest {
+		None,
+		Finish,
+		Abort
+	};
+
+	LibMCData::PDataModel m_pDataModel;
+	LibMCData::PDataCapture m_pManifest;
+	LibMCData::PStorage m_pRetentionStorage;
+	AMCCommon::PChrono m_pGlobalChrono;
+
+	std::string m_sUUID;
+	std::string m_sIdentifier;
+	std::string m_sName;
+	std::string m_sUserUUID;
+	sDataCaptureSettings m_Settings;
+
+	// Schema. Changed by the producer while configuring, immutable once recording has started.
+	std::vector<AMC::sDataTableV2Column> m_Columns;
+
+	// State shared between producer and writer thread, guarded by m_Mutex.
+	std::mutex m_Mutex;
+	std::condition_variable m_WriterCondition;
+	std::condition_variable m_ProducerCondition;
+	std::deque<PDataCaptureChunkBuffer> m_Queue;
+	std::vector<PDataCaptureChunkBuffer> m_FreeBuffers;
+	PDataCaptureChunkBuffer m_pOutstandingChunk;
+	bool m_bWriterBusy;
+	eStopRequest m_StopRequest;
+	LibMCEnv::eDataCaptureStatus m_Status;
+	bool m_bFailed;
+	std::string m_sFailureMessage;
+	uint64_t m_nCommittedRows;
+	uint64_t m_nDroppedRows;
+
+	std::atomic<uint64_t> m_nStorageSize;
+	std::atomic<uint32_t> m_nSegmentCount;
+
+	// Writer thread state.
+	PDataCaptureSegment m_pOpenSegment;
+	uint64_t m_nWrittenRows;
+	std::vector<uint8_t> m_WriteBuffer;
+	std::unique_ptr<AMC::CDataTableV2ChunkEncoder> m_pEncoder;
+	AMC::sDataTableV2EncodedChunk m_EncodedChunk;
+
+	// Hand-over from writer to finalizer, guarded by m_FinalizerMutex.
+	std::mutex m_FinalizerMutex;
+	std::condition_variable m_FinalizerCondition;
+	std::deque<PDataCaptureSegment> m_FinalizerQueue;
+	bool m_bWriterDone;
+
+	// Segments that were closed but must not be finalized anymore. Finalizer thread, or the caller of abort after the threads have ended.
+	std::vector<PDataCaptureSegment> m_LeftoverSegments;
+
+	std::thread m_WriterThread;
+	std::thread m_FinalizerThread;
+
+	void ensureRecording();
+	void throwFailure();
+	void recordFailure(const std::string& sMessage);
+	bool stopRequestIsAbortOrFailed();
+
+	void resolveColumnEncodings();
+	void startRecording();
+	void requestStopAndJoin(eStopRequest stopRequest);
+
+	void writerThreadMain();
+	void runWriter();
+	void openSegment();
+	void closeSegment();
+	void writeChunk(CDataCaptureChunkBuffer* pChunk);
+
+	void finalizerThreadMain();
+	void runFinalizer();
+	void finalizeSegment(PDataCaptureSegment pSegment);
+	void cleanupAfterAbort();
+
+public:
+
+	CDataCaptureInstance(LibMCData::PDataModel pDataModel, LibMCData::PDataCapture pManifest, const sDataCaptureSettings& settings, AMCCommon::PChrono pGlobalChrono, const std::string& sUserUUID);
+
+	// Finishes a capture that is still recording. A capture that has been abandoned without
+	// Finish or Abort keeps all data that has been committed.
+	virtual ~CDataCaptureInstance();
+
+	CDataCaptureInstance(const CDataCaptureInstance&) = delete;
+	CDataCaptureInstance& operator=(const CDataCaptureInstance&) = delete;
+
+	std::string getUUID() const;
+
+	std::string getIdentifier() const;
+
+	std::string getName() const;
+
+	LibMCEnv::eDataCaptureStatus getStatus();
+
+	void addColumn(const std::string& sIdentifier, const std::string& sDescription, const LibMCEnv::eDataTableColumnType eColumnType);
+
+	uint32_t getColumnCount();
+
+	// Returns a copy of the schema.
+	std::vector<AMC::sDataTableV2Column> getColumns();
+
+	PDataCaptureChunkBuffer beginChunk();
+
+	void commitChunk(PDataCaptureChunkBuffer pChunk);
+
+	void flush();
+
+	uint64_t getCapturedRowCount();
+
+	uint64_t getStorageSizeInBytes();
+
+	uint32_t getSegmentCount();
+
+	uint32_t getQueuedChunkCount();
+
+	uint64_t getDroppedRowCount();
+
+	std::string finish();
+
+	void abort();
+
+};
+
+typedef std::shared_ptr<CDataCaptureInstance> PDataCaptureInstance;
+
+} // namespace Impl
+} // namespace LibMCEnv
+
+#endif // __LIBMCENV_DATACAPTUREINSTANCE
diff --git a/Implementation/LibMCEnv/libmcenv_datacaptureoptions.cpp b/Implementation/LibMCEnv/libmcenv_datacaptureoptions.cpp
new file mode 100644
index 000000000..b20160c2b
--- /dev/null
+++ b/Implementation/LibMCEnv/libmcenv_datacaptureoptions.cpp
@@ -0,0 +1,191 @@
+/*++
+
+Copyright (C) 2020 Autodesk Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Autodesk Inc. nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL AUTODESK INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+Abstract: This is the class definition of CDataCaptureOptions
+
+*/
+
+#include "libmcenv_datacaptureoptions.hpp"
+#include "libmcenv_interfaceexception.hpp"
+
+// Include custom headers here.
+#include "amc_constants.hpp"
+#include "amc_datatableformat.hpp"
+#include <cmath>
+
+using namespace LibMCEnv::Impl;
+
+/*************************************************************************************************************************
+ Class definition of CDataCaptureOptions
+**************************************************************************************************************************/
+
+CDataCaptureOptions::CDataCaptureOptions()
+{
+
+}
+
+CDataCaptureOptions::~CDataCaptureOptions()
+{
+
+}
+
+sDataCaptureSettings CDataCaptureOptions::getSettings() const
+{
+	return m_Settings;
+}
+
+void CDataCaptureOptions::SetChunkRowCount(const LibMCEnv_uint32 nChunkRowCount)
+{
+	if ((nChunkRowCount < DATACAPTURE_MINCHUNKROWCOUNT) || (nChunkRowCount > DATACAPTURE_MAXCHUNKROWCOUNT))
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDDATACAPTUREOPTION, "invalid data capture chunk row count: " + std::to_string(nChunkRowCount));
+
+	m_Settings.m_nChunkRowCount = nChunkRowCount;
+}
+
+LibMCEnv_uint32 CDataCaptureOptions::GetChunkRowCount()
+{
+	return m_Settings.m_nChunkRowCount;
+}
+
+void CDataCaptureOptions::SetSegmentSizeInBytes(const LibMCEnv_uint64 nSegmentSizeInBytes)
+{
+	// 0 disables the rollover.
+	if ((nSegmentSizeInBytes != 0) && (nSegmentSizeInBytes < DATACAPTURE_MINSEGMENTSIZE))
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDDATACAPTUREOPTION, "invalid data capture segment size: " + std::to_string(nSegmentSizeInBytes));
+
+	m_Settings.m_nSegmentSizeInBytes = nSegmentSizeInBytes;
+}
+
+LibMCEnv_uint64 CDataCaptureOptions::GetSegmentSizeInBytes()
+{
+	return m_Settings.m_nSegmentSizeInBytes;
+}
+
+void CDataCaptureOptions::SetMaxQueuedChunks(const LibMCEnv_uint32 nMaxQueuedChunks)
+{
+	if ((nMaxQueuedChunks < DATACAPTURE_MINMAXQUEUEDCHUNKS) || (nMaxQueuedChunks > DATACAPTURE_MAXMAXQUEUEDCHUNKS))
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDDATACAPTUREOPTION, "invalid data capture queue depth: " + std::to_string(nMaxQueuedChunks));
+
+	m_Settings.m_nMaxQueuedChunks = nMaxQueuedChunks;
+}
+
+LibMCEnv_uint32 CDataCaptureOptions::GetMaxQueuedChunks()
+{
+	return m_Settings.m_nMaxQueuedChunks;
+}
+
+void CDataCaptureOptions::SetBackpressureMode(const LibMCEnv::eDataCaptureBackpressureMode eBackpressureMode)
+{
+	switch (eBackpressureMode) {
+	case LibMCEnv::eDataCaptureBackpressureMode::Block:
+	case LibMCEnv::eDataCaptureBackpressureMode::DropOldest:
+	case LibMCEnv::eDataCaptureBackpressureMode::Fail:
+		m_Settings.m_BackpressureMode = eBackpressureMode;
+		break;
+	default:
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDDATACAPTUREOPTION, "invalid data capture backpressure mode");
+	}
+}
+
+LibMCEnv::eDataCaptureBackpressureMode CDataCaptureOptions::GetBackpressureMode()
+{
+	return m_Settings.m_BackpressureMode;
+}
+
+void CDataCaptureOptions::SetStorageLimitInBytes(const LibMCEnv_uint64 nStorageLimitInBytes)
+{
+	m_Settings.m_nStorageLimitInBytes = nStorageLimitInBytes;
+}
+
+LibMCEnv_uint64 CDataCaptureOptions::GetStorageLimitInBytes()
+{
+	return m_Settings.m_nStorageLimitInBytes;
+}
+
+void CDataCaptureOptions::SetCompression(const LibMCEnv::eDataCaptureCompression eCompression)
+{
+	switch (eCompression) {
+	case LibMCEnv::eDataCaptureCompression::None:
+		m_Settings.m_nCodec = DATATABLE_V2_CODEC_NONE;
+		break;
+	case LibMCEnv::eDataCaptureCompression::LZ4:
+		m_Settings.m_nCodec = DATATABLE_V2_CODEC_LZ4;
+		break;
+	case LibMCEnv::eDataCaptureCompression::Deflate:
+		m_Settings.m_nCodec = DATATABLE_V2_CODEC_DEFLATE;
+		break;
+	default:
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDDATACAPTUREOPTION, "invalid data capture compression");
+	}
+}
+
+LibMCEnv::eDataCaptureCompression CDataCaptureOptions::GetCompression()
+{
+	switch (m_Settings.m_nCodec) {
+	case DATATABLE_V2_CODEC_LZ4: return LibMCEnv::eDataCaptureCompression::LZ4;
+	case DATATABLE_V2_CODEC_DEFLATE: return LibMCEnv::eDataCaptureCompression::Deflate;
+	default: return LibMCEnv::eDataCaptureCompression::None;
+	}
+}
+
+void CDataCaptureOptions::SetColumnEncoding(const std::string & sColumnIdentifier, const LibMCEnv::eDataCaptureEncoding eEncoding)
+{
+	if (sColumnIdentifier.empty())
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDDATACAPTUREOPTION, "column identifier of an encoding option is empty");
+
+	switch (eEncoding) {
+	case LibMCEnv::eDataCaptureEncoding::Automatic:
+		m_Settings.m_ColumnEncodings.erase(sColumnIdentifier);
+		break;
+	case LibMCEnv::eDataCaptureEncoding::Plain:
+		m_Settings.m_ColumnEncodings[sColumnIdentifier] = DATATABLE_V2_ENCODING_PLAIN;
+		break;
+	case LibMCEnv::eDataCaptureEncoding::Delta:
+		m_Settings.m_ColumnEncodings[sColumnIdentifier] = DATATABLE_V2_ENCODING_DELTA;
+		break;
+	case LibMCEnv::eDataCaptureEncoding::BitPack:
+		m_Settings.m_ColumnEncodings[sColumnIdentifier] = DATATABLE_V2_ENCODING_BITPACK;
+		break;
+	default:
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDDATACAPTUREOPTION, "invalid data capture encoding");
+	}
+}
+
+void CDataCaptureOptions::SetDoubleQuantization(const std::string & sColumnIdentifier, const LibMCEnv_double dStep)
+{
+	if (sColumnIdentifier.empty())
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDDATACAPTUREOPTION, "column identifier of a quantisation option is empty");
+	if (!std::isfinite(dStep) || (dStep < 0.0))
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDDATACAPTUREOPTION, "invalid quantisation step: " + std::to_string(dStep));
+
+	if (dStep == 0.0)
+		m_Settings.m_ColumnQuantization.erase(sColumnIdentifier);
+	else
+		m_Settings.m_ColumnQuantization[sColumnIdentifier] = dStep;
+}
diff --git a/Implementation/LibMCEnv/libmcenv_datacaptureoptions.hpp b/Implementation/LibMCEnv/libmcenv_datacaptureoptions.hpp
new file mode 100644
index 000000000..bac276ecb
--- /dev/null
+++ b/Implementation/LibMCEnv/libmcenv_datacaptureoptions.hpp
@@ -0,0 +1,108 @@
+/*++
+
+Copyright (C) 2020 Autodesk Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Autodesk Inc. nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL AUTODESK INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+Abstract: This is the class declaration of CDataCaptureOptions
+
+*/
+
+
+#ifndef __LIBMCENV_DATACAPTUREOPTIONS
+#define __LIBMCENV_DATACAPTUREOPTIONS
+
+#include "libmcenv_interfaces.hpp"
+
+// Parent classes
+#include "libmcenv_base.hpp"
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4250)
+#endif
+
+// Include custom headers here.
+#include "libmcenv_datacaptureinstance.hpp"
+
+namespace LibMCEnv {
+namespace Impl {
+
+
+/*************************************************************************************************************************
+ Class declaration of CDataCaptureOptions
+**************************************************************************************************************************/
+
+class CDataCaptureOptions : public virtual IDataCaptureOptions, public virtual CBase {
+private:
+
+	sDataCaptureSettings m_Settings;
+
+public:
+
+	CDataCaptureOptions();
+
+	virtual ~CDataCaptureOptions();
+
+	// Returns a copy of the validated settings.
+	sDataCaptureSettings getSettings() const;
+
+	void SetChunkRowCount(const LibMCEnv_uint32 nChunkRowCount) override;
+
+	LibMCEnv_uint32 GetChunkRowCount() override;
+
+	void SetSegmentSizeInBytes(const LibMCEnv_uint64 nSegmentSizeInBytes) override;
+
+	LibMCEnv_uint64 GetSegmentSizeInBytes() override;
+
+	void SetMaxQueuedChunks(const LibMCEnv_uint32 nMaxQueuedChunks) override;
+
+	LibMCEnv_uint32 GetMaxQueuedChunks() override;
+
+	void SetBackpressureMode(const LibMCEnv::eDataCaptureBackpressureMode eBackpressureMode) override;
+
+	LibMCEnv::eDataCaptureBackpressureMode GetBackpressureMode() override;
+
+	void SetStorageLimitInBytes(const LibMCEnv_uint64 nStorageLimitInBytes) override;
+
+	LibMCEnv_uint64 GetStorageLimitInBytes() override;
+
+	void SetCompression(const LibMCEnv::eDataCaptureCompression eCompression) override;
+
+	LibMCEnv::eDataCaptureCompression GetCompression() override;
+
+	void SetColumnEncoding(const std::string & sColumnIdentifier, const LibMCEnv::eDataCaptureEncoding eEncoding) override;
+
+	void SetDoubleQuantization(const std::string & sColumnIdentifier, const LibMCEnv_double dStep) override;
+
+};
+
+} // namespace Impl
+} // namespace LibMCEnv
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+#endif // __LIBMCENV_DATACAPTUREOPTIONS
diff --git a/Implementation/LibMCEnv/libmcenv_datatable.cpp b/Implementation/LibMCEnv/libmcenv_datatable.cpp
index c047b10ad..b075ffa3d 100644
--- a/Implementation/LibMCEnv/libmcenv_datatable.cpp
+++ b/Implementation/LibMCEnv/libmcenv_datatable.cpp
@@ -49,9 +49,82 @@ Abstract: This is a stub class definition of CDataTable
 
 #include "amc_constants.hpp"
 #include "amc_scatterplot.hpp"
+#include "amc_datatableformat.hpp"
 
 using namespace LibMCEnv::Impl;
 
+namespace {
+
+	// Clears a data table during stack unwinding, so that a failed load never leaves a partially loaded table behind.
+	class CDataTableClearGuard {
+	private:
+		CDataTable* m_pTable;
+		bool m_bArmed;
+
+	public:
+		explicit CDataTableClearGuard(CDataTable* pTable)
+			: m_pTable(pTable), m_bArmed(true)
+		{
+		}
+
+		~CDataTableClearGuard()
+		{
+			if (m_bArmed)
+				m_pTable->Clear();
+		}
+
+		void dismiss()
+		{
+			m_bArmed = false;
+		}
+	};
+
+}
+
+LibMCEnvResult CDataTable::formatErrorToResult(AMC::eDataTableFormatError formatError)
+{
+	switch (formatError) {
+	case AMC::eDataTableFormatError::InvalidSignature: return LIBMCENV_ERROR_INVALIDDATATABLESIGNATURE;
+	case AMC::eDataTableFormatError::UnsupportedVersion: return LIBMCENV_ERROR_UNSUPPORTEDDATATABLEVERSION;
+	case AMC::eDataTableFormatError::UnsupportedCodec: return LIBMCENV_ERROR_UNSUPPORTEDDATATABLECODEC;
+	case AMC::eDataTableFormatError::UnsupportedEncoding: return LIBMCENV_ERROR_UNSUPPORTEDDATATABLEENCODING;
+	case AMC::eDataTableFormatError::InvalidDataType: return LIBMCENV_ERROR_INVALIDCOLUMNDATATYPE;
+	case AMC::eDataTableFormatError::Truncated: return LIBMCENV_ERROR_DATATABLESEGMENTTRUNCATED;
+	case AMC::eDataTableFormatError::Corrupt: return LIBMCENV_ERROR_INVALIDDATATABLESEGMENT;
+	case AMC::eDataTableFormatError::InvalidRange: return LIBMCENV_ERROR_INVALIDDATATABLEROWRANGE;
+	case AMC::eDataTableFormatError::SegmentPurged: return LIBMCENV_ERROR_DATACAPTURESEGMENTPURGED;
+	case AMC::eDataTableFormatError::ColumnNotFound: return LIBMCENV_ERROR_DATACAPTURECOLUMNNOTFOUND;
+	case AMC::eDataTableFormatError::TypeMismatch: return LIBMCENV_ERROR_DATATABLECOLUMNTYPEMISMATCH;
+	default: return LIBMCENV_ERROR_INVALIDPARAM;
+	}
+}
+
+CDataTableColumn* CDataTable::getColumnByIndex(uint32_t nColumnIndex)
+{
+	if (nColumnIndex >= m_Columns.size())
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCOLUMNINDEX);
+
+	return m_Columns.at(nColumnIndex).get();
+}
+
+CDataTableColumn* CDataTable::findColumnByIdentifier(const std::string& sIdentifier)
+{
+	return findColumn(sIdentifier, false);
+}
+
+void CDataTable::setColumnPlainData(const std::string& sIdentifier, uint64_t nRowCount, const std::function<void(uint8_t* pPlainValues, uint64_t nSizeInBytes)>& fillCallback)
+{
+	auto pColumn = findColumn(sIdentifier, true);
+
+	uint8_t* pPlainValues = pColumn->resizeRawData(nRowCount);
+	if (nRowCount > 0) {
+		fillCallback(pPlainValues, nRowCount * pColumn->getEntrySizeInBytes());
+		pColumn->rawDataChanged();
+	}
+
+	updateMaxRowCount();
+}
+
 
 #pragma pack(push)
 #pragma pack(1)
@@ -112,6 +185,29 @@ void CDataTableColumn::writeUint64ToBuffer(uint64_t nValue, std::vector<char>& b
 
 }
 
+void CDataTableColumn::writeQuantizedDoubleToBuffer(double dValue, uint64_t nQuantizationFactor, uint32_t nQuantizationDigits, std::vector<char>& buffer, size_t& nBufferPosition)
+{
+	uint64_t nQuantizedValue;
+
+	if (dValue >= 0.0) {
+		nQuantizedValue = (uint64_t)round(dValue * (double)nQuantizationFactor);
+	}
+	else {
+		nQuantizedValue = (uint64_t)round((-dValue) * (double)nQuantizationFactor);
+
+		buffer.at(nBufferPosition) = '-';
+		nBufferPosition++;
+	}
+
+	uint64_t nIntegerValue = nQuantizedValue / nQuantizationFactor;
+	uint64_t nFracValue = nQuantizedValue % nQuantizationFactor;
+
+	writeUint64ToBuffer(nIntegerValue, buffer, nBufferPosition);
+	buffer.at(nBufferPosition) = '.';
+	nBufferPosition++;
+	writeUint64ToBufferFixedDigits(nFracValue, nQuantizationDigits, buffer, nBufferPosition);
+}
+
 
 class CDataTableColumn_Double : public CDataTableColumn 
 {
@@ -222,6 +318,12 @@ class CDataTableColumn_Double : public CDataTableColumn
 		return sizeof(double);
 	}
 
+	uint8_t* resizeRawData(uint64_t nEntryCount) override
+	{
+		m_Rows.resize(nEntryCount);
+		return (uint8_t*)m_Rows.data();
+	}
+
 	void WriteDataToStream(ITempStreamWriter* pWriter) override
 	{
 		if (pWriter == nullptr)
@@ -416,6 +518,12 @@ class CDataTableColumn_Uint32 : public CDataTableColumn
 		return sizeof(uint32_t);
 	}
 
+	uint8_t* resizeRawData(uint64_t nEntryCount) override
+	{
+		m_Rows.resize(nEntryCount);
+		return (uint8_t*)m_Rows.data();
+	}
+
 	void WriteDataToStream(ITempStreamWriter* pWriter) override
 	{
 		if (pWriter == nullptr)
@@ -602,6 +710,12 @@ class CDataTableColumn_Uint64 : public CDataTableColumn
 		return sizeof(uint64_t);
 	}
 
+	uint8_t* resizeRawData(uint64_t nEntryCount) override
+	{
+		m_Rows.resize(nEntryCount);
+		return (uint8_t*)m_Rows.data();
+	}
+
 	void WriteDataToStream(ITempStreamWriter* pWriter) override
 	{
 		if (pWriter == nullptr)
@@ -770,6 +884,12 @@ class CDataTableColumn_Int32 : public CDataTableColumn
 		return sizeof(int32_t);
 	}
 
+	uint8_t* resizeRawData(uint64_t nEntryCount) override
+	{
+		m_Rows.resize(nEntryCount);
+		return (uint8_t*)m_Rows.data();
+	}
+
 	void WriteDataToStream(ITempStreamWriter* pWriter) override
 	{
 		if (pWriter == nullptr)
@@ -963,6 +1083,12 @@ class CDataTableColumn_Int64 : public CDataTableColumn
 		return sizeof(int64_t);
 	}
 
+	uint8_t* resizeRawData(uint64_t nEntryCount) override
+	{
+		m_Rows.resize(nEntryCount);
+		return (uint8_t*)m_Rows.data();
+	}
+
 	void WriteDataToStream(ITempStreamWriter* pWriter) override
 	{
 		if (pWriter == nullptr)
@@ -1040,6 +1166,307 @@ class CDataTableColumn_Int64 : public CDataTableColumn
 
 };
 
+
+/*************************************************************************************************************************
+ Fixed-width column template for the column types added in format phase 0 (Float, Bool, Timestamp).
+ Rows are held in a flat std::vector<T> and written to the stream as a raw value array, exactly like
+ the five original column types. Bit-packing and delta encoding arrive with format version 2.
+**************************************************************************************************************************/
+
+template <typename T>
+class CDataTableColumn_FixedWidth : public CDataTableColumn
+{
+protected:
+
+	std::vector <T> m_Rows;
+
+public:
+
+	CDataTableColumn_FixedWidth(const std::string& sIdentifier, const std::string& sDescription)
+		: CDataTableColumn(sIdentifier, sDescription)
+	{
+
+	}
+
+	virtual ~CDataTableColumn_FixedWidth()
+	{
+
+	}
+
+	size_t getRowCount() override
+	{
+		return m_Rows.size();
+	}
+
+	void copyDataTo(T* pBuffer, size_t nBufferSize)
+	{
+		if (nBufferSize > 0) {
+			if (pBuffer == nullptr)
+				throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_COLUMNBUFFERISNULL);
+
+			size_t nCopyCount = nBufferSize;
+			if (nCopyCount > m_Rows.size())
+				nCopyCount = m_Rows.size();
+
+			for (size_t nIndex = 0; nIndex < nCopyCount; nIndex++)
+				pBuffer[nIndex] = m_Rows.at(nIndex);
+
+			// Fill up buffer with 0 as value, when buffer is larger than the row count of the column
+			for (size_t nFillIndex = nCopyCount; nFillIndex < nBufferSize; nFillIndex++)
+				pBuffer[nFillIndex] = (T)0;
+		}
+	}
+
+	virtual void copyDataFrom(const T* pBuffer, size_t nBufferSize)
+	{
+		m_Rows.resize(nBufferSize);
+
+		if (nBufferSize > 0) {
+
+			if (pBuffer == nullptr)
+				throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_COLUMNBUFFERISNULL);
+
+			for (size_t nIndex = 0; nIndex < nBufferSize; nIndex++)
+				m_Rows.at(nIndex) = pBuffer[nIndex];
+
+		}
+	}
+
+	size_t getEntrySizeInBytes() override
+	{
+		return sizeof(T);
+	}
+
+	uint8_t* resizeRawData(uint64_t nEntryCount) override
+	{
+		m_Rows.resize(nEntryCount);
+		return (uint8_t*)m_Rows.data();
+	}
+
+	void WriteDataToStream(ITempStreamWriter* pWriter) override
+	{
+		if (pWriter == nullptr)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDPARAM);
+
+		if (m_Rows.size() > 0) {
+			pWriter->WriteData(m_Rows.size() * getEntrySizeInBytes(), (uint8_t*)m_Rows.data());
+		}
+	}
+
+	void ReadDataFromStream(IStreamReader* pReader, uint64_t nEntryCount) override
+	{
+		if (pReader == nullptr)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDPARAM);
+
+		if (nEntryCount > 0) {
+			m_Rows.resize(nEntryCount);
+			size_t nBufferSize = m_Rows.size() * getEntrySizeInBytes();
+
+			pReader->ReadData(nBufferSize, nBufferSize, nullptr, (uint8_t*)m_Rows.data());
+
+		}
+		else {
+			m_Rows.resize(0);
+		}
+	}
+
+	void fillScatterplotXCoordinates(AMC::CScatterplot* pScatterplot, double dScaleFactor, double dOffset) override
+	{
+		if (pScatterplot == nullptr)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDPARAM);
+
+		auto& entries = pScatterplot->getEntries();
+		size_t entryCount = entries.size();
+		size_t rowCount = m_Rows.size();
+
+		for (size_t nIndex = 0; nIndex < entryCount; nIndex++) {
+			auto& entry = entries.at(nIndex);
+			if (nIndex < rowCount) {
+				entry.m_dX = (double)m_Rows.at(nIndex) * dScaleFactor + dOffset;
+			}
+			else {
+				entry.m_dX = 0.0;
+			}
+		}
+	}
+
+	void fillScatterplotYCoordinates(AMC::CScatterplot* pScatterplot, double dScaleFactor, double dOffset) override
+	{
+		if (pScatterplot == nullptr)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDPARAM);
+
+		auto& entries = pScatterplot->getEntries();
+		size_t entryCount = entries.size();
+		size_t rowCount = m_Rows.size();
+
+		for (size_t nIndex = 0; nIndex < entryCount; nIndex++) {
+			auto& entry = entries.at(nIndex);
+			if (nIndex < rowCount) {
+				entry.m_dY = (double)m_Rows.at(nIndex) * dScaleFactor + dOffset;
+			}
+			else {
+				entry.m_dY = 0.0;
+			}
+		}
+	}
+
+	void fillScatterplotChannel(AMC::CScatterplot* pScatterplot, const std::string& sChannel, const std::string& sColumn, double dScaleFactor, double dOffset) override
+	{
+		if (pScatterplot == nullptr)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDPARAM);
+
+		auto& channelEntries = pScatterplot->getChannelEntries();
+		auto channelIter = channelEntries.find(sChannel);
+
+		if (channelIter == channelEntries.end()) {
+			channelEntries[sChannel][sColumn] = std::vector<double>();
+		}
+		else {
+			auto& columnEntries = channelIter->second;
+
+			if (columnEntries.find(sColumn) == columnEntries.end())
+				columnEntries[sColumn] = std::vector<double>();
+			else {
+				std::string sException = "The channel = " + sChannel + " with the column = " + sColumn + " already exists";
+				throw std::runtime_error(sException.c_str());
+			}
+		}
+
+		auto& vecColumn = channelEntries[sChannel][sColumn];
+
+		vecColumn.resize(m_Rows.size());
+
+		for (size_t nIndex = 0; nIndex < m_Rows.size(); nIndex++) {
+			vecColumn[nIndex] = (double)m_Rows.at(nIndex) * dScaleFactor + dOffset;
+		}
+	}
+
+};
+
+
+class CDataTableColumn_Float : public CDataTableColumn_FixedWidth<float>
+{
+private:
+
+	uint64_t m_nCSVQuantizationFactor;
+	uint32_t m_nCSVQuantizationDigits;
+
+public:
+
+	CDataTableColumn_Float(const std::string& sIdentifier, const std::string& sDescription)
+		: CDataTableColumn_FixedWidth<float>(sIdentifier, sDescription)
+	{
+		// Same CSV export rounding as the double column.
+		m_nCSVQuantizationDigits = 3;
+		m_nCSVQuantizationFactor = 1ULL;
+		for (uint32_t nIndex = 0; nIndex < m_nCSVQuantizationDigits; nIndex++)
+			m_nCSVQuantizationFactor *= 10;
+	}
+
+	LibMCEnv::eDataTableColumnType getColumnType() override
+	{
+		return LibMCEnv::eDataTableColumnType::FloatColumn;
+	}
+
+	void writeCSVValue(size_t nRowIndex, std::vector<char>& buffer, size_t& nBufferPosition) override
+	{
+		if (nRowIndex < m_Rows.size()) {
+			writeQuantizedDoubleToBuffer((double)m_Rows[nRowIndex], m_nCSVQuantizationFactor, m_nCSVQuantizationDigits, buffer, nBufferPosition);
+		}
+		else {
+			buffer.at(nBufferPosition) = '0';
+			nBufferPosition++;
+		}
+	}
+
+};
+
+
+class CDataTableColumn_Bool : public CDataTableColumn_FixedWidth<uint8_t>
+{
+private:
+
+	void normalizeRows()
+	{
+		for (auto& nValue : m_Rows)
+			nValue = (nValue != 0) ? 1 : 0;
+	}
+
+public:
+
+	CDataTableColumn_Bool(const std::string& sIdentifier, const std::string& sDescription)
+		: CDataTableColumn_FixedWidth<uint8_t>(sIdentifier, sDescription)
+	{
+
+	}
+
+	LibMCEnv::eDataTableColumnType getColumnType() override
+	{
+		return LibMCEnv::eDataTableColumnType::BoolColumn;
+	}
+
+	// Values cross the ABI as bytes; any nonzero byte is true and is stored as 1.
+	void copyDataFrom(const uint8_t* pBuffer, size_t nBufferSize) override
+	{
+		CDataTableColumn_FixedWidth<uint8_t>::copyDataFrom(pBuffer, nBufferSize);
+		normalizeRows();
+	}
+
+	void ReadDataFromStream(IStreamReader* pReader, uint64_t nEntryCount) override
+	{
+		CDataTableColumn_FixedWidth<uint8_t>::ReadDataFromStream(pReader, nEntryCount);
+		normalizeRows();
+	}
+
+	void rawDataChanged() override
+	{
+		normalizeRows();
+	}
+
+	void writeCSVValue(size_t nRowIndex, std::vector<char>& buffer, size_t& nBufferPosition) override
+	{
+		if ((nRowIndex < m_Rows.size()) && (m_Rows[nRowIndex] != 0)) {
+			buffer.at(nBufferPosition) = '1';
+		}
+		else {
+			buffer.at(nBufferPosition) = '0';
+		}
+		nBufferPosition++;
+	}
+
+};
+
+
+class CDataTableColumn_Timestamp : public CDataTableColumn_FixedWidth<uint64_t>
+{
+public:
+
+	CDataTableColumn_Timestamp(const std::string& sIdentifier, const std::string& sDescription)
+		: CDataTableColumn_FixedWidth<uint64_t>(sIdentifier, sDescription)
+	{
+
+	}
+
+	LibMCEnv::eDataTableColumnType getColumnType() override
+	{
+		return LibMCEnv::eDataTableColumnType::TimestampColumn;
+	}
+
+	// Timestamps are microseconds and are exported as plain integers.
+	void writeCSVValue(size_t nRowIndex, std::vector<char>& buffer, size_t& nBufferPosition) override
+	{
+		if (nRowIndex < m_Rows.size()) {
+			writeUint64ToBuffer(m_Rows[nRowIndex], buffer, nBufferPosition);
+		}
+		else {
+			buffer.at(nBufferPosition) = '0';
+			nBufferPosition++;
+		}
+	}
+
+};
+
+
 CDataTableColumn::CDataTableColumn(const std::string& sIdentifier, const std::string& sDescription)
 	: m_sIdentifier (sIdentifier), m_sDescription (sDescription)
 {
@@ -1066,6 +1493,16 @@ std::string CDataTableColumn::getDescription()
 	return m_sDescription;
 }
 
+void CDataTableColumn::rawDataChanged()
+{
+}
+
+const uint8_t* CDataTableColumn::getRawData()
+{
+	// Resizing to the current row count changes nothing and returns the value array.
+	return resizeRawData(getRowCount());
+}
+
 void CDataTableColumn::setDescription(const std::string& sDescription)
 {
 	m_sDescription = sDescription;
@@ -1130,6 +1567,15 @@ PDataTableColumn CDataTable::addColumnEx(const std::string& sIdentifier, const s
 	case LibMCEnv::eDataTableColumnType::Int64Column:
 		pColumn = std::make_shared<CDataTableColumn_Int64>(sIdentifier, sDescription);
 		break;
+	case LibMCEnv::eDataTableColumnType::FloatColumn:
+		pColumn = std::make_shared<CDataTableColumn_Float>(sIdentifier, sDescription);
+		break;
+	case LibMCEnv::eDataTableColumnType::BoolColumn:
+		pColumn = std::make_shared<CDataTableColumn_Bool>(sIdentifier, sDescription);
+		break;
+	case LibMCEnv::eDataTableColumnType::TimestampColumn:
+		pColumn = std::make_shared<CDataTableColumn_Timestamp>(sIdentifier, sDescription);
+		break;
 	default:
 		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCOLUMNDATATYPE);
 	}
@@ -1173,9 +1619,16 @@ CDataTableColumn* CDataTable::findColumn(const std::string& sIdentifier, bool bM
 
 LibMCEnv_uint32 CDataTable::GetRowCount()
 {
+	// Kept for ABI compatibility. Row counts above the uint32 range are truncated here;
+	// GetRowCount64 returns the full value.
 	return (uint32_t) m_nMaxRowCount;
 }
 
+LibMCEnv_uint64 CDataTable::GetRowCount64()
+{
+	return (uint64_t) m_nMaxRowCount;
+}
+
 LibMCEnv_uint32 CDataTable::GetColumnCount()
 {
 	return (uint32_t)m_Columns.size();
@@ -1384,6 +1837,105 @@ void CDataTable::SetUint64ColumnValues(const std::string & sIdentifier, const Li
 }
 
 
+void CDataTable::GetFloatColumnValues(const std::string & sIdentifier, LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_single * pValuesBuffer)
+{
+	auto pColumn = findColumn(sIdentifier, true);
+	auto pFloatColumn = dynamic_cast<CDataTableColumn_Float*> (pColumn);
+
+	if (pFloatColumn == nullptr)
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_COLUMNISNOTOFTYPEFLOAT, "column is not of type float: " + sIdentifier);
+
+	if (pValuesNeededCount != nullptr)
+		*pValuesNeededCount = m_nMaxRowCount;
+
+	if (pValuesBuffer != nullptr)
+	{
+		if (nValuesBufferSize < m_nMaxRowCount)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_BUFFERTOOSMALL);
+
+		pFloatColumn->copyDataTo(pValuesBuffer, m_nMaxRowCount);
+	}
+}
+
+void CDataTable::GetBoolColumnValues(const std::string & sIdentifier, LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_uint8 * pValuesBuffer)
+{
+	auto pColumn = findColumn(sIdentifier, true);
+	auto pBoolColumn = dynamic_cast<CDataTableColumn_Bool*> (pColumn);
+
+	if (pBoolColumn == nullptr)
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_COLUMNISNOTOFTYPEBOOL, "column is not of type bool: " + sIdentifier);
+
+	if (pValuesNeededCount != nullptr)
+		*pValuesNeededCount = m_nMaxRowCount;
+
+	if (pValuesBuffer != nullptr)
+	{
+		if (nValuesBufferSize < m_nMaxRowCount)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_BUFFERTOOSMALL);
+
+		pBoolColumn->copyDataTo(pValuesBuffer, m_nMaxRowCount);
+	}
+}
+
+void CDataTable::GetTimestampColumnValues(const std::string & sIdentifier, LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_uint64 * pValuesBuffer)
+{
+	auto pColumn = findColumn(sIdentifier, true);
+	auto pTimestampColumn = dynamic_cast<CDataTableColumn_Timestamp*> (pColumn);
+
+	if (pTimestampColumn == nullptr)
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_COLUMNISNOTOFTYPETIMESTAMP, "column is not of type timestamp: " + sIdentifier);
+
+	if (pValuesNeededCount != nullptr)
+		*pValuesNeededCount = m_nMaxRowCount;
+
+	if (pValuesBuffer != nullptr)
+	{
+		if (nValuesBufferSize < m_nMaxRowCount)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_BUFFERTOOSMALL);
+
+		pTimestampColumn->copyDataTo(pValuesBuffer, m_nMaxRowCount);
+	}
+}
+
+void CDataTable::SetFloatColumnValues(const std::string & sIdentifier, const LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_single * pValuesBuffer)
+{
+	auto pColumn = findColumn(sIdentifier, true);
+	auto pFloatColumn = dynamic_cast<CDataTableColumn_Float*> (pColumn);
+
+	if (pFloatColumn == nullptr)
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_COLUMNISNOTOFTYPEFLOAT, "column is not of type float: " + sIdentifier);
+
+	pFloatColumn->copyDataFrom(pValuesBuffer, nValuesBufferSize);
+
+	updateMaxRowCount();
+}
+
+void CDataTable::SetBoolColumnValues(const std::string & sIdentifier, const LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint8 * pValuesBuffer)
+{
+	auto pColumn = findColumn(sIdentifier, true);
+	auto pBoolColumn = dynamic_cast<CDataTableColumn_Bool*> (pColumn);
+
+	if (pBoolColumn == nullptr)
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_COLUMNISNOTOFTYPEBOOL, "column is not of type bool: " + sIdentifier);
+
+	pBoolColumn->copyDataFrom(pValuesBuffer, nValuesBufferSize);
+
+	updateMaxRowCount();
+}
+
+void CDataTable::SetTimestampColumnValues(const std::string & sIdentifier, const LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint64 * pValuesBuffer)
+{
+	auto pColumn = findColumn(sIdentifier, true);
+	auto pTimestampColumn = dynamic_cast<CDataTableColumn_Timestamp*> (pColumn);
+
+	if (pTimestampColumn == nullptr)
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_COLUMNISNOTOFTYPETIMESTAMP, "column is not of type timestamp: " + sIdentifier);
+
+	pTimestampColumn->copyDataFrom(pValuesBuffer, nValuesBufferSize);
+
+	updateMaxRowCount();
+}
+
 void CDataTable::updateMaxRowCount()
 {
 	m_nMaxRowCount = 0;
@@ -1498,6 +2050,7 @@ void CDataTable::WriteDataToStream(ITempStreamWriter* pWriter, IDataTableWriteOp
 
 	uint64_t currentDataStart = sizeof (header);
 	header.m_nSignature = DATATABLE_HEADERSIGNATURE;
+	header.m_nVersion = DATATABLE_CURRENTFORMATVERSION;
 	header.m_nColumnTableStart = currentDataStart;
 	header.m_nColumnCount = (uint32_t)m_Columns.size();
 	pWriter->WriteData(sizeof (header), (uint8_t*)&header);
@@ -1549,6 +2102,70 @@ void CDataTable::LoadFromStream(IStreamReader* pStream)
 	if (pStream == nullptr)
 		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDPARAM);
 
+	uint64_t nStreamSize = pStream->GetSize();
+
+	// The signature selects the format: the chunked columnar format (version 2) carries its own
+	// signature, so that it is never interpreted as a version 1 column table.
+	uint32_t nSignature = 0;
+	pStream->Seek(0);
+	pStream->ReadData(sizeof(nSignature), sizeof(nSignature), nullptr, (uint8_t*)&nSignature);
+
+	if (nSignature == DATATABLE_HEADERSIGNATURE_V2)
+		loadFromStreamV2(pStream, nStreamSize);
+	else
+		loadFromStreamV1(pStream, nStreamSize);
+}
+
+void CDataTable::loadFromStreamV2(IStreamReader* pStream, uint64_t nStreamSize)
+{
+	CDataTableClearGuard clearOnFailure(this);
+
+	try {
+
+		AMC::CDataTableV2SegmentReader segmentReader([pStream](uint64_t nOffset, uint64_t nSize, uint8_t* pBuffer) {
+			if (nSize > 0) {
+				pStream->Seek(nOffset);
+				pStream->ReadData(nSize, nSize, nullptr, pBuffer);
+			}
+		}, nStreamSize);
+
+		uint64_t nRowCount = segmentReader.getRowCount();
+		uint32_t nChunkCount = segmentReader.getChunkCount();
+		uint32_t nColumnCount = segmentReader.getColumnCount();
+
+		for (uint32_t nColumnIndex = 0; nColumnIndex < nColumnCount; nColumnIndex++) {
+			auto& column = segmentReader.getColumn(nColumnIndex);
+			auto pColumn = addColumnEx(column.m_sIdentifier, column.m_sDescription, (LibMCEnv::eDataTableColumnType)column.m_DataType);
+
+			if (nRowCount > 0) {
+				uint64_t nEntrySize = pColumn->getEntrySizeInBytes();
+				uint8_t* pColumnData = pColumn->resizeRawData(nRowCount);
+
+				uint64_t nRowOffset = 0;
+				for (uint32_t nChunkIndex = 0; nChunkIndex < nChunkCount; nChunkIndex++) {
+					segmentReader.readPage(nChunkIndex, nColumnIndex, pColumnData + nRowOffset * nEntrySize, (nRowCount - nRowOffset) * nEntrySize);
+					nRowOffset += segmentReader.getChunkRowCount(nChunkIndex);
+				}
+
+				pColumn->rawDataChanged();
+			}
+		}
+
+	}
+	catch (const AMC::EDataTableFormatException& formatException) {
+		throw ELibMCEnvInterfaceException(formatErrorToResult(formatException.getError()), formatException.what());
+	}
+
+	clearOnFailure.dismiss();
+
+	updateMaxRowCount();
+}
+
+void CDataTable::loadFromStreamV1(IStreamReader* pStream, uint64_t nStreamSize)
+{
+	if (nStreamSize < sizeof(sLibMCDataTableStreamHeader))
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDDATATABLESIGNATURE, "stream is too small for a datatable");
+
 	sLibMCDataTableStreamHeader header;
 	memset((void*)&header, 0, sizeof(header));
 
@@ -1558,11 +2175,18 @@ void CDataTable::LoadFromStream(IStreamReader* pStream)
 	if (header.m_nSignature != DATATABLE_HEADERSIGNATURE)
 		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDDATATABLESIGNATURE);
 
+	// Files written before the version field was populated carry 0 and are format version 1.
+	if ((header.m_nVersion != DATATABLE_FORMATVERSION_UNVERSIONED) && (header.m_nVersion != DATATABLE_FORMATVERSION_1))
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_UNSUPPORTEDDATATABLEVERSION, "unsupported datatable format version: " + std::to_string(header.m_nVersion));
+
 	if (header.m_nColumnCount >= DATATABLE_MAXCOLUMNCOUNT)
 		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DATATABLEHASTOOMANYCOLUMS);
 
 	if (header.m_nColumnCount > 0) {
 
+		if (header.m_nColumnTableStart < sizeof(header))
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDDATATABLECOLUMNHEADER, "column table overlaps the stream header");
+
 		std::vector<sLibMCDataTableColumnHeader> columnHeaders;
 		columnHeaders.resize(header.m_nColumnCount);
 
@@ -1571,35 +2195,64 @@ void CDataTable::LoadFromStream(IStreamReader* pStream)
 		pStream->Seek(header.m_nColumnTableStart);
 		pStream->ReadData(nBufferSize, nBufferSize, nullptr, (uint8_t*)columnHeaders.data());
 
-		for (auto & columnHeader : columnHeaders) {
-			std::vector<uint8_t> identifierBytes;
-			std::vector<uint8_t> descriptionBytes;
+		// Never leave a partially loaded table behind: if any check or read below throws,
+		// the guard clears the table during stack unwinding.
+		CDataTableClearGuard clearOnFailure(this);
 
-			identifierBytes.resize((size_t)columnHeader.m_nIdentifierLength + 1);
-			descriptionBytes.resize((size_t)columnHeader.m_nDescriptionLength + 1);
+		{
 
-			if (columnHeader.m_nIdentifierLength > 0) {
-				pStream->Seek(columnHeader.m_nIdentifierStart);
-				pStream->ReadData(columnHeader.m_nIdentifierLength, columnHeader.m_nIdentifierLength, nullptr, identifierBytes.data());
-			}
+			for (auto& columnHeader : columnHeaders) {
 
-			if (columnHeader.m_nDescriptionLength > 0) {
-				pStream->Seek(columnHeader.m_nDescriptionStart);
-				pStream->ReadData(columnHeader.m_nDescriptionLength, columnHeader.m_nDescriptionLength, nullptr, descriptionBytes.data());
-			}
+				// RAW is the only encoding of format version 1. Anything else would be read as garbage.
+				if (columnHeader.m_nEncodingType != DATATABLE_ENCODINGTYPE_RAW)
+					throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_UNSUPPORTEDDATATABLEENCODING, "unsupported datatable column encoding: " + std::to_string(columnHeader.m_nEncodingType));
 
-			identifierBytes.at(columnHeader.m_nIdentifierLength) = 0;
-			descriptionBytes.at(columnHeader.m_nDescriptionLength) = 0;
+				// Validate all offsets against the stream size before allocating or reading anything,
+				// so that a truncated or corrupted stream fails with a datatable-specific error.
+				if ((columnHeader.m_nIdentifierStart > nStreamSize) || (columnHeader.m_nIdentifierLength > nStreamSize - columnHeader.m_nIdentifierStart))
+					throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDDATATABLECOLUMNHEADER, "column identifier exceeds the end of the stream");
+				if ((columnHeader.m_nDescriptionStart > nStreamSize) || (columnHeader.m_nDescriptionLength > nStreamSize - columnHeader.m_nDescriptionStart))
+					throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDDATATABLECOLUMNHEADER, "column description exceeds the end of the stream");
 
-			std::string sIdentifier((char*)identifierBytes.data());
-			std::string sDescription((char*)descriptionBytes.data());
+				std::vector<uint8_t> identifierBytes;
+				std::vector<uint8_t> descriptionBytes;
+
+				identifierBytes.resize((size_t)columnHeader.m_nIdentifierLength + 1);
+				descriptionBytes.resize((size_t)columnHeader.m_nDescriptionLength + 1);
+
+				if (columnHeader.m_nIdentifierLength > 0) {
+					pStream->Seek(columnHeader.m_nIdentifierStart);
+					pStream->ReadData(columnHeader.m_nIdentifierLength, columnHeader.m_nIdentifierLength, nullptr, identifierBytes.data());
+				}
+
+				if (columnHeader.m_nDescriptionLength > 0) {
+					pStream->Seek(columnHeader.m_nDescriptionStart);
+					pStream->ReadData(columnHeader.m_nDescriptionLength, columnHeader.m_nDescriptionLength, nullptr, descriptionBytes.data());
+				}
+
+				identifierBytes.at(columnHeader.m_nIdentifierLength) = 0;
+				descriptionBytes.at(columnHeader.m_nDescriptionLength) = 0;
+
+				std::string sIdentifier((char*)identifierBytes.data());
+				std::string sDescription((char*)descriptionBytes.data());
+
+				auto pColumn = addColumnEx(sIdentifier, sDescription, (LibMCEnv::eDataTableColumnType)columnHeader.m_nColumnDataType);
+
+				uint64_t nEntrySize = pColumn->getEntrySizeInBytes();
+				if (columnHeader.m_nColumnDataStart > nStreamSize)
+					throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDDATATABLECOLUMNHEADER, "column data of " + sIdentifier + " starts beyond the end of the stream");
+				if (columnHeader.m_nEntryCount > (nStreamSize - columnHeader.m_nColumnDataStart) / nEntrySize)
+					throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDDATATABLECOLUMNHEADER, "column data of " + sIdentifier + " exceeds the end of the stream");
+
+				pStream->Seek(columnHeader.m_nColumnDataStart);
+				pColumn->ReadDataFromStream(pStream, columnHeader.m_nEntryCount);
+
+			}
 
-			auto pColumn = addColumnEx(sIdentifier, sDescription, (LibMCEnv::eDataTableColumnType)columnHeader.m_nColumnDataType);
-			pStream->Seek(columnHeader.m_nColumnDataStart);
-			pColumn->ReadDataFromStream(pStream, columnHeader.m_nEntryCount);
-			
 		}
 
+		clearOnFailure.dismiss();
+
 		updateMaxRowCount();
 
 	}
@@ -1625,7 +2278,7 @@ IScatterPlot* CDataTable::CalculateScatterPlot(IDataTableScatterPlotOptions* pSc
 
 	std::string sNewUUID = AMCCommon::CUtils::createUUID();
 
-	uint32_t nPointCount = GetRowCount();
+	size_t nPointCount = m_nMaxRowCount;
 
 	std::string sXAxisColumn = pScatterPlotInput->GetXAxisColumn();
 	if (sXAxisColumn.empty ())
diff --git a/Implementation/LibMCEnv/libmcenv_datatable.hpp b/Implementation/LibMCEnv/libmcenv_datatable.hpp
index 15b890772..525b9b672 100644
--- a/Implementation/LibMCEnv/libmcenv_datatable.hpp
+++ b/Implementation/LibMCEnv/libmcenv_datatable.hpp
@@ -47,7 +47,9 @@ Abstract: This is the class declaration of CDataTable
 
 // Include custom headers here.
 #include <map>
+#include <functional>
 #include "amc_scatterplot.hpp"
+#include "amc_datatableformat.hpp"
 
 namespace LibMCEnv {
 namespace Impl {
@@ -68,6 +70,7 @@ class CDataTableColumn
 
 	void writeUint64ToBufferFixedDigits(uint64_t nValue, uint32_t nFixedDigits, std::vector<char>& buffer, size_t& nBufferPosition);
 	void writeUint64ToBuffer(uint64_t nValue, std::vector<char>& buffer, size_t& nBufferPosition);
+	void writeQuantizedDoubleToBuffer(double dValue, uint64_t nQuantizationFactor, uint32_t nQuantizationDigits, std::vector<char>& buffer, size_t& nBufferPosition);
 
 public:
 
@@ -93,6 +96,16 @@ class CDataTableColumn
 
 	virtual size_t getEntrySizeInBytes() = 0;
 
+	// Resizes the column to nEntryCount rows and returns its raw value array, so that a reader
+	// can fill the column page by page. rawDataChanged must be called after the array has been filled.
+	virtual uint8_t* resizeRawData(uint64_t nEntryCount) = 0;
+
+	virtual void rawDataChanged();
+
+	// Returns the raw value array of the column: getRowCount() values of getEntrySizeInBytes() bytes each.
+	// The pointer is valid until the column is changed.
+	const uint8_t* getRawData();
+
 	virtual void fillScatterplotXCoordinates (AMC::CScatterplot* pScatterplot, double dScaleFactor, double dOffset) = 0;
 
 	virtual void fillScatterplotYCoordinates(AMC::CScatterplot* pScatterplot, double dScaleFactor, double dOffset) = 0;
@@ -120,10 +133,28 @@ class CDataTable : public virtual IDataTable, public virtual CBase {
 
 	PDataTableColumn addColumnEx(const std::string& sIdentifier, const std::string& sDescription, const LibMCEnv::eDataTableColumnType eColumnType);
 
+	void loadFromStreamV1(IStreamReader* pStream, uint64_t nStreamSize);
+
+	void loadFromStreamV2(IStreamReader* pStream, uint64_t nStreamSize);
+
 public:
 
 	static CDataTable* makeFromStream (IStreamReader * pStreamReader, AMC::PToolpathHandler pToolpathHandler);
 
+	// Maps an error of the data table format layer to a LibMCEnv error code.
+	static LibMCEnvResult formatErrorToResult(AMC::eDataTableFormatError formatError);
+
+	// Resizes a column to nRowCount rows and lets the callback fill its plain value array.
+	// Used by readers that materialise a row range. Not part of the external API.
+	void setColumnPlainData(const std::string& sIdentifier, uint64_t nRowCount, const std::function<void(uint8_t* pPlainValues, uint64_t nSizeInBytes)>& fillCallback);
+
+	// Column access for implementation classes that read a table column by column, for example to
+	// append it to a data capture. Not part of the external API.
+	CDataTableColumn* getColumnByIndex(uint32_t nColumnIndex);
+
+	// Returns nullptr if the column does not exist.
+	CDataTableColumn* findColumnByIdentifier(const std::string& sIdentifier);
+
 	CDataTable(AMC::PToolpathHandler pToolpathHandler);
 
 	virtual ~CDataTable();
@@ -136,6 +167,8 @@ class CDataTable : public virtual IDataTable, public virtual CBase {
 
 	LibMCEnv_uint32 GetRowCount() override;
 
+	LibMCEnv_uint64 GetRowCount64() override;
+
 	LibMCEnv_uint32 GetColumnCount() override;
 
 	std::string GetColumnIdentifier(const LibMCEnv_uint32 nColumnIndex) override;
@@ -156,6 +189,12 @@ class CDataTable : public virtual IDataTable, public virtual CBase {
 
 	void GetUint64ColumnValues(const std::string & sIdentifier, LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_uint64 * pValuesBuffer) override;
 
+	void GetFloatColumnValues(const std::string & sIdentifier, LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_single * pValuesBuffer) override;
+
+	void GetBoolColumnValues(const std::string & sIdentifier, LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_uint8 * pValuesBuffer) override;
+
+	void GetTimestampColumnValues(const std::string & sIdentifier, LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_uint64 * pValuesBuffer) override;
+
 	void SetDoubleColumnValues(const std::string & sIdentifier, const LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_double * pValuesBuffer) override;
 
 	void SetInt32ColumnValues(const std::string & sIdentifier, const LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_int32 * pValuesBuffer) override;
@@ -166,6 +205,12 @@ class CDataTable : public virtual IDataTable, public virtual CBase {
 
 	void SetUint64ColumnValues(const std::string & sIdentifier, const LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint64 * pValuesBuffer) override;
 
+	void SetFloatColumnValues(const std::string & sIdentifier, const LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_single * pValuesBuffer) override;
+
+	void SetBoolColumnValues(const std::string & sIdentifier, const LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint8 * pValuesBuffer) override;
+
+	void SetTimestampColumnValues(const std::string & sIdentifier, const LibMCEnv_uint64 nValuesBufferSize, const LibMCEnv_uint64 * pValuesBuffer) override;
+
 	IDataTableWriteOptions* CreateWriteOptions() override;
 
 	IDataTableCSVWriteOptions* CreateCSVWriteOptions() override;
diff --git a/Implementation/LibMCEnv/libmcenv_datatablereader.cpp b/Implementation/LibMCEnv/libmcenv_datatablereader.cpp
new file mode 100644
index 000000000..bc3f87ee0
--- /dev/null
+++ b/Implementation/LibMCEnv/libmcenv_datatablereader.cpp
@@ -0,0 +1,346 @@
+/*++
+
+Copyright (C) 2020 Autodesk Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Autodesk Inc. nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL AUTODESK INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+Abstract: This is the class definition of CDataTableReader
+
+*/
+
+#include "libmcenv_datatablereader.hpp"
+#include "libmcenv_interfaceexception.hpp"
+
+// Include custom headers here.
+#include "libmcenv_datatable.hpp"
+#include "common_utils.hpp"
+
+#include <memory>
+#include <vector>
+
+using namespace LibMCEnv::Impl;
+
+namespace {
+
+	// Runs a call into the reader and reports its format errors as LibMCEnv errors.
+	template <typename F>
+	auto translateFormatErrors(F&& fn) -> decltype(fn())
+	{
+		try {
+			return fn();
+		}
+		catch (const AMC::EDataTableFormatException& formatException) {
+			throw ELibMCEnvInterfaceException(CDataTable::formatErrorToResult(formatException.getError()), formatException.what());
+		}
+	}
+
+	AMC::eDataCaptureDownsampleMode convertDownsampleMode(const LibMCEnv::eDataTableDownsampleMode eMode)
+	{
+		switch (eMode) {
+		case LibMCEnv::eDataTableDownsampleMode::Stride: return AMC::eDataCaptureDownsampleMode::Stride;
+		case LibMCEnv::eDataTableDownsampleMode::MinMax: return AMC::eDataCaptureDownsampleMode::MinMax;
+		case LibMCEnv::eDataTableDownsampleMode::Average: return AMC::eDataCaptureDownsampleMode::Average;
+		default:
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDDOWNSAMPLEPARAMETERS, "invalid downsample mode");
+		}
+	}
+
+}
+
+/*************************************************************************************************************************
+ Class definition of CDataTableReader
+**************************************************************************************************************************/
+
+CDataTableReader* CDataTableReader::makeFromManifest(LibMCData::PDataModel pDataModel, LibMCData::PDataCapture pManifest, AMC::PToolpathHandler pToolpathHandler)
+{
+	auto pReader = translateFormatErrors([&]() {
+		return std::make_shared<AMC::CDataCaptureReader>(pDataModel, pManifest);
+	});
+
+	return new CDataTableReader(pReader, pToolpathHandler);
+}
+
+CDataTableReader::CDataTableReader(AMC::PDataCaptureReader pReader, AMC::PToolpathHandler pToolpathHandler)
+	: m_pReader(pReader), m_pToolpathHandler(pToolpathHandler)
+{
+	if (pReader.get() == nullptr)
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDPARAM);
+	if (pToolpathHandler.get() == nullptr)
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDPARAM);
+}
+
+CDataTableReader::~CDataTableReader()
+{
+
+}
+
+uint64_t CDataTableReader::getPageReadCount()
+{
+	return m_pReader->getPageReadCount();
+}
+
+LibMCEnv_uint64 CDataTableReader::GetRowCount()
+{
+	return m_pReader->getRowCount();
+}
+
+LibMCEnv_uint64 CDataTableReader::GetFirstAvailableRow()
+{
+	return m_pReader->getFirstAvailableRow();
+}
+
+LibMCEnv_uint32 CDataTableReader::GetColumnCount()
+{
+	return m_pReader->getColumnCount();
+}
+
+bool CDataTableReader::HasColumn(const std::string & sIdentifier)
+{
+	uint32_t nColumnIndex = 0;
+	return m_pReader->findColumn(sIdentifier, nColumnIndex);
+}
+
+void CDataTableReader::GetColumnInformation(const LibMCEnv_uint32 nColumnIndex, std::string & sIdentifier, std::string & sDescription, LibMCEnv::eDataTableColumnType & eColumnType)
+{
+	if (nColumnIndex >= m_pReader->getColumnCount())
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDCOLUMNINDEX);
+
+	auto& column = m_pReader->getColumn(nColumnIndex);
+	sIdentifier = column.m_sIdentifier;
+	sDescription = column.m_sDescription;
+	eColumnType = (LibMCEnv::eDataTableColumnType)column.m_DataType;
+}
+
+LibMCEnv_double CDataTableReader::GetColumnQuantization(const std::string & sIdentifier)
+{
+	return translateFormatErrors([&]() {
+		return m_pReader->getColumnQuantization(m_pReader->getColumnIndex(sIdentifier));
+	});
+}
+
+LibMCEnv_uint32 CDataTableReader::GetSegmentCount()
+{
+	return m_pReader->getSegmentCount();
+}
+
+void CDataTableReader::GetSegmentInformation(const LibMCEnv_uint32 nSegmentIndex, LibMCEnv_uint64 & nFirstRow, LibMCEnv_uint64 & nRowCount, LibMCEnv_uint64 & nSizeInBytes, bool & bIsAvailable)
+{
+	if (nSegmentIndex >= m_pReader->getSegmentCount())
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDDATACAPTURESEGMENTINDEX, "invalid data capture segment index: " + std::to_string(nSegmentIndex));
+
+	auto& segment = m_pReader->getSegment(nSegmentIndex);
+	nFirstRow = segment.m_nFirstRow;
+	nRowCount = segment.m_nRowCount;
+	nSizeInBytes = segment.m_nSizeInBytes;
+	bIsAvailable = !segment.m_bIsPurged;
+}
+
+LibMCEnv_uint64 CDataTableReader::GetChunkCount()
+{
+	return m_pReader->getChunkCount();
+}
+
+void CDataTableReader::GetChunkInformation(const LibMCEnv_uint64 nChunkIndex, LibMCEnv_uint32 & nSegmentIndex, LibMCEnv_uint64 & nFirstRow, LibMCEnv_uint64 & nRowCount, bool & bIsAvailable)
+{
+	if (nChunkIndex >= m_pReader->getChunkCount())
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDDATATABLECHUNKINDEX, "invalid datatable chunk index: " + std::to_string(nChunkIndex));
+
+	auto chunkInfo = translateFormatErrors([&]() {
+		return m_pReader->getChunkInfo(nChunkIndex);
+	});
+
+	nSegmentIndex = chunkInfo.m_nSegmentIndex;
+	nFirstRow = chunkInfo.m_nFirstRow;
+	nRowCount = chunkInfo.m_nRowCount;
+	bIsAvailable = chunkInfo.m_bIsAvailable;
+}
+
+bool CDataTableReader::GetChunkStatistics(const LibMCEnv_uint64 nChunkIndex, const std::string & sIdentifier, LibMCEnv_double & dMinValue, LibMCEnv_double & dMaxValue)
+{
+	if (nChunkIndex >= m_pReader->getChunkCount())
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDDATATABLECHUNKINDEX, "invalid datatable chunk index: " + std::to_string(nChunkIndex));
+
+	return translateFormatErrors([&]() {
+		return m_pReader->getChunkStatistics(nChunkIndex, m_pReader->getColumnIndex(sIdentifier), dMinValue, dMaxValue);
+	});
+}
+
+void CDataTableReader::ReadDoubleColumnRange(const std::string & sIdentifier, const LibMCEnv_uint64 nFromRow, const LibMCEnv_uint64 nRowCount, LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_double * pValuesBuffer)
+{
+	translateFormatErrors([&]() {
+		uint32_t nColumnIndex = m_pReader->getColumnIndex(sIdentifier);
+		m_pReader->validateRowRange(nFromRow, nRowCount);
+
+		if (pValuesNeededCount != nullptr)
+			*pValuesNeededCount = nRowCount;
+
+		if (pValuesBuffer != nullptr) {
+			if (nValuesBufferSize < nRowCount)
+				throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_BUFFERTOOSMALL);
+
+			m_pReader->readColumnAsDouble(nColumnIndex, nFromRow, nRowCount, pValuesBuffer);
+		}
+	});
+}
+
+void CDataTableReader::ReadFloatColumnRange(const std::string & sIdentifier, const LibMCEnv_uint64 nFromRow, const LibMCEnv_uint64 nRowCount, LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_single * pValuesBuffer)
+{
+	translateFormatErrors([&]() {
+		uint32_t nColumnIndex = m_pReader->getColumnIndex(sIdentifier);
+		m_pReader->validateRowRange(nFromRow, nRowCount);
+
+		if (pValuesNeededCount != nullptr)
+			*pValuesNeededCount = nRowCount;
+
+		if (pValuesBuffer != nullptr) {
+			if (nValuesBufferSize < nRowCount)
+				throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_BUFFERTOOSMALL);
+
+			m_pReader->readColumnAsFloat(nColumnIndex, nFromRow, nRowCount, pValuesBuffer);
+		}
+	});
+}
+
+void CDataTableReader::ReadInt64ColumnRange(const std::string & sIdentifier, const LibMCEnv_uint64 nFromRow, const LibMCEnv_uint64 nRowCount, LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_int64 * pValuesBuffer)
+{
+	translateFormatErrors([&]() {
+		uint32_t nColumnIndex = m_pReader->getColumnIndex(sIdentifier);
+		m_pReader->validateRowRange(nFromRow, nRowCount);
+
+		if (pValuesNeededCount != nullptr)
+			*pValuesNeededCount = nRowCount;
+
+		if (pValuesBuffer != nullptr) {
+			if (nValuesBufferSize < nRowCount)
+				throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_BUFFERTOOSMALL);
+
+			m_pReader->readColumnAsInt64(nColumnIndex, nFromRow, nRowCount, pValuesBuffer);
+		}
+	});
+}
+
+void CDataTableReader::ReadBoolColumnRange(const std::string & sIdentifier, const LibMCEnv_uint64 nFromRow, const LibMCEnv_uint64 nRowCount, LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_uint8 * pValuesBuffer)
+{
+	translateFormatErrors([&]() {
+		uint32_t nColumnIndex = m_pReader->getColumnIndex(sIdentifier);
+		m_pReader->validateRowRange(nFromRow, nRowCount);
+
+		if (m_pReader->getColumn(nColumnIndex).m_DataType != AMC::eDataTableV2DataType::Bool)
+			throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DATATABLECOLUMNTYPEMISMATCH, "data capture column is not a bool column: " + sIdentifier);
+
+		if (pValuesNeededCount != nullptr)
+			*pValuesNeededCount = nRowCount;
+
+		if (pValuesBuffer != nullptr) {
+			if (nValuesBufferSize < nRowCount)
+				throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_BUFFERTOOSMALL);
+
+			m_pReader->readColumnPlain(nColumnIndex, nFromRow, nRowCount, pValuesBuffer, nValuesBufferSize);
+		}
+	});
+}
+
+void CDataTableReader::ReadColumnDownsampled(const std::string & sIdentifier, const LibMCEnv_uint64 nFromRow, const LibMCEnv_uint64 nRowCount, const LibMCEnv_uint32 nTargetPoints, const LibMCEnv::eDataTableDownsampleMode eMode, LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_double * pValuesBuffer)
+{
+	if (nTargetPoints == 0)
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDDOWNSAMPLEPARAMETERS, "downsample target point count is zero");
+
+	auto mode = convertDownsampleMode(eMode);
+
+	translateFormatErrors([&]() {
+		uint32_t nColumnIndex = m_pReader->getColumnIndex(sIdentifier);
+		m_pReader->validateRowRange(nFromRow, nRowCount);
+
+		uint64_t nValueCount = AMC::CDataCaptureReader::getDownsampleValueCount(nRowCount, nTargetPoints, mode);
+		if (pValuesNeededCount != nullptr)
+			*pValuesNeededCount = nValueCount;
+
+		if (pValuesBuffer != nullptr) {
+			if (nValuesBufferSize < nValueCount)
+				throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_BUFFERTOOSMALL);
+
+			m_pReader->readColumnDownsampled(nColumnIndex, nFromRow, nRowCount, nTargetPoints, mode, pValuesBuffer);
+		}
+	});
+}
+
+void CDataTableReader::FindChunksInValueRange(const std::string & sIdentifier, const LibMCEnv_double dMinValue, const LibMCEnv_double dMaxValue, LibMCEnv_uint64 nChunkIndicesBufferSize, LibMCEnv_uint64* pChunkIndicesNeededCount, LibMCEnv_uint64 * pChunkIndicesBuffer)
+{
+	translateFormatErrors([&]() {
+		auto chunkIndices = m_pReader->findChunksInValueRange(m_pReader->getColumnIndex(sIdentifier), dMinValue, dMaxValue);
+
+		if (pChunkIndicesNeededCount != nullptr)
+			*pChunkIndicesNeededCount = chunkIndices.size();
+
+		if (pChunkIndicesBuffer != nullptr) {
+			if (nChunkIndicesBufferSize < chunkIndices.size())
+				throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_BUFFERTOOSMALL);
+
+			for (size_t nIndex = 0; nIndex < chunkIndices.size(); nIndex++)
+				pChunkIndicesBuffer[nIndex] = chunkIndices[nIndex];
+		}
+	});
+}
+
+IDataTable * CDataTableReader::ExtractDataTable(const LibMCEnv_uint64 nFromRow, const LibMCEnv_uint64 nRowCount, const std::string & sColumnIdentifiers)
+{
+	return translateFormatErrors([&]() {
+		m_pReader->validateRowRange(nFromRow, nRowCount);
+
+		// An empty list selects all columns.
+		std::vector<uint32_t> columnIndices;
+		if (AMCCommon::CUtils::trimString(sColumnIdentifiers).empty()) {
+			for (uint32_t nColumnIndex = 0; nColumnIndex < m_pReader->getColumnCount(); nColumnIndex++)
+				columnIndices.push_back(nColumnIndex);
+		}
+		else {
+			size_t nPosition = 0;
+			while (nPosition <= sColumnIdentifiers.length()) {
+				size_t nSeparator = sColumnIdentifiers.find(',', nPosition);
+				if (nSeparator == std::string::npos)
+					nSeparator = sColumnIdentifiers.length();
+
+				std::string sIdentifier = AMCCommon::CUtils::trimString(sColumnIdentifiers.substr(nPosition, nSeparator - nPosition));
+				columnIndices.push_back(m_pReader->getColumnIndex(sIdentifier));
+
+				nPosition = nSeparator + 1;
+			}
+		}
+
+		auto pDataTable = std::make_unique<CDataTable>(m_pToolpathHandler);
+
+		for (uint32_t nColumnIndex : columnIndices) {
+			auto& column = m_pReader->getColumn(nColumnIndex);
+			pDataTable->AddColumn(column.m_sIdentifier, column.m_sDescription, (LibMCEnv::eDataTableColumnType)column.m_DataType);
+
+			pDataTable->setColumnPlainData(column.m_sIdentifier, nRowCount, [&](uint8_t* pPlainValues, uint64_t nSizeInBytes) {
+				m_pReader->readColumnPlain(nColumnIndex, nFromRow, nRowCount, pPlainValues, nSizeInBytes);
+			});
+		}
+
+		return (IDataTable*)pDataTable.release();
+	});
+}
diff --git a/Implementation/LibMCEnv/libmcenv_datatablereader.hpp b/Implementation/LibMCEnv/libmcenv_datatablereader.hpp
new file mode 100644
index 000000000..0c75b9e5b
--- /dev/null
+++ b/Implementation/LibMCEnv/libmcenv_datatablereader.hpp
@@ -0,0 +1,124 @@
+/*++
+
+Copyright (C) 2020 Autodesk Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Autodesk Inc. nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL AUTODESK INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+Abstract: This is the class declaration of CDataTableReader
+
+*/
+
+
+#ifndef __LIBMCENV_DATATABLEREADER
+#define __LIBMCENV_DATATABLEREADER
+
+#include "libmcenv_interfaces.hpp"
+
+// Parent classes
+#include "libmcenv_base.hpp"
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4250)
+#endif
+
+// Include custom headers here.
+#include "amc_datacapturereader.hpp"
+#include "amc_toolpathhandler.hpp"
+#include "libmcdata_dynamic.hpp"
+
+namespace LibMCEnv {
+namespace Impl {
+
+
+/*************************************************************************************************************************
+ Class declaration of CDataTableReader
+
+ The reading logic lives in AMC::CDataCaptureReader, which the API handlers use as well.
+ This class exposes it to plugins and drivers and translates its errors.
+**************************************************************************************************************************/
+
+class CDataTableReader : public virtual IDataTableReader, public virtual CBase {
+private:
+
+	AMC::PDataCaptureReader m_pReader;
+	AMC::PToolpathHandler m_pToolpathHandler;
+
+public:
+
+	static CDataTableReader* makeFromManifest(LibMCData::PDataModel pDataModel, LibMCData::PDataCapture pManifest, AMC::PToolpathHandler pToolpathHandler);
+
+	CDataTableReader(AMC::PDataCaptureReader pReader, AMC::PToolpathHandler pToolpathHandler);
+
+	virtual ~CDataTableReader();
+
+	// Number of pages that have been read from storage so far. Not part of the external API.
+	uint64_t getPageReadCount();
+
+	LibMCEnv_uint64 GetRowCount() override;
+
+	LibMCEnv_uint64 GetFirstAvailableRow() override;
+
+	LibMCEnv_uint32 GetColumnCount() override;
+
+	bool HasColumn(const std::string & sIdentifier) override;
+
+	void GetColumnInformation(const LibMCEnv_uint32 nColumnIndex, std::string & sIdentifier, std::string & sDescription, LibMCEnv::eDataTableColumnType & eColumnType) override;
+
+	LibMCEnv_double GetColumnQuantization(const std::string & sIdentifier) override;
+
+	LibMCEnv_uint32 GetSegmentCount() override;
+
+	void GetSegmentInformation(const LibMCEnv_uint32 nSegmentIndex, LibMCEnv_uint64 & nFirstRow, LibMCEnv_uint64 & nRowCount, LibMCEnv_uint64 & nSizeInBytes, bool & bIsAvailable) override;
+
+	LibMCEnv_uint64 GetChunkCount() override;
+
+	void GetChunkInformation(const LibMCEnv_uint64 nChunkIndex, LibMCEnv_uint32 & nSegmentIndex, LibMCEnv_uint64 & nFirstRow, LibMCEnv_uint64 & nRowCount, bool & bIsAvailable) override;
+
+	bool GetChunkStatistics(const LibMCEnv_uint64 nChunkIndex, const std::string & sIdentifier, LibMCEnv_double & dMinValue, LibMCEnv_double & dMaxValue) override;
+
+	void ReadDoubleColumnRange(const std::string & sIdentifier, const LibMCEnv_uint64 nFromRow, const LibMCEnv_uint64 nRowCount, LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_double * pValuesBuffer) override;
+
+	void ReadFloatColumnRange(const std::string & sIdentifier, const LibMCEnv_uint64 nFromRow, const LibMCEnv_uint64 nRowCount, LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_single * pValuesBuffer) override;
+
+	void ReadInt64ColumnRange(const std::string & sIdentifier, const LibMCEnv_uint64 nFromRow, const LibMCEnv_uint64 nRowCount, LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_int64 * pValuesBuffer) override;
+
+	void ReadBoolColumnRange(const std::string & sIdentifier, const LibMCEnv_uint64 nFromRow, const LibMCEnv_uint64 nRowCount, LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_uint8 * pValuesBuffer) override;
+
+	void ReadColumnDownsampled(const std::string & sIdentifier, const LibMCEnv_uint64 nFromRow, const LibMCEnv_uint64 nRowCount, const LibMCEnv_uint32 nTargetPoints, const LibMCEnv::eDataTableDownsampleMode eMode, LibMCEnv_uint64 nValuesBufferSize, LibMCEnv_uint64* pValuesNeededCount, LibMCEnv_double * pValuesBuffer) override;
+
+	void FindChunksInValueRange(const std::string & sIdentifier, const LibMCEnv_double dMinValue, const LibMCEnv_double dMaxValue, LibMCEnv_uint64 nChunkIndicesBufferSize, LibMCEnv_uint64* pChunkIndicesNeededCount, LibMCEnv_uint64 * pChunkIndicesBuffer) override;
+
+	IDataTable * ExtractDataTable(const LibMCEnv_uint64 nFromRow, const LibMCEnv_uint64 nRowCount, const std::string & sColumnIdentifiers) override;
+
+};
+
+} // namespace Impl
+} // namespace LibMCEnv
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+#endif // __LIBMCENV_DATATABLEREADER
diff --git a/Implementation/LibMCEnv/libmcenv_stateenvironment.cpp b/Implementation/LibMCEnv/libmcenv_stateenvironment.cpp
index c82850ee7..ecd7b5a53 100644
--- a/Implementation/LibMCEnv/libmcenv_stateenvironment.cpp
+++ b/Implementation/LibMCEnv/libmcenv_stateenvironment.cpp
@@ -75,6 +75,9 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "amc_alerthandler.hpp"
 #include "amc_dataserieshandler.hpp"
 #include "amc_streamregistry.hpp"
+#include "amc_streamdownloadregistry.hpp"
+#include "amc_api_sessionhandler.hpp"
+#include "amc_ui_clientaction.hpp"
 
 #include "common_chrono.hpp"
 #include <thread> 
@@ -1236,6 +1239,129 @@ IStreamReader* CStateEnvironment::LoadStream(const std::string& sUUID, const boo
 }
 
 
+#define STATEENV_DOWNLOADFILENAME_MAXLENGTH 256
+
+bool CStateEnvironment::StartStreamDownloadForSession(const std::string& sSessionUUID, const std::string& sStreamUUID, const std::string& sFileName)
+{
+	std::string sNormalizedSessionUUID = AMCCommon::CUtils::normalizeUUIDString(sSessionUUID);
+	std::string sNormalizedStreamUUID = AMCCommon::CUtils::normalizeUUIDString(sStreamUUID);
+
+	if (sFileName.empty())
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_EMPTYDOWNLOADSTREAMFILENAME);
+	if (sFileName.size() > STATEENV_DOWNLOADFILENAME_MAXLENGTH)
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDDOWNLOADSTREAMFILENAME);
+	if (!AMCCommon::CUtils::stringIsValidFileName(sFileName))
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDDOWNLOADSTREAMFILENAME, "invalid download stream filename: " + sFileName);
+
+	auto pSessionHandler = m_pSystemState->getSessionHandler();
+	if (pSessionHandler.get() == nullptr)
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_SESSIONHANDLERNOTAVAILABLE);
+
+	// The ticket belongs to the user of the session, exactly as a download started from a UI event.
+	std::string sUserUUID;
+	if (!pSessionHandler->getAuthorizedUserForSession(sNormalizedSessionUUID, sUserUUID))
+		return false;
+
+	auto pStorage = m_pSystemState->getDataModelInstance()->CreateStorage();
+	if (!pStorage->StreamIsReady(sNormalizedStreamUUID))
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_DOWNLOADSTREAMDOESNOTEXIST, "Download stream does not exist: " + sNormalizedStreamUUID);
+
+	auto pStream = pStorage->RetrieveStream(sNormalizedStreamUUID);
+	uint64_t nSize = pStream->GetSize();
+
+	auto pChrono = m_pSystemState->getGlobalChronoInstance();
+	std::string sTicketUUID = AMCCommon::CUtils::createUUID();
+	pStorage->CreateDownloadTicket(sTicketUUID, sNormalizedStreamUUID, sFileName, sNormalizedSessionUUID, sUserUUID, pChrono->getUTCTimeStampInMicrosecondsSince1970());
+
+	m_pSystemState->getStreamDownloadRegistryInstance()->prepareDownload(sNormalizedStreamUUID, nSize);
+
+	auto pAction = std::make_shared<AMC::CUIClientAction_StreamDownload>(sTicketUUID, sFileName);
+	return pSessionHandler->enqueueClientActionForSession(sNormalizedSessionUUID, pAction, sNormalizedStreamUUID);
+}
+
+void CStateEnvironment::GetStreamDownloadProgress(const std::string& sStreamUUID, LibMCEnv_uint32& nActiveConnections, LibMCEnv_uint64& nDeliveredBytes, LibMCEnv_uint64& nTotalBytes, bool& bCompleted, LibMCEnv_uint64& nMillisecondsSinceActivity)
+{
+	std::string sNormalizedStreamUUID = AMCCommon::CUtils::normalizeUUIDString(sStreamUUID);
+
+	auto progress = m_pSystemState->getStreamDownloadRegistryInstance()->getProgress(sNormalizedStreamUUID);
+	nActiveConnections = progress.m_nActiveConnections;
+	nDeliveredBytes = progress.m_nDeliveredBytes;
+	nTotalBytes = progress.m_nTotalBytes;
+	bCompleted = progress.m_bCompleted;
+	nMillisecondsSinceActivity = progress.m_nMillisecondsSinceActivity;
+}
+
+bool CStateEnvironment::CancelStreamDownloads(const std::string& sStreamUUID)
+{
+	std::string sNormalizedStreamUUID = AMCCommon::CUtils::normalizeUUIDString(sStreamUUID);
+
+	// The registry flag stops every running connection with its next chunk; revoked tickets make a resume
+	// fail with 410; dropped actions keep a download from starting after the cancel.
+	if (!m_pSystemState->getStreamDownloadRegistryInstance()->cancel(sNormalizedStreamUUID))
+		return false;
+
+	auto pStorage = m_pSystemState->getDataModelInstance()->CreateStorage();
+	pStorage->RevokeDownloadTicketsOfStream(sNormalizedStreamUUID);
+
+	auto pSessionHandler = m_pSystemState->getSessionHandler();
+	if (pSessionHandler.get() != nullptr)
+		pSessionHandler->removeClientActionsOfStream(sNormalizedStreamUUID);
+
+	return true;
+}
+
+void CStateEnvironment::DeleteStorageStream(const std::string& sUUID)
+{
+	std::string sNormalizedUUID = AMCCommon::CUtils::normalizeUUIDString(sUUID);
+
+	if (m_pSystemState->getStreamDownloadRegistryInstance()->hasActiveConnections(sNormalizedUUID))
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_STREAMHASACTIVEDOWNLOADS, "storage stream is being downloaded: " + sNormalizedUUID);
+
+	auto pSessionHandler = m_pSystemState->getSessionHandler();
+	if ((pSessionHandler.get() != nullptr) && pSessionHandler->hasUnclaimedClientActionsOfStream(sNormalizedUUID))
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_STREAMHASACTIVEDOWNLOADS, "storage stream has a pending download: " + sNormalizedUUID);
+
+	auto pStorage = m_pSystemState->getDataModelInstance()->CreateStorage();
+	pStorage->DeleteStream(sNormalizedUUID);
+}
+
+LibMCEnv_uint32 CStateEnvironment::EnforceStreamRetention(const std::string& sName, const LibMCEnv_uint32 nKeepCount)
+{
+	if (sName.empty())
+		throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDPARAM);
+
+	auto pStorage = m_pSystemState->getDataModelInstance()->CreateStorage();
+	auto pRegistry = m_pSystemState->getStreamDownloadRegistryInstance();
+	auto pSessionHandler = m_pSystemState->getSessionHandler();
+
+	std::vector<std::string> streamUUIDs;
+	AMCCommon::CUtils::splitString(pStorage->ListStreamUUIDsByName(sName), ",", streamUUIDs);
+
+	uint32_t nDeleted = 0;
+	uint32_t nKept = 0;
+	for (auto& sStreamUUID : streamUUIDs) {
+		if (sStreamUUID.empty())
+			continue;
+
+		if (nKept < nKeepCount) {
+			nKept++;
+			continue;
+		}
+
+		// A stream that is being downloaded or waits for a browser to fetch it is kept for this round.
+		if (pRegistry->hasActiveConnections(sStreamUUID))
+			continue;
+		if ((pSessionHandler.get() != nullptr) && pSessionHandler->hasUnclaimedClientActionsOfStream(sStreamUUID))
+			continue;
+
+		pStorage->DeleteStream(sStreamUUID);
+		nDeleted++;
+	}
+
+	return nDeleted;
+}
+
+
 IDateTime* CStateEnvironment::GetCurrentDateTime()
 {
 	auto pChrono = m_pSystemState->getGlobalChronoInstance();
diff --git a/Implementation/LibMCEnv/libmcenv_stateenvironment.hpp b/Implementation/LibMCEnv/libmcenv_stateenvironment.hpp
index deb26e1ce..42e616afb 100644
--- a/Implementation/LibMCEnv/libmcenv_stateenvironment.hpp
+++ b/Implementation/LibMCEnv/libmcenv_stateenvironment.hpp
@@ -277,6 +277,16 @@ class CStateEnvironment : public virtual IStateEnvironment, public virtual CBase
 
 	IStreamReader* LoadStream(const std::string& sUUID, const bool bMustExist) override;
 
+	bool StartStreamDownloadForSession(const std::string& sSessionUUID, const std::string& sStreamUUID, const std::string& sFileName) override;
+
+	void GetStreamDownloadProgress(const std::string& sStreamUUID, LibMCEnv_uint32& nActiveConnections, LibMCEnv_uint64& nDeliveredBytes, LibMCEnv_uint64& nTotalBytes, bool& bCompleted, LibMCEnv_uint64& nMillisecondsSinceActivity) override;
+
+	bool CancelStreamDownloads(const std::string& sStreamUUID) override;
+
+	void DeleteStorageStream(const std::string& sUUID) override;
+
+	LibMCEnv_uint32 EnforceStreamRetention(const std::string& sName, const LibMCEnv_uint32 nKeepCount) override;
+
 	IDateTime* GetCurrentDateTime() override;
 
 	IDateTime* GetCustomDateTime(const LibMCEnv_uint32 nYear, const LibMCEnv_uint32 nMonth, const LibMCEnv_uint32 nDay, const LibMCEnv_uint32 nHour, const LibMCEnv_uint32 nMinute, const LibMCEnv_uint32 nSecond, const LibMCEnv_uint32 nMicrosecond)  override;
diff --git a/Implementation/LibMCEnv/libmcenv_streamreader.cpp b/Implementation/LibMCEnv/libmcenv_streamreader.cpp
index 1b01fe3f8..cdf6c1e89 100644
--- a/Implementation/LibMCEnv/libmcenv_streamreader.cpp
+++ b/Implementation/LibMCEnv/libmcenv_streamreader.cpp
@@ -139,7 +139,7 @@ void CStreamReader::ReadData(const LibMCEnv_uint64 nSizeToRead, LibMCEnv_uint64
 		uint32_t nReadErrorCode = 0;
 		readCallback((void*) pDataBuffer, nSizeToRead, pUserData, &nReadErrorCode);
 		if (nReadErrorCode)
-			throw ELibMCEnvInterfaceException(nSeekErrorCode);
+			throw ELibMCEnvInterfaceException(nReadErrorCode);
 
 		m_nReadPosition += nSizeToRead;
 
diff --git a/Implementation/LibMCEnv/libmcenv_tempstreamwriter.cpp b/Implementation/LibMCEnv/libmcenv_tempstreamwriter.cpp
index 9544205a0..4456d8a74 100644
--- a/Implementation/LibMCEnv/libmcenv_tempstreamwriter.cpp
+++ b/Implementation/LibMCEnv/libmcenv_tempstreamwriter.cpp
@@ -74,6 +74,15 @@ CTempStreamWriter::~CTempStreamWriter()
 }
 
 
+void CTempStreamWriter::Discard()
+{
+    if (m_bIsFinished)
+        throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_INVALIDPARAM, "a finished stream can not be discarded");
+
+    m_pStorage->DiscardRandomWriteStream(m_sUUID);
+    m_bIsFinished = true;
+}
+
 std::string CTempStreamWriter::GetUUID()
 {
     return m_sUUID;
diff --git a/Implementation/LibMCEnv/libmcenv_tempstreamwriter.hpp b/Implementation/LibMCEnv/libmcenv_tempstreamwriter.hpp
index f01a04744..48d01b665 100644
--- a/Implementation/LibMCEnv/libmcenv_tempstreamwriter.hpp
+++ b/Implementation/LibMCEnv/libmcenv_tempstreamwriter.hpp
@@ -79,6 +79,10 @@ class CTempStreamWriter : public virtual ITempStreamWriter, public virtual CBase
 
 	virtual ~CTempStreamWriter();
 
+	// Discards the unfinished stream: the data on disk and the stream entry are deleted.
+	// The writer MUST NOT be used afterwards. Not part of the external API.
+	void Discard();
+
 	std::string GetUUID() override;
 
 	std::string GetName() override;
diff --git a/Implementation/LibMCEnv/libmcenv_zipstreamwriter.cpp b/Implementation/LibMCEnv/libmcenv_zipstreamwriter.cpp
index f46145d2d..dc8d9115d 100644
--- a/Implementation/LibMCEnv/libmcenv_zipstreamwriter.cpp
+++ b/Implementation/LibMCEnv/libmcenv_zipstreamwriter.cpp
@@ -183,6 +183,14 @@ void CZIPStreamWriter::Finish()
     m_pZIPWriter->Finish();
 }
 
+void CZIPStreamWriter::Discard()
+{
+    if (m_pZIPWriter->IsFinished())
+        throw ELibMCEnvInterfaceException(LIBMCENV_ERROR_ZIPSTREAMALREADYFINISHED, "ZIP stream has already been finished: " + m_sUUID);
+
+    m_pZIPWriter->Discard();
+}
+
 void CZIPStreamWriter::CreateZIPEntryFromStream(const std::string& sFileName, IStreamReader* pStreamReader) 
 {
     m_pZIPWriter->FinishCurrentEntry();
diff --git a/Implementation/LibMCEnv/libmcenv_zipstreamwriter.hpp b/Implementation/LibMCEnv/libmcenv_zipstreamwriter.hpp
index 48889acd7..572c62634 100644
--- a/Implementation/LibMCEnv/libmcenv_zipstreamwriter.hpp
+++ b/Implementation/LibMCEnv/libmcenv_zipstreamwriter.hpp
@@ -124,6 +124,8 @@ class CZIPStreamWriter : public virtual IZIPStreamWriter, public virtual CBase {
 
 	void Finish() override;
 
+	void Discard() override;
+
 	std::string GetUUID() override;
 
 	std::string GetName() override;
diff --git a/Implementation/Server/amc_server.cpp b/Implementation/Server/amc_server.cpp
index 167abaaa6..5925bf377 100644
--- a/Implementation/Server/amc_server.cpp
+++ b/Implementation/Server/amc_server.cpp
@@ -35,6 +35,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "Libraries/cpp-httplib/httplib.h"
 
 #include "amc_server.hpp"
+#include "common_httprange.hpp"
 #include "common_utils.hpp"
 #include <iostream>
 
@@ -46,6 +47,11 @@ using namespace AMC;
 #define PEMMAXLENGTH (1024 * 1024)
 
 #define AMC_SERVER_THREADPOOLSIZE 64
+// Streamed downloads are read from disk and written to the socket in chunks of this size.
+#define AMC_SERVER_DOWNLOADCHUNKSIZE (4 * 1024 * 1024)
+// Timeout of one socket write. It also bounds how long a cancel needs to reach a connection whose
+// client paused reading; a slower client is cut off and resumes with a range request.
+#define AMC_SERVER_WRITETIMEOUT_SEC 30
 #define AMC_SERVER_MAXEVENTSTREAMS 32
 #define AMC_SERVER_EVENTSTREAM_RETRY_MS 3000
 #define AMC_SERVER_EVENTSTREAM_MAXEVENTIDLENGTH 18
@@ -527,8 +533,9 @@ void CServer::executeBlocking(const std::string& sConfigurationFileName)
 					uint32_t nHttpCode;
 
 					auto pHandler = m_pContext->CreateAPIRequestHandler(sURL, sMethod, sAuthorization);
+					pHandler->SetClientAddress(req.remote_addr);
 
-					if (req.method == "GET") {
+					if ((req.method == "GET") || (req.method == "HEAD")) {
 						// In case of a get request, we can use the query parameters
 						for (auto iParamIter : req.params) {
 							pHandler->SetRequestParameter(iParamIter.first, iParamIter.second);
@@ -565,7 +572,6 @@ void CServer::executeBlocking(const std::string& sConfigurationFileName)
 
 					pHandler->Handle(Buffer, sContentType, nHttpCode);
 
-					pHandler->GetResultData(ResultBuffer);
 					std::string sContentDispositionName = pHandler->GetContentDispositionName();
 
 					if (!sContentDispositionName.empty()) {
@@ -585,17 +591,108 @@ void CServer::executeBlocking(const std::string& sConfigurationFileName)
 						}
 					}
 
-					if (!ResultBuffer.empty()) {
-						std::string sResult(reinterpret_cast<char*>(ResultBuffer.data()), ResultBuffer.size());
-
-						res.set_content(sResult, sContentType.c_str());
+					if (pHandler->HasStreamResult()) {
+						// The body is a storage stream on disk; it is sent in chunks through a content provider,
+						// so neither the file size nor the 2 GiB limit of one socket write matters.
+						LibMC_uint64 nStreamSize = 0;
+						std::string sETag, sLastModified;
+						pHandler->GetResultStreamInfo(nStreamSize, sETag, sLastModified);
+
+						res.set_header("Accept-Ranges", "bytes");
+						res.set_header("ETag", "\"" + sETag + "\"");
+						if (!sLastModified.empty())
+							res.set_header("Last-Modified", sLastModified);
+						res.set_header("Cache-Control", "no-store");
+
+						bool bSendBody = true;
+						if (!req.ranges.empty()) {
+							std::string sIfRange = req.get_header_value("If-Range");
+							if (!AMCCommon::CHTTPRange::ifRangeMatches(sIfRange, sETag, sLastModified)) {
+								// A stale validator means the whole body (RFC 7233). The HTTP library keeps the
+								// parsed ranges in the request, which belongs to this thread's call; they are
+								// cleared in place, since the library offers no other way to ignore them.
+								const_cast<httplib::Request&>(req).ranges.clear();
+							}
+							else {
+								// The HTTP library validates ranges only for bodies in memory; for a content
+								// provider it would pass an unsatisfiable range through.
+								std::vector<AMCCommon::CHTTPRange::Range> ranges;
+								for (auto& range : req.ranges)
+									ranges.push_back(AMCCommon::CHTTPRange::Range((int64_t)range.first, (int64_t)range.second));
+
+								if (!AMCCommon::CHTTPRange::normalizeRanges(ranges, nStreamSize)) {
+									res.status = 416;
+									res.set_header("Content-Range", "bytes */" + std::to_string(nStreamSize));
+									res.set_content("", "text/plain");
+									bSendBody = false;
+								}
+								else {
+									auto& mutableRanges = const_cast<httplib::Request&>(req).ranges;
+									mutableRanges[0].first = (decltype(mutableRanges[0].first))ranges[0].first;
+									mutableRanges[0].second = (decltype(mutableRanges[0].second))ranges[0].second;
+								}
+							}
+						}
 
+						if (bSendBody) {
+							// The provider runs after this handler returns; the lambdas keep the handler alive.
+							// The registry learns about the connection with the first chunk, so HEAD requests and
+							// failures before the first byte never count as downloads.
+							res.set_content_provider((size_t)nStreamSize, sContentType.c_str(),
+								[this, pHandler](size_t nOffset, size_t nLength, httplib::DataSink& sink) -> bool {
+									try {
+										size_t nChunkLength = nLength;
+										if (nChunkLength > AMC_SERVER_DOWNLOADCHUNKSIZE)
+											nChunkLength = AMC_SERVER_DOWNLOADCHUNKSIZE;
+
+										std::vector<LibMC_uint8> Chunk;
+										pHandler->ReadResultStreamChunk(nOffset, nChunkLength, Chunk);
+										if (Chunk.empty())
+											return false;
+
+										return sink.write(reinterpret_cast<const char*>(Chunk.data()), Chunk.size());
+									}
+									catch (const std::exception& E) {
+										// Returning false closes the connection; the browser can resume with a range request.
+										this->log("Download stream read failed: " + std::string(E.what()));
+										return false;
+									}
+								},
+								[this, pHandler](bool bSuccess) {
+									// Called from the response destructor for every response, also for HEAD.
+									try {
+										pHandler->FinishStreamResult(bSuccess);
+									}
+									catch (const std::exception& E) {
+										this->log("Download stream finish failed: " + std::string(E.what()));
+									}
+								});
+							// res.status stays unset: the HTTP library answers 200, or 206 with Content-Range for a range.
+						}
 					}
 					else {
-						res.set_content("", sContentType.c_str());
-					}
+						// Byte ranges only apply to streamed downloads. For every other response, among them the
+						// error document of a revoked download ticket, the HTTP library would otherwise cut the
+						// small body to the requested range and replace the status by 206 or 416.
+						if (!req.ranges.empty())
+							const_cast<httplib::Request&>(req).ranges.clear();
+
+						pHandler->GetResultData(ResultBuffer);
+
+						if (!ResultBuffer.empty()) {
+							std::string sResult(reinterpret_cast<char*>(ResultBuffer.data()), ResultBuffer.size());
+
+							res.set_content(sResult, sContentType.c_str());
 
-					res.status = nHttpCode;
+						}
+						else {
+							res.set_content("", sContentType.c_str());
+						}
+
+						res.status = nHttpCode;
+						if (nHttpCode == 503)
+							res.set_header("Retry-After", "5");
+					}
 
 				}
 				catch (std::exception& E) {
@@ -626,6 +723,7 @@ void CServer::executeBlocking(const std::string& sConfigurationFileName)
 					httplib::SSLServer sslsvr(serverCertificate.getCertificate(), privateKey.getPrivateKey());
 
 					sslsvr.new_task_queue = [] { return new httplib::ThreadPool(AMC_SERVER_THREADPOOLSIZE); };
+					sslsvr.set_write_timeout(AMC_SERVER_WRITETIMEOUT_SEC, 0);
 					sslsvr.Get("^/stream/.*", streamHandler);
 					sslsvr.Get("(.*?)", requestHandler);
 					sslsvr.Post("(.*?)", requestHandler);
@@ -665,6 +763,7 @@ void CServer::executeBlocking(const std::string& sConfigurationFileName)
 
 					httplib::Server svr;
 					svr.new_task_queue = [] { return new httplib::ThreadPool(AMC_SERVER_THREADPOOLSIZE); };
+					svr.set_write_timeout(AMC_SERVER_WRITETIMEOUT_SEC, 0);
 					svr.Get("^/stream/.*", streamHandler);
 					svr.Get("(.*?)", requestHandler);
 					svr.Post("(.*?)", requestHandler);
diff --git a/Implementation/UI/amc_ui_dialog.cpp b/Implementation/UI/amc_ui_dialog.cpp
index f3df81a93..a1e4aecee 100644
--- a/Implementation/UI/amc_ui_dialog.cpp
+++ b/Implementation/UI/amc_ui_dialog.cpp
@@ -40,8 +40,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 using namespace AMC;
 
-CUIDialog::CUIDialog(const std::string& sName, const std::string& sTitle, CUIModule_UIEventHandler* pUIEventHandler, const CUIExpression& icon, const CUIExpression& caption, const CUIExpression& description)
-	: CUIPage (sName, pUIEventHandler, icon, caption, description, ""), m_sTitle (sTitle)
+CUIDialog::CUIDialog(const std::string& sName, const std::string& sTitle, CUIModule_UIEventHandler* pUIEventHandler, const CUIExpression& icon, const CUIExpression& caption, const CUIExpression& description, const CUIExpression& active, const CUIExpression& closable)
+	: CUIPage (sName, pUIEventHandler, icon, caption, description, ""), m_sTitle (sTitle), m_Active (active), m_Closable (closable)
 {
 
 }
@@ -54,4 +54,14 @@ CUIDialog::~CUIDialog()
 std::string CUIDialog::getTitle()
 {
 	return m_sTitle;
+}
+
+CUIExpression& CUIDialog::getActiveExpression()
+{
+	return m_Active;
+}
+
+CUIExpression& CUIDialog::getClosableExpression()
+{
+	return m_Closable;
 }
\ No newline at end of file
diff --git a/Implementation/UI/amc_ui_dialog.hpp b/Implementation/UI/amc_ui_dialog.hpp
index a2f006110..5270cb98c 100644
--- a/Implementation/UI/amc_ui_dialog.hpp
+++ b/Implementation/UI/amc_ui_dialog.hpp
@@ -59,15 +59,28 @@ namespace AMC {
 
 		std::string m_sTitle;
 
+		// Optional "active" expression. When given (usually as sync:active bound to a machine
+		// parameter), the server decides whether the dialog is open and the client follows it
+		// on every frontend poll. Without it the dialog is only opened by client actions.
+		CUIExpression m_Active;
+
+		// "closable" expression, defaults to true. A non-closable dialog offers no close
+		// button and ignores Escape and clicks outside of it.
+		CUIExpression m_Closable;
+
 	public:
 
-		CUIDialog(const std::string & sName, const std::string& sTitle, CUIModule_UIEventHandler* pUIEventHandler, const CUIExpression& icon, const CUIExpression& caption, const CUIExpression& description);
-		
+		CUIDialog(const std::string & sName, const std::string& sTitle, CUIModule_UIEventHandler* pUIEventHandler, const CUIExpression& icon, const CUIExpression& caption, const CUIExpression& description, const CUIExpression& active, const CUIExpression& closable);
+
 		virtual ~CUIDialog();
 
 		std::string getTitle ();
 
-		
+		CUIExpression& getActiveExpression ();
+
+		CUIExpression& getClosableExpression ();
+
+
 	};
 		
 }
diff --git a/Implementation/UI/amc_ui_frontenddefinition.cpp b/Implementation/UI/amc_ui_frontenddefinition.cpp
index c40e55efa..81b882dca 100644
--- a/Implementation/UI/amc_ui_frontenddefinition.cpp
+++ b/Implementation/UI/amc_ui_frontenddefinition.cpp
@@ -120,6 +120,16 @@ void CUIFrontendDefinitionAttribute::collectSessionReferences(std::vector<std::s
 {
 }
 
+bool CUIFrontendDefinitionAttribute::isSynchronized()
+{
+	return true;
+}
+
+void CUIFrontendDefinitionAttribute::writeClientValueToFrontendJSON(CJSONWriter& writer, CJSONWriterObject& attributesObject, const std::string& sClientValue)
+{
+	throw ELibMCCustomException(LIBMC_ERROR_NOTIMPLEMENTED, "client values are not supported by attribute " + getName());
+}
+
 CUIFrontendDefinitionExpressionAttribute::CUIFrontendDefinitionExpressionAttribute(const std::string& sName, eUIFrontendDefinitionAttributeType attributeType, const CUIExpression& valueExpression)
 	: CUIFrontendDefinitionAttribute(sName, attributeType), m_ValueExpression(valueExpression)
 {
@@ -133,34 +143,52 @@ CUIFrontendDefinitionExpressionAttribute::~CUIFrontendDefinitionExpressionAttrib
 void CUIFrontendDefinitionExpressionAttribute::writeToFrontendJSON(CJSONWriter& writer, CJSONWriterObject& attributesObject, CStateMachineData* pStateMachineData, CUIFrontendState* pFrontendState)
 {
 	CUIExpressionSessionContext* pSessionContext = pFrontendState;
+	writeExpressionToFrontendJSON(attributesObject, m_ValueExpression, pStateMachineData, pSessionContext);
+}
+
+bool CUIFrontendDefinitionExpressionAttribute::isSynchronized()
+{
+	return m_ValueExpression.needsSync();
+}
+
+void CUIFrontendDefinitionExpressionAttribute::writeClientValueToFrontendJSON(CJSONWriter& writer, CJSONWriterObject& attributesObject, const std::string& sClientValue)
+{
+	// Client values are converted with the same rules as fixed values of the definition.
+	CUIExpression clientValueExpression;
+	clientValueExpression.setFixedValue(sClientValue);
+	writeExpressionToFrontendJSON(attributesObject, clientValueExpression, nullptr, nullptr);
+}
+
+void CUIFrontendDefinitionExpressionAttribute::writeExpressionToFrontendJSON(CJSONWriterObject& attributesObject, CUIExpression& valueExpression, CStateMachineData* pStateMachineData, CUIExpressionSessionContext* pSessionContext)
+{
 
 	switch (getAttributeType()) {
 		case eUIFrontendDefinitionAttributeType::atBoolean: {
-			bool bValue = m_ValueExpression.evaluateBoolValue (pStateMachineData, pSessionContext);
+			bool bValue = valueExpression.evaluateBoolValue(pStateMachineData, pSessionContext);
 			attributesObject.addBool(getName(), bValue);
 			break;
 		}
 
 		case eUIFrontendDefinitionAttributeType::atString: {
-			std::string sValue = m_ValueExpression.evaluateStringValue(pStateMachineData, pSessionContext);
+			std::string sValue = valueExpression.evaluateStringValue(pStateMachineData, pSessionContext);
 			attributesObject.addString(getName(), sValue);
 			break;
 		}
 
 		case eUIFrontendDefinitionAttributeType::atNumber: {
-			double dValue = m_ValueExpression.evaluateNumberValue(pStateMachineData, pSessionContext);
+			double dValue = valueExpression.evaluateNumberValue(pStateMachineData, pSessionContext);
 			attributesObject.addDouble(getName(), dValue);
 			break;
 		}
 
 		case eUIFrontendDefinitionAttributeType::atInteger: {
-			int64_t nValue = m_ValueExpression.evaluateIntegerValue(pStateMachineData, pSessionContext);
+			int64_t nValue = valueExpression.evaluateIntegerValue(pStateMachineData, pSessionContext);
 			attributesObject.addInteger(getName(), nValue);
 			break;
 		}
 
 		case eUIFrontendDefinitionAttributeType::atUUID: {
-			std::string sValue = m_ValueExpression.evaluateUUIDValue(pStateMachineData, pSessionContext);
+			std::string sValue = valueExpression.evaluateUUIDValue(pStateMachineData, pSessionContext);
 			attributesObject.addString(getName(), sValue);
 			break;
 		}
diff --git a/Implementation/UI/amc_ui_frontenddefinition.hpp b/Implementation/UI/amc_ui_frontenddefinition.hpp
index 4ac3dfbdf..02fbbb9c4 100644
--- a/Implementation/UI/amc_ui_frontenddefinition.hpp
+++ b/Implementation/UI/amc_ui_frontenddefinition.hpp
@@ -122,6 +122,14 @@ namespace AMC {
 
 		// Returns true if the value can differ between client sessions.
 		virtual bool isSessionScoped() = 0;
+
+		// Returns true if the value is bound to state machine data (or the session) and has to be evaluated on every
+		// request. Such attributes are never replaced by a client value. Provider attributes are always synchronized.
+		virtual bool isSynchronized();
+
+		// Writes a session specific value (e.g. set by a UI event handler with UIEnvironment::SetUIProperty) with the
+		// type of the attribute. The default implementation fails; only expression attributes support client values.
+		virtual void writeClientValueToFrontendJSON(CJSONWriter& writer, CJSONWriterObject& attributesObject, const std::string& sClientValue);
 	};
 
 	typedef std::shared_ptr<CUIFrontendDefinitionAttribute> PUIFrontendDefinitionAttribute;
@@ -131,7 +139,9 @@ namespace AMC {
 	private:
 		CUIExpression m_ValueExpression;
 
-	public: 
+		void writeExpressionToFrontendJSON(CJSONWriterObject& attributesObject, CUIExpression& valueExpression, CStateMachineData* pStateMachineData, CUIExpressionSessionContext* pSessionContext);
+
+	public:
 
 		CUIFrontendDefinitionExpressionAttribute(const std::string& sName, eUIFrontendDefinitionAttributeType attributeType, const CUIExpression& valueExpression);
 
@@ -143,6 +153,10 @@ namespace AMC {
 
 		virtual bool isSessionScoped() override;
 
+		virtual bool isSynchronized() override;
+
+		virtual void writeClientValueToFrontendJSON(CJSONWriter& writer, CJSONWriterObject& attributesObject, const std::string& sClientValue) override;
+
 	};
 
 
diff --git a/Implementation/UI/amc_ui_frontendstate.cpp b/Implementation/UI/amc_ui_frontendstate.cpp
index e01ade78f..34fad8611 100644
--- a/Implementation/UI/amc_ui_frontendstate.cpp
+++ b/Implementation/UI/amc_ui_frontendstate.cpp
@@ -31,6 +31,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define __AMCIMPL_UI_MODULE
 
 #include "amc_ui_frontendstate.hpp"
+#include "amc_ui_clientaction.hpp"
+#include "amc_jsoneventstreaminstance.hpp"
 #include "amc_parametergroup.hpp"
 #include "amc_userinformation.hpp"
 #include "amc_accesscontrol.hpp"
@@ -43,7 +45,7 @@ using namespace AMC;
 #define AMC_UI_SESSIONREFERENCE_PERMISSIONPREFIX "$user.permission."
 
 CUIFrontendState::CUIFrontendState(PUIFrontendDefinition pFrontendDefinition)
-	: m_pFrontendDefinition(pFrontendDefinition), m_nAppliedBroadcastCounter (0)
+	: m_pFrontendDefinition(pFrontendDefinition), m_nAppliedBroadcastCounter (0), m_nClientActionsRevision (0)
 {
 	if (pFrontendDefinition.get () == nullptr)
 		throw ELibMCInterfaceException(LIBMC_ERROR_INVALIDPARAM);
@@ -110,6 +112,145 @@ void CUIFrontendState::endEventStream()
 		pEventStream->endStream();
 }
 
+void CUIFrontendState::notifyEventStream()
+{
+	PJSONEventStreamInstance pEventStream;
+	{
+		std::lock_guard<std::mutex> lockGuard(m_EventStreamMutex);
+		pEventStream = m_pEventStream;
+	}
+
+	if (pEventStream.get() != nullptr)
+		pEventStream->notifyChange();
+}
+
+bool CUIFrontendState::removeExpiredClientActionsNoLock(std::chrono::steady_clock::time_point now)
+{
+	bool bRemoved = false;
+	for (auto iter = m_PendingClientActions.begin(); iter != m_PendingClientActions.end(); ) {
+		if (std::chrono::duration_cast<std::chrono::milliseconds>(now - iter->m_CreationTime).count() >= AMC_UI_CLIENTACTION_EXPIRY_MS) {
+			iter = m_PendingClientActions.erase(iter);
+			bRemoved = true;
+		}
+		else {
+			++iter;
+		}
+	}
+
+	if (bRemoved)
+		m_nClientActionsRevision++;
+
+	return bRemoved;
+}
+
+std::string CUIFrontendState::enqueueClientAction(PUIClientAction pAction, const std::string& sStreamUUID)
+{
+	if (pAction.get() == nullptr)
+		throw ELibMCInterfaceException(LIBMC_ERROR_INVALIDPARAM);
+
+	sPendingClientAction pendingAction;
+	pendingAction.m_sActionUUID = AMCCommon::CUtils::createUUID();
+	pendingAction.m_pAction = pAction;
+	pendingAction.m_sStreamUUID = sStreamUUID.empty() ? std::string() : AMCCommon::CUtils::normalizeUUIDString(sStreamUUID);
+	pendingAction.m_CreationTime = std::chrono::steady_clock::now();
+
+	{
+		std::lock_guard<std::mutex> lockGuard(m_ClientActionsMutex);
+		removeExpiredClientActionsNoLock(pendingAction.m_CreationTime);
+		m_PendingClientActions.push_back(pendingAction);
+		m_nClientActionsRevision++;
+	}
+
+	notifyEventStream();
+
+	return pendingAction.m_sActionUUID;
+}
+
+bool CUIFrontendState::claimClientAction(const std::string& sActionUUID)
+{
+	std::string sNormalizedUUID = AMCCommon::CUtils::normalizeUUIDString(sActionUUID);
+	bool bClaimed = false;
+
+	{
+		std::lock_guard<std::mutex> lockGuard(m_ClientActionsMutex);
+		removeExpiredClientActionsNoLock(std::chrono::steady_clock::now());
+		for (auto iter = m_PendingClientActions.begin(); iter != m_PendingClientActions.end(); ++iter) {
+			if (iter->m_sActionUUID == sNormalizedUUID) {
+				m_PendingClientActions.erase(iter);
+				m_nClientActionsRevision++;
+				bClaimed = true;
+				break;
+			}
+		}
+	}
+
+	if (bClaimed)
+		notifyEventStream();
+
+	return bClaimed;
+}
+
+void CUIFrontendState::removeClientActionsOfStream(const std::string& sStreamUUID)
+{
+	std::string sNormalizedUUID = AMCCommon::CUtils::normalizeUUIDString(sStreamUUID);
+	bool bRemoved = false;
+
+	{
+		std::lock_guard<std::mutex> lockGuard(m_ClientActionsMutex);
+		for (auto iter = m_PendingClientActions.begin(); iter != m_PendingClientActions.end(); ) {
+			if (iter->m_sStreamUUID == sNormalizedUUID) {
+				iter = m_PendingClientActions.erase(iter);
+				bRemoved = true;
+			}
+			else {
+				++iter;
+			}
+		}
+		if (bRemoved)
+			m_nClientActionsRevision++;
+	}
+
+	if (bRemoved)
+		notifyEventStream();
+}
+
+bool CUIFrontendState::hasClientActionsOfStream(const std::string& sStreamUUID)
+{
+	std::string sNormalizedUUID = AMCCommon::CUtils::normalizeUUIDString(sStreamUUID);
+
+	std::lock_guard<std::mutex> lockGuard(m_ClientActionsMutex);
+	removeExpiredClientActionsNoLock(std::chrono::steady_clock::now());
+	for (auto& pendingAction : m_PendingClientActions) {
+		if (pendingAction.m_sStreamUUID == sNormalizedUUID)
+			return true;
+	}
+
+	return false;
+}
+
+uint64_t CUIFrontendState::getClientActionsRevision()
+{
+	std::lock_guard<std::mutex> lockGuard(m_ClientActionsMutex);
+	removeExpiredClientActionsNoLock(std::chrono::steady_clock::now());
+	return m_nClientActionsRevision;
+}
+
+void CUIFrontendState::writePendingClientActionsToJSON(CJSONWriter& writer)
+{
+	std::lock_guard<std::mutex> lockGuard(m_ClientActionsMutex);
+	removeExpiredClientActionsNoLock(std::chrono::steady_clock::now());
+
+	CJSONWriterArray actionsArray(writer);
+	for (auto& pendingAction : m_PendingClientActions) {
+		CJSONWriterObject actionObject(writer);
+		actionObject.addString(AMC_UI_CLIENTACTION_UUIDJSONKEY, pendingAction.m_sActionUUID);
+		pendingAction.m_pAction->writeToJSON(writer, actionObject);
+		actionsArray.addObject(actionObject);
+	}
+
+	writer.addArray(AMC_UI_CLIENTACTIONS_JSONKEY, actionsArray);
+}
+
 CParameterGroup* CUIFrontendState::getSessionVariables()
 {
 	std::lock_guard<std::mutex> lockGuard(m_SessionMutex);
@@ -301,9 +442,22 @@ void CUIFrontendState::validateSessionReference(const std::string& sReference, C
 
 void CUIFrontendState::writeModuleAttributesToJSON(CJSONWriter& writer, CJSONWriterObject & attributesObject, CUIFrontendDefinitionModuleStore * pModuleStore, CStateMachineData* pStateMachineData, const sUIFrontendBuildEpoch& epoch)
 {
+	LibMCAssertNotNull(pModuleStore);
+
+	// UI event handlers change element properties of a session with UIEnvironment::SetUIProperty,
+	// which writes to the legacy client variables. Report these values instead of the definition
+	// values. Attributes bound to state machine data always win, like in the legacy syncClientVariables.
+	auto pClientVariableGroup = m_pLegacyParameterHandler->findGroup(pModuleStore->getPath(), false);
+
 	auto attributes = pModuleStore->getAttributes();
 	for (auto& pAttribute : attributes) {
-		pAttribute->writeToFrontendJSONForEpoch(writer, attributesObject, pStateMachineData, this, epoch);
+		std::string sAttributeName = pAttribute->getName();
+
+		// A client value is specific to this session, so it bypasses the per-epoch cache of global attributes.
+		if ((pClientVariableGroup.get() != nullptr) && (!pAttribute->isSynchronized()) && pClientVariableGroup->hasParameter(sAttributeName))
+			pAttribute->writeClientValueToFrontendJSON(writer, attributesObject, pClientVariableGroup->getParameterValueByName(sAttributeName));
+		else
+			pAttribute->writeToFrontendJSONForEpoch(writer, attributesObject, pStateMachineData, this, epoch);
 	}
 
 }
diff --git a/Implementation/UI/amc_ui_frontendstate.hpp b/Implementation/UI/amc_ui_frontendstate.hpp
index 5de5a9b74..f3be4ee1c 100644
--- a/Implementation/UI/amc_ui_frontendstate.hpp
+++ b/Implementation/UI/amc_ui_frontendstate.hpp
@@ -41,9 +41,28 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <functional>
 #include <mutex>
+#include <deque>
+#include <chrono>
+
+// An action that no browser tab claimed within this time is dropped.
+#define AMC_UI_CLIENTACTION_EXPIRY_MS 30000
+#define AMC_UI_CLIENTACTIONS_JSONKEY "pendingactions"
+#define AMC_UI_CLIENTACTION_UUIDJSONKEY "actionuuid"
 
 namespace AMC {
 
+	class CUIClientAction;
+	typedef std::shared_ptr<CUIClientAction> PUIClientAction;
+
+	// A client action queued by the server for the browser tabs of a session, for example a download
+	// that a state machine prepared. Exactly one tab claims and executes it.
+	typedef struct _sPendingClientAction {
+		std::string m_sActionUUID;
+		PUIClientAction m_pAction;
+		std::string m_sStreamUUID;
+		std::chrono::steady_clock::time_point m_CreationTime;
+	} sPendingClientAction;
+
 	class CUserInformation;
 	typedef std::shared_ptr<CUserInformation> PUserInformation;
 
@@ -70,6 +89,16 @@ namespace AMC {
 		std::mutex m_EventStreamMutex;
 		PJSONEventStreamInstance m_pEventStream;
 
+		std::mutex m_ClientActionsMutex;
+		std::deque<sPendingClientAction> m_PendingClientActions;
+		// Changes with every enqueue, claim and expiry; the event stream sends the queue when it differs.
+		uint64_t m_nClientActionsRevision;
+
+		// Drops expired actions. Returns true if any was dropped. Caller holds m_ClientActionsMutex.
+		bool removeExpiredClientActionsNoLock(std::chrono::steady_clock::time_point now);
+
+		void notifyEventStream();
+
 		// Returns the session variable group after applying broadcasts that arrived since the last access.
 		CParameterGroup* getSessionVariables();
 
@@ -96,6 +125,21 @@ namespace AMC {
 		// since the stream keeps a reference to the session's authentication.
 		void endEventStream();
 
+		// Queues an action for the browser tabs of this session and wakes the event stream. Returns the action UUID.
+		std::string enqueueClientAction(PUIClientAction pAction, const std::string& sStreamUUID);
+
+		// The first tab that claims an action executes it. Returns false if the action is unknown, expired or claimed.
+		bool claimClientAction(const std::string& sActionUUID);
+
+		void removeClientActionsOfStream(const std::string& sStreamUUID);
+
+		bool hasClientActionsOfStream(const std::string& sStreamUUID);
+
+		uint64_t getClientActionsRevision();
+
+		// Writes the unclaimed actions as the array "pendingactions". Expired actions are dropped first.
+		void writePendingClientActionsToJSON(CJSONWriter& writer);
+
 		bool hasSessionVariable(const std::string& sName);
 
 		std::string getSessionVariable(const std::string& sName);
diff --git a/Implementation/UI/amc_ui_handler.cpp b/Implementation/UI/amc_ui_handler.cpp
index ed69a11c2..7111a57b1 100644
--- a/Implementation/UI/amc_ui_handler.cpp
+++ b/Implementation/UI/amc_ui_handler.cpp
@@ -232,7 +232,7 @@ PUICustomPage CUIHandler::addCustomPage_Unsafe(const std::string& sName, const s
 
 }
 
-PUIDialog CUIHandler::addDialog_Unsafe(const std::string& sName, const std::string& sTitle, const CUIExpression& icon, const CUIExpression& caption, const CUIExpression& description)
+PUIDialog CUIHandler::addDialog_Unsafe(const std::string& sName, const std::string& sTitle, const CUIExpression& icon, const CUIExpression& caption, const CUIExpression& description, const CUIExpression& active, const CUIExpression& closable)
 {
     if (sName.empty())
         throw ELibMCInterfaceException(LIBMC_ERROR_INVALIDDIALOGNAME);
@@ -241,7 +241,7 @@ PUIDialog CUIHandler::addDialog_Unsafe(const std::string& sName, const std::stri
     if (iIterator != m_Dialogs.end())
         throw ELibMCCustomException(LIBMC_ERROR_DUPLICATEDIALOG, sName);
 
-    auto pDialog = std::make_shared<CUIDialog>(sName, sTitle, this, icon, caption, description);
+    auto pDialog = std::make_shared<CUIDialog>(sName, sTitle, this, icon, caption, description, active, closable);
     m_Dialogs.insert(std::make_pair(sName, pDialog));
 
     return pDialog;
@@ -546,7 +546,14 @@ void CUIHandler::loadFromXML(pugi::xml_node& xmlNode, const std::string& sUILibr
         auto dialogTitleAttrib = dialogNode.attribute("title");
         std::string sDialogTitle(dialogTitleAttrib.as_string());
 
-        auto pDialog = addDialog_Unsafe(sDialogName, sDialogTitle, icon, caption, description);
+        // active: optional, server-driven open state (usually sync:active="machine.group.param").
+        // closable: defaults to true; "0" removes every client-side way of closing the dialog.
+        CUIExpression active(dialogNode, "active");
+        CUIExpression closable(dialogNode, "closable", "1");
+        active.checkExpressionSyntax(pStateMachineData);
+        closable.checkExpressionSyntax(pStateMachineData);
+
+        auto pDialog = addDialog_Unsafe(sDialogName, sDialogTitle, icon, caption, description, active, closable);
         pDialog->setVisibleExpression(CUIExpression(dialogNode, "visible", "1"));
 
         auto dialogChildren = dialogNode.children();
@@ -1099,6 +1106,15 @@ void CUIHandler::frontendWriteStatusToJSON(CJSONWriter& writer, CAPIAuth* pAuth,
     for (auto iter : m_Dialogs) {
         CJSONWriterObject dialog(writer);
         dialog.addString(AMC_API_KEY_UI_DIALOGTITLE, iter.second->getTitle());
+
+        // "active" is only emitted for server-driven dialogs, so the client leaves
+        // event-driven dialogs alone and follows the server for the others. Both flags are
+        // members of the dialog object, so the frontend snapshot diff carries their changes.
+        auto& activeExpression = iter.second->getActiveExpression();
+        if (!activeExpression.isEmpty(pStateMachineData, pFrontendState))
+            dialog.addBool(AMC_API_KEY_UI_DIALOGACTIVE, activeExpression.evaluateBoolValue(pStateMachineData, pFrontendState));
+        dialog.addBool(AMC_API_KEY_UI_DIALOGCLOSABLE, iter.second->getClosableExpression().evaluateBoolValue(pStateMachineData, pFrontendState));
+
         bool bWriteModules = bWriteAllModules || isActiveName(pActiveDialogNames, iter.first);
         iter.second->frontendWritePageStatusToJSON(writer, dialog, pFrontendState, pStateMachineData, bWriteModules, epoch);
         dialogs.addObject(dialog);
diff --git a/Implementation/UI/amc_ui_handler.hpp b/Implementation/UI/amc_ui_handler.hpp
index fc05b0d4e..81402d792 100644
--- a/Implementation/UI/amc_ui_handler.hpp
+++ b/Implementation/UI/amc_ui_handler.hpp
@@ -152,7 +152,7 @@ namespace AMC {
 
 		PUICustomPage addCustomPage_Unsafe(const std::string& sName, const std::string& sComponentName, const CUIExpression& icon, const CUIExpression& caption, const CUIExpression& description);
 
-		PUIDialog addDialog_Unsafe(const std::string& sName, const std::string& sTitle, const CUIExpression& icon, const CUIExpression& caption, const CUIExpression& description);
+		PUIDialog addDialog_Unsafe(const std::string& sName, const std::string& sTitle, const CUIExpression& icon, const CUIExpression& caption, const CUIExpression& description, const CUIExpression& active, const CUIExpression& closable);
 
 	public:
 
diff --git a/Implementation/UI/amc_ui_module_contentitem_buttongroup.cpp b/Implementation/UI/amc_ui_module_contentitem_buttongroup.cpp
index d2e4b7133..c871905c1 100644
--- a/Implementation/UI/amc_ui_module_contentitem_buttongroup.cpp
+++ b/Implementation/UI/amc_ui_module_contentitem_buttongroup.cpp
@@ -44,12 +44,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 using namespace AMC;
 
-CUIModule_ContentButton::CUIModule_ContentButton (const std::string & sGroupPath, const CUIExpression& Caption, const CUIExpression& TargetPage, const CUIExpression& Event, const std::string& sButtonName, const CUIExpression& IconName, const CUIExpression& DisabledExpression, const CUIExpression& VisibleExpression, const std::string& sEventFormValueSetting, PStateMachineData pStateMachineData)
-	: m_sUUID(AMCCommon::CUtils::createUUID()), 
-	 m_CaptionExpression(Caption), 
-	m_TargetPageExpression(TargetPage), 
-	m_EventExpression (Event), 
+CUIModule_ContentButton::CUIModule_ContentButton (const std::string & sGroupPath, const CUIExpression& Caption, const CUIExpression& TargetPage, const CUIExpression& Event, const std::string& sButtonName, const CUIExpression& IconName, const CUIExpression& DisabledExpression, const CUIExpression& VisibleExpression, const CUIExpression& Hint, const std::string& sEventFormValueSetting, PStateMachineData pStateMachineData)
+	: m_sUUID(AMCCommon::CUtils::createUUID()),
+	 m_CaptionExpression(Caption),
+	m_TargetPageExpression(TargetPage),
+	m_EventExpression (Event),
 	m_IconExpression(IconName),
+	m_HintExpression(Hint),
 	m_DisabledExpression (DisabledExpression),
 	m_VisibleExpression (VisibleExpression),
 	m_sEventFormValueSetting(sEventFormValueSetting), 
@@ -158,7 +159,8 @@ PParameterGroup CUIModule_ContentButton::registerClientVariableGroup(CParameterH
 	pGroup->addNewStringParameter(AMC_API_KEY_UI_BUTTONTARGETPAGE, "button target page", m_TargetPageExpression.evaluateStringValue(m_pStateMachineData));
 	pGroup->addNewStringParameter(AMC_API_KEY_UI_BUTTONEVENT, "button event", m_EventExpression.evaluateStringValue(m_pStateMachineData));
 	pGroup->addNewStringParameter(AMC_API_KEY_UI_BUTTONICON, "button icon", m_IconExpression.evaluateStringValue(m_pStateMachineData));
-	// Readable by event handlers via GetUIProperty(sender, "tags"). Always registered
+	pGroup->addNewStringParameter(AMC_API_KEY_UI_BUTTONHINT, "button hint", m_HintExpression.evaluateStringValue(m_pStateMachineData));
+	// Readable by event handlers via GetUIProperty(sender, "tags").Always registered
 	// (empty when unset) so the lookup never throws for untagged buttons.
 	pGroup->addNewStringParameter("tags", "button tags", m_sTags);
 
@@ -184,6 +186,7 @@ void CUIModule_ContentButton::writeVariablesToJSON(CJSONWriter& writer, CJSONWri
 	object.addString(AMC_API_KEY_UI_BUTTONTARGETPAGE, pGroup->getParameterValueByName(AMC_API_KEY_UI_BUTTONTARGETPAGE));
 	object.addString(AMC_API_KEY_UI_BUTTONEVENT, pGroup->getParameterValueByName(AMC_API_KEY_UI_BUTTONEVENT));
 	object.addString(AMC_API_KEY_UI_BUTTONICON, pGroup->getParameterValueByName(AMC_API_KEY_UI_BUTTONICON));
+	object.addString(AMC_API_KEY_UI_BUTTONHINT, pGroup->getParameterValueByName(AMC_API_KEY_UI_BUTTONHINT));
 
 	// Static toolbar layout metadata.
 	object.addString("kind", m_sKind);
@@ -211,6 +214,8 @@ void CUIModule_ContentButton::syncClientVariables(CParameterHandler* pClientVari
 			pGroup->setParameterValueByName(AMC_API_KEY_UI_BUTTONEVENT, m_EventExpression.evaluateStringValue(m_pStateMachineData));
 		if (m_IconExpression.needsSync())
 			pGroup->setParameterValueByName(AMC_API_KEY_UI_BUTTONICON, m_IconExpression.evaluateStringValue(m_pStateMachineData));
+		if (m_HintExpression.needsSync())
+			pGroup->setParameterValueByName(AMC_API_KEY_UI_BUTTONHINT, m_HintExpression.evaluateStringValue(m_pStateMachineData));
 
 	}
 
@@ -228,6 +233,8 @@ void CUIModule_ContentButton::registerFrontendAttributes(PUIFrontendDefinitionMo
 	pStore->registerValue("event", eUIFrontendDefinitionAttributeType::atString, m_EventExpression);
 	pStore->registerValue("targetpage", eUIFrontendDefinitionAttributeType::atString, m_TargetPageExpression);
 	pStore->registerValue("icon", eUIFrontendDefinitionAttributeType::atString, m_IconExpression);
+	// Tooltip of the button; it may be bound to a state machine parameter with sync:hint.
+	pStore->registerValue("hint", eUIFrontendDefinitionAttributeType::atString, m_HintExpression);
 
 	// Static toolbar layout metadata registered as fixed-value attributes.
 	CUIExpression kindExpr; kindExpr.setFixedValue(m_sKind);
@@ -322,8 +329,9 @@ PUIModule_ContentButtonGroup CUIModule_ContentButtonGroup::makeFromXML(const pug
 		// Per-button visibility; defaults to visible ("1") when neither "visible" nor
 		// "sync:visible" is specified, so existing buttons are unaffected.
 		CUIExpression visibleExpression(childNode, "visible", "1");
+		CUIExpression hintExpression(childNode, "hint", "");
 
-		auto pButton = pButtonGroup->addButton(captionExpression, targetPageExpression, eventExpression, sButtonName, iconExpression, disabledExpression, visibleExpression, formvaluesAttrib.as_string());
+		auto pButton = pButtonGroup->addButton(captionExpression, targetPageExpression, eventExpression, sButtonName, iconExpression, disabledExpression, visibleExpression, hintExpression, formvaluesAttrib.as_string());
 
 		pButton->setKind(sKind);
 
@@ -374,9 +382,9 @@ CUIModule_ContentButtonGroup::~CUIModule_ContentButtonGroup()
 }
 
 
-PUIModule_ContentButton CUIModule_ContentButtonGroup::addButton(const CUIExpression& Caption, const CUIExpression& TargetPage, const CUIExpression& Event, const std::string& sButtonName, const CUIExpression& IconName, const CUIExpression& DisabledExpression, const CUIExpression& VisibleExpression, const std::string& sEventFormValueSetting)
+PUIModule_ContentButton CUIModule_ContentButtonGroup::addButton(const CUIExpression& Caption, const CUIExpression& TargetPage, const CUIExpression& Event, const std::string& sButtonName, const CUIExpression& IconName, const CUIExpression& DisabledExpression, const CUIExpression& VisibleExpression, const CUIExpression& HintExpression, const std::string& sEventFormValueSetting)
 {
-	auto pButton = std::make_shared<CUIModule_ContentButton>(m_sItemPath, Caption, TargetPage, Event, sButtonName, IconName, DisabledExpression, VisibleExpression, sEventFormValueSetting, m_pStateMachineData);
+	auto pButton = std::make_shared<CUIModule_ContentButton>(m_sItemPath, Caption, TargetPage, Event, sButtonName, IconName, DisabledExpression, VisibleExpression, HintExpression, sEventFormValueSetting, m_pStateMachineData);
 	m_Buttons.push_back(pButton);
 	m_ButtonMap.insert(std::make_pair (pButton->getUUID (), pButton));
 
diff --git a/Implementation/UI/amc_ui_module_contentitem_buttongroup.hpp b/Implementation/UI/amc_ui_module_contentitem_buttongroup.hpp
index 83e00e740..d6bdaed22 100644
--- a/Implementation/UI/amc_ui_module_contentitem_buttongroup.hpp
+++ b/Implementation/UI/amc_ui_module_contentitem_buttongroup.hpp
@@ -76,6 +76,7 @@ namespace AMC {
 		CUIExpression m_TargetPageExpression;
 		CUIExpression m_EventExpression;
 		CUIExpression m_IconExpression;
+		CUIExpression m_HintExpression;
 
 		// Static layout metadata (toolbar concept):
 		//   kind    = "button" | "spacer" | "spring"
@@ -103,7 +104,7 @@ namespace AMC {
 
 	public:
 
-		CUIModule_ContentButton (const std::string & sGroupPath, const CUIExpression& Caption, const CUIExpression& TargetPage, const CUIExpression& Event, const std::string& sButtonName, const CUIExpression & IconName, const CUIExpression& Disabled, const CUIExpression& Visible, const std::string& sEventFormValueSetting, PStateMachineData pStateMachineData);
+		CUIModule_ContentButton (const std::string & sGroupPath, const CUIExpression& Caption, const CUIExpression& TargetPage, const CUIExpression& Event, const std::string& sButtonName, const CUIExpression & IconName, const CUIExpression& Disabled, const CUIExpression& Visible, const CUIExpression& Hint, const std::string& sEventFormValueSetting, PStateMachineData pStateMachineData);
 
 		virtual ~CUIModule_ContentButton();
 
@@ -158,7 +159,7 @@ namespace AMC {
 
 		virtual ~CUIModule_ContentButtonGroup();
 
-		PUIModule_ContentButton addButton(const CUIExpression& Caption, const CUIExpression& TargetPage, const CUIExpression& Event, const std::string& sButtonName, const CUIExpression& IconName, const CUIExpression& DisabledExpression, const CUIExpression& VisibleExpression, const std::string& sEventFormValueSetting);
+		PUIModule_ContentButton addButton(const CUIExpression& Caption, const CUIExpression& TargetPage, const CUIExpression& Event, const std::string& sButtonName, const CUIExpression& IconName, const CUIExpression& DisabledExpression, const CUIExpression& VisibleExpression, const CUIExpression& HintExpression, const std::string& sEventFormValueSetting);
 
 		virtual void configurePostLoading() override;
 
diff --git a/Implementation/UI/amc_ui_module_contentitem_datacapture.cpp b/Implementation/UI/amc_ui_module_contentitem_datacapture.cpp
new file mode 100644
index 000000000..d66cc6d94
--- /dev/null
+++ b/Implementation/UI/amc_ui_module_contentitem_datacapture.cpp
@@ -0,0 +1,93 @@
+/*++
+
+Copyright (C) 2020 Autodesk Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+	* Redistributions of source code must retain the above copyright
+	  notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+	  notice, this list of conditions and the following disclaimer in the
+	  documentation and/or other materials provided with the distribution.
+	* Neither the name of the Autodesk Inc. nor the
+	  names of its contributors may be used to endorse or promote products
+	  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL AUTODESK INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#define __AMCIMPL_UI_MODULE
+#define __AMCIMPL_API_CONSTANTS
+
+#include "amc_ui_module_contentitem_datacapture.hpp"
+#include "libmc_interfaceexception.hpp"
+
+#include "amc_api_constants.hpp"
+#include "Common/common_utils.hpp"
+#include "amc_parameterhandler.hpp"
+
+using namespace AMC;
+
+
+PUIModule_ContentDataCapture CUIModule_ContentDataCapture::makeFromXML(const pugi::xml_node& xmlNode, const std::string& sItemName, const std::string& sModulePath)
+{
+	auto titleAttrib = xmlNode.attribute("title");
+	CUIExpression titleExpression(xmlNode, "title", std::string("Data Capture"));
+
+	// The capture uuid usually comes from a state machine parameter that the plugin sets when it creates the capture.
+	auto captureUUIDAttrib = xmlNode.attribute("captureuuid");
+	CUIExpression captureUUIDExpression(xmlNode, "captureuuid", std::string(""));
+
+	auto defaultColumnsAttrib = xmlNode.attribute("defaultcolumns");
+	CUIExpression defaultColumnsExpression(xmlNode, "defaultcolumns", std::string(""));
+
+	return std::make_shared<CUIModule_ContentDataCapture>(
+		titleAttrib.empty() ? "Data Capture" : titleAttrib.as_string(),
+		titleExpression,
+		captureUUIDAttrib.empty() ? "" : captureUUIDAttrib.as_string(),
+		captureUUIDExpression,
+		defaultColumnsAttrib.empty() ? "" : defaultColumnsAttrib.as_string(),
+		defaultColumnsExpression,
+		sItemName,
+		sModulePath
+	);
+}
+
+CUIModule_ContentDataCapture::CUIModule_ContentDataCapture(const std::string& sTitle, const CUIExpression& titleExpression, const std::string& sCaptureUUID, const CUIExpression& captureUUIDExpression, const std::string& sDefaultColumns, const CUIExpression& defaultColumnsExpression, const std::string& sItemName, const std::string& sModulePath)
+	: CUIModule_ContentItem(AMCCommon::CUtils::createUUID(), sItemName, sModulePath),
+	  m_sTitle(sTitle),
+	  m_sCaptureUUID(sCaptureUUID),
+	  m_sDefaultColumns(sDefaultColumns),
+	  m_TitleExpression(titleExpression),
+	  m_CaptureUUIDExpression(captureUUIDExpression),
+	  m_DefaultColumnsExpression(defaultColumnsExpression)
+{
+}
+
+CUIModule_ContentDataCapture::~CUIModule_ContentDataCapture()
+{
+}
+
+std::string CUIModule_ContentDataCapture::getItemType()
+{
+	return "datacapture";
+}
+
+void CUIModule_ContentDataCapture::registerFrontendAttributes()
+{
+	registerItemStringAttribute("title", m_TitleExpression);
+	registerItemStringAttribute("captureuuid", m_CaptureUUIDExpression);
+	registerItemStringAttribute("defaultcolumns", m_DefaultColumnsExpression);
+}
diff --git a/Implementation/UI/amc_ui_module_contentitem_datacapture.hpp b/Implementation/UI/amc_ui_module_contentitem_datacapture.hpp
new file mode 100644
index 000000000..ef8088ad1
--- /dev/null
+++ b/Implementation/UI/amc_ui_module_contentitem_datacapture.hpp
@@ -0,0 +1,80 @@
+/*++
+
+Copyright (C) 2020 Autodesk Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+	* Redistributions of source code must retain the above copyright
+	  notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+	  notice, this list of conditions and the following disclaimer in the
+	  documentation and/or other materials provided with the distribution.
+	* Neither the name of the Autodesk Inc. nor the
+	  names of its contributors may be used to endorse or promote products
+	  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL AUTODESK INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+
+#ifndef __AMC_UI_MODULE_CONTENTITEM_DATACAPTURE
+#define __AMC_UI_MODULE_CONTENTITEM_DATACAPTURE
+
+#include "header_protection.hpp"
+
+#ifndef __AMCIMPL_UI_MODULE
+#error this header is protected and should only be included in the corresponding implementation CPP files.
+#endif
+
+#include "amc_ui_module_contentitem.hpp"
+
+#include "pugixml.hpp"
+#include "amc_ui_expression.hpp"
+
+namespace AMC {
+
+	amcDeclareDependingClass(CUIModule_ContentDataCapture, PUIModule_ContentDataCapture);
+
+
+	// A data capture viewer content item. It only carries presentation configuration:
+	// the title, the uuid of the capture to show and the columns that are plotted initially.
+	// All data is fetched by the client from the /api/datatable REST endpoints.
+	class CUIModule_ContentDataCapture : public CUIModule_ContentItem {
+	protected:
+
+		std::string m_sTitle;
+		std::string m_sCaptureUUID;
+		std::string m_sDefaultColumns;
+		CUIExpression m_TitleExpression;
+		CUIExpression m_CaptureUUIDExpression;
+		CUIExpression m_DefaultColumnsExpression;
+
+	public:
+
+		static PUIModule_ContentDataCapture makeFromXML(const pugi::xml_node& xmlNode, const std::string& sItemName, const std::string& sModulePath);
+
+		CUIModule_ContentDataCapture(const std::string& sTitle, const CUIExpression& titleExpression, const std::string& sCaptureUUID, const CUIExpression& captureUUIDExpression, const std::string& sDefaultColumns, const CUIExpression& defaultColumnsExpression, const std::string& sItemName, const std::string& sModulePath);
+
+		virtual ~CUIModule_ContentDataCapture();
+
+		virtual std::string getItemType() override;
+		virtual void registerFrontendAttributes() override;
+
+	};
+
+}
+
+
+#endif //__AMC_UI_MODULE_CONTENTITEM_DATACAPTURE
diff --git a/Implementation/UI/amc_ui_module_contentleaf.cpp b/Implementation/UI/amc_ui_module_contentleaf.cpp
index 948f6218b..e5bfdd87f 100644
--- a/Implementation/UI/amc_ui_module_contentleaf.cpp
+++ b/Implementation/UI/amc_ui_module_contentleaf.cpp
@@ -39,6 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "amc_ui_module_contentitem_image.hpp"
 #include "amc_ui_module_contentitem_chart.hpp"
 #include "amc_ui_module_contentitem_journalhistory.hpp"
+#include "amc_ui_module_contentitem_datacapture.hpp"
 #include "amc_ui_module_contentitem_upload.hpp"
 #include "amc_ui_module_contentitem_buildlist.hpp"
 #include "amc_ui_module_contentitem_partlist.hpp"
@@ -122,6 +123,8 @@ CUIModule_ContentLeaf::CUIModule_ContentLeaf(pugi::xml_node& xmlNode, const std:
 		m_pItem = CUIModule_ContentStateMachineGraph::makeFromXML(xmlNode, m_sName, sPath, pUIModuleEnvironment);
 	if (m_sModuleType == "journalhistory")
 		m_pItem = CUIModule_ContentJournalHistory::makeFromXML(xmlNode, m_sName, sPath);
+	if (m_sModuleType == "datacapture")
+		m_pItem = CUIModule_ContentDataCapture::makeFromXML(xmlNode, m_sName, sPath);
 
 	LibMCAssertNotNull(m_pItem.get());
 
@@ -154,7 +157,7 @@ bool CUIModule_ContentLeaf::isSupportedModuleType(const std::string& sType)
 	return (sType == "paragraph") || (sType == "image") || (sType == "chart") || (sType == "videostream") ||
 		(sType == "upload") || (sType == "buildlist") || (sType == "partlist") || (sType == "executionlist") || (sType == "alertlist") ||
 		(sType == "buttongroup") || (sType == "parameterlist") || (sType == "statuslist") || (sType == "togglepanel") || (sType == "configurationlist") || (sType == "form") ||
-		(sType == "separator") || (sType == "statusbanner") || (sType == "workflow") || (sType == "statemachinegraph") || (sType == "journalhistory");
+		(sType == "separator") || (sType == "statusbanner") || (sType == "workflow") || (sType == "statemachinegraph") || (sType == "journalhistory") || (sType == "datacapture");
 }
 
 std::string CUIModule_ContentLeaf::getType()
diff --git a/Implementation/UI/amc_ui_module_layerview.cpp b/Implementation/UI/amc_ui_module_layerview.cpp
index 60d207893..dcc9b548d 100644
--- a/Implementation/UI/amc_ui_module_layerview.cpp
+++ b/Implementation/UI/amc_ui_module_layerview.cpp
@@ -51,6 +51,18 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 using namespace AMC;
 
 
+// The frontend loads platform images via /image/{uuid}, so a resource name from config.xml has to be
+// resolved to the UUID of its resource package entry. Returns an empty string for an empty name.
+static std::string resolveImageResourceUUID(PUIModuleEnvironment pUIModuleEnvironment, CUIExpression& imageExpression, PStateMachineData pStateMachineData)
+{
+	std::string sResourceName = imageExpression.evaluateStringValue(pStateMachineData);
+	if (sResourceName.empty())
+		return "";
+
+	auto pResourceEntry = pUIModuleEnvironment->resourcePackage()->findEntryByName(sResourceName, true);
+	return pResourceEntry->getUUID();
+}
+
 
 CUIModule_LayerViewPlatformItem::CUIModule_LayerViewPlatformItem (const std::string& sItemPath, CUIExpression sizeX, CUIExpression sizeY, CUIExpression originX, CUIExpression originY, CUIExpression paddingX, CUIExpression paddingY, CUIExpression transformAngle, CUIExpression rotationCenterX, CUIExpression rotationCenterY, CUIExpression translationX, CUIExpression translationY, CUIExpression showCoordinateSystem, CUIExpression layerIndex, CUIExpression baseImage, PUIModuleEnvironment pUIModuleEnvironment)
 	: CUIModuleItem(sItemPath), m_SizeX(sizeX), m_SizeY(sizeY), m_OriginX(originX), m_OriginY(originY), m_PaddingX(paddingX), m_PaddingY(paddingY), m_TransformAngle(transformAngle), m_RotationCenterX(rotationCenterX), m_RotationCenterY(rotationCenterY), m_TranslationX(translationX), m_TranslationY(translationY), m_ShowCoordinateSystem(showCoordinateSystem), m_BaseImage(baseImage), m_pUIModuleEnvironment(pUIModuleEnvironment),
@@ -142,7 +154,12 @@ void CUIModule_LayerViewPlatformItem::populateClientVariables(CParameterHandler*
 	pGroup->addNewDoubleParameter(AMC_API_KEY_UI_TRANSLATIONX, "Toolpath translation x", m_TranslationX.evaluateNumberValue(pStateMachineData), 1.0);
 	pGroup->addNewDoubleParameter(AMC_API_KEY_UI_TRANSLATIONY, "Toolpath translation y", m_TranslationY.evaluateNumberValue(pStateMachineData), 1.0);
 	pGroup->addNewIntParameter(AMC_API_KEY_UI_SHOWCOORDINATESYSTEM, "Show coordinate system annotation by default", m_ShowCoordinateSystem.evaluateIntegerValue(pStateMachineData));
-	pGroup->addNewStringParameter(AMC_API_KEY_UI_BASEIMAGERESOURCE, "Platform base image", m_BaseImage.evaluateStringValue(pStateMachineData));
+	// Client variables take precedence over the attributes of the new frontend, so the resource name
+	// has to be resolved to the UUID here as well.
+	std::string sBaseImageResourceUUID = resolveImageResourceUUID(m_pUIModuleEnvironment, m_BaseImage, pStateMachineData);
+	if (sBaseImageResourceUUID.empty())
+		sBaseImageResourceUUID = AMCCommon::CUtils::createEmptyUUID();
+	pGroup->addNewStringParameter(AMC_API_KEY_UI_BASEIMAGERESOURCE, "Platform base image", sBaseImageResourceUUID);
 	pGroup->addNewIntParameter(AMC_API_KEY_UI_LABELVISIBLE, "Label is visible", m_LabelVisible.evaluateIntegerValue (pStateMachineData));
 	pGroup->addNewStringParameter(AMC_API_KEY_UI_LABELCAPTION, "Label caption", m_LabelCaption.evaluateStringValue(pStateMachineData));
 	pGroup->addNewStringParameter(AMC_API_KEY_UI_LABELICON, "Label icon", m_LabelIcon.evaluateStringValue(pStateMachineData));
@@ -445,26 +462,17 @@ CUIModule_LayerView::CUIModule_LayerView(pugi::xml_node& xmlNode, const std::str
 	// Resolve the resource name -> UUID once at startup and register as a fixed value.
 	{
 		auto pStateMachineData = pUIModuleEnvironment->stateMachineData();
-		std::string sBaseImageName = baseImage.evaluateStringValue(pStateMachineData.get());
+
+		std::string sBaseImageResourceUUID = resolveImageResourceUUID(pUIModuleEnvironment, baseImage, pStateMachineData);
+		if (sBaseImageResourceUUID.empty())
+			sBaseImageResourceUUID = AMCCommon::CUtils::createEmptyUUID();
 		CUIExpression baseImageUUIDExpr;
-		if (!sBaseImageName.empty()) {
-			auto pResourceEntry = pUIModuleEnvironment->resourcePackage()->findEntryByName(sBaseImageName, true);
-			baseImageUUIDExpr.setFixedValue(pResourceEntry->getUUID());
-		} else {
-			baseImageUUIDExpr.setFixedValue(AMCCommon::CUtils::createEmptyUUID());
-		}
+		baseImageUUIDExpr.setFixedValue(sBaseImageResourceUUID);
 		registerStringAttribute(AMC_API_KEY_UI_BASEIMAGERESOURCE, baseImageUUIDExpr);
-	}
-	{
-		auto pStateMachineData = pUIModuleEnvironment->stateMachineData();
-		std::string sDarkBaseImageName = darkBaseImage.evaluateStringValue(pStateMachineData.get());
+
+		// An empty value (not the null UUID) means "no dark image", the client falls back to the light one.
 		CUIExpression darkBaseImageUUIDExpr;
-		if (!sDarkBaseImageName.empty()) {
-			auto pResourceEntry = pUIModuleEnvironment->resourcePackage()->findEntryByName(sDarkBaseImageName, true);
-			darkBaseImageUUIDExpr.setFixedValue(pResourceEntry->getUUID());
-		} else {
-			darkBaseImageUUIDExpr.setFixedValue("");
-		}
+		darkBaseImageUUIDExpr.setFixedValue(resolveImageResourceUUID(pUIModuleEnvironment, darkBaseImage, pStateMachineData));
 		registerStringAttribute("dark_baseimageresource", darkBaseImageUUIDExpr);
 	}
 	registerBoolAttribute(AMC_API_KEY_UI_LABELVISIBLE, labelVisible);
diff --git a/Implementation/UI/amc_ui_page.cpp b/Implementation/UI/amc_ui_page.cpp
index 12c5ffdb7..6d78ef345 100644
--- a/Implementation/UI/amc_ui_page.cpp
+++ b/Implementation/UI/amc_ui_page.cpp
@@ -188,6 +188,8 @@ void CUIPage::frontendWritePageStatusToJSON(CJSONWriter& writer, CJSONWriterObje
 
 	pageObject.addString("name", m_sName);
 	pageObject.addString("uuid", AMCCommon::CUtils::normalizeUUIDString(m_sUUID));
+	if (!m_sShowEvent.empty())
+		pageObject.addString(AMC_API_KEY_UI_PAGESHOWEVENT, m_sShowEvent);
 
 	if (!m_Caption.isEmpty (pStateMachineData, pFrontendState))
 		pageObject.addString("caption", m_Caption.evaluateStringValue (pStateMachineData, pFrontendState));
diff --git a/Implementation/UnitTest/amc_unittests.cpp b/Implementation/UnitTest/amc_unittests.cpp
index aa28006e0..19662d51b 100644
--- a/Implementation/UnitTest/amc_unittests.cpp
+++ b/Implementation/UnitTest/amc_unittests.cpp
@@ -44,6 +44,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "amc_unittests_signalslot.hpp"
 #include "amc_unittests_chrono.hpp"
 #include "amc_unittests_statejournal.hpp"
+#include "amc_unittests_streamdownload.hpp"
 #include "amc_unittests_common_utils.hpp"
 #include "amc_unittests_resourcepackage.hpp"
 #include "amc_unittests_jpeg.hpp"
@@ -51,6 +52,12 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "amc_unittests_alerts.hpp"
 #include "amc_unittests_dataseries.hpp"
 #include "amc_unittests_discretefielddata2d.hpp"
+#include "amc_unittests_datatable.hpp"
+#include "amc_unittests_datatableformat.hpp"
+#include "amc_unittests_datatableencoding.hpp"
+#include "amc_unittests_datacapture.hpp"
+#include "amc_unittests_datatablereader.hpp"
+#include "amc_unittests_datacapturequery.hpp"
 #include "amc_unittests_jsonwriter.hpp"
 #include "amc_unittests_geometryutils.hpp"
 #include "amc_unittests_logger.hpp"
@@ -64,6 +71,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "amc_unittests_scanlab_jumpfilter.hpp"
 #include "amc_unittests_scanlab_powerramp.hpp"
 #include "amc_unittests_parquetwriter.hpp"
+#include "amc_unittests_uifrontend.hpp"
 
 // LibMCData unit tests
 #include "amc_unittests_libmcdata_storage.hpp"
@@ -80,6 +88,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "amc_unittests_libmcdata_installationinfo.hpp"
 #include "amc_unittests_libmcdata_machineconfig.hpp"
 #include "amc_unittests_libmcdata_customdata.hpp"
+#include "amc_unittests_libmcdata_datacapture.hpp"
 
 
 using namespace AMCUnitTest;
@@ -102,6 +111,7 @@ CUnitTests::CUnitTests (PUnitTestIO pIO)
 	registerTestGroup(std::make_shared <CUnitTestGroup_SignalSlot>());
 	registerTestGroup(std::make_shared <CUnitTestGroup_Chrono>());
 	registerTestGroup(std::make_shared <CUnitTestGroup_StateJournal>());
+	registerTestGroup(std::make_shared <CUnitTestGroup_StreamDownload>());
 	registerTestGroup(std::make_shared <CUnitTestGroup_CommonUtils>());
 	registerTestGroup(std::make_shared <CUnitTestGroup_ResourcePackage>());
 	registerTestGroup(std::make_shared <CUnitTestGroup_JPEG>());
@@ -109,6 +119,12 @@ CUnitTests::CUnitTests (PUnitTestIO pIO)
 	registerTestGroup(std::make_shared <CUnitTestGroup_Alerts>());
 	registerTestGroup(std::make_shared <CUnitTestGroup_DataSeries>());
 	registerTestGroup(std::make_shared <CUnitTestGroup_DiscreteFieldData2D>());
+	registerTestGroup(std::make_shared <CUnitTestGroup_DataTable>());
+	registerTestGroup(std::make_shared <CUnitTestGroup_DataTableFormatV2>());
+	registerTestGroup(std::make_shared <CUnitTestGroup_DataTableEncoding>());
+	registerTestGroup(std::make_shared <CUnitTestGroup_DataCapture>());
+	registerTestGroup(std::make_shared <CUnitTestGroup_DataTableReader>());
+	registerTestGroup(std::make_shared <CUnitTestGroup_DataCaptureQuery>());
 	registerTestGroup(std::make_shared <CUnitTestGroup_JSONWriter>());
 	registerTestGroup(std::make_shared <CUnitTestGroup_GeometryUtils>());
 	registerTestGroup(std::make_shared <CUnitTestGroup_Logger>());
@@ -122,6 +138,7 @@ CUnitTests::CUnitTests (PUnitTestIO pIO)
 	registerTestGroup(std::make_shared <CUnitTestGroup_ScanLab_JumpFilter>());
 	registerTestGroup(std::make_shared <CUnitTestGroup_ScanLab_PowerRamp>());
 	registerTestGroup(std::make_shared <CUnitTestGroup_ParquetWriter>());
+	registerTestGroup(std::make_shared <CUnitTestGroup_UIFrontend>());
 
 	// LibMCData unit tests
 	registerTestGroup(std::make_shared <CUnitTestGroup_LibMCData_Storage>());
@@ -138,4 +155,5 @@ CUnitTests::CUnitTests (PUnitTestIO pIO)
 	registerTestGroup(std::make_shared <CUnitTestGroup_LibMCData_InstallationInfo>());
 	registerTestGroup(std::make_shared <CUnitTestGroup_LibMCData_MachineConfig>());
 	registerTestGroup(std::make_shared <CUnitTestGroup_LibMCData_CustomData>());
+	registerTestGroup(std::make_shared <CUnitTestGroup_LibMCData_DataCapture>());
 }
diff --git a/Implementation/UnitTest/amc_unittests_datacapture.hpp b/Implementation/UnitTest/amc_unittests_datacapture.hpp
new file mode 100644
index 000000000..411b3963e
--- /dev/null
+++ b/Implementation/UnitTest/amc_unittests_datacapture.hpp
@@ -0,0 +1,1158 @@
+/*++
+
+Copyright (C) 2020 Autodesk Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Autodesk Inc. nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL AUTODESK INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef __AMCTEST_UNITTEST_DATACAPTURE
+#define __AMCTEST_UNITTEST_DATACAPTURE
+
+#include "amc_unittests.hpp"
+#include "amc_unittests_libmcdata.hpp"
+#include "amc_constants.hpp"
+#include "amc_datatableformat.hpp"
+#include "amc_meshhandler.hpp"
+#include "amc_statejournal.hpp"
+#include "amc_statejournalstream.hpp"
+#include "amc_toolpathhandler.hpp"
+#include "common_chrono.hpp"
+#include "common_utils.hpp"
+
+#include "libmcenv_buildexecution.hpp"
+#include "libmcenv_datacapture.hpp"
+#include "libmcenv_datacaptureoptions.hpp"
+#include "libmcenv_datatable.hpp"
+#include "libmcenv_tempstreamwriter.hpp"
+#include "libmcenv_streamreader.hpp"
+#include "libmcenv_interfaceexception.hpp"
+
+#include <chrono>
+#include <cstdint>
+#include <filesystem>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace AMCUnitTest {
+
+	class CUnitTestGroup_DataCapture : public CUnitTestGroup {
+	public:
+
+		std::string getTestGroupName() override {
+			return "DataCapture";
+		}
+
+		void registerTests() override {
+			registerTest("OptionsDefaultsAndValidation", "Capture options have sane defaults and reject invalid values", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataCapture::testOptionsDefaultsAndValidation, this));
+			registerTest("CreateValidation", "Creating a capture in a build execution is validated", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataCapture::testCreateValidation, this));
+			registerTest("RoundTripAllTypes", "A chunk of all column types is captured and loaded back", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataCapture::testRoundTripAllTypes, this));
+			registerTest("ChunkBoundaries", "Full chunks, a partial final chunk and an empty chunk", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataCapture::testChunkBoundaries, this));
+			registerTest("EmptyCapture", "Captures without rows and without columns", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataCapture::testEmptyCapture, this));
+			registerTest("SegmentRollover", "Rollover exactly on and on either side of a chunk boundary", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataCapture::testSegmentRollover, this));
+			registerTest("RowWiseAPI", "Row-wise convenience path for low-rate producers", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataCapture::testRowWiseAPI, this));
+			registerTest("ChunkValidation", "Inconsistent chunks and calls in the wrong state are rejected", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataCapture::testChunkValidation, this));
+			registerTest("AbortDeletesEverything", "Abort deletes finalized, pending and open segments", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataCapture::testAbortDeletesEverything, this));
+			registerTest("BackpressureBlock", "Block mode bounds the queue and loses nothing", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataCapture::testBackpressureBlock, this));
+			registerTest("BackpressureDropOldest", "DropOldest mode discards queued chunks and counts the rows", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataCapture::testBackpressureDropOldest, this));
+			registerTest("BackpressureFail", "Fail mode raises an error when the queue is full", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataCapture::testBackpressureFail, this));
+			registerTest("RetentionPurgesOldest", "The storage limit deletes the oldest segments while recording", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataCapture::testRetentionPurgesOldest, this));
+			registerTest("CountersAndFlush", "Counters follow the capture and Flush drains the queue", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataCapture::testCountersAndFlush, this));
+			registerTest("AbandonedCaptureIsFinished", "A capture that is released without Finish keeps its data", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataCapture::testAbandonedCaptureIsFinished, this));
+			registerTest("TruncatedSegment", "An interrupted segment is reported cleanly on load", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataCapture::testTruncatedSegment, this));
+			registerTest("AppendDataTable", "A capture takes its schema and its rows from data tables", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataCapture::testAppendDataTable, this));
+		}
+
+		void initializeTests() override {
+		}
+
+	protected:
+
+		typedef std::unique_ptr<LibMCEnv::Impl::IDataCaptureOptions> UOptions;
+		typedef std::unique_ptr<LibMCEnv::Impl::IDataCapture> UCapture;
+		typedef std::unique_ptr<LibMCEnv::Impl::IDataCaptureChunk> UChunk;
+		typedef std::unique_ptr<LibMCEnv::Impl::IDataTable> UTable;
+
+		struct SFixture {
+			LibMCData::PWrapper m_pDataWrapper;
+			LibMCData::PDataModel m_pDataModel;
+			LibMCData::PBuildJobHandler m_pBuildJobHandler;
+			LibMCData::PStorage m_pStorage;
+			LibMCData::PLoginHandler m_pLoginHandler;
+			LibMCData::PJournalSession m_pJournalSession;
+			LibMCData::PBuildJobExecution m_pExecution;
+			AMCCommon::PChrono m_pChrono;
+			AMC::PToolpathHandler m_pToolpathHandler;
+			AMC::PMeshHandler m_pMeshHandler;
+			AMC::PStateJournalStream m_pStateJournalStream;
+			AMC::PStateJournal m_pStateJournal;
+			std::shared_ptr<LibMCEnv::Impl::CBuildExecution> m_pBuildExecution;
+			std::string m_sBasePath;
+			std::string m_sUserUUID;
+		};
+
+		uint64_t getCurrentTimestamp()
+		{
+			return static_cast<uint64_t>(std::chrono::duration_cast<std::chrono::microseconds>(
+				std::chrono::system_clock::now().time_since_epoch()).count());
+		}
+
+		SFixture createFixture(const std::string& sSuffix)
+		{
+			SFixture fixture;
+
+			std::string sRootPath = "temp";
+			if (!AMCCommon::CUtils::fileOrPathExistsOnDisk(sRootPath))
+				AMCCommon::CUtils::createDirectoryOnDisk(sRootPath);
+
+			fixture.m_sBasePath = sRootPath + "/datacapture_" + sSuffix + "_" + AMCCommon::CUtils::createUUID();
+			if (!AMCCommon::CUtils::fileOrPathExistsOnDisk(fixture.m_sBasePath))
+				AMCCommon::CUtils::createDirectoryOnDisk(fixture.m_sBasePath);
+
+			std::string sDatabaseFile = fixture.m_sBasePath + "/datacapture.db";
+
+			fixture.m_pDataWrapper = AMCUnitTest::loadLibMCDataInProcess();
+			fixture.m_pDataModel = fixture.m_pDataWrapper->CreateDataModelInstance();
+			fixture.m_pDataModel->InitialiseDatabase(fixture.m_sBasePath, LibMCData::eDataBaseType::SqLite, sDatabaseFile);
+			fixture.m_pBuildJobHandler = fixture.m_pDataModel->CreateBuildJobHandler();
+			fixture.m_pStorage = fixture.m_pDataModel->CreateStorage();
+			fixture.m_pLoginHandler = fixture.m_pDataModel->CreateLoginHandler();
+			fixture.m_pJournalSession = fixture.m_pDataModel->CreateJournalSession();
+
+			std::string sSalt = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
+			std::string sHash = "fedcba9876543210fedcba9876543210fedcba9876543210fedcba9876543210";
+			fixture.m_sUserUUID = fixture.m_pLoginHandler->CreateUser("testuser", "operator", sSalt, sHash, "Test User");
+
+			// A validated job with a running execution
+			std::string sContent = "job content";
+			std::vector<uint8_t> buffer(sContent.begin(), sContent.end());
+			std::string sStreamUUID = AMCCommon::CUtils::createUUID();
+			fixture.m_pStorage->StoreNewStream(sStreamUUID, "job.bin", "application/octet-stream", buffer, fixture.m_sUserUUID, getCurrentTimestamp());
+
+			auto pJob = fixture.m_pBuildJobHandler->CreateJob(AMCCommon::CUtils::createUUID(), "Capture Job", fixture.m_sUserUUID, sStreamUUID, getCurrentTimestamp());
+			pJob->StartValidating();
+			pJob->FinishValidating(10);
+			fixture.m_pExecution = pJob->CreateBuildJobExecution("Execution", fixture.m_sUserUUID, getCurrentTimestamp());
+
+			fixture.m_pChrono = std::make_shared<AMCCommon::CChrono>();
+			fixture.m_pToolpathHandler = std::make_shared<AMC::CToolpathHandler>(fixture.m_pDataModel);
+			fixture.m_pMeshHandler = std::make_shared<AMC::CMeshHandler>();
+			fixture.m_pStateJournalStream = std::make_shared<AMC::CStateJournalStream>(fixture.m_pJournalSession, nullptr, false);
+			fixture.m_pStateJournal = std::make_shared<AMC::CStateJournal>(fixture.m_pStateJournalStream, fixture.m_pChrono);
+
+			fixture.m_pBuildExecution = std::make_shared<LibMCEnv::Impl::CBuildExecution>(fixture.m_pExecution, fixture.m_pDataModel, fixture.m_pToolpathHandler, fixture.m_pMeshHandler, fixture.m_pChrono, fixture.m_pStateJournal);
+
+			return fixture;
+		}
+
+		UOptions createOptions(SFixture& fixture, uint32_t nChunkRowCount, uint64_t nSegmentSizeInBytes, uint32_t nMaxQueuedChunks = DATACAPTURE_DEFAULTMAXQUEUEDCHUNKS, LibMCEnv::eDataCaptureBackpressureMode eMode = LibMCEnv::eDataCaptureBackpressureMode::Block, uint64_t nStorageLimitInBytes = 0)
+		{
+			UOptions pOptions(fixture.m_pBuildExecution->CreateDataCaptureOptions());
+			pOptions->SetChunkRowCount(nChunkRowCount);
+			pOptions->SetSegmentSizeInBytes(nSegmentSizeInBytes);
+			pOptions->SetMaxQueuedChunks(nMaxQueuedChunks);
+			pOptions->SetBackpressureMode(eMode);
+			pOptions->SetStorageLimitInBytes(nStorageLimitInBytes);
+
+			// The tests of the capture structure work on uncompressed pages.
+			pOptions->SetCompression(LibMCEnv::eDataCaptureCompression::None);
+			return pOptions;
+		}
+
+		// Options for the counter capture: its column stays plain, so that the size of a segment is known exactly.
+		UOptions createCounterOptions(SFixture& fixture, uint32_t nChunkRowCount, uint64_t nSegmentSizeInBytes, uint32_t nMaxQueuedChunks = DATACAPTURE_DEFAULTMAXQUEUEDCHUNKS, LibMCEnv::eDataCaptureBackpressureMode eMode = LibMCEnv::eDataCaptureBackpressureMode::Block, uint64_t nStorageLimitInBytes = 0)
+		{
+			auto pOptions = createOptions(fixture, nChunkRowCount, nSegmentSizeInBytes, nMaxQueuedChunks, eMode, nStorageLimitInBytes);
+			pOptions->SetColumnEncoding("n", LibMCEnv::eDataCaptureEncoding::Plain);
+			return pOptions;
+		}
+
+		UCapture createCapture(SFixture& fixture, const std::string& sIdentifier, LibMCEnv::Impl::IDataCaptureOptions* pOptions)
+		{
+			return UCapture(fixture.m_pBuildExecution->CreateDataCapture(sIdentifier, "Capture " + sIdentifier, pOptions, fixture.m_sUserUUID));
+		}
+
+		// The counter capture has a single uint64 column that counts the rows of the capture.
+		void addCounterColumn(LibMCEnv::Impl::IDataCapture* pCapture)
+		{
+			pCapture->AddColumn("n", "Counter", LibMCEnv::eDataTableColumnType::Uint64Column);
+		}
+
+		void commitCounterChunk(LibMCEnv::Impl::IDataCapture* pCapture, uint64_t& nCounter, uint32_t nRowCount)
+		{
+			std::vector<uint64_t> values(nRowCount);
+			for (uint32_t nIndex = 0; nIndex < nRowCount; nIndex++)
+				values[nIndex] = nCounter + nIndex;
+
+			UChunk pChunk(pCapture->BeginChunk());
+			pChunk->SetUint64ColumnValues(0, values.size(), values.data());
+			pCapture->CommitChunk(pChunk.get());
+
+			nCounter += nRowCount;
+		}
+
+		// Size of a segment of the counter capture that holds nChunkCount chunks of nRowCount rows.
+		uint64_t counterSegmentSize(uint32_t nChunkCount, uint32_t nRowCount)
+		{
+			std::vector<AMC::sDataTableV2Column> columns;
+			columns.push_back({ "n", "Counter", AMC::eDataTableV2DataType::Uint64 });
+			AMC::CDataTableV2SegmentBuilder sizer(columns, 0, 0, nRowCount);
+
+			return sizeof(AMC::sDataTableV2SegmentHeader) + (uint64_t)nChunkCount * sizer.getChunkSizeInBytes(nRowCount) + sizer.getFooterSizeInBytes(nChunkCount);
+		}
+
+		std::vector<uint64_t> loadCounterSegment(SFixture& fixture, const std::string& sIdentifier, uint32_t nSegmentIndex)
+		{
+			UTable pTable(fixture.m_pBuildExecution->LoadDataCaptureSegment(sIdentifier, nSegmentIndex));
+
+			std::vector<uint64_t> values((size_t)pTable->GetRowCount64());
+			if (!values.empty())
+				pTable->GetUint64ColumnValues("n", values.size(), nullptr, values.data());
+
+			return values;
+		}
+
+		size_t countStreamFiles(SFixture& fixture)
+		{
+			size_t nCount = 0;
+			for (auto& entry : std::filesystem::directory_iterator(fixture.m_sBasePath)) {
+				if (entry.path().extension() == ".stream")
+					nCount++;
+			}
+			return nCount;
+		}
+
+		template <typename F>
+		int32_t errorCodeOf(F&& fn)
+		{
+			try {
+				fn();
+			}
+			catch (ELibMCEnvInterfaceException& envException) {
+				return envException.getErrorCode();
+			}
+			return 0;
+		}
+
+		template <typename F>
+		int32_t dataErrorCodeOf(F&& fn)
+		{
+			try {
+				fn();
+			}
+			catch (LibMCData::ELibMCDataException& dataException) {
+				return dataException.getErrorCode();
+			}
+			return 0;
+		}
+
+		void testOptionsDefaultsAndValidation()
+		{
+			auto fixture = createFixture("options");
+			UOptions pOptions(fixture.m_pBuildExecution->CreateDataCaptureOptions());
+
+			assertTrue(pOptions->GetChunkRowCount() == 65536, "default chunk row count");
+			assertTrue(pOptions->GetSegmentSizeInBytes() == 1024ULL * 1024ULL * 1024ULL, "default segment size is 1 GB");
+			assertTrue(pOptions->GetMaxQueuedChunks() == 16, "default queue depth");
+			assertTrue(pOptions->GetBackpressureMode() == LibMCEnv::eDataCaptureBackpressureMode::Block, "default backpressure mode is Block");
+			assertTrue(pOptions->GetStorageLimitInBytes() == 0, "retention is disabled by default");
+			assertTrue(pOptions->GetCompression() == LibMCEnv::eDataCaptureCompression::LZ4, "default compression is LZ4");
+
+			pOptions->SetChunkRowCount(1000);
+			pOptions->SetSegmentSizeInBytes(0);
+			pOptions->SetMaxQueuedChunks(4);
+			pOptions->SetBackpressureMode(LibMCEnv::eDataCaptureBackpressureMode::DropOldest);
+			pOptions->SetStorageLimitInBytes(123456);
+			assertTrue(pOptions->GetChunkRowCount() == 1000, "chunk row count is stored");
+			assertTrue(pOptions->GetSegmentSizeInBytes() == 0, "segment size 0 disables the rollover");
+			assertTrue(pOptions->GetMaxQueuedChunks() == 4, "queue depth is stored");
+			assertTrue(pOptions->GetBackpressureMode() == LibMCEnv::eDataCaptureBackpressureMode::DropOldest, "backpressure mode is stored");
+			assertTrue(pOptions->GetStorageLimitInBytes() == 123456, "storage limit is stored");
+
+			assertTrue(errorCodeOf([&]() { pOptions->SetChunkRowCount(0); }) == LIBMCENV_ERROR_INVALIDDATACAPTUREOPTION, "zero chunk row count is rejected");
+			assertTrue(errorCodeOf([&]() { pOptions->SetChunkRowCount(DATACAPTURE_MAXCHUNKROWCOUNT + 1); }) == LIBMCENV_ERROR_INVALIDDATACAPTUREOPTION, "too large chunk row count is rejected");
+			assertTrue(errorCodeOf([&]() { pOptions->SetSegmentSizeInBytes(10); }) == LIBMCENV_ERROR_INVALIDDATACAPTUREOPTION, "tiny segment size is rejected");
+			assertTrue(errorCodeOf([&]() { pOptions->SetMaxQueuedChunks(0); }) == LIBMCENV_ERROR_INVALIDDATACAPTUREOPTION, "zero queue depth is rejected");
+			assertTrue(errorCodeOf([&]() { pOptions->SetMaxQueuedChunks(DATACAPTURE_MAXMAXQUEUEDCHUNKS + 1); }) == LIBMCENV_ERROR_INVALIDDATACAPTUREOPTION, "too large queue depth is rejected");
+			assertTrue(errorCodeOf([&]() { pOptions->SetBackpressureMode(LibMCEnv::eDataCaptureBackpressureMode::Unknown); }) == LIBMCENV_ERROR_INVALIDDATACAPTUREOPTION, "unknown backpressure mode is rejected");
+			assertTrue(pOptions->GetChunkRowCount() == 1000, "rejected values do not change the options");
+		}
+
+		void testCreateValidation()
+		{
+			auto fixture = createFixture("create");
+
+			assertTrue(errorCodeOf([&]() { UCapture pCapture(fixture.m_pBuildExecution->CreateDataCapture("", "Name", nullptr, "")); }) == LIBMCENV_ERROR_EMPTYDATACAPTUREIDENTIFIER, "empty identifier is rejected");
+			assertTrue(errorCodeOf([&]() { UCapture pCapture(fixture.m_pBuildExecution->CreateDataCapture("trace", "", nullptr, "")); }) == LIBMCENV_ERROR_EMPTYDATACAPTURENAME, "empty name is rejected");
+			assertTrue(errorCodeOf([&]() { UCapture pCapture(fixture.m_pBuildExecution->CreateDataCapture("bad id!", "Name", nullptr, "")); }) == LIBMCENV_ERROR_INVALIDDATACAPTUREIDENTIFIER, "invalid identifier is rejected");
+
+			assertFalse(fixture.m_pBuildExecution->HasDataCapture("trace"), "capture does not exist yet");
+
+			// Options are optional and an empty user UUID means no user.
+			UCapture pCapture(fixture.m_pBuildExecution->CreateDataCapture("trace", "Trace", nullptr, ""));
+			assertTrue(pCapture->GetIdentifier() == "trace", "capture identifier");
+			assertTrue(pCapture->GetName() == "Trace", "capture name");
+			assertTrue(pCapture->GetStatus() == LibMCEnv::eDataCaptureStatus::Configuring, "new capture is configuring");
+			assertTrue(fixture.m_pBuildExecution->HasDataCapture("trace"), "capture exists in the execution");
+			assertTrue(fixture.m_pBuildExecution->GetDataCaptureSegmentCount("trace") == 0, "new capture has no segments");
+			assertTrue(fixture.m_pBuildExecution->GetDataCaptureRowCount("trace") == 0, "new capture has no rows");
+
+			assertTrue(dataErrorCodeOf([&]() { UCapture pDuplicate(fixture.m_pBuildExecution->CreateDataCapture("trace", "Duplicate", nullptr, "")); }) == LIBMCDATA_ERROR_DUPLICATEDATACAPTUREIDENTIFIER, "duplicate identifier is rejected");
+			assertTrue(dataErrorCodeOf([&]() { fixture.m_pBuildExecution->GetDataCaptureRowCount("missing"); }) == LIBMCDATA_ERROR_DATACAPTURENOTFOUND, "unknown capture is not found");
+			assertTrue(errorCodeOf([&]() { UTable pTable(fixture.m_pBuildExecution->LoadDataCaptureSegment("trace", 0)); }) == LIBMCENV_ERROR_INVALIDDATACAPTURESEGMENTINDEX, "unknown segment index is rejected");
+
+			pCapture->Abort();
+
+			// A capture lives inside a running execution.
+			fixture.m_pExecution->ChangeStatus(LibMCData::eBuildJobExecutionStatus::Finished, getCurrentTimestamp() + 1000000);
+			assertTrue(errorCodeOf([&]() { UCapture pLate(fixture.m_pBuildExecution->CreateDataCapture("late", "Late", nullptr, "")); }) == LIBMCENV_ERROR_DATACAPTUREEXECUTIONNOTINPROCESS, "capture can not be created in a finished execution");
+		}
+
+		void testRoundTripAllTypes()
+		{
+			auto fixture = createFixture("alltypes");
+			auto pOptions = createOptions(fixture, 16, 0);
+			auto pCapture = createCapture(fixture, "all", pOptions.get());
+
+			pCapture->AddColumn("d", "Double", LibMCEnv::eDataTableColumnType::DoubleColumn);
+			pCapture->AddColumn("i32", "Int32", LibMCEnv::eDataTableColumnType::Int32Column);
+			pCapture->AddColumn("u32", "Uint32", LibMCEnv::eDataTableColumnType::Uint32Column);
+			pCapture->AddColumn("i64", "Int64", LibMCEnv::eDataTableColumnType::Int64Column);
+			pCapture->AddColumn("u64", "Uint64", LibMCEnv::eDataTableColumnType::Uint64Column);
+			pCapture->AddColumn("f", "Float", LibMCEnv::eDataTableColumnType::FloatColumn);
+			pCapture->AddColumn("b", "Bool", LibMCEnv::eDataTableColumnType::BoolColumn);
+			pCapture->AddColumn("t", "Timestamp", LibMCEnv::eDataTableColumnType::TimestampColumn);
+			assertTrue(pCapture->GetColumnCount() == 8, "eight columns");
+
+			std::vector<double> doubles = { 1.5, -2.25, 3.0, 1.0e6 };
+			std::vector<int32_t> int32s = { -1, 2, -3, 4 };
+			std::vector<uint32_t> uint32s = { 1, 2, 3, 4000000000U };
+			std::vector<int64_t> int64s = { -10, 20, -5000000000LL, 40 };
+			std::vector<uint64_t> uint64s = { 10, 20, 30, 18000000000000000000ULL };
+			std::vector<float> floats = { 0.5f, 1.5f, 2.5f, 1800.25f };
+			std::vector<uint8_t> bools = { 1, 0, 7, 0 };
+			std::vector<uint64_t> timestamps = { 1000000ULL, 1000010ULL, 1000020ULL, 1000030ULL };
+
+			{
+				UChunk pChunk(pCapture->BeginChunk());
+				assertTrue(pCapture->GetStatus() == LibMCEnv::eDataCaptureStatus::Recording, "capture records after the first chunk was borrowed");
+				assertTrue(pChunk->GetCapacity() == 16, "chunk capacity follows the options");
+				assertTrue(pChunk->GetRowCount() == 0, "new chunk is empty");
+				assertFalse(pChunk->IsFull(), "new chunk is not full");
+
+				pChunk->SetDoubleColumnValues(0, doubles.size(), doubles.data());
+				pChunk->SetInt32ColumnValues(1, int32s.size(), int32s.data());
+				pChunk->SetUint32ColumnValues(2, uint32s.size(), uint32s.data());
+				pChunk->SetInt64ColumnValues(3, int64s.size(), int64s.data());
+				pChunk->SetUint64ColumnValues(4, uint64s.size(), uint64s.data());
+				pChunk->SetFloatColumnValues(5, floats.size(), floats.data());
+				pChunk->SetBoolColumnValues(6, bools.size(), bools.data());
+				pChunk->SetTimestampColumnValues(7, timestamps.size(), timestamps.data());
+				assertTrue(pChunk->GetRowCount() == 4, "chunk holds four rows");
+
+				pCapture->CommitChunk(pChunk.get());
+			}
+
+			std::string sCaptureUUID = pCapture->Finish();
+			assertTrue(sCaptureUUID == pCapture->GetUUID(), "Finish returns the capture uuid");
+			assertTrue(pCapture->GetStatus() == LibMCEnv::eDataCaptureStatus::Finished, "capture is finished");
+			assertTrue(pCapture->Finish() == sCaptureUUID, "a second Finish is harmless");
+
+			// The manifest holds the schema and the segment.
+			auto pManifest = fixture.m_pExecution->RetrieveDataCapture("all");
+			assertTrue(pManifest->GetUUID() == sCaptureUUID, "manifest uuid");
+			assertTrue(pManifest->GetStatus() == LibMCData::eDataCaptureStatus::Finished, "manifest is finished");
+			assertTrue(pManifest->GetColumnCount() == 8, "manifest schema has eight columns");
+			assertTrue(pManifest->GetSegmentCount() == 1, "one segment");
+			assertTrue(pManifest->GetRowCount() == 4, "four rows");
+
+			std::string sIdentifier;
+			std::string sDescription;
+			uint32_t nColumnType = 0;
+			pManifest->GetColumnInformation(5, sIdentifier, sDescription, nColumnType);
+			assertTrue((sIdentifier == "f") && (sDescription == "Float") && (nColumnType == (uint32_t)LibMCEnv::eDataTableColumnType::FloatColumn), "manifest column information");
+
+			assertTrue(fixture.m_pBuildExecution->GetDataCaptureRowCount("all") == 4, "row count through the build execution");
+			assertTrue(fixture.m_pBuildExecution->GetDataCaptureSegmentCount("all") == 1, "segment count through the build execution");
+
+			// The segment is an ordinary version 2 data table stream.
+			UTable pTable(fixture.m_pBuildExecution->LoadDataCaptureSegment("all", 0));
+			assertTrue(pTable->GetColumnCount() == 8, "loaded column count");
+			assertTrue(pTable->GetRowCount64() == 4, "loaded row count");
+			assertTrue(pTable->GetColumnIdentifier(7) == "t", "loaded column identifier");
+			assertTrue(pTable->GetColumnDescription(7) == "Timestamp", "loaded column description");
+			assertTrue(pTable->GetColumnType(6) == LibMCEnv::eDataTableColumnType::BoolColumn, "loaded column type");
+
+			std::vector<double> doublesOut(4);
+			pTable->GetDoubleColumnValues("d", doublesOut.size(), nullptr, doublesOut.data());
+			assertTrue(doublesOut == doubles, "double column round trip");
+			std::vector<int32_t> int32sOut(4);
+			pTable->GetInt32ColumnValues("i32", int32sOut.size(), nullptr, int32sOut.data());
+			assertTrue(int32sOut == int32s, "int32 column round trip");
+			std::vector<uint32_t> uint32sOut(4);
+			pTable->GetUint32ColumnValues("u32", uint32sOut.size(), nullptr, uint32sOut.data());
+			assertTrue(uint32sOut == uint32s, "uint32 column round trip");
+			std::vector<int64_t> int64sOut(4);
+			pTable->GetInt64ColumnValues("i64", int64sOut.size(), nullptr, int64sOut.data());
+			assertTrue(int64sOut == int64s, "int64 column round trip");
+			std::vector<uint64_t> uint64sOut(4);
+			pTable->GetUint64ColumnValues("u64", uint64sOut.size(), nullptr, uint64sOut.data());
+			assertTrue(uint64sOut == uint64s, "uint64 column round trip");
+			std::vector<float> floatsOut(4);
+			pTable->GetFloatColumnValues("f", floatsOut.size(), nullptr, floatsOut.data());
+			assertTrue(floatsOut == floats, "float column round trip");
+			std::vector<uint8_t> boolsOut(4);
+			pTable->GetBoolColumnValues("b", boolsOut.size(), nullptr, boolsOut.data());
+			assertTrue((boolsOut[0] == 1) && (boolsOut[1] == 0) && (boolsOut[2] == 1) && (boolsOut[3] == 0), "bool column round trip with normalisation");
+			std::vector<uint64_t> timestampsOut(4);
+			pTable->GetTimestampColumnValues("t", timestampsOut.size(), nullptr, timestampsOut.data());
+			assertTrue(timestampsOut == timestamps, "timestamp column round trip");
+		}
+
+		void testChunkBoundaries()
+		{
+			auto fixture = createFixture("boundaries");
+			auto pOptions = createCounterOptions(fixture, 4, 0);
+			auto pCapture = createCapture(fixture, "counter", pOptions.get());
+			addCounterColumn(pCapture.get());
+
+			uint64_t nCounter = 0;
+			commitCounterChunk(pCapture.get(), nCounter, 4);
+			commitCounterChunk(pCapture.get(), nCounter, 4);
+
+			// A chunk without rows is not an error and does not reach the file.
+			{
+				UChunk pEmptyChunk(pCapture->BeginChunk());
+				pCapture->CommitChunk(pEmptyChunk.get());
+			}
+			assertTrue(pCapture->GetCapturedRowCount() == 8, "empty chunk does not count");
+
+			// The final chunk is partial.
+			commitCounterChunk(pCapture.get(), nCounter, 2);
+			assertTrue(pCapture->GetCapturedRowCount() == 10, "captured row count");
+
+			pCapture->Finish();
+
+			auto pManifest = fixture.m_pExecution->RetrieveDataCapture("counter");
+			assertTrue(pManifest->GetSegmentCount() == 1, "no rollover without a segment size");
+			assertTrue(pManifest->GetRowCount() == 10, "ten rows stored");
+
+			auto values = loadCounterSegment(fixture, "counter", 0);
+			assertTrue(values.size() == 10, "ten rows loaded");
+			for (size_t nIndex = 0; nIndex < values.size(); nIndex++)
+				assertTrue(values[nIndex] == nIndex, "row " + std::to_string(nIndex) + " is in order");
+		}
+
+		// A table with the columns of a recording piece: nRowCount rows that continue at nFirstValue.
+		UTable createPieceTable(SFixture& fixture, uint32_t nRowCount, uint32_t nFirstValue, uint32_t nLayerIndex, bool bWithLayerColumn)
+		{
+			UTable pTable(new LibMCEnv::Impl::CDataTable(fixture.m_pToolpathHandler));
+			pTable->AddColumn("timestamp", "Timestamp", LibMCEnv::eDataTableColumnType::DoubleColumn);
+			pTable->AddColumn("x", "Target X", LibMCEnv::eDataTableColumnType::DoubleColumn);
+			pTable->AddColumn("laseron", "LaserOn", LibMCEnv::eDataTableColumnType::Int32Column);
+			pTable->AddColumn("tag", "Tag", LibMCEnv::eDataTableColumnType::Uint32Column);
+
+			std::vector<double> timestamps(nRowCount);
+			std::vector<double> positions(nRowCount);
+			std::vector<int32_t> laserOn(nRowCount);
+			std::vector<uint32_t> tags(nRowCount);
+			for (uint32_t nIndex = 0; nIndex < nRowCount; nIndex++) {
+				uint32_t nValue = nFirstValue + nIndex;
+				timestamps[nIndex] = (double)nValue * 10.0;
+				positions[nIndex] = (double)nValue * 0.125 - 3.0;
+				laserOn[nIndex] = (int32_t)(nValue % 2);
+				tags[nIndex] = 1000 + nValue;
+			}
+
+			if (nRowCount > 0) {
+				pTable->SetDoubleColumnValues("timestamp", timestamps.size(), timestamps.data());
+				pTable->SetDoubleColumnValues("x", positions.size(), positions.data());
+				pTable->SetInt32ColumnValues("laseron", laserOn.size(), laserOn.data());
+				pTable->SetUint32ColumnValues("tag", tags.size(), tags.data());
+			}
+
+			if (bWithLayerColumn) {
+				std::vector<uint32_t> layers(nRowCount, nLayerIndex);
+				pTable->AddColumn("layer", "Layer Index", LibMCEnv::eDataTableColumnType::Uint32Column);
+				if (nRowCount > 0)
+					pTable->SetUint32ColumnValues("layer", layers.size(), layers.data());
+			}
+
+			return pTable;
+		}
+
+		void testAppendDataTable()
+		{
+			auto fixture = createFixture("appendtable");
+			auto pOptions = createOptions(fixture, 4, 0);
+			auto pCapture = createCapture(fixture, "recording", pOptions.get());
+
+			// The schema is a layer column followed by the columns of the first piece.
+			auto pSchemaTable = createPieceTable(fixture, 0, 0, 0, false);
+			pCapture->AddColumn("layer", "Layer Index", LibMCEnv::eDataTableColumnType::Uint32Column);
+			pCapture->AddColumnsFromDataTable(pSchemaTable.get());
+			assertTrue(pCapture->GetColumnCount() == 5, "one capture column per table column");
+
+			assertTrue(errorCodeOf([&]() { pCapture->AddColumnsFromDataTable(pSchemaTable.get()); }) == LIBMCENV_ERROR_DUPLICATECOLUMNIDENTIFIER, "adding the same table twice is rejected");
+			assertTrue(pCapture->GetColumnCount() == 5, "a rejected table leaves the schema untouched");
+			assertTrue(errorCodeOf([&]() { pCapture->AddColumnsFromDataTable(nullptr); }) == LIBMCENV_ERROR_INVALIDCAST, "null table is rejected");
+
+			// A table without the layer column can not be appended.
+			auto pIncompleteTable = createPieceTable(fixture, 3, 0, 0, false);
+			assertTrue(errorCodeOf([&]() { pCapture->AppendDataTable(pIncompleteTable.get()); }) == LIBMCENV_ERROR_DATACAPTURECOLUMNNOTFOUND, "table without a capture column is rejected");
+
+			// Ten rows are split into chunks of four.
+			auto pFirstPiece = createPieceTable(fixture, 10, 0, 7, true);
+			assertTrue(pCapture->AppendDataTable(pFirstPiece.get()) == 10, "ten rows appended");
+			assertTrue(pCapture->GetCapturedRowCount() == 10, "ten rows captured");
+
+			assertTrue(errorCodeOf([&]() { pCapture->AddColumnsFromDataTable(pSchemaTable.get()); }) != 0, "schema is frozen after the first append");
+
+			// A further column of the table is ignored.
+			auto pSecondPiece = createPieceTable(fixture, 3, 10, 8, true);
+			pSecondPiece->AddColumn("extra", "Extra", LibMCEnv::eDataTableColumnType::DoubleColumn);
+			assertTrue(pCapture->AppendDataTable(pSecondPiece.get()) == 3, "three rows appended");
+
+			// An empty table appends nothing.
+			auto pEmptyPiece = createPieceTable(fixture, 0, 13, 9, true);
+			assertTrue(pCapture->AppendDataTable(pEmptyPiece.get()) == 0, "empty table appends no rows");
+
+			// Columns of a different type or length are rejected, and nothing of the table is written.
+			{
+				UTable pWrongType(new LibMCEnv::Impl::CDataTable(fixture.m_pToolpathHandler));
+				pWrongType->AddColumn("layer", "Layer Index", LibMCEnv::eDataTableColumnType::Uint32Column);
+				pWrongType->AddColumn("timestamp", "Timestamp", LibMCEnv::eDataTableColumnType::DoubleColumn);
+				pWrongType->AddColumn("x", "Target X", LibMCEnv::eDataTableColumnType::FloatColumn);
+				pWrongType->AddColumn("laseron", "LaserOn", LibMCEnv::eDataTableColumnType::Int32Column);
+				pWrongType->AddColumn("tag", "Tag", LibMCEnv::eDataTableColumnType::Uint32Column);
+				assertTrue(errorCodeOf([&]() { pCapture->AppendDataTable(pWrongType.get()); }) == LIBMCENV_ERROR_DATACAPTURECOLUMNTYPEMISMATCH, "column of another type is rejected");
+
+				auto pRagged = createPieceTable(fixture, 5, 13, 9, true);
+				std::vector<uint32_t> shortColumn(2, 9);
+				pRagged->SetUint32ColumnValues("tag", shortColumn.size(), shortColumn.data());
+				assertTrue(errorCodeOf([&]() { pCapture->AppendDataTable(pRagged.get()); }) == LIBMCENV_ERROR_DATACAPTURECHUNKINCOMPLETE, "columns of different length are rejected");
+			}
+			assertTrue(pCapture->GetCapturedRowCount() == 13, "rejected tables add no rows");
+
+			pCapture->Finish();
+
+			auto pManifest = fixture.m_pExecution->RetrieveDataCapture("recording");
+			assertTrue(pManifest->GetRowCount() == 13, "thirteen rows stored");
+			assertTrue(pManifest->GetColumnCount() == 5, "five columns stored");
+			assertTrue(pManifest->GetSegmentChunkCount(0) == 4, "ten rows make three chunks, three rows one more");
+
+			UTable pLoaded(fixture.m_pBuildExecution->LoadDataCaptureSegment("recording", 0));
+			assertTrue(pLoaded->GetRowCount64() == 13, "thirteen rows loaded");
+
+			std::vector<uint32_t> layers(13);
+			std::vector<double> timestamps(13);
+			std::vector<double> positions(13);
+			std::vector<int32_t> laserOn(13);
+			std::vector<uint32_t> tags(13);
+			pLoaded->GetUint32ColumnValues("layer", layers.size(), nullptr, layers.data());
+			pLoaded->GetDoubleColumnValues("timestamp", timestamps.size(), nullptr, timestamps.data());
+			pLoaded->GetDoubleColumnValues("x", positions.size(), nullptr, positions.data());
+			pLoaded->GetInt32ColumnValues("laseron", laserOn.size(), nullptr, laserOn.data());
+			pLoaded->GetUint32ColumnValues("tag", tags.size(), nullptr, tags.data());
+
+			for (uint32_t nIndex = 0; nIndex < 13; nIndex++) {
+				std::string sRow = "row " + std::to_string(nIndex);
+				assertTrue(layers[nIndex] == ((nIndex < 10) ? 7u : 8u), sRow + " layer");
+				assertTrue(timestamps[nIndex] == (double)nIndex * 10.0, sRow + " timestamp");
+				assertTrue(positions[nIndex] == (double)nIndex * 0.125 - 3.0, sRow + " position");
+				assertTrue(laserOn[nIndex] == (int32_t)(nIndex % 2), sRow + " laser");
+				assertTrue(tags[nIndex] == 1000 + nIndex, sRow + " tag");
+			}
+		}
+
+		void testEmptyCapture()
+		{
+			auto fixture = createFixture("empty");
+
+			// Columns but no chunk: the schema is still stored.
+			{
+				auto pCapture = createCapture(fixture, "norows", nullptr);
+				pCapture->AddColumn("f", "Float", LibMCEnv::eDataTableColumnType::FloatColumn);
+				pCapture->AddColumn("b", "Bool", LibMCEnv::eDataTableColumnType::BoolColumn);
+				pCapture->Finish();
+
+				assertTrue(pCapture->GetCapturedRowCount() == 0, "no rows captured");
+				assertTrue(pCapture->GetSegmentCount() == 1, "an empty capture has one segment");
+
+				auto pManifest = fixture.m_pExecution->RetrieveDataCapture("norows");
+				assertTrue(pManifest->GetStatus() == LibMCData::eDataCaptureStatus::Finished, "empty capture is finished");
+				assertTrue(pManifest->GetSegmentCount() == 1, "one segment registered");
+				assertTrue(pManifest->GetRowCount() == 0, "no rows registered");
+				assertTrue(pManifest->GetColumnCount() == 2, "schema registered");
+
+				UTable pTable(fixture.m_pBuildExecution->LoadDataCaptureSegment("norows", 0));
+				assertTrue(pTable->GetColumnCount() == 2, "empty segment keeps its columns");
+				assertTrue(pTable->GetRowCount64() == 0, "empty segment has no rows");
+				assertTrue(pTable->GetColumnType(0) == LibMCEnv::eDataTableColumnType::FloatColumn, "float column type survives");
+				assertTrue(pTable->GetColumnType(1) == LibMCEnv::eDataTableColumnType::BoolColumn, "bool column type survives");
+			}
+
+			// No columns at all.
+			{
+				auto pCapture = createCapture(fixture, "nocolumns", nullptr);
+				pCapture->Finish();
+
+				UTable pTable(fixture.m_pBuildExecution->LoadDataCaptureSegment("nocolumns", 0));
+				assertTrue(pTable->GetColumnCount() == 0, "capture without columns loads as an empty table");
+				assertTrue(pTable->GetRowCount64() == 0, "capture without columns has no rows");
+			}
+		}
+
+		struct SSegmentInfo {
+			std::string m_sStreamUUID;
+			uint64_t m_nFirstRow;
+			uint64_t m_nRowCount;
+			uint64_t m_nSizeInBytes;
+			bool m_bIsPurged;
+		};
+
+		std::vector<SSegmentInfo> listSegments(SFixture& fixture, const std::string& sIdentifier)
+		{
+			std::vector<SSegmentInfo> segments;
+			auto pManifest = fixture.m_pExecution->RetrieveDataCapture(sIdentifier);
+			uint32_t nSegmentCount = pManifest->GetSegmentCount();
+			for (uint32_t nIndex = 0; nIndex < nSegmentCount; nIndex++) {
+				SSegmentInfo info;
+				pManifest->GetSegmentInformation(nIndex, info.m_sStreamUUID, info.m_nFirstRow, info.m_nRowCount, info.m_nSizeInBytes, info.m_bIsPurged);
+				segments.push_back(info);
+			}
+			return segments;
+		}
+
+		// Captures nChunkCount chunks of 100 rows with the given segment size and returns the segments.
+		std::vector<SSegmentInfo> runRollover(SFixture& fixture, const std::string& sIdentifier, uint64_t nSegmentSize, uint32_t nChunkCount)
+		{
+			auto pOptions = createCounterOptions(fixture, 100, nSegmentSize);
+			auto pCapture = createCapture(fixture, sIdentifier, pOptions.get());
+			addCounterColumn(pCapture.get());
+
+			uint64_t nCounter = 0;
+			for (uint32_t nIndex = 0; nIndex < nChunkCount; nIndex++)
+				commitCounterChunk(pCapture.get(), nCounter, 100);
+
+			pCapture->Finish();
+			assertTrue(pCapture->GetCapturedRowCount() == (uint64_t)nChunkCount * 100, "all rows are captured");
+
+			auto segments = listSegments(fixture, sIdentifier);
+			assertTrue(pCapture->GetSegmentCount() == segments.size(), "segment count of the capture matches the manifest");
+
+			// The segments are contiguous, within the size limit, and the rows are in order.
+			uint64_t nExpectedFirstRow = 0;
+			for (uint32_t nSegmentIndex = 0; nSegmentIndex < segments.size(); nSegmentIndex++) {
+				auto& segment = segments[nSegmentIndex];
+				assertTrue(segment.m_nFirstRow == nExpectedFirstRow, "segment " + std::to_string(nSegmentIndex) + " continues the row numbering");
+				assertTrue(segment.m_nSizeInBytes <= nSegmentSize, "segment " + std::to_string(nSegmentIndex) + " is within the size limit");
+				assertTrue(fixture.m_pStorage->RetrieveStream(segment.m_sStreamUUID)->GetSize() == segment.m_nSizeInBytes, "manifest size is the stream size");
+				assertTrue(fixture.m_pStorage->StreamIsReady(segment.m_sStreamUUID), "segment stream is finished");
+
+				auto values = loadCounterSegment(fixture, sIdentifier, nSegmentIndex);
+				assertTrue(values.size() == segment.m_nRowCount, "loaded row count matches the manifest");
+				for (size_t nRowIndex = 0; nRowIndex < values.size(); nRowIndex++)
+					assertTrue(values[nRowIndex] == nExpectedFirstRow + nRowIndex, "segment " + std::to_string(nSegmentIndex) + " row " + std::to_string(nRowIndex) + " is in order");
+
+				nExpectedFirstRow += segment.m_nRowCount;
+			}
+			assertTrue(nExpectedFirstRow == (uint64_t)nChunkCount * 100, "segments hold all rows");
+
+			return segments;
+		}
+
+		void testSegmentRollover()
+		{
+			auto fixture = createFixture("rollover");
+
+			// A segment of three chunks is exactly this large.
+			uint64_t nThreeChunkSize = counterSegmentSize(3, 100);
+
+			// Exactly on the boundary: three chunks fit, the fourth rolls over.
+			auto exact = runRollover(fixture, "exact", nThreeChunkSize, 7);
+			assertTrue(exact.size() == 3, "seven chunks make three segments on the boundary");
+			assertTrue((exact[0].m_nRowCount == 300) && (exact[1].m_nRowCount == 300) && (exact[2].m_nRowCount == 100), "three, three and one chunk");
+			assertTrue(exact[0].m_nSizeInBytes == nThreeChunkSize, "a full segment has exactly the predicted size");
+
+			// One byte below: only two chunks fit.
+			auto below = runRollover(fixture, "below", nThreeChunkSize - 1, 7);
+			assertTrue(below.size() == 4, "seven chunks make four segments below the boundary");
+			assertTrue((below[0].m_nRowCount == 200) && (below[3].m_nRowCount == 100), "two chunks per segment");
+
+			// One byte above: still three chunks.
+			auto above = runRollover(fixture, "above", nThreeChunkSize + 1, 7);
+			assertTrue(above.size() == 3, "seven chunks make three segments above the boundary");
+			assertTrue(above[0].m_nRowCount == 300, "three chunks per segment");
+
+			// A segment always holds at least one chunk, even if the chunk alone exceeds the limit.
+			{
+				auto pOptions = createCounterOptions(fixture, 100, DATACAPTURE_MINSEGMENTSIZE);
+				auto pCapture = createCapture(fixture, "tiny", pOptions.get());
+				addCounterColumn(pCapture.get());
+				uint64_t nCounter = 0;
+				for (uint32_t nIndex = 0; nIndex < 3; nIndex++)
+					commitCounterChunk(pCapture.get(), nCounter, 100);
+				pCapture->Finish();
+
+				auto tiny = listSegments(fixture, "tiny");
+				assertTrue(tiny.size() == 3, "one chunk per segment");
+				assertTrue(tiny[0].m_nSizeInBytes == counterSegmentSize(1, 100), "segment of one chunk");
+				assertTrue(tiny[0].m_nSizeInBytes > DATACAPTURE_MINSEGMENTSIZE, "a single chunk may exceed the segment size");
+			}
+		}
+
+		void testRowWiseAPI()
+		{
+			auto fixture = createFixture("rows");
+			auto pOptions = createOptions(fixture, 4, 0);
+			auto pCapture = createCapture(fixture, "rows", pOptions.get());
+			pCapture->AddColumn("t", "Time", LibMCEnv::eDataTableColumnType::TimestampColumn);
+			pCapture->AddColumn("f", "Float", LibMCEnv::eDataTableColumnType::FloatColumn);
+			pCapture->AddColumn("i", "Int32", LibMCEnv::eDataTableColumnType::Int32Column);
+			pCapture->AddColumn("b", "Bool", LibMCEnv::eDataTableColumnType::BoolColumn);
+			pCapture->AddColumn("d", "Double", LibMCEnv::eDataTableColumnType::DoubleColumn);
+			pCapture->AddColumn("u", "Uint32", LibMCEnv::eDataTableColumnType::Uint32Column);
+
+			UChunk pChunk(pCapture->BeginChunk());
+
+			assertTrue(errorCodeOf([&]() { pChunk->SetRowDoubleValue(1, 1.0); }) == LIBMCENV_ERROR_DATACAPTUREROWNOTOPEN, "value without an open row is rejected");
+			assertTrue(errorCodeOf([&]() { pChunk->EndRow(); }) == LIBMCENV_ERROR_DATACAPTUREROWNOTOPEN, "EndRow without an open row is rejected");
+
+			pChunk->BeginRow();
+			assertTrue(errorCodeOf([&]() { pChunk->BeginRow(); }) == LIBMCENV_ERROR_DATACAPTUREROWALREADYOPEN, "second BeginRow is rejected");
+			pChunk->SetRowIntegerValue(0, 1000);
+			pChunk->SetRowDoubleValue(1, 1.5);
+			pChunk->SetRowIntegerValue(2, -7);
+			pChunk->SetRowIntegerValue(3, 5);
+			pChunk->SetRowDoubleValue(4, 2.5);
+			pChunk->SetRowIntegerValue(5, 42);
+
+			assertTrue(errorCodeOf([&]() { pChunk->SetRowDoubleValue(2, 1.0); }) == LIBMCENV_ERROR_DATACAPTURECOLUMNTYPEMISMATCH, "double value on an integer column is rejected");
+			assertTrue(errorCodeOf([&]() { pChunk->SetRowIntegerValue(1, 1); }) == LIBMCENV_ERROR_DATACAPTURECOLUMNTYPEMISMATCH, "integer value on a float column is rejected");
+			assertTrue(errorCodeOf([&]() { pChunk->SetRowIntegerValue(2, 5000000000LL); }) == LIBMCENV_ERROR_DATACAPTUREVALUEOUTOFRANGE, "int32 overflow is rejected");
+			assertTrue(errorCodeOf([&]() { pChunk->SetRowIntegerValue(5, -1); }) == LIBMCENV_ERROR_DATACAPTUREVALUEOUTOFRANGE, "negative uint32 is rejected");
+			assertTrue(errorCodeOf([&]() { pChunk->SetRowIntegerValue(0, -1); }) == LIBMCENV_ERROR_DATACAPTUREVALUEOUTOFRANGE, "negative timestamp is rejected");
+			assertTrue(errorCodeOf([&]() { pChunk->SetRowIntegerValue(9, 1); }) == LIBMCENV_ERROR_INVALIDCOLUMNINDEX, "unknown column index is rejected");
+
+			std::vector<uint64_t> bulk = { 1, 2 };
+			assertTrue(errorCodeOf([&]() { pChunk->SetTimestampColumnValues(0, bulk.size(), bulk.data()); }) == LIBMCENV_ERROR_DATACAPTUREROWALREADYOPEN, "bulk setter while a row is open is rejected");
+			assertTrue(errorCodeOf([&]() { pCapture->CommitChunk(pChunk.get()); }) == LIBMCENV_ERROR_DATACAPTUREROWALREADYOPEN, "commit with an open row is rejected");
+
+			pChunk->EndRow();
+			assertTrue(pChunk->GetRowCount() == 1, "one row after EndRow");
+
+			// Columns that are not set are zero.
+			pChunk->BeginRow();
+			pChunk->SetRowIntegerValue(0, 2000);
+			pChunk->EndRow();
+
+			pChunk->BeginRow();
+			pChunk->SetRowIntegerValue(0, 3000);
+			pChunk->SetRowDoubleValue(1, -0.25);
+			pChunk->SetRowIntegerValue(2, 2147483647);
+			pChunk->SetRowIntegerValue(3, 0);
+			pChunk->SetRowDoubleValue(4, -1.0e9);
+			pChunk->SetRowIntegerValue(5, 4000000000LL);
+			pChunk->EndRow();
+
+			pChunk->BeginRow();
+			pChunk->SetRowIntegerValue(0, 4000);
+			pChunk->EndRow();
+
+			assertTrue(pChunk->GetRowCount() == 4, "four rows");
+			assertTrue(pChunk->IsFull(), "chunk is full");
+			assertTrue(errorCodeOf([&]() { pChunk->BeginRow(); }) == LIBMCENV_ERROR_DATACAPTURECHUNKOVERFLOW, "row beyond the capacity is rejected");
+
+			pCapture->CommitChunk(pChunk.get());
+			pCapture->Finish();
+
+			UTable pTable(fixture.m_pBuildExecution->LoadDataCaptureSegment("rows", 0));
+			assertTrue(pTable->GetRowCount64() == 4, "four rows loaded");
+
+			std::vector<uint64_t> timestamps(4);
+			pTable->GetTimestampColumnValues("t", timestamps.size(), nullptr, timestamps.data());
+			assertTrue((timestamps[0] == 1000) && (timestamps[1] == 2000) && (timestamps[2] == 3000) && (timestamps[3] == 4000), "timestamp rows");
+
+			std::vector<float> floats(4);
+			pTable->GetFloatColumnValues("f", floats.size(), nullptr, floats.data());
+			assertTrue((floats[0] == 1.5f) && (floats[1] == 0.0f) && (floats[2] == -0.25f) && (floats[3] == 0.0f), "float rows with zero for unset values");
+
+			std::vector<int32_t> int32s(4);
+			pTable->GetInt32ColumnValues("i", int32s.size(), nullptr, int32s.data());
+			assertTrue((int32s[0] == -7) && (int32s[1] == 0) && (int32s[2] == 2147483647), "int32 rows");
+
+			std::vector<uint8_t> bools(4);
+			pTable->GetBoolColumnValues("b", bools.size(), nullptr, bools.data());
+			assertTrue((bools[0] == 1) && (bools[1] == 0) && (bools[2] == 0), "bool rows are normalised");
+
+			std::vector<double> doubles(4);
+			pTable->GetDoubleColumnValues("d", doubles.size(), nullptr, doubles.data());
+			assertTrue((doubles[0] == 2.5) && (doubles[1] == 0.0) && (doubles[2] == -1.0e9), "double rows");
+
+			std::vector<uint32_t> uint32s(4);
+			pTable->GetUint32ColumnValues("u", uint32s.size(), nullptr, uint32s.data());
+			assertTrue((uint32s[0] == 42) && (uint32s[2] == 4000000000U), "uint32 rows");
+		}
+
+		void testChunkValidation()
+		{
+			auto fixture = createFixture("validation");
+			auto pOptions = createOptions(fixture, 4, 0);
+			auto pCapture = createCapture(fixture, "checked", pOptions.get());
+
+			assertTrue(errorCodeOf([&]() { pCapture->AddColumn("", "Empty", LibMCEnv::eDataTableColumnType::DoubleColumn); }) == LIBMCENV_ERROR_COLUMNIDENTIFIEREMPTY, "empty column identifier is rejected");
+			assertTrue(errorCodeOf([&]() { pCapture->AddColumn("bad id!", "Invalid", LibMCEnv::eDataTableColumnType::DoubleColumn); }) == LIBMCENV_ERROR_INVALIDCOLUMNIDENTIFIER, "invalid column identifier is rejected");
+			assertTrue(errorCodeOf([&]() { pCapture->AddColumn("x", "Unknown", (LibMCEnv::eDataTableColumnType)99); }) == LIBMCENV_ERROR_INVALIDCOLUMNDATATYPE, "unknown column type is rejected");
+
+			pCapture->AddColumn("n", "Counter", LibMCEnv::eDataTableColumnType::Uint64Column);
+			pCapture->AddColumn("v", "Value", LibMCEnv::eDataTableColumnType::DoubleColumn);
+			assertTrue(errorCodeOf([&]() { pCapture->AddColumn("n", "Duplicate", LibMCEnv::eDataTableColumnType::DoubleColumn); }) == LIBMCENV_ERROR_DUPLICATECOLUMNIDENTIFIER, "duplicate column identifier is rejected");
+
+			std::vector<uint64_t> counters = { 1, 2, 3 };
+			std::vector<double> values = { 0.5, 1.0, 1.5 };
+			std::vector<uint64_t> tooMany = { 1, 2, 3, 4, 5 };
+
+			UChunk pChunk(pCapture->BeginChunk());
+
+			// The schema is frozen with the first chunk.
+			assertTrue(errorCodeOf([&]() { pCapture->AddColumn("late", "Late", LibMCEnv::eDataTableColumnType::DoubleColumn); }) == LIBMCENV_ERROR_DATACAPTURENOTCONFIGURABLE, "column after the first chunk is rejected");
+			assertTrue(errorCodeOf([&]() { UChunk pSecond(pCapture->BeginChunk()); }) == LIBMCENV_ERROR_DATACAPTURECHUNKALREADYOPEN, "second chunk while one is uncommitted is rejected");
+			assertTrue(errorCodeOf([&]() { pCapture->Finish(); }) == LIBMCENV_ERROR_DATACAPTURECHUNKOUTSTANDING, "Finish with an uncommitted chunk is rejected");
+
+			assertTrue(errorCodeOf([&]() { pChunk->SetUint64ColumnValues(0, tooMany.size(), tooMany.data()); }) == LIBMCENV_ERROR_DATACAPTURECHUNKOVERFLOW, "more rows than the capacity are rejected");
+			assertTrue(errorCodeOf([&]() { pChunk->SetDoubleColumnValues(0, values.size(), values.data()); }) == LIBMCENV_ERROR_DATACAPTURECOLUMNTYPEMISMATCH, "wrong column type is rejected");
+			assertTrue(errorCodeOf([&]() { pChunk->SetTimestampColumnValues(0, counters.size(), counters.data()); }) == LIBMCENV_ERROR_DATACAPTURECOLUMNTYPEMISMATCH, "timestamp setter on a uint64 column is rejected");
+			assertTrue(errorCodeOf([&]() { pChunk->SetUint64ColumnValues(5, counters.size(), counters.data()); }) == LIBMCENV_ERROR_INVALIDCOLUMNINDEX, "unknown column index is rejected");
+
+			// A chunk whose columns have different lengths is rejected and stays with the producer.
+			pChunk->SetUint64ColumnValues(0, counters.size(), counters.data());
+			pChunk->SetDoubleColumnValues(1, 2, values.data());
+			assertTrue(errorCodeOf([&]() { pCapture->CommitChunk(pChunk.get()); }) == LIBMCENV_ERROR_DATACAPTURECHUNKINCOMPLETE, "columns of different length are rejected");
+			assertTrue(pCapture->GetCapturedRowCount() == 0, "a rejected chunk is not captured");
+
+			pChunk->SetDoubleColumnValues(1, values.size(), values.data());
+			pCapture->CommitChunk(pChunk.get());
+			assertTrue(pCapture->GetCapturedRowCount() == 3, "the completed chunk is captured");
+
+			// A committed chunk is not usable anymore.
+			assertTrue(errorCodeOf([&]() { pChunk->GetRowCount(); }) == LIBMCENV_ERROR_DATACAPTURECHUNKINVALID, "committed chunk is invalid");
+			assertTrue(errorCodeOf([&]() { pChunk->SetUint64ColumnValues(0, counters.size(), counters.data()); }) == LIBMCENV_ERROR_DATACAPTURECHUNKINVALID, "writing to a committed chunk is rejected");
+			assertTrue(errorCodeOf([&]() { pCapture->CommitChunk(pChunk.get()); }) == LIBMCENV_ERROR_DATACAPTURECHUNKINVALID, "committing a chunk twice is rejected");
+			assertTrue(errorCodeOf([&]() { pCapture->CommitChunk(nullptr); }) == LIBMCENV_ERROR_DATACAPTURECHUNKINVALID, "committing a null chunk is rejected");
+
+			// A chunk of another capture is rejected.
+			auto pOtherCapture = createCapture(fixture, "other", pOptions.get());
+			pOtherCapture->AddColumn("n", "Counter", LibMCEnv::eDataTableColumnType::Uint64Column);
+			{
+				UChunk pOtherChunk(pOtherCapture->BeginChunk());
+				assertTrue(errorCodeOf([&]() { pCapture->CommitChunk(pOtherChunk.get()); }) == LIBMCENV_ERROR_DATACAPTURECHUNKINVALID, "chunk of another capture is rejected");
+			}
+			pOtherCapture->Abort();
+
+			pCapture->Finish();
+			assertTrue(errorCodeOf([&]() { UChunk pLate(pCapture->BeginChunk()); }) == LIBMCENV_ERROR_DATACAPTURENOTRECORDING, "chunk after Finish is rejected");
+			assertTrue(errorCodeOf([&]() { pCapture->Abort(); }) == LIBMCENV_ERROR_DATACAPTURENOTRECORDING, "a finished capture is not aborted");
+		}
+
+		void testAbortDeletesEverything()
+		{
+			auto fixture = createFixture("abort");
+			size_t nBaselineStreamFiles = countStreamFiles(fixture);
+
+			{
+				// One chunk per segment: some segments are finalized, some wait for the finalizer, one is open.
+				auto pOptions = createCounterOptions(fixture, 100, DATACAPTURE_MINSEGMENTSIZE);
+				auto pCapture = createCapture(fixture, "aborted", pOptions.get());
+				addCounterColumn(pCapture.get());
+
+				uint64_t nCounter = 0;
+				for (uint32_t nIndex = 0; nIndex < 6; nIndex++)
+					commitCounterChunk(pCapture.get(), nCounter, 100);
+
+				pCapture->Flush();
+				assertTrue(countStreamFiles(fixture) > nBaselineStreamFiles, "segment files exist while recording");
+
+				UChunk pOutstandingChunk(pCapture->BeginChunk());
+
+				pCapture->Abort();
+				assertTrue(pCapture->GetStatus() == LibMCEnv::eDataCaptureStatus::Aborted, "capture is aborted");
+
+				assertTrue(countStreamFiles(fixture) == nBaselineStreamFiles, "no segment file is left after abort");
+				assertTrue(fixture.m_pStorage->GetDataCaptureStorageSize() == 0, "no capture data is stored after abort");
+
+				auto pManifest = fixture.m_pExecution->RetrieveDataCapture("aborted");
+				assertTrue(pManifest->GetStatus() == LibMCData::eDataCaptureStatus::Aborted, "manifest is aborted");
+				assertTrue(pManifest->GetStoredSizeInBytes() == 0, "manifest has nothing stored");
+
+				pCapture->Abort();
+				assertTrue(errorCodeOf([&]() { UChunk pLate(pCapture->BeginChunk()); }) == LIBMCENV_ERROR_DATACAPTURENOTRECORDING, "chunk after abort is rejected");
+				assertTrue(errorCodeOf([&]() { pCapture->Finish(); }) == LIBMCENV_ERROR_DATACAPTURENOTRECORDING, "Finish after abort is rejected");
+			}
+
+			// A capture that never recorded is aborted without touching the storage.
+			{
+				auto pCapture = createCapture(fixture, "unused", nullptr);
+				addCounterColumn(pCapture.get());
+				pCapture->Abort();
+				assertTrue(pCapture->GetStatus() == LibMCEnv::eDataCaptureStatus::Aborted, "unused capture is aborted");
+				assertTrue(fixture.m_pExecution->RetrieveDataCapture("unused")->GetStatus() == LibMCData::eDataCaptureStatus::Aborted, "unused manifest is aborted");
+				assertTrue(countStreamFiles(fixture) == nBaselineStreamFiles, "no segment file was created");
+			}
+		}
+
+		void testBackpressureBlock()
+		{
+			auto fixture = createFixture("block");
+
+			// One chunk per segment keeps the writer busy, so the producer runs into the queue limit.
+			auto pOptions = createCounterOptions(fixture, 100, DATACAPTURE_MINSEGMENTSIZE, 2, LibMCEnv::eDataCaptureBackpressureMode::Block);
+			auto pCapture = createCapture(fixture, "blocked", pOptions.get());
+			addCounterColumn(pCapture.get());
+
+			uint64_t nCounter = 0;
+			for (uint32_t nIndex = 0; nIndex < 40; nIndex++) {
+				commitCounterChunk(pCapture.get(), nCounter, 100);
+				assertTrue(pCapture->GetQueuedChunkCount() <= 2, "queue never exceeds its depth");
+			}
+
+			pCapture->Finish();
+			assertTrue(pCapture->GetDroppedRowCount() == 0, "Block mode drops nothing");
+			assertTrue(pCapture->GetCapturedRowCount() == 4000, "all rows are captured");
+			assertTrue(pCapture->GetQueuedChunkCount() == 0, "queue is empty after Finish");
+
+			auto segments = listSegments(fixture, "blocked");
+			assertTrue(segments.size() == 40, "forty segments");
+			assertTrue(segments[39].m_nFirstRow == 3900, "last segment continues the row numbering");
+
+			auto lastValues = loadCounterSegment(fixture, "blocked", 39);
+			assertTrue((lastValues.size() == 100) && (lastValues[0] == 3900) && (lastValues[99] == 3999), "last segment holds the last rows");
+		}
+
+		void testBackpressureDropOldest()
+		{
+			auto fixture = createFixture("dropoldest");
+
+			auto pOptions = createCounterOptions(fixture, 100, DATACAPTURE_MINSEGMENTSIZE, 1, LibMCEnv::eDataCaptureBackpressureMode::DropOldest);
+			auto pCapture = createCapture(fixture, "dropping", pOptions.get());
+			addCounterColumn(pCapture.get());
+
+			// The producer is orders of magnitude faster than a writer that rolls over on every chunk.
+			uint64_t nCounter = 0;
+			for (uint32_t nIndex = 0; nIndex < 60; nIndex++) {
+				commitCounterChunk(pCapture.get(), nCounter, 100);
+				assertTrue(pCapture->GetQueuedChunkCount() <= 1, "queue never exceeds its depth");
+			}
+
+			pCapture->Finish();
+
+			uint64_t nDroppedRows = pCapture->GetDroppedRowCount();
+			uint64_t nCapturedRows = pCapture->GetCapturedRowCount();
+			assertTrue(nDroppedRows > 0, "the producer outran the writer and rows were dropped");
+			assertTrue(nDroppedRows % 100 == 0, "whole chunks are dropped");
+			assertTrue(nCapturedRows + nDroppedRows == 6000, "every committed row is either captured or counted as dropped");
+
+			auto pManifest = fixture.m_pExecution->RetrieveDataCapture("dropping");
+			assertTrue(pManifest->GetRowCount() == nCapturedRows, "the stored rows are the captured rows");
+
+			// The producer was never blocked and the newest chunk always survives.
+			auto segments = listSegments(fixture, "dropping");
+			auto lastValues = loadCounterSegment(fixture, "dropping", (uint32_t)segments.size() - 1);
+			assertTrue((lastValues.size() == 100) && (lastValues[99] == 5999), "the last committed chunk is stored");
+		}
+
+		void testBackpressureFail()
+		{
+			auto fixture = createFixture("fail");
+
+			auto pOptions = createCounterOptions(fixture, 100, DATACAPTURE_MINSEGMENTSIZE, 1, LibMCEnv::eDataCaptureBackpressureMode::Fail);
+			auto pCapture = createCapture(fixture, "failing", pOptions.get());
+			addCounterColumn(pCapture.get());
+
+			uint32_t nQueueFullCount = 0;
+			uint64_t nCounter = 0;
+			for (uint32_t nIndex = 0; nIndex < 60; nIndex++) {
+
+				// When the queue is full, the producer decides: here it waits and tries again.
+				for (;;) {
+					int32_t nErrorCode = errorCodeOf([&]() { commitCounterChunk(pCapture.get(), nCounter, 100); });
+					if (nErrorCode == 0)
+						break;
+
+					assertTrue(nErrorCode == LIBMCENV_ERROR_DATACAPTUREQUEUEFULL, "a full queue raises DATACAPTUREQUEUEFULL, got " + std::to_string(nErrorCode));
+					nQueueFullCount++;
+					pCapture->Flush();
+				}
+			}
+
+			pCapture->Finish();
+			assertTrue(nQueueFullCount > 0, "the producer outran the writer and the queue was reported as full");
+			assertTrue(pCapture->GetDroppedRowCount() == 0, "Fail mode drops nothing");
+			assertTrue(pCapture->GetCapturedRowCount() == 6000, "all rows are captured after retrying");
+			assertTrue(fixture.m_pExecution->RetrieveDataCapture("failing")->GetRowCount() == 6000, "all rows are stored");
+		}
+
+		void testRetentionPurgesOldest()
+		{
+			auto fixture = createFixture("retention");
+
+			// One chunk per segment. The limit holds exactly three segments.
+			uint64_t nSegmentSize = counterSegmentSize(1, 100);
+			auto pOptions = createCounterOptions(fixture, 100, DATACAPTURE_MINSEGMENTSIZE, 4, LibMCEnv::eDataCaptureBackpressureMode::Block, 3 * nSegmentSize);
+			auto pCapture = createCapture(fixture, "retained", pOptions.get());
+			addCounterColumn(pCapture.get());
+
+			uint64_t nCounter = 0;
+			for (uint32_t nIndex = 0; nIndex < 8; nIndex++)
+				commitCounterChunk(pCapture.get(), nCounter, 100);
+
+			pCapture->Finish();
+
+			auto segments = listSegments(fixture, "retained");
+			assertTrue(segments.size() == 8, "all eight segments are in the manifest");
+
+			for (uint32_t nIndex = 0; nIndex < 5; nIndex++)
+				assertTrue(segments[nIndex].m_bIsPurged, "old segment " + std::to_string(nIndex) + " is purged");
+			for (uint32_t nIndex = 5; nIndex < 8; nIndex++)
+				assertFalse(segments[nIndex].m_bIsPurged, "new segment " + std::to_string(nIndex) + " is stored");
+
+			assertTrue(fixture.m_pStorage->GetDataCaptureStorageSize() == 3 * nSegmentSize, "the stored size is at the limit");
+			assertTrue(fixture.m_pBuildExecution->GetDataCaptureRowCount("retained") == 800, "the manifest keeps the full row count");
+			assertTrue(fixture.m_pExecution->RetrieveDataCapture("retained")->GetStatus() == LibMCData::eDataCaptureStatus::Finished, "the capture finishes normally");
+
+			assertTrue(errorCodeOf([&]() { UTable pTable(fixture.m_pBuildExecution->LoadDataCaptureSegment("retained", 0)); }) == LIBMCENV_ERROR_DATACAPTURESEGMENTPURGED, "a purged segment can not be loaded");
+
+			auto values = loadCounterSegment(fixture, "retained", 7);
+			assertTrue((values.size() == 100) && (values[0] == 700), "the newest segment is loadable");
+		}
+
+		void testCountersAndFlush()
+		{
+			auto fixture = createFixture("counters");
+			auto pOptions = createCounterOptions(fixture, 100, DATACAPTURE_MINSEGMENTSIZE);
+			auto pCapture = createCapture(fixture, "counted", pOptions.get());
+			addCounterColumn(pCapture.get());
+
+			assertTrue(pCapture->GetSegmentCount() == 0, "no segment before recording");
+			assertTrue(pCapture->GetStorageSizeInBytes() == 0, "nothing written before recording");
+			pCapture->Flush();
+
+			uint64_t nCounter = 0;
+			for (uint32_t nIndex = 0; nIndex < 3; nIndex++)
+				commitCounterChunk(pCapture.get(), nCounter, 100);
+
+			pCapture->Flush();
+			assertTrue(pCapture->GetQueuedChunkCount() == 0, "queue is empty after Flush");
+			assertTrue(pCapture->GetSegmentCount() == 3, "three segments have been opened");
+			assertTrue(pCapture->GetCapturedRowCount() == 300, "three hundred rows captured");
+			assertTrue(pCapture->GetDroppedRowCount() == 0, "nothing dropped");
+
+			// Two segments are closed, the third one is open and has no footer yet.
+			uint64_t nSizeBeforeFinish = pCapture->GetStorageSizeInBytes();
+			uint64_t nOpenSegmentSize = counterSegmentSize(1, 100) - AMC::CDataTableV2SegmentBuilder({ { "n", "Counter", AMC::eDataTableV2DataType::Uint64 } }, 0, 0, 100).getFooterSizeInBytes(1);
+			assertTrue(nSizeBeforeFinish == 2 * counterSegmentSize(1, 100) + nOpenSegmentSize, "storage size counts every written byte");
+
+			pCapture->Finish();
+			assertTrue(pCapture->GetStorageSizeInBytes() == 3 * counterSegmentSize(1, 100), "storage size after Finish is the size of all segments");
+			assertTrue(fixture.m_pExecution->RetrieveDataCapture("counted")->GetStoredSizeInBytes() == pCapture->GetStorageSizeInBytes(), "manifest size matches the capture");
+		}
+
+		void testAbandonedCaptureIsFinished()
+		{
+			auto fixture = createFixture("abandoned");
+
+			{
+				auto pOptions = createOptions(fixture, 100, 0);
+				auto pCapture = createCapture(fixture, "abandoned", pOptions.get());
+				addCounterColumn(pCapture.get());
+
+				uint64_t nCounter = 0;
+				commitCounterChunk(pCapture.get(), nCounter, 100);
+				commitCounterChunk(pCapture.get(), nCounter, 50);
+
+				// The capture is released without Finish or Abort.
+			}
+
+			auto pManifest = fixture.m_pExecution->RetrieveDataCapture("abandoned");
+			assertTrue(pManifest->GetStatus() == LibMCData::eDataCaptureStatus::Finished, "an abandoned capture is finished");
+			assertTrue(pManifest->GetRowCount() == 150, "an abandoned capture keeps its committed rows");
+
+			auto values = loadCounterSegment(fixture, "abandoned", 0);
+			assertTrue((values.size() == 150) && (values[149] == 149), "the committed rows are loadable");
+		}
+
+		void testTruncatedSegment()
+		{
+			auto fixture = createFixture("truncated");
+			auto pOptions = createOptions(fixture, 100, 0);
+			auto pCapture = createCapture(fixture, "whole", pOptions.get());
+			addCounterColumn(pCapture.get());
+
+			uint64_t nCounter = 0;
+			commitCounterChunk(pCapture.get(), nCounter, 100);
+			commitCounterChunk(pCapture.get(), nCounter, 100);
+			pCapture->Finish();
+
+			auto segments = listSegments(fixture, "whole");
+			std::vector<uint8_t> bytes;
+			fixture.m_pStorage->RetrieveStream(segments[0].m_sStreamUUID)->GetContent(bytes);
+			assertTrue(bytes.size() == segments[0].m_nSizeInBytes, "segment content is read");
+
+			auto loadBytes = [&](const std::vector<uint8_t>& content, LibMCEnv::Impl::CDataTable* pTable) {
+				auto pWriter = std::make_unique<LibMCEnv::Impl::CTempStreamWriter>(fixture.m_pDataModel, "copy.dat", "application/amcf-datatable", AMCCommon::CUtils::createEmptyUUID(), fixture.m_pChrono);
+				pWriter->WriteData(content.size(), content.data());
+				pWriter->Finish();
+				std::unique_ptr<LibMCEnv::Impl::IStreamReader> pReader(pWriter->GetStreamReader());
+				pTable->LoadFromStream(pReader.get());
+			};
+
+			auto pTable = std::make_unique<LibMCEnv::Impl::CDataTable>(fixture.m_pToolpathHandler);
+
+			// The intact copy loads.
+			loadBytes(bytes, pTable.get());
+			assertTrue(pTable->GetRowCount64() == 200, "intact segment copy loads");
+
+			// A capture that was interrupted before the footer was written: all chunk data is there, the footer is missing.
+			AMC::sDataTableV2Trailer trailer;
+			memcpy(&trailer, bytes.data() + bytes.size() - sizeof(trailer), sizeof(trailer));
+			std::vector<uint8_t> interrupted(bytes.begin(), bytes.end() - sizeof(trailer) - (size_t)trailer.m_nFooterLength);
+
+			int32_t nErrorCode = errorCodeOf([&]() { loadBytes(interrupted, pTable.get()); });
+			assertTrue(nErrorCode == LIBMCENV_ERROR_DATATABLESEGMENTTRUNCATED, "interrupted segment is reported as truncated, got " + std::to_string(nErrorCode));
+			assertTrue(pTable->GetColumnCount() == 0, "no garbage is loaded from an interrupted segment");
+
+			// A segment cut in the middle of a page.
+			std::vector<uint8_t> cut(bytes.begin(), bytes.begin() + bytes.size() / 2);
+			nErrorCode = errorCodeOf([&]() { loadBytes(cut, pTable.get()); });
+			assertTrue(nErrorCode == LIBMCENV_ERROR_DATATABLESEGMENTTRUNCATED, "cut segment is reported as truncated, got " + std::to_string(nErrorCode));
+			assertTrue(pTable->GetColumnCount() == 0, "no garbage is loaded from a cut segment");
+		}
+
+	};
+
+}
+
+#endif // __AMCTEST_UNITTEST_DATACAPTURE
diff --git a/Implementation/UnitTest/amc_unittests_datacapturequery.hpp b/Implementation/UnitTest/amc_unittests_datacapturequery.hpp
new file mode 100644
index 000000000..2061c9a94
--- /dev/null
+++ b/Implementation/UnitTest/amc_unittests_datacapturequery.hpp
@@ -0,0 +1,513 @@
+/*++
+
+Copyright (C) 2020 Autodesk Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Autodesk Inc. nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL AUTODESK INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef __AMCTEST_UNITTEST_DATACAPTUREQUERY
+#define __AMCTEST_UNITTEST_DATACAPTUREQUERY
+
+#include "amc_unittests_datatablereader.hpp"
+#include "amc_datacapturequery.hpp"
+#include "amc_jsonwriter.hpp"
+
+#include <cmath>
+#include <cstring>
+#include <limits>
+
+namespace AMCUnitTest {
+
+	// The query class builds the response bodies of the datatable API handler.
+	// Uses the fixture and the signal capture of the reader tests.
+	class CUnitTestGroup_DataCaptureQuery : public CUnitTestGroup_DataTableReader {
+	public:
+
+		std::string getTestGroupName() override {
+			return "DataCaptureQuery";
+		}
+
+		void registerTests() override {
+			registerTest("Info", "Info document with schema, segments and value ranges", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataCaptureQuery::testInfo, this));
+			registerTest("JSONData", "Row range as JSON value arrays", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataCaptureQuery::testJSONData, this));
+			registerTest("JSONSpecialValues", "64 bit integers stay exact and NaN becomes null", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataCaptureQuery::testJSONSpecialValues, this));
+			registerTest("JSONEnvelope", "Downsampled data as bucket series", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataCaptureQuery::testJSONEnvelope, this));
+			registerTest("CSV", "Row range and downsampled data as CSV", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataCaptureQuery::testCSV, this));
+			registerTest("Binary", "Raw float64 and float32 arrays", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataCaptureQuery::testBinary, this));
+			registerTest("SizeCap", "Unbounded requests are rejected with an error that names the parameters", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataCaptureQuery::testSizeCap, this));
+			registerTest("DefaultsAndValidation", "Default range and parameter validation", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataCaptureQuery::testDefaultsAndValidation, this));
+		}
+
+	protected:
+
+		AMC::PDataCaptureReader openCoreReader(SFixture& fixture, const std::string& sIdentifier)
+		{
+			return std::make_shared<AMC::CDataCaptureReader>(fixture.m_pDataModel, fixture.m_pExecution->RetrieveDataCapture(sIdentifier));
+		}
+
+		template <typename F>
+		uint32_t formatErrorOf(F&& fn, std::string* pMessage = nullptr)
+		{
+			try {
+				fn();
+			}
+			catch (AMC::EDataTableFormatException& formatException) {
+				if (pMessage != nullptr)
+					*pMessage = formatException.what();
+				return (uint32_t)formatException.getError();
+			}
+			return 0;
+		}
+
+		// Wraps the members a query produces into a JSON object and parses it.
+		void parseQueryJSON(AMC::CDataCaptureQuery& captureQuery, const AMC::sDataCaptureQuery& query, rapidjson::Document& document, std::string& sJSON)
+		{
+			sJSON = "{";
+			captureQuery.appendJSONMembers(query, sJSON);
+			sJSON += "}";
+
+			document.Parse(sJSON.c_str());
+			assertFalse(document.HasParseError(), "query output is valid JSON: " + sJSON.substr(0, 200));
+			assertTrue(document.IsObject(), "query output is a JSON object");
+		}
+
+		void testInfo()
+		{
+			auto fixture = createFixture("queryinfo");
+			auto pOptions = signalOptions(fixture);
+			captureSignal(fixture, "signal", pOptions.get());
+
+			AMC::CDataCaptureQuery captureQuery(openCoreReader(fixture, "signal"));
+
+			AMC::CJSONWriter writer;
+			captureQuery.writeInfo(writer);
+
+			rapidjson::Document document;
+			document.Parse(writer.saveToString().c_str());
+			assertFalse(document.HasParseError(), "info is valid JSON");
+
+			auto pManifest = fixture.m_pExecution->RetrieveDataCapture("signal");
+			assertTrue(std::string(document["uuid"].GetString()) == pManifest->GetUUID(), "info uuid");
+			assertTrue(std::string(document["identifier"].GetString()) == "signal", "info identifier");
+			assertTrue(document["rowcount"].GetUint64() == SIGNAL_ROWCOUNT, "info row count");
+			assertTrue(document["firstavailablerow"].GetUint64() == 0, "info first available row");
+			assertTrue(document["columncount"].GetUint64() == 4, "info column count");
+			assertTrue(document["segmentcount"].GetUint64() == 7, "info segment count");
+			assertTrue(document["chunkcount"].GetUint64() == 25, "info chunk count");
+			assertTrue(document["storedsize"].GetUint64() == pManifest->GetStoredSizeInBytes(), "info stored size");
+
+			auto& columns = document["columns"];
+			assertTrue(columns.IsArray() && (columns.Size() == 4), "info has four columns");
+			assertTrue(std::string(columns[0]["name"].GetString()) == "t", "column 0 name");
+			assertTrue(std::string(columns[0]["type"].GetString()) == "timestamp", "column 0 type");
+			assertTrue(columns[0]["min"].GetDouble() == (double)signalTimestamp(0), "timestamp minimum");
+			assertTrue(columns[0]["max"].GetDouble() == (double)signalTimestamp(SIGNAL_ROWCOUNT - 1), "timestamp maximum");
+
+			assertTrue(std::string(columns[1]["name"].GetString()) == "v", "column 1 name");
+			assertTrue(std::string(columns[1]["description"].GetString()) == "Value", "column 1 description");
+			assertTrue(std::string(columns[1]["type"].GetString()) == "float", "column 1 type");
+			assertTrue(columns[1]["hasrange"].GetBool(), "column 1 has a value range");
+			assertTrue(columns[1]["min"].GetDouble() == 0.0, "value minimum");
+			assertTrue(columns[1]["max"].GetDouble() == 5000.0, "value maximum is the spike");
+			assertTrue(columns[1]["quantization"].GetDouble() == 0.0, "column is not quantised");
+			assertTrue(std::string(columns[3]["type"].GetString()) == "bool", "column 3 type");
+
+			auto& segments = document["segments"];
+			assertTrue(segments.IsArray() && (segments.Size() == 7), "info has seven segments");
+			assertTrue(segments[2]["firstrow"].GetUint64() == 800, "segment first row");
+			assertTrue(segments[2]["rowcount"].GetUint64() == 400, "segment row count");
+			assertTrue(segments[2]["chunkcount"].GetUint64() == 4, "segment chunk count");
+			assertTrue(segments[2]["available"].GetBool(), "segment is available");
+			assertTrue(segments[6]["rowcount"].GetUint64() == 100, "last segment row count");
+		}
+
+		void testJSONData()
+		{
+			auto fixture = createFixture("queryjson");
+			auto pOptions = signalOptions(fixture);
+			captureSignal(fixture, "signal", pOptions.get());
+
+			AMC::CDataCaptureQuery captureQuery(openCoreReader(fixture, "signal"));
+
+			AMC::sDataCaptureQuery query;
+			query.m_ColumnIdentifiers = { "n", "b", "v", "t" };
+			query.m_bHasFromRow = true;
+			query.m_nFromRow = 1298;
+			query.m_bHasRowCount = true;
+			query.m_nRowCount = 4;
+
+			rapidjson::Document document;
+			std::string sJSON;
+			parseQueryJSON(captureQuery, query, document, sJSON);
+
+			assertTrue(document["fromrow"].GetUint64() == 1298, "fromrow");
+			assertTrue(document["rowcount"].GetUint64() == 4, "rowcount");
+			assertTrue(std::string(document["downsample"].GetString()) == "none", "downsample mode");
+
+			auto& columns = document["columns"];
+			assertTrue(columns.IsArray() && (columns.Size() == 4), "four columns in request order");
+
+			assertTrue(std::string(columns[0]["name"].GetString()) == "n", "first column is n");
+			assertTrue(std::string(columns[0]["type"].GetString()) == "uint64", "counter type");
+			assertTrue(columns[0]["values"].Size() == 4, "four values");
+			assertTrue((columns[0]["values"][0].GetUint64() == 1298) && (columns[0]["values"][3].GetUint64() == 1301), "counter values across a chunk boundary");
+
+			// The flag toggles at row 1300.
+			assertTrue(columns[1]["values"][1].IsBool() && (columns[1]["values"][1].GetBool() == false), "bool value before the boundary");
+			assertTrue(columns[1]["values"][2].GetBool() == true, "bool value after the boundary");
+
+			assertTrue(columns[2]["values"][0].GetDouble() == 48.0, "float value");
+			assertTrue(columns[3]["values"][3].GetUint64() == signalTimestamp(1301), "timestamp value");
+
+			// The spike row
+			query.m_ColumnIdentifiers = { "v" };
+			query.m_nFromRow = SIGNAL_SPIKEROW;
+			query.m_nRowCount = 1;
+			parseQueryJSON(captureQuery, query, document, sJSON);
+			assertTrue(document["columns"][0]["values"][0].GetDouble() == 5000.0, "spike value");
+
+			// An empty range is a valid response.
+			query.m_nRowCount = 0;
+			parseQueryJSON(captureQuery, query, document, sJSON);
+			assertTrue(document["columns"][0]["values"].Size() == 0, "empty range has no values");
+		}
+
+		void testJSONSpecialValues()
+		{
+			auto fixture = createFixture("queryspecial");
+
+			UOptions pOptions(fixture.m_pBuildExecution->CreateDataCaptureOptions());
+			auto pCapture = createCapture(fixture, "special", pOptions.get());
+			pCapture->AddColumn("u", "Large integer", LibMCEnv::eDataTableColumnType::Uint64Column);
+			pCapture->AddColumn("i", "Negative integer", LibMCEnv::eDataTableColumnType::Int64Column);
+			pCapture->AddColumn("d", "Double", LibMCEnv::eDataTableColumnType::DoubleColumn);
+
+			std::vector<uint64_t> unsignedValues = { 18000000000000000001ULL, 9007199254740993ULL };
+			std::vector<int64_t> signedValues = { -9007199254740993LL, 7 };
+			std::vector<double> doubleValues = { std::numeric_limits<double>::quiet_NaN(), 0.1 };
+			{
+				UChunk pChunk(pCapture->BeginChunk());
+				pChunk->SetUint64ColumnValues(0, unsignedValues.size(), unsignedValues.data());
+				pChunk->SetInt64ColumnValues(1, signedValues.size(), signedValues.data());
+				pChunk->SetDoubleColumnValues(2, doubleValues.size(), doubleValues.data());
+				pCapture->CommitChunk(pChunk.get());
+			}
+			pCapture->Finish();
+
+			AMC::CDataCaptureQuery captureQuery(openCoreReader(fixture, "special"));
+			AMC::sDataCaptureQuery query;
+
+			rapidjson::Document document;
+			std::string sJSON;
+			parseQueryJSON(captureQuery, query, document, sJSON);
+
+			// Integers beyond 2^53 are written digit by digit and not through a double.
+			assertTrue(sJSON.find("18000000000000000001") != std::string::npos, "large unsigned integer is exact");
+			assertTrue(sJSON.find("9007199254740993") != std::string::npos, "integer beyond the double precision is exact");
+			assertTrue(sJSON.find("-9007199254740993") != std::string::npos, "negative integer beyond the double precision is exact");
+
+			auto& columns = document["columns"];
+			assertTrue(columns[0]["values"][0].GetUint64() == 18000000000000000001ULL, "large unsigned integer parses back");
+			assertTrue(columns[1]["values"][0].GetInt64() == -9007199254740993LL, "negative integer parses back");
+			assertTrue(columns[2]["values"][0].IsNull(), "NaN is null in JSON");
+			assertTrue(columns[2]["values"][1].GetDouble() == 0.1, "double value reads back unchanged");
+
+			// CSV prints the same exact integers.
+			std::string sCSV = captureQuery.buildCSV(query);
+			assertTrue(sCSV == "row;u;i;d\n0;18000000000000000001;-9007199254740993;nan\n1;9007199254740993;7;0.10000000000000001\n", "CSV with exact integers, got: " + sCSV);
+		}
+
+		void testJSONEnvelope()
+		{
+			auto fixture = createFixture("queryenvelope");
+			auto pOptions = signalOptions(fixture);
+			captureSignal(fixture, "signal", pOptions.get());
+
+			AMC::CDataCaptureQuery captureQuery(openCoreReader(fixture, "signal"));
+
+			AMC::sDataCaptureQuery query;
+			query.m_ColumnIdentifiers = { "v", "n" };
+			query.m_Downsample = AMC::eDataCaptureQueryDownsample::MinMax;
+			query.m_nTargetPoints = 10;
+
+			rapidjson::Document document;
+			std::string sJSON;
+			parseQueryJSON(captureQuery, query, document, sJSON);
+
+			assertTrue(std::string(document["downsample"].GetString()) == "minmax", "downsample mode");
+			assertTrue(document["count"].GetUint64() == 10, "bucket count");
+			assertTrue(document["fromrow"].GetUint64() == 0, "default first row");
+			assertTrue(document["rowcount"].GetUint64() == SIGNAL_ROWCOUNT, "default row count");
+
+			auto& series = document["series"];
+			assertTrue(series.IsArray() && (series.Size() == 2), "one series per column");
+			assertTrue(std::string(series[0]["name"].GetString()) == "v", "series name");
+			assertTrue(series[0]["available"].GetBool(), "series is available");
+
+			auto& buckets = series[0]["buckets"];
+			assertTrue(buckets.Size() == 10, "ten buckets");
+			assertTrue(buckets[0]["row"].GetUint64() == 0, "first bucket row");
+			assertTrue(buckets[4]["row"].GetUint64() == 1000, "bucket row is the first row of the bucket");
+			assertTrue(buckets[4]["min"].GetDouble() == 0.0, "bucket minimum");
+			assertTrue(buckets[4]["max"].GetDouble() == 5000.0, "the envelope preserves the spike");
+			assertTrue(buckets[5]["max"].GetDouble() == 249.0, "bucket maximum without spike");
+
+			auto& counterBuckets = series[1]["buckets"];
+			assertTrue((counterBuckets[9]["min"].GetDouble() == 2250.0) && (counterBuckets[9]["max"].GetDouble() == 2499.0), "counter envelope of the last bucket");
+
+			// Stride and average return one value per bucket.
+			query.m_Downsample = AMC::eDataCaptureQueryDownsample::Average;
+			parseQueryJSON(captureQuery, query, document, sJSON);
+			assertTrue(std::string(document["downsample"].GetString()) == "average", "average mode");
+			assertTrue(std::fabs(document["series"][0]["buckets"][0]["value"].GetDouble() - 124.5) < 1.0e-9, "bucket average");
+
+			query.m_Downsample = AMC::eDataCaptureQueryDownsample::Stride;
+			query.m_bHasFromRow = true;
+			query.m_nFromRow = 100;
+			query.m_bHasRowCount = true;
+			query.m_nRowCount = 400;
+			query.m_nTargetPoints = 4;
+			parseQueryJSON(captureQuery, query, document, sJSON);
+			auto& strideBuckets = document["series"][1]["buckets"];
+			assertTrue((strideBuckets.Size() == 4) && (strideBuckets[0]["row"].GetUint64() == 100) && (strideBuckets[3]["row"].GetUint64() == 400), "stride bucket rows");
+			assertTrue((strideBuckets[0]["value"].GetDouble() == 100.0) && (strideBuckets[3]["value"].GetDouble() == 400.0), "stride values");
+		}
+
+		void testCSV()
+		{
+			auto fixture = createFixture("querycsv");
+			auto pOptions = signalOptions(fixture);
+			captureSignal(fixture, "signal", pOptions.get());
+
+			AMC::CDataCaptureQuery captureQuery(openCoreReader(fixture, "signal"));
+
+			AMC::sDataCaptureQuery query;
+			query.m_ColumnIdentifiers = { "t", "v", "b" };
+			query.m_bHasFromRow = true;
+			query.m_nFromRow = 1233;
+			query.m_bHasRowCount = true;
+			query.m_nRowCount = 3;
+
+			std::string sExpected = "row;t;v;b\n";
+			sExpected += "1233;" + std::to_string(signalTimestamp(1233)) + ";233;0\n";
+			sExpected += "1234;" + std::to_string(signalTimestamp(1234)) + ";5000;0\n";
+			sExpected += "1235;" + std::to_string(signalTimestamp(1235)) + ";235;0\n";
+
+			std::string sCSV = captureQuery.buildCSV(query);
+			assertTrue(sCSV == sExpected, "CSV of a row range, got: " + sCSV);
+
+			// Downsampled CSV has a minimum and a maximum column per data column.
+			AMC::sDataCaptureQuery envelopeQuery;
+			envelopeQuery.m_ColumnIdentifiers = { "v" };
+			envelopeQuery.m_Downsample = AMC::eDataCaptureQueryDownsample::MinMax;
+			envelopeQuery.m_nTargetPoints = 5;
+
+			std::string sEnvelopeCSV = captureQuery.buildCSV(envelopeQuery);
+			assertTrue(sEnvelopeCSV == "row;v_min;v_max\n0;0;249\n500;0;249\n1000;0;5000\n1500;0;249\n2000;0;249\n", "CSV envelope, got: " + sEnvelopeCSV);
+
+			AMC::sDataCaptureQuery averageQuery;
+			averageQuery.m_ColumnIdentifiers = { "n" };
+			averageQuery.m_bHasFromRow = true;
+			averageQuery.m_nFromRow = 0;
+			averageQuery.m_bHasRowCount = true;
+			averageQuery.m_nRowCount = 4;
+			averageQuery.m_Downsample = AMC::eDataCaptureQueryDownsample::Average;
+			averageQuery.m_nTargetPoints = 2;
+			assertTrue(captureQuery.buildCSV(averageQuery) == "row;n\n0;0.5\n2;2.5\n", "CSV of bucket averages");
+		}
+
+		void testBinary()
+		{
+			auto fixture = createFixture("querybinary");
+			auto pOptions = signalOptions(fixture);
+			captureSignal(fixture, "signal", pOptions.get());
+
+			AMC::CDataCaptureQuery captureQuery(openCoreReader(fixture, "signal"));
+
+			AMC::sDataCaptureQuery query;
+			query.m_ColumnIdentifiers = { "n", "v" };
+			query.m_bHasFromRow = true;
+			query.m_nFromRow = 1230;
+			query.m_bHasRowCount = true;
+			query.m_nRowCount = 10;
+
+			// One float64 array per column, one after the other.
+			std::vector<uint8_t> buffer;
+			captureQuery.buildBinary(query, false, buffer);
+			assertTrue(buffer.size() == 2 * 10 * sizeof(double), "float64 buffer size");
+
+			std::vector<double> doubles(20);
+			memcpy(doubles.data(), buffer.data(), buffer.size());
+			assertTrue((doubles[0] == 1230.0) && (doubles[9] == 1239.0), "first array is the counter column");
+			assertTrue((doubles[10] == 230.0) && (doubles[14] == 5000.0), "second array is the value column");
+
+			captureQuery.buildBinary(query, true, buffer);
+			assertTrue(buffer.size() == 2 * 10 * sizeof(float), "float32 buffer size");
+			std::vector<float> floats(20);
+			memcpy(floats.data(), buffer.data(), buffer.size());
+			assertTrue((floats[0] == 1230.0f) && (floats[14] == 5000.0f), "float32 values");
+
+			// Downsampled: two values per bucket in MinMax mode.
+			AMC::sDataCaptureQuery envelopeQuery;
+			envelopeQuery.m_ColumnIdentifiers = { "v" };
+			envelopeQuery.m_Downsample = AMC::eDataCaptureQueryDownsample::MinMax;
+			envelopeQuery.m_nTargetPoints = 10;
+			captureQuery.buildBinary(envelopeQuery, true, buffer);
+			assertTrue(buffer.size() == 20 * sizeof(float), "envelope buffer holds minimum and maximum per bucket");
+			memcpy(floats.data(), buffer.data(), buffer.size());
+			assertTrue((floats[8] == 0.0f) && (floats[9] == 5000.0f), "envelope of the bucket with the spike");
+
+			// Empty range
+			query.m_nRowCount = 0;
+			captureQuery.buildBinary(query, false, buffer);
+			assertTrue(buffer.empty(), "empty range is an empty buffer");
+		}
+
+		void testSizeCap()
+		{
+			auto fixture = createFixture("querycap");
+			auto pOptions = signalOptions(fixture);
+			captureSignal(fixture, "signal", pOptions.get());
+
+			// A cap of 1000 values stands in for the production limit.
+			AMC::CDataCaptureQuery captureQuery(openCoreReader(fixture, "signal"), 1000);
+			uint32_t nInvalidRange = (uint32_t)AMC::eDataTableFormatError::InvalidRange;
+
+			// The whole capture: 4 columns of 2500 rows.
+			AMC::sDataCaptureQuery unbounded;
+			std::string sMessage;
+			std::string sJSON;
+			assertTrue(formatErrorOf([&]() { captureQuery.appendJSONMembers(unbounded, sJSON); }, &sMessage) == nInvalidRange, "unbounded JSON request is rejected");
+			assertTrue((sMessage.find("rowcount") != std::string::npos) && (sMessage.find("downsample") != std::string::npos) && (sMessage.find("targetpoints") != std::string::npos), "the error names the parameters that bound the request: " + sMessage);
+			assertTrue(sJSON.empty(), "nothing is written for a rejected request");
+
+			std::vector<uint8_t> buffer;
+			assertTrue(formatErrorOf([&]() { captureQuery.buildCSV(unbounded); }) == nInvalidRange, "unbounded CSV request is rejected");
+			assertTrue(formatErrorOf([&]() { captureQuery.buildBinary(unbounded, false, buffer); }) == nInvalidRange, "unbounded binary request is rejected");
+
+			// The cap counts values, which is rows times columns.
+			AMC::sDataCaptureQuery oneColumn;
+			oneColumn.m_ColumnIdentifiers = { "n" };
+			oneColumn.m_bHasFromRow = true;
+			oneColumn.m_nFromRow = 0;
+			oneColumn.m_bHasRowCount = true;
+			oneColumn.m_nRowCount = 1000;
+			captureQuery.buildBinary(oneColumn, false, buffer);
+			assertTrue(buffer.size() == 1000 * sizeof(double), "a request at the limit is served");
+
+			oneColumn.m_nRowCount = 1001;
+			assertTrue(formatErrorOf([&]() { captureQuery.buildBinary(oneColumn, false, buffer); }) == nInvalidRange, "one value above the limit is rejected");
+
+			AMC::sDataCaptureQuery twoColumns = oneColumn;
+			twoColumns.m_ColumnIdentifiers = { "n", "v" };
+			twoColumns.m_nRowCount = 501;
+			assertTrue(formatErrorOf([&]() { captureQuery.buildBinary(twoColumns, false, buffer); }) == nInvalidRange, "two columns of 501 rows are above the limit");
+			twoColumns.m_nRowCount = 500;
+			captureQuery.buildBinary(twoColumns, false, buffer);
+			assertTrue(buffer.size() == 1000 * sizeof(double), "two columns of 500 rows are at the limit");
+
+			// Downsampling bounds the response by the target points, whatever the capture length.
+			AMC::sDataCaptureQuery downsampled;
+			downsampled.m_Downsample = AMC::eDataCaptureQueryDownsample::MinMax;
+			downsampled.m_nTargetPoints = 100;
+			captureQuery.buildBinary(downsampled, false, buffer);
+			assertTrue(buffer.size() == 4 * 200 * sizeof(double), "the downsampled whole capture is served");
+
+			downsampled.m_nTargetPoints = 200;
+			assertTrue(formatErrorOf([&]() { captureQuery.buildBinary(downsampled, false, buffer); }) == nInvalidRange, "a downsampled request above the limit is rejected as well");
+		}
+
+		void testDefaultsAndValidation()
+		{
+			auto fixture = createFixture("querydefaults");
+
+			// Retention has deleted the oldest segments of this capture.
+			auto pProbeOptions = signalOptions(fixture);
+			auto pOptions = signalOptions(fixture, 3 * pProbeOptions->GetSegmentSizeInBytes());
+			captureSignal(fixture, "signal", pOptions.get());
+
+			auto pReader = openCoreReader(fixture, "signal");
+			uint64_t nFirstAvailableRow = pReader->getFirstAvailableRow();
+			assertTrue(nFirstAvailableRow > 0, "the capture has deleted rows");
+
+			AMC::CDataCaptureQuery captureQuery(pReader);
+
+			// Without a range the query covers everything that is still stored.
+			AMC::sDataCaptureQuery query;
+			query.m_ColumnIdentifiers = { "n" };
+
+			std::vector<uint8_t> buffer;
+			captureQuery.buildBinary(query, false, buffer);
+			assertTrue(buffer.size() == (SIGNAL_ROWCOUNT - nFirstAvailableRow) * sizeof(double), "default range is the stored part of the capture");
+
+			double dFirstValue = 0.0;
+			memcpy(&dFirstValue, buffer.data(), sizeof(double));
+			assertTrue(dFirstValue == (double)nFirstAvailableRow, "default range starts at the first available row");
+
+			// An explicit range over deleted rows is reported.
+			query.m_bHasFromRow = true;
+			query.m_nFromRow = 0;
+			assertTrue(formatErrorOf([&]() { captureQuery.buildBinary(query, false, buffer); }) == (uint32_t)AMC::eDataTableFormatError::SegmentPurged, "a range over deleted rows is reported");
+
+			// Parameter validation
+			uint32_t nInvalidParam = (uint32_t)AMC::eDataTableFormatError::InvalidParam;
+
+			AMC::sDataCaptureQuery unknownColumn;
+			unknownColumn.m_ColumnIdentifiers = { "missing" };
+			assertTrue(formatErrorOf([&]() { captureQuery.buildBinary(unknownColumn, false, buffer); }) == (uint32_t)AMC::eDataTableFormatError::ColumnNotFound, "unknown column is rejected");
+
+			AMC::sDataCaptureQuery beyondEnd;
+			beyondEnd.m_bHasFromRow = true;
+			beyondEnd.m_nFromRow = SIGNAL_ROWCOUNT + 1;
+			assertTrue(formatErrorOf([&]() { captureQuery.buildBinary(beyondEnd, false, buffer); }) == (uint32_t)AMC::eDataTableFormatError::InvalidRange, "fromrow beyond the end is rejected");
+
+			AMC::sDataCaptureQuery tooManyRows;
+			tooManyRows.m_bHasFromRow = true;
+			tooManyRows.m_nFromRow = 2400;
+			tooManyRows.m_bHasRowCount = true;
+			tooManyRows.m_nRowCount = 101;
+			assertTrue(formatErrorOf([&]() { captureQuery.buildBinary(tooManyRows, false, buffer); }) == (uint32_t)AMC::eDataTableFormatError::InvalidRange, "rowcount beyond the end is rejected");
+
+			AMC::sDataCaptureQuery zeroTargetPoints;
+			zeroTargetPoints.m_Downsample = AMC::eDataCaptureQueryDownsample::MinMax;
+			zeroTargetPoints.m_nTargetPoints = 0;
+			assertTrue(formatErrorOf([&]() { captureQuery.buildBinary(zeroTargetPoints, false, buffer); }) == nInvalidParam, "zero target points are rejected");
+			zeroTargetPoints.m_nTargetPoints = DATACAPTUREQUERY_MAXTARGETPOINTS + 1;
+			assertTrue(formatErrorOf([&]() { captureQuery.buildBinary(zeroTargetPoints, false, buffer); }) == nInvalidParam, "too many target points are rejected");
+
+			assertTrue(AMC::CDataCaptureQuery::parseDownsample("") == AMC::eDataCaptureQueryDownsample::None, "empty downsample is none");
+			assertTrue(AMC::CDataCaptureQuery::parseDownsample("none") == AMC::eDataCaptureQueryDownsample::None, "none");
+			assertTrue(AMC::CDataCaptureQuery::parseDownsample("stride") == AMC::eDataCaptureQueryDownsample::Stride, "stride");
+			assertTrue(AMC::CDataCaptureQuery::parseDownsample("minmax") == AMC::eDataCaptureQueryDownsample::MinMax, "minmax");
+			assertTrue(AMC::CDataCaptureQuery::parseDownsample("average") == AMC::eDataCaptureQueryDownsample::Average, "average");
+			assertTrue(formatErrorOf([&]() { AMC::CDataCaptureQuery::parseDownsample("bogus"); }) == nInvalidParam, "unknown downsample mode is rejected");
+		}
+
+	};
+
+}
+
+#endif // __AMCTEST_UNITTEST_DATACAPTUREQUERY
diff --git a/Implementation/UnitTest/amc_unittests_datatable.hpp b/Implementation/UnitTest/amc_unittests_datatable.hpp
new file mode 100644
index 000000000..8a1bfad62
--- /dev/null
+++ b/Implementation/UnitTest/amc_unittests_datatable.hpp
@@ -0,0 +1,629 @@
+/*++
+
+Copyright (C) 2020 Autodesk Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Autodesk Inc. nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL AUTODESK INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef __AMCTEST_UNITTEST_DATATABLE
+#define __AMCTEST_UNITTEST_DATATABLE
+
+#include "amc_unittests.hpp"
+#include "amc_unittests_libmcdata.hpp"
+#include "amc_constants.hpp"
+#include "amc_toolpathhandler.hpp"
+#include "common_chrono.hpp"
+#include "common_utils.hpp"
+
+#include "libmcenv_datatable.hpp"
+#include "libmcenv_tempstreamwriter.hpp"
+#include "libmcenv_streamreader.hpp"
+#include "libmcenv_interfaceexception.hpp"
+
+#include "lz4.h"
+
+#include <cmath>
+#include <cstdint>
+#include <cstring>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace AMCUnitTest {
+
+#pragma pack(push, 1)
+
+	// Byte-exact mirror of the version 1 stream layout. Used to hand-craft legacy (unversioned)
+	// and corrupted streams independently of the writer under test.
+	struct sDataTableTestStreamHeader {
+		uint32_t m_nSignature;
+		uint32_t m_nVersion;
+		uint64_t m_nColumnTableStart;
+		uint32_t m_nColumnCount;
+		uint32_t m_nReserved[8];
+	};
+
+	struct sDataTableTestColumnHeader {
+		uint32_t m_nColumnDataType;
+		uint32_t m_nEncodingType;
+		uint64_t m_nColumnDataStart;
+		uint64_t m_nIdentifierStart;
+		uint32_t m_nIdentifierLength;
+		uint64_t m_nDescriptionStart;
+		uint32_t m_nDescriptionLength;
+		uint64_t m_nEntryCount;
+		uint32_t m_nReserved[8];
+	};
+
+#pragma pack(pop)
+
+	static_assert(sizeof(sDataTableTestStreamHeader) == 52, "datatable stream header must be 52 bytes");
+	static_assert(sizeof(sDataTableTestColumnHeader) == 80, "datatable column header must be 80 bytes");
+
+	class CUnitTestGroup_DataTable : public CUnitTestGroup {
+	public:
+
+		std::string getTestGroupName() override {
+			return "DataTable";
+		}
+
+		void registerTests() override {
+			registerTest("ColumnManagement", "Adding, querying and removing columns of all types", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataTable::testColumnManagement, this));
+			registerTest("ColumnValuesInMemory", "Whole-column setters and getters, padding and type checks", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataTable::testColumnValuesInMemory, this));
+			registerTest("BinaryRoundTripAllTypes", "Format version 1 round trip through a storage stream", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataTable::testBinaryRoundTripAllTypes, this));
+			registerTest("LegacyUnversionedFileLoads", "Streams with version field 0 still load", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataTable::testLegacyUnversionedFileLoads, this));
+			registerTest("RejectsUnknownVersion", "Reader rejects unknown format versions", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataTable::testRejectsUnknownVersion, this));
+			registerTest("RejectsUnknownEncoding", "Reader rejects unknown column encodings", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataTable::testRejectsUnknownEncoding, this));
+			registerTest("RejectsInvalidSignature", "Reader rejects foreign signatures and invalid streams under the version 2 signature", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataTable::testRejectsInvalidSignature, this));
+			registerTest("RejectsTruncatedStream", "Reader reports truncated column data cleanly", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataTable::testRejectsTruncatedStream, this));
+			registerTest("CSVExport", "CSV export of all column types", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataTable::testCSVExport, this));
+			registerTest("EmptyTableRoundTrip", "Round trip of tables without columns or without rows", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataTable::testEmptyTableRoundTrip, this));
+			registerTest("LZ4RoundTrip", "Vendored LZ4 is linked and compresses/decompresses correctly", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataTable::testLZ4RoundTrip, this));
+		}
+
+		void initializeTests() override {
+		}
+
+	private:
+
+		struct SFixture {
+			LibMCData::PWrapper m_pDataWrapper;
+			LibMCData::PDataModel m_pDataModel;
+			AMC::PToolpathHandler m_pToolpathHandler;
+			AMCCommon::PChrono m_pChrono;
+			std::string m_sBasePath;
+		};
+
+		SFixture createFixture(const std::string& sSuffix)
+		{
+			SFixture fixture;
+
+			std::string sRootPath = "temp";
+			if (!AMCCommon::CUtils::fileOrPathExistsOnDisk(sRootPath))
+				AMCCommon::CUtils::createDirectoryOnDisk(sRootPath);
+
+			fixture.m_sBasePath = sRootPath + "/datatable_" + sSuffix + "_" + AMCCommon::CUtils::createUUID();
+			if (!AMCCommon::CUtils::fileOrPathExistsOnDisk(fixture.m_sBasePath))
+				AMCCommon::CUtils::createDirectoryOnDisk(fixture.m_sBasePath);
+
+			std::string sDatabaseFile = fixture.m_sBasePath + "/storage.db";
+
+			fixture.m_pDataWrapper = AMCUnitTest::loadLibMCDataInProcess();
+			fixture.m_pDataModel = fixture.m_pDataWrapper->CreateDataModelInstance();
+			fixture.m_pDataModel->InitialiseDatabase(fixture.m_sBasePath, LibMCData::eDataBaseType::SqLite, sDatabaseFile);
+			fixture.m_pToolpathHandler = std::make_shared<AMC::CToolpathHandler>(fixture.m_pDataModel);
+			fixture.m_pChrono = std::make_shared<AMCCommon::CChrono>();
+
+			return fixture;
+		}
+
+		std::unique_ptr<LibMCEnv::Impl::CDataTable> createTable(SFixture& fixture)
+		{
+			return std::make_unique<LibMCEnv::Impl::CDataTable>(fixture.m_pToolpathHandler);
+		}
+
+		std::unique_ptr<LibMCEnv::Impl::CTempStreamWriter> createWriter(SFixture& fixture, const std::string& sMIMEType)
+		{
+			return std::make_unique<LibMCEnv::Impl::CTempStreamWriter>(fixture.m_pDataModel, "datatable_test.dat", sMIMEType, AMCCommon::CUtils::createEmptyUUID(), fixture.m_pChrono);
+		}
+
+		std::unique_ptr<LibMCEnv::Impl::IStreamReader> writeBytes(SFixture& fixture, const std::vector<uint8_t>& bytes)
+		{
+			auto pWriter = createWriter(fixture, "application/amcf-datatable");
+			if (!bytes.empty())
+				pWriter->WriteData(bytes.size(), bytes.data());
+			pWriter->Finish();
+			return std::unique_ptr<LibMCEnv::Impl::IStreamReader>(pWriter->GetStreamReader());
+		}
+
+		std::vector<uint8_t> readAll(LibMCEnv::Impl::IStreamReader* pReader)
+		{
+			std::vector<uint8_t> bytes;
+			uint64_t nSize = pReader->GetSize();
+			bytes.resize((size_t)nSize);
+			if (nSize > 0) {
+				pReader->Seek(0);
+				pReader->ReadData(nSize, nSize, nullptr, bytes.data());
+			}
+			return bytes;
+		}
+
+		template <typename F>
+		int32_t errorCodeOf(F&& fn)
+		{
+			try {
+				fn();
+			}
+			catch (ELibMCEnvInterfaceException& e) {
+				return e.getErrorCode();
+			}
+			return 0;
+		}
+
+		bool nearlyEqual(double a, double b, double epsilon = 1.0e-9)
+		{
+			return std::fabs(a - b) < epsilon;
+		}
+
+		template <typename T>
+		void appendBytes(std::vector<uint8_t>& bytes, const T& value)
+		{
+			const uint8_t* pData = (const uint8_t*)&value;
+			bytes.insert(bytes.end(), pData, pData + sizeof(T));
+		}
+
+		// Builds a single double column stream in the version 1 layout with arbitrary header fields,
+		// so that legacy and corrupted variants can be produced without going through the writer.
+		std::vector<uint8_t> buildDoubleColumnStream(uint32_t nSignature, uint32_t nVersion, uint32_t nEncoding, const std::vector<double>& values, uint64_t nEntryCountOverride = UINT64_MAX)
+		{
+			std::string sIdentifier = "x";
+			std::string sDescription = "X value";
+
+			sDataTableTestStreamHeader header;
+			memset(&header, 0, sizeof(header));
+			header.m_nSignature = nSignature;
+			header.m_nVersion = nVersion;
+			header.m_nColumnTableStart = sizeof(header);
+			header.m_nColumnCount = 1;
+
+			sDataTableTestColumnHeader column;
+			memset(&column, 0, sizeof(column));
+			column.m_nColumnDataType = (uint32_t)LibMCEnv::eDataTableColumnType::DoubleColumn;
+			column.m_nEncodingType = nEncoding;
+
+			uint64_t nOffset = sizeof(header) + sizeof(column);
+			column.m_nIdentifierStart = nOffset;
+			column.m_nIdentifierLength = (uint32_t)sIdentifier.length();
+			nOffset += sIdentifier.length();
+			column.m_nDescriptionStart = nOffset;
+			column.m_nDescriptionLength = (uint32_t)sDescription.length();
+			nOffset += sDescription.length();
+			column.m_nColumnDataStart = nOffset;
+			column.m_nEntryCount = (nEntryCountOverride == UINT64_MAX) ? values.size() : nEntryCountOverride;
+
+			std::vector<uint8_t> bytes;
+			appendBytes(bytes, header);
+			appendBytes(bytes, column);
+			bytes.insert(bytes.end(), sIdentifier.begin(), sIdentifier.end());
+			bytes.insert(bytes.end(), sDescription.begin(), sDescription.end());
+			for (double dValue : values)
+				appendBytes(bytes, dValue);
+
+			return bytes;
+		}
+
+		void addAllColumnTypes(LibMCEnv::Impl::CDataTable* pTable)
+		{
+			pTable->AddColumn("d", "Double", LibMCEnv::eDataTableColumnType::DoubleColumn);
+			pTable->AddColumn("i32", "Int32", LibMCEnv::eDataTableColumnType::Int32Column);
+			pTable->AddColumn("u32", "Uint32", LibMCEnv::eDataTableColumnType::Uint32Column);
+			pTable->AddColumn("i64", "Int64", LibMCEnv::eDataTableColumnType::Int64Column);
+			pTable->AddColumn("u64", "Uint64", LibMCEnv::eDataTableColumnType::Uint64Column);
+			pTable->AddColumn("f", "Float", LibMCEnv::eDataTableColumnType::FloatColumn);
+			pTable->AddColumn("b", "Bool", LibMCEnv::eDataTableColumnType::BoolColumn);
+			pTable->AddColumn("t", "Timestamp", LibMCEnv::eDataTableColumnType::TimestampColumn);
+		}
+
+		void testColumnManagement()
+		{
+			auto fixture = createFixture("columns");
+			auto pTable = createTable(fixture);
+
+			assertTrue(pTable->GetColumnCount() == 0, "new table has no columns");
+			assertTrue(pTable->GetRowCount() == 0, "new table has no rows");
+			assertTrue(pTable->GetRowCount64() == 0, "new table has no rows (64 bit)");
+
+			addAllColumnTypes(pTable.get());
+
+			assertTrue(pTable->GetColumnCount() == 8, "eight columns added");
+			assertTrue(pTable->HasColumn("f"), "float column exists");
+			assertTrue(pTable->HasColumn("b"), "bool column exists");
+			assertTrue(pTable->HasColumn("t"), "timestamp column exists");
+			assertFalse(pTable->HasColumn("missing"), "unknown column does not exist");
+
+			assertTrue(pTable->GetColumnType(0) == LibMCEnv::eDataTableColumnType::DoubleColumn, "column 0 is double");
+			assertTrue(pTable->GetColumnType(5) == LibMCEnv::eDataTableColumnType::FloatColumn, "column 5 is float");
+			assertTrue(pTable->GetColumnType(6) == LibMCEnv::eDataTableColumnType::BoolColumn, "column 6 is bool");
+			assertTrue(pTable->GetColumnType(7) == LibMCEnv::eDataTableColumnType::TimestampColumn, "column 7 is timestamp");
+			assertTrue(pTable->GetColumnIdentifier(7) == "t", "column 7 identifier");
+			assertTrue(pTable->GetColumnDescription(7) == "Timestamp", "column 7 description");
+
+			std::string sDescription;
+			LibMCEnv::eDataTableColumnType eType = LibMCEnv::eDataTableColumnType::Unknown;
+			pTable->GetColumnInformation("b", sDescription, eType);
+			assertTrue(sDescription == "Bool", "column information description");
+			assertTrue(eType == LibMCEnv::eDataTableColumnType::BoolColumn, "column information type");
+
+			assertTrue(errorCodeOf([&]() { pTable->AddColumn("", "empty", LibMCEnv::eDataTableColumnType::DoubleColumn); }) == LIBMCENV_ERROR_COLUMNIDENTIFIEREMPTY, "empty identifier rejected");
+			assertTrue(errorCodeOf([&]() { pTable->AddColumn("bad id!", "invalid", LibMCEnv::eDataTableColumnType::DoubleColumn); }) == LIBMCENV_ERROR_INVALIDCOLUMNIDENTIFIER, "invalid identifier rejected");
+			assertTrue(errorCodeOf([&]() { pTable->AddColumn("d", "duplicate", LibMCEnv::eDataTableColumnType::DoubleColumn); }) == LIBMCENV_ERROR_DUPLICATECOLUMNIDENTIFIER, "duplicate identifier rejected");
+			assertTrue(errorCodeOf([&]() { pTable->AddColumn("unknown", "unknown type", (LibMCEnv::eDataTableColumnType)99); }) == LIBMCENV_ERROR_INVALIDCOLUMNDATATYPE, "unknown column type rejected");
+			assertTrue(errorCodeOf([&]() { pTable->GetColumnIdentifier(99); }) == LIBMCENV_ERROR_INVALIDCOLUMNINDEX, "column index out of range rejected");
+			assertTrue(errorCodeOf([&]() { pTable->RemoveColumn("missing"); }) == LIBMCENV_ERROR_COLUMNIDENTIFIERNOTFOUND, "removing unknown column rejected");
+
+			pTable->RemoveColumn("i32");
+			assertTrue(pTable->GetColumnCount() == 7, "column removed");
+			assertFalse(pTable->HasColumn("i32"), "removed column is gone");
+			assertTrue(pTable->GetColumnIdentifier(1) == "u32", "columns shift after removal");
+
+			pTable->Clear();
+			assertTrue(pTable->GetColumnCount() == 0, "clear removes all columns");
+		}
+
+		void testColumnValuesInMemory()
+		{
+			auto fixture = createFixture("values");
+			auto pTable = createTable(fixture);
+			addAllColumnTypes(pTable.get());
+
+			std::vector<double> doubles = { 1.5, -2.25, 3.0 };
+			std::vector<float> floats = { 0.5f, 100.25f };
+			std::vector<uint8_t> bools = { 0, 5, 1, 0 };
+			std::vector<uint64_t> timestamps = { 1000000ULL, 2000000ULL, 3000000ULL, 4000000ULL };
+			std::vector<int32_t> int32s = { -1, 2 };
+
+			pTable->SetDoubleColumnValues("d", doubles.size(), doubles.data());
+			assertTrue(pTable->GetRowCount() == 3, "row count follows the longest column");
+			pTable->SetFloatColumnValues("f", floats.size(), floats.data());
+			assertTrue(pTable->GetRowCount() == 3, "shorter column does not shrink the row count");
+			pTable->SetBoolColumnValues("b", bools.size(), bools.data());
+			pTable->SetTimestampColumnValues("t", timestamps.size(), timestamps.data());
+			pTable->SetInt32ColumnValues("i32", int32s.size(), int32s.data());
+			assertTrue(pTable->GetRowCount() == 4, "row count grows with the longest column");
+			assertTrue(pTable->GetRowCount64() == 4, "64 bit row count matches");
+
+			uint64_t nNeeded = 0;
+			pTable->GetFloatColumnValues("f", 0, &nNeeded, nullptr);
+			assertTrue(nNeeded == 4, "needed count is the table row count");
+
+			std::vector<float> floatsOut(4, -1.0f);
+			pTable->GetFloatColumnValues("f", floatsOut.size(), nullptr, floatsOut.data());
+			assertTrue(floatsOut[0] == 0.5f && floatsOut[1] == 100.25f, "float values round trip");
+			assertTrue(floatsOut[2] == 0.0f && floatsOut[3] == 0.0f, "missing float rows are padded with zero");
+
+			std::vector<uint8_t> boolsOut(4, 7);
+			pTable->GetBoolColumnValues("b", boolsOut.size(), nullptr, boolsOut.data());
+			assertTrue(boolsOut[0] == 0 && boolsOut[1] == 1 && boolsOut[2] == 1 && boolsOut[3] == 0, "bool values are normalised to 0 and 1");
+
+			std::vector<uint64_t> timestampsOut(4, 0);
+			pTable->GetTimestampColumnValues("t", timestampsOut.size(), nullptr, timestampsOut.data());
+			assertTrue(timestampsOut == timestamps, "timestamp values round trip");
+
+			std::vector<double> doublesOut(4, -1.0);
+			pTable->GetDoubleColumnValues("d", doublesOut.size(), nullptr, doublesOut.data());
+			assertTrue(nearlyEqual(doublesOut[1], -2.25) && nearlyEqual(doublesOut[3], 0.0), "double values round trip with padding");
+
+			std::vector<float> tooSmall(2);
+			assertTrue(errorCodeOf([&]() { pTable->GetFloatColumnValues("f", tooSmall.size(), nullptr, tooSmall.data()); }) == LIBMCENV_ERROR_BUFFERTOOSMALL, "small buffer rejected");
+			assertTrue(errorCodeOf([&]() { pTable->GetFloatColumnValues("d", floatsOut.size(), nullptr, floatsOut.data()); }) == LIBMCENV_ERROR_COLUMNISNOTOFTYPEFLOAT, "float getter on double column rejected");
+			assertTrue(errorCodeOf([&]() { pTable->GetBoolColumnValues("d", boolsOut.size(), nullptr, boolsOut.data()); }) == LIBMCENV_ERROR_COLUMNISNOTOFTYPEBOOL, "bool getter on double column rejected");
+			assertTrue(errorCodeOf([&]() { pTable->GetTimestampColumnValues("d", timestampsOut.size(), nullptr, timestampsOut.data()); }) == LIBMCENV_ERROR_COLUMNISNOTOFTYPETIMESTAMP, "timestamp getter on double column rejected");
+			assertTrue(errorCodeOf([&]() { pTable->SetDoubleColumnValues("f", doubles.size(), doubles.data()); }) == LIBMCENV_ERROR_COLUMNISNOTOFTYPEDOUBLE, "double setter on float column rejected");
+			assertTrue(errorCodeOf([&]() { pTable->SetFloatColumnValues("t", floats.size(), floats.data()); }) == LIBMCENV_ERROR_COLUMNISNOTOFTYPEFLOAT, "float setter on timestamp column rejected");
+			assertTrue(errorCodeOf([&]() { pTable->SetBoolColumnValues("missing", bools.size(), bools.data()); }) == LIBMCENV_ERROR_COLUMNIDENTIFIERNOTFOUND, "setter on unknown column rejected");
+
+			pTable->Clear();
+			assertTrue(pTable->GetRowCount64() == 0, "clear resets the row count");
+		}
+
+		void testBinaryRoundTripAllTypes()
+		{
+			auto fixture = createFixture("roundtrip");
+			auto pTable = createTable(fixture);
+			addAllColumnTypes(pTable.get());
+
+			std::vector<double> doubles = { 1.5, -2.25, 3.0, 4.125, 1.0e6 };
+			std::vector<int32_t> int32s = { -1, 2, -3, 4, 5 };
+			std::vector<uint32_t> uint32s = { 1, 2, 3, 4, 4000000000U };
+			std::vector<int64_t> int64s = { -10, 20, -30, 40, 50 };
+			std::vector<uint64_t> uint64s = { 10, 20, 30, 40, 50 };
+			std::vector<float> floats = { 0.5f, 1.5f, 2.5f, 3.5f, 4.5f };
+			std::vector<uint8_t> bools = { 1, 0, 1, 1, 0 };
+			std::vector<uint64_t> timestamps = { 1000000ULL, 2000000ULL, 3000000ULL, 4000000ULL, 5000000ULL };
+
+			pTable->SetDoubleColumnValues("d", doubles.size(), doubles.data());
+			pTable->SetInt32ColumnValues("i32", int32s.size(), int32s.data());
+			pTable->SetUint32ColumnValues("u32", uint32s.size(), uint32s.data());
+			pTable->SetInt64ColumnValues("i64", int64s.size(), int64s.data());
+			pTable->SetUint64ColumnValues("u64", uint64s.size(), uint64s.data());
+			pTable->SetFloatColumnValues("f", floats.size(), floats.data());
+			pTable->SetBoolColumnValues("b", bools.size(), bools.data());
+			pTable->SetTimestampColumnValues("t", timestamps.size(), timestamps.data());
+
+			auto pWriter = createWriter(fixture, "application/amcf-datatable");
+			pTable->WriteDataToStream(pWriter.get(), nullptr);
+			pWriter->Finish();
+
+			std::unique_ptr<LibMCEnv::Impl::IStreamReader> pReader(pWriter->GetStreamReader());
+
+			// The writer populates the version field; the signature is unchanged for format version 1.
+			auto bytes = readAll(pReader.get());
+			assertTrue(bytes.size() > sizeof(sDataTableTestStreamHeader), "stream contains a header");
+			sDataTableTestStreamHeader header;
+			memcpy(&header, bytes.data(), sizeof(header));
+			assertTrue(header.m_nSignature == DATATABLE_HEADERSIGNATURE, "written signature is the v1 signature");
+			assertTrue(header.m_nVersion == DATATABLE_FORMATVERSION_1, "written version field is 1");
+			assertTrue(header.m_nColumnCount == 8, "written column count");
+			assertTrue(header.m_nColumnTableStart == sizeof(sDataTableTestStreamHeader), "column table follows the header");
+
+			sDataTableTestColumnHeader firstColumn;
+			memcpy(&firstColumn, bytes.data() + header.m_nColumnTableStart, sizeof(firstColumn));
+			assertTrue(firstColumn.m_nEncodingType == DATATABLE_ENCODINGTYPE_RAW, "columns are written with RAW encoding");
+			assertTrue(firstColumn.m_nEntryCount == 5, "first column entry count");
+
+			auto pLoaded = createTable(fixture);
+			pLoaded->LoadFromStream(pReader.get());
+
+			assertTrue(pLoaded->GetColumnCount() == 8, "loaded column count");
+			assertTrue(pLoaded->GetRowCount64() == 5, "loaded row count");
+			for (uint32_t nIndex = 0; nIndex < 8; nIndex++) {
+				assertTrue(pLoaded->GetColumnIdentifier(nIndex) == pTable->GetColumnIdentifier(nIndex), "loaded identifier " + std::to_string(nIndex));
+				assertTrue(pLoaded->GetColumnDescription(nIndex) == pTable->GetColumnDescription(nIndex), "loaded description " + std::to_string(nIndex));
+				assertTrue(pLoaded->GetColumnType(nIndex) == pTable->GetColumnType(nIndex), "loaded type " + std::to_string(nIndex));
+			}
+
+			std::vector<double> doublesOut(5);
+			pLoaded->GetDoubleColumnValues("d", doublesOut.size(), nullptr, doublesOut.data());
+			assertTrue(doublesOut == doubles, "double column round trip");
+			std::vector<int32_t> int32sOut(5);
+			pLoaded->GetInt32ColumnValues("i32", int32sOut.size(), nullptr, int32sOut.data());
+			assertTrue(int32sOut == int32s, "int32 column round trip");
+			std::vector<uint32_t> uint32sOut(5);
+			pLoaded->GetUint32ColumnValues("u32", uint32sOut.size(), nullptr, uint32sOut.data());
+			assertTrue(uint32sOut == uint32s, "uint32 column round trip");
+			std::vector<int64_t> int64sOut(5);
+			pLoaded->GetInt64ColumnValues("i64", int64sOut.size(), nullptr, int64sOut.data());
+			assertTrue(int64sOut == int64s, "int64 column round trip");
+			std::vector<uint64_t> uint64sOut(5);
+			pLoaded->GetUint64ColumnValues("u64", uint64sOut.size(), nullptr, uint64sOut.data());
+			assertTrue(uint64sOut == uint64s, "uint64 column round trip");
+			std::vector<float> floatsOut(5);
+			pLoaded->GetFloatColumnValues("f", floatsOut.size(), nullptr, floatsOut.data());
+			assertTrue(floatsOut == floats, "float column round trip");
+			std::vector<uint8_t> boolsOut(5);
+			pLoaded->GetBoolColumnValues("b", boolsOut.size(), nullptr, boolsOut.data());
+			assertTrue(boolsOut == bools, "bool column round trip");
+			std::vector<uint64_t> timestampsOut(5);
+			pLoaded->GetTimestampColumnValues("t", timestampsOut.size(), nullptr, timestampsOut.data());
+			assertTrue(timestampsOut == timestamps, "timestamp column round trip");
+		}
+
+		void testLegacyUnversionedFileLoads()
+		{
+			auto fixture = createFixture("legacy");
+			std::vector<double> values = { 1.5, -2.25, 3.0 };
+
+			auto bytes = buildDoubleColumnStream(DATATABLE_HEADERSIGNATURE, DATATABLE_FORMATVERSION_UNVERSIONED, DATATABLE_ENCODINGTYPE_RAW, values);
+			auto pReader = writeBytes(fixture, bytes);
+
+			auto pTable = createTable(fixture);
+			pTable->LoadFromStream(pReader.get());
+
+			assertTrue(pTable->GetColumnCount() == 1, "legacy stream has one column");
+			assertTrue(pTable->GetRowCount64() == 3, "legacy stream has three rows");
+			assertTrue(pTable->GetColumnIdentifier(0) == "x", "legacy column identifier");
+			assertTrue(pTable->GetColumnDescription(0) == "X value", "legacy column description");
+			assertTrue(pTable->GetColumnType(0) == LibMCEnv::eDataTableColumnType::DoubleColumn, "legacy column type");
+
+			std::vector<double> valuesOut(3);
+			pTable->GetDoubleColumnValues("x", valuesOut.size(), nullptr, valuesOut.data());
+			assertTrue(valuesOut == values, "legacy values load unchanged");
+
+			// Version 1 with an explicit version field loads identically.
+			auto bytesV1 = buildDoubleColumnStream(DATATABLE_HEADERSIGNATURE, DATATABLE_FORMATVERSION_1, DATATABLE_ENCODINGTYPE_RAW, values);
+			auto pReaderV1 = writeBytes(fixture, bytesV1);
+			pTable->LoadFromStream(pReaderV1.get());
+			assertTrue(pTable->GetRowCount64() == 3, "explicit version 1 stream loads");
+		}
+
+		void testRejectsUnknownVersion()
+		{
+			auto fixture = createFixture("version");
+			std::vector<double> values = { 1.0, 2.0 };
+
+			auto bytes = buildDoubleColumnStream(DATATABLE_HEADERSIGNATURE, 7, DATATABLE_ENCODINGTYPE_RAW, values);
+			auto pReader = writeBytes(fixture, bytes);
+
+			auto pTable = createTable(fixture);
+			pTable->AddColumn("stale", "Stale column", LibMCEnv::eDataTableColumnType::Int32Column);
+
+			int32_t nErrorCode = errorCodeOf([&]() { pTable->LoadFromStream(pReader.get()); });
+			assertTrue(nErrorCode == LIBMCENV_ERROR_UNSUPPORTEDDATATABLEVERSION, "unknown version rejected with UNSUPPORTEDDATATABLEVERSION, got " + std::to_string(nErrorCode));
+			assertTrue(pTable->GetColumnCount() == 0, "table is empty after a rejected load");
+		}
+
+		void testRejectsUnknownEncoding()
+		{
+			auto fixture = createFixture("encoding");
+			std::vector<double> values = { 1.0, 2.0 };
+
+			auto bytes = buildDoubleColumnStream(DATATABLE_HEADERSIGNATURE, DATATABLE_FORMATVERSION_1, 2, values);
+			auto pReader = writeBytes(fixture, bytes);
+
+			auto pTable = createTable(fixture);
+			int32_t nErrorCode = errorCodeOf([&]() { pTable->LoadFromStream(pReader.get()); });
+			assertTrue(nErrorCode == LIBMCENV_ERROR_UNSUPPORTEDDATATABLEENCODING, "unknown encoding rejected with UNSUPPORTEDDATATABLEENCODING, got " + std::to_string(nErrorCode));
+			assertTrue(pTable->GetColumnCount() == 0, "no partially loaded columns remain");
+		}
+
+		void testRejectsInvalidSignature()
+		{
+			auto fixture = createFixture("signature");
+			std::vector<double> values = { 1.0 };
+
+			auto bytesForeign = buildDoubleColumnStream(0x12345678, DATATABLE_FORMATVERSION_1, DATATABLE_ENCODINGTYPE_RAW, values);
+			auto pReaderForeign = writeBytes(fixture, bytesForeign);
+			auto pTable = createTable(fixture);
+			int32_t nErrorCode = errorCodeOf([&]() { pTable->LoadFromStream(pReaderForeign.get()); });
+			assertTrue(nErrorCode == LIBMCENV_ERROR_INVALIDDATATABLESIGNATURE, "foreign signature rejected, got " + std::to_string(nErrorCode));
+
+			// The version 2 signature selects the chunked format. A stream that carries it with a version 1 layout
+			// is not a valid segment, and a later format version is reported as unsupported. Neither is read as garbage.
+			auto bytesV2 = buildDoubleColumnStream(DATATABLE_HEADERSIGNATURE_V2, 2, DATATABLE_ENCODINGTYPE_RAW, values);
+			auto pReaderV2 = writeBytes(fixture, bytesV2);
+			nErrorCode = errorCodeOf([&]() { pTable->LoadFromStream(pReaderV2.get()); });
+			assertTrue(nErrorCode == LIBMCENV_ERROR_INVALIDDATATABLESEGMENT, "version 1 layout under the version 2 signature is rejected as invalid segment, got " + std::to_string(nErrorCode));
+			assertTrue(pTable->GetColumnCount() == 0, "table stays empty");
+
+			auto bytesV3 = buildDoubleColumnStream(DATATABLE_HEADERSIGNATURE_V2, 3, DATATABLE_ENCODINGTYPE_RAW, values);
+			auto pReaderV3 = writeBytes(fixture, bytesV3);
+			nErrorCode = errorCodeOf([&]() { pTable->LoadFromStream(pReaderV3.get()); });
+			assertTrue(nErrorCode == LIBMCENV_ERROR_UNSUPPORTEDDATATABLEVERSION, "later format version is rejected as unsupported version, got " + std::to_string(nErrorCode));
+			assertTrue(pTable->GetColumnCount() == 0, "table stays empty");
+		}
+
+		void testRejectsTruncatedStream()
+		{
+			auto fixture = createFixture("truncated");
+			std::vector<double> values = { 1.0, 2.0, 3.0 };
+
+			// The column header claims far more entries than the payload holds.
+			auto bytes = buildDoubleColumnStream(DATATABLE_HEADERSIGNATURE, DATATABLE_FORMATVERSION_1, DATATABLE_ENCODINGTYPE_RAW, values, 1000);
+			auto pReader = writeBytes(fixture, bytes);
+
+			auto pTable = createTable(fixture);
+			int32_t nErrorCode = errorCodeOf([&]() { pTable->LoadFromStream(pReader.get()); });
+			assertTrue(nErrorCode == LIBMCENV_ERROR_INVALIDDATATABLECOLUMNHEADER, "truncated column data rejected cleanly, got " + std::to_string(nErrorCode));
+			assertTrue(pTable->GetColumnCount() == 0, "no partially loaded columns remain after truncation");
+
+			// A stream that ends inside the column table is rejected by the stream reader, not by reading garbage.
+			std::vector<uint8_t> cut(bytes.begin(), bytes.begin() + sizeof(sDataTableTestStreamHeader) + 10);
+			auto pReaderCut = writeBytes(fixture, cut);
+			nErrorCode = errorCodeOf([&]() { pTable->LoadFromStream(pReaderCut.get()); });
+			assertTrue(nErrorCode == LIBMCENV_ERROR_STREAMREADEXCEEDSSTREAMSIZE, "stream cut inside the column table is rejected by the stream reader, got " + std::to_string(nErrorCode));
+			assertTrue(pTable->GetColumnCount() == 0, "table stays empty after a cut stream");
+		}
+
+		void testCSVExport()
+		{
+			auto fixture = createFixture("csv");
+			auto pTable = createTable(fixture);
+			pTable->AddColumn("d", "Double", LibMCEnv::eDataTableColumnType::DoubleColumn);
+			pTable->AddColumn("f", "Float", LibMCEnv::eDataTableColumnType::FloatColumn);
+			pTable->AddColumn("b", "Bool", LibMCEnv::eDataTableColumnType::BoolColumn);
+			pTable->AddColumn("t", "Timestamp", LibMCEnv::eDataTableColumnType::TimestampColumn);
+			pTable->AddColumn("u", "Uint32", LibMCEnv::eDataTableColumnType::Uint32Column);
+
+			std::vector<double> doubles = { 1.5, -0.5 };
+			std::vector<float> floats = { 2.25f, 0.125f };
+			std::vector<uint8_t> bools = { 1, 0 };
+			std::vector<uint64_t> timestamps = { 1000000ULL, 2000000ULL };
+			std::vector<uint32_t> uint32s = { 7, 8 };
+			pTable->SetDoubleColumnValues("d", doubles.size(), doubles.data());
+			pTable->SetFloatColumnValues("f", floats.size(), floats.data());
+			pTable->SetBoolColumnValues("b", bools.size(), bools.data());
+			pTable->SetTimestampColumnValues("t", timestamps.size(), timestamps.data());
+			pTable->SetUint32ColumnValues("u", uint32s.size(), uint32s.data());
+
+			auto pWriter = createWriter(fixture, "text/csv");
+			pTable->WriteCSVToStream(pWriter.get(), nullptr);
+			pWriter->Finish();
+
+			std::unique_ptr<LibMCEnv::Impl::IStreamReader> pReader(pWriter->GetStreamReader());
+			auto bytes = readAll(pReader.get());
+			std::string sCSV(bytes.begin(), bytes.end());
+
+			std::string sExpected = "Double;Float;Bool;Timestamp;Uint32\n1.500;2.250;1;1000000;7\n-0.500;0.125;0;2000000;8\n";
+			assertTrue(sCSV == sExpected, "CSV export matches, got: " + sCSV);
+		}
+
+		void testEmptyTableRoundTrip()
+		{
+			auto fixture = createFixture("empty");
+
+			auto pEmpty = createTable(fixture);
+			auto pWriter = createWriter(fixture, "application/amcf-datatable");
+			pEmpty->WriteDataToStream(pWriter.get(), nullptr);
+			pWriter->Finish();
+			std::unique_ptr<LibMCEnv::Impl::IStreamReader> pReader(pWriter->GetStreamReader());
+			assertTrue(pReader->GetSize() == sizeof(sDataTableTestStreamHeader), "empty table is a bare header");
+
+			auto pLoaded = createTable(fixture);
+			pLoaded->AddColumn("stale", "Stale column", LibMCEnv::eDataTableColumnType::Int32Column);
+			pLoaded->LoadFromStream(pReader.get());
+			assertTrue(pLoaded->GetColumnCount() == 0, "loading an empty stream clears the table");
+			assertTrue(pLoaded->GetRowCount64() == 0, "empty table has no rows");
+
+			auto pColumnsOnly = createTable(fixture);
+			pColumnsOnly->AddColumn("f", "Float", LibMCEnv::eDataTableColumnType::FloatColumn);
+			pColumnsOnly->AddColumn("b", "Bool", LibMCEnv::eDataTableColumnType::BoolColumn);
+			auto pWriter2 = createWriter(fixture, "application/amcf-datatable");
+			pColumnsOnly->WriteDataToStream(pWriter2.get(), nullptr);
+			pWriter2->Finish();
+			std::unique_ptr<LibMCEnv::Impl::IStreamReader> pReader2(pWriter2->GetStreamReader());
+
+			pLoaded->LoadFromStream(pReader2.get());
+			assertTrue(pLoaded->GetColumnCount() == 2, "columns without rows round trip");
+			assertTrue(pLoaded->GetRowCount64() == 0, "columns without rows have zero rows");
+			assertTrue(pLoaded->GetColumnType(0) == LibMCEnv::eDataTableColumnType::FloatColumn, "float column type survives");
+			assertTrue(pLoaded->GetColumnType(1) == LibMCEnv::eDataTableColumnType::BoolColumn, "bool column type survives");
+		}
+
+		void testLZ4RoundTrip()
+		{
+			std::vector<uint8_t> input(64 * 1024);
+			for (size_t nIndex = 0; nIndex < input.size(); nIndex++)
+				input[nIndex] = (uint8_t)((nIndex / 64) & 0xff);
+
+			int nBound = LZ4_compressBound((int)input.size());
+			assertTrue(nBound > 0, "LZ4 compress bound is positive");
+
+			std::vector<char> compressed((size_t)nBound);
+			int nCompressedSize = LZ4_compress_default((const char*)input.data(), compressed.data(), (int)input.size(), nBound);
+			assertTrue(nCompressedSize > 0, "LZ4 compression succeeds");
+			assertTrue((size_t)nCompressedSize < input.size(), "LZ4 shrinks the repetitive input");
+
+			std::vector<uint8_t> output(input.size());
+			int nDecompressedSize = LZ4_decompress_safe(compressed.data(), (char*)output.data(), nCompressedSize, (int)output.size());
+			assertTrue(nDecompressedSize == (int)input.size(), "LZ4 decompression restores the original size");
+			assertTrue(output == input, "LZ4 decompression restores the original bytes");
+		}
+
+	};
+
+}
+
+#endif // __AMCTEST_UNITTEST_DATATABLE
diff --git a/Implementation/UnitTest/amc_unittests_datatableencoding.hpp b/Implementation/UnitTest/amc_unittests_datatableencoding.hpp
new file mode 100644
index 000000000..32c38865e
--- /dev/null
+++ b/Implementation/UnitTest/amc_unittests_datatableencoding.hpp
@@ -0,0 +1,619 @@
+/*++
+
+Copyright (C) 2020 Autodesk Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Autodesk Inc. nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL AUTODESK INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef __AMCTEST_UNITTEST_DATATABLEENCODING
+#define __AMCTEST_UNITTEST_DATATABLEENCODING
+
+#include "amc_unittests.hpp"
+#include "amc_constants.hpp"
+#include "amc_datatableformat.hpp"
+#include "amc_datatableencoding.hpp"
+
+#include <cmath>
+#include <cstdint>
+#include <cstring>
+#include <limits>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+namespace AMCUnitTest {
+
+	class CUnitTestGroup_DataTableEncoding : public CUnitTestGroup {
+	public:
+
+		std::string getTestGroupName() override {
+			return "DataTableEncoding";
+		}
+
+		void registerTests() override {
+			registerTest("DeltaKnownAnswers", "Delta encoding produces the byte layout of Parquet DELTA_BINARY_PACKED", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataTableEncoding::testDeltaKnownAnswers, this));
+			registerTest("DeltaRoundTrip", "Delta encoding round trip across block boundaries and value extremes", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataTableEncoding::testDeltaRoundTrip, this));
+			registerTest("DeltaFixedRateClock", "A fixed-rate clock deltas to almost nothing", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataTableEncoding::testDeltaFixedRateClock, this));
+			registerTest("DeltaCorruptData", "Corrupt and truncated delta data is rejected", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataTableEncoding::testDeltaCorruptData, this));
+			registerTest("BitPack", "Bool bit packing round trip", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataTableEncoding::testBitPack, this));
+			registerTest("Codecs", "LZ4 and deflate page compression", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataTableEncoding::testCodecs, this));
+			registerTest("EncodedChunkRoundTrip", "A chunk with all encodings and codecs is read back", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataTableEncoding::testEncodedChunkRoundTrip, this));
+			registerTest("FallbackToPlain", "Pages that do not get smaller stay plain and uncompressed", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataTableEncoding::testFallbackToPlain, this));
+			registerTest("EncodingValidation", "Encodings that do not fit the column type are rejected on write and read", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataTableEncoding::testEncodingValidation, this));
+		}
+
+		void initializeTests() override {
+		}
+
+	private:
+
+		template <typename F>
+		uint32_t formatErrorOf(F&& fn)
+		{
+			try {
+				fn();
+			}
+			catch (AMC::EDataTableFormatException& formatException) {
+				return (uint32_t)formatException.getError();
+			}
+			return 0;
+		}
+
+		AMC::CDataTableV2SegmentReader::ReadCallback memoryReader(const std::vector<uint8_t>& bytes)
+		{
+			return [&bytes](uint64_t nOffset, uint64_t nSize, uint8_t* pBuffer) {
+				if ((nOffset > bytes.size()) || (nSize > bytes.size() - nOffset))
+					throw std::out_of_range("segment reader read outside of the stream");
+				if (nSize > 0)
+					memcpy(pBuffer, bytes.data() + nOffset, (size_t)nSize);
+			};
+		}
+
+		// Deterministic pseudo random numbers, so that the tests are reproducible.
+		uint64_t nextRandom(uint64_t& nState)
+		{
+			nState = nState * 6364136223846793005ULL + 1442695040888963407ULL;
+			return nState ^ (nState >> 29);
+		}
+
+		void assertDeltaRoundTrip(const std::vector<int64_t>& values, const std::string& sContext)
+		{
+			std::vector<uint8_t> encoded;
+			AMC::CDataTableEncoding::encodeDelta(values.data(), values.size(), encoded);
+
+			std::vector<int64_t> decoded(values.size(), -1);
+			AMC::CDataTableEncoding::decodeDelta(encoded.data(), encoded.size(), decoded.data(), decoded.size());
+
+			assertTrue(decoded == values, "delta round trip: " + sContext);
+		}
+
+		void testDeltaKnownAnswers()
+		{
+			// The examples of the Parquet format specification, with the block layout of this implementation:
+			// blocks of 128 values in 4 miniblocks.
+			{
+				std::vector<int64_t> values = { 1, 2, 3, 4, 5 };
+				std::vector<uint8_t> encoded;
+				AMC::CDataTableEncoding::encodeDelta(values.data(), values.size(), encoded);
+
+				// block size 128, 4 miniblocks, 5 values, first value 1 (zigzag 2),
+				// block: min delta 1 (zigzag 2), bit widths 0 0 0 0, no miniblock data
+				std::vector<uint8_t> expected = { 0x80, 0x01, 0x04, 0x05, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00 };
+				assertTrue(encoded == expected, "constant delta sequence has the specified layout");
+			}
+
+			{
+				std::vector<int64_t> values = { 7, 5, 3, 1, 2, 3, 4, 5 };
+				std::vector<uint8_t> encoded;
+				AMC::CDataTableEncoding::encodeDelta(values.data(), values.size(), encoded);
+
+				// deltas -2 -2 -2 1 1 1 1, min delta -2 (zigzag 3), relative deltas 0 0 0 3 3 3 3 on 2 bits,
+				// packed least significant bit first and padded to a full miniblock of 32 values
+				std::vector<uint8_t> expected = { 0x80, 0x01, 0x04, 0x08, 0x0E, 0x03, 0x02, 0x00, 0x00, 0x00, 0xC0, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+				assertTrue(encoded == expected, "mixed delta sequence has the specified layout");
+			}
+		}
+
+		void testDeltaRoundTrip()
+		{
+			assertDeltaRoundTrip({}, "empty");
+			assertDeltaRoundTrip({ 42 }, "single value");
+			assertDeltaRoundTrip({ -5, -5 }, "two equal values");
+			assertDeltaRoundTrip({ (std::numeric_limits<int64_t>::min)(), (std::numeric_limits<int64_t>::max)(), 0, -1, 1 }, "value extremes with wrapping deltas");
+
+			// Lengths around miniblock and block boundaries
+			for (size_t nCount : { 2, 31, 32, 33, 34, 64, 65, 128, 129, 130, 161, 256, 257, 258, 1000, 4097 }) {
+				std::vector<int64_t> ramp(nCount);
+				for (size_t nIndex = 0; nIndex < nCount; nIndex++)
+					ramp[nIndex] = 1000 + (int64_t)nIndex * 7;
+				assertDeltaRoundTrip(ramp, "ramp of " + std::to_string(nCount));
+
+				uint64_t nState = 12345 + nCount;
+				std::vector<int64_t> noisy(nCount);
+				int64_t nValue = 0;
+				for (size_t nIndex = 0; nIndex < nCount; nIndex++) {
+					nValue += (int64_t)(nextRandom(nState) % 2001) - 1000;
+					noisy[nIndex] = nValue;
+				}
+				assertDeltaRoundTrip(noisy, "random walk of " + std::to_string(nCount));
+
+				std::vector<int64_t> random(nCount);
+				for (size_t nIndex = 0; nIndex < nCount; nIndex++)
+					random[nIndex] = (int64_t)nextRandom(nState);
+				assertDeltaRoundTrip(random, "full range random values of " + std::to_string(nCount));
+			}
+		}
+
+		void testDeltaFixedRateClock()
+		{
+			// 65536 timestamps of a 100 kHz clock in microseconds
+			std::vector<int64_t> timestamps(65536);
+			for (size_t nIndex = 0; nIndex < timestamps.size(); nIndex++)
+				timestamps[nIndex] = 1700000000000000LL + (int64_t)nIndex * 10;
+
+			std::vector<uint8_t> encoded;
+			AMC::CDataTableEncoding::encodeDelta(timestamps.data(), timestamps.size(), encoded);
+
+			size_t nPlainSize = timestamps.size() * sizeof(int64_t);
+			assertTrue(encoded.size() * 100 < nPlainSize, "fixed-rate clock encodes to less than one percent, got " + std::to_string(encoded.size()) + " of " + std::to_string(nPlainSize) + " bytes");
+
+			std::vector<int64_t> decoded(timestamps.size());
+			AMC::CDataTableEncoding::decodeDelta(encoded.data(), encoded.size(), decoded.data(), decoded.size());
+			assertTrue(decoded == timestamps, "fixed-rate clock round trip");
+		}
+
+		void testDeltaCorruptData()
+		{
+			uint64_t nState = 99;
+			std::vector<int64_t> values(300);
+			for (auto& nValue : values)
+				nValue = (int64_t)(nextRandom(nState) % 100000);
+
+			std::vector<uint8_t> encoded;
+			AMC::CDataTableEncoding::encodeDelta(values.data(), values.size(), encoded);
+
+			std::vector<int64_t> decoded(values.size());
+			uint32_t nCorrupt = (uint32_t)AMC::eDataTableFormatError::Corrupt;
+
+			// Every truncation is rejected.
+			for (size_t nCutSize = 0; nCutSize < encoded.size(); nCutSize++) {
+				std::vector<uint8_t> cut(encoded.begin(), encoded.begin() + nCutSize);
+				cut.reserve(1);
+				uint32_t nError = formatErrorOf([&]() { AMC::CDataTableEncoding::decodeDelta(cut.data(), cut.size(), decoded.data(), decoded.size()); });
+				assertTrue((nError == nCorrupt) || ((nCutSize == 0) && (nError == (uint32_t)AMC::eDataTableFormatError::InvalidParam)), "delta data cut at " + std::to_string(nCutSize) + " is rejected, got " + std::to_string(nError));
+			}
+
+			// A different number of values than the page directory states is rejected.
+			std::vector<int64_t> tooFew(values.size() - 1);
+			assertTrue(formatErrorOf([&]() { AMC::CDataTableEncoding::decodeDelta(encoded.data(), encoded.size(), tooFew.data(), tooFew.size()); }) == nCorrupt, "value count mismatch is rejected");
+
+			// An invalid bit width is rejected. The first width byte follows the header and the minimum delta.
+			{
+				std::vector<int64_t> fewValues = { 1, 2, 3, 4, 5 };
+				std::vector<uint8_t> smallEncoded;
+				AMC::CDataTableEncoding::encodeDelta(fewValues.data(), fewValues.size(), smallEncoded);
+				smallEncoded[6] = 65;
+				std::vector<int64_t> smallDecoded(5);
+				assertTrue(formatErrorOf([&]() { AMC::CDataTableEncoding::decodeDelta(smallEncoded.data(), smallEncoded.size(), smallDecoded.data(), smallDecoded.size()); }) == nCorrupt, "bit width above 64 is rejected");
+			}
+
+			// An invalid block layout is rejected.
+			{
+				std::vector<uint8_t> invalidLayout = { 0x00, 0x04, 0x01, 0x02 };
+				std::vector<int64_t> one(1);
+				assertTrue(formatErrorOf([&]() { AMC::CDataTableEncoding::decodeDelta(invalidLayout.data(), invalidLayout.size(), one.data(), one.size()); }) == nCorrupt, "zero block size is rejected");
+			}
+		}
+
+		void testBitPack()
+		{
+			for (size_t nCount : { 0, 1, 7, 8, 9, 63, 64, 65, 1000 }) {
+				std::vector<uint8_t> values(nCount);
+				for (size_t nIndex = 0; nIndex < nCount; nIndex++)
+					values[nIndex] = ((nIndex % 3) == 0) ? (uint8_t)((nIndex % 200) + 1) : 0;
+
+				std::vector<uint8_t> packed;
+				AMC::CDataTableEncoding::encodeBitPack(values.data(), values.size(), packed);
+				assertTrue(packed.size() == (nCount + 7) / 8, "bit packed size of " + std::to_string(nCount) + " values");
+				assertTrue(packed.size() == AMC::CDataTableEncoding::getBitPackSize(nCount), "bit packed size matches the prediction");
+
+				std::vector<uint8_t> unpacked(nCount, 7);
+				unpacked.reserve(1);
+				packed.reserve(1);
+				AMC::CDataTableEncoding::decodeBitPack(packed.data(), packed.size(), unpacked.data(), unpacked.size());
+				for (size_t nIndex = 0; nIndex < nCount; nIndex++)
+					assertTrue(unpacked[nIndex] == (((nIndex % 3) == 0) ? 1 : 0), "bit " + std::to_string(nIndex) + " of " + std::to_string(nCount));
+			}
+
+			// Least significant bit first
+			std::vector<uint8_t> pattern = { 1, 0, 0, 0, 0, 0, 0, 1, 1 };
+			std::vector<uint8_t> packed;
+			AMC::CDataTableEncoding::encodeBitPack(pattern.data(), pattern.size(), packed);
+			assertTrue((packed.size() == 2) && (packed[0] == 0x81) && (packed[1] == 0x01), "bits are packed least significant bit first");
+
+			std::vector<uint8_t> unpacked(9);
+			assertTrue(formatErrorOf([&]() { AMC::CDataTableEncoding::decodeBitPack(packed.data(), 1, unpacked.data(), unpacked.size()); }) == (uint32_t)AMC::eDataTableFormatError::Corrupt, "bit packed data of the wrong size is rejected");
+		}
+
+		void testCodecs()
+		{
+			// Compressible data: a slowly changing byte pattern
+			std::vector<uint8_t> compressible(100000);
+			for (size_t nIndex = 0; nIndex < compressible.size(); nIndex++)
+				compressible[nIndex] = (uint8_t)((nIndex / 100) & 0xff);
+
+			// Incompressible data
+			uint64_t nState = 7;
+			std::vector<uint8_t> random(100000);
+			for (auto& nByte : random)
+				nByte = (uint8_t)(nextRandom(nState) >> 24);
+
+			uint32_t nCorrupt = (uint32_t)AMC::eDataTableFormatError::Corrupt;
+
+			for (uint32_t nCodec : { (uint32_t)DATATABLE_V2_CODEC_LZ4, (uint32_t)DATATABLE_V2_CODEC_DEFLATE }) {
+				std::string sCodec = "codec " + std::to_string(nCodec);
+
+				std::vector<uint8_t> compressed;
+				assertTrue(AMC::CDataTableEncoding::compress(nCodec, compressible.data(), compressible.size(), compressed), sCodec + " compresses compressible data");
+				assertTrue(compressed.size() < compressible.size() / 10, sCodec + " shrinks the pattern by an order of magnitude");
+
+				std::vector<uint8_t> decompressed(compressible.size());
+				AMC::CDataTableEncoding::decompress(nCodec, compressed.data(), compressed.size(), decompressed.data(), decompressed.size());
+				assertTrue(decompressed == compressible, sCodec + " round trip");
+
+				// The decompressed size must match exactly.
+				std::vector<uint8_t> tooSmall(compressible.size() - 1);
+				assertTrue(formatErrorOf([&]() { AMC::CDataTableEncoding::decompress(nCodec, compressed.data(), compressed.size(), tooSmall.data(), tooSmall.size()); }) == nCorrupt, sCodec + " rejects a target that is too small");
+				std::vector<uint8_t> tooLarge(compressible.size() + 1);
+				assertTrue(formatErrorOf([&]() { AMC::CDataTableEncoding::decompress(nCodec, compressed.data(), compressed.size(), tooLarge.data(), tooLarge.size()); }) == nCorrupt, sCodec + " rejects a target that is too large");
+
+				// Truncated compressed data
+				assertTrue(formatErrorOf([&]() { AMC::CDataTableEncoding::decompress(nCodec, compressed.data(), compressed.size() / 2, decompressed.data(), decompressed.size()); }) == nCorrupt, sCodec + " rejects truncated data");
+
+				// Data that does not get smaller is reported, so that the page is stored uncompressed.
+				std::vector<uint8_t> notSmaller;
+				assertFalse(AMC::CDataTableEncoding::compress(nCodec, random.data(), random.size(), notSmaller), sCodec + " does not shrink random data");
+				assertFalse(AMC::CDataTableEncoding::compress(nCodec, random.data(), 0, notSmaller), sCodec + " does not compress empty data");
+			}
+
+			std::vector<uint8_t> unused;
+			assertFalse(AMC::CDataTableEncoding::compress(DATATABLE_V2_CODEC_NONE, compressible.data(), compressible.size(), unused), "codec none never compresses");
+
+			std::vector<uint8_t> copy(compressible.size());
+			AMC::CDataTableEncoding::decompress(DATATABLE_V2_CODEC_NONE, compressible.data(), compressible.size(), copy.data(), copy.size());
+			assertTrue(copy == compressible, "codec none copies");
+
+			assertTrue(formatErrorOf([&]() { AMC::CDataTableEncoding::compress(9, compressible.data(), compressible.size(), unused); }) == (uint32_t)AMC::eDataTableFormatError::UnsupportedCodec, "unknown codec is rejected on compression");
+			assertTrue(formatErrorOf([&]() { AMC::CDataTableEncoding::decompress(9, compressible.data(), compressible.size(), copy.data(), copy.size()); }) == (uint32_t)AMC::eDataTableFormatError::UnsupportedCodec, "unknown codec is rejected on decompression");
+		}
+
+		struct SSampleData {
+			std::vector<uint64_t> m_Timestamps;
+			std::vector<int32_t> m_Int32s;
+			std::vector<uint32_t> m_Uint32s;
+			std::vector<int64_t> m_Int64s;
+			std::vector<uint64_t> m_Uint64s;
+			std::vector<uint8_t> m_Bools;
+			std::vector<float> m_Floats;
+			std::vector<double> m_Quantized;
+			std::vector<double> m_Doubles;
+		};
+
+		std::vector<AMC::sDataTableV2Column> sampleColumns()
+		{
+			std::vector<AMC::sDataTableV2Column> columns;
+			columns.push_back({ "t", "Time", AMC::eDataTableV2DataType::Timestamp, DATATABLE_V2_ENCODING_DELTA, 0.0 });
+			columns.push_back({ "i32", "Int32", AMC::eDataTableV2DataType::Int32, DATATABLE_V2_ENCODING_DELTA, 0.0 });
+			columns.push_back({ "u32", "Uint32", AMC::eDataTableV2DataType::Uint32, DATATABLE_V2_ENCODING_DELTA, 0.0 });
+			columns.push_back({ "i64", "Int64", AMC::eDataTableV2DataType::Int64, DATATABLE_V2_ENCODING_DELTA, 0.0 });
+			columns.push_back({ "u64", "Uint64", AMC::eDataTableV2DataType::Uint64, DATATABLE_V2_ENCODING_DELTA, 0.0 });
+			columns.push_back({ "b", "Bool", AMC::eDataTableV2DataType::Bool, DATATABLE_V2_ENCODING_BITPACK, 0.0 });
+			columns.push_back({ "f", "Float", AMC::eDataTableV2DataType::Float, DATATABLE_V2_ENCODING_PLAIN, 0.0 });
+			columns.push_back({ "q", "Quantised double", AMC::eDataTableV2DataType::Double, DATATABLE_V2_ENCODING_DELTA, 0.001 });
+			columns.push_back({ "d", "Double", AMC::eDataTableV2DataType::Double, DATATABLE_V2_ENCODING_PLAIN, 0.0 });
+			return columns;
+		}
+
+		SSampleData sampleData(uint32_t nRowCount)
+		{
+			SSampleData data;
+			for (uint32_t nIndex = 0; nIndex < nRowCount; nIndex++) {
+				data.m_Timestamps.push_back(1700000000000000ULL + (uint64_t)nIndex * 10);
+				data.m_Int32s.push_back(-500 + (int32_t)(nIndex % 17) - (int32_t)nIndex);
+				data.m_Uint32s.push_back(4000000000U + nIndex);
+				data.m_Int64s.push_back(-5000000000LL + (int64_t)nIndex * 3);
+				data.m_Uint64s.push_back(18000000000000000000ULL + nIndex);
+				data.m_Bools.push_back(((nIndex / 50) % 2) ? 1 : 0);
+				data.m_Floats.push_back(20.0f + (float)std::sin(nIndex * 0.01) * 5.0f);
+				data.m_Quantized.push_back(1500.0 + std::sin(nIndex * 0.01) * 300.0);
+				data.m_Doubles.push_back(std::cos(nIndex * 0.013) * 1.0e-3);
+			}
+			return data;
+		}
+
+		std::vector<const uint8_t*> columnPointers(const SSampleData& data)
+		{
+			return {
+				(const uint8_t*)data.m_Timestamps.data(), (const uint8_t*)data.m_Int32s.data(), (const uint8_t*)data.m_Uint32s.data(),
+				(const uint8_t*)data.m_Int64s.data(), (const uint8_t*)data.m_Uint64s.data(), data.m_Bools.data(),
+				(const uint8_t*)data.m_Floats.data(), (const uint8_t*)data.m_Quantized.data(), (const uint8_t*)data.m_Doubles.data()
+			};
+		}
+
+		template <typename T>
+		std::vector<T> readColumn(AMC::CDataTableV2SegmentReader& reader, uint32_t nColumnIndex)
+		{
+			std::vector<T> values((size_t)reader.getRowCount());
+			size_t nRowOffset = 0;
+			for (uint32_t nChunkIndex = 0; nChunkIndex < reader.getChunkCount(); nChunkIndex++) {
+				reader.readPage(nChunkIndex, nColumnIndex, (uint8_t*)(values.data() + nRowOffset), (values.size() - nRowOffset) * sizeof(T));
+				nRowOffset += reader.getChunkRowCount(nChunkIndex);
+			}
+			return values;
+		}
+
+		void testEncodedChunkRoundTrip()
+		{
+			auto columns = sampleColumns();
+			auto data1 = sampleData(1000);
+			auto data2 = sampleData(300);
+
+			size_t nPlainChunkSize = 1000 * (8 + 4 + 4 + 8 + 8 + 1 + 4 + 8 + 8);
+
+			for (uint32_t nCodec : { (uint32_t)DATATABLE_V2_CODEC_NONE, (uint32_t)DATATABLE_V2_CODEC_LZ4, (uint32_t)DATATABLE_V2_CODEC_DEFLATE }) {
+				std::string sCodec = "codec " + std::to_string(nCodec) + ": ";
+
+				AMC::CDataTableV2ChunkEncoder encoder(columns, nCodec);
+				AMC::CDataTableV2SegmentBuilder builder(columns, 0, 0, 1000);
+				AMC::sDataTableV2EncodedChunk chunk;
+
+				std::vector<uint8_t> bytes;
+				builder.appendHeader(bytes);
+
+				encoder.encodeChunk(columnPointers(data1), 1000, chunk);
+				assertTrue(chunk.m_Bytes.size() < nPlainChunkSize / 2, sCodec + "encoded chunk is less than half of the plain size, got " + std::to_string(chunk.m_Bytes.size()));
+				assertTrue(chunk.m_Bytes.size() <= builder.getChunkSizeInBytes(1000), sCodec + "encoded chunk is never larger than the plain chunk");
+				builder.appendEncodedChunk(chunk, bytes);
+
+				encoder.encodeChunk(columnPointers(data2), 300, chunk);
+				builder.appendEncodedChunk(chunk, bytes);
+
+				builder.appendFooter(bytes);
+				assertTrue(builder.getCurrentSize() == bytes.size(), sCodec + "builder size is the segment size");
+
+				AMC::CDataTableV2SegmentReader reader(memoryReader(bytes), bytes.size());
+				assertTrue(reader.getRowCount() == 1300, sCodec + "row count");
+				assertTrue(reader.getChunkCount() == 2, sCodec + "chunk count");
+
+				// The schema records encoding and quantisation.
+				assertTrue(reader.getColumn(0).m_nEncoding == DATATABLE_V2_ENCODING_DELTA, sCodec + "timestamp column encoding in the schema");
+				assertTrue(reader.getColumn(5).m_nEncoding == DATATABLE_V2_ENCODING_BITPACK, sCodec + "bool column encoding in the schema");
+				assertTrue(reader.getColumn(7).m_dQuantizationStep == 0.001, sCodec + "quantisation step in the schema");
+				assertTrue(reader.getColumn(8).m_dQuantizationStep == 0.0, sCodec + "plain double column is not quantised");
+
+				// The page directory records what was actually stored.
+				auto& timestampEntry = reader.getPageEntry(0, 0);
+				assertTrue(timestampEntry.m_nEncoding == DATATABLE_V2_ENCODING_DELTA, sCodec + "timestamp page is delta encoded");
+				assertTrue(timestampEntry.m_nUncompressedSize < 100, sCodec + "fixed-rate timestamp page is tiny, got " + std::to_string(timestampEntry.m_nUncompressedSize));
+				assertTrue(timestampEntry.m_nMinValue == 1700000000000000ULL, sCodec + "timestamp page minimum");
+				assertTrue(timestampEntry.m_nMaxValue == 1700000000000000ULL + 9990, sCodec + "timestamp page maximum");
+
+				auto& boolEntry = reader.getPageEntry(0, 5);
+				assertTrue(boolEntry.m_nEncoding == DATATABLE_V2_ENCODING_BITPACK, sCodec + "bool page is bit packed");
+				assertTrue(boolEntry.m_nUncompressedSize == 125, sCodec + "bool page holds one bit per row");
+
+				auto& floatEntry = reader.getPageEntry(0, 6);
+				assertTrue(floatEntry.m_nEncoding == DATATABLE_V2_ENCODING_PLAIN, sCodec + "float page is plain");
+				assertTrue(floatEntry.m_nUncompressedSize == 4000, sCodec + "float page size");
+				if (nCodec == DATATABLE_V2_CODEC_NONE)
+					assertTrue(floatEntry.m_nCodec == DATATABLE_V2_CODEC_NONE, sCodec + "float page is uncompressed");
+
+				auto& quantizedEntry = reader.getPageEntry(0, 7);
+				assertTrue(quantizedEntry.m_nEncoding == DATATABLE_V2_ENCODING_DELTA, sCodec + "quantised page is delta encoded");
+				assertTrue(quantizedEntry.m_nUncompressedSize < 4000, sCodec + "quantised page is less than half of the plain doubles");
+
+				// Exact columns
+				std::vector<uint64_t> expectedTimestamps = data1.m_Timestamps;
+				expectedTimestamps.insert(expectedTimestamps.end(), data2.m_Timestamps.begin(), data2.m_Timestamps.end());
+				assertTrue(readColumn<uint64_t>(reader, 0) == expectedTimestamps, sCodec + "timestamp column is exact");
+
+				std::vector<int32_t> expectedInt32s = data1.m_Int32s;
+				expectedInt32s.insert(expectedInt32s.end(), data2.m_Int32s.begin(), data2.m_Int32s.end());
+				assertTrue(readColumn<int32_t>(reader, 1) == expectedInt32s, sCodec + "int32 column is exact");
+
+				std::vector<uint32_t> expectedUint32s = data1.m_Uint32s;
+				expectedUint32s.insert(expectedUint32s.end(), data2.m_Uint32s.begin(), data2.m_Uint32s.end());
+				assertTrue(readColumn<uint32_t>(reader, 2) == expectedUint32s, sCodec + "uint32 column is exact");
+
+				std::vector<int64_t> expectedInt64s = data1.m_Int64s;
+				expectedInt64s.insert(expectedInt64s.end(), data2.m_Int64s.begin(), data2.m_Int64s.end());
+				assertTrue(readColumn<int64_t>(reader, 3) == expectedInt64s, sCodec + "int64 column is exact");
+
+				std::vector<uint64_t> expectedUint64s = data1.m_Uint64s;
+				expectedUint64s.insert(expectedUint64s.end(), data2.m_Uint64s.begin(), data2.m_Uint64s.end());
+				assertTrue(readColumn<uint64_t>(reader, 4) == expectedUint64s, sCodec + "uint64 column is exact");
+
+				std::vector<uint8_t> expectedBools = data1.m_Bools;
+				expectedBools.insert(expectedBools.end(), data2.m_Bools.begin(), data2.m_Bools.end());
+				assertTrue(readColumn<uint8_t>(reader, 5) == expectedBools, sCodec + "bool column is exact");
+
+				std::vector<float> expectedFloats = data1.m_Floats;
+				expectedFloats.insert(expectedFloats.end(), data2.m_Floats.begin(), data2.m_Floats.end());
+				assertTrue(readColumn<float>(reader, 6) == expectedFloats, sCodec + "float column is bit-exact");
+
+				std::vector<double> expectedDoubles = data1.m_Doubles;
+				expectedDoubles.insert(expectedDoubles.end(), data2.m_Doubles.begin(), data2.m_Doubles.end());
+				assertTrue(readColumn<double>(reader, 8) == expectedDoubles, sCodec + "unquantised double column is bit-exact");
+
+				// The quantised column is exact to half a step and holds integer multiples of the step.
+				auto quantized = readColumn<double>(reader, 7);
+				for (size_t nIndex = 0; nIndex < 1000; nIndex++) {
+					double dOriginal = data1.m_Quantized[nIndex];
+					assertTrue(std::fabs(quantized[nIndex] - dOriginal) <= 0.0005 + 1.0e-9, sCodec + "quantised value " + std::to_string(nIndex) + " is within half a step");
+					assertTrue(quantized[nIndex] == (double)std::llround(dOriginal / 0.001) * 0.001, sCodec + "quantised value " + std::to_string(nIndex) + " is a multiple of the step");
+				}
+
+				// The statistics of the quantised page describe the values as they are read back.
+				double dPageMin = AMC::CDataTableV2::statisticsValueToDouble(AMC::eDataTableV2DataType::Double, quantizedEntry.m_nMinValue);
+				double dPageMax = AMC::CDataTableV2::statisticsValueToDouble(AMC::eDataTableV2DataType::Double, quantizedEntry.m_nMaxValue);
+				double dReadMin = quantized[0];
+				double dReadMax = quantized[0];
+				for (size_t nIndex = 0; nIndex < 1000; nIndex++) {
+					if (quantized[nIndex] < dReadMin)
+						dReadMin = quantized[nIndex];
+					if (quantized[nIndex] > dReadMax)
+						dReadMax = quantized[nIndex];
+				}
+				assertTrue((dPageMin == dReadMin) && (dPageMax == dReadMax), sCodec + "quantised page statistics match the values read back");
+
+				assertTrue(reader.getPageReadCount() == 18, sCodec + "every page was read once");
+			}
+		}
+
+		void testFallbackToPlain()
+		{
+			uint64_t nState = 4711;
+
+			std::vector<AMC::sDataTableV2Column> columns;
+			columns.push_back({ "r", "Random", AMC::eDataTableV2DataType::Int64, DATATABLE_V2_ENCODING_DELTA, 0.0 });
+			columns.push_back({ "q", "Quantised with NaN", AMC::eDataTableV2DataType::Double, DATATABLE_V2_ENCODING_DELTA, 0.5 });
+			columns.push_back({ "b", "Bool", AMC::eDataTableV2DataType::Bool, DATATABLE_V2_ENCODING_BITPACK, 0.0 });
+
+			// Full range random integers have deltas as wide as the values.
+			std::vector<int64_t> random(200);
+			for (auto& nValue : random)
+				nValue = (int64_t)nextRandom(nState);
+
+			// A value that can not be quantised keeps the page plain and bit-exact.
+			std::vector<double> withNaN(200, 1.26);
+			withNaN[17] = std::numeric_limits<double>::quiet_NaN();
+
+			std::vector<uint8_t> bools(200, 1);
+
+			AMC::CDataTableV2ChunkEncoder encoder(columns, DATATABLE_V2_CODEC_LZ4);
+			AMC::CDataTableV2SegmentBuilder builder(columns, 0, 0, 200);
+			AMC::sDataTableV2EncodedChunk chunk;
+
+			std::vector<uint8_t> bytes;
+			builder.appendHeader(bytes);
+			encoder.encodeChunk({ (const uint8_t*)random.data(), (const uint8_t*)withNaN.data(), bools.data() }, 200, chunk);
+			builder.appendEncodedChunk(chunk, bytes);
+
+			// A single bool does not get smaller by bit packing.
+			encoder.encodeChunk({ (const uint8_t*)random.data(), (const uint8_t*)withNaN.data(), bools.data() }, 1, chunk);
+			builder.appendEncodedChunk(chunk, bytes);
+			builder.appendFooter(bytes);
+
+			AMC::CDataTableV2SegmentReader reader(memoryReader(bytes), bytes.size());
+
+			auto& randomEntry = reader.getPageEntry(0, 0);
+			assertTrue(randomEntry.m_nEncoding == DATATABLE_V2_ENCODING_PLAIN, "random integers fall back to plain");
+			assertTrue(randomEntry.m_nCodec == DATATABLE_V2_CODEC_NONE, "random integers stay uncompressed");
+			assertTrue(randomEntry.m_nCompressedSize == 1600, "random integer page has the plain size");
+
+			auto& nanEntry = reader.getPageEntry(0, 1);
+			assertTrue(nanEntry.m_nEncoding == DATATABLE_V2_ENCODING_PLAIN, "a page with NaN is not quantised");
+
+			assertTrue(reader.getPageEntry(0, 2).m_nEncoding == DATATABLE_V2_ENCODING_BITPACK, "bool page of 200 rows is bit packed");
+			assertTrue(reader.getPageEntry(1, 2).m_nEncoding == DATATABLE_V2_ENCODING_PLAIN, "bool page of one row stays plain");
+
+			auto randomOut = readColumn<int64_t>(reader, 0);
+			assertTrue(std::vector<int64_t>(randomOut.begin(), randomOut.begin() + 200) == random, "plain fallback is exact");
+
+			auto nanOut = readColumn<double>(reader, 1);
+			assertTrue(nanOut[0] == 1.26, "unquantised fallback page is bit-exact");
+			assertTrue(std::isnan(nanOut[17]), "NaN survives in the fallback page");
+
+			// Without the NaN the same column is quantised.
+			withNaN[17] = 1.26;
+			std::vector<uint8_t> quantizedBytes;
+			AMC::CDataTableV2SegmentBuilder quantizedBuilder(columns, 0, 0, 200);
+			quantizedBuilder.appendHeader(quantizedBytes);
+			quantizedBuilder.appendChunk({ (const uint8_t*)random.data(), (const uint8_t*)withNaN.data(), bools.data() }, 200, quantizedBytes);
+			quantizedBuilder.appendFooter(quantizedBytes);
+
+			AMC::CDataTableV2SegmentReader quantizedReader(memoryReader(quantizedBytes), quantizedBytes.size());
+			assertTrue(quantizedReader.getPageEntry(0, 1).m_nEncoding == DATATABLE_V2_ENCODING_DELTA, "the page is quantised without the NaN");
+			assertTrue(readColumn<double>(quantizedReader, 1)[0] == 1.5, "1.26 is stored as the nearest multiple of 0.5");
+		}
+
+		void testEncodingValidation()
+		{
+			uint32_t nUnsupportedEncoding = (uint32_t)AMC::eDataTableFormatError::UnsupportedEncoding;
+
+			auto encoderError = [&](AMC::eDataTableV2DataType dataType, uint32_t nEncoding, double dStep) {
+				std::vector<AMC::sDataTableV2Column> columns;
+				columns.push_back({ "x", "X", dataType, nEncoding, dStep });
+				return formatErrorOf([&]() { AMC::CDataTableV2ChunkEncoder encoder(columns, DATATABLE_V2_CODEC_NONE); });
+			};
+
+			assertTrue(encoderError(AMC::eDataTableV2DataType::Float, DATATABLE_V2_ENCODING_DELTA, 0.0) == nUnsupportedEncoding, "delta on a float column is rejected");
+			assertTrue(encoderError(AMC::eDataTableV2DataType::Double, DATATABLE_V2_ENCODING_DELTA, 0.0) == nUnsupportedEncoding, "delta on an unquantised double column is rejected");
+			assertTrue(encoderError(AMC::eDataTableV2DataType::Int32, DATATABLE_V2_ENCODING_BITPACK, 0.0) == nUnsupportedEncoding, "bit packing on an integer column is rejected");
+			assertTrue(encoderError(AMC::eDataTableV2DataType::Bool, DATATABLE_V2_ENCODING_DELTA, 0.0) == nUnsupportedEncoding, "delta on a bool column is rejected");
+			assertTrue(encoderError(AMC::eDataTableV2DataType::Int32, 42, 0.0) == nUnsupportedEncoding, "unknown encoding is rejected");
+			assertTrue(encoderError(AMC::eDataTableV2DataType::Double, DATATABLE_V2_ENCODING_DELTA, -1.0) == (uint32_t)AMC::eDataTableFormatError::InvalidParam, "negative quantisation step is rejected");
+			assertTrue(encoderError(AMC::eDataTableV2DataType::Double, DATATABLE_V2_ENCODING_DELTA, 0.01) == 0, "delta on a quantised double column is accepted");
+			assertTrue(encoderError(AMC::eDataTableV2DataType::Timestamp, DATATABLE_V2_ENCODING_DELTA, 0.0) == 0, "delta on a timestamp column is accepted");
+
+			assertTrue(AMC::CDataTableV2::getDefaultEncoding(AMC::eDataTableV2DataType::Timestamp) == DATATABLE_V2_ENCODING_DELTA, "timestamps default to delta");
+			assertTrue(AMC::CDataTableV2::getDefaultEncoding(AMC::eDataTableV2DataType::Uint32) == DATATABLE_V2_ENCODING_DELTA, "integers default to delta");
+			assertTrue(AMC::CDataTableV2::getDefaultEncoding(AMC::eDataTableV2DataType::Bool) == DATATABLE_V2_ENCODING_BITPACK, "bools default to bit packing");
+			assertTrue(AMC::CDataTableV2::getDefaultEncoding(AMC::eDataTableV2DataType::Float) == DATATABLE_V2_ENCODING_PLAIN, "floats default to plain");
+			assertTrue(AMC::CDataTableV2::getDefaultEncoding(AMC::eDataTableV2DataType::Double) == DATATABLE_V2_ENCODING_PLAIN, "doubles default to plain");
+
+			// A directory that claims a delta page in a float column is rejected by the reader.
+			std::vector<AMC::sDataTableV2Column> columns;
+			columns.push_back({ "f", "Float", AMC::eDataTableV2DataType::Float });
+			std::vector<float> floats(10, 1.0f);
+
+			AMC::CDataTableV2SegmentBuilder builder(columns, 0, 0, 10);
+			std::vector<uint8_t> bytes;
+			builder.appendHeader(bytes);
+			builder.appendChunk({ (const uint8_t*)floats.data() }, 10, bytes);
+			builder.appendFooter(bytes);
+
+			AMC::sDataTableV2Trailer trailer;
+			memcpy(&trailer, bytes.data() + bytes.size() - sizeof(trailer), sizeof(trailer));
+			size_t nEntryOffset = bytes.size() - sizeof(trailer) - sizeof(AMC::sDataTableV2PageEntry);
+
+			AMC::sDataTableV2PageEntry entry;
+			memcpy(&entry, bytes.data() + nEntryOffset, sizeof(entry));
+			entry.m_nEncoding = DATATABLE_V2_ENCODING_DELTA;
+			memcpy(bytes.data() + nEntryOffset, &entry, sizeof(entry));
+
+			assertTrue(formatErrorOf([&]() { AMC::CDataTableV2SegmentReader reader(memoryReader(bytes), bytes.size()); }) == (uint32_t)AMC::eDataTableFormatError::Corrupt, "delta page in a float column is rejected on read");
+
+			entry.m_nEncoding = DATATABLE_V2_ENCODING_BITPACK;
+			memcpy(bytes.data() + nEntryOffset, &entry, sizeof(entry));
+			assertTrue(formatErrorOf([&]() { AMC::CDataTableV2SegmentReader reader(memoryReader(bytes), bytes.size()); }) == (uint32_t)AMC::eDataTableFormatError::Corrupt, "bit packed page in a float column is rejected on read");
+		}
+
+	};
+
+}
+
+#endif // __AMCTEST_UNITTEST_DATATABLEENCODING
diff --git a/Implementation/UnitTest/amc_unittests_datatableformat.hpp b/Implementation/UnitTest/amc_unittests_datatableformat.hpp
new file mode 100644
index 000000000..f28511ebc
--- /dev/null
+++ b/Implementation/UnitTest/amc_unittests_datatableformat.hpp
@@ -0,0 +1,479 @@
+/*++
+
+Copyright (C) 2020 Autodesk Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Autodesk Inc. nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL AUTODESK INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef __AMCTEST_UNITTEST_DATATABLEFORMAT
+#define __AMCTEST_UNITTEST_DATATABLEFORMAT
+
+#include "amc_unittests.hpp"
+#include "amc_constants.hpp"
+#include "amc_datatableformat.hpp"
+
+#include <cmath>
+#include <cstdint>
+#include <cstring>
+#include <limits>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+namespace AMCUnitTest {
+
+	class CUnitTestGroup_DataTableFormatV2 : public CUnitTestGroup {
+	public:
+
+		std::string getTestGroupName() override {
+			return "DataTableFormatV2";
+		}
+
+		void registerTests() override {
+			registerTest("Statistics", "Typed page statistics for all column types", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataTableFormatV2::testStatistics, this));
+			registerTest("SegmentRoundTrip", "Segment builder output is read back by the segment reader", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataTableFormatV2::testSegmentRoundTrip, this));
+			registerTest("EmptySegments", "Segments without chunks and without columns", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataTableFormatV2::testEmptySegments, this));
+			registerTest("SizePrediction", "Predicted chunk and footer sizes match the produced bytes", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataTableFormatV2::testSizePrediction, this));
+			registerTest("TruncatedSegments", "Segments cut at any position are reported as truncated or corrupt", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataTableFormatV2::testTruncatedSegments, this));
+			registerTest("CorruptSegments", "Corrupted headers, footers and directories are rejected", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataTableFormatV2::testCorruptSegments, this));
+			registerTest("BuilderMisuse", "Builder rejects calls in the wrong order and invalid chunks", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataTableFormatV2::testBuilderMisuse, this));
+		}
+
+		void initializeTests() override {
+		}
+
+	private:
+
+		// Returns the format error a call fails with, or 0 if it does not fail.
+		template <typename F>
+		uint32_t formatErrorOf(F&& fn)
+		{
+			try {
+				fn();
+			}
+			catch (AMC::EDataTableFormatException& formatException) {
+				return (uint32_t)formatException.getError();
+			}
+			return 0;
+		}
+
+		// A read callback over a byte vector. Reading outside of the vector is a test failure:
+		// the reader must validate every offset against the stream size first.
+		AMC::CDataTableV2SegmentReader::ReadCallback memoryReader(const std::vector<uint8_t>& bytes)
+		{
+			return [&bytes](uint64_t nOffset, uint64_t nSize, uint8_t* pBuffer) {
+				if ((nOffset > bytes.size()) || (nSize > bytes.size() - nOffset))
+					throw std::out_of_range("segment reader read outside of the stream");
+				if (nSize > 0)
+					memcpy(pBuffer, bytes.data() + nOffset, (size_t)nSize);
+			};
+		}
+
+		std::vector<AMC::sDataTableV2Column> sampleColumns()
+		{
+			std::vector<AMC::sDataTableV2Column> columns;
+			columns.push_back({ "t", "Time", AMC::eDataTableV2DataType::Timestamp });
+			columns.push_back({ "temp", "Temperature in C", AMC::eDataTableV2DataType::Float });
+			columns.push_back({ "laser", "Laser active", AMC::eDataTableV2DataType::Bool });
+			return columns;
+		}
+
+		// Builds a segment with two chunks of 5 and 3 rows.
+		std::vector<uint8_t> buildSampleSegment(uint32_t nSegmentIndex = 2, uint64_t nFirstRow = 1000)
+		{
+			std::vector<uint64_t> timestamps1 = { 100, 200, 300, 400, 500 };
+			std::vector<float> temperatures1 = { 20.5f, 21.0f, 1800.25f, -5.0f, 22.0f };
+			std::vector<uint8_t> laser1 = { 0, 1, 1, 0, 0 };
+
+			std::vector<uint64_t> timestamps2 = { 600, 700, 800 };
+			std::vector<float> temperatures2 = { 30.0f, 31.0f, 32.0f };
+			std::vector<uint8_t> laser2 = { 1, 1, 1 };
+
+			AMC::CDataTableV2SegmentBuilder builder(sampleColumns(), nSegmentIndex, nFirstRow, 5);
+
+			std::vector<uint8_t> bytes;
+			builder.appendHeader(bytes);
+			builder.appendChunk({ (const uint8_t*)timestamps1.data(), (const uint8_t*)temperatures1.data(), laser1.data() }, 5, bytes);
+			builder.appendChunk({ (const uint8_t*)timestamps2.data(), (const uint8_t*)temperatures2.data(), laser2.data() }, 3, bytes);
+			builder.appendFooter(bytes);
+
+			return bytes;
+		}
+
+		double bitsToDouble(uint64_t nBits)
+		{
+			double dValue = 0.0;
+			memcpy(&dValue, &nBits, sizeof(dValue));
+			return dValue;
+		}
+
+		// Offset of the page directory inside a finished segment.
+		size_t directoryOffset(const std::vector<uint8_t>& bytes)
+		{
+			AMC::sDataTableV2Trailer trailer;
+			memcpy(&trailer, bytes.data() + bytes.size() - sizeof(trailer), sizeof(trailer));
+			size_t nFooterStart = bytes.size() - sizeof(trailer) - (size_t)trailer.m_nFooterLength;
+
+			AMC::sDataTableV2FooterHeader footerHeader;
+			memcpy(&footerHeader, bytes.data() + nFooterStart, sizeof(footerHeader));
+
+			return nFooterStart + sizeof(footerHeader) + footerHeader.m_nSchemaSize;
+		}
+
+		void testStatistics()
+		{
+			uint64_t nMin = 0;
+			uint64_t nMax = 0;
+
+			std::vector<double> doubles = { 1.5, std::numeric_limits<double>::quiet_NaN(), -2.25, 1800.0 };
+			assertTrue(AMC::CDataTableV2::computeStatistics(AMC::eDataTableV2DataType::Double, (const uint8_t*)doubles.data(), (uint32_t)doubles.size(), nMin, nMax), "double statistics are valid");
+			assertTrue(bitsToDouble(nMin) == -2.25, "double minimum ignores NaN");
+			assertTrue(bitsToDouble(nMax) == 1800.0, "double maximum ignores NaN");
+
+			std::vector<float> floats = { 0.5f, -100.25f, 3.0f };
+			assertTrue(AMC::CDataTableV2::computeStatistics(AMC::eDataTableV2DataType::Float, (const uint8_t*)floats.data(), (uint32_t)floats.size(), nMin, nMax), "float statistics are valid");
+			assertTrue(bitsToDouble(nMin) == -100.25, "float minimum is widened to double");
+			assertTrue(bitsToDouble(nMax) == 3.0, "float maximum is widened to double");
+
+			std::vector<double> nans = { std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN() };
+			assertFalse(AMC::CDataTableV2::computeStatistics(AMC::eDataTableV2DataType::Double, (const uint8_t*)nans.data(), (uint32_t)nans.size(), nMin, nMax), "NaN only page has no statistics");
+
+			std::vector<int32_t> int32s = { 5, -7, 3 };
+			assertTrue(AMC::CDataTableV2::computeStatistics(AMC::eDataTableV2DataType::Int32, (const uint8_t*)int32s.data(), (uint32_t)int32s.size(), nMin, nMax), "int32 statistics are valid");
+			assertTrue((int64_t)nMin == -7, "int32 minimum is signed");
+			assertTrue((int64_t)nMax == 5, "int32 maximum is signed");
+
+			std::vector<int64_t> int64s = { -5000000000LL, 12 };
+			assertTrue(AMC::CDataTableV2::computeStatistics(AMC::eDataTableV2DataType::Int64, (const uint8_t*)int64s.data(), (uint32_t)int64s.size(), nMin, nMax), "int64 statistics are valid");
+			assertTrue((int64_t)nMin == -5000000000LL, "int64 minimum");
+			assertTrue((int64_t)nMax == 12, "int64 maximum");
+
+			std::vector<uint32_t> uint32s = { 4000000000U, 1 };
+			assertTrue(AMC::CDataTableV2::computeStatistics(AMC::eDataTableV2DataType::Uint32, (const uint8_t*)uint32s.data(), (uint32_t)uint32s.size(), nMin, nMax), "uint32 statistics are valid");
+			assertTrue(nMin == 1, "uint32 minimum");
+			assertTrue(nMax == 4000000000ULL, "uint32 maximum is unsigned");
+
+			std::vector<uint64_t> uint64s = { 18000000000000000000ULL, 7 };
+			assertTrue(AMC::CDataTableV2::computeStatistics(AMC::eDataTableV2DataType::Uint64, (const uint8_t*)uint64s.data(), (uint32_t)uint64s.size(), nMin, nMax), "uint64 statistics are valid");
+			assertTrue(nMin == 7, "uint64 minimum");
+			assertTrue(nMax == 18000000000000000000ULL, "uint64 maximum is unsigned");
+
+			std::vector<uint8_t> bools = { 0, 0, 0 };
+			assertTrue(AMC::CDataTableV2::computeStatistics(AMC::eDataTableV2DataType::Bool, bools.data(), (uint32_t)bools.size(), nMin, nMax), "bool statistics are valid");
+			assertTrue((nMin == 0) && (nMax == 0), "constant bool page has equal minimum and maximum");
+
+			assertFalse(AMC::CDataTableV2::computeStatistics(AMC::eDataTableV2DataType::Timestamp, (const uint8_t*)uint64s.data(), 0, nMin, nMax), "empty page has no statistics");
+
+			assertTrue(AMC::CDataTableV2::getEntrySize(AMC::eDataTableV2DataType::Bool) == 1, "bool entry size");
+			assertTrue(AMC::CDataTableV2::getEntrySize(AMC::eDataTableV2DataType::Float) == 4, "float entry size");
+			assertTrue(AMC::CDataTableV2::getEntrySize(AMC::eDataTableV2DataType::Timestamp) == 8, "timestamp entry size");
+			assertTrue(formatErrorOf([&]() { AMC::CDataTableV2::getEntrySize((AMC::eDataTableV2DataType)99); }) == (uint32_t)AMC::eDataTableFormatError::InvalidDataType, "unknown data type is rejected");
+		}
+
+		void testSegmentRoundTrip()
+		{
+			auto bytes = buildSampleSegment();
+
+			AMC::sDataTableV2SegmentHeader header;
+			memcpy(&header, bytes.data(), sizeof(header));
+			assertTrue(header.m_nSignature == DATATABLE_HEADERSIGNATURE_V2, "segment carries the version 2 signature");
+			assertTrue(header.m_nSignature != DATATABLE_HEADERSIGNATURE, "version 2 signature differs from version 1");
+			assertTrue(header.m_nVersion == DATATABLE_FORMATVERSION_2, "segment version is 2");
+			assertTrue(header.m_nHeaderSize == sizeof(header), "header size field");
+
+			AMC::CDataTableV2SegmentReader reader(memoryReader(bytes), bytes.size());
+
+			assertTrue(reader.getSegmentIndex() == 2, "segment index round trip");
+			assertTrue(reader.getFirstRowIndex() == 1000, "first row index round trip");
+			assertTrue(reader.getRowCount() == 8, "row count round trip");
+			assertTrue(reader.getChunkCount() == 2, "chunk count round trip");
+			assertTrue(reader.getColumnCount() == 3, "column count round trip");
+			assertTrue(reader.getChunkRowCount(0) == 5, "first chunk row count");
+			assertTrue(reader.getChunkRowCount(1) == 3, "second chunk row count");
+
+			assertTrue(reader.getColumn(0).m_sIdentifier == "t", "column 0 identifier");
+			assertTrue(reader.getColumn(1).m_sDescription == "Temperature in C", "column 1 description");
+			assertTrue(reader.getColumn(2).m_DataType == AMC::eDataTableV2DataType::Bool, "column 2 type");
+
+			// Typed statistics: the temperature page reports its real range, which a directory with integer bounds could not.
+			auto& temperatureEntry = reader.getPageEntry(0, 1);
+			assertTrue((temperatureEntry.m_nFlags & DATATABLE_V2_PAGEFLAG_STATISTICSVALID) != 0, "temperature page has statistics");
+			assertTrue(bitsToDouble(temperatureEntry.m_nMinValue) == -5.0, "temperature page minimum");
+			assertTrue(bitsToDouble(temperatureEntry.m_nMaxValue) == 1800.25, "temperature page maximum");
+			assertTrue(temperatureEntry.m_nRowCount == 5, "temperature page row count");
+			assertTrue(temperatureEntry.m_nUncompressedSize == 20, "temperature page size");
+			assertTrue(temperatureEntry.m_nCodec == DATATABLE_V2_CODEC_NONE, "page codec is none");
+			assertTrue(temperatureEntry.m_nEncoding == DATATABLE_V2_ENCODING_PLAIN, "page encoding is plain");
+
+			auto& timestampEntry = reader.getPageEntry(1, 0);
+			assertTrue(timestampEntry.m_nMinValue == 600, "timestamp page minimum");
+			assertTrue(timestampEntry.m_nMaxValue == 800, "timestamp page maximum");
+
+			// Every page is preceded by a self-describing page header.
+			AMC::sDataTableV2PageHeader pageHeader;
+			memcpy(&pageHeader, bytes.data() + temperatureEntry.m_nFileOffset - sizeof(pageHeader), sizeof(pageHeader));
+			assertTrue(pageHeader.m_nMagic == DATATABLE_V2_PAGEMAGIC, "page header magic");
+			assertTrue(pageHeader.m_nColumnIndex == 1, "page header column index");
+			assertTrue(pageHeader.m_nRowCount == 5, "page header row count");
+			assertTrue(pageHeader.m_nDataType == (uint32_t)AMC::eDataTableV2DataType::Float, "page header data type");
+
+			std::vector<float> temperatures(5);
+			reader.readPage(0, 1, (uint8_t*)temperatures.data(), temperatures.size() * sizeof(float));
+			assertTrue((temperatures[0] == 20.5f) && (temperatures[2] == 1800.25f) && (temperatures[4] == 22.0f), "temperature page content");
+
+			std::vector<uint64_t> timestamps(3);
+			reader.readPage(1, 0, (uint8_t*)timestamps.data(), timestamps.size() * sizeof(uint64_t));
+			assertTrue((timestamps[0] == 600) && (timestamps[2] == 800), "timestamp page content");
+
+			std::vector<uint8_t> laser(3);
+			reader.readPage(1, 2, laser.data(), laser.size());
+			assertTrue((laser[0] == 1) && (laser[2] == 1), "bool page content");
+
+			std::vector<uint8_t> tooSmall(2);
+			assertTrue(formatErrorOf([&]() { reader.readPage(0, 0, tooSmall.data(), tooSmall.size()); }) == (uint32_t)AMC::eDataTableFormatError::InvalidParam, "small target buffer is rejected");
+			assertTrue(formatErrorOf([&]() { reader.getPageEntry(2, 0); }) == (uint32_t)AMC::eDataTableFormatError::InvalidParam, "chunk index out of range is rejected");
+			assertTrue(formatErrorOf([&]() { reader.getColumn(3); }) == (uint32_t)AMC::eDataTableFormatError::InvalidParam, "column index out of range is rejected");
+		}
+
+		void testEmptySegments()
+		{
+			// A segment without chunks keeps the schema.
+			AMC::CDataTableV2SegmentBuilder builder(sampleColumns(), 0, 0, 100);
+			std::vector<uint8_t> bytes;
+			builder.appendHeader(bytes);
+			builder.appendFooter(bytes);
+
+			AMC::CDataTableV2SegmentReader reader(memoryReader(bytes), bytes.size());
+			assertTrue(reader.getColumnCount() == 3, "empty segment keeps its columns");
+			assertTrue(reader.getChunkCount() == 0, "empty segment has no chunks");
+			assertTrue(reader.getRowCount() == 0, "empty segment has no rows");
+
+			// A segment without columns is the smallest valid segment.
+			std::vector<AMC::sDataTableV2Column> noColumns;
+			AMC::CDataTableV2SegmentBuilder emptyBuilder(noColumns, 0, 0, 100);
+			std::vector<uint8_t> emptyBytes;
+			emptyBuilder.appendHeader(emptyBytes);
+			emptyBuilder.appendFooter(emptyBytes);
+			assertTrue(emptyBytes.size() == sizeof(AMC::sDataTableV2SegmentHeader) + sizeof(AMC::sDataTableV2FooterHeader) + sizeof(AMC::sDataTableV2Trailer), "smallest segment is header, footer header and trailer");
+
+			AMC::CDataTableV2SegmentReader emptyReader(memoryReader(emptyBytes), emptyBytes.size());
+			assertTrue(emptyReader.getColumnCount() == 0, "segment without columns");
+			assertTrue(emptyReader.getRowCount() == 0, "segment without columns has no rows");
+		}
+
+		void testSizePrediction()
+		{
+			auto columns = sampleColumns();
+			AMC::CDataTableV2SegmentBuilder builder(columns, 0, 0, 10);
+
+			std::vector<uint64_t> timestamps(10, 1);
+			std::vector<float> temperatures(10, 2.0f);
+			std::vector<uint8_t> laser(10, 1);
+
+			std::vector<uint8_t> bytes;
+			builder.appendHeader(bytes);
+			assertTrue(bytes.size() == sizeof(AMC::sDataTableV2SegmentHeader), "header size");
+			assertTrue(builder.getCurrentSize() == bytes.size(), "current size after header");
+
+			size_t nBefore = bytes.size();
+			builder.appendChunk({ (const uint8_t*)timestamps.data(), (const uint8_t*)temperatures.data(), laser.data() }, 10, bytes);
+			assertTrue(bytes.size() - nBefore == builder.getChunkSizeInBytes(10), "predicted chunk size matches");
+			// 3 page headers and 10 rows of 8 + 4 + 1 bytes
+			assertTrue(builder.getChunkSizeInBytes(10) == 3 * sizeof(AMC::sDataTableV2PageHeader) + 10 * 13, "chunk size formula");
+
+			nBefore = bytes.size();
+			builder.appendChunk({ (const uint8_t*)timestamps.data(), (const uint8_t*)temperatures.data(), laser.data() }, 4, bytes);
+			assertTrue(bytes.size() - nBefore == builder.getChunkSizeInBytes(4), "predicted partial chunk size matches");
+
+			uint64_t nPredictedFooterSize = builder.getFooterSizeInBytes(builder.getChunkCount());
+			nBefore = bytes.size();
+			builder.appendFooter(bytes);
+			assertTrue(bytes.size() - nBefore == nPredictedFooterSize, "predicted footer size matches");
+			assertTrue(builder.getCurrentSize() == bytes.size(), "current size is the segment size");
+			assertTrue(builder.getRowCount() == 14, "builder row count");
+			assertTrue(builder.getChunkCount() == 2, "builder chunk count");
+		}
+
+		void testTruncatedSegments()
+		{
+			auto bytes = buildSampleSegment();
+
+			// A segment that was interrupted anywhere before its trailer is complete has no footer.
+			// No cut may make the reader read outside of the stream or return data.
+			for (size_t nCutSize = 0; nCutSize < bytes.size(); nCutSize++) {
+				std::vector<uint8_t> cut(bytes.begin(), bytes.begin() + nCutSize);
+
+				uint32_t nError = formatErrorOf([&]() {
+					AMC::CDataTableV2SegmentReader reader(memoryReader(cut), cut.size());
+				});
+
+				bool bRejected = (nError == (uint32_t)AMC::eDataTableFormatError::Truncated) || (nError == (uint32_t)AMC::eDataTableFormatError::Corrupt);
+				assertTrue(bRejected, "segment cut at " + std::to_string(nCutSize) + " bytes is rejected, got error " + std::to_string(nError));
+			}
+
+			// The typical interruption: the chunk data is complete, the footer is missing.
+			std::vector<uint8_t> noFooter(bytes.begin(), bytes.begin() + directoryOffset(bytes) - 200);
+			assertTrue(formatErrorOf([&]() {
+				AMC::CDataTableV2SegmentReader reader(memoryReader(noFooter), noFooter.size());
+			}) == (uint32_t)AMC::eDataTableFormatError::Truncated, "segment without footer is reported as truncated");
+		}
+
+		void testCorruptSegments()
+		{
+			auto bytes = buildSampleSegment();
+			size_t nDirectoryOffset = directoryOffset(bytes);
+
+			auto errorOfVariant = [&](std::vector<uint8_t>& variant) {
+				return formatErrorOf([&]() {
+					AMC::CDataTableV2SegmentReader reader(memoryReader(variant), variant.size());
+				});
+			};
+
+			{
+				auto variant = bytes;
+				uint32_t nSignature = 0x12345678;
+				memcpy(variant.data(), &nSignature, sizeof(nSignature));
+				assertTrue(errorOfVariant(variant) == (uint32_t)AMC::eDataTableFormatError::InvalidSignature, "foreign signature is rejected");
+			}
+
+			{
+				auto variant = bytes;
+				uint32_t nVersion = 3;
+				memcpy(variant.data() + 4, &nVersion, sizeof(nVersion));
+				assertTrue(errorOfVariant(variant) == (uint32_t)AMC::eDataTableFormatError::UnsupportedVersion, "unknown version is rejected");
+			}
+
+			{
+				auto variant = bytes;
+				AMC::sDataTableV2Trailer trailer;
+				memcpy(&trailer, variant.data() + variant.size() - sizeof(trailer), sizeof(trailer));
+				trailer.m_nFooterLength = variant.size();
+				memcpy(variant.data() + variant.size() - sizeof(trailer), &trailer, sizeof(trailer));
+				assertTrue(errorOfVariant(variant) == (uint32_t)AMC::eDataTableFormatError::Corrupt, "footer length beyond the stream is rejected");
+			}
+
+			{
+				auto variant = bytes;
+				AMC::sDataTableV2PageEntry entry;
+				memcpy(&entry, variant.data() + nDirectoryOffset, sizeof(entry));
+				entry.m_nCodec = 7;
+				memcpy(variant.data() + nDirectoryOffset, &entry, sizeof(entry));
+				assertTrue(errorOfVariant(variant) == (uint32_t)AMC::eDataTableFormatError::UnsupportedCodec, "unknown page codec is rejected");
+			}
+
+			{
+				auto variant = bytes;
+				AMC::sDataTableV2PageEntry entry;
+				memcpy(&entry, variant.data() + nDirectoryOffset, sizeof(entry));
+				entry.m_nEncoding = 9;
+				memcpy(variant.data() + nDirectoryOffset, &entry, sizeof(entry));
+				assertTrue(errorOfVariant(variant) == (uint32_t)AMC::eDataTableFormatError::UnsupportedEncoding, "unknown page encoding is rejected");
+			}
+
+			{
+				auto variant = bytes;
+				AMC::sDataTableV2PageEntry entry;
+				memcpy(&entry, variant.data() + nDirectoryOffset, sizeof(entry));
+				entry.m_nFileOffset = variant.size() * 2;
+				memcpy(variant.data() + nDirectoryOffset, &entry, sizeof(entry));
+				assertTrue(errorOfVariant(variant) == (uint32_t)AMC::eDataTableFormatError::Corrupt, "page offset outside of the segment is rejected");
+			}
+
+			{
+				// The second column of the first chunk claims a different row count.
+				auto variant = bytes;
+				size_t nEntryOffset = nDirectoryOffset + sizeof(AMC::sDataTableV2PageEntry);
+				AMC::sDataTableV2PageEntry entry;
+				memcpy(&entry, variant.data() + nEntryOffset, sizeof(entry));
+				entry.m_nRowCount = 4;
+				entry.m_nCompressedSize = 16;
+				entry.m_nUncompressedSize = 16;
+				memcpy(variant.data() + nEntryOffset, &entry, sizeof(entry));
+				assertTrue(errorOfVariant(variant) == (uint32_t)AMC::eDataTableFormatError::Corrupt, "different row counts within a chunk are rejected");
+			}
+
+			{
+				// The page size does not match the row count.
+				auto variant = bytes;
+				AMC::sDataTableV2PageEntry entry;
+				memcpy(&entry, variant.data() + nDirectoryOffset, sizeof(entry));
+				entry.m_nUncompressedSize = 7;
+				memcpy(variant.data() + nDirectoryOffset, &entry, sizeof(entry));
+				assertTrue(errorOfVariant(variant) == (uint32_t)AMC::eDataTableFormatError::Corrupt, "page size mismatch is rejected");
+			}
+
+			{
+				auto variant = bytes;
+				AMC::sDataTableV2SegmentHeader header;
+				memcpy(&header, variant.data(), sizeof(header));
+				header.m_nColumnCount = 5;
+				memcpy(variant.data(), &header, sizeof(header));
+				assertTrue(errorOfVariant(variant) == (uint32_t)AMC::eDataTableFormatError::Corrupt, "column count mismatch between header and footer is rejected");
+			}
+		}
+
+		void testBuilderMisuse()
+		{
+			std::vector<uint64_t> timestamps(4, 1);
+			std::vector<float> temperatures(4, 2.0f);
+			std::vector<uint8_t> laser(4, 1);
+			std::vector<const uint8_t*> columnData = { (const uint8_t*)timestamps.data(), (const uint8_t*)temperatures.data(), laser.data() };
+
+			uint32_t nInvalidParam = (uint32_t)AMC::eDataTableFormatError::InvalidParam;
+
+			{
+				AMC::CDataTableV2SegmentBuilder builder(sampleColumns(), 0, 0, 4);
+				std::vector<uint8_t> bytes;
+				assertTrue(formatErrorOf([&]() { builder.appendChunk(columnData, 4, bytes); }) == nInvalidParam, "chunk before header is rejected");
+				assertTrue(formatErrorOf([&]() { builder.appendFooter(bytes); }) == nInvalidParam, "footer before header is rejected");
+
+				builder.appendHeader(bytes);
+				assertTrue(formatErrorOf([&]() { builder.appendHeader(bytes); }) == nInvalidParam, "second header is rejected");
+				assertTrue(formatErrorOf([&]() { builder.appendChunk(columnData, 0, bytes); }) == nInvalidParam, "empty chunk is rejected");
+
+				std::vector<const uint8_t*> tooFewColumns = { (const uint8_t*)timestamps.data() };
+				assertTrue(formatErrorOf([&]() { builder.appendChunk(tooFewColumns, 4, bytes); }) == nInvalidParam, "chunk with missing columns is rejected");
+
+				std::vector<const uint8_t*> nullColumn = { (const uint8_t*)timestamps.data(), nullptr, laser.data() };
+				assertTrue(formatErrorOf([&]() { builder.appendChunk(nullColumn, 4, bytes); }) == nInvalidParam, "chunk with a null column is rejected");
+
+				builder.appendFooter(bytes);
+				assertTrue(formatErrorOf([&]() { builder.appendChunk(columnData, 4, bytes); }) == nInvalidParam, "chunk after footer is rejected");
+				assertTrue(formatErrorOf([&]() { builder.appendFooter(bytes); }) == nInvalidParam, "second footer is rejected");
+			}
+
+			{
+				std::vector<AMC::sDataTableV2Column> invalidColumns;
+				invalidColumns.push_back({ "x", "X", (AMC::eDataTableV2DataType)42 });
+				assertTrue(formatErrorOf([&]() { AMC::CDataTableV2SegmentBuilder builder(invalidColumns, 0, 0, 4); }) == (uint32_t)AMC::eDataTableFormatError::InvalidDataType, "unknown column type is rejected");
+			}
+		}
+
+	};
+
+}
+
+#endif // __AMCTEST_UNITTEST_DATATABLEFORMAT
diff --git a/Implementation/UnitTest/amc_unittests_datatablereader.hpp b/Implementation/UnitTest/amc_unittests_datatablereader.hpp
new file mode 100644
index 000000000..780432f5c
--- /dev/null
+++ b/Implementation/UnitTest/amc_unittests_datatablereader.hpp
@@ -0,0 +1,815 @@
+/*++
+
+Copyright (C) 2020 Autodesk Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Autodesk Inc. nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL AUTODESK INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef __AMCTEST_UNITTEST_DATATABLEREADER
+#define __AMCTEST_UNITTEST_DATATABLEREADER
+
+#include "amc_unittests_datacapture.hpp"
+#include "libmcenv_datatablereader.hpp"
+
+#include <chrono>
+#include <cmath>
+#include <limits>
+
+namespace AMCUnitTest {
+
+	// Uses the fixture and the helpers of the data capture tests.
+	class CUnitTestGroup_DataTableReader : public CUnitTestGroup_DataCapture {
+	public:
+
+		std::string getTestGroupName() override {
+			return "DataTableReader";
+		}
+
+		void registerTests() override {
+			registerTest("DefaultEncodingsCompress", "Default options encode and compress a capture and keep it exact", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataTableReader::testDefaultEncodingsCompress, this));
+			registerTest("CompressionModes", "None, LZ4 and deflate captures are read back identically", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataTableReader::testCompressionModes, this));
+			registerTest("QuantizedDoubleColumn", "Opt-in quantisation of a double column is bounded and recorded", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataTableReader::testQuantizedDoubleColumn, this));
+			registerTest("EncodingOptionValidation", "Encoding options that do not fit the schema fail when recording starts", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataTableReader::testEncodingOptionValidation, this));
+			registerTest("SchemaAndChunks", "Reader reports schema, segments and chunks of a capture", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataTableReader::testSchemaAndChunks, this));
+			registerTest("RangeReads", "Row ranges across chunk and segment boundaries", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataTableReader::testRangeReads, this));
+			registerTest("ReadSelectivity", "A range read touches only the pages that overlap it", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataTableReader::testReadSelectivity, this));
+			registerTest("ChunkStatisticsAndValueSearch", "Page statistics and chunk search by value range", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataTableReader::testChunkStatisticsAndValueSearch, this));
+			registerTest("Downsampling", "Stride, MinMax and Average downsampling", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataTableReader::testDownsampling, this));
+			registerTest("ExtractDataTable", "A row range is materialised as a data table", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataTableReader::testExtractDataTable, this));
+			registerTest("PurgedSegments", "Reader reports segments that retention has deleted", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataTableReader::testPurgedSegments, this));
+			registerTest("ThroughputReport", "Synthetic throughput of the write path per codec", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_DataTableReader::testThroughputReport, this));
+		}
+
+	protected:
+
+		typedef std::unique_ptr<LibMCEnv::Impl::IDataTableReader> UReader;
+
+		// The signal capture: 2500 rows in chunks of 100.
+		//   t  timestamp, 10 microseconds per row
+		//   v  float sawtooth 0..249 with a single spike of 5000 at row 1234
+		//   n  row counter
+		//   b  bool that toggles every 100 rows
+		static constexpr uint32_t SIGNAL_ROWCOUNT = 2500;
+		static constexpr uint32_t SIGNAL_CHUNKROWS = 100;
+		static constexpr uint32_t SIGNAL_SPIKEROW = 1234;
+
+		uint64_t signalTimestamp(uint64_t nRow) { return 1000000ULL + nRow * 10; }
+		float signalValue(uint64_t nRow) { return (nRow == SIGNAL_SPIKEROW) ? 5000.0f : (float)(nRow % 250); }
+		uint8_t signalBool(uint64_t nRow) { return (uint8_t)((nRow / 100) % 2); }
+
+		void captureSignal(SFixture& fixture, const std::string& sIdentifier, LibMCEnv::Impl::IDataCaptureOptions* pOptions, uint32_t nRowCount = SIGNAL_ROWCOUNT)
+		{
+			auto pCapture = createCapture(fixture, sIdentifier, pOptions);
+			pCapture->AddColumn("t", "Time", LibMCEnv::eDataTableColumnType::TimestampColumn);
+			pCapture->AddColumn("v", "Value", LibMCEnv::eDataTableColumnType::FloatColumn);
+			pCapture->AddColumn("n", "Counter", LibMCEnv::eDataTableColumnType::Uint64Column);
+			pCapture->AddColumn("b", "Flag", LibMCEnv::eDataTableColumnType::BoolColumn);
+
+			for (uint32_t nFirstRow = 0; nFirstRow < nRowCount; nFirstRow += SIGNAL_CHUNKROWS) {
+				std::vector<uint64_t> timestamps(SIGNAL_CHUNKROWS);
+				std::vector<float> values(SIGNAL_CHUNKROWS);
+				std::vector<uint64_t> counters(SIGNAL_CHUNKROWS);
+				std::vector<uint8_t> flags(SIGNAL_CHUNKROWS);
+				for (uint32_t nIndex = 0; nIndex < SIGNAL_CHUNKROWS; nIndex++) {
+					uint64_t nRow = (uint64_t)nFirstRow + nIndex;
+					timestamps[nIndex] = signalTimestamp(nRow);
+					values[nIndex] = signalValue(nRow);
+					counters[nIndex] = nRow;
+					flags[nIndex] = signalBool(nRow);
+				}
+
+				UChunk pChunk(pCapture->BeginChunk());
+				pChunk->SetTimestampColumnValues(0, timestamps.size(), timestamps.data());
+				pChunk->SetFloatColumnValues(1, values.size(), values.data());
+				pChunk->SetUint64ColumnValues(2, counters.size(), counters.data());
+				pChunk->SetBoolColumnValues(3, flags.size(), flags.data());
+				pCapture->CommitChunk(pChunk.get());
+			}
+
+			pCapture->Finish();
+		}
+
+		// Segments of four chunks: the pages are plain and uncompressed, so that the segment layout is deterministic.
+		UOptions signalOptions(SFixture& fixture, uint64_t nStorageLimitInBytes = 0)
+		{
+			std::vector<AMC::sDataTableV2Column> columns;
+			columns.push_back({ "t", "Time", AMC::eDataTableV2DataType::Timestamp });
+			columns.push_back({ "v", "Value", AMC::eDataTableV2DataType::Float });
+			columns.push_back({ "n", "Counter", AMC::eDataTableV2DataType::Uint64 });
+			columns.push_back({ "b", "Flag", AMC::eDataTableV2DataType::Bool });
+			AMC::CDataTableV2SegmentBuilder sizer(columns, 0, 0, SIGNAL_CHUNKROWS);
+			uint64_t nSegmentSize = sizeof(AMC::sDataTableV2SegmentHeader) + 4 * sizer.getChunkSizeInBytes(SIGNAL_CHUNKROWS) + sizer.getFooterSizeInBytes(4);
+
+			auto pOptions = createOptions(fixture, SIGNAL_CHUNKROWS, nSegmentSize, DATACAPTURE_DEFAULTMAXQUEUEDCHUNKS, LibMCEnv::eDataCaptureBackpressureMode::Block, nStorageLimitInBytes);
+			pOptions->SetColumnEncoding("t", LibMCEnv::eDataCaptureEncoding::Plain);
+			pOptions->SetColumnEncoding("n", LibMCEnv::eDataCaptureEncoding::Plain);
+			pOptions->SetColumnEncoding("b", LibMCEnv::eDataCaptureEncoding::Plain);
+			return pOptions;
+		}
+
+		UReader openReader(SFixture& fixture, const std::string& sIdentifier)
+		{
+			return UReader(fixture.m_pBuildExecution->OpenDataCaptureReader(sIdentifier));
+		}
+
+		uint64_t pageReadCount(LibMCEnv::Impl::IDataTableReader* pReader)
+		{
+			auto pReaderImpl = dynamic_cast<LibMCEnv::Impl::CDataTableReader*>(pReader);
+			assertAssigned(pReaderImpl, "reader implementation");
+			return pReaderImpl->getPageReadCount();
+		}
+
+		std::vector<double> readDoubles(LibMCEnv::Impl::IDataTableReader* pReader, const std::string& sIdentifier, uint64_t nFromRow, uint64_t nRowCount)
+		{
+			uint64_t nNeededCount = 0;
+			pReader->ReadDoubleColumnRange(sIdentifier, nFromRow, nRowCount, 0, &nNeededCount, nullptr);
+			std::vector<double> values((size_t)nNeededCount);
+			if (nNeededCount > 0)
+				pReader->ReadDoubleColumnRange(sIdentifier, nFromRow, nRowCount, values.size(), nullptr, values.data());
+			return values;
+		}
+
+		std::vector<double> readDownsampled(LibMCEnv::Impl::IDataTableReader* pReader, const std::string& sIdentifier, uint64_t nFromRow, uint64_t nRowCount, uint32_t nTargetPoints, LibMCEnv::eDataTableDownsampleMode eMode)
+		{
+			uint64_t nNeededCount = 0;
+			pReader->ReadColumnDownsampled(sIdentifier, nFromRow, nRowCount, nTargetPoints, eMode, 0, &nNeededCount, nullptr);
+			std::vector<double> values((size_t)nNeededCount);
+			if (nNeededCount > 0)
+				pReader->ReadColumnDownsampled(sIdentifier, nFromRow, nRowCount, nTargetPoints, eMode, values.size(), nullptr, values.data());
+			return values;
+		}
+
+		std::vector<uint64_t> findChunks(LibMCEnv::Impl::IDataTableReader* pReader, const std::string& sIdentifier, double dMinValue, double dMaxValue)
+		{
+			uint64_t nNeededCount = 0;
+			pReader->FindChunksInValueRange(sIdentifier, dMinValue, dMaxValue, 0, &nNeededCount, nullptr);
+			std::vector<uint64_t> chunkIndices((size_t)nNeededCount);
+			if (nNeededCount > 0)
+				pReader->FindChunksInValueRange(sIdentifier, dMinValue, dMaxValue, chunkIndices.size(), nullptr, chunkIndices.data());
+			return chunkIndices;
+		}
+
+		void assertSignalIsExact(SFixture& fixture, const std::string& sIdentifier, const std::string& sContext)
+		{
+			auto pReader = openReader(fixture, sIdentifier);
+			assertTrue(pReader->GetRowCount() == SIGNAL_ROWCOUNT, sContext + ": row count");
+
+			std::vector<int64_t> timestamps(SIGNAL_ROWCOUNT);
+			pReader->ReadInt64ColumnRange("t", 0, SIGNAL_ROWCOUNT, timestamps.size(), nullptr, timestamps.data());
+			std::vector<float> values(SIGNAL_ROWCOUNT);
+			pReader->ReadFloatColumnRange("v", 0, SIGNAL_ROWCOUNT, values.size(), nullptr, values.data());
+			std::vector<int64_t> counters(SIGNAL_ROWCOUNT);
+			pReader->ReadInt64ColumnRange("n", 0, SIGNAL_ROWCOUNT, counters.size(), nullptr, counters.data());
+			std::vector<uint8_t> flags(SIGNAL_ROWCOUNT);
+			pReader->ReadBoolColumnRange("b", 0, SIGNAL_ROWCOUNT, flags.size(), nullptr, flags.data());
+
+			bool bExact = true;
+			for (uint64_t nRow = 0; nRow < SIGNAL_ROWCOUNT; nRow++) {
+				bExact = bExact && (timestamps[(size_t)nRow] == (int64_t)signalTimestamp(nRow));
+				bExact = bExact && (values[(size_t)nRow] == signalValue(nRow));
+				bExact = bExact && (counters[(size_t)nRow] == (int64_t)nRow);
+				bExact = bExact && (flags[(size_t)nRow] == signalBool(nRow));
+			}
+			assertTrue(bExact, sContext + ": all columns are exact");
+		}
+
+		void testDefaultEncodingsCompress()
+		{
+			auto fixture = createFixture("defaults");
+
+			// Default options: LZ4, delta for timestamps and counters, bit packing for bools, plain floats.
+			UOptions pOptions(fixture.m_pBuildExecution->CreateDataCaptureOptions());
+			pOptions->SetChunkRowCount(SIGNAL_CHUNKROWS);
+			captureSignal(fixture, "signal", pOptions.get());
+
+			assertSignalIsExact(fixture, "signal", "default encodings");
+
+			// 8 + 4 + 8 + 1 bytes per row in plain form
+			uint64_t nPlainSize = (uint64_t)SIGNAL_ROWCOUNT * 21;
+			uint64_t nStoredSize = fixture.m_pExecution->RetrieveDataCapture("signal")->GetStoredSizeInBytes();
+			assertTrue(nStoredSize * 2 < nPlainSize, "encoded capture is less than half of the plain data, got " + std::to_string(nStoredSize) + " of " + std::to_string(nPlainSize) + " bytes");
+
+			// The segment is still an ordinary data table stream.
+			UTable pTable(fixture.m_pBuildExecution->LoadDataCaptureSegment("signal", 0));
+			assertTrue(pTable->GetRowCount64() == SIGNAL_ROWCOUNT, "encoded segment loads as data table");
+			std::vector<uint64_t> timestamps(SIGNAL_ROWCOUNT);
+			pTable->GetTimestampColumnValues("t", timestamps.size(), nullptr, timestamps.data());
+			assertTrue((timestamps[0] == signalTimestamp(0)) && (timestamps[SIGNAL_ROWCOUNT - 1] == signalTimestamp(SIGNAL_ROWCOUNT - 1)), "delta encoded timestamps load exactly");
+			std::vector<uint8_t> flags(SIGNAL_ROWCOUNT);
+			pTable->GetBoolColumnValues("b", flags.size(), nullptr, flags.data());
+			assertTrue((flags[99] == 0) && (flags[100] == 1) && (flags[200] == 0), "bit packed bools load exactly");
+		}
+
+		void testCompressionModes()
+		{
+			auto fixture = createFixture("codecs");
+
+			uint64_t nUncompressedSize = 0;
+			for (auto eCompression : { LibMCEnv::eDataCaptureCompression::None, LibMCEnv::eDataCaptureCompression::LZ4, LibMCEnv::eDataCaptureCompression::Deflate }) {
+				std::string sIdentifier = "codec" + std::to_string((uint32_t)eCompression);
+
+				UOptions pOptions(fixture.m_pBuildExecution->CreateDataCaptureOptions());
+				pOptions->SetChunkRowCount(SIGNAL_CHUNKROWS);
+				pOptions->SetCompression(eCompression);
+				assertTrue(pOptions->GetCompression() == eCompression, "compression option is stored");
+
+				captureSignal(fixture, sIdentifier, pOptions.get());
+				assertSignalIsExact(fixture, sIdentifier, sIdentifier);
+
+				uint64_t nStoredSize = fixture.m_pExecution->RetrieveDataCapture(sIdentifier)->GetStoredSizeInBytes();
+				// A page that a codec does not shrink is stored uncompressed, so a codec never makes the capture larger.
+				if (eCompression == LibMCEnv::eDataCaptureCompression::None)
+					nUncompressedSize = nStoredSize;
+				else
+					assertTrue(nStoredSize <= nUncompressedSize, sIdentifier + " is not larger than the uncompressed capture");
+
+				if (eCompression == LibMCEnv::eDataCaptureCompression::Deflate)
+					assertTrue(nStoredSize < nUncompressedSize, sIdentifier + " is smaller than the uncompressed capture");
+			}
+
+			UOptions pOptions(fixture.m_pBuildExecution->CreateDataCaptureOptions());
+			assertTrue(pOptions->GetCompression() == LibMCEnv::eDataCaptureCompression::LZ4, "default compression is LZ4");
+			assertTrue(errorCodeOf([&]() { pOptions->SetCompression(LibMCEnv::eDataCaptureCompression::Unknown); }) == LIBMCENV_ERROR_INVALIDDATACAPTUREOPTION, "unknown compression is rejected");
+		}
+
+		void testQuantizedDoubleColumn()
+		{
+			auto fixture = createFixture("quantized");
+
+			UOptions pOptions(fixture.m_pBuildExecution->CreateDataCaptureOptions());
+			pOptions->SetChunkRowCount(500);
+			pOptions->SetDoubleQuantization("q", 0.01);
+
+			auto pCapture = createCapture(fixture, "quantized", pOptions.get());
+			pCapture->AddColumn("q", "Quantised", LibMCEnv::eDataTableColumnType::DoubleColumn);
+			pCapture->AddColumn("x", "Exact", LibMCEnv::eDataTableColumnType::DoubleColumn);
+
+			std::vector<double> values(1000);
+			for (size_t nIndex = 0; nIndex < values.size(); nIndex++)
+				values[nIndex] = 1500.0 + std::sin(nIndex * 0.02) * 321.123456789;
+
+			for (size_t nFirstRow = 0; nFirstRow < values.size(); nFirstRow += 500) {
+				UChunk pChunk(pCapture->BeginChunk());
+				pChunk->SetDoubleColumnValues(0, 500, values.data() + nFirstRow);
+				pChunk->SetDoubleColumnValues(1, 500, values.data() + nFirstRow);
+				pCapture->CommitChunk(pChunk.get());
+			}
+			pCapture->Finish();
+
+			auto pReader = openReader(fixture, "quantized");
+			assertTrue(pReader->GetColumnQuantization("q") == 0.01, "quantisation step is recorded");
+			assertTrue(pReader->GetColumnQuantization("x") == 0.0, "a column that did not ask for it is not quantised");
+
+			auto quantized = readDoubles(pReader.get(), "q", 0, 1000);
+			auto exact = readDoubles(pReader.get(), "x", 0, 1000);
+			assertTrue(exact == values, "unquantised double column is bit-exact");
+
+			bool bWithinBound = true;
+			bool bLossy = false;
+			for (size_t nIndex = 0; nIndex < values.size(); nIndex++) {
+				bWithinBound = bWithinBound && (std::fabs(quantized[nIndex] - values[nIndex]) <= 0.005 + 1.0e-9);
+				bLossy = bLossy || (quantized[nIndex] != values[nIndex]);
+			}
+			assertTrue(bWithinBound, "quantised values are within half a step");
+			assertTrue(bLossy, "quantisation is lossy for this signal");
+
+			// The quantised column is much smaller than the exact one.
+			UOptions pExactOptions(fixture.m_pBuildExecution->CreateDataCaptureOptions());
+			auto pExactOnly = createCapture(fixture, "exactonly", pExactOptions.get());
+			pExactOnly->AddColumn("x", "Exact", LibMCEnv::eDataTableColumnType::DoubleColumn);
+			auto pQuantizedOptions = UOptions(fixture.m_pBuildExecution->CreateDataCaptureOptions());
+			pQuantizedOptions->SetDoubleQuantization("q", 0.01);
+			auto pQuantizedOnly = createCapture(fixture, "quantizedonly", pQuantizedOptions.get());
+			pQuantizedOnly->AddColumn("q", "Quantised", LibMCEnv::eDataTableColumnType::DoubleColumn);
+			{
+				UChunk pChunk(pExactOnly->BeginChunk());
+				pChunk->SetDoubleColumnValues(0, values.size(), values.data());
+				pExactOnly->CommitChunk(pChunk.get());
+				UChunk pQuantizedChunk(pQuantizedOnly->BeginChunk());
+				pQuantizedChunk->SetDoubleColumnValues(0, values.size(), values.data());
+				pQuantizedOnly->CommitChunk(pQuantizedChunk.get());
+			}
+			pExactOnly->Finish();
+			pQuantizedOnly->Finish();
+			assertTrue(pQuantizedOnly->GetStorageSizeInBytes() * 2 < pExactOnly->GetStorageSizeInBytes(), "quantised column takes less than half of the exact column, got " + std::to_string(pQuantizedOnly->GetStorageSizeInBytes()) + " of " + std::to_string(pExactOnly->GetStorageSizeInBytes()) + " bytes");
+		}
+
+		void testEncodingOptionValidation()
+		{
+			auto fixture = createFixture("encodingoptions");
+
+			UOptions pOptions(fixture.m_pBuildExecution->CreateDataCaptureOptions());
+			assertTrue(errorCodeOf([&]() { pOptions->SetDoubleQuantization("q", -0.1); }) == LIBMCENV_ERROR_INVALIDDATACAPTUREOPTION, "negative quantisation step is rejected");
+			assertTrue(errorCodeOf([&]() { pOptions->SetDoubleQuantization("q", std::numeric_limits<double>::quiet_NaN()); }) == LIBMCENV_ERROR_INVALIDDATACAPTUREOPTION, "NaN quantisation step is rejected");
+			assertTrue(errorCodeOf([&]() { pOptions->SetDoubleQuantization("", 0.1); }) == LIBMCENV_ERROR_INVALIDDATACAPTUREOPTION, "empty column identifier is rejected");
+			assertTrue(errorCodeOf([&]() { pOptions->SetColumnEncoding("n", LibMCEnv::eDataCaptureEncoding::Unknown); }) == LIBMCENV_ERROR_INVALIDDATACAPTUREOPTION, "unknown encoding is rejected");
+
+			// The schema is only known when recording starts, so that is where the options are checked.
+			auto tryStart = [&](const std::string& sIdentifier, LibMCEnv::Impl::IDataCaptureOptions* pCaptureOptions) {
+				auto pCapture = createCapture(fixture, sIdentifier, pCaptureOptions);
+				pCapture->AddColumn("n", "Counter", LibMCEnv::eDataTableColumnType::Uint64Column);
+				pCapture->AddColumn("f", "Float", LibMCEnv::eDataTableColumnType::FloatColumn);
+				pCapture->AddColumn("d", "Double", LibMCEnv::eDataTableColumnType::DoubleColumn);
+				int32_t nErrorCode = errorCodeOf([&]() { UChunk pChunk(pCapture->BeginChunk()); });
+				pCapture->Abort();
+				return nErrorCode;
+			};
+
+			{
+				UOptions pUnknownColumn(fixture.m_pBuildExecution->CreateDataCaptureOptions());
+				pUnknownColumn->SetColumnEncoding("missing", LibMCEnv::eDataCaptureEncoding::Plain);
+				assertTrue(tryStart("unknowncolumn", pUnknownColumn.get()) == LIBMCENV_ERROR_DATACAPTURECOLUMNNOTFOUND, "encoding for an unknown column is rejected");
+			}
+			{
+				UOptions pUnknownQuantization(fixture.m_pBuildExecution->CreateDataCaptureOptions());
+				pUnknownQuantization->SetDoubleQuantization("missing", 0.1);
+				assertTrue(tryStart("unknownquantization", pUnknownQuantization.get()) == LIBMCENV_ERROR_DATACAPTURECOLUMNNOTFOUND, "quantisation for an unknown column is rejected");
+			}
+			{
+				UOptions pFloatQuantization(fixture.m_pBuildExecution->CreateDataCaptureOptions());
+				pFloatQuantization->SetDoubleQuantization("f", 0.1);
+				assertTrue(tryStart("floatquantization", pFloatQuantization.get()) == LIBMCENV_ERROR_INVALIDDATACAPTUREOPTION, "quantisation of a float column is rejected");
+			}
+			{
+				UOptions pBitPackInteger(fixture.m_pBuildExecution->CreateDataCaptureOptions());
+				pBitPackInteger->SetColumnEncoding("n", LibMCEnv::eDataCaptureEncoding::BitPack);
+				assertTrue(tryStart("bitpackinteger", pBitPackInteger.get()) == LIBMCENV_ERROR_INVALIDDATACAPTUREOPTION, "bit packing of an integer column is rejected");
+			}
+			{
+				UOptions pDeltaFloat(fixture.m_pBuildExecution->CreateDataCaptureOptions());
+				pDeltaFloat->SetColumnEncoding("f", LibMCEnv::eDataCaptureEncoding::Delta);
+				assertTrue(tryStart("deltafloat", pDeltaFloat.get()) == LIBMCENV_ERROR_INVALIDDATACAPTUREOPTION, "delta encoding of a float column is rejected");
+			}
+			{
+				UOptions pPlainQuantized(fixture.m_pBuildExecution->CreateDataCaptureOptions());
+				pPlainQuantized->SetDoubleQuantization("d", 0.1);
+				pPlainQuantized->SetColumnEncoding("d", LibMCEnv::eDataCaptureEncoding::Plain);
+				assertTrue(tryStart("plainquantized", pPlainQuantized.get()) == LIBMCENV_ERROR_INVALIDDATACAPTUREOPTION, "plain encoding of a quantised column is rejected");
+			}
+			{
+				// Automatic removes an explicit encoding again, and a step of 0 removes the quantisation.
+				UOptions pReset(fixture.m_pBuildExecution->CreateDataCaptureOptions());
+				pReset->SetColumnEncoding("missing", LibMCEnv::eDataCaptureEncoding::Plain);
+				pReset->SetColumnEncoding("missing", LibMCEnv::eDataCaptureEncoding::Automatic);
+				pReset->SetDoubleQuantization("f", 0.1);
+				pReset->SetDoubleQuantization("f", 0.0);
+				assertTrue(tryStart("reset", pReset.get()) == 0, "options that have been reset are accepted");
+			}
+		}
+
+		void testSchemaAndChunks()
+		{
+			auto fixture = createFixture("schema");
+			auto pOptions = signalOptions(fixture);
+			captureSignal(fixture, "signal", pOptions.get());
+
+			auto pReader = openReader(fixture, "signal");
+			assertTrue(pReader->GetRowCount() == SIGNAL_ROWCOUNT, "row count");
+			assertTrue(pReader->GetFirstAvailableRow() == 0, "all rows are available");
+			assertTrue(pReader->GetColumnCount() == 4, "column count");
+			assertTrue(pReader->HasColumn("v"), "column v exists");
+			assertFalse(pReader->HasColumn("missing"), "unknown column does not exist");
+
+			std::string sIdentifier;
+			std::string sDescription;
+			LibMCEnv::eDataTableColumnType eColumnType = LibMCEnv::eDataTableColumnType::Unknown;
+			pReader->GetColumnInformation(1, sIdentifier, sDescription, eColumnType);
+			assertTrue((sIdentifier == "v") && (sDescription == "Value") && (eColumnType == LibMCEnv::eDataTableColumnType::FloatColumn), "column information");
+			assertTrue(errorCodeOf([&]() { pReader->GetColumnInformation(9, sIdentifier, sDescription, eColumnType); }) == LIBMCENV_ERROR_INVALIDCOLUMNINDEX, "column index out of bounds is rejected");
+
+			// 25 chunks in segments of four
+			assertTrue(pReader->GetChunkCount() == 25, "chunk count");
+			assertTrue(pReader->GetSegmentCount() == 7, "segment count");
+
+			uint64_t nFirstRow = 0;
+			uint64_t nRowCount = 0;
+			uint64_t nSizeInBytes = 0;
+			bool bIsAvailable = false;
+			pReader->GetSegmentInformation(2, nFirstRow, nRowCount, nSizeInBytes, bIsAvailable);
+			assertTrue((nFirstRow == 800) && (nRowCount == 400) && bIsAvailable && (nSizeInBytes > 0), "segment information");
+			pReader->GetSegmentInformation(6, nFirstRow, nRowCount, nSizeInBytes, bIsAvailable);
+			assertTrue((nFirstRow == 2400) && (nRowCount == 100), "the last segment holds the remaining chunk");
+			assertTrue(errorCodeOf([&]() { pReader->GetSegmentInformation(7, nFirstRow, nRowCount, nSizeInBytes, bIsAvailable); }) == LIBMCENV_ERROR_INVALIDDATACAPTURESEGMENTINDEX, "segment index out of bounds is rejected");
+
+			uint32_t nSegmentIndex = 0;
+			pReader->GetChunkInformation(7, nSegmentIndex, nFirstRow, nRowCount, bIsAvailable);
+			assertTrue((nSegmentIndex == 1) && (nFirstRow == 700) && (nRowCount == 100) && bIsAvailable, "chunk information");
+			pReader->GetChunkInformation(24, nSegmentIndex, nFirstRow, nRowCount, bIsAvailable);
+			assertTrue((nSegmentIndex == 6) && (nFirstRow == 2400) && (nRowCount == 100), "last chunk information");
+			assertTrue(errorCodeOf([&]() { pReader->GetChunkInformation(25, nSegmentIndex, nFirstRow, nRowCount, bIsAvailable); }) == LIBMCENV_ERROR_INVALIDDATATABLECHUNKINDEX, "chunk index out of bounds is rejected");
+
+			assertTrue(dataErrorCodeOf([&]() { UReader pMissing(fixture.m_pBuildExecution->OpenDataCaptureReader("missing")); }) == LIBMCDATA_ERROR_DATACAPTURENOTFOUND, "reader on an unknown capture is rejected");
+
+			// Opening a reader reads no page.
+			assertTrue(pageReadCount(pReader.get()) == 0, "schema and chunk queries read no page");
+		}
+
+		void testRangeReads()
+		{
+			auto fixture = createFixture("ranges");
+			auto pOptions = signalOptions(fixture);
+			captureSignal(fixture, "signal", pOptions.get());
+			auto pReader = openReader(fixture, "signal");
+
+			// Across chunk boundaries and the segment boundary at row 400
+			auto counters = readDoubles(pReader.get(), "n", 95, 310);
+			assertTrue(counters.size() == 310, "range size");
+			bool bInOrder = true;
+			for (size_t nIndex = 0; nIndex < counters.size(); nIndex++)
+				bInOrder = bInOrder && (counters[nIndex] == (double)(95 + nIndex));
+			assertTrue(bInOrder, "range across chunk and segment boundaries is in order");
+
+			// The whole capture across all seven segments
+			assertSignalIsExact(fixture, "signal", "plain capture");
+
+			// The spike
+			std::vector<float> values(10);
+			pReader->ReadFloatColumnRange("v", 1230, 10, values.size(), nullptr, values.data());
+			assertTrue((values[3] == 233.0f) && (values[4] == 5000.0f) && (values[5] == 235.0f), "float range holds the spike");
+
+			// Every column type reads as double
+			auto timestamps = readDoubles(pReader.get(), "t", 2499, 1);
+			assertTrue(timestamps[0] == (double)signalTimestamp(2499), "timestamp as double");
+			auto flags = readDoubles(pReader.get(), "b", 99, 2);
+			assertTrue((flags[0] == 0.0) && (flags[1] == 1.0), "bool as double");
+			auto valuesAsDouble = readDoubles(pReader.get(), "v", 1234, 1);
+			assertTrue(valuesAsDouble[0] == 5000.0, "float as double");
+
+			std::vector<uint8_t> flagBytes(20);
+			pReader->ReadBoolColumnRange("b", 190, 20, flagBytes.size(), nullptr, flagBytes.data());
+			assertTrue((flagBytes[9] == 1) && (flagBytes[10] == 0), "bool range across a chunk boundary");
+
+			std::vector<int64_t> flagsAsInt(2);
+			pReader->ReadInt64ColumnRange("b", 99, 2, flagsAsInt.size(), nullptr, flagsAsInt.data());
+			assertTrue((flagsAsInt[0] == 0) && (flagsAsInt[1] == 1), "bool as integer");
+
+			// An empty range at the end is valid.
+			assertTrue(readDoubles(pReader.get(), "n", SIGNAL_ROWCOUNT, 0).empty(), "empty range at the end");
+
+			assertTrue(errorCodeOf([&]() { readDoubles(pReader.get(), "n", 2400, 101); }) == LIBMCENV_ERROR_INVALIDDATATABLEROWRANGE, "range beyond the end is rejected");
+			assertTrue(errorCodeOf([&]() { readDoubles(pReader.get(), "n", SIGNAL_ROWCOUNT + 1, 0); }) == LIBMCENV_ERROR_INVALIDDATATABLEROWRANGE, "start beyond the end is rejected");
+			assertTrue(errorCodeOf([&]() { readDoubles(pReader.get(), "n", 10, UINT64_MAX); }) == LIBMCENV_ERROR_INVALIDDATATABLEROWRANGE, "overflowing range is rejected");
+			assertTrue(errorCodeOf([&]() { readDoubles(pReader.get(), "missing", 0, 1); }) == LIBMCENV_ERROR_DATACAPTURECOLUMNNOTFOUND, "unknown column is rejected");
+
+			std::vector<float> floatBuffer(10);
+			assertTrue(errorCodeOf([&]() { pReader->ReadFloatColumnRange("n", 0, 10, floatBuffer.size(), nullptr, floatBuffer.data()); }) == LIBMCENV_ERROR_DATATABLECOLUMNTYPEMISMATCH, "integer column is not read as float");
+			std::vector<int64_t> intBuffer(10);
+			assertTrue(errorCodeOf([&]() { pReader->ReadInt64ColumnRange("v", 0, 10, intBuffer.size(), nullptr, intBuffer.data()); }) == LIBMCENV_ERROR_DATATABLECOLUMNTYPEMISMATCH, "float column is not read as integer");
+			std::vector<uint8_t> boolBuffer(10);
+			assertTrue(errorCodeOf([&]() { pReader->ReadBoolColumnRange("n", 0, 10, boolBuffer.size(), nullptr, boolBuffer.data()); }) == LIBMCENV_ERROR_DATATABLECOLUMNTYPEMISMATCH, "integer column is not read as bool");
+
+			std::vector<double> tooSmall(5);
+			assertTrue(errorCodeOf([&]() { pReader->ReadDoubleColumnRange("n", 0, 10, tooSmall.size(), nullptr, tooSmall.data()); }) == LIBMCENV_ERROR_BUFFERTOOSMALL, "small buffer is rejected");
+		}
+
+		void testReadSelectivity()
+		{
+			auto fixture = createFixture("selectivity");
+			auto pOptions = signalOptions(fixture);
+			captureSignal(fixture, "signal", pOptions.get());
+			auto pReader = openReader(fixture, "signal");
+
+			// One chunk of one column is one page, no matter how many columns and chunks the capture has.
+			readDoubles(pReader.get(), "v", 200, 100);
+			assertTrue(pageReadCount(pReader.get()) == 1, "a range inside one chunk reads one page, got " + std::to_string(pageReadCount(pReader.get())));
+
+			// Rows 250 to 449 overlap the chunks 2, 3 and 4.
+			uint64_t nBefore = pageReadCount(pReader.get());
+			readDoubles(pReader.get(), "n", 250, 200);
+			assertTrue(pageReadCount(pReader.get()) - nBefore == 3, "a range over three chunks reads three pages");
+
+			// A single row
+			nBefore = pageReadCount(pReader.get());
+			readDoubles(pReader.get(), "t", 1999, 1);
+			assertTrue(pageReadCount(pReader.get()) - nBefore == 1, "a single row reads one page");
+
+			// The same page again is served from the page cache.
+			nBefore = pageReadCount(pReader.get());
+			readDoubles(pReader.get(), "t", 1950, 10);
+			assertTrue(pageReadCount(pReader.get()) == nBefore, "the last page is not read twice");
+
+			// A whole column reads one page per chunk: a quarter of the pages of the four column capture.
+			auto pFreshReader = openReader(fixture, "signal");
+			readDoubles(pFreshReader.get(), "v", 0, SIGNAL_ROWCOUNT);
+			assertTrue(pageReadCount(pFreshReader.get()) == 25, "a whole column reads one page per chunk");
+
+			// The size query of the two-call pattern reads nothing.
+			auto pQueryReader = openReader(fixture, "signal");
+			uint64_t nNeededCount = 0;
+			pQueryReader->ReadDoubleColumnRange("v", 0, SIGNAL_ROWCOUNT, 0, &nNeededCount, nullptr);
+			assertTrue((nNeededCount == SIGNAL_ROWCOUNT) && (pageReadCount(pQueryReader.get()) == 0), "the size query reads no page");
+		}
+
+		void testChunkStatisticsAndValueSearch()
+		{
+			auto fixture = createFixture("statistics");
+			auto pOptions = signalOptions(fixture);
+			captureSignal(fixture, "signal", pOptions.get());
+			auto pReader = openReader(fixture, "signal");
+
+			double dMinValue = 0.0;
+			double dMaxValue = 0.0;
+
+			assertTrue(pReader->GetChunkStatistics(0, "v", dMinValue, dMaxValue), "chunk 0 has statistics");
+			assertTrue((dMinValue == 0.0) && (dMaxValue == 99.0), "chunk 0 value range");
+
+			// Chunk 12 holds the rows 1200 to 1299: the sawtooth wraps and the spike is inside.
+			assertTrue(pReader->GetChunkStatistics(12, "v", dMinValue, dMaxValue), "chunk 12 has statistics");
+			assertTrue((dMinValue == 0.0) && (dMaxValue == 5000.0), "chunk 12 holds the spike");
+
+			assertTrue(pReader->GetChunkStatistics(3, "t", dMinValue, dMaxValue), "timestamp statistics");
+			assertTrue((dMinValue == (double)signalTimestamp(300)) && (dMaxValue == (double)signalTimestamp(399)), "timestamp range of chunk 3");
+
+			assertTrue(pReader->GetChunkStatistics(1, "b", dMinValue, dMaxValue), "bool statistics");
+			assertTrue((dMinValue == 1.0) && (dMaxValue == 1.0), "constant bool chunk");
+
+			assertTrue(errorCodeOf([&]() { pReader->GetChunkStatistics(25, "v", dMinValue, dMaxValue); }) == LIBMCENV_ERROR_INVALIDDATATABLECHUNKINDEX, "chunk index out of bounds is rejected");
+			assertTrue(errorCodeOf([&]() { pReader->GetChunkStatistics(0, "missing", dMinValue, dMaxValue); }) == LIBMCENV_ERROR_DATACAPTURECOLUMNNOTFOUND, "unknown column is rejected");
+
+			// Where did the value exceed 1000? Only the chunk with the spike can hold a match.
+			auto spikeChunks = findChunks(pReader.get(), "v", 1000.0, 10000.0);
+			assertTrue((spikeChunks.size() == 1) && (spikeChunks[0] == 12), "only the spike chunk matches the value range");
+
+			// Values 240 to 249 occur at the end of every sawtooth period.
+			auto highChunks = findChunks(pReader.get(), "v", 240.0, 249.0);
+			std::vector<uint64_t> expectedChunks = { 2, 4, 7, 9, 12, 14, 17, 19, 22, 24 };
+			assertTrue(highChunks == expectedChunks, "chunks that reach the end of the sawtooth");
+
+			assertTrue(findChunks(pReader.get(), "v", 6000.0, 7000.0).empty(), "no chunk above the spike");
+			assertTrue(findChunks(pReader.get(), "v", 10.0, 5.0).empty(), "an inverted range matches nothing");
+			assertTrue(findChunks(pReader.get(), "n", 700.0, 700.0).size() == 1, "a single counter value is in one chunk");
+
+			// Statistics and search use the page directory only.
+			assertTrue(pageReadCount(pReader.get()) == 0, "statistics and value search read no page");
+		}
+
+		void testDownsampling()
+		{
+			auto fixture = createFixture("downsample");
+			auto pOptions = signalOptions(fixture);
+			captureSignal(fixture, "signal", pOptions.get());
+			auto pReader = openReader(fixture, "signal");
+
+			// Ten buckets of 250 rows, which is one sawtooth period each.
+			auto envelope = readDownsampled(pReader.get(), "v", 0, SIGNAL_ROWCOUNT, 10, LibMCEnv::eDataTableDownsampleMode::MinMax);
+			assertTrue(envelope.size() == 20, "MinMax returns two values per bucket");
+			for (size_t nBucket = 0; nBucket < 10; nBucket++) {
+				assertTrue(envelope[2 * nBucket] == 0.0, "minimum of bucket " + std::to_string(nBucket));
+				assertTrue(envelope[2 * nBucket + 1] == ((nBucket == 4) ? 5000.0 : 249.0), "maximum of bucket " + std::to_string(nBucket));
+			}
+
+			// Chunks that lie inside one bucket are answered from the page statistics. Only the five chunks
+			// that straddle a bucket boundary are read: 250, 750, 1250, 1750 and 2250 fall inside a chunk.
+			assertTrue(pageReadCount(pReader.get()) == 5, "MinMax reads only the chunks on bucket boundaries, got " + std::to_string(pageReadCount(pReader.get())));
+
+			// Stride returns the first value of each bucket and misses the spike that MinMax preserves.
+			auto pStrideReader = openReader(fixture, "signal");
+			auto stride = readDownsampled(pStrideReader.get(), "v", 0, SIGNAL_ROWCOUNT, 10, LibMCEnv::eDataTableDownsampleMode::Stride);
+			assertTrue(stride.size() == 10, "Stride returns one value per bucket");
+			bool bSpikeFound = false;
+			for (double dValue : stride) {
+				assertTrue(dValue == 0.0, "every bucket starts at the beginning of a sawtooth period");
+				bSpikeFound = bSpikeFound || (dValue == 5000.0);
+			}
+			assertFalse(bSpikeFound, "Stride hides the spike");
+			assertTrue(pageReadCount(pStrideReader.get()) == 10, "Stride reads one page per bucket");
+
+			auto average = readDownsampled(pReader.get(), "v", 0, SIGNAL_ROWCOUNT, 10, LibMCEnv::eDataTableDownsampleMode::Average);
+			assertTrue(average.size() == 10, "Average returns one value per bucket");
+			assertTrue(std::fabs(average[0] - 124.5) < 1.0e-9, "average of a sawtooth period");
+			assertTrue(std::fabs(average[4] - (124.5 + (5000.0 - 234.0) / 250.0)) < 1.0e-9, "average of the period with the spike");
+
+			// Fewer rows than target points: one bucket per row.
+			auto fewValues = readDownsampled(pReader.get(), "n", 1000, 5, 100, LibMCEnv::eDataTableDownsampleMode::MinMax);
+			assertTrue(fewValues.size() == 10, "five rows make five buckets");
+			assertTrue((fewValues[0] == 1000.0) && (fewValues[1] == 1000.0) && (fewValues[8] == 1004.0) && (fewValues[9] == 1004.0), "a bucket of one row has equal minimum and maximum");
+
+			// Buckets of uneven size cover the range without gaps: 1000 rows in three buckets start at 0, 333 and 666.
+			auto uneven = readDownsampled(pReader.get(), "n", 0, 1000, 3, LibMCEnv::eDataTableDownsampleMode::Stride);
+			assertTrue((uneven.size() == 3) && (uneven[0] == 0.0) && (uneven[1] == 333.0) && (uneven[2] == 666.0), "uneven bucket starts");
+			auto unevenEnvelope = readDownsampled(pReader.get(), "n", 0, 1000, 3, LibMCEnv::eDataTableDownsampleMode::MinMax);
+			assertTrue((unevenEnvelope[0] == 0.0) && (unevenEnvelope[1] == 332.0) && (unevenEnvelope[2] == 333.0) && (unevenEnvelope[3] == 665.0) && (unevenEnvelope[4] == 666.0) && (unevenEnvelope[5] == 999.0), "uneven buckets are contiguous");
+
+			// A range that does not start at a chunk boundary
+			auto offset = readDownsampled(pReader.get(), "n", 150, 600, 2, LibMCEnv::eDataTableDownsampleMode::MinMax);
+			assertTrue((offset[0] == 150.0) && (offset[1] == 449.0) && (offset[2] == 450.0) && (offset[3] == 749.0), "envelope of a range inside the capture");
+
+			assertTrue(readDownsampled(pReader.get(), "n", 100, 0, 10, LibMCEnv::eDataTableDownsampleMode::MinMax).empty(), "an empty range has no buckets");
+
+			assertTrue(errorCodeOf([&]() { readDownsampled(pReader.get(), "v", 0, 100, 0, LibMCEnv::eDataTableDownsampleMode::MinMax); }) == LIBMCENV_ERROR_INVALIDDOWNSAMPLEPARAMETERS, "zero target points are rejected");
+			assertTrue(errorCodeOf([&]() { readDownsampled(pReader.get(), "v", 0, 100, 10, LibMCEnv::eDataTableDownsampleMode::Unknown); }) == LIBMCENV_ERROR_INVALIDDOWNSAMPLEPARAMETERS, "unknown mode is rejected");
+			assertTrue(errorCodeOf([&]() { readDownsampled(pReader.get(), "v", 2000, 1000, 10, LibMCEnv::eDataTableDownsampleMode::MinMax); }) == LIBMCENV_ERROR_INVALIDDATATABLEROWRANGE, "range beyond the end is rejected");
+		}
+
+		void testExtractDataTable()
+		{
+			auto fixture = createFixture("extract");
+			auto pOptions = signalOptions(fixture);
+			captureSignal(fixture, "signal", pOptions.get());
+			auto pReader = openReader(fixture, "signal");
+
+			UTable pTable(pReader->ExtractDataTable(1230, 10, "t, v"));
+			assertTrue(pTable->GetColumnCount() == 2, "two columns extracted");
+			assertTrue(pTable->GetRowCount64() == 10, "ten rows extracted");
+			assertTrue(pTable->GetColumnIdentifier(0) == "t", "column order follows the request");
+			assertTrue(pTable->GetColumnType(1) == LibMCEnv::eDataTableColumnType::FloatColumn, "column type is kept");
+			assertTrue(pTable->GetColumnDescription(1) == "Value", "column description is kept");
+
+			std::vector<uint64_t> timestamps(10);
+			pTable->GetTimestampColumnValues("t", timestamps.size(), nullptr, timestamps.data());
+			assertTrue((timestamps[0] == signalTimestamp(1230)) && (timestamps[9] == signalTimestamp(1239)), "extracted timestamps");
+			std::vector<float> values(10);
+			pTable->GetFloatColumnValues("v", values.size(), nullptr, values.data());
+			assertTrue(values[4] == 5000.0f, "extracted values hold the spike");
+
+			// An empty column list extracts all columns, across a segment boundary.
+			UTable pAllColumns(pReader->ExtractDataTable(390, 20, ""));
+			assertTrue(pAllColumns->GetColumnCount() == 4, "all columns extracted");
+			std::vector<uint64_t> counters(20);
+			pAllColumns->GetUint64ColumnValues("n", counters.size(), nullptr, counters.data());
+			assertTrue((counters[0] == 390) && (counters[19] == 409), "extracted counters across the segment boundary");
+			std::vector<uint8_t> flags(20);
+			pAllColumns->GetBoolColumnValues("b", flags.size(), nullptr, flags.data());
+			assertTrue((flags[9] == 1) && (flags[10] == 0), "extracted bools");
+
+			UTable pEmpty(pReader->ExtractDataTable(100, 0, "n"));
+			assertTrue((pEmpty->GetColumnCount() == 1) && (pEmpty->GetRowCount64() == 0), "an empty range extracts an empty table");
+
+			assertTrue(errorCodeOf([&]() { UTable pInvalid(pReader->ExtractDataTable(0, 10, "t,missing")); }) == LIBMCENV_ERROR_DATACAPTURECOLUMNNOTFOUND, "unknown column is rejected");
+			assertTrue(errorCodeOf([&]() { UTable pInvalid(pReader->ExtractDataTable(2495, 10, "t")); }) == LIBMCENV_ERROR_INVALIDDATATABLEROWRANGE, "range beyond the end is rejected");
+		}
+
+		void testPurgedSegments()
+		{
+			auto fixture = createFixture("purged");
+
+			// The limit holds three of the seven segments: six full ones of four chunks and one of a single chunk.
+			auto pProbeOptions = signalOptions(fixture);
+			uint64_t nSegmentSize = pProbeOptions->GetSegmentSizeInBytes();
+			auto pOptions = signalOptions(fixture, 3 * nSegmentSize);
+			captureSignal(fixture, "signal", pOptions.get());
+
+			auto pReader = openReader(fixture, "signal");
+			assertTrue(pReader->GetSegmentCount() == 7, "all segments are in the manifest");
+			assertTrue(pReader->GetRowCount() == SIGNAL_ROWCOUNT, "the row count includes the deleted rows");
+			assertTrue(pReader->GetChunkCount() == 25, "the chunk count includes the deleted chunks");
+
+			uint64_t nFirstAvailableRow = pReader->GetFirstAvailableRow();
+			assertTrue((nFirstAvailableRow > 0) && (nFirstAvailableRow < SIGNAL_ROWCOUNT) && ((nFirstAvailableRow % 400) == 0), "the oldest segments have been deleted, first available row is " + std::to_string(nFirstAvailableRow));
+
+			uint64_t nFirstRow = 0;
+			uint64_t nRowCount = 0;
+			uint64_t nSizeInBytes = 0;
+			bool bIsAvailable = true;
+			pReader->GetSegmentInformation(0, nFirstRow, nRowCount, nSizeInBytes, bIsAvailable);
+			assertFalse(bIsAvailable, "the first segment is deleted");
+			assertTrue((nFirstRow == 0) && (nRowCount == 400), "a deleted segment keeps its row range");
+			pReader->GetSegmentInformation(6, nFirstRow, nRowCount, nSizeInBytes, bIsAvailable);
+			assertTrue(bIsAvailable, "the newest segment is stored");
+
+			uint32_t nSegmentIndex = 0;
+			pReader->GetChunkInformation(1, nSegmentIndex, nFirstRow, nRowCount, bIsAvailable);
+			assertTrue((nSegmentIndex == 0) && !bIsAvailable && (nRowCount == 0), "a chunk of a deleted segment is not available");
+			pReader->GetChunkInformation(24, nSegmentIndex, nFirstRow, nRowCount, bIsAvailable);
+			assertTrue((nSegmentIndex == 6) && bIsAvailable && (nFirstRow == 2400), "chunk indices are stable when old segments are deleted");
+
+			double dMinValue = 0.0;
+			double dMaxValue = 0.0;
+			assertFalse(pReader->GetChunkStatistics(1, "v", dMinValue, dMaxValue), "a deleted chunk has no statistics");
+
+			// Available rows read normally, deleted rows are reported.
+			auto counters = readDoubles(pReader.get(), "n", nFirstAvailableRow, SIGNAL_ROWCOUNT - nFirstAvailableRow);
+			assertTrue((counters.front() == (double)nFirstAvailableRow) && (counters.back() == (double)(SIGNAL_ROWCOUNT - 1)), "available rows are read");
+
+			assertTrue(errorCodeOf([&]() { readDoubles(pReader.get(), "n", 0, 10); }) == LIBMCENV_ERROR_DATACAPTURESEGMENTPURGED, "deleted rows are reported");
+			assertTrue(errorCodeOf([&]() { readDoubles(pReader.get(), "n", nFirstAvailableRow - 1, 10); }) == LIBMCENV_ERROR_DATACAPTURESEGMENTPURGED, "a range that starts in a deleted segment is reported");
+			assertTrue(errorCodeOf([&]() { readDownsampled(pReader.get(), "v", 0, SIGNAL_ROWCOUNT, 10, LibMCEnv::eDataTableDownsampleMode::MinMax); }) == LIBMCENV_ERROR_DATACAPTURESEGMENTPURGED, "downsampling over deleted rows is reported");
+			assertTrue(errorCodeOf([&]() { UTable pTable(pReader->ExtractDataTable(0, 10, "n")); }) == LIBMCENV_ERROR_DATACAPTURESEGMENTPURGED, "extracting deleted rows is reported");
+
+			// The value search only returns chunks that can be read.
+			auto chunks = findChunks(pReader.get(), "v", 0.0, 10000.0);
+			for (uint64_t nChunkIndex : chunks) {
+				pReader->GetChunkInformation(nChunkIndex, nSegmentIndex, nFirstRow, nRowCount, bIsAvailable);
+				assertTrue(bIsAvailable && (nFirstRow >= nFirstAvailableRow), "value search returns only stored chunks");
+			}
+			assertTrue(chunks.size() == (SIGNAL_ROWCOUNT - nFirstAvailableRow) / 100, "value search finds every stored chunk");
+
+			// A capture that was aborted has nothing to read.
+			auto pAbortedOptions = createCounterOptions(fixture, 100, 0);
+			auto pAborted = createCapture(fixture, "aborted", pAbortedOptions.get());
+			addCounterColumn(pAborted.get());
+			uint64_t nCounter = 0;
+			commitCounterChunk(pAborted.get(), nCounter, 100);
+			pAborted->Abort();
+			auto pAbortedReader = openReader(fixture, "aborted");
+			assertTrue(pAbortedReader->GetFirstAvailableRow() == pAbortedReader->GetRowCount(), "an aborted capture has no available row");
+		}
+
+		void testThroughputReport()
+		{
+			auto fixture = createFixture("throughput");
+
+			// 20 channels of float32 plus a timestamp and a flag, the first scenario of the capacity budget.
+			const uint32_t nChunkRows = 65536;
+			const uint32_t nChunkCount = 4;
+			const uint32_t nChannelCount = 20;
+
+			std::vector<uint64_t> timestamps(nChunkRows);
+			std::vector<uint8_t> flags(nChunkRows);
+			std::vector<std::vector<float>> channels(nChannelCount, std::vector<float>(nChunkRows));
+
+			// A 16 bit front-end: smooth signal plus a little noise, quantised like an ADC would.
+			uint64_t nState = 2024;
+			for (uint32_t nIndex = 0; nIndex < nChunkRows; nIndex++) {
+				flags[nIndex] = (uint8_t)((nIndex / 5000) % 2);
+				for (uint32_t nChannel = 0; nChannel < nChannelCount; nChannel++) {
+					nState = nState * 6364136223846793005ULL + 1442695040888963407ULL;
+					double dNoise = (double)((nState >> 33) % 64) - 32.0;
+					double dSignal = 20000.0 + std::sin(nIndex * 0.0005 * (nChannel + 1)) * 10000.0 + dNoise;
+					channels[nChannel][nIndex] = (float)std::floor(dSignal) * (10.0f / 65536.0f);
+				}
+			}
+
+			uint64_t nPlainBytes = (uint64_t)nChunkRows * nChunkCount * (8 + 1 + 4 * nChannelCount);
+
+			for (auto eCompression : { LibMCEnv::eDataCaptureCompression::None, LibMCEnv::eDataCaptureCompression::LZ4, LibMCEnv::eDataCaptureCompression::Deflate }) {
+				std::string sIdentifier = "throughput" + std::to_string((uint32_t)eCompression);
+				std::string sCodec = (eCompression == LibMCEnv::eDataCaptureCompression::None) ? "none" : ((eCompression == LibMCEnv::eDataCaptureCompression::LZ4) ? "lz4" : "deflate");
+
+				UOptions pOptions(fixture.m_pBuildExecution->CreateDataCaptureOptions());
+				pOptions->SetChunkRowCount(nChunkRows);
+				pOptions->SetCompression(eCompression);
+				pOptions->SetSegmentSizeInBytes(16ULL * 1024ULL * 1024ULL);
+
+				auto pCapture = createCapture(fixture, sIdentifier, pOptions.get());
+				pCapture->AddColumn("t", "Time", LibMCEnv::eDataTableColumnType::TimestampColumn);
+				pCapture->AddColumn("flag", "Flag", LibMCEnv::eDataTableColumnType::BoolColumn);
+				for (uint32_t nChannel = 0; nChannel < nChannelCount; nChannel++)
+					pCapture->AddColumn("ch" + std::to_string(nChannel), "Channel " + std::to_string(nChannel), LibMCEnv::eDataTableColumnType::FloatColumn);
+
+				auto startTime = std::chrono::steady_clock::now();
+
+				for (uint32_t nChunkIndex = 0; nChunkIndex < nChunkCount; nChunkIndex++) {
+					for (uint32_t nIndex = 0; nIndex < nChunkRows; nIndex++)
+						timestamps[nIndex] = 1700000000000000ULL + ((uint64_t)nChunkIndex * nChunkRows + nIndex) * 10;
+
+					UChunk pChunk(pCapture->BeginChunk());
+					pChunk->SetTimestampColumnValues(0, timestamps.size(), timestamps.data());
+					pChunk->SetBoolColumnValues(1, flags.size(), flags.data());
+					for (uint32_t nChannel = 0; nChannel < nChannelCount; nChannel++)
+						pChunk->SetFloatColumnValues(2 + nChannel, channels[nChannel].size(), channels[nChannel].data());
+					pCapture->CommitChunk(pChunk.get());
+				}
+
+				pCapture->Flush();
+				auto flushTime = std::chrono::steady_clock::now();
+
+				// Finish includes finalizing the last segment, which hashes the file.
+				pCapture->Finish();
+				auto finishTime = std::chrono::steady_clock::now();
+
+				double dWriteSeconds = std::chrono::duration<double>(flushTime - startTime).count();
+				double dFinishSeconds = std::chrono::duration<double>(finishTime - flushTime).count();
+				uint64_t nStoredBytes = pCapture->GetStorageSizeInBytes();
+
+				assertTrue(pCapture->GetCapturedRowCount() == (uint64_t)nChunkRows * nChunkCount, sCodec + ": all rows are captured");
+				assertTrue(pCapture->GetDroppedRowCount() == 0, sCodec + ": nothing is dropped");
+				assertTrue(nStoredBytes < nPlainBytes, sCodec + ": the stored capture is smaller than the plain data");
+
+				// The test console prints short lines only.
+				double dMegabytes = (double)nPlainBytes / (1024.0 * 1024.0);
+				uint32_t nRate = (uint32_t)(dMegabytes / ((dWriteSeconds > 0.0) ? dWriteSeconds : 1.0e-9));
+				uint32_t nStoredPercent = (uint32_t)(100.0 * (double)nStoredBytes / (double)nPlainBytes);
+				uint32_t nFinishMilliseconds = (uint32_t)(dFinishSeconds * 1000.0);
+				logInfo("capture " + sCodec + ": " + std::to_string(nRate) + " MB/s, stored " + std::to_string(nStoredPercent) + " %, finish " + std::to_string(nFinishMilliseconds) + " ms");
+			}
+		}
+
+	};
+
+}
+
+#endif // __AMCTEST_UNITTEST_DATATABLEREADER
diff --git a/Implementation/UnitTest/amc_unittests_libmcdata_datacapture.hpp b/Implementation/UnitTest/amc_unittests_libmcdata_datacapture.hpp
new file mode 100644
index 000000000..4fc34c6de
--- /dev/null
+++ b/Implementation/UnitTest/amc_unittests_libmcdata_datacapture.hpp
@@ -0,0 +1,432 @@
+/*++
+
+Copyright (C) 2020 Autodesk Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Autodesk Inc. nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL AUTODESK INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef __AMCTEST_UNITTEST_LIBMCDATA_DATACAPTURE
+#define __AMCTEST_UNITTEST_LIBMCDATA_DATACAPTURE
+
+#include "amc_unittests.hpp"
+#include "amc_unittests_libmcdata.hpp"
+#include "common_utils.hpp"
+#include "libmcdata_dynamic.hpp"
+
+#include <chrono>
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace AMCUnitTest {
+
+	class CUnitTestGroup_LibMCData_DataCapture : public CUnitTestGroup {
+	public:
+
+		std::string getTestGroupName() override {
+			return "LibMCData_DataCapture";
+		}
+
+		void registerTests() override {
+			registerTest("SchemaVersion", "Data model schema contains the data capture tables", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_LibMCData_DataCapture::testSchemaVersion, this));
+			registerTest("CreateAndRetrieve", "Create, find and retrieve a capture manifest", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_LibMCData_DataCapture::testCreateAndRetrieve, this));
+			registerTest("Columns", "Register and read back the capture schema", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_LibMCData_DataCapture::testColumns, this));
+			registerTest("SegmentsAndFinish", "Register segments and finish the capture", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_LibMCData_DataCapture::testSegmentsAndFinish, this));
+			registerTest("AbortPurgesSegments", "Abort deletes the stored segments and keeps the manifest", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_LibMCData_DataCapture::testAbortPurgesSegments, this));
+			registerTest("StorageLimit", "Retention deletes the oldest segments across captures", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_LibMCData_DataCapture::testStorageLimit, this));
+			registerTest("DiscardRandomWriteStream", "Discard an unfinished random write stream", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_LibMCData_DataCapture::testDiscardRandomWriteStream, this));
+			registerTest("ListingAndLookup", "List the captures of an execution and find a capture by uuid", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_LibMCData_DataCapture::testListingAndLookup, this));
+		}
+
+		void initializeTests() override {
+		}
+
+	private:
+
+		struct SFixture {
+			LibMCData::PWrapper m_pDataWrapper;
+			LibMCData::PDataModel m_pDataModel;
+			LibMCData::PBuildJobHandler m_pBuildJobHandler;
+			LibMCData::PStorage m_pStorage;
+			LibMCData::PLoginHandler m_pLoginHandler;
+			LibMCData::PBuildJobExecution m_pExecution;
+			std::string m_sBasePath;
+			std::string m_sUserUUID;
+		};
+
+		uint64_t getCurrentTimestamp()
+		{
+			return static_cast<uint64_t>(std::chrono::duration_cast<std::chrono::microseconds>(
+				std::chrono::system_clock::now().time_since_epoch()).count());
+		}
+
+		SFixture createFixture(const std::string& sSuffix)
+		{
+			SFixture fixture;
+
+			std::string sRootPath = "temp";
+			if (!AMCCommon::CUtils::fileOrPathExistsOnDisk(sRootPath))
+				AMCCommon::CUtils::createDirectoryOnDisk(sRootPath);
+
+			fixture.m_sBasePath = sRootPath + "/libmcdata_datacapture_" + sSuffix + "_" + AMCCommon::CUtils::createUUID();
+			if (!AMCCommon::CUtils::fileOrPathExistsOnDisk(fixture.m_sBasePath))
+				AMCCommon::CUtils::createDirectoryOnDisk(fixture.m_sBasePath);
+
+			std::string sDatabaseFile = fixture.m_sBasePath + "/datacapture.db";
+
+			fixture.m_pDataWrapper = AMCUnitTest::loadLibMCDataInProcess();
+			fixture.m_pDataModel = fixture.m_pDataWrapper->CreateDataModelInstance();
+			fixture.m_pDataModel->InitialiseDatabase(fixture.m_sBasePath, LibMCData::eDataBaseType::SqLite, sDatabaseFile);
+			fixture.m_pBuildJobHandler = fixture.m_pDataModel->CreateBuildJobHandler();
+			fixture.m_pStorage = fixture.m_pDataModel->CreateStorage();
+			fixture.m_pLoginHandler = fixture.m_pDataModel->CreateLoginHandler();
+
+			std::string sSalt = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
+			std::string sHash = "fedcba9876543210fedcba9876543210fedcba9876543210fedcba9876543210";
+			fixture.m_sUserUUID = fixture.m_pLoginHandler->CreateUser("testuser", "operator", sSalt, sHash, "Test User");
+
+			fixture.m_pExecution = createExecution(fixture, "Capture Job");
+
+			return fixture;
+		}
+
+		LibMCData::PBuildJobExecution createExecution(SFixture& fixture, const std::string& sJobName)
+		{
+			std::string sContent = "job content for " + sJobName;
+			std::vector<uint8_t> buffer(sContent.begin(), sContent.end());
+			std::string sStreamUUID = AMCCommon::CUtils::createUUID();
+			fixture.m_pStorage->StoreNewStream(sStreamUUID, "job.bin", "application/octet-stream", buffer, fixture.m_sUserUUID, getCurrentTimestamp());
+
+			auto pJob = fixture.m_pBuildJobHandler->CreateJob(AMCCommon::CUtils::createUUID(), sJobName, fixture.m_sUserUUID, sStreamUUID, getCurrentTimestamp());
+			pJob->StartValidating();
+			pJob->FinishValidating(10);
+
+			return pJob->CreateBuildJobExecution("Execution", fixture.m_sUserUUID, getCurrentTimestamp());
+		}
+
+		// Stores a finished random write stream of the given size and returns its UUID.
+		std::string createSegmentStream(SFixture& fixture, size_t nSize)
+		{
+			std::string sUUID = AMCCommon::CUtils::createUUID();
+			std::vector<uint8_t> buffer(nSize, 0x5A);
+
+			fixture.m_pStorage->BeginRandomWriteStream(sUUID, "segment", "application/amcf-datatable", fixture.m_sUserUUID, getCurrentTimestamp());
+			fixture.m_pStorage->StoreRandomWriteStream(sUUID, 0, buffer);
+			fixture.m_pStorage->FinishRandomWriteStream(sUUID);
+
+			return sUUID;
+		}
+
+		std::string streamPath(SFixture& fixture, const std::string& sStreamUUID)
+		{
+			return fixture.m_sBasePath + "/" + AMCCommon::CUtils::normalizeUUIDString(sStreamUUID) + ".stream";
+		}
+
+		template <typename F>
+		int32_t errorCodeOf(F&& fn)
+		{
+			try {
+				fn();
+			}
+			catch (LibMCData::ELibMCDataException& dataException) {
+				return dataException.getErrorCode();
+			}
+			return 0;
+		}
+
+		void testSchemaVersion()
+		{
+			auto fixture = createFixture("schema");
+			assertTrue(fixture.m_pDataModel->GetDataModelVersion() >= 23, "schema version includes the data capture tables");
+
+			// The tables exist: an unknown capture is reported as not found and not as an SQL error.
+			assertFalse(fixture.m_pExecution->HasDataCapture("missing"), "unknown capture does not exist");
+			assertTrue(fixture.m_pStorage->GetDataCaptureStorageSize() == 0, "no capture data is stored initially");
+		}
+
+		void testCreateAndRetrieve()
+		{
+			auto fixture = createFixture("create");
+
+			auto pCapture = fixture.m_pExecution->CreateDataCapture("pyrometer", "Build pyrometer trace", fixture.m_sUserUUID, getCurrentTimestamp());
+			assertAssigned(pCapture.get(), "capture is created");
+			assertTrue(pCapture->GetIdentifier() == "pyrometer", "capture identifier");
+			assertTrue(pCapture->GetName() == "Build pyrometer trace", "capture name");
+			assertTrue(pCapture->GetExecutionUUID() == fixture.m_pExecution->GetExecutionUUID(), "capture belongs to the execution");
+			assertTrue(pCapture->GetStatus() == LibMCData::eDataCaptureStatus::Recording, "new capture is recording");
+			assertTrue(pCapture->GetSegmentCount() == 0, "new capture has no segments");
+			assertTrue(pCapture->GetRowCount() == 0, "new capture has no rows");
+			assertTrue(pCapture->GetColumnCount() == 0, "new capture has no columns");
+
+			assertTrue(fixture.m_pExecution->HasDataCapture("pyrometer"), "capture is found by identifier");
+			assertFalse(fixture.m_pExecution->HasDataCapture("other"), "other identifier is not found");
+
+			auto pRetrieved = fixture.m_pExecution->RetrieveDataCapture("pyrometer");
+			assertTrue(pRetrieved->GetUUID() == pCapture->GetUUID(), "retrieved capture has the same uuid");
+			assertTrue(pRetrieved->GetName() == "Build pyrometer trace", "retrieved capture name");
+
+			assertTrue(errorCodeOf([&]() { fixture.m_pExecution->CreateDataCapture("pyrometer", "Duplicate", fixture.m_sUserUUID, getCurrentTimestamp()); }) == LIBMCDATA_ERROR_DUPLICATEDATACAPTUREIDENTIFIER, "duplicate identifier is rejected");
+			assertTrue(errorCodeOf([&]() { fixture.m_pExecution->CreateDataCapture("bad id!", "Invalid", fixture.m_sUserUUID, getCurrentTimestamp()); }) == LIBMCDATA_ERROR_INVALIDDATACAPTUREIDENTIFIER, "invalid identifier is rejected");
+			assertTrue(errorCodeOf([&]() { fixture.m_pExecution->CreateDataCapture("", "Empty", fixture.m_sUserUUID, getCurrentTimestamp()); }) == LIBMCDATA_ERROR_INVALIDDATACAPTUREIDENTIFIER, "empty identifier is rejected");
+			assertTrue(errorCodeOf([&]() { fixture.m_pExecution->CreateDataCapture("unnamed", "", fixture.m_sUserUUID, getCurrentTimestamp()); }) == LIBMCDATA_ERROR_INVALIDDATACAPTURENAME, "empty name is rejected");
+			assertTrue(errorCodeOf([&]() { fixture.m_pExecution->RetrieveDataCapture("missing"); }) == LIBMCDATA_ERROR_DATACAPTURENOTFOUND, "unknown capture is not found");
+
+			// The identifier is unique per execution, not globally.
+			auto pOtherExecution = createExecution(fixture, "Other Job");
+			assertFalse(pOtherExecution->HasDataCapture("pyrometer"), "capture is not visible in another execution");
+			auto pOtherCapture = pOtherExecution->CreateDataCapture("pyrometer", "Other trace", fixture.m_sUserUUID, getCurrentTimestamp());
+			assertTrue(pOtherCapture->GetUUID() != pCapture->GetUUID(), "same identifier in another execution is a different capture");
+		}
+
+		void testColumns()
+		{
+			auto fixture = createFixture("columns");
+			auto pCapture = fixture.m_pExecution->CreateDataCapture("trace", "Trace", fixture.m_sUserUUID, getCurrentTimestamp());
+
+			pCapture->AddColumn(0, "t", "Time", 8);
+			pCapture->AddColumn(1, "temp", "Temperature in C", 6);
+			pCapture->AddColumn(2, "laser", "Laser active", 7);
+			assertTrue(pCapture->GetColumnCount() == 3, "three columns registered");
+
+			std::string sIdentifier;
+			std::string sDescription;
+			uint32_t nColumnType = 0;
+			pCapture->GetColumnInformation(1, sIdentifier, sDescription, nColumnType);
+			assertTrue(sIdentifier == "temp", "column identifier");
+			assertTrue(sDescription == "Temperature in C", "column description");
+			assertTrue(nColumnType == 6, "column type");
+
+			assertTrue(errorCodeOf([&]() { pCapture->AddColumn(1, "other", "Other", 1); }) == LIBMCDATA_ERROR_DUPLICATEDATACAPTURECOLUMN, "duplicate column index is rejected");
+			assertTrue(errorCodeOf([&]() { pCapture->AddColumn(3, "temp", "Again", 1); }) == LIBMCDATA_ERROR_DUPLICATEDATACAPTURECOLUMN, "duplicate column identifier is rejected");
+			assertTrue(errorCodeOf([&]() { pCapture->GetColumnInformation(9, sIdentifier, sDescription, nColumnType); }) == LIBMCDATA_ERROR_INVALIDDATACAPTURECOLUMNINDEX, "unknown column index is rejected");
+
+			pCapture->Finish(getCurrentTimestamp());
+			assertTrue(errorCodeOf([&]() { pCapture->AddColumn(3, "late", "Late", 1); }) == LIBMCDATA_ERROR_DATACAPTURENOTRECORDING, "schema is frozen after finish");
+		}
+
+		void testSegmentsAndFinish()
+		{
+			auto fixture = createFixture("segments");
+			auto pCapture = fixture.m_pExecution->CreateDataCapture("trace", "Trace", fixture.m_sUserUUID, getCurrentTimestamp());
+
+			std::string sStream0 = createSegmentStream(fixture, 1000);
+			std::string sStream1 = createSegmentStream(fixture, 600);
+
+			uint64_t nTime = getCurrentTimestamp();
+			pCapture->AddSegment(0, sStream0, 0, 500, 5, 1000, nTime, nTime + 10);
+			pCapture->AddSegment(1, sStream1, 500, 300, 3, 600, nTime + 10, nTime + 20);
+
+			assertTrue(pCapture->GetSegmentCount() == 2, "two segments registered");
+			assertTrue(pCapture->GetRowCount() == 800, "row count is the sum of the segments");
+			assertTrue(pCapture->GetStoredSizeInBytes() == 1600, "stored size is the sum of the segments");
+			assertTrue(fixture.m_pStorage->GetDataCaptureStorageSize() == 1600, "global stored size");
+
+			std::string sStreamUUID;
+			uint64_t nFirstRow = 0;
+			uint64_t nRowCount = 0;
+			uint64_t nSizeInBytes = 0;
+			bool bIsPurged = true;
+			pCapture->GetSegmentInformation(1, sStreamUUID, nFirstRow, nRowCount, nSizeInBytes, bIsPurged);
+			assertTrue(AMCCommon::CUtils::normalizeUUIDString(sStreamUUID) == AMCCommon::CUtils::normalizeUUIDString(sStream1), "segment stream uuid");
+			assertTrue(nFirstRow == 500, "segment first row");
+			assertTrue(nRowCount == 300, "segment row count");
+			assertTrue(nSizeInBytes == 600, "segment size");
+			assertFalse(bIsPurged, "segment is stored");
+
+			assertTrue(errorCodeOf([&]() { pCapture->AddSegment(1, sStream1, 800, 1, 1, 1, nTime, nTime); }) == LIBMCDATA_ERROR_DUPLICATEDATACAPTURESEGMENT, "duplicate segment index is rejected");
+			assertTrue(errorCodeOf([&]() { pCapture->AddSegment(2, AMCCommon::CUtils::createUUID(), 800, 1, 1, 1, nTime, nTime); }) == LIBMCDATA_ERROR_STORAGESTREAMNOTFOUND, "unknown stream is rejected");
+			assertTrue(errorCodeOf([&]() { pCapture->GetSegmentInformation(7, sStreamUUID, nFirstRow, nRowCount, nSizeInBytes, bIsPurged); }) == LIBMCDATA_ERROR_INVALIDDATACAPTURESEGMENTINDEX, "unknown segment index is rejected");
+
+			pCapture->Finish(getCurrentTimestamp());
+			assertTrue(pCapture->GetStatus() == LibMCData::eDataCaptureStatus::Finished, "capture is finished");
+
+			std::string sStream2 = createSegmentStream(fixture, 100);
+			assertTrue(errorCodeOf([&]() { pCapture->AddSegment(2, sStream2, 800, 1, 1, 100, nTime, nTime); }) == LIBMCDATA_ERROR_DATACAPTURENOTRECORDING, "no segments after finish");
+			assertTrue(errorCodeOf([&]() { pCapture->Finish(getCurrentTimestamp()); }) == LIBMCDATA_ERROR_DATACAPTURENOTRECORDING, "second finish is rejected");
+
+			// The status is read from the database, so another manifest instance sees it.
+			auto pRetrieved = fixture.m_pExecution->RetrieveDataCapture("trace");
+			assertTrue(pRetrieved->GetStatus() == LibMCData::eDataCaptureStatus::Finished, "retrieved capture is finished");
+			assertTrue(pRetrieved->GetSegmentCount() == 2, "retrieved capture has its segments");
+		}
+
+		void testAbortPurgesSegments()
+		{
+			auto fixture = createFixture("abort");
+			auto pCapture = fixture.m_pExecution->CreateDataCapture("trace", "Trace", fixture.m_sUserUUID, getCurrentTimestamp());
+
+			std::string sStream0 = createSegmentStream(fixture, 1000);
+			std::string sStream1 = createSegmentStream(fixture, 600);
+			uint64_t nTime = getCurrentTimestamp();
+			pCapture->AddSegment(0, sStream0, 0, 500, 5, 1000, nTime, nTime + 10);
+			pCapture->AddSegment(1, sStream1, 500, 300, 3, 600, nTime + 10, nTime + 20);
+
+			assertTrue(AMCCommon::CUtils::fileOrPathExistsOnDisk(streamPath(fixture, sStream0)), "segment file exists before abort");
+
+			pCapture->Abort(getCurrentTimestamp());
+
+			assertTrue(pCapture->GetStatus() == LibMCData::eDataCaptureStatus::Aborted, "capture is aborted");
+			assertFalse(AMCCommon::CUtils::fileOrPathExistsOnDisk(streamPath(fixture, sStream0)), "first segment file is deleted");
+			assertFalse(AMCCommon::CUtils::fileOrPathExistsOnDisk(streamPath(fixture, sStream1)), "second segment file is deleted");
+			assertTrue(pCapture->GetStoredSizeInBytes() == 0, "nothing is stored after abort");
+			assertTrue(fixture.m_pStorage->GetDataCaptureStorageSize() == 0, "global stored size is zero after abort");
+
+			// The manifest keeps telling which rows have existed.
+			assertTrue(pCapture->GetSegmentCount() == 2, "manifest keeps the purged segments");
+			assertTrue(pCapture->GetRowCount() == 800, "manifest keeps the row count");
+
+			std::string sStreamUUID;
+			uint64_t nFirstRow = 0;
+			uint64_t nRowCount = 0;
+			uint64_t nSizeInBytes = 0;
+			bool bIsPurged = false;
+			pCapture->GetSegmentInformation(0, sStreamUUID, nFirstRow, nRowCount, nSizeInBytes, bIsPurged);
+			assertTrue(bIsPurged, "segment is marked as purged");
+
+			assertTrue(errorCodeOf([&]() { fixture.m_pStorage->RetrieveStream(sStream0); }) == LIBMCDATA_ERROR_STORAGESTREAMNOTFOUND, "purged stream is not found anymore");
+			assertTrue(errorCodeOf([&]() { pCapture->Abort(getCurrentTimestamp()); }) == LIBMCDATA_ERROR_DATACAPTUREALREADYABORTED, "second abort is rejected");
+		}
+
+		void testStorageLimit()
+		{
+			auto fixture = createFixture("limit");
+			auto pCaptureA = fixture.m_pExecution->CreateDataCapture("first", "First", fixture.m_sUserUUID, getCurrentTimestamp());
+			auto pCaptureB = fixture.m_pExecution->CreateDataCapture("second", "Second", fixture.m_sUserUUID, getCurrentTimestamp());
+
+			std::string sStreamA0 = createSegmentStream(fixture, 1000);
+			std::string sStreamB0 = createSegmentStream(fixture, 1000);
+			std::string sStreamA1 = createSegmentStream(fixture, 1000);
+
+			// Age is given by the end time stamp of the segment: A0 is the oldest, A1 the newest.
+			uint64_t nTime = getCurrentTimestamp();
+			pCaptureA->AddSegment(0, sStreamA0, 0, 100, 1, 1000, nTime, nTime + 10);
+			pCaptureB->AddSegment(0, sStreamB0, 0, 100, 1, 1000, nTime + 10, nTime + 20);
+			pCaptureA->AddSegment(1, sStreamA1, 100, 100, 1, 1000, nTime + 20, nTime + 30);
+
+			assertTrue(fixture.m_pStorage->GetDataCaptureStorageSize() == 3000, "three segments stored");
+			assertTrue(fixture.m_pStorage->EnforceDataCaptureStorageLimit(3000) == 0, "nothing is purged within the limit");
+
+			uint32_t nPurged = fixture.m_pStorage->EnforceDataCaptureStorageLimit(2500);
+			assertTrue(nPurged == 1, "one segment is purged to get below the limit");
+			assertTrue(fixture.m_pStorage->GetDataCaptureStorageSize() == 2000, "two segments remain");
+			assertFalse(AMCCommon::CUtils::fileOrPathExistsOnDisk(streamPath(fixture, sStreamA0)), "the oldest segment file is deleted");
+			assertTrue(AMCCommon::CUtils::fileOrPathExistsOnDisk(streamPath(fixture, sStreamB0)), "the second oldest segment file is kept");
+			assertTrue(AMCCommon::CUtils::fileOrPathExistsOnDisk(streamPath(fixture, sStreamA1)), "the newest segment file is kept");
+
+			std::string sStreamUUID;
+			uint64_t nFirstRow = 0;
+			uint64_t nRowCount = 0;
+			uint64_t nSizeInBytes = 0;
+			bool bIsPurged = false;
+			pCaptureA->GetSegmentInformation(0, sStreamUUID, nFirstRow, nRowCount, nSizeInBytes, bIsPurged);
+			assertTrue(bIsPurged, "the oldest segment is marked as purged");
+			pCaptureA->GetSegmentInformation(1, sStreamUUID, nFirstRow, nRowCount, nSizeInBytes, bIsPurged);
+			assertFalse(bIsPurged, "the newest segment is still stored");
+			assertTrue(pCaptureA->GetStoredSizeInBytes() == 1000, "capture stored size follows the purge");
+			assertTrue(pCaptureA->GetRowCount() == 200, "capture row count is unchanged by the purge");
+			assertTrue(pCaptureA->GetStatus() == LibMCData::eDataCaptureStatus::Recording, "retention does not change the capture status");
+
+			// Oldest first across captures: B0 goes before A1.
+			nPurged = fixture.m_pStorage->EnforceDataCaptureStorageLimit(1000);
+			assertTrue(nPurged == 1, "one more segment is purged");
+			assertFalse(AMCCommon::CUtils::fileOrPathExistsOnDisk(streamPath(fixture, sStreamB0)), "the second oldest segment file is deleted");
+			assertTrue(AMCCommon::CUtils::fileOrPathExistsOnDisk(streamPath(fixture, sStreamA1)), "the newest segment file is still kept");
+
+			nPurged = fixture.m_pStorage->EnforceDataCaptureStorageLimit(999);
+			assertTrue(nPurged == 1, "the last segment is purged");
+			assertTrue(fixture.m_pStorage->GetDataCaptureStorageSize() == 0, "nothing remains");
+			assertTrue(fixture.m_pStorage->EnforceDataCaptureStorageLimit(0) == 0, "nothing left to purge");
+		}
+
+		void testListingAndLookup()
+		{
+			auto fixture = createFixture("listing");
+
+			assertTrue(fixture.m_pExecution->GetDataCaptureCount() == 0, "new execution has no captures");
+
+			uint64_t nTime = getCurrentTimestamp();
+			auto pFirst = fixture.m_pExecution->CreateDataCapture("alpha", "First capture", fixture.m_sUserUUID, nTime);
+			auto pSecond = fixture.m_pExecution->CreateDataCapture("beta", "Second capture", fixture.m_sUserUUID, nTime + 1000000);
+
+			assertTrue(fixture.m_pExecution->GetDataCaptureCount() == 2, "two captures in the execution");
+
+			// Captures are ordered by their creation time.
+			auto pByIndex0 = fixture.m_pExecution->RetrieveDataCaptureByIndex(0);
+			auto pByIndex1 = fixture.m_pExecution->RetrieveDataCaptureByIndex(1);
+			assertTrue(pByIndex0->GetUUID() == pFirst->GetUUID(), "first capture by index");
+			assertTrue(pByIndex1->GetIdentifier() == "beta", "second capture by index");
+			assertTrue(!pByIndex0->GetTimeStamp().empty(), "capture has a creation time stamp");
+			assertTrue(pByIndex0->GetTimeStamp() < pByIndex1->GetTimeStamp(), "creation time stamps are ordered");
+			assertTrue(errorCodeOf([&]() { fixture.m_pExecution->RetrieveDataCaptureByIndex(2); }) == LIBMCDATA_ERROR_DATACAPTURENOTFOUND, "index out of bounds is rejected");
+
+			// A capture is found by its uuid without knowing the execution.
+			auto pByUUID = fixture.m_pBuildJobHandler->RetrieveDataCapture(pSecond->GetUUID());
+			assertTrue(pByUUID->GetIdentifier() == "beta", "capture found by uuid");
+			assertTrue(pByUUID->GetName() == "Second capture", "capture name by uuid");
+			assertTrue(pByUUID->GetExecutionUUID() == fixture.m_pExecution->GetExecutionUUID(), "execution of the capture found by uuid");
+			assertTrue(errorCodeOf([&]() { fixture.m_pBuildJobHandler->RetrieveDataCapture(AMCCommon::CUtils::createUUID()); }) == LIBMCDATA_ERROR_DATACAPTURENOTFOUND, "unknown uuid is not found");
+
+			// Captures of another execution are not listed.
+			auto pOtherExecution = createExecution(fixture, "Other Job");
+			assertTrue(pOtherExecution->GetDataCaptureCount() == 0, "another execution has its own captures");
+
+			// The chunk count of a segment is part of the manifest.
+			std::string sStream = createSegmentStream(fixture, 500);
+			pFirst->AddSegment(0, sStream, 0, 300, 3, 500, nTime, nTime + 10);
+			assertTrue(pFirst->GetSegmentChunkCount(0) == 3, "segment chunk count");
+			assertTrue(errorCodeOf([&]() { pFirst->GetSegmentChunkCount(1); }) == LIBMCDATA_ERROR_INVALIDDATACAPTURESEGMENTINDEX, "unknown segment index is rejected");
+		}
+
+		void testDiscardRandomWriteStream()
+		{
+			auto fixture = createFixture("discard");
+
+			std::string sUUID = AMCCommon::CUtils::createUUID();
+			std::vector<uint8_t> buffer(500, 0x11);
+			fixture.m_pStorage->BeginRandomWriteStream(sUUID, "unfinished", "application/amcf-datatable", fixture.m_sUserUUID, getCurrentTimestamp());
+			fixture.m_pStorage->StoreRandomWriteStream(sUUID, 0, buffer);
+			assertTrue(fixture.m_pStorage->GetRandomWriteStreamSize(sUUID) == 500, "unfinished stream holds the data");
+			assertTrue(AMCCommon::CUtils::fileOrPathExistsOnDisk(streamPath(fixture, sUUID)), "unfinished stream file exists");
+
+			fixture.m_pStorage->DiscardRandomWriteStream(sUUID);
+
+			assertFalse(AMCCommon::CUtils::fileOrPathExistsOnDisk(streamPath(fixture, sUUID)), "discarded stream file is deleted");
+			assertFalse(fixture.m_pStorage->StreamIsReady(sUUID), "discarded stream is not ready");
+			assertTrue(errorCodeOf([&]() { fixture.m_pStorage->RetrieveStream(sUUID); }) == LIBMCDATA_ERROR_STORAGESTREAMNOTFOUND, "discarded stream entry is deleted");
+			assertTrue(errorCodeOf([&]() { fixture.m_pStorage->DiscardRandomWriteStream(sUUID); }) == LIBMCDATA_ERROR_RANDOMWRITESTREAMNOTFOUND, "second discard is rejected");
+			assertTrue(errorCodeOf([&]() { fixture.m_pStorage->DiscardRandomWriteStream(AMCCommon::CUtils::createUUID()); }) == LIBMCDATA_ERROR_RANDOMWRITESTREAMNOTFOUND, "unknown stream is rejected");
+
+			// A finished stream is not a random write stream anymore and is left untouched.
+			std::string sFinished = createSegmentStream(fixture, 100);
+			assertTrue(errorCodeOf([&]() { fixture.m_pStorage->DiscardRandomWriteStream(sFinished); }) == LIBMCDATA_ERROR_RANDOMWRITESTREAMNOTFOUND, "finished stream can not be discarded");
+			assertTrue(fixture.m_pStorage->StreamIsReady(sFinished), "finished stream is still ready");
+		}
+
+	};
+
+}
+
+#endif // __AMCTEST_UNITTEST_LIBMCDATA_DATACAPTURE
diff --git a/Implementation/UnitTest/amc_unittests_libmcdata_storage.hpp b/Implementation/UnitTest/amc_unittests_libmcdata_storage.hpp
index 4fe0f9bd3..8fc538577 100644
--- a/Implementation/UnitTest/amc_unittests_libmcdata_storage.hpp
+++ b/Implementation/UnitTest/amc_unittests_libmcdata_storage.hpp
@@ -75,6 +75,9 @@ namespace AMCUnitTest {
 			registerTest("AttachStreamToJournal", "Attach stream to journal", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_LibMCData_Storage::testAttachStreamToJournal, this));
 			registerTest("DownloadTicket", "Create download ticket", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_LibMCData_Storage::testDownloadTicket, this));
 			registerTest("RequestDownloadTicket", "Request download ticket", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_LibMCData_Storage::testRequestDownloadTicket, this));
+			registerTest("DownloadTicketDetailsAndRevoke", "Ticket details, revocation and the download access log", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_LibMCData_Storage::testDownloadTicketDetailsAndRevoke, this));
+			registerTest("ZIPStreamDiscard", "Discarding an unfinished ZIP stream removes file and entry", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_LibMCData_Storage::testZIPStreamDiscard, this));
+			registerTest("DeleteStreamAndListByName", "Deleting finished streams and listing them by name", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_LibMCData_Storage::testDeleteStreamAndListByName, this));
 			
 			// Additional tests to reach 100
 			registerTest("StoreEmptyStream", "Store empty stream", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_LibMCData_Storage::testStoreEmptyStream, this));
@@ -644,9 +647,168 @@ namespace AMCUnitTest {
 			// Request the valid ticket
 			std::string sStreamOut, sFileOut, sSessionOut, sUserOut;
 			fixture.m_pStorage->RequestDownloadTicket(sTicketUUID, "127.0.0.1", getCurrentTimestamp(), sStreamOut, sFileOut, sSessionOut, sUserOut);
-			
+
 			assertTrue(sStreamOut == sStreamUUID, "Stream UUID should match");
 		}
+
+		void testDownloadTicketDetailsAndRevoke()
+		{
+			auto fixture = createFixture("ticket_revoke");
+
+			auto pLoginHandler = fixture.m_pDataModel->CreateLoginHandler();
+			std::string sSalt = "c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4";
+			std::string sHashedPassword = "d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5";
+			pLoginHandler->CreateUser("revokeuser", "admin", sSalt, sHashedPassword, "Revoke User");
+			std::string sUserUUID, sDesc, sRole, sLang;
+			pLoginHandler->GetUserProperties("revokeuser", sUserUUID, sDesc, sRole, sLang);
+
+			std::string sStreamUUID = AMCCommon::CUtils::createUUID();
+			std::string sSessionUUID = AMCCommon::CUtils::createUUID();
+			std::vector<uint8_t> buffer = { 0x01, 0x02, 0x03 };
+			fixture.m_pStorage->StoreNewStream(sStreamUUID, "revoke.bin", "application/octet-stream", buffer, sUserUUID, getCurrentTimestamp());
+
+			uint64_t nCreated = getCurrentTimestamp();
+			std::string sTicketUUID = AMCCommon::CUtils::createUUID();
+			fixture.m_pStorage->CreateDownloadTicket(sTicketUUID, sStreamUUID, "revoke_download.bin", sSessionUUID, sUserUUID, nCreated);
+
+			std::string sStreamOut, sFileOut, sSessionOut, sUserOut;
+			uint64_t nCreationOut = 0;
+			bool bRevoked = true;
+			fixture.m_pStorage->GetDownloadTicketDetails(sTicketUUID, sStreamOut, sFileOut, sSessionOut, sUserOut, nCreationOut, bRevoked);
+			assertTrue(sStreamOut == sStreamUUID, "Ticket details: stream");
+			assertTrue(sFileOut == "revoke_download.bin", "Ticket details: file name");
+			assertTrue(sSessionOut == sSessionUUID, "Ticket details: session");
+			assertTrue(sUserOut == sUserUUID, "Ticket details: user");
+			assertFalse(bRevoked, "A new ticket is not revoked");
+			// The time stamp is stored with microsecond precision.
+			assertTrue((nCreationOut >= nCreated - 1000000) && (nCreationOut <= nCreated + 1000000), "Ticket details: creation time");
+
+			// The access log records start and end of a download.
+			std::string sDownloadUUID = fixture.m_pStorage->LogDownloadStart(sTicketUUID, "127.0.0.1", getCurrentTimestamp());
+			assertTrue(AMCCommon::CUtils::stringIsUUIDString(sDownloadUUID), "Download log entry UUID");
+			fixture.m_pStorage->LogDownloadFinish(sDownloadUUID, 3, true, getCurrentTimestamp());
+
+			bool bThrown = false;
+			try {
+				fixture.m_pStorage->LogDownloadFinish(AMCCommon::CUtils::createUUID(), 0, false, getCurrentTimestamp());
+			}
+			catch (LibMCData::ELibMCDataException&) {
+				bThrown = true;
+			}
+			assertTrue(bThrown, "Finishing an unknown download entry fails");
+
+			assertTrue(fixture.m_pStorage->RevokeDownloadTicketsOfStream(sStreamUUID) == 1, "One ticket revoked");
+			assertTrue(fixture.m_pStorage->RevokeDownloadTicketsOfStream(sStreamUUID) == 0, "Second revocation changes nothing");
+			fixture.m_pStorage->GetDownloadTicketDetails(sTicketUUID, sStreamOut, sFileOut, sSessionOut, sUserOut, nCreationOut, bRevoked);
+			assertTrue(bRevoked, "Ticket is revoked");
+		}
+
+		void testZIPStreamDiscard()
+		{
+			auto fixture = createFixture("zip_discard");
+
+			std::string sUUID = AMCCommon::CUtils::createUUID();
+			std::string sUserUUID = AMCCommon::CUtils::createUUID();
+			auto pWriter = fixture.m_pStorage->CreateZIPStream(sUUID, "discard.zip", sUserUUID, getCurrentTimestamp());
+			uint32_t nEntryID = pWriter->StartNewEntry("entry.txt", getCurrentTimestamp());
+			std::vector<uint8_t> data = { 'a', 'b', 'c' };
+			pWriter->WriteData(nEntryID, data);
+			pWriter->FinishCurrentEntry();
+
+			std::string sPath = fixture.m_sBasePath + "/" + sUUID + ".stream";
+			assertTrue(AMCCommon::CUtils::fileOrPathExistsOnDisk(sPath), "ZIP file exists while writing: " + sPath);
+			assertFalse(pWriter->IsFinished(), "ZIP stream is not finished");
+
+			pWriter->Discard();
+			assertFalse(AMCCommon::CUtils::fileOrPathExistsOnDisk(sPath), "ZIP file is deleted by Discard");
+			assertFalse(fixture.m_pStorage->StreamIsReady(sUUID), "Discarded stream is not ready");
+
+			bool bThrown = false;
+			try {
+				pWriter->StartNewEntry("after.txt", getCurrentTimestamp());
+			}
+			catch (LibMCData::ELibMCDataException&) {
+				bThrown = true;
+			}
+			assertTrue(bThrown, "Writing after Discard fails");
+
+			// A finished stream can not be discarded, and a new stream of the same name can be created.
+			std::string sUUID2 = AMCCommon::CUtils::createUUID();
+			auto pWriter2 = fixture.m_pStorage->CreateZIPStream(sUUID2, "discard.zip", sUserUUID, getCurrentTimestamp());
+			uint32_t nEntryID2 = pWriter2->StartNewEntry("entry.txt", getCurrentTimestamp());
+			pWriter2->WriteData(nEntryID2, data);
+			pWriter2->Finish();
+			assertTrue(fixture.m_pStorage->StreamIsReady(sUUID2), "Finished stream is ready");
+			bThrown = false;
+			try {
+				pWriter2->Discard();
+			}
+			catch (LibMCData::ELibMCDataException&) {
+				bThrown = true;
+			}
+			assertTrue(bThrown, "Discard of a finished stream fails");
+
+			// An unfinished stream without a writer (as after a crash) is removed at startup.
+			std::string sUUID3 = AMCCommon::CUtils::createUUID();
+			auto pWriter3 = fixture.m_pStorage->CreateZIPStream(sUUID3, "crashed.zip", sUserUUID, getCurrentTimestamp());
+			uint32_t nEntryID3 = pWriter3->StartNewEntry("entry.txt", getCurrentTimestamp());
+			pWriter3->WriteData(nEntryID3, data);
+			pWriter3 = nullptr;
+			assertTrue(fixture.m_pStorage->DiscardUnfinishedZIPStreams() == 1, "One unfinished ZIP stream discarded");
+			assertTrue(fixture.m_pStorage->DiscardUnfinishedZIPStreams() == 0, "Nothing left to discard");
+			assertFalse(AMCCommon::CUtils::fileOrPathExistsOnDisk(fixture.m_sBasePath + "/" + sUUID3 + ".stream"), "Crashed ZIP file is deleted");
+		}
+
+		void testDeleteStreamAndListByName()
+		{
+			auto fixture = createFixture("delete_list");
+			std::string sUserUUID = AMCCommon::CUtils::createUUID();
+			std::vector<uint8_t> buffer = { 0x01, 0x02 };
+
+			std::string sUUIDA = AMCCommon::CUtils::createUUID();
+			std::string sUUIDB = AMCCommon::CUtils::createUUID();
+			std::string sUUIDOther = AMCCommon::CUtils::createUUID();
+			fixture.m_pStorage->StoreNewStream(sUUIDA, "archive.zip", "application/zip", buffer, sUserUUID, getCurrentTimestamp());
+			std::this_thread::sleep_for(std::chrono::milliseconds(5));
+			fixture.m_pStorage->StoreNewStream(sUUIDB, "archive.zip", "application/zip", buffer, sUserUUID, getCurrentTimestamp());
+			fixture.m_pStorage->StoreNewStream(sUUIDOther, "other.zip", "application/zip", buffer, sUserUUID, getCurrentTimestamp());
+
+			std::string sList = fixture.m_pStorage->ListStreamUUIDsByName("archive.zip");
+			assertTrue(sList == sUUIDB + "," + sUUIDA, "Newest first: " + sList);
+			assertTrue(fixture.m_pStorage->ListStreamUUIDsByName("missing.zip").empty(), "Unknown name lists nothing");
+
+			std::string sTicketUUID = AMCCommon::CUtils::createUUID();
+			auto pLoginHandler = fixture.m_pDataModel->CreateLoginHandler();
+			std::string sSalt = "c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4";
+			std::string sHashedPassword = "d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5";
+			pLoginHandler->CreateUser("deleteuser", "admin", sSalt, sHashedPassword, "Delete User");
+			std::string sRealUserUUID, sDesc, sRole, sLang;
+			pLoginHandler->GetUserProperties("deleteuser", sRealUserUUID, sDesc, sRole, sLang);
+			fixture.m_pStorage->CreateDownloadTicket(sTicketUUID, sUUIDA, "archive.zip", AMCCommon::CUtils::createUUID(), sRealUserUUID, getCurrentTimestamp());
+
+			std::string sPathA = fixture.m_sBasePath + "/" + sUUIDA + ".stream";
+			assertTrue(AMCCommon::CUtils::fileOrPathExistsOnDisk(sPathA), "Stream file exists before delete");
+			fixture.m_pStorage->DeleteStream(sUUIDA);
+			assertFalse(AMCCommon::CUtils::fileOrPathExistsOnDisk(sPathA), "Stream file deleted");
+			assertFalse(fixture.m_pStorage->StreamIsReady(sUUIDA), "Deleted stream is not ready");
+			assertTrue(fixture.m_pStorage->ListStreamUUIDsByName("archive.zip") == sUUIDB, "Only the remaining stream is listed");
+
+			// The tickets of a deleted stream are revoked.
+			std::string sStreamOut, sFileOut, sSessionOut, sUserOut;
+			uint64_t nCreationOut = 0;
+			bool bRevoked = false;
+			fixture.m_pStorage->GetDownloadTicketDetails(sTicketUUID, sStreamOut, sFileOut, sSessionOut, sUserOut, nCreationOut, bRevoked);
+			assertTrue(bRevoked, "Ticket of a deleted stream is revoked");
+
+			bool bThrown = false;
+			try {
+				fixture.m_pStorage->DeleteStream(sUUIDA);
+			}
+			catch (LibMCData::ELibMCDataException&) {
+				bThrown = true;
+			}
+			assertTrue(bThrown, "Deleting a missing stream fails");
+		}
 		
 		// ============= Additional tests to reach 100 =============
 		
diff --git a/Implementation/UnitTest/amc_unittests_streamdownload.hpp b/Implementation/UnitTest/amc_unittests_streamdownload.hpp
new file mode 100644
index 000000000..24a567a6d
--- /dev/null
+++ b/Implementation/UnitTest/amc_unittests_streamdownload.hpp
@@ -0,0 +1,289 @@
+/*++
+
+Copyright (C) 2026 Autodesk Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+	* Redistributions of source code must retain the above copyright
+	  notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+	  notice, this list of conditions and the following disclaimer in the
+	  documentation and/or other materials provided with the distribution.
+	* Neither the name of the Autodesk Inc. nor the
+	  names of its contributors may be used to endorse or promote products
+	  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL AUTODESK INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef __AMCTEST_UNITTEST_STREAMDOWNLOAD
+#define __AMCTEST_UNITTEST_STREAMDOWNLOAD
+
+#include "amc_unittests.hpp"
+#include "amc_streamdownloadregistry.hpp"
+#include "common_httprange.hpp"
+#include "common_utils.hpp"
+
+#include <string>
+#include <vector>
+
+namespace AMCUnitTest {
+
+	// Tests of the download registry (contiguous delivery, cancel, connection counting) and of the
+	// HTTP range validation that the server applies before it streams a storage stream.
+	class CUnitTestGroup_StreamDownload : public CUnitTestGroup {
+	public:
+		CUnitTestGroup_StreamDownload() = default;
+		virtual ~CUnitTestGroup_StreamDownload() = default;
+
+		std::string getTestGroupName() override {
+			return "StreamDownload";
+		}
+
+		void registerTests() override {
+			registerTest("RegistryContiguousDelivery", "Delivered bytes grow only without gaps and resume continues at the gap", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_StreamDownload::test_RegistryContiguousDelivery, this));
+			registerTest("RegistryCompletion", "Completion needs the last byte and a successful connection end", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_StreamDownload::test_RegistryCompletion, this));
+			registerTest("RegistryCancel", "Cancel stops chunks, is refused after completion and is cleared by a new delivery", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_StreamDownload::test_RegistryCancel, this));
+			registerTest("RegistryConnectionCounting", "Connection ends without a start and double ends never make the count negative", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_StreamDownload::test_RegistryConnectionCounting, this));
+			registerTest("RegistrySlots", "The number of concurrent downloads is limited", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_StreamDownload::test_RegistrySlots, this));
+			registerTest("RangeValidation", "Single ranges are validated and clamped, everything else is unsatisfiable", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_StreamDownload::test_RangeValidation, this));
+			registerTest("RangeLargeOffsets", "Ranges beyond 4 GiB keep their offsets", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_StreamDownload::test_RangeLargeOffsets, this));
+			registerTest("IfRangeAndHTTPDate", "If-Range matching and HTTP date formatting", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_StreamDownload::test_IfRangeAndHTTPDate, this));
+		}
+
+		void initializeTests() override {
+		}
+
+	private:
+
+		void test_RegistryContiguousDelivery()
+		{
+			AMC::CStreamDownloadRegistry registry(4);
+			std::string sUUID = AMCCommon::CUtils::createUUID();
+			const uint64_t nSize = 10000;
+
+			registry.prepareDownload(sUUID, nSize);
+			auto progress = registry.getProgress(sUUID);
+			assertTrue(progress.m_nTotalBytes == nSize, "Total bytes should be set by prepareDownload");
+			assertTrue(progress.m_nDeliveredBytes == 0, "Nothing delivered yet");
+			assertTrue(progress.m_nActiveConnections == 0, "No connection yet");
+
+			registry.connectionStarted(sUUID, nSize);
+			assertTrue(registry.chunkSent(sUUID, 0, 4000), "Chunk should be accepted");
+			assertTrue(registry.getProgress(sUUID).m_nDeliveredBytes == 4000, "First chunk delivered");
+
+			// A chunk after a gap does not count until the gap is filled.
+			assertTrue(registry.chunkSent(sUUID, 6000, 2000), "Chunk after gap should be accepted");
+			assertTrue(registry.getProgress(sUUID).m_nDeliveredBytes == 4000, "Gap keeps the delivered bytes");
+
+			assertTrue(registry.chunkSent(sUUID, 4000, 2000), "Gap filler should be accepted");
+			assertTrue(registry.getProgress(sUUID).m_nDeliveredBytes == 8000, "Filled gap merges the ranges");
+
+			registry.connectionEnded(sUUID, false);
+			progress = registry.getProgress(sUUID);
+			assertTrue(progress.m_nActiveConnections == 0, "Connection ended");
+			assertFalse(progress.m_bCompleted, "Not completed after an interrupted connection");
+
+			// Resume with a range request from the gap.
+			registry.connectionStarted(sUUID, nSize);
+			assertTrue(registry.chunkSent(sUUID, 8000, 2000), "Resume chunk should be accepted");
+			registry.connectionEnded(sUUID, true);
+			progress = registry.getProgress(sUUID);
+			assertTrue(progress.m_nDeliveredBytes == nSize, "All bytes delivered after resume");
+			assertTrue(progress.m_bCompleted, "Completed after resume");
+		}
+
+		void test_RegistryCompletion()
+		{
+			AMC::CStreamDownloadRegistry registry(4);
+			std::string sUUID = AMCCommon::CUtils::createUUID();
+			const uint64_t nSize = 100;
+
+			registry.prepareDownload(sUUID, nSize);
+			registry.connectionStarted(sUUID, nSize);
+			registry.chunkSent(sUUID, 0, 100);
+			assertFalse(registry.getProgress(sUUID).m_bCompleted, "The last byte alone does not complete the download");
+
+			registry.connectionEnded(sUUID, false);
+			assertFalse(registry.getProgress(sUUID).m_bCompleted, "A failed connection end does not complete the download");
+
+			registry.connectionStarted(sUUID, nSize);
+			registry.chunkSent(sUUID, 50, 50);
+			registry.connectionEnded(sUUID, true);
+			assertTrue(registry.getProgress(sUUID).m_bCompleted, "Successful end with all bytes completes the download");
+
+			// An unknown stream reports nothing.
+			auto unknown = registry.getProgress(AMCCommon::CUtils::createUUID());
+			assertTrue(unknown.m_nTotalBytes == 0, "Unknown stream has no size");
+			assertFalse(unknown.m_bCompleted, "Unknown stream is not completed");
+		}
+
+		void test_RegistryCancel()
+		{
+			AMC::CStreamDownloadRegistry registry(4);
+			std::string sUUID = AMCCommon::CUtils::createUUID();
+			const uint64_t nSize = 1000;
+
+			registry.prepareDownload(sUUID, nSize);
+			registry.connectionStarted(sUUID, nSize);
+			assertTrue(registry.chunkSent(sUUID, 0, 100), "Chunk before cancel should be accepted");
+
+			assertTrue(registry.cancel(sUUID), "Cancel of a running download succeeds");
+			assertTrue(registry.isCancelled(sUUID), "Stream is cancelled");
+			assertFalse(registry.chunkSent(sUUID, 100, 100), "Chunk after cancel is refused");
+			assertTrue(registry.getProgress(sUUID).m_bCancelled, "Progress reports the cancel");
+
+			registry.connectionEnded(sUUID, true);
+			assertFalse(registry.getProgress(sUUID).m_bCompleted, "A cancelled download never completes");
+
+			// A new delivery of the same stream starts clean.
+			registry.prepareDownload(sUUID, nSize);
+			assertFalse(registry.isCancelled(sUUID), "prepareDownload clears the cancel");
+			assertTrue(registry.getProgress(sUUID).m_nDeliveredBytes == 0, "prepareDownload clears the delivered bytes");
+
+			registry.connectionStarted(sUUID, nSize);
+			registry.chunkSent(sUUID, 0, 1000);
+			registry.connectionEnded(sUUID, true);
+			assertTrue(registry.getProgress(sUUID).m_bCompleted, "Completed");
+			assertFalse(registry.cancel(sUUID), "Cancel after completion is refused");
+			assertFalse(registry.isCancelled(sUUID), "Completed download stays uncancelled");
+		}
+
+		void test_RegistryConnectionCounting()
+		{
+			AMC::CStreamDownloadRegistry registry(4);
+			std::string sUUID = AMCCommon::CUtils::createUUID();
+
+			registry.prepareDownload(sUUID, 10);
+			// HEAD requests and failures before the first chunk report an end without a start.
+			registry.connectionEnded(sUUID, false);
+			registry.connectionEnded(sUUID, true);
+			assertTrue(registry.getProgress(sUUID).m_nActiveConnections == 0, "Ends without starts do not go negative");
+			assertFalse(registry.getProgress(sUUID).m_bCompleted, "An end without data does not complete");
+
+			registry.connectionStarted(sUUID, 10);
+			registry.connectionStarted(sUUID, 10);
+			assertTrue(registry.getProgress(sUUID).m_nActiveConnections == 2, "Two connections");
+			assertTrue(registry.hasActiveConnections(sUUID), "Has active connections");
+			registry.connectionEnded(sUUID, false);
+			assertTrue(registry.getProgress(sUUID).m_nActiveConnections == 1, "One connection left");
+			registry.connectionEnded(sUUID, false);
+			registry.connectionEnded(sUUID, false);
+			assertTrue(registry.getProgress(sUUID).m_nActiveConnections == 0, "Double end does not go negative");
+			assertFalse(registry.hasActiveConnections(sUUID), "No active connections");
+		}
+
+		void test_RegistrySlots()
+		{
+			AMC::CStreamDownloadRegistry registry(2);
+			assertTrue(registry.getMaxDownloads() == 2, "Max downloads");
+			assertTrue(registry.reserveSlot(), "First slot");
+			assertTrue(registry.reserveSlot(), "Second slot");
+			assertFalse(registry.reserveSlot(), "Third slot is refused");
+			assertTrue(registry.getActiveDownloadCount() == 2, "Two active downloads");
+			registry.releaseSlot();
+			assertTrue(registry.reserveSlot(), "Slot available again after release");
+			registry.releaseSlot();
+			registry.releaseSlot();
+			registry.releaseSlot();
+			assertTrue(registry.getActiveDownloadCount() == 0, "Release never goes negative");
+		}
+
+		void test_RangeValidation()
+		{
+			typedef AMCCommon::CHTTPRange::Range Range;
+			const uint64_t nSize = 1000;
+
+			std::vector<Range> ranges;
+			ranges.push_back(Range(0, 99));
+			assertTrue(AMCCommon::CHTTPRange::normalizeRanges(ranges, nSize), "0-99 is satisfiable");
+			assertTrue(ranges[0].second == 99, "0-99 keeps its end");
+
+			ranges.assign(1, Range(500, -1));
+			assertTrue(AMCCommon::CHTTPRange::normalizeRanges(ranges, nSize), "Open end is satisfiable");
+
+			ranges.assign(1, Range(-1, -1));
+			assertTrue(AMCCommon::CHTTPRange::normalizeRanges(ranges, nSize), "Full range is satisfiable");
+
+			ranges.assign(1, Range(-1, 100));
+			assertTrue(AMCCommon::CHTTPRange::normalizeRanges(ranges, nSize), "Suffix range is satisfiable");
+
+			ranges.assign(1, Range(-1, 0));
+			assertFalse(AMCCommon::CHTTPRange::normalizeRanges(ranges, nSize), "Suffix range of zero length is unsatisfiable");
+
+			ranges.assign(1, Range(0, 999999));
+			assertTrue(AMCCommon::CHTTPRange::normalizeRanges(ranges, nSize), "End beyond the body is satisfiable");
+			assertTrue(ranges[0].second == 999, "End beyond the body is clamped to the last byte");
+
+			ranges.assign(1, Range(1000, -1));
+			assertFalse(AMCCommon::CHTTPRange::normalizeRanges(ranges, nSize), "Start at the end is unsatisfiable");
+
+			ranges.assign(1, Range(5000, 5010));
+			assertFalse(AMCCommon::CHTTPRange::normalizeRanges(ranges, nSize), "Start beyond the end is unsatisfiable");
+
+			ranges.assign(1, Range(100, 50));
+			assertFalse(AMCCommon::CHTTPRange::normalizeRanges(ranges, nSize), "End before start is unsatisfiable");
+
+			ranges.clear();
+			ranges.push_back(Range(0, 99));
+			ranges.push_back(Range(200, 299));
+			assertFalse(AMCCommon::CHTTPRange::normalizeRanges(ranges, nSize), "Several ranges are unsatisfiable");
+
+			ranges.assign(1, Range(0, 0));
+			assertFalse(AMCCommon::CHTTPRange::normalizeRanges(ranges, 0), "Any range of an empty body is unsatisfiable");
+
+			ranges.clear();
+			assertFalse(AMCCommon::CHTTPRange::normalizeRanges(ranges, nSize), "No range is not a range request");
+		}
+
+		void test_RangeLargeOffsets()
+		{
+			typedef AMCCommon::CHTTPRange::Range Range;
+			const uint64_t nSize = 10000000000ULL;
+
+			std::vector<Range> ranges;
+			ranges.push_back(Range(5000000000LL, 5000000099LL));
+			assertTrue(AMCCommon::CHTTPRange::normalizeRanges(ranges, nSize), "Range beyond 4 GiB is satisfiable");
+			assertTrue(ranges[0].first == 5000000000LL, "Start beyond 4 GiB is kept");
+			assertTrue(ranges[0].second == 5000000099LL, "End beyond 4 GiB is kept");
+
+			ranges.assign(1, Range(9999999999LL, 20000000000LL));
+			assertTrue(AMCCommon::CHTTPRange::normalizeRanges(ranges, nSize), "Last byte is satisfiable");
+			assertTrue(ranges[0].second == 9999999999LL, "End is clamped to the last byte");
+
+			ranges.assign(1, Range(10000000000LL, -1));
+			assertFalse(AMCCommon::CHTTPRange::normalizeRanges(ranges, nSize), "Start at the size is unsatisfiable");
+		}
+
+		void test_IfRangeAndHTTPDate()
+		{
+			std::string sETag = "abcdef0123456789";
+			std::string sDate = "Sun, 06 Nov 1994 08:49:37 GMT";
+			assertTrue(AMCCommon::CHTTPRange::ifRangeMatches("", sETag, sDate), "Empty If-Range matches");
+			assertTrue(AMCCommon::CHTTPRange::ifRangeMatches("\"abcdef0123456789\"", sETag, sDate), "Quoted entity tag matches");
+			assertTrue(AMCCommon::CHTTPRange::ifRangeMatches(sDate, sETag, sDate), "Date matches");
+			assertFalse(AMCCommon::CHTTPRange::ifRangeMatches("\"other\"", sETag, sDate), "Other entity tag does not match");
+			assertFalse(AMCCommon::CHTTPRange::ifRangeMatches("Mon, 07 Nov 1994 08:49:37 GMT", sETag, sDate), "Other date does not match");
+
+			// 784111777 seconds since 1970 is Sun, 06 Nov 1994 08:49:37 GMT (the RFC 7231 example).
+			std::string sFormatted = AMCCommon::CHTTPRange::formatHTTPDate(784111777ULL * 1000000ULL);
+			assertTrue(sFormatted == sDate, "HTTP date formatting: " + sFormatted);
+		}
+
+	};
+
+}
+
+#endif //__AMCTEST_UNITTEST_STREAMDOWNLOAD
diff --git a/Implementation/UnitTest/amc_unittests_uifrontend.hpp b/Implementation/UnitTest/amc_unittests_uifrontend.hpp
new file mode 100644
index 000000000..83b8a220d
--- /dev/null
+++ b/Implementation/UnitTest/amc_unittests_uifrontend.hpp
@@ -0,0 +1,226 @@
+/*++
+
+Copyright (C) 2026 Autodesk Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+	* Redistributions of source code must retain the above copyright
+	  notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+	  notice, this list of conditions and the following disclaimer in the
+	  documentation and/or other materials provided with the distribution.
+	* Neither the name of the Autodesk Inc. nor the
+	  names of its contributors may be used to endorse or promote products
+	  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL AUTODESK INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef __AMCTEST_UNITTEST_UIFRONTEND
+#define __AMCTEST_UNITTEST_UIFRONTEND
+
+// The page headers are protected for implementation files; the tests use them white-box.
+#define __AMCIMPL_UI_MODULE
+#define __AMCIMPL_UI_PAGE
+
+#include "amc_unittests.hpp"
+#include "amc_ui_frontenddefinition.hpp"
+#include "amc_ui_frontendstate.hpp"
+#include "amc_ui_page.hpp"
+#include "amc_parametergroup.hpp"
+#include "common_chrono.hpp"
+#include "common_utils.hpp"
+
+#include "RapidJSON/document.h"
+
+
+namespace AMCUnitTest {
+
+	// Pages require an event handler; the tests never trigger events.
+	class CUnitTestUIEventHandler : public AMC::CUIModule_UIEventHandler {
+	public:
+
+		void ensureUIEventExists(const std::string& sEventName) override
+		{
+		}
+
+		AMC::CUIHandleEventResponse handleEvent(const std::string& sEventName, const std::string& sSenderUUID, const std::string& sEventFormPayloadJSON, const std::string& sEventParameterJSON, AMC::PAPIAuth pAPIAuth) override
+		{
+			throw std::runtime_error("unit test event handler does not handle events: " + sEventName);
+		}
+	};
+
+	class CUnitTestGroup_UIFrontend : public CUnitTestGroup {
+	public:
+
+		std::string getTestGroupName() override {
+			return "UIFrontend";
+		}
+
+		void registerTests() override {
+			registerTest("DefinitionValues", "Frontend attributes report definition values without client variables", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_UIFrontend::testDefinitionValues, this));
+			registerTest("ClientVariableValues", "Frontend attributes report values set through the client variables", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_UIFrontend::testClientVariableValues, this));
+			registerTest("SynchronizedAttributes", "Attributes bound to state machine data are flagged as synchronized", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_UIFrontend::testSynchronizedAttributes, this));
+			registerTest("PageShowEvent", "Frontend page status contains the show event", eUnitTestCategory::utMandatoryPass, std::bind(&CUnitTestGroup_UIFrontend::testPageShowEvent, this));
+		}
+
+		void initializeTests() override {
+		}
+
+	private:
+
+		static AMC::CUIExpression fixedExpression(const std::string& sValue)
+		{
+			AMC::CUIExpression expression;
+			expression.setFixedValue(sValue);
+			return expression;
+		}
+
+		static AMC::PUIFrontendDefinition createDefinition()
+		{
+			return std::make_shared<AMC::CUIFrontendDefinition>(std::make_shared<AMCCommon::CChrono>(), std::make_shared<AMC::CFrontendChangeCounter>());
+		}
+
+		// Attributes of a form entity, one per value type.
+		static AMC::PUIFrontendDefinitionModuleStore createEntityStore(AMC::PUIFrontendDefinition pDefinition, const std::string& sPath)
+		{
+			auto pStore = pDefinition->registerModuleStore(AMCCommon::CUtils::createUUID(), sPath, "edit");
+			pStore->registerValue("caption", AMC::eUIFrontendDefinitionAttributeType::atString, fixedExpression("PLC IP Address"));
+			pStore->registerValue("value", AMC::eUIFrontendDefinitionAttributeType::atString, fixedExpression("0"));
+			pStore->registerValue("count", AMC::eUIFrontendDefinitionAttributeType::atInteger, fixedExpression("0"));
+			pStore->registerValue("ratio", AMC::eUIFrontendDefinitionAttributeType::atNumber, fixedExpression("0"));
+			pStore->registerValue("visible", AMC::eUIFrontendDefinitionAttributeType::atBoolean, fixedExpression("1"));
+			pStore->registerValue("readonly", AMC::eUIFrontendDefinitionAttributeType::atBoolean, fixedExpression("0"));
+			return pStore;
+		}
+
+		void writeAttributes(AMC::CUIFrontendState& frontendState, AMC::CUIFrontendDefinitionModuleStore* pStore, rapidjson::Document& document)
+		{
+			AMC::CJSONWriter writer;
+			AMC::CJSONWriterObject attributesObject(writer);
+			frontendState.writeModuleAttributesToJSON(writer, attributesObject, pStore, nullptr, AMC::sUIFrontendBuildEpoch());
+			writer.addObject("attributes", attributesObject);
+
+			document.Parse(writer.saveToString().c_str());
+			assertTrue(document.IsObject() && document.HasMember("attributes"), "attributes JSON");
+		}
+
+		void writePageStatus(AMC::CUIPage& page, AMC::CUIFrontendState& frontendState, rapidjson::Document& document)
+		{
+			AMC::CJSONWriter writer;
+			AMC::CJSONWriterObject pageObject(writer);
+			page.frontendWritePageStatusToJSON(writer, pageObject, &frontendState, nullptr, false, AMC::sUIFrontendBuildEpoch());
+			writer.addObject("page", pageObject);
+
+			document.Parse(writer.saveToString().c_str());
+			assertTrue(document.IsObject() && document.HasMember("page"), "page JSON");
+		}
+
+		void testDefinitionValues()
+		{
+			auto pDefinition = createDefinition();
+			auto pStore = createEntityStore(pDefinition, "systemsettings.plcipaddress.plcipaddress.plcipaddress");
+			AMC::CUIFrontendState frontendState(pDefinition);
+
+			rapidjson::Document document;
+			writeAttributes(frontendState, pStore.get(), document);
+			const auto& attributes = document["attributes"];
+
+			assertTrue(attributes["caption"].GetString() == std::string("PLC IP Address"), "caption");
+			assertTrue(attributes["value"].GetString() == std::string("0"), "value");
+			assertTrue(attributes["count"].GetInt64() == 0, "count");
+			assertDoubleRange(attributes["ratio"].GetDouble(), 0.0, 0.0, "ratio");
+			assertTrue(attributes["visible"].GetBool(), "visible");
+			assertFalse(attributes["readonly"].GetBool(), "readonly");
+		}
+
+		void testClientVariableValues()
+		{
+			std::string sPath = "systemsettings.plcipaddress.plcipaddress.plcipaddress";
+			auto pDefinition = createDefinition();
+			auto pStore = createEntityStore(pDefinition, sPath);
+			auto pOtherStore = createEntityStore(pDefinition, "systemsettings.plcmask.plcmask.plcmask");
+			AMC::CUIFrontendState frontendState(pDefinition);
+
+			// Client variables as populateClientVariables creates them, changed like UIEnvironment::SetUIProperty does.
+			auto pGroup = frontendState.getLegacyParameterHandler()->addGroup(sPath, "form entity edit");
+			pGroup->addNewStringParameter("value", "edit value", "0");
+			pGroup->addNewStringParameter("count", "combo value", "0");
+			pGroup->addNewDoubleParameter("ratio", "ratio", 0.0, 0.001);
+			pGroup->addNewBoolParameter("visible", "visibility", true);
+			pGroup->setParameterValueByName("value", "192.168.2.2");
+			pGroup->setIntParameterValueByName("count", 2);
+			pGroup->setDoubleParameterValueByName("ratio", 1007.0);
+			pGroup->setBoolParameterValueByName("visible", false);
+
+			rapidjson::Document document;
+			writeAttributes(frontendState, pStore.get(), document);
+			const auto& attributes = document["attributes"];
+
+			assertTrue(attributes["value"].GetString() == std::string("192.168.2.2"), "string client value");
+			assertTrue(attributes["count"].GetInt64() == 2, "integer client value");
+			assertDoubleRange(attributes["ratio"].GetDouble(), 1006.999, 1007.001, "number client value");
+			assertFalse(attributes["visible"].GetBool(), "boolean client value");
+
+			// Attributes without a client variable keep their definition value.
+			assertTrue(attributes["caption"].GetString() == std::string("PLC IP Address"), "caption without client variable");
+			assertFalse(attributes["readonly"].GetBool(), "readonly without client variable");
+
+			// Client variables of one element must not change other elements.
+			rapidjson::Document otherDocument;
+			writeAttributes(frontendState, pOtherStore.get(), otherDocument);
+			assertTrue(otherDocument["attributes"]["value"].GetString() == std::string("0"), "other element value");
+			assertTrue(otherDocument["attributes"]["visible"].GetBool(), "other element visibility");
+		}
+
+		void testSynchronizedAttributes()
+		{
+			auto pDefinition = createDefinition();
+			auto pStore = pDefinition->registerModuleStore(AMCCommon::CUtils::createUUID(), "systemsettings.scanner2", "content");
+
+			AMC::CUIExpression syncExpression;
+			syncExpression.setSyncValue("main.jobinfo.isactive");
+
+			auto pSyncAttribute = pStore->registerValue("visible", AMC::eUIFrontendDefinitionAttributeType::atBoolean, syncExpression);
+			auto pFixedAttribute = pStore->registerValue("caption", AMC::eUIFrontendDefinitionAttributeType::atString, fixedExpression("Scanner2"));
+
+			assertTrue(pSyncAttribute->isSynchronized(), "sync expression");
+			assertFalse(pFixedAttribute->isSynchronized(), "fixed expression");
+		}
+
+		void testPageShowEvent()
+		{
+			CUnitTestUIEventHandler eventHandler;
+			auto pDefinition = createDefinition();
+			AMC::CUIFrontendState frontendState(pDefinition);
+
+			AMC::CUIPage pageWithShowEvent("systemsettings", &eventHandler, fixedExpression(""), fixedExpression("System Settings"), fixedExpression(""), "onshowsystemsettings");
+			AMC::CUIPage pageWithoutShowEvent("buildlist", &eventHandler, fixedExpression(""), fixedExpression("Build Library"), fixedExpression(""), "");
+
+			rapidjson::Document document;
+			writePageStatus(pageWithShowEvent, frontendState, document);
+			assertTrue(document["page"]["name"].GetString() == std::string("systemsettings"), "page name");
+			assertTrue(document["page"].HasMember("showevent"), "page with show event");
+			assertTrue(document["page"]["showevent"].GetString() == std::string("onshowsystemsettings"), "show event name");
+
+			rapidjson::Document documentWithoutShowEvent;
+			writePageStatus(pageWithoutShowEvent, frontendState, documentWithoutShowEvent);
+			assertFalse(documentWithoutShowEvent["page"].HasMember("showevent"), "page without show event");
+		}
+	};
+
+}
+
+#endif // __AMCTEST_UNITTEST_UIFRONTEND
diff --git a/build_clean_win64.bat b/build_clean_win64.bat
index 2f1da678e..14554ae25 100644
--- a/build_clean_win64.bat
+++ b/build_clean_win64.bat
@@ -88,7 +88,7 @@ if "%ERRORLEVEL%" neq "0" (
 cd "%builddir%"
 
 echo "Building Core Modules"
-call cmake ..
+call cmake .. -A x64
 if errorlevel 1 goto ERROR
 
 REM call cmake -G "MinGW Makefiles" ..