@@ -76,20 +76,56 @@ supplied, all three are exported.
 - **Permissions** — the storage credential needs blob write on the container; the DTS credential needs
   orchestration read.
 
+## Export format
+
+Each blob holds the instance's full history, and the **blob body is byte-for-byte identical to the .NET
+`Microsoft.DurableTask.ExportHistory` output** (pinned by a test against golden output captured from
+`Microsoft.Azure.DurableTask.Core`):
+
+- **JSONL** (default, gzipped) is one JSON object per line; **JSON** is a single array.
+- Each event is `{"eventType": "...", <type-specific fields>, "eventId": N, "isPlayed": false, "timestamp": "..."}`.
+- camelCase field names, null fields omitted, empty maps as `{}`, enum values in PascalCase (e.g. `"Completed"`),
+  timestamps as trimmed ISO-8601 ending in `Z`, and the same HTML-safe string escaping (`"` → `\u0022`,
+  `& < > ' +` and all non-ASCII → `\uXXXX`).
+
+Blob **names**: a lowercase-hex SHA-256 of `"<completedTimestamp>|<instanceId>"` plus the format extension.
+
 ## Differences from .NET
 
 1. **Worker registration takes an explicit client** — `useExportHistory(workerBuilder, storage, client)`. Java has
    no dependency injection, so the export activities require a `DurableTaskClient` for the same backend.
-2. **Export format** — history is serialized from the structured `com.microsoft.durabletask.history` domain model
-   (camelCase, null fields omitted, one event per line for JSONL). Byte-level parity with .NET's
-   protobuf-`HistoryEvent`-JSON output is an open item.
+2. **Entity events** — the .NET export folds durable-entity operations into core events via a stateful converter, so
+   it has no distinct JSON for them; Java emits entity events in a Java-native shape instead (a reflective projection
+   with an `eventType` discriminator, e.g. `"EntityLockGranted"` — matching the Python SDK, which also keeps entity
+   events as first-class types). Every **non-entity** event is byte-for-byte identical to .NET, so only orchestrations
+   that call entities differ, and only on those entity-specific lines.
 
 ## Backend requirement
 
 The export feature relies on the `ListInstanceIds` and `StreamInstanceHistory` gRPC operations. Managed DTS serves
 both; the emulator / self-hosted sidecar needs **≥ v0.4.22**. Against an older backend, a raw gRPC `UNIMPLEMENTED`
 surfaces (matching .NET).
 
+## Validating the export
+
+Locally, with the DTS emulator and Azurite:
+
+1. Start the backends:
+   ```
+   docker run --name durabletask-emulator -p 4001:8080 -d mcr.microsoft.com/dts/dts-emulator:latest
+   docker run --name azurite -p 10000:10000 -d mcr.microsoft.com/azure-storage/azurite azurite-blob --blobHost 0.0.0.0
+   ```
+2. Point the app at them: DTS connection `Endpoint=http://localhost:4001;Authentication=None`, storage = the Azurite
+   dev connection string, container `orchestration-history`.
+3. Run an orchestration to a terminal state, then create a `BATCH` export job whose window covers its completion time.
+4. Confirm the job reaches `COMPLETED` and inspect progress:
+   ```java
+   ExportJobDescription d = job.describe();
+   // d.getStatus() == ExportJobStatus.COMPLETED, d.getExportedInstances() >= 1
+   ```
+5. Download the blob from the container (gunzip for JSONL) and inspect it. Every line carries an `eventType`
+   discriminator, `isPlayed:false`, and a trailing `timestamp`.
+
 ## Sample
 
 See [`HistoryExportSample`](../samples/src/main/java/io/durabletask/samples/HistoryExportSample.java):
 
@@ -12,7 +12,6 @@ archivesBaseName = 'durabletask-exporthistory'
 def grpcVersion = '1.78.0'
 def azureCoreVersion = '1.57.1'
 def azureStorageBlobVersion = '12.29.1'
-def jacksonVersion = '2.18.3'
 
 // Java 11 is used to compile and run all tests. Set the JDK_11 env var to your
 // local JDK 11 home directory, e.g. C:/Program Files/Java/openjdk-11.0.12_7/
@@ -34,10 +33,6 @@ dependencies {
     // Azure Storage Blobs — export destination for serialized history.
     implementation "com.azure:azure-storage-blob:${azureStorageBlobVersion}"
 
-    // Jackson — serialize the history domain model to JSONL/JSON for export.
-    implementation "com.fasterxml.jackson.core:jackson-databind:${jacksonVersion}"
-    implementation "com.fasterxml.jackson.datatype:jackson-datatype-jsr310:${jacksonVersion}"
-
     // TokenCredential abstraction (from azure-core) — 'api' because
     // ExportHistoryStorageOptions exposes TokenCredential in its public API.
     api "com.azure:azure-core:${azureCoreVersion}"
 
@@ -23,7 +23,7 @@
  * <p>
  * Built once from {@link ExportHistoryStorageOptions} (connection-string or identity auth) and reused across export
  * activities. The target container is taken from each {@link ExportDestination}; the container is created on first
- * use. Mirrors the upload behavior of the .NET {@code ExportInstanceHistoryActivity}.
+ * use.
  */
 final class BlobExportWriter {
 
 
@@ -8,9 +8,8 @@
 /**
  * Request to commit a checkpoint with progress updates and optional failures.
  * <p>
- * Mirrors the .NET {@code Microsoft.DurableTask.ExportHistory.CommitCheckpointRequest}. When
- * {@link #getCheckpoint()} is non-null the cursor moves forward (successful batch); when {@code null} the cursor is
- * retained (failed batch eligible for retry).
+ * When {@link #getCheckpoint()} is non-null the cursor moves forward (successful batch); when {@code null} the
+ * cursor is retained (failed batch eligible for retry).
  */
 public final class CommitCheckpointRequest {
 
 
@@ -9,7 +9,7 @@
  * Orchestrator that executes a single operation on an export job entity and returns its result.
  * <p>
  * The client schedules this orchestrator (rather than signaling the entity directly) so it can await completion and
- * surface validation errors. Mirrors the .NET {@code ExecuteExportJobOperationOrchestrator}.
+ * surface validation errors.
  */
 public final class ExecuteExportJobOperationOrchestrator implements TaskOrchestration {
 
 
@@ -6,15 +6,22 @@
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
 import java.time.Instant;
+import java.time.OffsetDateTime;
+import java.time.ZoneOffset;
 import java.time.format.DateTimeFormatter;
 
 /**
- * Computes export blob names and paths. The blob name is a SHA-256 hash of
- * {@code "<completedTimestamp ISO-8601>|<instanceId>"} plus the format-specific extension, mirroring the .NET
- * {@code ExportInstanceHistoryActivity} naming scheme.
+ * Computes export blob names and paths. The blob name is a lowercase-hex SHA-256 hash of
+ * {@code "<completedTimestamp>|<instanceId>"} plus the format-specific extension. The timestamp is rendered with a
+ * fixed round-trip format ({@code yyyy-MM-ddTHH:mm:ss.fffffff+00:00}) so blob names are stable and idempotent under
+ * retry.
  */
 final class ExportBlobNaming {
 
+    // Date-time portion of the timestamp format; the fractional seconds and offset are appended manually.
+    private static final DateTimeFormatter TIMESTAMP_DATE_TIME =
+            DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss");
+
     private ExportBlobNaming() {
     }
 
@@ -27,10 +34,26 @@ private ExportBlobNaming() {
      * @return the blob file name, e.g. {@code "<hex>.jsonl.gz"}
      */
     static String blobFileName(Instant completedTimestamp, String instanceId, ExportFormat format) {
-        String hashInput = DateTimeFormatter.ISO_INSTANT.format(completedTimestamp) + "|" + instanceId;
+        String hashInput = formatTimestamp(completedTimestamp) + "|" + instanceId;
         return sha256Hex(hashInput) + "." + HistoryEventSerializer.fileExtension(format);
     }
 
+    /**
+     * Formats an instant as {@code yyyy-MM-ddTHH:mm:ss.fffffff+00:00} (seven fractional digits, explicit UTC
+     * offset). The instant is treated as UTC.
+     * <p>
+     * Note: instance timestamps are truncated to milliseconds upstream, so the sub-millisecond fractional digits
+     * are always zero here.
+     *
+     * @param instant the timestamp (treated as UTC)
+     * @return the formatted timestamp string
+     */
+    static String formatTimestamp(Instant instant) {
+        OffsetDateTime utc = instant.atOffset(ZoneOffset.UTC);
+        long ticks = utc.getNano() / 100L;
+        return TIMESTAMP_DATE_TIME.format(utc) + "." + String.format("%07d", ticks) + "+00:00";
+    }
+
     /**
      * Combines an optional prefix with a blob file name.
      *
 
@@ -7,8 +7,7 @@
 /**
  * Checkpoint information used to resume an export.
  * <p>
- * Mirrors the .NET {@code Microsoft.DurableTask.ExportHistory.ExportCheckpoint}. The
- * {@code lastInstanceKey} is the pagination cursor returned by the client {@code listInstanceIds} wrapper.
+ * The {@code lastInstanceKey} is the pagination cursor returned by the client {@code listInstanceIds} wrapper.
  */
 public final class ExportCheckpoint {
 
 
@@ -6,8 +6,6 @@
 
 /**
  * Export destination settings for Azure Blob Storage.
- * <p>
- * Mirrors the .NET {@code Microsoft.DurableTask.ExportHistory.ExportDestination}.
  */
 public final class ExportDestination {
 
 
@@ -6,8 +6,6 @@
 
 /**
  * Failure of a specific instance export.
- * <p>
- * Mirrors the .NET {@code Microsoft.DurableTask.ExportHistory.ExportFailure}.
  */
 public final class ExportFailure {
 
 
@@ -10,8 +10,6 @@
 
 /**
  * Filter criteria for selecting orchestration instances to export.
- * <p>
- * Mirrors the .NET {@code Microsoft.DurableTask.ExportHistory.ExportFilter}.
  */
 public final class ExportFilter {