From bd8af6e9d43db35e5adec7df198ca0a9f63b05e0 Mon Sep 17 00:00:00 2001
From: Jason Doyle <46789294+Jason-Doyle@users.noreply.github.com>
Date: Tue, 29 Sep 2026 19:25:21 -0700
Subject: [PATCH 1/4] Reuse validated Trie index pages

Pass validated secondary-index pages into write preparation, preserve fail-closed configuration checks, and add byte-equivalence and paired local benchmark coverage.
---
 benchmarks/trie-index-page-reuse/README.md  |  30 ++
 benchmarks/trie-index-page-reuse/control.ts |  38 ++
 benchmarks/trie-index-page-reuse/local.mjs  | 431 ++++++++++++++++++++
 package.json                                |   1 +
 src/engines/content-trie.ts                 |  57 ++-
 tests/trie-index-page-reuse.test.ts         | 246 +++++++++++
 6 files changed, 770 insertions(+), 33 deletions(-)
 create mode 100644 benchmarks/trie-index-page-reuse/README.md
 create mode 100644 benchmarks/trie-index-page-reuse/control.ts
 create mode 100644 benchmarks/trie-index-page-reuse/local.mjs
 create mode 100644 tests/trie-index-page-reuse.test.ts

diff --git a/benchmarks/trie-index-page-reuse/README.md b/benchmarks/trie-index-page-reuse/README.md
new file mode 100644
index 0000000..24dcd24
--- /dev/null
+++ b/benchmarks/trie-index-page-reuse/README.md
@@ -0,0 +1,30 @@
+# Trie index-page reuse benchmark
+
+This benchmark measures a production-internal optimisation: a Trie write
+reuses each secondary-index page already loaded and validated before mutation
+preparation.
+
+The control wraps the candidate engine and deliberately duplicates every
+index-page read. This recreates the previous operation count in the same
+process, fixture, and benchmark run.
+
+## Local preflight
+
+```powershell
+npm run benchmark:trie-index-reuse
+```
+
+The local matrix covers:
+
+- 128, 5,000, and 25,000 documents
+- zero, one, and two indexes
+- eight independent updates per case
+- exact decoded protocol equivalence
+
+Acceptance requires:
+
+- one authoritative read removed per configured index
+- identical decoded keys and values
+- no indexed p50 regression above 5 percent
+
+Regional evidence is required before merging the production change.
diff --git a/benchmarks/trie-index-page-reuse/control.ts b/benchmarks/trie-index-page-reuse/control.ts
new file mode 100644
index 0000000..347ae2a
--- /dev/null
+++ b/benchmarks/trie-index-page-reuse/control.ts
@@ -0,0 +1,38 @@
+import type {
+  ObjectStore,
+  PutConditions,
+  StoredObject,
+} from "../../src/core.js";
+
+export class DuplicateIndexReadStore
+implements ObjectStore {
+  constructor(private readonly delegate: ObjectStore) {}
+
+  async get(key: string): Promise<StoredObject | null> {
+    const object = await this.delegate.get(key);
+    if (key.includes("/indexes/")) {
+      await this.delegate.get(key);
+    }
+    return object;
+  }
+
+  put(
+    key: string,
+    bytes: Uint8Array,
+    conditions?: PutConditions,
+  ) {
+    return this.delegate.put(
+      key,
+      bytes,
+      conditions,
+    );
+  }
+
+  delete(key: string) {
+    return this.delegate.delete(key);
+  }
+
+  list(prefix: string) {
+    return this.delegate.list(prefix);
+  }
+}
diff --git a/benchmarks/trie-index-page-reuse/local.mjs b/benchmarks/trie-index-page-reuse/local.mjs
new file mode 100644
index 0000000..9bf81dc
--- /dev/null
+++ b/benchmarks/trie-index-page-reuse/local.mjs
@@ -0,0 +1,431 @@
+import {
+  mkdir,
+  writeFile,
+} from "node:fs/promises";
+import path from "node:path";
+import { performance } from "node:perf_hooks";
+import {
+  PreconditionFailedError,
+} from "../../src/core.ts";
+import { ContentAddressedTrieEngine } from "../../src/engines/content-trie.ts";
+import { EnvelopeObjectStore } from "../../src/envelope-store.ts";
+import {
+  importAesGcmKey,
+} from "../../src/envelope.ts";
+import { DuplicateIndexReadStore } from "./control.ts";
+import {
+  BENCHMARK_COLLECTION,
+  BENCHMARK_PROFILES,
+  WRITE_SCALING_INDEX_SETS,
+  benchmarkDocuments,
+} from "../write-scaling/regional/scenario.ts";
+
+const iterations = Number(
+  process.env.THIMBLE_INDEX_REUSE_ITERATIONS ?? "8",
+);
+const modes = ["duplicate", "reuse"];
+
+async function main() {
+  const rawKey = Uint8Array.from(
+    { length: 32 },
+    (_, index) => index + 193,
+  );
+  const key = await importAesGcmKey(
+    rawKey,
+    ["encrypt", "decrypt"],
+  );
+  const results = {};
+
+  for (const [profile, count] of Object.entries(
+    BENCHMARK_PROFILES,
+  )) {
+    const documents = benchmarkDocuments(count);
+    for (const [indexSet, indexes] of Object.entries(
+      WRITE_SCALING_INDEX_SETS,
+    )) {
+      const seededRaw = new CountingStore();
+      await engine(
+        envelope(seededRaw, key),
+        indexes,
+      ).putMany(BENCHMARK_COLLECTION, documents);
+      const samples = Object.fromEntries(
+        modes.map((mode) => [mode, []]),
+      );
+
+      for (
+        let iteration = 0;
+        iteration < iterations;
+        iteration += 1
+      ) {
+        const index =
+          (iteration * 997) % count;
+        const document = {
+          ...documents[index],
+          body:
+            `${documents[index].body} index-reuse ` +
+            iteration,
+          lastModified: count + iteration,
+        };
+        const duplicateRaw = seededRaw.clone();
+        const reuseRaw = seededRaw.clone();
+        const duplicateStore = new DuplicateIndexReadStore(
+          envelope(duplicateRaw, key),
+        );
+        const reuseStore = envelope(reuseRaw, key);
+        duplicateRaw.resetMetrics();
+        reuseRaw.resetMetrics();
+
+        const duplicateStarted = performance.now();
+        await engine(
+          duplicateStore,
+          indexes,
+        ).put(
+          BENCHMARK_COLLECTION,
+          document.id,
+          document,
+        );
+        samples.duplicate.push(
+          sample(
+            performance.now() -
+              duplicateStarted,
+            duplicateRaw,
+          ),
+        );
+
+        const reuseStarted = performance.now();
+        await engine(
+          reuseStore,
+          indexes,
+        ).put(
+          BENCHMARK_COLLECTION,
+          document.id,
+          document,
+        );
+        samples.reuse.push(
+          sample(
+            performance.now() - reuseStarted,
+            reuseRaw,
+          ),
+        );
+
+        const duplicateSnapshot =
+          await decodedSnapshot(
+            duplicateStore,
+          );
+        const reuseSnapshot =
+          await decodedSnapshot(reuseStore);
+        if (
+          JSON.stringify(duplicateSnapshot) !==
+          JSON.stringify(reuseSnapshot)
+        ) {
+          throw new Error(
+            `${profile}/${indexSet} changed protocol objects`,
+          );
+        }
+      }
+
+      results[`${profile}-${indexSet}`] = {
+        profile,
+        documents: count,
+        indexSet,
+        indexCount:
+          indexes.notes?.length ?? 0,
+        duplicate: {
+          summary: summarise(
+            samples.duplicate,
+          ),
+          samples: samples.duplicate,
+        },
+        reuse: {
+          summary: summarise(samples.reuse),
+          samples: samples.reuse,
+        },
+        comparison: compare(
+          samples.reuse,
+          samples.duplicate,
+        ),
+      };
+    }
+  }
+
+  const output = {
+    generatedAt: new Date().toISOString(),
+    sourceCommit:
+      process.env.THIMBLE_BENCHMARK_SOURCE_COMMIT ??
+        null,
+    iterations,
+    warning:
+      "Local in-memory CPU and operation-count preflight. Regional cloud evidence remains required for end-to-end latency conclusions.",
+    acceptance: {
+      protocolEquivalent:
+        "Every candidate must retain identical decoded keys and bytes.",
+      reads:
+        "Reuse must remove exactly one read per configured index.",
+      indexedP50:
+        "Indexed candidate p50 must not regress by more than 5%.",
+    },
+    results,
+  };
+  await mkdir("benchmark-results", {
+    recursive: true,
+  });
+  const outputPath = path.resolve(
+    "benchmark-results",
+    `trie-index-page-reuse-${Date.now()}.json`,
+  );
+  await writeFile(
+    outputPath,
+    `${JSON.stringify(output, null, 2)}\n`,
+  );
+  console.log(JSON.stringify({
+    outputPath,
+    results: Object.fromEntries(
+      Object.entries(results).map(
+        ([name, result]) => [
+          name,
+          {
+            duplicate:
+              result.duplicate.summary,
+            reuse: result.reuse.summary,
+            comparison: result.comparison,
+          },
+        ],
+      ),
+    ),
+  }, null, 2));
+}
+
+function engine(store, indexes) {
+  return new ContentAddressedTrieEngine(
+    store,
+    40,
+    undefined,
+    false,
+    indexes,
+  );
+}
+
+function envelope(raw, key) {
+  return new EnvelopeObjectStore(raw, {
+    key,
+    keyId: "trie-index-reuse-local-v1",
+    compression: "gzip",
+  });
+}
+
+function sample(elapsedMs, raw) {
+  return {
+    elapsedMs: round(elapsedMs),
+    reads: raw.reads,
+    indexReads: raw.indexReads,
+    readBytes: raw.readBytes,
+    writes: raw.writes,
+    writeBytes: raw.writeBytes,
+    preconditionFailures:
+      raw.preconditionFailures,
+  };
+}
+
+async function decodedSnapshot(store) {
+  const keys = (await store.list("")).sort();
+  return Promise.all(
+    keys.map(async (key) => {
+      const object = await store.get(key);
+      return [
+        key,
+        object
+          ? Buffer.from(object.bytes).toString("base64")
+          : null,
+      ];
+    }),
+  );
+}
+
+function summarise(samples) {
+  return {
+    p50Ms: percentile(
+      samples.map((value) => value.elapsedMs),
+      0.5,
+    ),
+    p95Ms: percentile(
+      samples.map((value) => value.elapsedMs),
+      0.95,
+    ),
+    meanMs: mean(
+      samples.map((value) => value.elapsedMs),
+    ),
+    meanReads: mean(
+      samples.map((value) => value.reads),
+    ),
+    meanIndexReads: mean(
+      samples.map((value) => value.indexReads),
+    ),
+    meanReadBytes: Math.round(
+      mean(
+        samples.map((value) => value.readBytes),
+      ),
+    ),
+    meanWrites: mean(
+      samples.map((value) => value.writes),
+    ),
+    meanWriteBytes: Math.round(
+      mean(
+        samples.map((value) => value.writeBytes),
+      ),
+    ),
+  };
+}
+
+function compare(candidate, baseline) {
+  const candidateSummary =
+    summarise(candidate);
+  const baselineSummary =
+    summarise(baseline);
+  return {
+    p50ChangePercent: change(
+      candidateSummary.p50Ms,
+      baselineSummary.p50Ms,
+    ),
+    p95ChangePercent: change(
+      candidateSummary.p95Ms,
+      baselineSummary.p95Ms,
+    ),
+    readCountChangePercent: change(
+      candidateSummary.meanReads,
+      baselineSummary.meanReads,
+    ),
+    readByteChangePercent: change(
+      candidateSummary.meanReadBytes,
+      baselineSummary.meanReadBytes,
+    ),
+  };
+}
+
+function percentile(values, quantile) {
+  const sorted = [...values].sort(
+    (left, right) => left - right,
+  );
+  return sorted[
+    Math.min(
+      sorted.length - 1,
+      Math.ceil(sorted.length * quantile) - 1,
+    )
+  ];
+}
+
+function mean(values) {
+  return Number(
+    (
+      values.reduce(
+        (total, value) => total + value,
+        0,
+      ) / values.length
+    ).toFixed(3),
+  );
+}
+
+function change(candidate, baseline) {
+  if (baseline === 0) {
+    return candidate === 0 ? 0 : null;
+  }
+  return Number(
+    (
+      ((candidate - baseline) / baseline) *
+      100
+    ).toFixed(2),
+  );
+}
+
+function round(value) {
+  return Number(value.toFixed(3));
+}
+
+class CountingStore {
+  objects = new Map();
+  etag = 0;
+  reads = 0;
+  indexReads = 0;
+  readBytes = 0;
+  writes = 0;
+  writeBytes = 0;
+  preconditionFailures = 0;
+
+  get(key) {
+    const object = this.objects.get(key);
+    this.reads += 1;
+    if (key.includes("/indexes/")) {
+      this.indexReads += 1;
+    }
+    this.readBytes +=
+      object?.bytes.byteLength ?? 0;
+    return Promise.resolve(
+      object
+        ? {
+            bytes: object.bytes.slice(),
+            etag: object.etag,
+          }
+        : null,
+    );
+  }
+
+  put(key, bytes, conditions = {}) {
+    const current = this.objects.get(key);
+    if (
+      (conditions.ifNoneMatch && current) ||
+      (conditions.ifMatch !== undefined &&
+        current?.etag !== conditions.ifMatch)
+    ) {
+      this.preconditionFailures += 1;
+      return Promise.reject(
+        new PreconditionFailedError(key),
+      );
+    }
+    const etag = String(++this.etag);
+    this.objects.set(key, {
+      bytes: bytes.slice(),
+      etag,
+    });
+    this.writes += 1;
+    this.writeBytes += bytes.byteLength;
+    return Promise.resolve({ etag });
+  }
+
+  delete(key) {
+    this.objects.delete(key);
+    return Promise.resolve();
+  }
+
+  list(prefix) {
+    return Promise.resolve(
+      [...this.objects.keys()].filter((key) =>
+        key.startsWith(prefix),
+      ),
+    );
+  }
+
+  clone() {
+    const clone = new CountingStore();
+    clone.etag = this.etag;
+    clone.objects = new Map(
+      [...this.objects].map(([key, object]) => [
+        key,
+        {
+          bytes: object.bytes.slice(),
+          etag: object.etag,
+        },
+      ]),
+    );
+    return clone;
+  }
+
+  resetMetrics() {
+    this.reads = 0;
+    this.indexReads = 0;
+    this.readBytes = 0;
+    this.writes = 0;
+    this.writeBytes = 0;
+    this.preconditionFailures = 0;
+  }
+}
+
+await main();
diff --git a/package.json b/package.json
index f45d545..c37b04e 100644
--- a/package.json
+++ b/package.json
@@ -116,6 +116,7 @@
     "benchmark:current-regional:aggregate": "tsx benchmarks/current-regional/aggregate.mjs",
     "benchmark:current-regional:publish": "tsx benchmarks/current-regional/publish.mjs",
     "benchmark:write-scaling": "tsx benchmarks/write-scaling/local.mjs",
+    "benchmark:trie-index-reuse": "tsx benchmarks/trie-index-page-reuse/local.mjs",
     "benchmark:write-scaling:regional:generate": "tsx benchmarks/write-scaling/regional/generate-data.mjs",
     "benchmark:write-scaling:regional:build": "tsc -p benchmarks/write-scaling/regional/tsconfig.json --noEmit && vite build --config benchmarks/write-scaling/regional/vite.config.ts",
     "benchmark:write-scaling:regional:upload": "tsx benchmarks/write-scaling/regional/upload.mjs",
diff --git a/src/engines/content-trie.ts b/src/engines/content-trie.ts
index a119173..f5b5839 100644
--- a/src/engines/content-trie.ts
+++ b/src/engines/content-trie.ts
@@ -542,7 +542,11 @@ export class ContentAddressedTrieEngine implements DatabaseEngine {
       expectedHeadEtag === undefined ? this.maxRetries : 1;
     for (let attempt = 0; attempt < attempts; attempt += 1) {
       const head = await this.loadHead(normalized);
-      await this.requireIndexConfiguration(normalized, head.state);
+      const currentIndexPages =
+        await this.requireIndexConfiguration(
+          normalized,
+          head.state,
+        );
       if (
         expectedHeadEtag !== undefined &&
         (head.object?.etag ?? null) !== expectedHeadEtag
@@ -553,6 +557,7 @@ export class ContentAddressedTrieEngine implements DatabaseEngine {
         normalized,
         head.state,
         collapsedChanges,
+        currentIndexPages,
       );
       const limitIndexWrite = createAsyncOperationLimiter(
         MAX_PARALLEL_INDEX_WRITES,
@@ -1175,6 +1180,10 @@ export class ContentAddressedTrieEngine implements DatabaseEngine {
     collection: string,
     head: TrieHead,
     changes: SecondaryIndexChange[],
+    currentIndexPages: ReadonlyMap<
+      string,
+      SecondaryIndexPage
+    >,
   ): Promise<PreparedSecondaryIndex[]> {
     const definitions = this.indexConfiguration[collection] ?? [];
     if (definitions.length === 0) {
@@ -1187,38 +1196,14 @@ export class ContentAddressedTrieEngine implements DatabaseEngine {
       const currentReference = head.indexes?.[definition.name];
       let currentPage: SecondaryIndexPage | null = null;
       if (currentReference && !this.allowIndexConfigurationChange) {
-        const object = await this.store.get(
-          trieIndexKey(
-            collection,
-            definition.name,
-            currentReference.hash,
-          ),
-        );
-        if (!object) {
+        const validated =
+          currentIndexPages.get(definition.name);
+        if (!validated) {
           throw new Error(
-            `Secondary index ${definition.name} is missing`,
-          );
-        }
-        const loadedPage = secondaryIndexPageFromJson(
-          decodeJson<JsonValue>(object.bytes),
-        );
-        if (
-          secondaryIndexDefinitionsEqual(
-            loadedPage.definition,
-            definition,
-          )
-        ) {
-          currentPage = loadedPage;
-        } else {
-          storedDocuments ??= await this.scanStoredFromHead(
-            collection,
-            head,
-          );
-          currentPage = buildSecondaryIndexPage(
-            definition,
-            storedDocuments,
+            `Secondary index ${definition.name} was not validated`,
           );
         }
+        currentPage = validated;
       } else {
         storedDocuments ??= await this.scanStoredFromHead(
           collection,
@@ -1339,10 +1324,14 @@ export class ContentAddressedTrieEngine implements DatabaseEngine {
   private async requireIndexConfiguration(
     collection: string,
     head: TrieHead,
-  ): Promise<void> {
+  ): Promise<Map<string, SecondaryIndexPage>> {
     const active = Object.entries(head.indexes ?? {});
+    const pages = new Map<
+      string,
+      SecondaryIndexPage
+    >();
     if (this.allowIndexConfigurationChange) {
-      return;
+      return pages;
     }
     const configured = new Map(
       (this.indexConfiguration[collection] ?? []).map(
@@ -1350,7 +1339,7 @@ export class ContentAddressedTrieEngine implements DatabaseEngine {
       ),
     );
     if (head.revision === 0 && active.length === 0) {
-      return;
+      return pages;
     }
     if (active.length !== configured.size) {
       throw new Error(
@@ -1383,7 +1372,9 @@ export class ContentAddressedTrieEngine implements DatabaseEngine {
           `Collection ${collection} secondary index ${name} does not match the supplied configuration`,
         );
       }
+      pages.set(name, page);
     }
+    return pages;
   }
 
   private async readStoredAtHead(
diff --git a/tests/trie-index-page-reuse.test.ts b/tests/trie-index-page-reuse.test.ts
new file mode 100644
index 0000000..8bce41d
--- /dev/null
+++ b/tests/trie-index-page-reuse.test.ts
@@ -0,0 +1,246 @@
+import { createHash } from "node:crypto";
+import { describe, expect, it } from "vitest";
+import {
+  PreconditionFailedError,
+  type ObjectStore,
+  type PutConditions,
+  type StoredObject,
+} from "../src/core.js";
+import { ContentAddressedTrieEngine } from "../src/engines/content-trie.js";
+import type {
+  CollectionIndexConfiguration,
+} from "../src/secondary-index.js";
+
+const indexes: CollectionIndexConfiguration = {
+  notes: [
+    {
+      name: "by-title",
+      fields: ["title"],
+      mode: "equality",
+    },
+    {
+      name: "by-rank",
+      fields: ["rank"],
+      mode: "range",
+    },
+  ],
+};
+const address = (bytes: Uint8Array) =>
+  createHash("sha256").update(bytes).digest("hex");
+
+describe("Trie index page reuse", () => {
+  it("removes one read per index without changing stored bytes", async () => {
+    const seeded = new MemoryStore();
+    await engine(seeded).putMany("notes", [
+      {
+        id: "note-1",
+        title: "First",
+        rank: 1,
+      },
+      {
+        id: "note-2",
+        title: "Second",
+        rank: 2,
+      },
+    ]);
+    const baselineStore = seeded.clone();
+    const candidateStore = seeded.clone();
+    const baselineReads =
+      new DuplicateIndexReadStore(baselineStore);
+    baselineStore.resetMetrics();
+    candidateStore.resetMetrics();
+    const document = {
+      id: "note-1",
+      title: "Updated",
+      rank: 3,
+    };
+
+    await engine(baselineReads).put(
+      "notes",
+      document.id,
+      document,
+    );
+    await engine(candidateStore).put(
+      "notes",
+      document.id,
+      document,
+    );
+
+    expect(baselineStore.reads).toBe(8);
+    expect(baselineStore.indexReads).toBe(4);
+    expect(candidateStore.reads).toBe(6);
+    expect(candidateStore.indexReads).toBe(2);
+    expect(candidateStore.snapshot()).toEqual(
+      baselineStore.snapshot(),
+    );
+  });
+
+  it("still rejects partial index configuration before candidate writes", async () => {
+    const store = new MemoryStore();
+    await engine(store).putMany("notes", [
+      {
+        id: "note-1",
+        title: "First",
+        rank: 1,
+      },
+    ]);
+    store.resetMetrics();
+    const partial = new ContentAddressedTrieEngine(
+      store,
+      40,
+      address,
+      false,
+      {
+        notes: [indexes.notes![0]!],
+      },
+    );
+
+    await expect(
+      partial.put("notes", "note-1", {
+        id: "note-1",
+        title: "Rejected",
+        rank: 2,
+      }),
+    ).rejects.toThrow(
+      "active secondary indexes do not exactly match",
+    );
+    expect(store.writes).toBe(0);
+  });
+});
+
+function engine(store: ObjectStore) {
+  return new ContentAddressedTrieEngine(
+    store,
+    40,
+    address,
+    false,
+    indexes,
+  );
+}
+
+class DuplicateIndexReadStore implements ObjectStore {
+  constructor(private readonly delegate: ObjectStore) {}
+
+  async get(key: string): Promise<StoredObject | null> {
+    const object = await this.delegate.get(key);
+    if (key.includes("/indexes/")) {
+      await this.delegate.get(key);
+    }
+    return object;
+  }
+
+  put(
+    key: string,
+    bytes: Uint8Array,
+    conditions?: PutConditions,
+  ) {
+    return this.delegate.put(
+      key,
+      bytes,
+      conditions,
+    );
+  }
+
+  delete(key: string) {
+    return this.delegate.delete(key);
+  }
+
+  list(prefix: string) {
+    return this.delegate.list(prefix);
+  }
+}
+
+class MemoryStore implements ObjectStore {
+  private objects = new Map<string, StoredObject>();
+  private etag = 0;
+  reads = 0;
+  indexReads = 0;
+  writes = 0;
+
+  get(key: string): Promise<StoredObject | null> {
+    this.reads += 1;
+    if (key.includes("/indexes/")) {
+      this.indexReads += 1;
+    }
+    const object = this.objects.get(key);
+    return Promise.resolve(
+      object
+        ? {
+            bytes: object.bytes.slice(),
+            etag: object.etag,
+          }
+        : null,
+    );
+  }
+
+  put(
+    key: string,
+    bytes: Uint8Array,
+    conditions: PutConditions = {},
+  ): Promise<{ etag: string }> {
+    const current = this.objects.get(key);
+    if (
+      (conditions.ifNoneMatch && current) ||
+      (conditions.ifMatch !== undefined &&
+        current?.etag !== conditions.ifMatch)
+    ) {
+      return Promise.reject(
+        new PreconditionFailedError(key),
+      );
+    }
+    const etag = String(++this.etag);
+    this.objects.set(key, {
+      bytes: bytes.slice(),
+      etag,
+    });
+    this.writes += 1;
+    return Promise.resolve({ etag });
+  }
+
+  delete(key: string): Promise<void> {
+    this.objects.delete(key);
+    return Promise.resolve();
+  }
+
+  list(prefix: string): Promise<string[]> {
+    return Promise.resolve(
+      [...this.objects.keys()].filter((key) =>
+        key.startsWith(prefix),
+      ),
+    );
+  }
+
+  clone(): MemoryStore {
+    const clone = new MemoryStore();
+    clone.etag = this.etag;
+    clone.objects = new Map(
+      [...this.objects].map(([key, object]) => [
+        key,
+        {
+          bytes: object.bytes.slice(),
+          etag: object.etag,
+        },
+      ]),
+    );
+    return clone;
+  }
+
+  snapshot(): Record<string, string> {
+    return Object.fromEntries(
+      [...this.objects]
+        .sort(([left], [right]) =>
+          left.localeCompare(right),
+        )
+        .map(([key, object]) => [
+          key,
+          Buffer.from(object.bytes).toString("base64"),
+        ]),
+    );
+  }
+
+  resetMetrics(): void {
+    this.reads = 0;
+    this.indexReads = 0;
+    this.writes = 0;
+  }
+}

From a1a1d02d9ce71318956e5a5cb9574eed43314c04 Mon Sep 17 00:00:00 2001
From: Jason Doyle <46789294+Jason-Doyle@users.noreply.github.com>
Date: Tue, 29 Sep 2026 19:27:35 -0700
Subject: [PATCH 2/4] Add paired regional index reuse benchmark

Compare the production candidate with a control that reproduces duplicate index reads across isolated regional R2 fixtures and verifies final protocol state.
---
 .../regional/aggregate.mjs                    | 433 ++++++++++
 .../regional/client-runner.ts                 | 296 +++++++
 .../regional/generate-data.mjs                | 172 ++++
 .../regional/scenario.ts                      |  36 +
 .../regional/tsconfig.json                    |  12 +
 .../trie-index-page-reuse/regional/upload.mjs | 106 +++
 .../regional/vite.config.ts                   |  25 +
 .../trie-index-page-reuse/regional/worker.ts  | 776 ++++++++++++++++++
 package.json                                  |   4 +
 9 files changed, 1860 insertions(+)
 create mode 100644 benchmarks/trie-index-page-reuse/regional/aggregate.mjs
 create mode 100644 benchmarks/trie-index-page-reuse/regional/client-runner.ts
 create mode 100644 benchmarks/trie-index-page-reuse/regional/generate-data.mjs
 create mode 100644 benchmarks/trie-index-page-reuse/regional/scenario.ts
 create mode 100644 benchmarks/trie-index-page-reuse/regional/tsconfig.json
 create mode 100644 benchmarks/trie-index-page-reuse/regional/upload.mjs
 create mode 100644 benchmarks/trie-index-page-reuse/regional/vite.config.ts
 create mode 100644 benchmarks/trie-index-page-reuse/regional/worker.ts

diff --git a/benchmarks/trie-index-page-reuse/regional/aggregate.mjs b/benchmarks/trie-index-page-reuse/regional/aggregate.mjs
new file mode 100644
index 0000000..08239b4
--- /dev/null
+++ b/benchmarks/trie-index-page-reuse/regional/aggregate.mjs
@@ -0,0 +1,433 @@
+import {
+  mkdir,
+  readFile,
+  writeFile,
+} from "node:fs/promises";
+import path from "node:path";
+import {
+  BENCHMARK_PROFILES,
+  BENCHMARK_REGIONS,
+  INDEX_REUSE_INDEX_SETS,
+} from "./scenario.ts";
+
+const root = path.resolve(
+  process.env.THIMBLE_INDEX_REUSE_OUTPUT ??
+    ".bench-data/trie-index-page-reuse-regional",
+);
+const outputPath = path.resolve(
+  process.env.THIMBLE_INDEX_REUSE_EVIDENCE ??
+    "evidence/trie-index-page-reuse-regional-worker-2026-09-30.json",
+);
+const replicates = (
+  process.env.THIMBLE_INDEX_REUSE_REPLICATES ??
+    "a,b"
+)
+  .split(",")
+  .map((value) => value.trim())
+  .filter(Boolean);
+const manifest = JSON.parse(
+  await readFile(
+    path.join(root, "manifest.json"),
+    "utf8",
+  ),
+);
+const runs = await loadRuns();
+const cases = collectCases(runs);
+const summaries = Object.fromEntries(
+  Object.entries(cases).map(([name, samples]) => [
+    name,
+    summarise(samples),
+  ]),
+);
+const comparisons = buildComparisons(summaries);
+const verification = runs.flatMap((run) =>
+  run.result.verification.map((value) => ({
+    replicate: run.replicate,
+    region: run.region,
+    ...value,
+  })),
+);
+
+const evidence = {
+  generatedAt: new Date().toISOString(),
+  sourceCommit: manifest.sourceCommit,
+  harnessCommits: unique(
+    runs.map((run) => run.result.harnessCommit),
+  ),
+  target:
+    "temporary workers.dev Worker and temporary Cloudflare R2 bucket",
+  productionChanged: false,
+  profiles: manifest.profiles,
+  indexSets: manifest.indexSets,
+  modes: manifest.modes,
+  methodology: {
+    execution:
+      "Disposable Azure Node 22 callers compared the production index-page reuse path with a control wrapper that duplicates each index get.",
+    regions: BENCHMARK_REGIONS,
+    replicates: replicates.length,
+    iterationsPerCase: 4,
+    matrix:
+      "128, 5,000, and 25,000 documents with one and two secondary indexes.",
+    primaryLatency:
+      "clientElapsedMs measured one complete Trie document update.",
+    equivalence:
+      "Post-run stored documents and active HEAD values were compared between control and candidate prefixes.",
+  },
+  acceptance: {
+    allWritesSucceeded:
+      Object.values(summaries).every(
+        (summary) => summary.failed === 0,
+      ),
+    protocolEquivalent:
+      verification.every(
+        (value) => value.equivalent,
+      ),
+    exactReadReduction:
+      ["small", "medium", "large"].every(
+        (profile) =>
+          comparisons[`${profile}-one`]
+            .candidateReads === 5 &&
+          comparisons[`${profile}-two`]
+            .candidateReads === 6,
+      ),
+    mediumAndLargeP50AtLeast10Percent:
+      ["medium", "large"].every((profile) =>
+        Object.keys(INDEX_REUSE_INDEX_SETS).every(
+          (indexSet) =>
+            comparisons[
+              `${profile}-${indexSet}`
+            ].p50ChangePercent <= -10,
+        ),
+      ),
+    p95DoesNotRegressMoreThan10Percent:
+      Object.values(comparisons).every(
+        (comparison) =>
+          comparison.p95ChangePercent <= 10,
+      ),
+  },
+  limitations: [
+    "The control reproduces the old operation count by duplicating each immutable index get around the candidate engine.",
+    "Azure regions approximate geography and do not represent residential last-mile networks.",
+    "One Cloudflare account and one R2 bucket placement were used.",
+    "Authentication and browser rendering were excluded.",
+    "Cloudflare Worker timers do not measure CPU-only work normally.",
+  ],
+  totals: {
+    operations: Object.values(cases).reduce(
+      (total, samples) =>
+        total + samples.length,
+      0,
+    ),
+    runs: runs.length,
+    verificationCases: verification.length,
+  },
+  overall: {
+    cases: summaries,
+    comparisons,
+  },
+  regions: Object.fromEntries(
+    BENCHMARK_REGIONS.map((region) => {
+      const regional = collectCases(
+        runs.filter(
+          (run) => run.region === region,
+        ),
+      );
+      const regionalSummary =
+        Object.fromEntries(
+          Object.entries(regional).map(
+            ([name, samples]) => [
+              name,
+              summarise(samples),
+            ],
+          ),
+        );
+      return [
+        region,
+        {
+          cases: regionalSummary,
+          comparisons:
+            buildComparisons(regionalSummary),
+        },
+      ];
+    }),
+  ),
+  verification,
+  runs,
+};
+
+await mkdir(path.dirname(outputPath), {
+  recursive: true,
+});
+await writeFile(
+  outputPath,
+  `${JSON.stringify(evidence, null, 2)}\n`,
+);
+console.log(JSON.stringify({
+  outputPath,
+  totals: evidence.totals,
+  acceptance: evidence.acceptance,
+  comparisons: evidence.overall.comparisons,
+}, null, 2));
+
+async function loadRuns() {
+  const loaded = [];
+  for (const replicate of replicates) {
+    for (const region of BENCHMARK_REGIONS) {
+      const file = path.join(
+        root,
+        "results",
+        `index-reuse-${replicate}`,
+        `${region}.json`,
+      );
+      loaded.push({
+        replicate,
+        region,
+        result: JSON.parse(
+          await readFile(file, "utf8"),
+        ),
+      });
+    }
+  }
+  return loaded;
+}
+
+function collectCases(selected) {
+  const result = {};
+  for (const run of selected) {
+    for (const [name, samples] of Object.entries(
+      run.result.samples,
+    )) {
+      result[name] ??= [];
+      result[name].push(...samples);
+    }
+  }
+  return result;
+}
+
+function summarise(samples) {
+  const successful = samples.filter(
+    (sample) => sample.success !== false,
+  );
+  const elapsed = sorted(
+    successful.map(
+      (sample) => sample.clientElapsedMs,
+    ),
+  );
+  return {
+    operations: samples.length,
+    successful: successful.length,
+    failed: samples.length - successful.length,
+    successRatePercent: percent(
+      successful.length,
+      samples.length,
+    ),
+    clientP50Ms: percentile(elapsed, 0.5),
+    clientP95Ms: percentile(elapsed, 0.95),
+    clientMeanMs: mean(elapsed),
+    workerMeanMs: mean(
+      successful.map(
+        (sample) =>
+          sample.workerIoTimerMs ?? 0,
+      ),
+    ),
+    meanReads: mean(
+      successful.map(
+        (sample) =>
+          sample.storage.reads.count,
+      ),
+    ),
+    meanReadBytes: Math.round(
+      mean(
+        successful.map(
+          (sample) =>
+            sample.storage.reads.bytes,
+        ),
+      ),
+    ),
+    meanReadDurationMs: mean(
+      successful.map(
+        (sample) =>
+          sample.storage.reads.durationMs,
+      ),
+    ),
+    meanWrites: mean(
+      successful.map(
+        (sample) =>
+          sample.storage.writes.count,
+      ),
+    ),
+    meanWriteBytes: Math.round(
+      mean(
+        successful.map(
+          (sample) =>
+            sample.storage.writes.bytes,
+        ),
+      ),
+    ),
+    meanWriteDurationMs: mean(
+      successful.map(
+        (sample) =>
+          sample.storage.writes.durationMs,
+      ),
+    ),
+    byKind: aggregateKinds(successful),
+    failures: failureCounts(samples),
+  };
+}
+
+function buildComparisons(summary) {
+  const result = {};
+  for (const profile of Object.keys(
+    BENCHMARK_PROFILES,
+  )) {
+    for (const indexSet of Object.keys(
+      INDEX_REUSE_INDEX_SETS,
+    )) {
+      const candidate =
+        summary[
+          `write-${profile}-${indexSet}-reuse`
+        ];
+      const baseline =
+        summary[
+          `write-${profile}-${indexSet}-duplicate`
+        ];
+      result[`${profile}-${indexSet}`] = {
+        ...compare(candidate, baseline),
+        baselineReads: baseline.meanReads,
+        candidateReads: candidate.meanReads,
+      };
+    }
+  }
+  return result;
+}
+
+function compare(candidate, baseline) {
+  return {
+    p50ChangePercent: change(
+      candidate.clientP50Ms,
+      baseline.clientP50Ms,
+    ),
+    p95ChangePercent: change(
+      candidate.clientP95Ms,
+      baseline.clientP95Ms,
+    ),
+    readCountChangePercent: change(
+      candidate.meanReads,
+      baseline.meanReads,
+    ),
+    readByteChangePercent: change(
+      candidate.meanReadBytes,
+      baseline.meanReadBytes,
+    ),
+  };
+}
+
+function aggregateKinds(samples) {
+  const kinds = new Set(
+    samples.flatMap((sample) =>
+      Object.keys(
+        sample.storage.byKind ?? {},
+      ),
+    ),
+  );
+  return Object.fromEntries(
+    [...kinds].sort().map((kind) => [
+      kind,
+      {
+        meanReadCount: mean(
+          samples.map(
+            (sample) =>
+              sample.storage.byKind?.[kind]
+                ?.reads.count ?? 0,
+          ),
+        ),
+        meanReadBytes: Math.round(
+          mean(
+            samples.map(
+              (sample) =>
+                sample.storage.byKind?.[kind]
+                  ?.reads.bytes ?? 0,
+            ),
+          ),
+        ),
+        meanReadDurationMs: mean(
+          samples.map(
+            (sample) =>
+              sample.storage.byKind?.[kind]
+                ?.reads.durationMs ?? 0,
+          ),
+        ),
+      },
+    ]),
+  );
+}
+
+function failureCounts(samples) {
+  const counts = {};
+  for (const sample of samples) {
+    if (sample.success !== false) {
+      continue;
+    }
+    const key =
+      sample.error ??
+      `HTTP ${sample.status ?? 0}`;
+    counts[key] = (counts[key] ?? 0) + 1;
+  }
+  return counts;
+}
+
+function sorted(values) {
+  return [...values].sort(
+    (left, right) => left - right,
+  );
+}
+
+function percentile(values, quantile) {
+  if (values.length === 0) {
+    return 0;
+  }
+  return values[
+    Math.min(
+      values.length - 1,
+      Math.ceil(values.length * quantile) - 1,
+    )
+  ];
+}
+
+function mean(values) {
+  if (values.length === 0) {
+    return 0;
+  }
+  return Number(
+    (
+      values.reduce(
+        (total, value) => total + value,
+        0,
+      ) / values.length
+    ).toFixed(3),
+  );
+}
+
+function percent(value, total) {
+  return total === 0
+    ? 0
+    : Number(
+        ((value / total) * 100).toFixed(2),
+      );
+}
+
+function change(candidate, baseline) {
+  if (baseline === 0) {
+    return candidate === 0 ? 0 : null;
+  }
+  return Number(
+    (
+      ((candidate - baseline) / baseline) *
+      100
+    ).toFixed(2),
+  );
+}
+
+function unique(values) {
+  return [...new Set(values)].sort();
+}
diff --git a/benchmarks/trie-index-page-reuse/regional/client-runner.ts b/benchmarks/trie-index-page-reuse/regional/client-runner.ts
new file mode 100644
index 0000000..f578e4d
--- /dev/null
+++ b/benchmarks/trie-index-page-reuse/regional/client-runner.ts
@@ -0,0 +1,296 @@
+import {
+  BENCHMARK_PROFILES,
+  BENCHMARK_REGIONS,
+  INDEX_REUSE_INDEX_SETS,
+  INDEX_REUSE_MODES,
+  type IndexReuseIndexSet,
+  type IndexReuseMode,
+  type IndexReuseProfile,
+} from "./scenario.js";
+
+type Config = {
+  sourceCommit: string;
+  harnessCommit: string;
+};
+
+const target = required("TARGET_URL").replace(/\/+$/, "");
+const token = required("BENCHMARK_RESULT_TOKEN");
+const region = required("BENCHMARK_REGION");
+const runId = required("BENCHMARK_RUN_ID");
+const replicate = required("BENCHMARK_REPLICATE");
+const iterations = integerValue(
+  process.env.WRITE_ITERATIONS,
+  4,
+  1,
+  10,
+);
+
+async function main() {
+  const response = await fetch(
+    `${target}/benchmark-config.json`,
+    {
+      cache: "no-store",
+      headers: {
+        "x-benchmark-token": token,
+      },
+    },
+  );
+  if (!response.ok) {
+    throw new Error(
+      `Config failed with ${response.status}`,
+    );
+  }
+  const config = (await response.json()) as Config;
+  const colo =
+    response.headers.get("x-benchmark-colo") ??
+      "unknown";
+  const cases = Object.keys(
+    INDEX_REUSE_INDEX_SETS,
+  ).flatMap((indexSet) =>
+    INDEX_REUSE_MODES.flatMap((mode) =>
+      Object.keys(BENCHMARK_PROFILES).map(
+        (profile) => ({
+          name:
+            `write-${profile}-${indexSet}-${mode}`,
+          profile:
+            profile as IndexReuseProfile,
+          indexSet:
+            indexSet as IndexReuseIndexSet,
+          mode,
+        }),
+      ),
+    ),
+  );
+  const samples = Object.fromEntries(
+    cases.map((value) => [value.name, []]),
+  ) as Record<string, unknown[]>;
+
+  for (
+    let iteration = 0;
+    iteration < iterations;
+    iteration += 1
+  ) {
+    for (const value of rotate(cases, iteration)) {
+      samples[value.name]!.push(
+        await invokeWrite(value, iteration),
+      );
+    }
+  }
+  const verification = [];
+  for (const profile of Object.keys(
+    BENCHMARK_PROFILES,
+  )) {
+    for (const indexSet of Object.keys(
+      INDEX_REUSE_INDEX_SETS,
+    )) {
+      verification.push(
+        await verifyCase(
+          profile as IndexReuseProfile,
+          indexSet as IndexReuseIndexSet,
+        ),
+      );
+    }
+  }
+
+  const result = {
+    generatedAt: new Date().toISOString(),
+    sourceCommit: config.sourceCommit,
+    harnessCommit: config.harnessCommit,
+    runId,
+    replicate,
+    region,
+    colo,
+    runtime: `Node ${process.version}`,
+    iterations,
+    samples,
+    verification,
+  };
+  const resultUrl = new URL(
+    "/regional-result",
+    target,
+  );
+  resultUrl.searchParams.set("run", runId);
+  resultUrl.searchParams.set("region", region);
+  const stored = await fetch(resultUrl, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      "x-benchmark-token": token,
+    },
+    body: JSON.stringify(result),
+  });
+  if (!stored.ok) {
+    throw new Error(
+      `Result upload failed with ${stored.status}`,
+    );
+  }
+  console.log(JSON.stringify({
+    stored: true,
+    region,
+    replicate,
+    colo,
+    operations:
+      cases.length * iterations,
+    verified: verification.every(
+      (value) => value.equivalent,
+    ),
+  }));
+}
+
+async function invokeWrite(
+  value: {
+    profile: IndexReuseProfile;
+    indexSet: IndexReuseIndexSet;
+    mode: IndexReuseMode;
+  },
+  iteration: number,
+) {
+  const url = operationUrl(
+    "/write",
+    value,
+    iteration,
+  );
+  const started = performance.now();
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "x-benchmark-token": token,
+      },
+    });
+    const elapsed = round(
+      performance.now() - started,
+    );
+    const text = await response.text();
+    let body;
+    try {
+      body = JSON.parse(text);
+    } catch {
+      body = {
+        error:
+          `Non-JSON ${response.status}: ` +
+          text.slice(0, 200),
+      };
+    }
+    return {
+      ...body,
+      success: response.ok,
+      status: response.status,
+      clientElapsedMs: elapsed,
+    };
+  } catch (error) {
+    return {
+      ...value,
+      iteration,
+      success: false,
+      status: 0,
+      clientElapsedMs: round(
+        performance.now() - started,
+      ),
+      error:
+        error instanceof Error
+          ? `${error.name}: ${error.message}`
+          : String(error),
+    };
+  }
+}
+
+async function verifyCase(
+  profile: IndexReuseProfile,
+  indexSet: IndexReuseIndexSet,
+) {
+  const url = new URL("/verify", target);
+  url.searchParams.set("region", region);
+  url.searchParams.set("profile", profile);
+  url.searchParams.set("indexes", indexSet);
+  const response = await fetch(url, {
+    headers: {
+      "x-benchmark-token": token,
+    },
+  });
+  const body = await response.json() as {
+    equivalent?: boolean;
+  };
+  return {
+    ...body,
+    success:
+      response.ok &&
+      body.equivalent === true,
+    status: response.status,
+  };
+}
+
+function operationUrl(
+  path: string,
+  value: {
+    profile: IndexReuseProfile;
+    indexSet: IndexReuseIndexSet;
+    mode: IndexReuseMode;
+  },
+  iteration: number,
+) {
+  const url = new URL(path, target);
+  url.searchParams.set("region", region);
+  url.searchParams.set(
+    "profile",
+    value.profile,
+  );
+  url.searchParams.set(
+    "indexes",
+    value.indexSet,
+  );
+  url.searchParams.set("mode", value.mode);
+  url.searchParams.set(
+    "iteration",
+    String(iteration),
+  );
+  return url;
+}
+
+function rotate<T>(
+  values: readonly T[],
+  index: number,
+) {
+  const offset = index % values.length;
+  return [
+    ...values.slice(offset),
+    ...values.slice(0, offset),
+  ];
+}
+
+function required(name: string) {
+  const value = process.env[name];
+  if (!value) {
+    throw new Error(`${name} is required`);
+  }
+  return value;
+}
+
+function integerValue(
+  value: string | undefined,
+  fallback: number,
+  minimum: number,
+  maximum: number,
+) {
+  if (!value) {
+    return fallback;
+  }
+  const parsed = Number(value);
+  if (
+    !Number.isInteger(parsed) ||
+    parsed < minimum ||
+    parsed > maximum
+  ) {
+    throw new Error(
+      `Iterations must be ${minimum}-${maximum}`,
+    );
+  }
+  return parsed;
+}
+
+function round(value: number) {
+  return Number(value.toFixed(3));
+}
+
+void BENCHMARK_REGIONS;
+await main();
diff --git a/benchmarks/trie-index-page-reuse/regional/generate-data.mjs b/benchmarks/trie-index-page-reuse/regional/generate-data.mjs
new file mode 100644
index 0000000..b08d49f
--- /dev/null
+++ b/benchmarks/trie-index-page-reuse/regional/generate-data.mjs
@@ -0,0 +1,172 @@
+import {
+  cp,
+  mkdir,
+  readdir,
+  rm,
+  stat,
+  writeFile,
+} from "node:fs/promises";
+import path from "node:path";
+import { ContentAddressedTrieEngine } from "../../../src/engines/content-trie.ts";
+import { EnvelopeObjectStore } from "../../../src/envelope-store.ts";
+import {
+  bytesToBase64,
+  importAesGcmKey,
+} from "../../../src/envelope.ts";
+import { PrefixObjectStore } from "../../../src/prefix-store.ts";
+import { LocalObjectStore } from "../../../src/stores.ts";
+import { scopeStoragePrefix } from "../../../src/trie-protocol.ts";
+import {
+  BENCHMARK_COLLECTION,
+  BENCHMARK_KEY_ID,
+  BENCHMARK_PROFILES,
+  BENCHMARK_REGIONS,
+  BENCHMARK_SCOPE_ID,
+  INDEX_REUSE_INDEX_SETS,
+  INDEX_REUSE_MODES,
+  benchmarkDocuments,
+} from "./scenario.ts";
+
+const root = path.resolve(
+  process.env.THIMBLE_INDEX_REUSE_OUTPUT ??
+    ".bench-data/trie-index-page-reuse-regional",
+);
+await rm(root, { recursive: true, force: true });
+const baseRoot = path.join(root, "base");
+const objectsRoot = path.join(root, "objects");
+await mkdir(baseRoot, { recursive: true });
+await mkdir(objectsRoot, { recursive: true });
+
+const rawKey = Uint8Array.from(
+  { length: 32 },
+  (_, index) => index + 211,
+);
+const key = await importAesGcmKey(
+  rawKey,
+  ["encrypt", "decrypt"],
+);
+const matrix = {};
+
+for (const [profile, count] of Object.entries(
+  BENCHMARK_PROFILES,
+)) {
+  const documents = benchmarkDocuments(count);
+  matrix[profile] = {};
+  for (const [indexSet, indexes] of Object.entries(
+    INDEX_REUSE_INDEX_SETS,
+  )) {
+    const base = path.join(
+      baseRoot,
+      profile,
+      indexSet,
+    );
+    await mkdir(base, { recursive: true });
+    const raw = new LocalObjectStore(base);
+    const scopePrefix = scopeStoragePrefix(
+      BENCHMARK_SCOPE_ID,
+    );
+    const store = new EnvelopeObjectStore(
+      new PrefixObjectStore(raw, scopePrefix),
+      {
+        key,
+        keyId: BENCHMARK_KEY_ID,
+        compression: "gzip",
+        objectKeyPrefix: scopePrefix,
+      },
+    );
+    await new ContentAddressedTrieEngine(
+      store,
+      40,
+      undefined,
+      false,
+      indexes,
+    ).putMany(
+      BENCHMARK_COLLECTION,
+      documents,
+    );
+    matrix[profile][indexSet] =
+      await inventory(base);
+    for (const region of BENCHMARK_REGIONS) {
+      for (const mode of INDEX_REUSE_MODES) {
+        await cp(
+          base,
+          path.join(
+            objectsRoot,
+            "index-reuse",
+            region,
+            profile,
+            indexSet,
+            mode,
+          ),
+          { recursive: true },
+        );
+      }
+    }
+  }
+}
+
+const manifest = {
+  generatedAt: new Date().toISOString(),
+  sourceCommit:
+    process.env.THIMBLE_BENCHMARK_SOURCE_COMMIT ??
+      null,
+  harnessCommit:
+    process.env.THIMBLE_BENCHMARK_HARNESS_COMMIT ??
+      null,
+  keyBase64: bytesToBase64(rawKey),
+  keyId: BENCHMARK_KEY_ID,
+  scopeId: BENCHMARK_SCOPE_ID,
+  collection: BENCHMARK_COLLECTION,
+  profiles: BENCHMARK_PROFILES,
+  indexSets: Object.fromEntries(
+    Object.entries(
+      INDEX_REUSE_INDEX_SETS,
+    ).map(([name, indexes]) => [
+      name,
+      {
+        count: indexes.notes?.length ?? 0,
+        indexes,
+      },
+    ]),
+  ),
+  modes: INDEX_REUSE_MODES,
+  regions: BENCHMARK_REGIONS,
+  matrix,
+  total: await inventory(objectsRoot),
+};
+await writeFile(
+  path.join(root, "manifest.json"),
+  `${JSON.stringify(manifest, null, 2)}\n`,
+);
+console.log(JSON.stringify(manifest, null, 2));
+
+async function inventory(directory) {
+  const files = await walk(directory);
+  let bytes = 0;
+  for (const file of files) {
+    bytes += (await stat(file)).size;
+  }
+  return {
+    objects: files.length,
+    bytes,
+  };
+}
+
+async function walk(directory) {
+  const entries = await readdir(directory, {
+    withFileTypes: true,
+  });
+  const files = [];
+  for (const entry of entries) {
+    const entryPath = path.join(
+      directory,
+      entry.name,
+    );
+    if (entry.isDirectory()) {
+      files.push(...(await walk(entryPath)));
+    } else {
+      files.push(entryPath);
+    }
+  }
+  return files;
+}
diff --git a/benchmarks/trie-index-page-reuse/regional/scenario.ts b/benchmarks/trie-index-page-reuse/regional/scenario.ts
new file mode 100644
index 0000000..634ec47
--- /dev/null
+++ b/benchmarks/trie-index-page-reuse/regional/scenario.ts
@@ -0,0 +1,36 @@
+import {
+  BENCHMARK_COLLECTION,
+  BENCHMARK_KEY_ID,
+  BENCHMARK_PROFILES,
+  BENCHMARK_REGIONS,
+  BENCHMARK_SCOPE_ID,
+  WRITE_SCALING_INDEX_SETS,
+  benchmarkDocument,
+  benchmarkDocuments,
+} from "../../write-scaling/regional/scenario.js";
+
+export {
+  BENCHMARK_COLLECTION,
+  BENCHMARK_KEY_ID,
+  BENCHMARK_PROFILES,
+  BENCHMARK_REGIONS,
+  BENCHMARK_SCOPE_ID,
+  benchmarkDocument,
+  benchmarkDocuments,
+};
+
+export const INDEX_REUSE_MODES = [
+  "duplicate",
+  "reuse",
+] as const;
+export type IndexReuseMode =
+  (typeof INDEX_REUSE_MODES)[number];
+export type IndexReuseProfile =
+  keyof typeof BENCHMARK_PROFILES;
+export type IndexReuseIndexSet =
+  | "one"
+  | "two";
+export const INDEX_REUSE_INDEX_SETS = {
+  one: WRITE_SCALING_INDEX_SETS.one,
+  two: WRITE_SCALING_INDEX_SETS.two,
+} as const;
diff --git a/benchmarks/trie-index-page-reuse/regional/tsconfig.json b/benchmarks/trie-index-page-reuse/regional/tsconfig.json
new file mode 100644
index 0000000..29fa23d
--- /dev/null
+++ b/benchmarks/trie-index-page-reuse/regional/tsconfig.json
@@ -0,0 +1,12 @@
+{
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": {
+    "noEmit": true
+  },
+  "include": [
+    "./client-runner.ts",
+    "./scenario.ts",
+    "./vite.config.ts",
+    "./worker.ts"
+  ]
+}
diff --git a/benchmarks/trie-index-page-reuse/regional/upload.mjs b/benchmarks/trie-index-page-reuse/regional/upload.mjs
new file mode 100644
index 0000000..146f4ee
--- /dev/null
+++ b/benchmarks/trie-index-page-reuse/regional/upload.mjs
@@ -0,0 +1,106 @@
+import {
+  readFile,
+  readdir,
+} from "node:fs/promises";
+import path from "node:path";
+
+const root = path.resolve(
+  process.env.THIMBLE_INDEX_REUSE_OUTPUT ??
+    ".bench-data/trie-index-page-reuse-regional",
+);
+const target = required("THIMBLE_BENCHMARK_TARGET")
+  .replace(/\/+$/, "");
+const token = required("THIMBLE_BENCHMARK_TOKEN");
+const objectsRoot = path.join(root, "objects");
+const files = await walk(objectsRoot);
+let completed = 0;
+
+for (let offset = 0; offset < files.length; offset += 12) {
+  await Promise.all(
+    files.slice(offset, offset + 12).map(upload),
+  );
+}
+console.log(JSON.stringify({ objects: files.length }));
+
+async function upload(file) {
+  const relative = path
+    .relative(objectsRoot, file)
+    .split(path.sep)
+    .join("/");
+  const url = [
+    target,
+    "fixture",
+    ...relative
+      .split("/")
+      .map(encodeURIComponent),
+  ].join("/");
+  const bytes = await readFile(file);
+  for (let attempt = 1; attempt <= 8; attempt += 1) {
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "content-type":
+            "application/octet-stream",
+          "x-benchmark-token": token,
+        },
+        body: bytes,
+      });
+      if (!response.ok) {
+        throw new Error(
+          `${response.status}: ${await response.text()}`,
+        );
+      }
+      completed += 1;
+      if (
+        completed === files.length ||
+        completed % 1_000 === 0
+      ) {
+        console.log(
+          `Uploaded ${completed}/${files.length}`,
+        );
+      }
+      return;
+    } catch (error) {
+      if (attempt === 8) {
+        throw error;
+      }
+      await delay(
+        500 * 2 ** Math.min(attempt - 1, 4),
+      );
+    }
+  }
+}
+
+async function walk(directory) {
+  const entries = await readdir(directory, {
+    withFileTypes: true,
+  });
+  const files = [];
+  for (const entry of entries) {
+    const entryPath = path.join(
+      directory,
+      entry.name,
+    );
+    if (entry.isDirectory()) {
+      files.push(...(await walk(entryPath)));
+    } else {
+      files.push(entryPath);
+    }
+  }
+  return files;
+}
+
+function required(name) {
+  const value = process.env[name];
+  if (!value) {
+    throw new Error(`${name} is required`);
+  }
+  return value;
+}
+
+function delay(milliseconds) {
+  return new Promise((resolve) =>
+    setTimeout(resolve, milliseconds),
+  );
+}
diff --git a/benchmarks/trie-index-page-reuse/regional/vite.config.ts b/benchmarks/trie-index-page-reuse/regional/vite.config.ts
new file mode 100644
index 0000000..a5d0561
--- /dev/null
+++ b/benchmarks/trie-index-page-reuse/regional/vite.config.ts
@@ -0,0 +1,25 @@
+import { fileURLToPath } from "node:url";
+import { defineConfig } from "vite";
+
+export default defineConfig({
+  publicDir: false,
+  build: {
+    target: "node22",
+    ssr: fileURLToPath(
+      new URL("./client-runner.ts", import.meta.url),
+    ),
+    outDir: fileURLToPath(
+      new URL(
+        "../../../.bench-data/trie-index-page-reuse-regional/assets",
+        import.meta.url,
+      ),
+    ),
+    emptyOutDir: true,
+    minify: false,
+    rollupOptions: {
+      output: {
+        entryFileNames: "runner.mjs",
+      },
+    },
+  },
+});
diff --git a/benchmarks/trie-index-page-reuse/regional/worker.ts b/benchmarks/trie-index-page-reuse/regional/worker.ts
new file mode 100644
index 0000000..233fa50
--- /dev/null
+++ b/benchmarks/trie-index-page-reuse/regional/worker.ts
@@ -0,0 +1,776 @@
+import type {
+  JsonDocument,
+  JsonValue,
+  ObjectStore,
+  PutConditions,
+  StoredObject,
+} from "../../../src/core.js";
+import { ContentAddressedTrieEngine } from "../../../src/engines/content-trie.js";
+import { EnvelopeObjectStore } from "../../../src/envelope-store.js";
+import {
+  base64ToBytes,
+  importAesGcmKey,
+} from "../../../src/envelope.js";
+import { PrefixObjectStore } from "../../../src/prefix-store.js";
+import {
+  decodeJson,
+  stableStringify,
+} from "../../../src/shared-utils.js";
+import {
+  R2ObjectStore,
+  type R2BucketBinding,
+} from "../../../src/cloudflare/r2-object-store.js";
+import {
+  scopeStoragePrefix,
+  trieHeadKey,
+} from "../../../src/trie-protocol.js";
+import { DuplicateIndexReadStore } from "../control.js";
+import {
+  BENCHMARK_COLLECTION,
+  BENCHMARK_KEY_ID,
+  BENCHMARK_PROFILES,
+  BENCHMARK_REGIONS,
+  BENCHMARK_SCOPE_ID,
+  INDEX_REUSE_INDEX_SETS,
+  INDEX_REUSE_MODES,
+  benchmarkDocument,
+  type IndexReuseIndexSet,
+  type IndexReuseMode,
+  type IndexReuseProfile,
+} from "./scenario.js";
+
+type BenchmarkBucket = R2BucketBinding & {
+  get(
+    key: string,
+  ): Promise<
+    | {
+        etag: string;
+        arrayBuffer(): Promise<ArrayBuffer>;
+      }
+    | null
+  >;
+};
+
+type Env = {
+  BENCHMARK_BUCKET: BenchmarkBucket;
+  ASSETS?: {
+    fetch(request: Request): Promise<Response>;
+  };
+  BENCHMARK_KEY_BASE64: string;
+  BENCHMARK_RESULT_TOKEN: string;
+  BENCHMARK_SOURCE_COMMIT: string;
+  BENCHMARK_HARNESS_COMMIT: string;
+};
+
+type OperationMetric = {
+  count: number;
+  bytes: number;
+  durationMs: number;
+};
+
+type StoreMetrics = {
+  reads: OperationMetric;
+  writes: OperationMetric;
+  preconditionFailures: number;
+  byKind: Record<
+    string,
+    {
+      reads: OperationMetric;
+      writes: OperationMetric;
+    }
+  >;
+};
+
+let keyPromise: Promise<CryptoKey> | undefined;
+
+export default {
+  async fetch(
+    request: Request,
+    env: Env,
+  ): Promise<Response> {
+    try {
+      const url = new URL(request.url);
+      if (url.pathname === "/health") {
+        return withColo(
+          json({
+            sourceCommit: env.BENCHMARK_SOURCE_COMMIT,
+            harnessCommit: env.BENCHMARK_HARNESS_COMMIT,
+          }),
+          request,
+        );
+      }
+      if (url.pathname === "/benchmark-config.json") {
+        requireToken(request, env);
+        return withColo(
+          json({
+            sourceCommit: env.BENCHMARK_SOURCE_COMMIT,
+            harnessCommit: env.BENCHMARK_HARNESS_COMMIT,
+            profiles: BENCHMARK_PROFILES,
+            indexSets: Object.fromEntries(
+              Object.entries(
+                INDEX_REUSE_INDEX_SETS,
+              ).map(([name, indexes]) => [
+                name,
+                indexes.notes?.length ?? 0,
+              ]),
+            ),
+            modes: INDEX_REUSE_MODES,
+            regions: BENCHMARK_REGIONS,
+          }),
+          request,
+        );
+      }
+      if (url.pathname === "/write") {
+        requirePost(request);
+        requireToken(request, env);
+        return withColo(
+          json(await runWrite(env, url)),
+          request,
+        );
+      }
+      if (url.pathname === "/verify") {
+        requireToken(request, env);
+        return withColo(
+          json(await verifyEquivalent(env, url)),
+          request,
+        );
+      }
+      if (url.pathname.startsWith("/fixture/")) {
+        requirePost(request);
+        requireToken(request, env);
+        return uploadFixture(request, env, url);
+      }
+      if (url.pathname === "/regional-result") {
+        return regionalResult(request, env, url);
+      }
+      if (url.pathname === "/cleanup") {
+        requirePost(request);
+        requireToken(request, env);
+        return json(await cleanupBucket(env));
+      }
+      if (env.ASSETS) {
+        return env.ASSETS.fetch(request);
+      }
+      return json({ error: "Not found" }, 404);
+    } catch (error) {
+      if (error instanceof BenchmarkRequestError) {
+        return json(
+          { error: error.message },
+          error.status,
+        );
+      }
+      console.error(error);
+      return json(
+        {
+          error:
+            error instanceof Error
+              ? error.message
+              : String(error),
+        },
+        500,
+      );
+    }
+  },
+};
+
+async function runWrite(
+  env: Env,
+  url: URL,
+) {
+  const parameters = writeParameters(url);
+  const mode = requireMode(
+    url.searchParams.get("mode"),
+  );
+  const runtime = await createRuntime(
+    env,
+    prefixFor(parameters, mode),
+    parameters.indexSet,
+    mode,
+  );
+  const started = performance.now();
+  await runtime.engine.put(
+    BENCHMARK_COLLECTION,
+    parameters.document.id,
+    parameters.document,
+  );
+  return {
+    ...parameters.public,
+    mode,
+    workerIoTimerMs: round(
+      performance.now() - started,
+    ),
+    storage: runtime.counting.publicMetrics(),
+    diagnostics: runtime.engine.diagnostics(),
+  };
+}
+
+async function verifyEquivalent(
+  env: Env,
+  url: URL,
+) {
+  const region = requireRegion(
+    url.searchParams.get("region"),
+  );
+  const profile = requireProfile(
+    url.searchParams.get("profile"),
+  );
+  const indexSet = requireIndexSet(
+    url.searchParams.get("indexes"),
+  );
+  const common = { region, profile, indexSet };
+  const duplicate = await createRuntime(
+    env,
+    prefixFor(common, "duplicate"),
+    indexSet,
+    "duplicate",
+  );
+  const reuse = await createRuntime(
+    env,
+    prefixFor(common, "reuse"),
+    indexSet,
+    "reuse",
+  );
+  const [duplicateDocuments, reuseDocuments] =
+    await Promise.all([
+      duplicate.engine.exportStored(
+        BENCHMARK_COLLECTION,
+      ),
+      reuse.engine.exportStored(
+        BENCHMARK_COLLECTION,
+      ),
+    ]);
+  const [duplicateHead, reuseHead] =
+    await Promise.all([
+      duplicate.store.get(
+        trieHeadKey(BENCHMARK_COLLECTION),
+      ),
+      reuse.store.get(
+        trieHeadKey(BENCHMARK_COLLECTION),
+      ),
+    ]);
+  const documentsEqual =
+    stableStringify(
+      duplicateDocuments as unknown as JsonValue,
+    ) ===
+    stableStringify(
+      reuseDocuments as unknown as JsonValue,
+    );
+  const headsEqual =
+    stableStringify(
+      duplicateHead
+        ? decodeJson<JsonValue>(
+            duplicateHead.bytes,
+          )
+        : null,
+    ) ===
+    stableStringify(
+      reuseHead
+        ? decodeJson<JsonValue>(
+            reuseHead.bytes,
+          )
+        : null,
+    );
+  return {
+    region,
+    profile,
+    indexSet,
+    documentsEqual,
+    headsEqual,
+    equivalent: documentsEqual && headsEqual,
+  };
+}
+
+function writeParameters(url: URL) {
+  const region = requireRegion(
+    url.searchParams.get("region"),
+  );
+  const profile = requireProfile(
+    url.searchParams.get("profile"),
+  );
+  const indexSet = requireIndexSet(
+    url.searchParams.get("indexes"),
+  );
+  const iteration = Number(
+    url.searchParams.get("iteration"),
+  );
+  if (
+    !Number.isInteger(iteration) ||
+    iteration < 0 ||
+    iteration > 100
+  ) {
+    throw new BenchmarkRequestError(
+      400,
+      "Iteration is invalid",
+    );
+  }
+  const count = BENCHMARK_PROFILES[profile];
+  const index =
+    (iteration * 977 +
+      BENCHMARK_REGIONS.indexOf(region) * 37) %
+    count;
+  const original = benchmarkDocument(index, count);
+  const document: JsonDocument = {
+    ...original,
+    body:
+      `${original.body} index-reuse ${profile} ` +
+      `${indexSet} ${iteration}`,
+    lastModified: count + iteration,
+  };
+  return {
+    region,
+    profile,
+    indexSet,
+    document,
+    public: {
+      region,
+      profile,
+      indexSet,
+      indexCount:
+        INDEX_REUSE_INDEX_SETS[indexSet]
+          .notes?.length ?? 0,
+      iteration,
+      id: document.id,
+    },
+  };
+}
+
+function prefixFor(
+  parameters: {
+    region: string;
+    profile: string;
+    indexSet: string;
+  },
+  mode: IndexReuseMode,
+) {
+  return [
+    "index-reuse",
+    parameters.region,
+    parameters.profile,
+    parameters.indexSet,
+    mode,
+  ].join("/");
+}
+
+async function createRuntime(
+  env: Env,
+  prefix: string,
+  indexSet: IndexReuseIndexSet,
+  mode: IndexReuseMode,
+) {
+  const counting = new TimingObjectStore(
+    new R2ObjectStore(env.BENCHMARK_BUCKET),
+  );
+  const scopePrefix = scopeStoragePrefix(
+    BENCHMARK_SCOPE_ID,
+  );
+  const store = new EnvelopeObjectStore(
+    new PrefixObjectStore(
+      new PrefixObjectStore(counting, prefix),
+      scopePrefix,
+    ),
+    {
+      key: await benchmarkKey(env),
+      keyId: BENCHMARK_KEY_ID,
+      compression: "gzip",
+      objectKeyPrefix: scopePrefix,
+    },
+  );
+  const engineStore =
+    mode === "duplicate"
+      ? new DuplicateIndexReadStore(store)
+      : store;
+  return {
+    store,
+    counting,
+    engine: new ContentAddressedTrieEngine(
+      engineStore,
+      40,
+      undefined,
+      false,
+      INDEX_REUSE_INDEX_SETS[indexSet],
+    ),
+  };
+}
+
+async function uploadFixture(
+  request: Request,
+  env: Env,
+  url: URL,
+) {
+  const key = decodeObjectPath(
+    url.pathname.slice("/fixture/".length),
+  );
+  if (
+    !key.startsWith("index-reuse/") ||
+    key.includes("..")
+  ) {
+    throw new BenchmarkRequestError(
+      400,
+      "Fixture path is invalid",
+    );
+  }
+  const body = await request.arrayBuffer();
+  if (body.byteLength > 20 * 1024 * 1024) {
+    throw new BenchmarkRequestError(
+      413,
+      "Fixture is too large",
+    );
+  }
+  await env.BENCHMARK_BUCKET.put(
+    key,
+    new Uint8Array(body),
+  );
+  return json({ stored: key }, 201);
+}
+
+async function regionalResult(
+  request: Request,
+  env: Env,
+  url: URL,
+) {
+  requireToken(request, env);
+  const run = safeName(url.searchParams.get("run"));
+  const region = safeName(
+    url.searchParams.get("region"),
+  );
+  if (!run || !region) {
+    throw new BenchmarkRequestError(
+      400,
+      "Result path is invalid",
+    );
+  }
+  const key = `results/${run}/${region}.json`;
+  if (request.method === "POST") {
+    const body = await request.text();
+    if (
+      new TextEncoder().encode(body).byteLength >
+      5 * 1024 * 1024
+    ) {
+      throw new BenchmarkRequestError(
+        413,
+        "Result is too large",
+      );
+    }
+    JSON.parse(body);
+    await env.BENCHMARK_BUCKET.put(
+      key,
+      new TextEncoder().encode(body),
+    );
+    return json({ stored: key }, 201);
+  }
+  if (request.method === "GET") {
+    const object = await env.BENCHMARK_BUCKET.get(key);
+    if (!object) {
+      return json(
+        { error: "Result not found" },
+        404,
+      );
+    }
+    return new Response(
+      await object.arrayBuffer(),
+      {
+        headers: {
+          "cache-control": "no-store",
+          "content-type":
+            "application/json; charset=utf-8",
+        },
+      },
+    );
+  }
+  throw new BenchmarkRequestError(
+    405,
+    "Method not allowed",
+  );
+}
+
+async function cleanupBucket(env: Env) {
+  const page = await env.BENCHMARK_BUCKET.list({
+    limit: 1_000,
+  });
+  const keys = page.objects.map(
+    (object) => object.key,
+  );
+  if (keys.length > 0) {
+    await env.BENCHMARK_BUCKET.delete(keys);
+  }
+  return {
+    deleted: keys.length,
+    truncated: page.truncated,
+  };
+}
+
+function benchmarkKey(env: Env) {
+  keyPromise ??= importAesGcmKey(
+    base64ToBytes(env.BENCHMARK_KEY_BASE64),
+    ["encrypt", "decrypt"],
+  );
+  return keyPromise;
+}
+
+class TimingObjectStore implements ObjectStore {
+  private readonly metrics: StoreMetrics = {
+    reads: metric(),
+    writes: metric(),
+    preconditionFailures: 0,
+    byKind: {},
+  };
+
+  constructor(private readonly delegate: ObjectStore) {}
+
+  async get(key: string): Promise<StoredObject | null> {
+    const started = performance.now();
+    const result = await this.delegate.get(key);
+    record(
+      this.metrics,
+      "reads",
+      key,
+      result?.bytes.byteLength ?? 0,
+      performance.now() - started,
+    );
+    return result;
+  }
+
+  async put(
+    key: string,
+    bytes: Uint8Array,
+    conditions?: PutConditions,
+  ) {
+    const started = performance.now();
+    try {
+      const result = await this.delegate.put(
+        key,
+        bytes,
+        conditions,
+      );
+      record(
+        this.metrics,
+        "writes",
+        key,
+        bytes.byteLength,
+        performance.now() - started,
+      );
+      return result;
+    } catch (error) {
+      if (
+        error instanceof Error &&
+        error.name ===
+          "PreconditionFailedError"
+      ) {
+        this.metrics.preconditionFailures += 1;
+      }
+      throw error;
+    }
+  }
+
+  delete(key: string) {
+    return this.delegate.delete(key);
+  }
+
+  list(prefix: string) {
+    return this.delegate.list(prefix);
+  }
+
+  publicMetrics() {
+    return structuredClone(this.metrics);
+  }
+}
+
+function record(
+  metrics: StoreMetrics,
+  operation: "reads" | "writes",
+  key: string,
+  bytes: number,
+  durationMs: number,
+) {
+  addMetric(
+    metrics[operation],
+    bytes,
+    durationMs,
+  );
+  const kind = objectKind(key);
+  metrics.byKind[kind] ??= {
+    reads: metric(),
+    writes: metric(),
+  };
+  addMetric(
+    metrics.byKind[kind]![operation],
+    bytes,
+    durationMs,
+  );
+}
+
+function addMetric(
+  value: OperationMetric,
+  bytes: number,
+  durationMs: number,
+) {
+  value.count += 1;
+  value.bytes += bytes;
+  value.durationMs = round(
+    value.durationMs + durationMs,
+  );
+}
+
+function metric(): OperationMetric {
+  return {
+    count: 0,
+    bytes: 0,
+    durationMs: 0,
+  };
+}
+
+function objectKind(key: string) {
+  if (key.endsWith("/HEAD.json")) {
+    return "head";
+  }
+  if (key.includes("/indexes/")) {
+    return "index";
+  }
+  if (key.includes("/nodes/")) {
+    return "node";
+  }
+  return "other";
+}
+
+function requirePost(request: Request) {
+  if (request.method !== "POST") {
+    throw new BenchmarkRequestError(
+      405,
+      "POST required",
+    );
+  }
+}
+
+function requireToken(request: Request, env: Env) {
+  if (
+    request.headers.get("x-benchmark-token") !==
+    env.BENCHMARK_RESULT_TOKEN
+  ) {
+    throw new BenchmarkRequestError(
+      401,
+      "Benchmark token is invalid",
+    );
+  }
+}
+
+function requireRegion(
+  value: string | null,
+): (typeof BENCHMARK_REGIONS)[number] {
+  if (
+    !value ||
+    !BENCHMARK_REGIONS.includes(
+      value as (typeof BENCHMARK_REGIONS)[number],
+    )
+  ) {
+    throw new BenchmarkRequestError(
+      400,
+      "Region is invalid",
+    );
+  }
+  return value as (typeof BENCHMARK_REGIONS)[number];
+}
+
+function requireProfile(
+  value: string | null,
+): IndexReuseProfile {
+  if (
+    !value ||
+    !(value in BENCHMARK_PROFILES)
+  ) {
+    throw new BenchmarkRequestError(
+      400,
+      "Profile is invalid",
+    );
+  }
+  return value as IndexReuseProfile;
+}
+
+function requireIndexSet(
+  value: string | null,
+): IndexReuseIndexSet {
+  if (
+    value !== "one" &&
+    value !== "two"
+  ) {
+    throw new BenchmarkRequestError(
+      400,
+      "Index set is invalid",
+    );
+  }
+  return value;
+}
+
+function requireMode(
+  value: string | null,
+): IndexReuseMode {
+  if (
+    !value ||
+    !INDEX_REUSE_MODES.includes(
+      value as IndexReuseMode,
+    )
+  ) {
+    throw new BenchmarkRequestError(
+      400,
+      "Mode is invalid",
+    );
+  }
+  return value as IndexReuseMode;
+}
+
+function decodeObjectPath(value: string) {
+  return value
+    .split("/")
+    .map((segment) => decodeURIComponent(segment))
+    .join("/");
+}
+
+function safeName(value: string | null) {
+  return value &&
+    /^[A-Za-z0-9_-]{1,96}$/.test(value)
+    ? value
+    : null;
+}
+
+function json(
+  value: unknown,
+  status = 200,
+) {
+  return Response.json(value, {
+    status,
+    headers: {
+      "cache-control": "no-store",
+    },
+  });
+}
+
+function withColo(
+  response: Response,
+  request: Request,
+) {
+  const colo =
+    (
+      request as Request & {
+        cf?: { colo?: string };
+      }
+    ).cf?.colo ?? "unknown";
+  const headers = new Headers(response.headers);
+  headers.set("x-benchmark-colo", colo);
+  return new Response(response.body, {
+    status: response.status,
+    headers,
+  });
+}
+
+function round(value: number) {
+  return Number(value.toFixed(3));
+}
+
+class BenchmarkRequestError extends Error {
+  constructor(
+    readonly status: number,
+    message: string,
+  ) {
+    super(message);
+    this.name = "BenchmarkRequestError";
+  }
+}
diff --git a/package.json b/package.json
index c37b04e..4d81c9e 100644
--- a/package.json
+++ b/package.json
@@ -117,6 +117,10 @@
     "benchmark:current-regional:publish": "tsx benchmarks/current-regional/publish.mjs",
     "benchmark:write-scaling": "tsx benchmarks/write-scaling/local.mjs",
     "benchmark:trie-index-reuse": "tsx benchmarks/trie-index-page-reuse/local.mjs",
+    "benchmark:trie-index-reuse:regional:generate": "tsx benchmarks/trie-index-page-reuse/regional/generate-data.mjs",
+    "benchmark:trie-index-reuse:regional:build": "tsc -p benchmarks/trie-index-page-reuse/regional/tsconfig.json --noEmit && vite build --config benchmarks/trie-index-page-reuse/regional/vite.config.ts",
+    "benchmark:trie-index-reuse:regional:upload": "tsx benchmarks/trie-index-page-reuse/regional/upload.mjs",
+    "benchmark:trie-index-reuse:regional:aggregate": "tsx benchmarks/trie-index-page-reuse/regional/aggregate.mjs",
     "benchmark:write-scaling:regional:generate": "tsx benchmarks/write-scaling/regional/generate-data.mjs",
     "benchmark:write-scaling:regional:build": "tsc -p benchmarks/write-scaling/regional/tsconfig.json --noEmit && vite build --config benchmarks/write-scaling/regional/vite.config.ts",
     "benchmark:write-scaling:regional:upload": "tsx benchmarks/write-scaling/regional/upload.mjs",

From 8cf4641d8425684409bb05cd452b1bbc52c36d76 Mon Sep 17 00:00:00 2001
From: Jason Doyle <46789294+Jason-Doyle@users.noreply.github.com>
Date: Tue, 29 Sep 2026 20:39:09 -0700
Subject: [PATCH 3/4] Publish Trie index reuse evidence

Retain paired local and regional measurements, document the missed latency gate and deterministic read reduction, and expose the raw artifacts and graph.
---
 CHANGELOG.md                                  |     3 +
 README.md                                     |     3 +
 benchmarks/trie-index-page-reuse/README.md    |    13 +
 benchmarks/trie-index-page-reuse/RESULTS.md   |   197 +
 benchmarks/trie-index-page-reuse/publish.mjs  |   222 +
 .../trie-index-page-reuse-p50.svg             |    46 +
 docs/BENCHMARKS.md                            |    26 +
 evidence/README.md                            |     8 +
 ...rie-index-page-reuse-local-2026-09-30.json |  1669 +
 ...page-reuse-regional-worker-2026-09-30.json | 53211 ++++++++++++++++
 ...ie-index-page-reuse-summary-2026-09-30.csv |     7 +
 package.json                                  |     1 +
 .../benchmarks/trie-index-page-reuse-p50.svg  |    46 +
 site/scripts/prepare-assets.mjs               |     3 +
 14 files changed, 55455 insertions(+)
 create mode 100644 benchmarks/trie-index-page-reuse/RESULTS.md
 create mode 100644 benchmarks/trie-index-page-reuse/publish.mjs
 create mode 100644 benchmarks/trie-index-page-reuse/trie-index-page-reuse-p50.svg
 create mode 100644 evidence/trie-index-page-reuse-local-2026-09-30.json
 create mode 100644 evidence/trie-index-page-reuse-regional-worker-2026-09-30.json
 create mode 100644 evidence/trie-index-page-reuse-summary-2026-09-30.csv
 create mode 100644 site/public/benchmarks/trie-index-page-reuse-p50.svg

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7443534..96137b0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,9 @@ The format follows Keep a Changelog and the package uses semantic versioning.
 
 ## Unreleased
 
+- Reused Trie secondary-index pages already loaded during configuration
+  validation, removing one object-store read per configured index without
+  changing stored protocol objects.
 - Corrected GHCR visibility guidance after the first image and chart packages
   inherited public access without a manual settings change.
 
diff --git a/README.md b/README.md
index 81d9cdd..f682264 100644
--- a/README.md
+++ b/README.md
@@ -372,6 +372,9 @@ The measurements show:
 - post-merge two-index p50 amplification fell by 48-72 percent relative to
   each run's no-index floor, while current absolute writes still remained
   multi-second
+- paired Trie index-page reuse removed one read per configured index, reduced
+  indexed read bytes by 35-50 percent, and improved regional p50 by 4-13
+  percent without changing stored protocol objects
 - the post-merge write run retained three R2 internal failures and recorded
   zero CAS retries
 - cold reads and large indexed writes remain too slow for latency-sensitive
diff --git a/benchmarks/trie-index-page-reuse/README.md b/benchmarks/trie-index-page-reuse/README.md
index 24dcd24..8502a15 100644
--- a/benchmarks/trie-index-page-reuse/README.md
+++ b/benchmarks/trie-index-page-reuse/README.md
@@ -28,3 +28,16 @@ Acceptance requires:
 - no indexed p50 regression above 5 percent
 
 Regional evidence is required before merging the production change.
+
+## Result
+
+The completed paired local and regional result is documented in
+[RESULTS.md](RESULTS.md).
+
+The candidate removed one read per index and reduced indexed read bytes by
+35-50 percent. All six regional p50 values improved by 4-13 percent, although
+the predeclared 10-percent medium/large threshold did not pass in every case.
+
+The production candidate is recommended for `main` because the redundant work
+is removed deterministically, protocol output is unchanged, and no material
+regression was observed.
diff --git a/benchmarks/trie-index-page-reuse/RESULTS.md b/benchmarks/trie-index-page-reuse/RESULTS.md
new file mode 100644
index 0000000..1962886
--- /dev/null
+++ b/benchmarks/trie-index-page-reuse/RESULTS.md
@@ -0,0 +1,197 @@
+# Trie index-page reuse benchmark
+
+Date: 29 September 2026
+
+Branch: `perf/reuse-trie-index-pages`
+
+Production candidate:
+
+```text
+bd8af6eec98b8f4a745d90327e96534c4a09fac0
+```
+
+Regional harness:
+
+```text
+a1a1d02d9ce71318956e5a5cb9574eed43314c04
+```
+
+## Decision
+
+Promote the production candidate to `main`.
+
+The candidate reuses each secondary-index page already loaded during
+fail-closed configuration validation instead of reading it again during
+update preparation.
+
+The regional matrix did not meet the predeclared 10-percent p50 target in
+every medium and large case. Pooled p50 improved by 4.24 to 13.10 percent,
+with the largest two-index case improving by 9.69 percent. The narrower
+latency gate therefore failed.
+
+The change is still worth promoting because:
+
+- every one-index write removes one remote read
+- every two-index write removes two remote reads
+- indexed read bytes fall by 35.22 to 49.84 percent
+- all six regional p50 values improved
+- five of six regional p95 values improved; the remaining p95 changed by
+  +0.71 percent
+- all 672 writes succeeded
+- all 84 post-run protocol comparisons passed
+- local decoded keys and bytes were identical
+- the worst local p50 change was +1.91 percent, inside the 5-percent CPU
+  rejection limit
+- there is no API, request, trust, storage-format, or migration change
+
+This is a deterministic removal of redundant work with a modest but consistent
+regional latency benefit.
+
+## Implementation
+
+`requireIndexConfiguration()` now returns the decoded active index pages after
+checking:
+
+- the configured and active index counts match
+- every active index remains configured
+- every referenced index object exists
+- every stored index definition matches the supplied definition
+
+`prepareIndexes()` consumes those exact validated pages. It does not fetch the
+same objects again.
+
+Validation still finishes before candidate immutable objects are written.
+Missing, partial, or mismatched index configuration still fails closed.
+
+## Method
+
+The paired regional matrix covered:
+
+- the production Trie engine
+- 128, 5,000, and 25,000 documents
+- one and two covering secondary indexes
+- four iterations per case and region
+- seven Azure caller regions
+- two pristine R2 bucket replicates
+- 672 measured writes
+
+The control used the same candidate engine and wrapped the object store to
+duplicate each index-page `get`. This reproduced the old operation count in
+the same Worker deployment and time window without maintaining a second
+engine implementation.
+
+Every region, profile, index set, and mode used an isolated prefix.
+Authentication and browser rendering were excluded.
+
+The local matrix ran eight updates per case and compared decoded object keys
+and bytes after every control/candidate pair.
+
+All temporary Workers, R2 buckets, Azure container groups, and the resource
+group were deleted.
+
+## Regional latency
+
+![Trie index-page reuse p50](trie-index-page-reuse-p50.svg)
+
+| Documents | Indexes | Duplicate-read p50 | Reuse p50 | p50 change | Duplicate-read p95 | Reuse p95 | p95 change |
+| ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
+| 128 | 1 | 5,370.46 ms | 4,666.81 ms | -13.10% | 8,739.04 ms | 8,670.09 ms | -0.79% |
+| 128 | 2 | 5,765.41 ms | 5,309.08 ms | -7.91% | 9,581.24 ms | 8,998.60 ms | -6.08% |
+| 5,000 | 1 | 5,250.03 ms | 5,002.49 ms | -4.72% | 8,497.84 ms | 8,558.28 ms | +0.71% |
+| 5,000 | 2 | 5,875.73 ms | 5,503.14 ms | -6.34% | 9,702.23 ms | 8,980.71 ms | -7.44% |
+| 25,000 | 1 | 5,418.36 ms | 5,188.63 ms | -4.24% | 9,505.72 ms | 8,956.49 ms | -5.78% |
+| 25,000 | 2 | 6,825.80 ms | 6,164.57 ms | -9.69% | 11,467.73 ms | 10,657.09 ms | -7.07% |
+
+## Remote-read reduction
+
+| Indexes | Previous reads | Candidate reads | Read-count change |
+| ---: | ---: | ---: | ---: |
+| 1 | 6 | 5 | -16.67% |
+| 2 | 8 | 6 | -25.00% |
+
+Read-byte reduction increased with collection size because index pages grew
+while the unchanged HEAD and Trie-path reads remained small.
+
+| Documents | Indexes | Read-byte change |
+| ---: | ---: | ---: |
+| 128 | 1 | -35.22% |
+| 128 | 2 | -41.57% |
+| 5,000 | 1 | -49.00% |
+| 5,000 | 2 | -49.53% |
+| 25,000 | 1 | -49.65% |
+| 25,000 | 2 | -49.84% |
+
+## Reliability and equivalence
+
+| Result | Count |
+| --- | ---: |
+| Successful writes | 672 |
+| Failed writes | 0 |
+| CAS retries | 0 |
+| Precondition failures | 0 |
+| Post-run protocol comparisons | 84 |
+| Failed protocol comparisons | 0 |
+
+Local protocol-equivalence tests also compare every stored key and decoded
+byte. Partial index configurations fail before any candidate write.
+
+## Local result
+
+The local result isolated decoding, validation, index update, encryption, and
+compression cost without network latency.
+
+| Case | Duplicate-read p50 | Reuse p50 | p50 change | Read-byte change |
+| --- | ---: | ---: | ---: | ---: |
+| Small, 1 index | 2.99 ms | 2.21 ms | -26.22% | -34.97% |
+| Small, 2 indexes | 3.52 ms | 2.88 ms | -18.12% | -41.40% |
+| Medium, 1 index | 26.07 ms | 23.42 ms | -10.16% | -48.99% |
+| Medium, 2 indexes | 56.84 ms | 52.83 ms | -7.06% | -49.53% |
+| Large, 1 index | 139.26 ms | 129.26 ms | -7.18% | -49.65% |
+| Large, 2 indexes | 308.51 ms | 314.39 ms | +1.91% | -49.84% |
+
+## Acceptance result
+
+| Gate | Result |
+| --- | --- |
+| Every write succeeds | Pass |
+| Final active protocol state is equivalent | Pass |
+| Exactly one read removed per index | Pass |
+| Every medium and large p50 improves by at least 10% | Fail |
+| No p95 regresses by more than 10% | Pass |
+| No local indexed p50 regresses by more than 5% | Pass |
+
+The missed latency threshold is retained rather than redefined. Promotion is
+based on the deterministic operation and byte reduction, complete
+equivalence, low implementation risk, and absence of a material regression.
+
+## Raw evidence
+
+Regional:
+
+```text
+evidence/trie-index-page-reuse-regional-worker-2026-09-30.json
+SHA-256 DC263801D5BF1C1F9CB563788F566D1A29D22DBAEEF32DDC735E20CF23CFC76F
+```
+
+Local:
+
+```text
+evidence/trie-index-page-reuse-local-2026-09-30.json
+SHA-256 EED29BF6C7C547D2FAB121E024D5F6AC4FE415B3036A690C45F182E9935AC246
+```
+
+Summary CSV:
+
+```text
+evidence/trie-index-page-reuse-summary-2026-09-30.csv
+SHA-256 0ABD1C8229F952BE5E66C78E639FAA4188049B8CCF228373D26EC326D5F1123E
+```
+
+Graph:
+
+```text
+benchmarks/trie-index-page-reuse/trie-index-page-reuse-p50.svg
+SHA-256 69EDA99ECB628C0C7F24028B9A689AA9F28BA22CFD629CCCBDDDFF1CF61D0AA0
+```
+
+The evidence contains no credentials.
diff --git a/benchmarks/trie-index-page-reuse/publish.mjs b/benchmarks/trie-index-page-reuse/publish.mjs
new file mode 100644
index 0000000..5999d28
--- /dev/null
+++ b/benchmarks/trie-index-page-reuse/publish.mjs
@@ -0,0 +1,222 @@
+import {
+  copyFile,
+  mkdir,
+  readFile,
+  readdir,
+  writeFile,
+} from "node:fs/promises";
+import path from "node:path";
+
+const date = "2026-09-30";
+const regionalPath = path.resolve(
+  "evidence",
+  `trie-index-page-reuse-regional-worker-${date}.json`,
+);
+const localSource =
+  process.env.THIMBLE_INDEX_REUSE_LOCAL_RESULT ??
+  await latestLocalResult();
+const localPath = path.resolve(
+  "evidence",
+  `trie-index-page-reuse-local-${date}.json`,
+);
+const csvPath = path.resolve(
+  "evidence",
+  `trie-index-page-reuse-summary-${date}.csv`,
+);
+const graphPath = path.resolve(
+  "benchmarks",
+  "trie-index-page-reuse",
+  "trie-index-page-reuse-p50.svg",
+);
+
+await mkdir(path.dirname(localPath), {
+  recursive: true,
+});
+await copyFile(localSource, localPath);
+const regional = JSON.parse(
+  await readFile(regionalPath, "utf8"),
+);
+const profiles = ["small", "medium", "large"];
+const indexSets = ["one", "two"];
+const rows = profiles.flatMap((profile) =>
+  indexSets.map((indexSet) => {
+    const baseline =
+      regional.overall.cases[
+        `write-${profile}-${indexSet}-duplicate`
+      ];
+    const candidate =
+      regional.overall.cases[
+        `write-${profile}-${indexSet}-reuse`
+      ];
+    const comparison =
+      regional.overall.comparisons[
+        `${profile}-${indexSet}`
+      ];
+    return {
+      profile,
+      documents:
+        regional.profiles[profile],
+      indexSet,
+      indexCount:
+        regional.indexSets[indexSet].count,
+      baselineP50Ms: baseline.clientP50Ms,
+      candidateP50Ms:
+        candidate.clientP50Ms,
+      p50ChangePercent:
+        comparison.p50ChangePercent,
+      baselineP95Ms: baseline.clientP95Ms,
+      candidateP95Ms:
+        candidate.clientP95Ms,
+      p95ChangePercent:
+        comparison.p95ChangePercent,
+      baselineReads: baseline.meanReads,
+      candidateReads: candidate.meanReads,
+      readByteChangePercent:
+        comparison.readByteChangePercent,
+    };
+  }),
+);
+await writeFile(
+  csvPath,
+  [
+    [
+      "profile",
+      "documents",
+      "index_set",
+      "index_count",
+      "baseline_p50_ms",
+      "candidate_p50_ms",
+      "p50_change_percent",
+      "baseline_p95_ms",
+      "candidate_p95_ms",
+      "p95_change_percent",
+      "baseline_reads",
+      "candidate_reads",
+      "read_byte_change_percent",
+    ].join(","),
+    ...rows.map((row) =>
+      [
+        row.profile,
+        row.documents,
+        row.indexSet,
+        row.indexCount,
+        row.baselineP50Ms,
+        row.candidateP50Ms,
+        row.p50ChangePercent,
+        row.baselineP95Ms,
+        row.candidateP95Ms,
+        row.p95ChangePercent,
+        row.baselineReads,
+        row.candidateReads,
+        row.readByteChangePercent,
+      ].join(","),
+    ),
+    "",
+  ].join("\n"),
+);
+await writeFile(graphPath, graph(rows));
+console.log(JSON.stringify({
+  localPath,
+  csvPath,
+  graphPath,
+}, null, 2));
+
+async function latestLocalResult() {
+  const root = path.resolve("benchmark-results");
+  const files = (await readdir(root))
+    .filter((file) =>
+      /^trie-index-page-reuse-\d+\.json$/.test(file),
+    )
+    .sort();
+  const latest = files.at(-1);
+  if (!latest) {
+    throw new Error(
+      "No local Trie index-page reuse result was found",
+    );
+  }
+  return path.join(root, latest);
+}
+
+function graph(rows) {
+  const width = 1_050;
+  const height = 590;
+  const margin = {
+    top: 80,
+    right: 40,
+    bottom: 105,
+    left: 90,
+  };
+  const chartWidth =
+    width - margin.left - margin.right;
+  const chartHeight =
+    height - margin.top - margin.bottom;
+  const maximum =
+    Math.ceil(
+      Math.max(
+        ...rows.flatMap((row) => [
+          row.baselineP50Ms,
+          row.candidateP50Ms,
+        ]),
+      ) / 1_000,
+    ) * 1_000;
+  const groupWidth = chartWidth / rows.length;
+  const barWidth = Math.min(38, groupWidth * 0.3);
+  const y = (value) =>
+    margin.top +
+    chartHeight -
+    (value / maximum) * chartHeight;
+  const bars = rows.flatMap((row, index) => {
+    const center =
+      margin.left +
+      groupWidth * index +
+      groupWidth / 2;
+    return [
+      `<rect x="${round(center - barWidth - 3)}" y="${round(y(row.baselineP50Ms))}" width="${round(barWidth)}" height="${round(margin.top + chartHeight - y(row.baselineP50Ms))}" fill="#0b1f3a"/>`,
+      `<rect x="${round(center + 3)}" y="${round(y(row.candidateP50Ms))}" width="${round(barWidth)}" height="${round(margin.top + chartHeight - y(row.candidateP50Ms))}" fill="#1677ff"/>`,
+      `<text x="${round(center)}" y="${height - 70}" text-anchor="middle" font-size="14" fill="#0b1f3a">${label(row)}</text>`,
+      `<text x="${round(center)}" y="${height - 49}" text-anchor="middle" font-size="12" fill="#526274">${row.p50ChangePercent}%</text>`,
+    ];
+  });
+  const ticks = Array.from(
+    { length: 8 },
+    (_, index) => (maximum / 7) * index,
+  ).map((value) => {
+    const position = y(value);
+    return [
+      `<line x1="${margin.left}" y1="${round(position)}" x2="${width - margin.right}" y2="${round(position)}" stroke="#d8e1ee"/>`,
+      `<text x="${margin.left - 12}" y="${round(position + 4)}" text-anchor="end" font-size="12" fill="#526274">${Math.round(value).toLocaleString("en-US")}</text>`,
+    ].join("");
+  });
+  return [
+    `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}" role="img" aria-labelledby="title description">`,
+    `<title id="title">Trie index page reuse p50 latency</title>`,
+    `<desc id="description">Control with duplicate index reads and candidate with reused validated pages across collection sizes and index counts.</desc>`,
+    `<rect width="${width}" height="${height}" fill="#f5f8fd"/>`,
+    `<text x="${margin.left}" y="36" font-size="25" font-weight="700" fill="#0b1f3a">Reusing validated index pages reduces every regional p50</text>`,
+    `<text x="${margin.left}" y="61" font-size="14" fill="#526274">Pooled p50 across seven Azure regions and two pristine R2 replicates. Lower is better.</text>`,
+    ...ticks,
+    `<line x1="${margin.left}" y1="${margin.top + chartHeight}" x2="${width - margin.right}" y2="${margin.top + chartHeight}" stroke="#0b1f3a"/>`,
+    ...bars,
+    `<rect x="${width - 310}" y="24" width="16" height="16" fill="#0b1f3a"/>`,
+    `<text x="${width - 286}" y="37" font-size="13" fill="#0b1f3a">Duplicate reads</text>`,
+    `<rect x="${width - 170}" y="24" width="16" height="16" fill="#1677ff"/>`,
+    `<text x="${width - 146}" y="37" font-size="13" fill="#0b1f3a">Reuse</text>`,
+    `<text x="24" y="${margin.top + chartHeight / 2}" transform="rotate(-90 24 ${margin.top + chartHeight / 2})" text-anchor="middle" font-size="14" fill="#526274">p50 latency (ms)</text>`,
+    `<text x="${width / 2}" y="${height - 14}" text-anchor="middle" font-size="12" fill="#526274">S/M/L = 128 / 5,000 / 25,000 documents; number = index count.</text>`,
+    `</svg>`,
+    "",
+  ].join("\n");
+}
+
+function label(row) {
+  const prefix = {
+    small: "S",
+    medium: "M",
+    large: "L",
+  }[row.profile];
+  return `${prefix}${row.indexCount}`;
+}
+
+function round(value) {
+  return Number(value.toFixed(2));
+}
diff --git a/benchmarks/trie-index-page-reuse/trie-index-page-reuse-p50.svg b/benchmarks/trie-index-page-reuse/trie-index-page-reuse-p50.svg
new file mode 100644
index 0000000..db9905c
--- /dev/null
+++ b/benchmarks/trie-index-page-reuse/trie-index-page-reuse-p50.svg
@@ -0,0 +1,46 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="1050" height="590" viewBox="0 0 1050 590" role="img" aria-labelledby="title description">
+<title id="title">Trie index page reuse p50 latency</title>
+<desc id="description">Control with duplicate index reads and candidate with reused validated pages across collection sizes and index counts.</desc>
+<rect width="1050" height="590" fill="#f5f8fd"/>
+<text x="90" y="36" font-size="25" font-weight="700" fill="#0b1f3a">Reusing validated index pages reduces every regional p50</text>
+<text x="90" y="61" font-size="14" fill="#526274">Pooled p50 across seven Azure regions and two pristine R2 replicates. Lower is better.</text>
+<line x1="90" y1="485" x2="1010" y2="485" stroke="#d8e1ee"/><text x="78" y="489" text-anchor="end" font-size="12" fill="#526274">0</text>
+<line x1="90" y1="427.14" x2="1010" y2="427.14" stroke="#d8e1ee"/><text x="78" y="431.14" text-anchor="end" font-size="12" fill="#526274">1,000</text>
+<line x1="90" y1="369.29" x2="1010" y2="369.29" stroke="#d8e1ee"/><text x="78" y="373.29" text-anchor="end" font-size="12" fill="#526274">2,000</text>
+<line x1="90" y1="311.43" x2="1010" y2="311.43" stroke="#d8e1ee"/><text x="78" y="315.43" text-anchor="end" font-size="12" fill="#526274">3,000</text>
+<line x1="90" y1="253.57" x2="1010" y2="253.57" stroke="#d8e1ee"/><text x="78" y="257.57" text-anchor="end" font-size="12" fill="#526274">4,000</text>
+<line x1="90" y1="195.71" x2="1010" y2="195.71" stroke="#d8e1ee"/><text x="78" y="199.71" text-anchor="end" font-size="12" fill="#526274">5,000</text>
+<line x1="90" y1="137.86" x2="1010" y2="137.86" stroke="#d8e1ee"/><text x="78" y="141.86" text-anchor="end" font-size="12" fill="#526274">6,000</text>
+<line x1="90" y1="80" x2="1010" y2="80" stroke="#d8e1ee"/><text x="78" y="84" text-anchor="end" font-size="12" fill="#526274">7,000</text>
+<line x1="90" y1="485" x2="1010" y2="485" stroke="#0b1f3a"/>
+<rect x="125.67" y="174.28" width="38" height="310.72" fill="#0b1f3a"/>
+<rect x="169.67" y="214.99" width="38" height="270.01" fill="#1677ff"/>
+<text x="166.67" y="520" text-anchor="middle" font-size="14" fill="#0b1f3a">S1</text>
+<text x="166.67" y="541" text-anchor="middle" font-size="12" fill="#526274">-13.1%</text>
+<rect x="279" y="151.43" width="38" height="333.57" fill="#0b1f3a"/>
+<rect x="323" y="177.83" width="38" height="307.17" fill="#1677ff"/>
+<text x="320" y="520" text-anchor="middle" font-size="14" fill="#0b1f3a">S2</text>
+<text x="320" y="541" text-anchor="middle" font-size="12" fill="#526274">-7.91%</text>
+<rect x="432.33" y="181.25" width="38" height="303.75" fill="#0b1f3a"/>
+<rect x="476.33" y="195.57" width="38" height="289.43" fill="#1677ff"/>
+<text x="473.33" y="520" text-anchor="middle" font-size="14" fill="#0b1f3a">M1</text>
+<text x="473.33" y="541" text-anchor="middle" font-size="12" fill="#526274">-4.72%</text>
+<rect x="585.67" y="145.05" width="38" height="339.95" fill="#0b1f3a"/>
+<rect x="629.67" y="166.6" width="38" height="318.4" fill="#1677ff"/>
+<text x="626.67" y="520" text-anchor="middle" font-size="14" fill="#0b1f3a">M2</text>
+<text x="626.67" y="541" text-anchor="middle" font-size="12" fill="#526274">-6.34%</text>
+<rect x="739" y="171.51" width="38" height="313.49" fill="#0b1f3a"/>
+<rect x="783" y="184.8" width="38" height="300.2" fill="#1677ff"/>
+<text x="780" y="520" text-anchor="middle" font-size="14" fill="#0b1f3a">L1</text>
+<text x="780" y="541" text-anchor="middle" font-size="12" fill="#526274">-4.24%</text>
+<rect x="892.33" y="90.08" width="38" height="394.92" fill="#0b1f3a"/>
+<rect x="936.33" y="128.34" width="38" height="356.66" fill="#1677ff"/>
+<text x="933.33" y="520" text-anchor="middle" font-size="14" fill="#0b1f3a">L2</text>
+<text x="933.33" y="541" text-anchor="middle" font-size="12" fill="#526274">-9.69%</text>
+<rect x="740" y="24" width="16" height="16" fill="#0b1f3a"/>
+<text x="764" y="37" font-size="13" fill="#0b1f3a">Duplicate reads</text>
+<rect x="880" y="24" width="16" height="16" fill="#1677ff"/>
+<text x="904" y="37" font-size="13" fill="#0b1f3a">Reuse</text>
+<text x="24" y="282.5" transform="rotate(-90 24 282.5)" text-anchor="middle" font-size="14" fill="#526274">p50 latency (ms)</text>
+<text x="525" y="576" text-anchor="middle" font-size="12" fill="#526274">S/M/L = 128 / 5,000 / 25,000 documents; number = index count.</text>
+</svg>
diff --git a/docs/BENCHMARKS.md b/docs/BENCHMARKS.md
index 9435ff0..d217e53 100644
--- a/docs/BENCHMARKS.md
+++ b/docs/BENCHMARKS.md
@@ -317,6 +317,32 @@ See the
 for the regional breakdown, local comparison, exact hashes, failures, and
 method.
 
+## Trie index-page reuse
+
+A paired 672-write regional matrix compared the production Trie candidate
+with a control that duplicates every index-page read. The candidate removed
+one read per configured index, reduced indexed read bytes by 35-50 percent,
+and preserved active protocol state in all 84 post-run comparisons.
+
+Pooled p50 improved by 4.24-13.10 percent across 128, 5,000, and 25,000
+documents with one and two indexes. The predeclared 10-percent threshold did
+not pass in every medium and large case. The result is still promoted because
+the operation removal is deterministic, all six p50 values improved, and no
+material regression or protocol change was observed.
+
+![Trie index-page reuse p50](https://thimbledb.com/benchmarks/trie-index-page-reuse-p50.svg)
+
+Raw artifacts:
+
+- `evidence/trie-index-page-reuse-regional-worker-2026-09-30.json`
+- `evidence/trie-index-page-reuse-local-2026-09-30.json`
+- `evidence/trie-index-page-reuse-summary-2026-09-30.csv`
+
+See the
+[index-page reuse report](https://github.com/Jason-Doyle/thimble/blob/main/benchmarks/trie-index-page-reuse/RESULTS.md)
+for the paired method, exact tables, hashes, local preflight, and acceptance
+result.
+
 ## Envelope limit validation
 
 Every one of the 14 regional read runs fetched a 16,336-byte gzip envelope
diff --git a/evidence/README.md b/evidence/README.md
index 1c0da32..13376cc 100644
--- a/evidence/README.md
+++ b/evidence/README.md
@@ -41,6 +41,11 @@ The local artifacts isolate CPU and encoding cost. The
 historical source on the same machine and with the same eight-iteration
 configuration as the post-merge local artifact.
 
+`trie-index-page-reuse-regional-worker-2026-09-30.json` contains the paired
+672-write matrix comparing duplicate index reads with reused validated index
+pages. `trie-index-page-reuse-local-2026-09-30.json` contains the matching
+local protocol-equivalence and CPU preflight.
+
 SHA-256:
 
 ```text
@@ -49,4 +54,7 @@ Post-merge local    C3273165AEA82CDE6B0EB052D174BFEDD3D7CAA8E7BC04329FC9C9D89192
 Historical regional FB922BE12A86631482FC4EA52C21F8D29FD211F42E3C7C45765CC23E157FB0A3
 Historical local    23B461C033F5BD16CC17AA199FA526D790898EDD4A289CE30FCE6427D4BB017D
 Local baseline rerun B474B2017A0F275C0EB819B03EFA0DED469E09C82BCCBB8811788CBC183B063A
+Index-reuse regional  DC263801D5BF1C1F9CB563788F566D1A29D22DBAEEF32DDC735E20CF23CFC76F
+Index-reuse local     EED29BF6C7C547D2FAB121E024D5F6AC4FE415B3036A690C45F182E9935AC246
+Index-reuse summary   0ABD1C8229F952BE5E66C78E639FAA4188049B8CCF228373D26EC326D5F1123E
 ```
diff --git a/evidence/trie-index-page-reuse-local-2026-09-30.json b/evidence/trie-index-page-reuse-local-2026-09-30.json
new file mode 100644
index 0000000..dda9f88
--- /dev/null
+++ b/evidence/trie-index-page-reuse-local-2026-09-30.json
@@ -0,0 +1,1669 @@
+{
+  "generatedAt": "2026-09-30T02:25:03.900Z",
+  "sourceCommit": "dbfa505e09b38e03ca2e9dbf0396b27190414291",
+  "iterations": 8,
+  "warning": "Local in-memory CPU and operation-count preflight. Regional cloud evidence remains required for end-to-end latency conclusions.",
+  "acceptance": {
+    "protocolEquivalent": "Every candidate must retain identical decoded keys and bytes.",
+    "reads": "Reuse must remove exactly one read per configured index.",
+    "indexedP50": "Indexed candidate p50 must not regress by more than 5%."
+  },
+  "results": {
+    "small-none": {
+      "profile": "small",
+      "documents": 128,
+      "indexSet": "none",
+      "indexCount": 0,
+      "duplicate": {
+        "summary": {
+          "p50Ms": 1.561,
+          "p95Ms": 2.71,
+          "meanMs": 1.895,
+          "meanReads": 4,
+          "meanIndexReads": 0,
+          "meanReadBytes": 1645,
+          "meanWrites": 4,
+          "meanWriteBytes": 1660
+        },
+        "samples": [
+          {
+            "elapsedMs": 2.451,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 1534,
+            "writes": 4,
+            "writeBytes": 1549,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 2.303,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 1621,
+            "writes": 4,
+            "writeBytes": 1632,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 1.689,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 1660,
+            "writes": 4,
+            "writeBytes": 1681,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 1.542,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 1789,
+            "writes": 4,
+            "writeBytes": 1806,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 2.71,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 1527,
+            "writes": 4,
+            "writeBytes": 1540,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 1.561,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 1665,
+            "writes": 4,
+            "writeBytes": 1676,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 1.474,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 1612,
+            "writes": 4,
+            "writeBytes": 1623,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 1.433,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 1752,
+            "writes": 4,
+            "writeBytes": 1771,
+            "preconditionFailures": 0
+          }
+        ]
+      },
+      "reuse": {
+        "summary": {
+          "p50Ms": 1.381,
+          "p95Ms": 2.162,
+          "meanMs": 1.533,
+          "meanReads": 4,
+          "meanIndexReads": 0,
+          "meanReadBytes": 1645,
+          "meanWrites": 4,
+          "meanWriteBytes": 1660
+        },
+        "samples": [
+          {
+            "elapsedMs": 1.773,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 1534,
+            "writes": 4,
+            "writeBytes": 1549,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 2.162,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 1621,
+            "writes": 4,
+            "writeBytes": 1632,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 1.258,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 1660,
+            "writes": 4,
+            "writeBytes": 1681,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 1.648,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 1789,
+            "writes": 4,
+            "writeBytes": 1806,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 1.305,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 1527,
+            "writes": 4,
+            "writeBytes": 1540,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 1.381,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 1665,
+            "writes": 4,
+            "writeBytes": 1676,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 1.434,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 1612,
+            "writes": 4,
+            "writeBytes": 1623,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 1.303,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 1752,
+            "writes": 4,
+            "writeBytes": 1771,
+            "preconditionFailures": 0
+          }
+        ]
+      },
+      "comparison": {
+        "p50ChangePercent": -11.53,
+        "p95ChangePercent": -20.22,
+        "readCountChangePercent": 0,
+        "readByteChangePercent": 0
+      }
+    },
+    "small-one": {
+      "profile": "small",
+      "documents": 128,
+      "indexSet": "one",
+      "indexCount": 1,
+      "duplicate": {
+        "summary": {
+          "p50Ms": 2.99,
+          "p95Ms": 3.623,
+          "meanMs": 3.02,
+          "meanReads": 6,
+          "meanIndexReads": 2,
+          "meanReadBytes": 5793,
+          "meanWrites": 5,
+          "meanWriteBytes": 3783
+        },
+        "samples": [
+          {
+            "elapsedMs": 3.623,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 5682,
+            "writes": 5,
+            "writeBytes": 3673,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 3.035,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 5769,
+            "writes": 5,
+            "writeBytes": 3754,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 2.777,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 5808,
+            "writes": 5,
+            "writeBytes": 3806,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 3.382,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 5937,
+            "writes": 5,
+            "writeBytes": 3931,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 3.458,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 5675,
+            "writes": 5,
+            "writeBytes": 3660,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 2.56,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 5813,
+            "writes": 5,
+            "writeBytes": 3799,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 2.99,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 5760,
+            "writes": 5,
+            "writeBytes": 3746,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 2.333,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 5900,
+            "writes": 5,
+            "writeBytes": 3896,
+            "preconditionFailures": 0
+          }
+        ]
+      },
+      "reuse": {
+        "summary": {
+          "p50Ms": 2.206,
+          "p95Ms": 3.137,
+          "meanMs": 2.431,
+          "meanReads": 5,
+          "meanIndexReads": 1,
+          "meanReadBytes": 3767,
+          "meanWrites": 5,
+          "meanWriteBytes": 3783
+        },
+        "samples": [
+          {
+            "elapsedMs": 2.206,
+            "reads": 5,
+            "indexReads": 1,
+            "readBytes": 3656,
+            "writes": 5,
+            "writeBytes": 3673,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 2.553,
+            "reads": 5,
+            "indexReads": 1,
+            "readBytes": 3743,
+            "writes": 5,
+            "writeBytes": 3754,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 3.07,
+            "reads": 5,
+            "indexReads": 1,
+            "readBytes": 3782,
+            "writes": 5,
+            "writeBytes": 3806,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 3.137,
+            "reads": 5,
+            "indexReads": 1,
+            "readBytes": 3911,
+            "writes": 5,
+            "writeBytes": 3931,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 2.021,
+            "reads": 5,
+            "indexReads": 1,
+            "readBytes": 3649,
+            "writes": 5,
+            "writeBytes": 3660,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 2.13,
+            "reads": 5,
+            "indexReads": 1,
+            "readBytes": 3787,
+            "writes": 5,
+            "writeBytes": 3799,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 2.605,
+            "reads": 5,
+            "indexReads": 1,
+            "readBytes": 3734,
+            "writes": 5,
+            "writeBytes": 3746,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 1.727,
+            "reads": 5,
+            "indexReads": 1,
+            "readBytes": 3874,
+            "writes": 5,
+            "writeBytes": 3896,
+            "preconditionFailures": 0
+          }
+        ]
+      },
+      "comparison": {
+        "p50ChangePercent": -26.22,
+        "p95ChangePercent": -13.41,
+        "readCountChangePercent": -16.67,
+        "readByteChangePercent": -34.97
+      }
+    },
+    "small-two": {
+      "profile": "small",
+      "documents": 128,
+      "indexSet": "two",
+      "indexCount": 2,
+      "duplicate": {
+        "summary": {
+          "p50Ms": 3.52,
+          "p95Ms": 4.908,
+          "meanMs": 3.684,
+          "meanReads": 8,
+          "meanIndexReads": 4,
+          "meanReadBytes": 10504,
+          "meanWrites": 6,
+          "meanWriteBytes": 6173
+        },
+        "samples": [
+          {
+            "elapsedMs": 3.52,
+            "reads": 8,
+            "indexReads": 4,
+            "readBytes": 10393,
+            "writes": 6,
+            "writeBytes": 6063,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 3.377,
+            "reads": 8,
+            "indexReads": 4,
+            "readBytes": 10480,
+            "writes": 6,
+            "writeBytes": 6139,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 3.212,
+            "reads": 8,
+            "indexReads": 4,
+            "readBytes": 10519,
+            "writes": 6,
+            "writeBytes": 6199,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 3.906,
+            "reads": 8,
+            "indexReads": 4,
+            "readBytes": 10648,
+            "writes": 6,
+            "writeBytes": 6322,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 4.053,
+            "reads": 8,
+            "indexReads": 4,
+            "readBytes": 10386,
+            "writes": 6,
+            "writeBytes": 6052,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 4.908,
+            "reads": 8,
+            "indexReads": 4,
+            "readBytes": 10524,
+            "writes": 6,
+            "writeBytes": 6187,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 3.541,
+            "reads": 8,
+            "indexReads": 4,
+            "readBytes": 10471,
+            "writes": 6,
+            "writeBytes": 6137,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 2.952,
+            "reads": 8,
+            "indexReads": 4,
+            "readBytes": 10611,
+            "writes": 6,
+            "writeBytes": 6288,
+            "preconditionFailures": 0
+          }
+        ]
+      },
+      "reuse": {
+        "summary": {
+          "p50Ms": 2.882,
+          "p95Ms": 4.509,
+          "meanMs": 3.002,
+          "meanReads": 6,
+          "meanIndexReads": 2,
+          "meanReadBytes": 6155,
+          "meanWrites": 6,
+          "meanWriteBytes": 6173
+        },
+        "samples": [
+          {
+            "elapsedMs": 2.893,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 6044,
+            "writes": 6,
+            "writeBytes": 6063,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 2.882,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 6131,
+            "writes": 6,
+            "writeBytes": 6139,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 3.045,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 6170,
+            "writes": 6,
+            "writeBytes": 6199,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 2.68,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 6299,
+            "writes": 6,
+            "writeBytes": 6322,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 3.081,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 6037,
+            "writes": 6,
+            "writeBytes": 6052,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 4.509,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 6175,
+            "writes": 6,
+            "writeBytes": 6187,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 2.481,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 6122,
+            "writes": 6,
+            "writeBytes": 6137,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 2.444,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 6262,
+            "writes": 6,
+            "writeBytes": 6288,
+            "preconditionFailures": 0
+          }
+        ]
+      },
+      "comparison": {
+        "p50ChangePercent": -18.12,
+        "p95ChangePercent": -8.13,
+        "readCountChangePercent": -25,
+        "readByteChangePercent": -41.4
+      }
+    },
+    "medium-none": {
+      "profile": "medium",
+      "documents": 5000,
+      "indexSet": "none",
+      "indexCount": 0,
+      "duplicate": {
+        "summary": {
+          "p50Ms": 1.412,
+          "p95Ms": 3.09,
+          "meanMs": 1.896,
+          "meanReads": 4,
+          "meanIndexReads": 0,
+          "meanReadBytes": 2616,
+          "meanWrites": 4,
+          "meanWriteBytes": 2630
+        },
+        "samples": [
+          {
+            "elapsedMs": 1.26,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 2488,
+            "writes": 4,
+            "writeBytes": 2504,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 1.651,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 2657,
+            "writes": 4,
+            "writeBytes": 2672,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 3.09,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 2617,
+            "writes": 4,
+            "writeBytes": 2628,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 1.412,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 2498,
+            "writes": 4,
+            "writeBytes": 2513,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 1.356,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 2610,
+            "writes": 4,
+            "writeBytes": 2620,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 2.463,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 2779,
+            "writes": 4,
+            "writeBytes": 2795,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 1.344,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 2672,
+            "writes": 4,
+            "writeBytes": 2687,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 2.591,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 2608,
+            "writes": 4,
+            "writeBytes": 2622,
+            "preconditionFailures": 0
+          }
+        ]
+      },
+      "reuse": {
+        "summary": {
+          "p50Ms": 1.119,
+          "p95Ms": 1.503,
+          "meanMs": 1.164,
+          "meanReads": 4,
+          "meanIndexReads": 0,
+          "meanReadBytes": 2616,
+          "meanWrites": 4,
+          "meanWriteBytes": 2630
+        },
+        "samples": [
+          {
+            "elapsedMs": 1.257,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 2488,
+            "writes": 4,
+            "writeBytes": 2504,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 1.101,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 2657,
+            "writes": 4,
+            "writeBytes": 2672,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 1.119,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 2617,
+            "writes": 4,
+            "writeBytes": 2628,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 1.165,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 2498,
+            "writes": 4,
+            "writeBytes": 2513,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 0.951,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 2610,
+            "writes": 4,
+            "writeBytes": 2620,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 1.043,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 2779,
+            "writes": 4,
+            "writeBytes": 2795,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 1.17,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 2672,
+            "writes": 4,
+            "writeBytes": 2687,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 1.503,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 2608,
+            "writes": 4,
+            "writeBytes": 2622,
+            "preconditionFailures": 0
+          }
+        ]
+      },
+      "comparison": {
+        "p50ChangePercent": -20.75,
+        "p95ChangePercent": -51.36,
+        "readCountChangePercent": 0,
+        "readByteChangePercent": 0
+      }
+    },
+    "medium-one": {
+      "profile": "medium",
+      "documents": 5000,
+      "indexSet": "one",
+      "indexCount": 1,
+      "duplicate": {
+        "summary": {
+          "p50Ms": 26.065,
+          "p95Ms": 28.363,
+          "meanMs": 26.455,
+          "meanReads": 6,
+          "meanIndexReads": 2,
+          "meanReadBytes": 134412,
+          "meanWrites": 5,
+          "meanWriteBytes": 68580
+        },
+        "samples": [
+          {
+            "elapsedMs": 28.363,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 134284,
+            "writes": 5,
+            "writeBytes": 68457,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 26.301,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 134453,
+            "writes": 5,
+            "writeBytes": 68622,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 24.883,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 134413,
+            "writes": 5,
+            "writeBytes": 68576,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 25.945,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 134294,
+            "writes": 5,
+            "writeBytes": 68461,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 25.196,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 134406,
+            "writes": 5,
+            "writeBytes": 68567,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 28.19,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 134575,
+            "writes": 5,
+            "writeBytes": 68746,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 26.699,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 134468,
+            "writes": 5,
+            "writeBytes": 68638,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 26.065,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 134404,
+            "writes": 5,
+            "writeBytes": 68574,
+            "preconditionFailures": 0
+          }
+        ]
+      },
+      "reuse": {
+        "summary": {
+          "p50Ms": 23.418,
+          "p95Ms": 25.864,
+          "meanMs": 23.782,
+          "meanReads": 5,
+          "meanIndexReads": 1,
+          "meanReadBytes": 68562,
+          "meanWrites": 5,
+          "meanWriteBytes": 68580
+        },
+        "samples": [
+          {
+            "elapsedMs": 23.045,
+            "reads": 5,
+            "indexReads": 1,
+            "readBytes": 68434,
+            "writes": 5,
+            "writeBytes": 68457,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 23.816,
+            "reads": 5,
+            "indexReads": 1,
+            "readBytes": 68603,
+            "writes": 5,
+            "writeBytes": 68622,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 23.418,
+            "reads": 5,
+            "indexReads": 1,
+            "readBytes": 68563,
+            "writes": 5,
+            "writeBytes": 68576,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 25.864,
+            "reads": 5,
+            "indexReads": 1,
+            "readBytes": 68444,
+            "writes": 5,
+            "writeBytes": 68461,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 23.251,
+            "reads": 5,
+            "indexReads": 1,
+            "readBytes": 68556,
+            "writes": 5,
+            "writeBytes": 68567,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 22.34,
+            "reads": 5,
+            "indexReads": 1,
+            "readBytes": 68725,
+            "writes": 5,
+            "writeBytes": 68746,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 24.547,
+            "reads": 5,
+            "indexReads": 1,
+            "readBytes": 68618,
+            "writes": 5,
+            "writeBytes": 68638,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 23.972,
+            "reads": 5,
+            "indexReads": 1,
+            "readBytes": 68554,
+            "writes": 5,
+            "writeBytes": 68574,
+            "preconditionFailures": 0
+          }
+        ]
+      },
+      "comparison": {
+        "p50ChangePercent": -10.16,
+        "p95ChangePercent": -8.81,
+        "readCountChangePercent": -16.67,
+        "readByteChangePercent": -48.99
+      }
+    },
+    "medium-two": {
+      "profile": "medium",
+      "documents": 5000,
+      "indexSet": "two",
+      "indexCount": 2,
+      "duplicate": {
+        "summary": {
+          "p50Ms": 56.84,
+          "p95Ms": 66.306,
+          "meanMs": 58.458,
+          "meanReads": 8,
+          "meanIndexReads": 4,
+          "meanReadBytes": 294707,
+          "meanWrites": 6,
+          "meanWriteBytes": 148765
+        },
+        "samples": [
+          {
+            "elapsedMs": 60.799,
+            "reads": 8,
+            "indexReads": 4,
+            "readBytes": 294579,
+            "writes": 6,
+            "writeBytes": 148641,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 56.501,
+            "reads": 8,
+            "indexReads": 4,
+            "readBytes": 294748,
+            "writes": 6,
+            "writeBytes": 148807,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 66.306,
+            "reads": 8,
+            "indexReads": 4,
+            "readBytes": 294708,
+            "writes": 6,
+            "writeBytes": 148760,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 56.305,
+            "reads": 8,
+            "indexReads": 4,
+            "readBytes": 294589,
+            "writes": 6,
+            "writeBytes": 148646,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 57.53,
+            "reads": 8,
+            "indexReads": 4,
+            "readBytes": 294701,
+            "writes": 6,
+            "writeBytes": 148752,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 56.84,
+            "reads": 8,
+            "indexReads": 4,
+            "readBytes": 294870,
+            "writes": 6,
+            "writeBytes": 148935,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 58.636,
+            "reads": 8,
+            "indexReads": 4,
+            "readBytes": 294763,
+            "writes": 6,
+            "writeBytes": 148823,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 54.749,
+            "reads": 8,
+            "indexReads": 4,
+            "readBytes": 294699,
+            "writes": 6,
+            "writeBytes": 148759,
+            "preconditionFailures": 0
+          }
+        ]
+      },
+      "reuse": {
+        "summary": {
+          "p50Ms": 52.825,
+          "p95Ms": 54.945,
+          "meanMs": 53.171,
+          "meanReads": 6,
+          "meanIndexReads": 2,
+          "meanReadBytes": 148743,
+          "meanWrites": 6,
+          "meanWriteBytes": 148765
+        },
+        "samples": [
+          {
+            "elapsedMs": 52.825,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 148615,
+            "writes": 6,
+            "writeBytes": 148641,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 52.482,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 148784,
+            "writes": 6,
+            "writeBytes": 148807,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 54.381,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 148744,
+            "writes": 6,
+            "writeBytes": 148760,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 53.858,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 148625,
+            "writes": 6,
+            "writeBytes": 148646,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 53.397,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 148737,
+            "writes": 6,
+            "writeBytes": 148752,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 54.945,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 148906,
+            "writes": 6,
+            "writeBytes": 148935,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 52.718,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 148799,
+            "writes": 6,
+            "writeBytes": 148823,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 50.76,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 148735,
+            "writes": 6,
+            "writeBytes": 148759,
+            "preconditionFailures": 0
+          }
+        ]
+      },
+      "comparison": {
+        "p50ChangePercent": -7.06,
+        "p95ChangePercent": -17.13,
+        "readCountChangePercent": -25,
+        "readByteChangePercent": -49.53
+      }
+    },
+    "large-none": {
+      "profile": "large",
+      "documents": 25000,
+      "indexSet": "none",
+      "indexCount": 0,
+      "duplicate": {
+        "summary": {
+          "p50Ms": 2.328,
+          "p95Ms": 2.914,
+          "meanMs": 2.365,
+          "meanReads": 4,
+          "meanIndexReads": 0,
+          "meanReadBytes": 4467,
+          "meanWrites": 4,
+          "meanWriteBytes": 4486
+        },
+        "samples": [
+          {
+            "elapsedMs": 2.914,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 4178,
+            "writes": 4,
+            "writeBytes": 4198,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 2.328,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 4425,
+            "writes": 4,
+            "writeBytes": 4439,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 2.08,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 4507,
+            "writes": 4,
+            "writeBytes": 4522,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 2.525,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 4294,
+            "writes": 4,
+            "writeBytes": 4313,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 2.297,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 4510,
+            "writes": 4,
+            "writeBytes": 4529,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 1.942,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 4506,
+            "writes": 4,
+            "writeBytes": 4528,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 2.381,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 4497,
+            "writes": 4,
+            "writeBytes": 4517,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 2.453,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 4820,
+            "writes": 4,
+            "writeBytes": 4843,
+            "preconditionFailures": 0
+          }
+        ]
+      },
+      "reuse": {
+        "summary": {
+          "p50Ms": 1.562,
+          "p95Ms": 2.598,
+          "meanMs": 1.749,
+          "meanReads": 4,
+          "meanIndexReads": 0,
+          "meanReadBytes": 4467,
+          "meanWrites": 4,
+          "meanWriteBytes": 4486
+        },
+        "samples": [
+          {
+            "elapsedMs": 2.598,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 4178,
+            "writes": 4,
+            "writeBytes": 4198,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 1.741,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 4425,
+            "writes": 4,
+            "writeBytes": 4439,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 1.537,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 4507,
+            "writes": 4,
+            "writeBytes": 4522,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 1.829,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 4294,
+            "writes": 4,
+            "writeBytes": 4313,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 1.549,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 4510,
+            "writes": 4,
+            "writeBytes": 4529,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 1.519,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 4506,
+            "writes": 4,
+            "writeBytes": 4528,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 1.66,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 4497,
+            "writes": 4,
+            "writeBytes": 4517,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 1.562,
+            "reads": 4,
+            "indexReads": 0,
+            "readBytes": 4820,
+            "writes": 4,
+            "writeBytes": 4843,
+            "preconditionFailures": 0
+          }
+        ]
+      },
+      "comparison": {
+        "p50ChangePercent": -32.9,
+        "p95ChangePercent": -10.84,
+        "readCountChangePercent": 0,
+        "readByteChangePercent": 0
+      }
+    },
+    "large-one": {
+      "profile": "large",
+      "documents": 25000,
+      "indexSet": "one",
+      "indexCount": 1,
+      "duplicate": {
+        "summary": {
+          "p50Ms": 139.26,
+          "p95Ms": 142.883,
+          "meanMs": 140.44,
+          "meanReads": 6,
+          "meanIndexReads": 2,
+          "meanReadBytes": 656692,
+          "meanWrites": 5,
+          "meanWriteBytes": 330651
+        },
+        "samples": [
+          {
+            "elapsedMs": 138.576,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 656403,
+            "writes": 5,
+            "writeBytes": 330363,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 142.883,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 656650,
+            "writes": 5,
+            "writeBytes": 330603,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 140.889,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 656732,
+            "writes": 5,
+            "writeBytes": 330687,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 142.846,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 656519,
+            "writes": 5,
+            "writeBytes": 330475,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 139.26,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 656735,
+            "writes": 5,
+            "writeBytes": 330692,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 139.154,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 656731,
+            "writes": 5,
+            "writeBytes": 330695,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 141.279,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 656722,
+            "writes": 5,
+            "writeBytes": 330683,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 138.635,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 657045,
+            "writes": 5,
+            "writeBytes": 331010,
+            "preconditionFailures": 0
+          }
+        ]
+      },
+      "reuse": {
+        "summary": {
+          "p50Ms": 129.258,
+          "p95Ms": 132.135,
+          "meanMs": 128.682,
+          "meanReads": 5,
+          "meanIndexReads": 1,
+          "meanReadBytes": 330628,
+          "meanWrites": 5,
+          "meanWriteBytes": 330651
+        },
+        "samples": [
+          {
+            "elapsedMs": 130.058,
+            "reads": 5,
+            "indexReads": 1,
+            "readBytes": 330339,
+            "writes": 5,
+            "writeBytes": 330363,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 126.313,
+            "reads": 5,
+            "indexReads": 1,
+            "readBytes": 330586,
+            "writes": 5,
+            "writeBytes": 330603,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 126.221,
+            "reads": 5,
+            "indexReads": 1,
+            "readBytes": 330668,
+            "writes": 5,
+            "writeBytes": 330687,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 132.135,
+            "reads": 5,
+            "indexReads": 1,
+            "readBytes": 330455,
+            "writes": 5,
+            "writeBytes": 330475,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 130.478,
+            "reads": 5,
+            "indexReads": 1,
+            "readBytes": 330671,
+            "writes": 5,
+            "writeBytes": 330692,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 124.187,
+            "reads": 5,
+            "indexReads": 1,
+            "readBytes": 330667,
+            "writes": 5,
+            "writeBytes": 330695,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 129.258,
+            "reads": 5,
+            "indexReads": 1,
+            "readBytes": 330658,
+            "writes": 5,
+            "writeBytes": 330683,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 130.808,
+            "reads": 5,
+            "indexReads": 1,
+            "readBytes": 330981,
+            "writes": 5,
+            "writeBytes": 331010,
+            "preconditionFailures": 0
+          }
+        ]
+      },
+      "comparison": {
+        "p50ChangePercent": -7.18,
+        "p95ChangePercent": -7.52,
+        "readCountChangePercent": -16.67,
+        "readByteChangePercent": -49.65
+      }
+    },
+    "large-two": {
+      "profile": "large",
+      "documents": 25000,
+      "indexSet": "two",
+      "indexCount": 2,
+      "duplicate": {
+        "summary": {
+          "p50Ms": 308.507,
+          "p95Ms": 316.911,
+          "meanMs": 311.327,
+          "meanReads": 8,
+          "meanIndexReads": 4,
+          "meanReadBytes": 1450752,
+          "meanWrites": 6,
+          "meanWriteBytes": 727722
+        },
+        "samples": [
+          {
+            "elapsedMs": 307.918,
+            "reads": 8,
+            "indexReads": 4,
+            "readBytes": 1450463,
+            "writes": 6,
+            "writeBytes": 727426,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 309.21,
+            "reads": 8,
+            "indexReads": 4,
+            "readBytes": 1450710,
+            "writes": 6,
+            "writeBytes": 727673,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 315.51,
+            "reads": 8,
+            "indexReads": 4,
+            "readBytes": 1450792,
+            "writes": 6,
+            "writeBytes": 727758,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 307.823,
+            "reads": 8,
+            "indexReads": 4,
+            "readBytes": 1450579,
+            "writes": 6,
+            "writeBytes": 727545,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 316.707,
+            "reads": 8,
+            "indexReads": 4,
+            "readBytes": 1450795,
+            "writes": 6,
+            "writeBytes": 727764,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 316.911,
+            "reads": 8,
+            "indexReads": 4,
+            "readBytes": 1450791,
+            "writes": 6,
+            "writeBytes": 727770,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 308.029,
+            "reads": 8,
+            "indexReads": 4,
+            "readBytes": 1450782,
+            "writes": 6,
+            "writeBytes": 727757,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 308.507,
+            "reads": 8,
+            "indexReads": 4,
+            "readBytes": 1451105,
+            "writes": 6,
+            "writeBytes": 728084,
+            "preconditionFailures": 0
+          }
+        ]
+      },
+      "reuse": {
+        "summary": {
+          "p50Ms": 314.394,
+          "p95Ms": 321.036,
+          "meanMs": 313.463,
+          "meanReads": 6,
+          "meanIndexReads": 2,
+          "meanReadBytes": 727692,
+          "meanWrites": 6,
+          "meanWriteBytes": 727722
+        },
+        "samples": [
+          {
+            "elapsedMs": 293.203,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 727403,
+            "writes": 6,
+            "writeBytes": 727426,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 313.518,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 727650,
+            "writes": 6,
+            "writeBytes": 727673,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 321.036,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 727732,
+            "writes": 6,
+            "writeBytes": 727758,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 314.394,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 727519,
+            "writes": 6,
+            "writeBytes": 727545,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 317.349,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 727735,
+            "writes": 6,
+            "writeBytes": 727764,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 318.73,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 727731,
+            "writes": 6,
+            "writeBytes": 727770,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 315.688,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 727722,
+            "writes": 6,
+            "writeBytes": 727757,
+            "preconditionFailures": 0
+          },
+          {
+            "elapsedMs": 313.783,
+            "reads": 6,
+            "indexReads": 2,
+            "readBytes": 728045,
+            "writes": 6,
+            "writeBytes": 728084,
+            "preconditionFailures": 0
+          }
+        ]
+      },
+      "comparison": {
+        "p50ChangePercent": 1.91,
+        "p95ChangePercent": 1.3,
+        "readCountChangePercent": -25,
+        "readByteChangePercent": -49.84
+      }
+    }
+  }
+}
diff --git a/evidence/trie-index-page-reuse-regional-worker-2026-09-30.json b/evidence/trie-index-page-reuse-regional-worker-2026-09-30.json
new file mode 100644
index 0000000..62f18d9
--- /dev/null
+++ b/evidence/trie-index-page-reuse-regional-worker-2026-09-30.json
@@ -0,0 +1,53211 @@
+{
+  "generatedAt": "2026-09-30T03:35:34.391Z",
+  "sourceCommit": "bd8af6eec98b8f4a745d90327e96534c4a09fac0",
+  "harnessCommits": [
+    "a1a1d02d9ce71318956e5a5cb9574eed43314c04"
+  ],
+  "target": "temporary workers.dev Worker and temporary Cloudflare R2 bucket",
+  "productionChanged": false,
+  "profiles": {
+    "small": 128,
+    "medium": 5000,
+    "large": 25000
+  },
+  "indexSets": {
+    "one": {
+      "count": 1,
+      "indexes": {
+        "notes": [
+          {
+            "name": "by-category",
+            "fields": [
+              "category"
+            ],
+            "mode": "equality",
+            "include": [
+              "title",
+              "lastModified"
+            ]
+          }
+        ]
+      }
+    },
+    "two": {
+      "count": 2,
+      "indexes": {
+        "notes": [
+          {
+            "name": "by-category",
+            "fields": [
+              "category"
+            ],
+            "mode": "equality",
+            "include": [
+              "title",
+              "lastModified"
+            ]
+          },
+          {
+            "name": "by-last-modified",
+            "fields": [
+              "lastModified"
+            ],
+            "mode": "range",
+            "include": [
+              "title",
+              "category"
+            ]
+          }
+        ]
+      }
+    }
+  },
+  "modes": [
+    "duplicate",
+    "reuse"
+  ],
+  "methodology": {
+    "execution": "Disposable Azure Node 22 callers compared the production index-page reuse path with a control wrapper that duplicates each index get.",
+    "regions": [
+      "eastus",
+      "westus2",
+      "northeurope",
+      "southeastasia",
+      "japaneast",
+      "australiaeast",
+      "brazilsouth"
+    ],
+    "replicates": 2,
+    "iterationsPerCase": 4,
+    "matrix": "128, 5,000, and 25,000 documents with one and two secondary indexes.",
+    "primaryLatency": "clientElapsedMs measured one complete Trie document update.",
+    "equivalence": "Post-run stored documents and active HEAD values were compared between control and candidate prefixes."
+  },
+  "acceptance": {
+    "allWritesSucceeded": true,
+    "protocolEquivalent": true,
+    "exactReadReduction": true,
+    "mediumAndLargeP50AtLeast10Percent": false,
+    "p95DoesNotRegressMoreThan10Percent": true
+  },
+  "limitations": [
+    "The control reproduces the old operation count by duplicating each immutable index get around the candidate engine.",
+    "Azure regions approximate geography and do not represent residential last-mile networks.",
+    "One Cloudflare account and one R2 bucket placement were used.",
+    "Authentication and browser rendering were excluded.",
+    "Cloudflare Worker timers do not measure CPU-only work normally."
+  ],
+  "totals": {
+    "operations": 672,
+    "runs": 14,
+    "verificationCases": 84
+  },
+  "overall": {
+    "cases": {
+      "write-small-one-duplicate": {
+        "operations": 56,
+        "successful": 56,
+        "failed": 0,
+        "successRatePercent": 100,
+        "clientP50Ms": 5370.461,
+        "clientP95Ms": 8739.036,
+        "clientMeanMs": 5497.551,
+        "workerMeanMs": 5476.589,
+        "meanReads": 6,
+        "meanReadBytes": 5739,
+        "meanReadDurationMs": 2263.607,
+        "meanWrites": 5,
+        "meanWriteBytes": 3741,
+        "meanWriteDurationMs": 3984.411,
+        "byKind": {
+          "head": {
+            "meanReadCount": 1,
+            "meanReadBytes": 243,
+            "meanReadDurationMs": 443.089
+          },
+          "index": {
+            "meanReadCount": 2,
+            "meanReadBytes": 4043,
+            "meanReadDurationMs": 591.607
+          },
+          "node": {
+            "meanReadCount": 3,
+            "meanReadBytes": 1453,
+            "meanReadDurationMs": 1228.911
+          }
+        },
+        "failures": {}
+      },
+      "write-medium-one-duplicate": {
+        "operations": 56,
+        "successful": 56,
+        "failed": 0,
+        "successRatePercent": 100,
+        "clientP50Ms": 5250.03,
+        "clientP95Ms": 8497.837,
+        "clientMeanMs": 5474.172,
+        "workerMeanMs": 5450.75,
+        "meanReads": 6,
+        "meanReadBytes": 134394,
+        "meanReadDurationMs": 2260.161,
+        "meanWrites": 5,
+        "meanWriteBytes": 68570,
+        "meanWriteDurationMs": 4066.411,
+        "byKind": {
+          "head": {
+            "meanReadCount": 1,
+            "meanReadBytes": 243,
+            "meanReadDurationMs": 381.643
+          },
+          "index": {
+            "meanReadCount": 2,
+            "meanReadBytes": 131701,
+            "meanReadDurationMs": 622.268
+          },
+          "node": {
+            "meanReadCount": 3,
+            "meanReadBytes": 2450,
+            "meanReadDurationMs": 1256.25
+          }
+        },
+        "failures": {}
+      },
+      "write-large-one-duplicate": {
+        "operations": 56,
+        "successful": 56,
+        "failed": 0,
+        "successRatePercent": 100,
+        "clientP50Ms": 5418.358,
+        "clientP95Ms": 9505.719,
+        "clientMeanMs": 5758.83,
+        "workerMeanMs": 5724.768,
+        "meanReads": 6,
+        "meanReadBytes": 656671,
+        "meanReadDurationMs": 2541.768,
+        "meanWrites": 5,
+        "meanWriteBytes": 330638,
+        "meanWriteDurationMs": 4346.054,
+        "byKind": {
+          "head": {
+            "meanReadCount": 1,
+            "meanReadBytes": 244,
+            "meanReadDurationMs": 391.5
+          },
+          "index": {
+            "meanReadCount": 2,
+            "meanReadBytes": 652128,
+            "meanReadDurationMs": 677.107
+          },
+          "node": {
+            "meanReadCount": 3,
+            "meanReadBytes": 4299,
+            "meanReadDurationMs": 1473.161
+          }
+        },
+        "failures": {}
+      },
+      "write-small-one-reuse": {
+        "operations": 56,
+        "successful": 56,
+        "failed": 0,
+        "successRatePercent": 100,
+        "clientP50Ms": 4666.812,
+        "clientP95Ms": 8670.088,
+        "clientMeanMs": 4997.666,
+        "workerMeanMs": 4975.893,
+        "meanReads": 5,
+        "meanReadBytes": 3718,
+        "meanReadDurationMs": 1929.321,
+        "meanWrites": 5,
+        "meanWriteBytes": 3741,
+        "meanWriteDurationMs": 3778.982,
+        "byKind": {
+          "head": {
+            "meanReadCount": 1,
+            "meanReadBytes": 243,
+            "meanReadDurationMs": 380.089
+          },
+          "index": {
+            "meanReadCount": 1,
+            "meanReadBytes": 2022,
+            "meanReadDurationMs": 372.804
+          },
+          "node": {
+            "meanReadCount": 3,
+            "meanReadBytes": 1453,
+            "meanReadDurationMs": 1176.429
+          }
+        },
+        "failures": {}
+      },
+      "write-medium-one-reuse": {
+        "operations": 56,
+        "successful": 56,
+        "failed": 0,
+        "successRatePercent": 100,
+        "clientP50Ms": 5002.49,
+        "clientP95Ms": 8558.276,
+        "clientMeanMs": 5124.868,
+        "workerMeanMs": 5101.946,
+        "meanReads": 5,
+        "meanReadBytes": 68543,
+        "meanReadDurationMs": 2008.607,
+        "meanWrites": 5,
+        "meanWriteBytes": 68570,
+        "meanWriteDurationMs": 3891.214,
+        "byKind": {
+          "head": {
+            "meanReadCount": 1,
+            "meanReadBytes": 243,
+            "meanReadDurationMs": 388.107
+          },
+          "index": {
+            "meanReadCount": 1,
+            "meanReadBytes": 65851,
+            "meanReadDurationMs": 391.696
+          },
+          "node": {
+            "meanReadCount": 3,
+            "meanReadBytes": 2450,
+            "meanReadDurationMs": 1228.804
+          }
+        },
+        "failures": {}
+      },
+      "write-large-one-reuse": {
+        "operations": 56,
+        "successful": 56,
+        "failed": 0,
+        "successRatePercent": 100,
+        "clientP50Ms": 5188.63,
+        "clientP95Ms": 8956.486,
+        "clientMeanMs": 5524.679,
+        "workerMeanMs": 5488.625,
+        "meanReads": 5,
+        "meanReadBytes": 330607,
+        "meanReadDurationMs": 2350.625,
+        "meanWrites": 5,
+        "meanWriteBytes": 330638,
+        "meanWriteDurationMs": 4227,
+        "byKind": {
+          "head": {
+            "meanReadCount": 1,
+            "meanReadBytes": 244,
+            "meanReadDurationMs": 400.196
+          },
+          "index": {
+            "meanReadCount": 1,
+            "meanReadBytes": 326064,
+            "meanReadDurationMs": 457.089
+          },
+          "node": {
+            "meanReadCount": 3,
+            "meanReadBytes": 4299,
+            "meanReadDurationMs": 1493.339
+          }
+        },
+        "failures": {}
+      },
+      "write-small-two-duplicate": {
+        "operations": 56,
+        "successful": 56,
+        "failed": 0,
+        "successRatePercent": 100,
+        "clientP50Ms": 5765.41,
+        "clientP95Ms": 9581.24,
+        "clientMeanMs": 5991.444,
+        "workerMeanMs": 5971.536,
+        "meanReads": 8,
+        "meanReadBytes": 10445,
+        "meanReadDurationMs": 2834.714,
+        "meanWrites": 6,
+        "meanWriteBytes": 6128,
+        "meanWriteDurationMs": 4717.768,
+        "byKind": {
+          "head": {
+            "meanReadCount": 1,
+            "meanReadBytes": 308,
+            "meanReadDurationMs": 390.554
+          },
+          "index": {
+            "meanReadCount": 4,
+            "meanReadBytes": 8684,
+            "meanReadDurationMs": 1232.018
+          },
+          "node": {
+            "meanReadCount": 3,
+            "meanReadBytes": 1453,
+            "meanReadDurationMs": 1212.143
+          }
+        },
+        "failures": {}
+      },
+      "write-medium-two-duplicate": {
+        "operations": 56,
+        "successful": 56,
+        "failed": 0,
+        "successRatePercent": 100,
+        "clientP50Ms": 5875.732,
+        "clientP95Ms": 9702.225,
+        "clientMeanMs": 6136.947,
+        "workerMeanMs": 6110.375,
+        "meanReads": 8,
+        "meanReadBytes": 294699,
+        "meanReadDurationMs": 2962.054,
+        "meanWrites": 6,
+        "meanWriteBytes": 148765,
+        "meanWriteDurationMs": 4947.911,
+        "byKind": {
+          "head": {
+            "meanReadCount": 1,
+            "meanReadBytes": 310,
+            "meanReadDurationMs": 415.893
+          },
+          "index": {
+            "meanReadCount": 4,
+            "meanReadBytes": 291940,
+            "meanReadDurationMs": 1248.679
+          },
+          "node": {
+            "meanReadCount": 3,
+            "meanReadBytes": 2450,
+            "meanReadDurationMs": 1297.482
+          }
+        },
+        "failures": {}
+      },
+      "write-large-two-duplicate": {
+        "operations": 56,
+        "successful": 56,
+        "failed": 0,
+        "successRatePercent": 100,
+        "clientP50Ms": 6825.799,
+        "clientP95Ms": 11467.727,
+        "clientMeanMs": 7208.522,
+        "workerMeanMs": 7157.661,
+        "meanReads": 8,
+        "meanReadBytes": 1450743,
+        "meanReadDurationMs": 3886.946,
+        "meanWrites": 6,
+        "meanWriteBytes": 727719,
+        "meanWriteDurationMs": 6239.036,
+        "byKind": {
+          "head": {
+            "meanReadCount": 1,
+            "meanReadBytes": 312,
+            "meanReadDurationMs": 389.875
+          },
+          "index": {
+            "meanReadCount": 4,
+            "meanReadBytes": 1446132,
+            "meanReadDurationMs": 1634.518
+          },
+          "node": {
+            "meanReadCount": 3,
+            "meanReadBytes": 4299,
+            "meanReadDurationMs": 1862.554
+          }
+        },
+        "failures": {}
+      },
+      "write-small-two-reuse": {
+        "operations": 56,
+        "successful": 56,
+        "failed": 0,
+        "successRatePercent": 100,
+        "clientP50Ms": 5309.08,
+        "clientP95Ms": 8998.601,
+        "clientMeanMs": 5543.429,
+        "workerMeanMs": 5522.964,
+        "meanReads": 6,
+        "meanReadBytes": 6103,
+        "meanReadDurationMs": 2386.375,
+        "meanWrites": 6,
+        "meanWriteBytes": 6128,
+        "meanWriteDurationMs": 4699.571,
+        "byKind": {
+          "head": {
+            "meanReadCount": 1,
+            "meanReadBytes": 308,
+            "meanReadDurationMs": 400.25
+          },
+          "index": {
+            "meanReadCount": 2,
+            "meanReadBytes": 4342,
+            "meanReadDurationMs": 782.875
+          },
+          "node": {
+            "meanReadCount": 3,
+            "meanReadBytes": 1453,
+            "meanReadDurationMs": 1203.25
+          }
+        },
+        "failures": {}
+      },
+      "write-medium-two-reuse": {
+        "operations": 56,
+        "successful": 56,
+        "failed": 0,
+        "successRatePercent": 100,
+        "clientP50Ms": 5503.139,
+        "clientP95Ms": 8980.712,
+        "clientMeanMs": 5551.41,
+        "workerMeanMs": 5525.304,
+        "meanReads": 6,
+        "meanReadBytes": 148729,
+        "meanReadDurationMs": 2529.982,
+        "meanWrites": 6,
+        "meanWriteBytes": 148765,
+        "meanWriteDurationMs": 4818.857,
+        "byKind": {
+          "head": {
+            "meanReadCount": 1,
+            "meanReadBytes": 310,
+            "meanReadDurationMs": 385.893
+          },
+          "index": {
+            "meanReadCount": 2,
+            "meanReadBytes": 145970,
+            "meanReadDurationMs": 850.179
+          },
+          "node": {
+            "meanReadCount": 3,
+            "meanReadBytes": 2450,
+            "meanReadDurationMs": 1293.911
+          }
+        },
+        "failures": {}
+      },
+      "write-large-two-reuse": {
+        "operations": 56,
+        "successful": 56,
+        "failed": 0,
+        "successRatePercent": 100,
+        "clientP50Ms": 6164.567,
+        "clientP95Ms": 10657.092,
+        "clientMeanMs": 6513.922,
+        "workerMeanMs": 6463.536,
+        "meanReads": 6,
+        "meanReadBytes": 727677,
+        "meanReadDurationMs": 3213.018,
+        "meanWrites": 6,
+        "meanWriteBytes": 727719,
+        "meanWriteDurationMs": 5993.946,
+        "byKind": {
+          "head": {
+            "meanReadCount": 1,
+            "meanReadBytes": 312,
+            "meanReadDurationMs": 398.268
+          },
+          "index": {
+            "meanReadCount": 2,
+            "meanReadBytes": 723066,
+            "meanReadDurationMs": 1014.554
+          },
+          "node": {
+            "meanReadCount": 3,
+            "meanReadBytes": 4299,
+            "meanReadDurationMs": 1800.196
+          }
+        },
+        "failures": {}
+      }
+    },
+    "comparisons": {
+      "small-one": {
+        "p50ChangePercent": -13.1,
+        "p95ChangePercent": -0.79,
+        "readCountChangePercent": -16.67,
+        "readByteChangePercent": -35.22,
+        "baselineReads": 6,
+        "candidateReads": 5
+      },
+      "small-two": {
+        "p50ChangePercent": -7.91,
+        "p95ChangePercent": -6.08,
+        "readCountChangePercent": -25,
+        "readByteChangePercent": -41.57,
+        "baselineReads": 8,
+        "candidateReads": 6
+      },
+      "medium-one": {
+        "p50ChangePercent": -4.72,
+        "p95ChangePercent": 0.71,
+        "readCountChangePercent": -16.67,
+        "readByteChangePercent": -49,
+        "baselineReads": 6,
+        "candidateReads": 5
+      },
+      "medium-two": {
+        "p50ChangePercent": -6.34,
+        "p95ChangePercent": -7.44,
+        "readCountChangePercent": -25,
+        "readByteChangePercent": -49.53,
+        "baselineReads": 8,
+        "candidateReads": 6
+      },
+      "large-one": {
+        "p50ChangePercent": -4.24,
+        "p95ChangePercent": -5.78,
+        "readCountChangePercent": -16.67,
+        "readByteChangePercent": -49.65,
+        "baselineReads": 6,
+        "candidateReads": 5
+      },
+      "large-two": {
+        "p50ChangePercent": -9.69,
+        "p95ChangePercent": -7.07,
+        "readCountChangePercent": -25,
+        "readByteChangePercent": -49.84,
+        "baselineReads": 8,
+        "candidateReads": 6
+      }
+    }
+  },
+  "regions": {
+    "eastus": {
+      "cases": {
+        "write-small-one-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 2371.406,
+          "clientP95Ms": 5185.977,
+          "clientMeanMs": 2944.411,
+          "workerMeanMs": 2926.625,
+          "meanReads": 6,
+          "meanReadBytes": 5694,
+          "meanReadDurationMs": 1213.25,
+          "meanWrites": 5,
+          "meanWriteBytes": 3695,
+          "meanWriteDurationMs": 2124.625,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 244,
+              "meanReadDurationMs": 260.375
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 4046,
+              "meanReadDurationMs": 322.375
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 1405,
+              "meanReadDurationMs": 630.5
+            }
+          },
+          "failures": {}
+        },
+        "write-medium-one-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 2308.08,
+          "clientP95Ms": 5355.551,
+          "clientMeanMs": 3318.2,
+          "workerMeanMs": 3294.75,
+          "meanReads": 6,
+          "meanReadBytes": 134416,
+          "meanReadDurationMs": 1284.75,
+          "meanWrites": 5,
+          "meanWriteBytes": 68590,
+          "meanWriteDurationMs": 2544.375,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 244,
+              "meanReadDurationMs": 207
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 131702,
+              "meanReadDurationMs": 383.5
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 2470,
+              "meanReadDurationMs": 694.25
+            }
+          },
+          "failures": {}
+        },
+        "write-large-one-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 2744.08,
+          "clientP95Ms": 5363.53,
+          "clientMeanMs": 3585.315,
+          "workerMeanMs": 3537,
+          "meanReads": 6,
+          "meanReadBytes": 656648,
+          "meanReadDurationMs": 1484,
+          "meanWrites": 5,
+          "meanWriteBytes": 330616,
+          "meanWriteDurationMs": 2811.625,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 244,
+              "meanReadDurationMs": 196.5
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 652124,
+              "meanReadDurationMs": 400.875
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 4280,
+              "meanReadDurationMs": 886.625
+            }
+          },
+          "failures": {}
+        },
+        "write-small-one-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 2094.114,
+          "clientP95Ms": 5309.932,
+          "clientMeanMs": 2784.302,
+          "workerMeanMs": 2767.75,
+          "meanReads": 5,
+          "meanReadBytes": 3671,
+          "meanReadDurationMs": 1017.75,
+          "meanWrites": 5,
+          "meanWriteBytes": 3695,
+          "meanWriteDurationMs": 2143.25,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 244,
+              "meanReadDurationMs": 197.375
+            },
+            "index": {
+              "meanReadCount": 1,
+              "meanReadBytes": 2023,
+              "meanReadDurationMs": 208.125
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 1405,
+              "meanReadDurationMs": 612.25
+            }
+          },
+          "failures": {}
+        },
+        "write-medium-one-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 2187.197,
+          "clientP95Ms": 5220.689,
+          "clientMeanMs": 2878.079,
+          "workerMeanMs": 2855.125,
+          "meanReads": 5,
+          "meanReadBytes": 68565,
+          "meanReadDurationMs": 1113.25,
+          "meanWrites": 5,
+          "meanWriteBytes": 68590,
+          "meanWriteDurationMs": 2220.625,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 244,
+              "meanReadDurationMs": 212.125
+            },
+            "index": {
+              "meanReadCount": 1,
+              "meanReadBytes": 65851,
+              "meanReadDurationMs": 212
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 2470,
+              "meanReadDurationMs": 689.125
+            }
+          },
+          "failures": {}
+        },
+        "write-large-one-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 2442.825,
+          "clientP95Ms": 5530.772,
+          "clientMeanMs": 3166.617,
+          "workerMeanMs": 3112.125,
+          "meanReads": 5,
+          "meanReadBytes": 330586,
+          "meanReadDurationMs": 1276.375,
+          "meanWrites": 5,
+          "meanWriteBytes": 330616,
+          "meanWriteDurationMs": 2429.125,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 244,
+              "meanReadDurationMs": 187.875
+            },
+            "index": {
+              "meanReadCount": 1,
+              "meanReadBytes": 326062,
+              "meanReadDurationMs": 233.625
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 4280,
+              "meanReadDurationMs": 854.875
+            }
+          },
+          "failures": {}
+        },
+        "write-small-two-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 2711.051,
+          "clientP95Ms": 5765.41,
+          "clientMeanMs": 3451.151,
+          "workerMeanMs": 3435,
+          "meanReads": 8,
+          "meanReadBytes": 10401,
+          "meanReadDurationMs": 1633.375,
+          "meanWrites": 6,
+          "meanWriteBytes": 6083,
+          "meanWriteDurationMs": 2652.25,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 309,
+              "meanReadDurationMs": 203.5
+            },
+            "index": {
+              "meanReadCount": 4,
+              "meanReadBytes": 8688,
+              "meanReadDurationMs": 759.5
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 1405,
+              "meanReadDurationMs": 670.375
+            }
+          },
+          "failures": {}
+        },
+        "write-medium-two-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 2737.044,
+          "clientP95Ms": 6131.331,
+          "clientMeanMs": 3545.913,
+          "workerMeanMs": 3514.125,
+          "meanReads": 8,
+          "meanReadBytes": 294712,
+          "meanReadDurationMs": 1782.875,
+          "meanWrites": 6,
+          "meanWriteBytes": 148777,
+          "meanWriteDurationMs": 2832.75,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 310,
+              "meanReadDurationMs": 297
+            },
+            "index": {
+              "meanReadCount": 4,
+              "meanReadBytes": 291932,
+              "meanReadDurationMs": 742.75
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 2471,
+              "meanReadDurationMs": 743.125
+            }
+          },
+          "failures": {}
+        },
+        "write-large-two-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 3638.715,
+          "clientP95Ms": 6164.338,
+          "clientMeanMs": 4272.732,
+          "workerMeanMs": 4176.125,
+          "meanReads": 8,
+          "meanReadBytes": 1450705,
+          "meanReadDurationMs": 2387.75,
+          "meanWrites": 6,
+          "meanWriteBytes": 727684,
+          "meanWriteDurationMs": 3431.75,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 312,
+              "meanReadDurationMs": 212.25
+            },
+            "index": {
+              "meanReadCount": 4,
+              "meanReadBytes": 1446113,
+              "meanReadDurationMs": 966.5
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 4280,
+              "meanReadDurationMs": 1209
+            }
+          },
+          "failures": {}
+        },
+        "write-small-two-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 2382.522,
+          "clientP95Ms": 6002.953,
+          "clientMeanMs": 2846.404,
+          "workerMeanMs": 2827.875,
+          "meanReads": 6,
+          "meanReadBytes": 6058,
+          "meanReadDurationMs": 1310.5,
+          "meanWrites": 6,
+          "meanWriteBytes": 6083,
+          "meanWriteDurationMs": 2264.125,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 309,
+              "meanReadDurationMs": 276.375
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 4344,
+              "meanReadDurationMs": 389.375
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 1405,
+              "meanReadDurationMs": 644.75
+            }
+          },
+          "failures": {}
+        },
+        "write-medium-two-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 2602.669,
+          "clientP95Ms": 5355.429,
+          "clientMeanMs": 2912.081,
+          "workerMeanMs": 2879,
+          "meanReads": 6,
+          "meanReadBytes": 148747,
+          "meanReadDurationMs": 1377,
+          "meanWrites": 6,
+          "meanWriteBytes": 148777,
+          "meanWriteDurationMs": 2342.125,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 310,
+              "meanReadDurationMs": 209.125
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 145966,
+              "meanReadDurationMs": 492.875
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 2471,
+              "meanReadDurationMs": 675
+            }
+          },
+          "failures": {}
+        },
+        "write-large-two-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 3317.894,
+          "clientP95Ms": 6243.648,
+          "clientMeanMs": 3901.44,
+          "workerMeanMs": 3806.5,
+          "meanReads": 6,
+          "meanReadBytes": 727649,
+          "meanReadDurationMs": 1951.625,
+          "meanWrites": 6,
+          "meanWriteBytes": 727684,
+          "meanWriteDurationMs": 3479.375,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 312,
+              "meanReadDurationMs": 207.125
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 723057,
+              "meanReadDurationMs": 680.875
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 4280,
+              "meanReadDurationMs": 1063.625
+            }
+          },
+          "failures": {}
+        }
+      },
+      "comparisons": {
+        "small-one": {
+          "p50ChangePercent": -11.69,
+          "p95ChangePercent": 2.39,
+          "readCountChangePercent": -16.67,
+          "readByteChangePercent": -35.53,
+          "baselineReads": 6,
+          "candidateReads": 5
+        },
+        "small-two": {
+          "p50ChangePercent": -12.12,
+          "p95ChangePercent": 4.12,
+          "readCountChangePercent": -25,
+          "readByteChangePercent": -41.76,
+          "baselineReads": 8,
+          "candidateReads": 6
+        },
+        "medium-one": {
+          "p50ChangePercent": -5.24,
+          "p95ChangePercent": -2.52,
+          "readCountChangePercent": -16.67,
+          "readByteChangePercent": -48.99,
+          "baselineReads": 6,
+          "candidateReads": 5
+        },
+        "medium-two": {
+          "p50ChangePercent": -4.91,
+          "p95ChangePercent": -12.65,
+          "readCountChangePercent": -25,
+          "readByteChangePercent": -49.53,
+          "baselineReads": 8,
+          "candidateReads": 6
+        },
+        "large-one": {
+          "p50ChangePercent": -10.98,
+          "p95ChangePercent": 3.12,
+          "readCountChangePercent": -16.67,
+          "readByteChangePercent": -49.66,
+          "baselineReads": 6,
+          "candidateReads": 5
+        },
+        "large-two": {
+          "p50ChangePercent": -8.82,
+          "p95ChangePercent": 1.29,
+          "readCountChangePercent": -25,
+          "readByteChangePercent": -49.84,
+          "baselineReads": 8,
+          "candidateReads": 6
+        }
+      }
+    },
+    "westus2": {
+      "cases": {
+        "write-small-one-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 2216.887,
+          "clientP95Ms": 5162.642,
+          "clientMeanMs": 2627.472,
+          "workerMeanMs": 2595.75,
+          "meanReads": 6,
+          "meanReadBytes": 5732,
+          "meanReadDurationMs": 1077.375,
+          "meanWrites": 5,
+          "meanWriteBytes": 3735,
+          "meanWriteDurationMs": 1894.5,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 243,
+              "meanReadDurationMs": 208.5
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 4041,
+              "meanReadDurationMs": 314.75
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 1448,
+              "meanReadDurationMs": 554.125
+            }
+          },
+          "failures": {}
+        },
+        "write-medium-one-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 2268.73,
+          "clientP95Ms": 5250.03,
+          "clientMeanMs": 3027.184,
+          "workerMeanMs": 2986.875,
+          "meanReads": 6,
+          "meanReadBytes": 134410,
+          "meanReadDurationMs": 1168.625,
+          "meanWrites": 5,
+          "meanWriteBytes": 68583,
+          "meanWriteDurationMs": 2334.125,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 243,
+              "meanReadDurationMs": 200.75
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 131701,
+              "meanReadDurationMs": 344.25
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 2466,
+              "meanReadDurationMs": 623.625
+            }
+          },
+          "failures": {}
+        },
+        "write-large-one-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 3126.079,
+          "clientP95Ms": 5662.927,
+          "clientMeanMs": 3799.358,
+          "workerMeanMs": 3726.5,
+          "meanReads": 6,
+          "meanReadBytes": 656672,
+          "meanReadDurationMs": 1519.625,
+          "meanWrites": 5,
+          "meanWriteBytes": 330636,
+          "meanWriteDurationMs": 2920.375,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 244,
+              "meanReadDurationMs": 225.75
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 652131,
+              "meanReadDurationMs": 424.875
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 4298,
+              "meanReadDurationMs": 869
+            }
+          },
+          "failures": {}
+        },
+        "write-small-one-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 2302.785,
+          "clientP95Ms": 4633.694,
+          "clientMeanMs": 2819.208,
+          "workerMeanMs": 2781.125,
+          "meanReads": 5,
+          "meanReadBytes": 3712,
+          "meanReadDurationMs": 936.125,
+          "meanWrites": 5,
+          "meanWriteBytes": 3735,
+          "meanWriteDurationMs": 2278.25,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 243,
+              "meanReadDurationMs": 174.75
+            },
+            "index": {
+              "meanReadCount": 1,
+              "meanReadBytes": 2020,
+              "meanReadDurationMs": 183.375
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 1448,
+              "meanReadDurationMs": 578
+            }
+          },
+          "failures": {}
+        },
+        "write-medium-one-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 2212.284,
+          "clientP95Ms": 4837.525,
+          "clientMeanMs": 2798.009,
+          "workerMeanMs": 2760.25,
+          "meanReads": 5,
+          "meanReadBytes": 68559,
+          "meanReadDurationMs": 960.75,
+          "meanWrites": 5,
+          "meanWriteBytes": 68583,
+          "meanWriteDurationMs": 2271.625,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 243,
+              "meanReadDurationMs": 185.75
+            },
+            "index": {
+              "meanReadCount": 1,
+              "meanReadBytes": 65850,
+              "meanReadDurationMs": 173.375
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 2466,
+              "meanReadDurationMs": 601.625
+            }
+          },
+          "failures": {}
+        },
+        "write-large-one-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 2678.914,
+          "clientP95Ms": 5292.773,
+          "clientMeanMs": 3210.589,
+          "workerMeanMs": 3126,
+          "meanReads": 5,
+          "meanReadBytes": 330607,
+          "meanReadDurationMs": 1173.75,
+          "meanWrites": 5,
+          "meanWriteBytes": 330636,
+          "meanWriteDurationMs": 2657.25,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 244,
+              "meanReadDurationMs": 212.25
+            },
+            "index": {
+              "meanReadCount": 1,
+              "meanReadBytes": 326066,
+              "meanReadDurationMs": 201
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 4298,
+              "meanReadDurationMs": 760.5
+            }
+          },
+          "failures": {}
+        },
+        "write-small-two-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 2670.994,
+          "clientP95Ms": 6045.732,
+          "clientMeanMs": 3474.777,
+          "workerMeanMs": 3448.125,
+          "meanReads": 8,
+          "meanReadBytes": 10435,
+          "meanReadDurationMs": 1457.5,
+          "meanWrites": 6,
+          "meanWriteBytes": 6121,
+          "meanWriteDurationMs": 2900.75,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 308,
+              "meanReadDurationMs": 173.875
+            },
+            "index": {
+              "meanReadCount": 4,
+              "meanReadBytes": 8679,
+              "meanReadDurationMs": 705.875
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 1448,
+              "meanReadDurationMs": 577.75
+            }
+          },
+          "failures": {}
+        },
+        "write-medium-two-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 2935.256,
+          "clientP95Ms": 5237.982,
+          "clientMeanMs": 3506.09,
+          "workerMeanMs": 3453,
+          "meanReads": 8,
+          "meanReadBytes": 294714,
+          "meanReadDurationMs": 1626,
+          "meanWrites": 6,
+          "meanWriteBytes": 148777,
+          "meanWriteDurationMs": 2893.625,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 309,
+              "meanReadDurationMs": 262.125
+            },
+            "index": {
+              "meanReadCount": 4,
+              "meanReadBytes": 291937,
+              "meanReadDurationMs": 738.375
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 2467,
+              "meanReadDurationMs": 625.5
+            }
+          },
+          "failures": {}
+        },
+        "write-large-two-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 4474.394,
+          "clientP95Ms": 6320.868,
+          "clientMeanMs": 4692.409,
+          "workerMeanMs": 4564,
+          "meanReads": 8,
+          "meanReadBytes": 1450749,
+          "meanReadDurationMs": 2358,
+          "meanWrites": 6,
+          "meanWriteBytes": 727719,
+          "meanWriteDurationMs": 4332.75,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 312,
+              "meanReadDurationMs": 184.375
+            },
+            "index": {
+              "meanReadCount": 4,
+              "meanReadBytes": 1446139,
+              "meanReadDurationMs": 1023.75
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 4297,
+              "meanReadDurationMs": 1149.875
+            }
+          },
+          "failures": {}
+        },
+        "write-small-two-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 2430.288,
+          "clientP95Ms": 5030.692,
+          "clientMeanMs": 3010.254,
+          "workerMeanMs": 2979.5,
+          "meanReads": 6,
+          "meanReadBytes": 6095,
+          "meanReadDurationMs": 1200.75,
+          "meanWrites": 6,
+          "meanWriteBytes": 6121,
+          "meanWriteDurationMs": 2686.625,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 308,
+              "meanReadDurationMs": 177.875
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 4340,
+              "meanReadDurationMs": 415.25
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 1448,
+              "meanReadDurationMs": 607.625
+            }
+          },
+          "failures": {}
+        },
+        "write-medium-two-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 2455.406,
+          "clientP95Ms": 5252.813,
+          "clientMeanMs": 2854.29,
+          "workerMeanMs": 2806,
+          "meanReads": 6,
+          "meanReadBytes": 148745,
+          "meanReadDurationMs": 1223.375,
+          "meanWrites": 6,
+          "meanWriteBytes": 148777,
+          "meanWriteDurationMs": 2583.5,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 309,
+              "meanReadDurationMs": 171.875
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 145969,
+              "meanReadDurationMs": 403.75
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 2467,
+              "meanReadDurationMs": 647.75
+            }
+          },
+          "failures": {}
+        },
+        "write-large-two-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 3491.576,
+          "clientP95Ms": 5666.715,
+          "clientMeanMs": 3749.281,
+          "workerMeanMs": 3618.5,
+          "meanReads": 6,
+          "meanReadBytes": 727679,
+          "meanReadDurationMs": 1826.375,
+          "meanWrites": 6,
+          "meanWriteBytes": 727719,
+          "meanWriteDurationMs": 3612,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 312,
+              "meanReadDurationMs": 184.125
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 723070,
+              "meanReadDurationMs": 528.625
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 4297,
+              "meanReadDurationMs": 1113.625
+            }
+          },
+          "failures": {}
+        }
+      },
+      "comparisons": {
+        "small-one": {
+          "p50ChangePercent": 3.87,
+          "p95ChangePercent": -10.25,
+          "readCountChangePercent": -16.67,
+          "readByteChangePercent": -35.24,
+          "baselineReads": 6,
+          "candidateReads": 5
+        },
+        "small-two": {
+          "p50ChangePercent": -9.01,
+          "p95ChangePercent": -16.79,
+          "readCountChangePercent": -25,
+          "readByteChangePercent": -41.59,
+          "baselineReads": 8,
+          "candidateReads": 6
+        },
+        "medium-one": {
+          "p50ChangePercent": -2.49,
+          "p95ChangePercent": -7.86,
+          "readCountChangePercent": -16.67,
+          "readByteChangePercent": -48.99,
+          "baselineReads": 6,
+          "candidateReads": 5
+        },
+        "medium-two": {
+          "p50ChangePercent": -16.35,
+          "p95ChangePercent": 0.28,
+          "readCountChangePercent": -25,
+          "readByteChangePercent": -49.53,
+          "baselineReads": 8,
+          "candidateReads": 6
+        },
+        "large-one": {
+          "p50ChangePercent": -14.3,
+          "p95ChangePercent": -6.54,
+          "readCountChangePercent": -16.67,
+          "readByteChangePercent": -49.65,
+          "baselineReads": 6,
+          "candidateReads": 5
+        },
+        "large-two": {
+          "p50ChangePercent": -21.97,
+          "p95ChangePercent": -10.35,
+          "readCountChangePercent": -25,
+          "readByteChangePercent": -49.84,
+          "baselineReads": 8,
+          "candidateReads": 6
+        }
+      }
+    },
+    "northeurope": {
+      "cases": {
+        "write-small-one-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 5198.019,
+          "clientP95Ms": 8739.036,
+          "clientMeanMs": 6121.236,
+          "workerMeanMs": 6111.25,
+          "meanReads": 6,
+          "meanReadBytes": 5739,
+          "meanReadDurationMs": 2489.5,
+          "meanWrites": 5,
+          "meanWriteBytes": 3742,
+          "meanWriteDurationMs": 4481.5,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 243,
+              "meanReadDurationMs": 487.5
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 4042,
+              "meanReadDurationMs": 661.375
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 1455,
+              "meanReadDurationMs": 1340.625
+            }
+          },
+          "failures": {}
+        },
+        "write-medium-one-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 5061.474,
+          "clientP95Ms": 7541.946,
+          "clientMeanMs": 6116.313,
+          "workerMeanMs": 6105.25,
+          "meanReads": 6,
+          "meanReadBytes": 134324,
+          "meanReadDurationMs": 2546.25,
+          "meanWrites": 5,
+          "meanWriteBytes": 68501,
+          "meanWriteDurationMs": 4694.25,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 243,
+              "meanReadDurationMs": 430.375
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 131702,
+              "meanReadDurationMs": 715.875
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 2380,
+              "meanReadDurationMs": 1400
+            }
+          },
+          "failures": {}
+        },
+        "write-large-one-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 5429.253,
+          "clientP95Ms": 8048.382,
+          "clientMeanMs": 6042.942,
+          "workerMeanMs": 6027.25,
+          "meanReads": 6,
+          "meanReadBytes": 656631,
+          "meanReadDurationMs": 2787.5,
+          "meanWrites": 5,
+          "meanWriteBytes": 330594,
+          "meanWriteDurationMs": 4307.875,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 244,
+              "meanReadDurationMs": 403.5
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 652134,
+              "meanReadDurationMs": 764.625
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 4253,
+              "meanReadDurationMs": 1619.375
+            }
+          },
+          "failures": {}
+        },
+        "write-small-one-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 4406.234,
+          "clientP95Ms": 7062.094,
+          "clientMeanMs": 5037.439,
+          "workerMeanMs": 5026.5,
+          "meanReads": 5,
+          "meanReadBytes": 3719,
+          "meanReadDurationMs": 2073.5,
+          "meanWrites": 5,
+          "meanWriteBytes": 3742,
+          "meanWriteDurationMs": 3682.625,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 243,
+              "meanReadDurationMs": 419.75
+            },
+            "index": {
+              "meanReadCount": 1,
+              "meanReadBytes": 2021,
+              "meanReadDurationMs": 413.25
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 1455,
+              "meanReadDurationMs": 1240.5
+            }
+          },
+          "failures": {}
+        },
+        "write-medium-one-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 4868.451,
+          "clientP95Ms": 7141.247,
+          "clientMeanMs": 5713.913,
+          "workerMeanMs": 5703.875,
+          "meanReads": 5,
+          "meanReadBytes": 68474,
+          "meanReadDurationMs": 2189,
+          "meanWrites": 5,
+          "meanWriteBytes": 68501,
+          "meanWriteDurationMs": 4363,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 243,
+              "meanReadDurationMs": 428.875
+            },
+            "index": {
+              "meanReadCount": 1,
+              "meanReadBytes": 65851,
+              "meanReadDurationMs": 434.375
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 2380,
+              "meanReadDurationMs": 1325.75
+            }
+          },
+          "failures": {}
+        },
+        "write-large-one-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 5025.038,
+          "clientP95Ms": 8402.012,
+          "clientMeanMs": 6077.291,
+          "workerMeanMs": 6061.875,
+          "meanReads": 5,
+          "meanReadBytes": 330564,
+          "meanReadDurationMs": 2619.75,
+          "meanWrites": 5,
+          "meanWriteBytes": 330594,
+          "meanWriteDurationMs": 4662,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 244,
+              "meanReadDurationMs": 417.25
+            },
+            "index": {
+              "meanReadCount": 1,
+              "meanReadBytes": 326067,
+              "meanReadDurationMs": 536.5
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 4253,
+              "meanReadDurationMs": 1666
+            }
+          },
+          "failures": {}
+        },
+        "write-small-two-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 5876.551,
+          "clientP95Ms": 8456.861,
+          "clientMeanMs": 6596.67,
+          "workerMeanMs": 6587.375,
+          "meanReads": 8,
+          "meanReadBytes": 10445,
+          "meanReadDurationMs": 3189.375,
+          "meanWrites": 6,
+          "meanWriteBytes": 6130,
+          "meanWriteDurationMs": 5011.625,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 308,
+              "meanReadDurationMs": 485.375
+            },
+            "index": {
+              "meanReadCount": 4,
+              "meanReadBytes": 8682,
+              "meanReadDurationMs": 1325.375
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 1455,
+              "meanReadDurationMs": 1378.625
+            }
+          },
+          "failures": {}
+        },
+        "write-medium-two-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 5661.422,
+          "clientP95Ms": 9021.386,
+          "clientMeanMs": 6795.313,
+          "workerMeanMs": 6783.75,
+          "meanReads": 8,
+          "meanReadBytes": 294634,
+          "meanReadDurationMs": 3255.5,
+          "meanWrites": 6,
+          "meanWriteBytes": 148699,
+          "meanWriteDurationMs": 5465.375,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 311,
+              "meanReadDurationMs": 406.25
+            },
+            "index": {
+              "meanReadCount": 4,
+              "meanReadBytes": 291943,
+              "meanReadDurationMs": 1388.75
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 2381,
+              "meanReadDurationMs": 1460.5
+            }
+          },
+          "failures": {}
+        },
+        "write-large-two-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 6986.206,
+          "clientP95Ms": 9845.256,
+          "clientMeanMs": 7918.065,
+          "workerMeanMs": 7897.75,
+          "meanReads": 8,
+          "meanReadBytes": 1450708,
+          "meanReadDurationMs": 4210.125,
+          "meanWrites": 6,
+          "meanWriteBytes": 727679,
+          "meanWriteDurationMs": 6704.5,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 312,
+              "meanReadDurationMs": 416
+            },
+            "index": {
+              "meanReadCount": 4,
+              "meanReadBytes": 1446144,
+              "meanReadDurationMs": 1791.25
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 4253,
+              "meanReadDurationMs": 2002.875
+            }
+          },
+          "failures": {}
+        },
+        "write-small-two-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 5370.845,
+          "clientP95Ms": 8842.452,
+          "clientMeanMs": 6337.117,
+          "workerMeanMs": 6326.75,
+          "meanReads": 6,
+          "meanReadBytes": 6104,
+          "meanReadDurationMs": 2694.25,
+          "meanWrites": 6,
+          "meanWriteBytes": 6130,
+          "meanWriteDurationMs": 5351.125,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 308,
+              "meanReadDurationMs": 422.625
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 4341,
+              "meanReadDurationMs": 880
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 1455,
+              "meanReadDurationMs": 1391.625
+            }
+          },
+          "failures": {}
+        },
+        "write-medium-two-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 5216.384,
+          "clientP95Ms": 7854.83,
+          "clientMeanMs": 6122.484,
+          "workerMeanMs": 6110.75,
+          "meanReads": 6,
+          "meanReadBytes": 148663,
+          "meanReadDurationMs": 2732.875,
+          "meanWrites": 6,
+          "meanWriteBytes": 148699,
+          "meanWriteDurationMs": 5294.875,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 311,
+              "meanReadDurationMs": 444.75
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 145971,
+              "meanReadDurationMs": 883.75
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 2381,
+              "meanReadDurationMs": 1404.375
+            }
+          },
+          "failures": {}
+        },
+        "write-large-two-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 5930.262,
+          "clientP95Ms": 9297.354,
+          "clientMeanMs": 6993.725,
+          "workerMeanMs": 6975.875,
+          "meanReads": 6,
+          "meanReadBytes": 727636,
+          "meanReadDurationMs": 3395.875,
+          "meanWrites": 6,
+          "meanWriteBytes": 727679,
+          "meanWriteDurationMs": 6484.375,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 312,
+              "meanReadDurationMs": 428
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 723072,
+              "meanReadDurationMs": 1058.25
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 4253,
+              "meanReadDurationMs": 1909.625
+            }
+          },
+          "failures": {}
+        }
+      },
+      "comparisons": {
+        "small-one": {
+          "p50ChangePercent": -15.23,
+          "p95ChangePercent": -19.19,
+          "readCountChangePercent": -16.67,
+          "readByteChangePercent": -35.2,
+          "baselineReads": 6,
+          "candidateReads": 5
+        },
+        "small-two": {
+          "p50ChangePercent": -8.61,
+          "p95ChangePercent": 4.56,
+          "readCountChangePercent": -25,
+          "readByteChangePercent": -41.56,
+          "baselineReads": 8,
+          "candidateReads": 6
+        },
+        "medium-one": {
+          "p50ChangePercent": -3.81,
+          "p95ChangePercent": -5.31,
+          "readCountChangePercent": -16.67,
+          "readByteChangePercent": -49.02,
+          "baselineReads": 6,
+          "candidateReads": 5
+        },
+        "medium-two": {
+          "p50ChangePercent": -7.86,
+          "p95ChangePercent": -12.93,
+          "readCountChangePercent": -25,
+          "readByteChangePercent": -49.54,
+          "baselineReads": 8,
+          "candidateReads": 6
+        },
+        "large-one": {
+          "p50ChangePercent": -7.45,
+          "p95ChangePercent": 4.39,
+          "readCountChangePercent": -16.67,
+          "readByteChangePercent": -49.66,
+          "baselineReads": 6,
+          "candidateReads": 5
+        },
+        "large-two": {
+          "p50ChangePercent": -15.11,
+          "p95ChangePercent": -5.57,
+          "readCountChangePercent": -25,
+          "readByteChangePercent": -49.84,
+          "baselineReads": 8,
+          "candidateReads": 6
+        }
+      }
+    },
+    "southeastasia": {
+      "cases": {
+        "write-small-one-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 7125.411,
+          "clientP95Ms": 8931.25,
+          "clientMeanMs": 7472.892,
+          "workerMeanMs": 7428.25,
+          "meanReads": 6,
+          "meanReadBytes": 5775,
+          "meanReadDurationMs": 3021.625,
+          "meanWrites": 5,
+          "meanWriteBytes": 3775,
+          "meanWriteDurationMs": 5393.5,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 243,
+              "meanReadDurationMs": 567.25
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 4047,
+              "meanReadDurationMs": 786.25
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 1486,
+              "meanReadDurationMs": 1668.125
+            }
+          },
+          "failures": {}
+        },
+        "write-medium-one-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 6399.23,
+          "clientP95Ms": 8497.837,
+          "clientMeanMs": 7071.482,
+          "workerMeanMs": 7028.125,
+          "meanReads": 6,
+          "meanReadBytes": 134340,
+          "meanReadDurationMs": 2952.875,
+          "meanWrites": 5,
+          "meanWriteBytes": 68515,
+          "meanWriteDurationMs": 5156.75,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 244,
+              "meanReadDurationMs": 512.75
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 131702,
+              "meanReadDurationMs": 789.125
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 2395,
+              "meanReadDurationMs": 1651
+            }
+          },
+          "failures": {}
+        },
+        "write-large-one-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 6630.599,
+          "clientP95Ms": 10097.646,
+          "clientMeanMs": 7745.248,
+          "workerMeanMs": 7697.75,
+          "meanReads": 6,
+          "meanReadBytes": 656664,
+          "meanReadDurationMs": 3471.375,
+          "meanWrites": 5,
+          "meanWriteBytes": 330630,
+          "meanWriteDurationMs": 5589.75,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 243,
+              "meanReadDurationMs": 546.625
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 652130,
+              "meanReadDurationMs": 937.375
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 4291,
+              "meanReadDurationMs": 1987.375
+            }
+          },
+          "failures": {}
+        },
+        "write-small-one-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 5729.068,
+          "clientP95Ms": 8670.088,
+          "clientMeanMs": 6558.582,
+          "workerMeanMs": 6514.75,
+          "meanReads": 5,
+          "meanReadBytes": 3752,
+          "meanReadDurationMs": 2631.125,
+          "meanWrites": 5,
+          "meanWriteBytes": 3775,
+          "meanWriteDurationMs": 4917.75,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 243,
+              "meanReadDurationMs": 507.375
+            },
+            "index": {
+              "meanReadCount": 1,
+              "meanReadBytes": 2023,
+              "meanReadDurationMs": 496.75
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 1486,
+              "meanReadDurationMs": 1627
+            }
+          },
+          "failures": {}
+        },
+        "write-medium-one-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 5589.191,
+          "clientP95Ms": 8901.203,
+          "clientMeanMs": 6666.12,
+          "workerMeanMs": 6621.375,
+          "meanReads": 5,
+          "meanReadBytes": 68489,
+          "meanReadDurationMs": 2704.25,
+          "meanWrites": 5,
+          "meanWriteBytes": 68515,
+          "meanWriteDurationMs": 4989.5,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 244,
+              "meanReadDurationMs": 558.875
+            },
+            "index": {
+              "meanReadCount": 1,
+              "meanReadBytes": 65851,
+              "meanReadDurationMs": 560.125
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 2395,
+              "meanReadDurationMs": 1585.25
+            }
+          },
+          "failures": {}
+        },
+        "write-large-one-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 6233.708,
+          "clientP95Ms": 9409.368,
+          "clientMeanMs": 7377.479,
+          "workerMeanMs": 7332.125,
+          "meanReads": 5,
+          "meanReadBytes": 330599,
+          "meanReadDurationMs": 3167.125,
+          "meanWrites": 5,
+          "meanWriteBytes": 330630,
+          "meanWriteDurationMs": 5575.875,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 243,
+              "meanReadDurationMs": 562.5
+            },
+            "index": {
+              "meanReadCount": 1,
+              "meanReadBytes": 326065,
+              "meanReadDurationMs": 596.625
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 4291,
+              "meanReadDurationMs": 2008
+            }
+          },
+          "failures": {}
+        },
+        "write-small-two-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 6802.855,
+          "clientP95Ms": 10125.045,
+          "clientMeanMs": 7818.3,
+          "workerMeanMs": 7774.25,
+          "meanReads": 8,
+          "meanReadBytes": 10485,
+          "meanReadDurationMs": 3735.25,
+          "meanWrites": 6,
+          "meanWriteBytes": 6166,
+          "meanWriteDurationMs": 6278.625,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 309,
+              "meanReadDurationMs": 506.25
+            },
+            "index": {
+              "meanReadCount": 4,
+              "meanReadBytes": 8691,
+              "meanReadDurationMs": 1680.875
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 1486,
+              "meanReadDurationMs": 1548.125
+            }
+          },
+          "failures": {}
+        },
+        "write-medium-two-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 6891.497,
+          "clientP95Ms": 9702.225,
+          "clientMeanMs": 7842.695,
+          "workerMeanMs": 7798.25,
+          "meanReads": 8,
+          "meanReadBytes": 294647,
+          "meanReadDurationMs": 3852.375,
+          "meanWrites": 6,
+          "meanWriteBytes": 148715,
+          "meanWriteDurationMs": 6267.875,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 311,
+              "meanReadDurationMs": 572.75
+            },
+            "index": {
+              "meanReadCount": 4,
+              "meanReadBytes": 291942,
+              "meanReadDurationMs": 1623.25
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 2395,
+              "meanReadDurationMs": 1656.375
+            }
+          },
+          "failures": {}
+        },
+        "write-large-two-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 8285.631,
+          "clientP95Ms": 11736.38,
+          "clientMeanMs": 9335.148,
+          "workerMeanMs": 9287.375,
+          "meanReads": 8,
+          "meanReadBytes": 1450742,
+          "meanReadDurationMs": 5037,
+          "meanWrites": 6,
+          "meanWriteBytes": 727716,
+          "meanWriteDurationMs": 8193.5,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 312,
+              "meanReadDurationMs": 521.75
+            },
+            "index": {
+              "meanReadCount": 4,
+              "meanReadBytes": 1446140,
+              "meanReadDurationMs": 2036.75
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 4291,
+              "meanReadDurationMs": 2478.5
+            }
+          },
+          "failures": {}
+        },
+        "write-small-two-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 6231.551,
+          "clientP95Ms": 9147.509,
+          "clientMeanMs": 7360.822,
+          "workerMeanMs": 7318.375,
+          "meanReads": 6,
+          "meanReadBytes": 6140,
+          "meanReadDurationMs": 3187.875,
+          "meanWrites": 6,
+          "meanWriteBytes": 6166,
+          "meanWriteDurationMs": 6370.375,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 309,
+              "meanReadDurationMs": 512.75
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 4345,
+              "meanReadDurationMs": 1097.25
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 1486,
+              "meanReadDurationMs": 1577.875
+            }
+          },
+          "failures": {}
+        },
+        "write-medium-two-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 6298.736,
+          "clientP95Ms": 9981.078,
+          "clientMeanMs": 7445.488,
+          "workerMeanMs": 7400.625,
+          "meanReads": 6,
+          "meanReadBytes": 148677,
+          "meanReadDurationMs": 3447.875,
+          "meanWrites": 6,
+          "meanWriteBytes": 148715,
+          "meanWriteDurationMs": 6659,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 311,
+              "meanReadDurationMs": 517.625
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 145971,
+              "meanReadDurationMs": 1134.875
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 2395,
+              "meanReadDurationMs": 1795.375
+            }
+          },
+          "failures": {}
+        },
+        "write-large-two-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 7799.964,
+          "clientP95Ms": 11146.876,
+          "clientMeanMs": 8536.262,
+          "workerMeanMs": 8489.125,
+          "meanReads": 6,
+          "meanReadBytes": 727673,
+          "meanReadDurationMs": 4379,
+          "meanWrites": 6,
+          "meanWriteBytes": 727716,
+          "meanWriteDurationMs": 8020.75,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 312,
+              "meanReadDurationMs": 496.875
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 723070,
+              "meanReadDurationMs": 1318.5
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 4291,
+              "meanReadDurationMs": 2563.625
+            }
+          },
+          "failures": {}
+        }
+      },
+      "comparisons": {
+        "small-one": {
+          "p50ChangePercent": -19.6,
+          "p95ChangePercent": -2.92,
+          "readCountChangePercent": -16.67,
+          "readByteChangePercent": -35.03,
+          "baselineReads": 6,
+          "candidateReads": 5
+        },
+        "small-two": {
+          "p50ChangePercent": -8.4,
+          "p95ChangePercent": -9.65,
+          "readCountChangePercent": -25,
+          "readByteChangePercent": -41.44,
+          "baselineReads": 8,
+          "candidateReads": 6
+        },
+        "medium-one": {
+          "p50ChangePercent": -12.66,
+          "p95ChangePercent": 4.75,
+          "readCountChangePercent": -16.67,
+          "readByteChangePercent": -49.02,
+          "baselineReads": 6,
+          "candidateReads": 5
+        },
+        "medium-two": {
+          "p50ChangePercent": -8.6,
+          "p95ChangePercent": 2.87,
+          "readCountChangePercent": -25,
+          "readByteChangePercent": -49.54,
+          "baselineReads": 8,
+          "candidateReads": 6
+        },
+        "large-one": {
+          "p50ChangePercent": -5.99,
+          "p95ChangePercent": -6.82,
+          "readCountChangePercent": -16.67,
+          "readByteChangePercent": -49.65,
+          "baselineReads": 6,
+          "candidateReads": 5
+        },
+        "large-two": {
+          "p50ChangePercent": -5.86,
+          "p95ChangePercent": -5.02,
+          "readCountChangePercent": -25,
+          "readByteChangePercent": -49.84,
+          "baselineReads": 8,
+          "candidateReads": 6
+        }
+      }
+    },
+    "japaneast": {
+      "cases": {
+        "write-small-one-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 4703.311,
+          "clientP95Ms": 7663.158,
+          "clientMeanMs": 5846.236,
+          "workerMeanMs": 5833.75,
+          "meanReads": 6,
+          "meanReadBytes": 5783,
+          "meanReadDurationMs": 2718.875,
+          "meanWrites": 5,
+          "meanWriteBytes": 3785,
+          "meanWriteDurationMs": 3917.25,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 243,
+              "meanReadDurationMs": 541.75
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 4042,
+              "meanReadDurationMs": 646.5
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 1498,
+              "meanReadDurationMs": 1530.625
+            }
+          },
+          "failures": {}
+        },
+        "write-medium-one-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 4840.112,
+          "clientP95Ms": 7905.845,
+          "clientMeanMs": 5906.419,
+          "workerMeanMs": 5892.5,
+          "meanReads": 6,
+          "meanReadBytes": 134445,
+          "meanReadDurationMs": 2586.375,
+          "meanWrites": 5,
+          "meanWriteBytes": 68625,
+          "meanWriteDurationMs": 4143.375,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 243,
+              "meanReadDurationMs": 400.5
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 131701,
+              "meanReadDurationMs": 675.625
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 2501,
+              "meanReadDurationMs": 1510.25
+            }
+          },
+          "failures": {}
+        },
+        "write-large-one-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 5314.065,
+          "clientP95Ms": 7981.337,
+          "clientMeanMs": 5926.46,
+          "workerMeanMs": 5909.875,
+          "meanReads": 6,
+          "meanReadBytes": 656685,
+          "meanReadDurationMs": 2818.875,
+          "meanWrites": 5,
+          "meanWriteBytes": 330658,
+          "meanWriteDurationMs": 4275.625,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 244,
+              "meanReadDurationMs": 459.625
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 652123,
+              "meanReadDurationMs": 714.75
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 4318,
+              "meanReadDurationMs": 1644.5
+            }
+          },
+          "failures": {}
+        },
+        "write-small-one-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 4601.84,
+          "clientP95Ms": 7265.315,
+          "clientMeanMs": 5440.96,
+          "workerMeanMs": 5428.25,
+          "meanReads": 5,
+          "meanReadBytes": 3762,
+          "meanReadDurationMs": 2340.125,
+          "meanWrites": 5,
+          "meanWriteBytes": 3785,
+          "meanWriteDurationMs": 3820.125,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 243,
+              "meanReadDurationMs": 467.625
+            },
+            "index": {
+              "meanReadCount": 1,
+              "meanReadBytes": 2021,
+              "meanReadDurationMs": 448.5
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 1498,
+              "meanReadDurationMs": 1424
+            }
+          },
+          "failures": {}
+        },
+        "write-medium-one-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 4519.853,
+          "clientP95Ms": 7559.02,
+          "clientMeanMs": 5498.471,
+          "workerMeanMs": 5484.75,
+          "meanReads": 5,
+          "meanReadBytes": 68594,
+          "meanReadDurationMs": 2371.125,
+          "meanWrites": 5,
+          "meanWriteBytes": 68625,
+          "meanWriteDurationMs": 3897.125,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 243,
+              "meanReadDurationMs": 430.875
+            },
+            "index": {
+              "meanReadCount": 1,
+              "meanReadBytes": 65851,
+              "meanReadDurationMs": 453.375
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 2501,
+              "meanReadDurationMs": 1486.875
+            }
+          },
+          "failures": {}
+        },
+        "write-large-one-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 4996.215,
+          "clientP95Ms": 7739.067,
+          "clientMeanMs": 5857.87,
+          "workerMeanMs": 5839.375,
+          "meanReads": 5,
+          "meanReadBytes": 330624,
+          "meanReadDurationMs": 2788.125,
+          "meanWrites": 5,
+          "meanWriteBytes": 330658,
+          "meanWriteDurationMs": 4042.875,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 244,
+              "meanReadDurationMs": 455.75
+            },
+            "index": {
+              "meanReadCount": 1,
+              "meanReadBytes": 326062,
+              "meanReadDurationMs": 576.625
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 4318,
+              "meanReadDurationMs": 1755.75
+            }
+          },
+          "failures": {}
+        },
+        "write-small-two-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 5715.647,
+          "clientP95Ms": 8081.634,
+          "clientMeanMs": 6347.561,
+          "workerMeanMs": 6335.125,
+          "meanReads": 8,
+          "meanReadBytes": 10480,
+          "meanReadDurationMs": 3320.75,
+          "meanWrites": 6,
+          "meanWriteBytes": 6165,
+          "meanWriteDurationMs": 4614.875,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 308,
+              "meanReadDurationMs": 456.75
+            },
+            "index": {
+              "meanReadCount": 4,
+              "meanReadBytes": 8676,
+              "meanReadDurationMs": 1367
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 1497,
+              "meanReadDurationMs": 1497
+            }
+          },
+          "failures": {}
+        },
+        "write-medium-two-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 5950.512,
+          "clientP95Ms": 8545.85,
+          "clientMeanMs": 6826.315,
+          "workerMeanMs": 6812.25,
+          "meanReads": 8,
+          "meanReadBytes": 294751,
+          "meanReadDurationMs": 3499.625,
+          "meanWrites": 6,
+          "meanWriteBytes": 148820,
+          "meanWriteDurationMs": 5138.75,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 310,
+              "meanReadDurationMs": 454.625
+            },
+            "index": {
+              "meanReadCount": 4,
+              "meanReadBytes": 291942,
+              "meanReadDurationMs": 1401.625
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 2500,
+              "meanReadDurationMs": 1643.375
+            }
+          },
+          "failures": {}
+        },
+        "write-large-two-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 7226.699,
+          "clientP95Ms": 11467.727,
+          "clientMeanMs": 8162.932,
+          "workerMeanMs": 8144.25,
+          "meanReads": 8,
+          "meanReadBytes": 1450756,
+          "meanReadDurationMs": 4842.75,
+          "meanWrites": 6,
+          "meanWriteBytes": 727737,
+          "meanWriteDurationMs": 5949.375,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 311,
+              "meanReadDurationMs": 475.5
+            },
+            "index": {
+              "meanReadCount": 4,
+              "meanReadBytes": 1446127,
+              "meanReadDurationMs": 2237.625
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 4319,
+              "meanReadDurationMs": 2129.625
+            }
+          },
+          "failures": {}
+        },
+        "write-small-two-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 5303.121,
+          "clientP95Ms": 8235.105,
+          "clientMeanMs": 6177.495,
+          "workerMeanMs": 6166,
+          "meanReads": 6,
+          "meanReadBytes": 6143,
+          "meanReadDurationMs": 2803,
+          "meanWrites": 6,
+          "meanWriteBytes": 6165,
+          "meanWriteDurationMs": 5025.5,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 308,
+              "meanReadDurationMs": 462.25
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 4338,
+              "meanReadDurationMs": 937
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 1497,
+              "meanReadDurationMs": 1403.75
+            }
+          },
+          "failures": {}
+        },
+        "write-medium-two-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 5156.84,
+          "clientP95Ms": 8024.339,
+          "clientMeanMs": 6120.059,
+          "workerMeanMs": 6106.375,
+          "meanReads": 6,
+          "meanReadBytes": 148781,
+          "meanReadDurationMs": 3065.25,
+          "meanWrites": 6,
+          "meanWriteBytes": 148820,
+          "meanWriteDurationMs": 4976.5,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 310,
+              "meanReadDurationMs": 488.875
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 145971,
+              "meanReadDurationMs": 1098.875
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 2500,
+              "meanReadDurationMs": 1477.5
+            }
+          },
+          "failures": {}
+        },
+        "write-large-two-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 6226.906,
+          "clientP95Ms": 8950.587,
+          "clientMeanMs": 7013.301,
+          "workerMeanMs": 6993.75,
+          "meanReads": 6,
+          "meanReadBytes": 727693,
+          "meanReadDurationMs": 3600.125,
+          "meanWrites": 6,
+          "meanWriteBytes": 727737,
+          "meanWriteDurationMs": 5929.125,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 311,
+              "meanReadDurationMs": 507.5
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 723063,
+              "meanReadDurationMs": 1181.5
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 4319,
+              "meanReadDurationMs": 1911.125
+            }
+          },
+          "failures": {}
+        }
+      },
+      "comparisons": {
+        "small-one": {
+          "p50ChangePercent": -2.16,
+          "p95ChangePercent": -5.19,
+          "readCountChangePercent": -16.67,
+          "readByteChangePercent": -34.95,
+          "baselineReads": 6,
+          "candidateReads": 5
+        },
+        "small-two": {
+          "p50ChangePercent": -7.22,
+          "p95ChangePercent": 1.9,
+          "readCountChangePercent": -25,
+          "readByteChangePercent": -41.38,
+          "baselineReads": 8,
+          "candidateReads": 6
+        },
+        "medium-one": {
+          "p50ChangePercent": -6.62,
+          "p95ChangePercent": -4.39,
+          "readCountChangePercent": -16.67,
+          "readByteChangePercent": -48.98,
+          "baselineReads": 6,
+          "candidateReads": 5
+        },
+        "medium-two": {
+          "p50ChangePercent": -13.34,
+          "p95ChangePercent": -6.1,
+          "readCountChangePercent": -25,
+          "readByteChangePercent": -49.52,
+          "baselineReads": 8,
+          "candidateReads": 6
+        },
+        "large-one": {
+          "p50ChangePercent": -5.98,
+          "p95ChangePercent": -3.04,
+          "readCountChangePercent": -16.67,
+          "readByteChangePercent": -49.65,
+          "baselineReads": 6,
+          "candidateReads": 5
+        },
+        "large-two": {
+          "p50ChangePercent": -13.83,
+          "p95ChangePercent": -21.95,
+          "readCountChangePercent": -25,
+          "readByteChangePercent": -49.84,
+          "baselineReads": 8,
+          "candidateReads": 6
+        }
+      }
+    },
+    "australiaeast": {
+      "cases": {
+        "write-small-one-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 5792.251,
+          "clientP95Ms": 9125.474,
+          "clientMeanMs": 6989.591,
+          "workerMeanMs": 6975.125,
+          "meanReads": 6,
+          "meanReadBytes": 5711,
+          "meanReadDurationMs": 2710.875,
+          "meanWrites": 5,
+          "meanWriteBytes": 3715,
+          "meanWriteDurationMs": 5261,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 243,
+              "meanReadDurationMs": 536.625
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 4043,
+              "meanReadDurationMs": 731.875
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 1425,
+              "meanReadDurationMs": 1442.375
+            }
+          },
+          "failures": {}
+        },
+        "write-medium-one-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 5400.743,
+          "clientP95Ms": 8800.966,
+          "clientMeanMs": 6515.754,
+          "workerMeanMs": 6498.75,
+          "meanReads": 6,
+          "meanReadBytes": 134335,
+          "meanReadDurationMs": 2688.25,
+          "meanWrites": 5,
+          "meanWriteBytes": 68511,
+          "meanWriteDurationMs": 4845.125,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 244,
+              "meanReadDurationMs": 472.75
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 131701,
+              "meanReadDurationMs": 750.375
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 2390,
+              "meanReadDurationMs": 1465.125
+            }
+          },
+          "failures": {}
+        },
+        "write-large-one-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 5588.196,
+          "clientP95Ms": 9505.719,
+          "clientMeanMs": 6766.685,
+          "workerMeanMs": 6748.25,
+          "meanReads": 6,
+          "meanReadBytes": 656626,
+          "meanReadDurationMs": 2907.25,
+          "meanWrites": 5,
+          "meanWriteBytes": 330594,
+          "meanWriteDurationMs": 5480.125,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 244,
+              "meanReadDurationMs": 436.625
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 652126,
+              "meanReadDurationMs": 772.125
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 4257,
+              "meanReadDurationMs": 1698.5
+            }
+          },
+          "failures": {}
+        },
+        "write-small-one-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 5254.724,
+          "clientP95Ms": 9285.271,
+          "clientMeanMs": 6257.602,
+          "workerMeanMs": 6242.125,
+          "meanReads": 5,
+          "meanReadBytes": 3690,
+          "meanReadDurationMs": 2307.25,
+          "meanWrites": 5,
+          "meanWriteBytes": 3715,
+          "meanWriteDurationMs": 4894.125,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 243,
+              "meanReadDurationMs": 456.625
+            },
+            "index": {
+              "meanReadCount": 1,
+              "meanReadBytes": 2021,
+              "meanReadDurationMs": 444.5
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 1425,
+              "meanReadDurationMs": 1406.125
+            }
+          },
+          "failures": {}
+        },
+        "write-medium-one-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 5103.61,
+          "clientP95Ms": 8558.276,
+          "clientMeanMs": 6218.636,
+          "workerMeanMs": 6203,
+          "meanReads": 5,
+          "meanReadBytes": 68484,
+          "meanReadDurationMs": 2438.75,
+          "meanWrites": 5,
+          "meanWriteBytes": 68511,
+          "meanWriteDurationMs": 4756.125,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 244,
+              "meanReadDurationMs": 458.625
+            },
+            "index": {
+              "meanReadCount": 1,
+              "meanReadBytes": 65851,
+              "meanReadDurationMs": 462.25
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 2390,
+              "meanReadDurationMs": 1517.875
+            }
+          },
+          "failures": {}
+        },
+        "write-large-one-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 5863.385,
+          "clientP95Ms": 8739.421,
+          "clientMeanMs": 6733.204,
+          "workerMeanMs": 6716.625,
+          "meanReads": 5,
+          "meanReadBytes": 330563,
+          "meanReadDurationMs": 2762.625,
+          "meanWrites": 5,
+          "meanWriteBytes": 330594,
+          "meanWriteDurationMs": 5262.75,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 244,
+              "meanReadDurationMs": 497.625
+            },
+            "index": {
+              "meanReadCount": 1,
+              "meanReadBytes": 326063,
+              "meanReadDurationMs": 568.625
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 4257,
+              "meanReadDurationMs": 1696.375
+            }
+          },
+          "failures": {}
+        },
+        "write-small-two-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 5754.999,
+          "clientP95Ms": 9581.24,
+          "clientMeanMs": 7085.034,
+          "workerMeanMs": 7069.5,
+          "meanReads": 8,
+          "meanReadBytes": 10418,
+          "meanReadDurationMs": 3242.75,
+          "meanWrites": 6,
+          "meanWriteBytes": 6103,
+          "meanWriteDurationMs": 5881.25,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 309,
+              "meanReadDurationMs": 465.25
+            },
+            "index": {
+              "meanReadCount": 4,
+              "meanReadBytes": 8685,
+              "meanReadDurationMs": 1435.75
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 1424,
+              "meanReadDurationMs": 1341.75
+            }
+          },
+          "failures": {}
+        },
+        "write-medium-two-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 6260.516,
+          "clientP95Ms": 9837.282,
+          "clientMeanMs": 7432.361,
+          "workerMeanMs": 7417.375,
+          "meanReads": 8,
+          "meanReadBytes": 294640,
+          "meanReadDurationMs": 3414.125,
+          "meanWrites": 6,
+          "meanWriteBytes": 148703,
+          "meanWriteDurationMs": 6125.125,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 310,
+              "meanReadDurationMs": 456.5
+            },
+            "index": {
+              "meanReadCount": 4,
+              "meanReadBytes": 291942,
+              "meanReadDurationMs": 1468.875
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 2389,
+              "meanReadDurationMs": 1488.75
+            }
+          },
+          "failures": {}
+        },
+        "write-large-two-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 7125.824,
+          "clientP95Ms": 10839.057,
+          "clientMeanMs": 8224.776,
+          "workerMeanMs": 8205.125,
+          "meanReads": 8,
+          "meanReadBytes": 1450703,
+          "meanReadDurationMs": 4298.75,
+          "meanWrites": 6,
+          "meanWriteBytes": 727678,
+          "meanWriteDurationMs": 7402.25,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 312,
+              "meanReadDurationMs": 457.5
+            },
+            "index": {
+              "meanReadCount": 4,
+              "meanReadBytes": 1446134,
+              "meanReadDurationMs": 1804.125
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 4257,
+              "meanReadDurationMs": 2037.125
+            }
+          },
+          "failures": {}
+        },
+        "write-small-two-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 5713.243,
+          "clientP95Ms": 9128.445,
+          "clientMeanMs": 6647.797,
+          "workerMeanMs": 6633.625,
+          "meanReads": 6,
+          "meanReadBytes": 6075,
+          "meanReadDurationMs": 2713.75,
+          "meanWrites": 6,
+          "meanWriteBytes": 6103,
+          "meanWriteDurationMs": 5796.75,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 309,
+              "meanReadDurationMs": 447
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 4343,
+              "meanReadDurationMs": 882.875
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 1424,
+              "meanReadDurationMs": 1383.875
+            }
+          },
+          "failures": {}
+        },
+        "write-medium-two-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 6576.373,
+          "clientP95Ms": 8980.712,
+          "clientMeanMs": 6963.593,
+          "workerMeanMs": 6949.5,
+          "meanReads": 6,
+          "meanReadBytes": 148669,
+          "meanReadDurationMs": 2897.25,
+          "meanWrites": 6,
+          "meanWriteBytes": 148703,
+          "meanWriteDurationMs": 6279.25,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 310,
+              "meanReadDurationMs": 441.25
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 145971,
+              "meanReadDurationMs": 911.625
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 2389,
+              "meanReadDurationMs": 1544.375
+            }
+          },
+          "failures": {}
+        },
+        "write-large-two-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 7064.388,
+          "clientP95Ms": 9706.283,
+          "clientMeanMs": 7820.922,
+          "workerMeanMs": 7800.25,
+          "meanReads": 6,
+          "meanReadBytes": 727636,
+          "meanReadDurationMs": 3735.375,
+          "meanWrites": 6,
+          "meanWriteBytes": 727678,
+          "meanWriteDurationMs": 7363,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 312,
+              "meanReadDurationMs": 523.75
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 723067,
+              "meanReadDurationMs": 1197.625
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 4257,
+              "meanReadDurationMs": 2014
+            }
+          },
+          "failures": {}
+        }
+      },
+      "comparisons": {
+        "small-one": {
+          "p50ChangePercent": -9.28,
+          "p95ChangePercent": 1.75,
+          "readCountChangePercent": -16.67,
+          "readByteChangePercent": -35.39,
+          "baselineReads": 6,
+          "candidateReads": 5
+        },
+        "small-two": {
+          "p50ChangePercent": -0.73,
+          "p95ChangePercent": -4.73,
+          "readCountChangePercent": -25,
+          "readByteChangePercent": -41.69,
+          "baselineReads": 8,
+          "candidateReads": 6
+        },
+        "medium-one": {
+          "p50ChangePercent": -5.5,
+          "p95ChangePercent": -2.76,
+          "readCountChangePercent": -16.67,
+          "readByteChangePercent": -49.02,
+          "baselineReads": 6,
+          "candidateReads": 5
+        },
+        "medium-two": {
+          "p50ChangePercent": 5.05,
+          "p95ChangePercent": -8.71,
+          "readCountChangePercent": -25,
+          "readByteChangePercent": -49.54,
+          "baselineReads": 8,
+          "candidateReads": 6
+        },
+        "large-one": {
+          "p50ChangePercent": 4.92,
+          "p95ChangePercent": -8.06,
+          "readCountChangePercent": -16.67,
+          "readByteChangePercent": -49.66,
+          "baselineReads": 6,
+          "candidateReads": 5
+        },
+        "large-two": {
+          "p50ChangePercent": -0.86,
+          "p95ChangePercent": -10.45,
+          "readCountChangePercent": -25,
+          "readByteChangePercent": -49.84,
+          "baselineReads": 8,
+          "candidateReads": 6
+        }
+      }
+    },
+    "brazilsouth": {
+      "cases": {
+        "write-small-one-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 5965.38,
+          "clientP95Ms": 8076.56,
+          "clientMeanMs": 6481.022,
+          "workerMeanMs": 6465.375,
+          "meanReads": 6,
+          "meanReadBytes": 5742,
+          "meanReadDurationMs": 2613.75,
+          "meanWrites": 5,
+          "meanWriteBytes": 3742,
+          "meanWriteDurationMs": 4818.5,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 243,
+              "meanReadDurationMs": 499.625
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 4044,
+              "meanReadDurationMs": 678.125
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 1455,
+              "meanReadDurationMs": 1436
+            }
+          },
+          "failures": {}
+        },
+        "write-medium-one-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 5559.079,
+          "clientP95Ms": 8533.866,
+          "clientMeanMs": 6363.85,
+          "workerMeanMs": 6349,
+          "meanReads": 6,
+          "meanReadBytes": 134490,
+          "meanReadDurationMs": 2594,
+          "meanWrites": 5,
+          "meanWriteBytes": 68668,
+          "meanWriteDurationMs": 4746.875,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 243,
+              "meanReadDurationMs": 447.375
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 131701,
+              "meanReadDurationMs": 697.125
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 2546,
+              "meanReadDurationMs": 1449.5
+            }
+          },
+          "failures": {}
+        },
+        "write-large-one-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 5556.951,
+          "clientP95Ms": 8119.632,
+          "clientMeanMs": 6445.802,
+          "workerMeanMs": 6426.75,
+          "meanReads": 6,
+          "meanReadBytes": 656770,
+          "meanReadDurationMs": 2803.75,
+          "meanWrites": 5,
+          "meanWriteBytes": 330739,
+          "meanWriteDurationMs": 5037,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 245,
+              "meanReadDurationMs": 471.875
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 652128,
+              "meanReadDurationMs": 725.125
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 4398,
+              "meanReadDurationMs": 1606.75
+            }
+          },
+          "failures": {}
+        },
+        "write-small-one-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 5082.522,
+          "clientP95Ms": 9380.755,
+          "clientMeanMs": 6085.571,
+          "workerMeanMs": 6070.75,
+          "meanReads": 5,
+          "meanReadBytes": 3720,
+          "meanReadDurationMs": 2199.375,
+          "meanWrites": 5,
+          "meanWriteBytes": 3742,
+          "meanWriteDurationMs": 4716.75,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 243,
+              "meanReadDurationMs": 437.125
+            },
+            "index": {
+              "meanReadCount": 1,
+              "meanReadBytes": 2022,
+              "meanReadDurationMs": 415.125
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 1455,
+              "meanReadDurationMs": 1347.125
+            }
+          },
+          "failures": {}
+        },
+        "write-medium-one-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 5136.007,
+          "clientP95Ms": 8508.538,
+          "clientMeanMs": 6100.85,
+          "workerMeanMs": 6085.25,
+          "meanReads": 5,
+          "meanReadBytes": 68639,
+          "meanReadDurationMs": 2283.125,
+          "meanWrites": 5,
+          "meanWriteBytes": 68668,
+          "meanWriteDurationMs": 4740.5,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 243,
+              "meanReadDurationMs": 441.625
+            },
+            "index": {
+              "meanReadCount": 1,
+              "meanReadBytes": 65851,
+              "meanReadDurationMs": 446.375
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 2546,
+              "meanReadDurationMs": 1395.125
+            }
+          },
+          "failures": {}
+        },
+        "write-large-one-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 5689.518,
+          "clientP95Ms": 7969.278,
+          "clientMeanMs": 6249.7,
+          "workerMeanMs": 6232.25,
+          "meanReads": 5,
+          "meanReadBytes": 330706,
+          "meanReadDurationMs": 2666.625,
+          "meanWrites": 5,
+          "meanWriteBytes": 330739,
+          "meanWriteDurationMs": 4959.125,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 245,
+              "meanReadDurationMs": 468.125
+            },
+            "index": {
+              "meanReadCount": 1,
+              "meanReadBytes": 326064,
+              "meanReadDurationMs": 486.625
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 4398,
+              "meanReadDurationMs": 1711.875
+            }
+          },
+          "failures": {}
+        },
+        "write-small-two-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 5829.436,
+          "clientP95Ms": 10321.589,
+          "clientMeanMs": 7166.616,
+          "workerMeanMs": 7151.375,
+          "meanReads": 8,
+          "meanReadBytes": 10449,
+          "meanReadDurationMs": 3264,
+          "meanWrites": 6,
+          "meanWriteBytes": 6131,
+          "meanWriteDurationMs": 5685,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 308,
+              "meanReadDurationMs": 442.875
+            },
+            "index": {
+              "meanReadCount": 4,
+              "meanReadBytes": 8686,
+              "meanReadDurationMs": 1349.75
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 1455,
+              "meanReadDurationMs": 1471.375
+            }
+          },
+          "failures": {}
+        },
+        "write-medium-two-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 5933.391,
+          "clientP95Ms": 9328.616,
+          "clientMeanMs": 7009.943,
+          "workerMeanMs": 6993.875,
+          "meanReads": 8,
+          "meanReadBytes": 294795,
+          "meanReadDurationMs": 3303.875,
+          "meanWrites": 6,
+          "meanWriteBytes": 148862,
+          "meanWriteDurationMs": 5911.875,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 310,
+              "meanReadDurationMs": 462
+            },
+            "index": {
+              "meanReadCount": 4,
+              "meanReadBytes": 291941,
+              "meanReadDurationMs": 1377.125
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 2544,
+              "meanReadDurationMs": 1464.75
+            }
+          },
+          "failures": {}
+        },
+        "write-large-two-duplicate": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 6619.084,
+          "clientP95Ms": 10901.264,
+          "clientMeanMs": 7853.593,
+          "workerMeanMs": 7829,
+          "meanReads": 8,
+          "meanReadBytes": 1450841,
+          "meanReadDurationMs": 4074.25,
+          "meanWrites": 6,
+          "meanWriteBytes": 727820,
+          "meanWriteDurationMs": 7659.125,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 312,
+              "meanReadDurationMs": 461.75
+            },
+            "index": {
+              "meanReadCount": 4,
+              "meanReadBytes": 1446132,
+              "meanReadDurationMs": 1581.625
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 4397,
+              "meanReadDurationMs": 2030.875
+            }
+          },
+          "failures": {}
+        },
+        "write-small-two-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 5309.08,
+          "clientP95Ms": 8869.341,
+          "clientMeanMs": 6424.116,
+          "workerMeanMs": 6408.625,
+          "meanReads": 6,
+          "meanReadBytes": 6106,
+          "meanReadDurationMs": 2794.5,
+          "meanWrites": 6,
+          "meanWriteBytes": 6131,
+          "meanWriteDurationMs": 5402.5,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 308,
+              "meanReadDurationMs": 502.875
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 4343,
+              "meanReadDurationMs": 878.375
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 1455,
+              "meanReadDurationMs": 1413.25
+            }
+          },
+          "failures": {}
+        },
+        "write-medium-two-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 5942.5,
+          "clientP95Ms": 7952.112,
+          "clientMeanMs": 6441.878,
+          "workerMeanMs": 6424.875,
+          "meanReads": 6,
+          "meanReadBytes": 148824,
+          "meanReadDurationMs": 2966.25,
+          "meanWrites": 6,
+          "meanWriteBytes": 148862,
+          "meanWriteDurationMs": 5596.75,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 310,
+              "meanReadDurationMs": 427.75
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 145970,
+              "meanReadDurationMs": 1025.5
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 2544,
+              "meanReadDurationMs": 1513
+            }
+          },
+          "failures": {}
+        },
+        "write-large-two-reuse": {
+          "operations": 8,
+          "successful": 8,
+          "failed": 0,
+          "successRatePercent": 100,
+          "clientP50Ms": 6164.567,
+          "clientP95Ms": 10944.592,
+          "clientMeanMs": 7582.526,
+          "workerMeanMs": 7560.75,
+          "meanReads": 6,
+          "meanReadBytes": 727775,
+          "meanReadDurationMs": 3602.75,
+          "meanWrites": 6,
+          "meanWriteBytes": 727820,
+          "meanWriteDurationMs": 7069,
+          "byKind": {
+            "head": {
+              "meanReadCount": 1,
+              "meanReadBytes": 312,
+              "meanReadDurationMs": 440.5
+            },
+            "index": {
+              "meanReadCount": 2,
+              "meanReadBytes": 723066,
+              "meanReadDurationMs": 1136.5
+            },
+            "node": {
+              "meanReadCount": 3,
+              "meanReadBytes": 4397,
+              "meanReadDurationMs": 2025.75
+            }
+          },
+          "failures": {}
+        }
+      },
+      "comparisons": {
+        "small-one": {
+          "p50ChangePercent": -14.8,
+          "p95ChangePercent": 16.15,
+          "readCountChangePercent": -16.67,
+          "readByteChangePercent": -35.21,
+          "baselineReads": 6,
+          "candidateReads": 5
+        },
+        "small-two": {
+          "p50ChangePercent": -8.93,
+          "p95ChangePercent": -14.07,
+          "readCountChangePercent": -25,
+          "readByteChangePercent": -41.56,
+          "baselineReads": 8,
+          "candidateReads": 6
+        },
+        "medium-one": {
+          "p50ChangePercent": -7.61,
+          "p95ChangePercent": -0.3,
+          "readCountChangePercent": -16.67,
+          "readByteChangePercent": -48.96,
+          "baselineReads": 6,
+          "candidateReads": 5
+        },
+        "medium-two": {
+          "p50ChangePercent": 0.15,
+          "p95ChangePercent": -14.76,
+          "readCountChangePercent": -25,
+          "readByteChangePercent": -49.52,
+          "baselineReads": 8,
+          "candidateReads": 6
+        },
+        "large-one": {
+          "p50ChangePercent": 2.39,
+          "p95ChangePercent": -1.85,
+          "readCountChangePercent": -16.67,
+          "readByteChangePercent": -49.65,
+          "baselineReads": 6,
+          "candidateReads": 5
+        },
+        "large-two": {
+          "p50ChangePercent": -6.87,
+          "p95ChangePercent": 0.4,
+          "readCountChangePercent": -25,
+          "readByteChangePercent": -49.84,
+          "baselineReads": 8,
+          "candidateReads": 6
+        }
+      }
+    }
+  },
+  "verification": [
+    {
+      "replicate": "a",
+      "region": "eastus",
+      "profile": "small",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "eastus",
+      "profile": "small",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "eastus",
+      "profile": "medium",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "eastus",
+      "profile": "medium",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "eastus",
+      "profile": "large",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "eastus",
+      "profile": "large",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "westus2",
+      "profile": "small",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "westus2",
+      "profile": "small",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "westus2",
+      "profile": "medium",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "westus2",
+      "profile": "medium",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "westus2",
+      "profile": "large",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "westus2",
+      "profile": "large",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "northeurope",
+      "profile": "small",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "northeurope",
+      "profile": "small",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "northeurope",
+      "profile": "medium",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "northeurope",
+      "profile": "medium",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "northeurope",
+      "profile": "large",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "northeurope",
+      "profile": "large",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "southeastasia",
+      "profile": "small",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "southeastasia",
+      "profile": "small",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "southeastasia",
+      "profile": "medium",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "southeastasia",
+      "profile": "medium",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "southeastasia",
+      "profile": "large",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "southeastasia",
+      "profile": "large",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "japaneast",
+      "profile": "small",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "japaneast",
+      "profile": "small",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "japaneast",
+      "profile": "medium",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "japaneast",
+      "profile": "medium",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "japaneast",
+      "profile": "large",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "japaneast",
+      "profile": "large",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "australiaeast",
+      "profile": "small",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "australiaeast",
+      "profile": "small",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "australiaeast",
+      "profile": "medium",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "australiaeast",
+      "profile": "medium",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "australiaeast",
+      "profile": "large",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "australiaeast",
+      "profile": "large",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "brazilsouth",
+      "profile": "small",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "brazilsouth",
+      "profile": "small",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "brazilsouth",
+      "profile": "medium",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "brazilsouth",
+      "profile": "medium",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "brazilsouth",
+      "profile": "large",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "a",
+      "region": "brazilsouth",
+      "profile": "large",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "eastus",
+      "profile": "small",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "eastus",
+      "profile": "small",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "eastus",
+      "profile": "medium",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "eastus",
+      "profile": "medium",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "eastus",
+      "profile": "large",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "eastus",
+      "profile": "large",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "westus2",
+      "profile": "small",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "westus2",
+      "profile": "small",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "westus2",
+      "profile": "medium",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "westus2",
+      "profile": "medium",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "westus2",
+      "profile": "large",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "westus2",
+      "profile": "large",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "northeurope",
+      "profile": "small",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "northeurope",
+      "profile": "small",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "northeurope",
+      "profile": "medium",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "northeurope",
+      "profile": "medium",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "northeurope",
+      "profile": "large",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "northeurope",
+      "profile": "large",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "southeastasia",
+      "profile": "small",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "southeastasia",
+      "profile": "small",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "southeastasia",
+      "profile": "medium",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "southeastasia",
+      "profile": "medium",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "southeastasia",
+      "profile": "large",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "southeastasia",
+      "profile": "large",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "japaneast",
+      "profile": "small",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "japaneast",
+      "profile": "small",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "japaneast",
+      "profile": "medium",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "japaneast",
+      "profile": "medium",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "japaneast",
+      "profile": "large",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "japaneast",
+      "profile": "large",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "australiaeast",
+      "profile": "small",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "australiaeast",
+      "profile": "small",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "australiaeast",
+      "profile": "medium",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "australiaeast",
+      "profile": "medium",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "australiaeast",
+      "profile": "large",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "australiaeast",
+      "profile": "large",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "brazilsouth",
+      "profile": "small",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "brazilsouth",
+      "profile": "small",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "brazilsouth",
+      "profile": "medium",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "brazilsouth",
+      "profile": "medium",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "brazilsouth",
+      "profile": "large",
+      "indexSet": "one",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    },
+    {
+      "replicate": "b",
+      "region": "brazilsouth",
+      "profile": "large",
+      "indexSet": "two",
+      "documentsEqual": true,
+      "headsEqual": true,
+      "equivalent": true,
+      "success": true,
+      "status": 200
+    }
+  ],
+  "runs": [
+    {
+      "replicate": "a",
+      "region": "eastus",
+      "result": {
+        "generatedAt": "2026-09-30T02:50:24.507Z",
+        "sourceCommit": "bd8af6eec98b8f4a745d90327e96534c4a09fac0",
+        "harnessCommit": "a1a1d02d9ce71318956e5a5cb9574eed43314c04",
+        "runId": "index-reuse-a",
+        "replicate": "a",
+        "region": "eastus",
+        "colo": "IAD",
+        "runtime": "Node v22.23.3",
+        "iterations": 4,
+        "samples": {
+          "write-small-one-duplicate": [
+            {
+              "region": "eastus",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000000",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5168,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5646,
+                  "durationMs": 1894
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3649,
+                  "durationMs": 4233
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 358
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 926
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4040,
+                      "durationMs": 434
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2021,
+                      "durationMs": 959
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1363,
+                      "durationMs": 1102
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1384,
+                      "durationMs": 2348
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5185.977
+            },
+            {
+              "region": "eastus",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-000081",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2437,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5682,
+                  "durationMs": 1054
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3686,
+                  "durationMs": 1641
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 237
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 292
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4042,
+                      "durationMs": 298
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2024,
+                      "durationMs": 258
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1396,
+                      "durationMs": 519
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1418,
+                      "durationMs": 1091
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2454.497
+            },
+            {
+              "region": "eastus",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-000034",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2128,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5742,
+                  "durationMs": 992
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3744,
+                  "durationMs": 1406
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 148
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 319
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4048,
+                      "durationMs": 299
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2026,
+                      "durationMs": 270
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1450,
+                      "durationMs": 545
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1475,
+                      "durationMs": 817
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2144.682
+            },
+            {
+              "region": "eastus",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-000115",
+              "mode": "duplicate",
+              "workerIoTimerMs": 4847,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5706,
+                  "durationMs": 1487
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3699,
+                  "durationMs": 4097
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 271
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 983
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4052,
+                      "durationMs": 423
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2027,
+                      "durationMs": 737
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1411,
+                      "durationMs": 793
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1429,
+                      "durationMs": 2377
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4866.604
+            }
+          ],
+          "write-medium-one-duplicate": [
+            {
+              "region": "eastus",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000000",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5112,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134248,
+                  "durationMs": 1556
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68434,
+                  "durationMs": 4559
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 278
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 949
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131688,
+                      "durationMs": 424
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65850,
+                      "durationMs": 1003
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2317,
+                      "durationMs": 854
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2340,
+                      "durationMs": 2607
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5127.871
+            },
+            {
+              "region": "eastus",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-000977",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5340,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134482,
+                  "durationMs": 1826
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68657,
+                  "durationMs": 4414
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 236
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1031
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131700,
+                      "durationMs": 829
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65854,
+                      "durationMs": 900
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2538,
+                      "durationMs": 761
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2559,
+                      "durationMs": 2483
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5355.551
+            },
+            {
+              "region": "eastus",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-001954",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2386,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134514,
+                  "durationMs": 1065
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68683,
+                  "durationMs": 1648
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 184
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 303
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131708,
+                      "durationMs": 298
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65856,
+                      "durationMs": 327
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2562,
+                      "durationMs": 583
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2584,
+                      "durationMs": 1018
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2410.364
+            },
+            {
+              "region": "eastus",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-002931",
+              "mode": "duplicate",
+              "workerIoTimerMs": 4890,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134419,
+                  "durationMs": 1573
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68587,
+                  "durationMs": 4140
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 328
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 1061
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131712,
+                      "durationMs": 395
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65860,
+                      "durationMs": 823
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2464,
+                      "durationMs": 850
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2484,
+                      "durationMs": 2256
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4906.005
+            }
+          ],
+          "write-large-one-duplicate": [
+            {
+              "region": "eastus",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000000",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5347,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656367,
+                  "durationMs": 1714
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330341,
+                  "durationMs": 4701
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 247
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1136
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652116,
+                      "durationMs": 466
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326061,
+                      "durationMs": 1068
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4007,
+                      "durationMs": 1001
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4036,
+                      "durationMs": 2497
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5363.53
+            },
+            {
+              "region": "eastus",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-000977",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5225,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656564,
+                  "durationMs": 1662
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330531,
+                  "durationMs": 4614
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 209
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1018
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652122,
+                      "durationMs": 477
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326062,
+                      "durationMs": 1051
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4198,
+                      "durationMs": 976
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4225,
+                      "durationMs": 2545
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5248.252
+            },
+            {
+              "region": "eastus",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-001954",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2563,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 657042,
+                  "durationMs": 1340
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 331012,
+                  "durationMs": 1640
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 167
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 314
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652124,
+                      "durationMs": 344
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326067,
+                      "durationMs": 417
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4674,
+                      "durationMs": 829
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4700,
+                      "durationMs": 909
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2619.719
+            },
+            {
+              "region": "eastus",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-002931",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5083,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656618,
+                  "durationMs": 1671
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330578,
+                  "durationMs": 4432
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 252
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 935
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652134,
+                      "durationMs": 468
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326069,
+                      "durationMs": 1020
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4239,
+                      "durationMs": 951
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4265,
+                      "durationMs": 2477
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5097.575
+            }
+          ],
+          "write-small-one-reuse": [
+            {
+              "region": "eastus",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000000",
+              "mode": "reuse",
+              "workerIoTimerMs": 4656,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3626,
+                  "durationMs": 1319
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3649,
+                  "durationMs": 4118
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 259
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 938
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2020,
+                      "durationMs": 297
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2021,
+                      "durationMs": 781
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1363,
+                      "durationMs": 763
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1384,
+                      "durationMs": 2399
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4666.812
+            },
+            {
+              "region": "eastus",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-000081",
+              "mode": "reuse",
+              "workerIoTimerMs": 5299,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3661,
+                  "durationMs": 1329
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3686,
+                  "durationMs": 4782
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 283
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1084
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2021,
+                      "durationMs": 242
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2024,
+                      "durationMs": 812
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1396,
+                      "durationMs": 804
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1418,
+                      "durationMs": 2886
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5309.932
+            },
+            {
+              "region": "eastus",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-000034",
+              "mode": "reuse",
+              "workerIoTimerMs": 2168,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3718,
+                  "durationMs": 1023
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3744,
+                  "durationMs": 1410
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 189
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 331
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2024,
+                      "durationMs": 286
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2026,
+                      "durationMs": 265
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1450,
+                      "durationMs": 548
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1475,
+                      "durationMs": 814
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2184.913
+            },
+            {
+              "region": "eastus",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-000115",
+              "mode": "reuse",
+              "workerIoTimerMs": 2078,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3680,
+                  "durationMs": 869
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3699,
+                  "durationMs": 1492
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 156
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 351
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2026,
+                      "durationMs": 179
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2027,
+                      "durationMs": 283
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1411,
+                      "durationMs": 534
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1429,
+                      "durationMs": 858
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2094.114
+            }
+          ],
+          "write-medium-one-reuse": [
+            {
+              "region": "eastus",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000000",
+              "mode": "reuse",
+              "workerIoTimerMs": 5207,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68404,
+                  "durationMs": 1590
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68434,
+                  "durationMs": 4534
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 481
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1085
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65844,
+                      "durationMs": 273
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65850,
+                      "durationMs": 917
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2317,
+                      "durationMs": 836
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2340,
+                      "durationMs": 2532
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5220.689
+            },
+            {
+              "region": "eastus",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-000977",
+              "mode": "reuse",
+              "workerIoTimerMs": 4894,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68632,
+                  "durationMs": 1322
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68657,
+                  "durationMs": 4500
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 256
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 939
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65850,
+                      "durationMs": 288
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65854,
+                      "durationMs": 928
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2538,
+                      "durationMs": 778
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2559,
+                      "durationMs": 2633
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4908.025
+            },
+            {
+              "region": "eastus",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-001954",
+              "mode": "reuse",
+              "workerIoTimerMs": 2157,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68660,
+                  "durationMs": 980
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68683,
+                  "durationMs": 1515
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 164
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 296
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65854,
+                      "durationMs": 195
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65856,
+                      "durationMs": 338
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2562,
+                      "durationMs": 621
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2584,
+                      "durationMs": 881
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2187.197
+            },
+            {
+              "region": "eastus",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-002931",
+              "mode": "reuse",
+              "workerIoTimerMs": 2232,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68563,
+                  "durationMs": 917
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68587,
+                  "durationMs": 1651
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 172
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 291
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65856,
+                      "durationMs": 173
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65860,
+                      "durationMs": 336
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2464,
+                      "durationMs": 572
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2484,
+                      "durationMs": 1024
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2252.374
+            }
+          ],
+          "write-large-one-reuse": [
+            {
+              "region": "eastus",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000000",
+              "mode": "reuse",
+              "workerIoTimerMs": 5262,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330309,
+                  "durationMs": 1536
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330341,
+                  "durationMs": 4775
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 257
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1013
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326058,
+                      "durationMs": 277
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326061,
+                      "durationMs": 1049
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4007,
+                      "durationMs": 1002
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4036,
+                      "durationMs": 2713
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5276.526
+            },
+            {
+              "region": "eastus",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-000977",
+              "mode": "reuse",
+              "workerIoTimerMs": 5515,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330503,
+                  "durationMs": 2058
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330531,
+                  "durationMs": 4517
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 294
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1023
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326061,
+                      "durationMs": 375
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326062,
+                      "durationMs": 1060
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4198,
+                      "durationMs": 1389
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4225,
+                      "durationMs": 2434
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5530.772
+            },
+            {
+              "region": "eastus",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-001954",
+              "mode": "reuse",
+              "workerIoTimerMs": 2358,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330980,
+                  "durationMs": 1031
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 331012,
+                  "durationMs": 1724
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 153
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 476
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326062,
+                      "durationMs": 190
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326067,
+                      "durationMs": 397
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4674,
+                      "durationMs": 688
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4700,
+                      "durationMs": 851
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2416.601
+            },
+            {
+              "region": "eastus",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-002931",
+              "mode": "reuse",
+              "workerIoTimerMs": 2409,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330551,
+                  "durationMs": 1038
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330578,
+                  "durationMs": 1881
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 176
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 328
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326067,
+                      "durationMs": 166
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326069,
+                      "durationMs": 510
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4239,
+                      "durationMs": 696
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4265,
+                      "durationMs": 1043
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2461.141
+            }
+          ],
+          "write-small-two-duplicate": [
+            {
+              "region": "eastus",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000000",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5753,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10345,
+                  "durationMs": 2367
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6035,
+                  "durationMs": 5114
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 260
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 1008
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8674,
+                      "durationMs": 999
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4340,
+                      "durationMs": 1728
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1363,
+                      "durationMs": 1108
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1386,
+                      "durationMs": 2378
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5765.41
+            },
+            {
+              "region": "eastus",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-000081",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5469,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10386,
+                  "durationMs": 1840
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6072,
+                  "durationMs": 5322
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 266
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 945
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8680,
+                      "durationMs": 819
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4347,
+                      "durationMs": 1693
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1397,
+                      "durationMs": 755
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1416,
+                      "durationMs": 2684
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5479.844
+            },
+            {
+              "region": "eastus",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-000034",
+              "mode": "duplicate",
+              "workerIoTimerMs": 3227,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10453,
+                  "durationMs": 1759
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6133,
+                  "durationMs": 2037
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 222
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 286
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8694,
+                      "durationMs": 994
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4351,
+                      "durationMs": 569
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1450,
+                      "durationMs": 543
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1473,
+                      "durationMs": 1182
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 3244.596
+            },
+            {
+              "region": "eastus",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-000115",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2459,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10421,
+                  "durationMs": 1272
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6091,
+                  "durationMs": 1916
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 160
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 323
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8702,
+                      "durationMs": 541
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4353,
+                      "durationMs": 729
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1410,
+                      "durationMs": 571
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1429,
+                      "durationMs": 864
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2477.282
+            }
+          ],
+          "write-medium-two-duplicate": [
+            {
+              "region": "eastus",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000000",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5556,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294531,
+                  "durationMs": 2113
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148611,
+                  "durationMs": 5431
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 312
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 307,
+                      "durationMs": 936
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291904,
+                      "durationMs": 943
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145962,
+                      "durationMs": 1988
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2317,
+                      "durationMs": 858
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2342,
+                      "durationMs": 2507
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5570.424
+            },
+            {
+              "region": "eastus",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-000977",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6118,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294772,
+                  "durationMs": 2736
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148842,
+                  "durationMs": 5297
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 307,
+                      "durationMs": 288
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 1001
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291924,
+                      "durationMs": 1341
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145971,
+                      "durationMs": 1915
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2541,
+                      "durationMs": 1107
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2560,
+                      "durationMs": 2381
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6131.331
+            },
+            {
+              "region": "eastus",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-001954",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2681,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294815,
+                  "durationMs": 1524
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148874,
+                  "durationMs": 2357
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 165
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 294
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291942,
+                      "durationMs": 750
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145978,
+                      "durationMs": 1200
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2562,
+                      "durationMs": 609
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2584,
+                      "durationMs": 863
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2719.113
+            },
+            {
+              "region": "eastus",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-002931",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2822,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294731,
+                  "durationMs": 1565
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148782,
+                  "durationMs": 1921
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 177
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 337
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291956,
+                      "durationMs": 610
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145988,
+                      "durationMs": 664
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2463,
+                      "durationMs": 778
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2484,
+                      "durationMs": 920
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2852.879
+            }
+          ],
+          "write-large-two-duplicate": [
+            {
+              "region": "eastus",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000000",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6143,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450415,
+                  "durationMs": 2616
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727401,
+                  "durationMs": 6221
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 250
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 936
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446096,
+                      "durationMs": 1064
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723051,
+                      "durationMs": 2694
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4007,
+                      "durationMs": 1302
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4037,
+                      "durationMs": 2591
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6164.338
+            },
+            {
+              "region": "eastus",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-000977",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5503,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450614,
+                  "durationMs": 2613
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727597,
+                  "durationMs": 5586
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 255
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 530
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446102,
+                      "durationMs": 1015
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723057,
+                      "durationMs": 2696
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4199,
+                      "durationMs": 1343
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4228,
+                      "durationMs": 2360
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5541.262
+            },
+            {
+              "region": "eastus",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-001954",
+              "mode": "duplicate",
+              "workerIoTimerMs": 4301,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1451101,
+                  "durationMs": 3040
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 728082,
+                  "durationMs": 2657
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 307
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 295
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446114,
+                      "durationMs": 1217
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723070,
+                      "durationMs": 1396
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4675,
+                      "durationMs": 1516
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4700,
+                      "durationMs": 966
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4391.653
+            },
+            {
+              "region": "eastus",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-002931",
+              "mode": "duplicate",
+              "workerIoTimerMs": 3527,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450691,
+                  "durationMs": 2066
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727656,
+                  "durationMs": 2799
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 150
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 474
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446140,
+                      "durationMs": 945
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723079,
+                      "durationMs": 1338
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4239,
+                      "durationMs": 971
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4265,
+                      "durationMs": 987
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 3638.715
+            }
+          ],
+          "write-small-two-reuse": [
+            {
+              "region": "eastus",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000000",
+              "mode": "reuse",
+              "workerIoTimerMs": 5990,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6008,
+                  "durationMs": 1867
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6035,
+                  "durationMs": 5642
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 350
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 1024
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4337,
+                      "durationMs": 608
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4340,
+                      "durationMs": 1519
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1363,
+                      "durationMs": 909
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1386,
+                      "durationMs": 3099
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6002.953
+            },
+            {
+              "region": "eastus",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-000081",
+              "mode": "reuse",
+              "workerIoTimerMs": 2650,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6046,
+                  "durationMs": 1195
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6072,
+                  "durationMs": 2111
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 171
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 359
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4340,
+                      "durationMs": 392
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4347,
+                      "durationMs": 656
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1397,
+                      "durationMs": 632
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1416,
+                      "durationMs": 1096
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2666.887
+            },
+            {
+              "region": "eastus",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-000034",
+              "mode": "reuse",
+              "workerIoTimerMs": 2407,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6106,
+                  "durationMs": 1173
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6133,
+                  "durationMs": 1828
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 183
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 350
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4347,
+                      "durationMs": 403
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4351,
+                      "durationMs": 594
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1450,
+                      "durationMs": 587
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1473,
+                      "durationMs": 884
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2425.705
+            },
+            {
+              "region": "eastus",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-000115",
+              "mode": "reuse",
+              "workerIoTimerMs": 2186,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6070,
+                  "durationMs": 1084
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6091,
+                  "durationMs": 1703
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 178
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 304
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4351,
+                      "durationMs": 326
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4353,
+                      "durationMs": 601
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1410,
+                      "durationMs": 580
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1429,
+                      "durationMs": 798
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2206.617
+            }
+          ],
+          "write-medium-two-reuse": [
+            {
+              "region": "eastus",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000000",
+              "mode": "reuse",
+              "workerIoTimerMs": 5342,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148579,
+                  "durationMs": 1853
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148611,
+                  "durationMs": 5266
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 250
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 307,
+                      "durationMs": 981
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145952,
+                      "durationMs": 692
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145962,
+                      "durationMs": 1777
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2317,
+                      "durationMs": 911
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2342,
+                      "durationMs": 2508
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5355.429
+            },
+            {
+              "region": "eastus",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-000977",
+              "mode": "reuse",
+              "workerIoTimerMs": 2820,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148810,
+                  "durationMs": 1151
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148842,
+                  "durationMs": 2342
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 307,
+                      "durationMs": 245
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 474
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145962,
+                      "durationMs": 344
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145971,
+                      "durationMs": 673
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2541,
+                      "durationMs": 562
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2560,
+                      "durationMs": 1195
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2845.037
+            },
+            {
+              "region": "eastus",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-001954",
+              "mode": "reuse",
+              "workerIoTimerMs": 2377,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148844,
+                  "durationMs": 1254
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148874,
+                  "durationMs": 2106
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 152
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 314
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145971,
+                      "durationMs": 434
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145978,
+                      "durationMs": 983
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2562,
+                      "durationMs": 668
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2584,
+                      "durationMs": 809
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2414.644
+            },
+            {
+              "region": "eastus",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-002931",
+              "mode": "reuse",
+              "workerIoTimerMs": 2690,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148753,
+                  "durationMs": 1449
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148782,
+                  "durationMs": 1890
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 192
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 392
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145978,
+                      "durationMs": 675
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145988,
+                      "durationMs": 649
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2463,
+                      "durationMs": 582
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2484,
+                      "durationMs": 849
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2724.305
+            }
+          ],
+          "write-large-two-reuse": [
+            {
+              "region": "eastus",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000000",
+              "mode": "reuse",
+              "workerIoTimerMs": 6224,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727367,
+                  "durationMs": 2731
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727401,
+                  "durationMs": 6254
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 250
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 975
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723048,
+                      "durationMs": 861
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723051,
+                      "durationMs": 2761
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4007,
+                      "durationMs": 1620
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4037,
+                      "durationMs": 2518
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6243.648
+            },
+            {
+              "region": "eastus",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-000977",
+              "mode": "reuse",
+              "workerIoTimerMs": 3112,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727563,
+                  "durationMs": 1837
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727597,
+                  "durationMs": 2586
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 165
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 344
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723051,
+                      "durationMs": 743
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723057,
+                      "durationMs": 1311
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4199,
+                      "durationMs": 929
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4228,
+                      "durationMs": 931
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 3220.533
+            },
+            {
+              "region": "eastus",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-001954",
+              "mode": "reuse",
+              "workerIoTimerMs": 3231,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 728044,
+                  "durationMs": 1849
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 728082,
+                  "durationMs": 2808
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 235
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 328
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723057,
+                      "durationMs": 748
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723070,
+                      "durationMs": 1426
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4675,
+                      "durationMs": 866
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4700,
+                      "durationMs": 1054
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 3352.28
+            },
+            {
+              "region": "eastus",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-002931",
+              "mode": "reuse",
+              "workerIoTimerMs": 5565,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727621,
+                  "durationMs": 1984
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727656,
+                  "durationMs": 6072
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 161
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 1065
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723070,
+                      "durationMs": 518
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723079,
+                      "durationMs": 2491
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4239,
+                      "durationMs": 1305
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4265,
+                      "durationMs": 2516
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5584.277
+            }
+          ]
+        },
+        "verification": [
+          {
+            "region": "eastus",
+            "profile": "small",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "eastus",
+            "profile": "small",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "eastus",
+            "profile": "medium",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "eastus",
+            "profile": "medium",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "eastus",
+            "profile": "large",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "eastus",
+            "profile": "large",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          }
+        ]
+      }
+    },
+    {
+      "replicate": "a",
+      "region": "westus2",
+      "result": {
+        "generatedAt": "2026-09-30T02:49:51.206Z",
+        "sourceCommit": "bd8af6eec98b8f4a745d90327e96534c4a09fac0",
+        "harnessCommit": "a1a1d02d9ce71318956e5a5cb9574eed43314c04",
+        "runId": "index-reuse-a",
+        "replicate": "a",
+        "region": "westus2",
+        "colo": "PDX",
+        "runtime": "Node v22.23.3",
+        "iterations": 4,
+        "samples": {
+          "write-small-one-duplicate": [
+            {
+              "region": "westus2",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000037",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5142,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5601,
+                  "durationMs": 1493
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3604,
+                  "durationMs": 4567
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 252
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 910
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4040,
+                      "durationMs": 478
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2019,
+                      "durationMs": 918
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1318,
+                      "durationMs": 763
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1342,
+                      "durationMs": 2739
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5162.642
+            },
+            {
+              "region": "westus2",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-000118",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2168,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5772,
+                  "durationMs": 926
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3776,
+                  "durationMs": 1530
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 137
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 296
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4038,
+                      "durationMs": 240
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2020,
+                      "durationMs": 288
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1491,
+                      "durationMs": 549
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1512,
+                      "durationMs": 946
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2192.168
+            },
+            {
+              "region": "westus2",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-000071",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2325,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5775,
+                  "durationMs": 995
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3779,
+                  "durationMs": 1615
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 271
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 337
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4040,
+                      "durationMs": 271
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2022,
+                      "durationMs": 285
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1491,
+                      "durationMs": 453
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1514,
+                      "durationMs": 993
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2346.743
+            },
+            {
+              "region": "westus2",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-000024",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2156,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5779,
+                  "durationMs": 968
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3779,
+                  "durationMs": 1449
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 201
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 392
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4044,
+                      "durationMs": 292
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2024,
+                      "durationMs": 261
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1492,
+                      "durationMs": 475
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1513,
+                      "durationMs": 796
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2178.698
+            }
+          ],
+          "write-medium-one-duplicate": [
+            {
+              "region": "westus2",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000037",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5104,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134159,
+                  "durationMs": 1678
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68337,
+                  "durationMs": 4419
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 401
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 959
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131688,
+                      "durationMs": 533
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65848,
+                      "durationMs": 993
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2228,
+                      "durationMs": 744
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2247,
+                      "durationMs": 2467
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5128.813
+            },
+            {
+              "region": "westus2",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001014",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5229,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134613,
+                  "durationMs": 1680
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68791,
+                  "durationMs": 4419
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 214
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 1031
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131696,
+                      "durationMs": 399
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65854,
+                      "durationMs": 870
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2675,
+                      "durationMs": 1067
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2694,
+                      "durationMs": 2518
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5250.03
+            },
+            {
+              "region": "westus2",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-001991",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2124,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134284,
+                  "durationMs": 908
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68453,
+                  "durationMs": 1501
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 149
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 353
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131708,
+                      "durationMs": 251
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65855,
+                      "durationMs": 285
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2333,
+                      "durationMs": 508
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2354,
+                      "durationMs": 863
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2157.108
+            },
+            {
+              "region": "westus2",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-002968",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2132,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134582,
+                  "durationMs": 940
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68751,
+                  "durationMs": 1512
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 142
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 280
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131710,
+                      "durationMs": 278
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65859,
+                      "durationMs": 320
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2628,
+                      "durationMs": 520
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2649,
+                      "durationMs": 912
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2164.373
+            }
+          ],
+          "write-large-one-duplicate": [
+            {
+              "region": "westus2",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000037",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5017,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656502,
+                  "durationMs": 1631
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330475,
+                  "durationMs": 4563
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 248
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 946
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652116,
+                      "durationMs": 540
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326064,
+                      "durationMs": 1177
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4142,
+                      "durationMs": 843
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4167,
+                      "durationMs": 2440
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5045.112
+            },
+            {
+              "region": "westus2",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001014",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5639,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656777,
+                  "durationMs": 2038
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330739,
+                  "durationMs": 4685
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 416
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1077
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652128,
+                      "durationMs": 497
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326067,
+                      "durationMs": 1084
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4405,
+                      "durationMs": 1125
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4428,
+                      "durationMs": 2524
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5662.927
+            },
+            {
+              "region": "westus2",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-001991",
+              "mode": "duplicate",
+              "workerIoTimerMs": 3095,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656515,
+                  "durationMs": 1540
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330477,
+                  "durationMs": 2019
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 426
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 268
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652134,
+                      "durationMs": 313
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326073,
+                      "durationMs": 464
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4137,
+                      "durationMs": 801
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4161,
+                      "durationMs": 1287
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 3146.668
+            },
+            {
+              "region": "westus2",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-002968",
+              "mode": "duplicate",
+              "workerIoTimerMs": 4671,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656895,
+                  "durationMs": 1271
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330854,
+                  "durationMs": 3874
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 115
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 969
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652146,
+                      "durationMs": 312
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326076,
+                      "durationMs": 474
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4506,
+                      "durationMs": 844
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4533,
+                      "durationMs": 2431
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4696.413
+            }
+          ],
+          "write-small-one-reuse": [
+            {
+              "region": "westus2",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000037",
+              "mode": "reuse",
+              "workerIoTimerMs": 4614,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3581,
+                  "durationMs": 1213
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3604,
+                  "durationMs": 4164
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 232
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 1027
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2020,
+                      "durationMs": 279
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2019,
+                      "durationMs": 763
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1318,
+                      "durationMs": 702
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1342,
+                      "durationMs": 2374
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4633.694
+            },
+            {
+              "region": "westus2",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-000118",
+              "mode": "reuse",
+              "workerIoTimerMs": 4606,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3753,
+                  "durationMs": 1093
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3776,
+                  "durationMs": 4343
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 186
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 997
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2019,
+                      "durationMs": 186
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2020,
+                      "durationMs": 830
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1491,
+                      "durationMs": 721
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1512,
+                      "durationMs": 2516
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4623.856
+            },
+            {
+              "region": "westus2",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-000071",
+              "mode": "reuse",
+              "workerIoTimerMs": 1873,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3755,
+                  "durationMs": 699
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3779,
+                  "durationMs": 1494
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 137
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 340
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2020,
+                      "durationMs": 130
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2022,
+                      "durationMs": 320
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1491,
+                      "durationMs": 432
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1514,
+                      "durationMs": 834
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 1897.677
+            },
+            {
+              "region": "westus2",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-000024",
+              "mode": "reuse",
+              "workerIoTimerMs": 2331,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3757,
+                  "durationMs": 986
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3779,
+                  "durationMs": 1630
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 154
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 273
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2022,
+                      "durationMs": 200
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2024,
+                      "durationMs": 285
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1492,
+                      "durationMs": 632
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1513,
+                      "durationMs": 1072
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2352.668
+            }
+          ],
+          "write-medium-one-reuse": [
+            {
+              "region": "westus2",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000037",
+              "mode": "reuse",
+              "workerIoTimerMs": 4320,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68315,
+                  "durationMs": 1207
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68337,
+                  "durationMs": 3968
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 307
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 927
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65844,
+                      "durationMs": 159
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65848,
+                      "durationMs": 855
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2228,
+                      "durationMs": 741
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2247,
+                      "durationMs": 2186
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4341.289
+            },
+            {
+              "region": "westus2",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001014",
+              "mode": "reuse",
+              "workerIoTimerMs": 4813,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68765,
+                  "durationMs": 1124
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68791,
+                  "durationMs": 4482
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 231
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 1090
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65848,
+                      "durationMs": 180
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65854,
+                      "durationMs": 793
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2675,
+                      "durationMs": 713
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2694,
+                      "durationMs": 2599
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4837.525
+            },
+            {
+              "region": "westus2",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-001991",
+              "mode": "reuse",
+              "workerIoTimerMs": 2282,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68430,
+                  "durationMs": 1037
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68453,
+                  "durationMs": 1597
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 149
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 281
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65854,
+                      "durationMs": 238
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65855,
+                      "durationMs": 352
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2333,
+                      "durationMs": 650
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2354,
+                      "durationMs": 964
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2317.404
+            },
+            {
+              "region": "westus2",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-002968",
+              "mode": "reuse",
+              "workerIoTimerMs": 1949,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68727,
+                  "durationMs": 772
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68751,
+                  "durationMs": 1475
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 152
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 307
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65855,
+                      "durationMs": 140
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65859,
+                      "durationMs": 298
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2628,
+                      "durationMs": 480
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2649,
+                      "durationMs": 870
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 1977.599
+            }
+          ],
+          "write-large-one-reuse": [
+            {
+              "region": "westus2",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000037",
+              "mode": "reuse",
+              "workerIoTimerMs": 4900,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330444,
+                  "durationMs": 1413
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330475,
+                  "durationMs": 4519
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 228
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 913
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326058,
+                      "durationMs": 283
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326064,
+                      "durationMs": 1032
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4142,
+                      "durationMs": 902
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4167,
+                      "durationMs": 2574
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4925.837
+            },
+            {
+              "region": "westus2",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001014",
+              "mode": "reuse",
+              "workerIoTimerMs": 5272,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330713,
+                  "durationMs": 1327
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330739,
+                  "durationMs": 4978
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 213
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 992
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326064,
+                      "durationMs": 238
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326067,
+                      "durationMs": 1033
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4405,
+                      "durationMs": 876
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4428,
+                      "durationMs": 2953
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5292.773
+            },
+            {
+              "region": "westus2",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-001991",
+              "mode": "reuse",
+              "workerIoTimerMs": 2268,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330448,
+                  "durationMs": 934
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330477,
+                  "durationMs": 2061
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 119
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 305
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326067,
+                      "durationMs": 181
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326073,
+                      "durationMs": 727
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4137,
+                      "durationMs": 634
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4161,
+                      "durationMs": 1029
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2344.213
+            },
+            {
+              "region": "westus2",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-002968",
+              "mode": "reuse",
+              "workerIoTimerMs": 2325,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330822,
+                  "durationMs": 980
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330854,
+                  "durationMs": 1839
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 130
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 358
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326073,
+                      "durationMs": 161
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326076,
+                      "durationMs": 494
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4506,
+                      "durationMs": 689
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4533,
+                      "durationMs": 987
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2384.402
+            }
+          ],
+          "write-small-two-duplicate": [
+            {
+              "region": "westus2",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000037",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5750,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10300,
+                  "durationMs": 1729
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 5991,
+                  "durationMs": 5773
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 225
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 1367
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8674,
+                      "durationMs": 835
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4338,
+                      "durationMs": 1752
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1318,
+                      "durationMs": 669
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1344,
+                      "durationMs": 2654
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5771.474
+            },
+            {
+              "region": "westus2",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-000118",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6026,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10476,
+                  "durationMs": 1679
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6158,
+                  "durationMs": 6139
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 216
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 307,
+                      "durationMs": 1063
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8676,
+                      "durationMs": 692
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4339,
+                      "durationMs": 1792
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1491,
+                      "durationMs": 771
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1512,
+                      "durationMs": 3284
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6045.732
+            },
+            {
+              "region": "westus2",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-000071",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2200,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10475,
+                  "durationMs": 1096
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6166,
+                  "durationMs": 1708
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 307,
+                      "durationMs": 151
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 300
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8678,
+                      "durationMs": 527
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4344,
+                      "durationMs": 604
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1490,
+                      "durationMs": 418
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1514,
+                      "durationMs": 804
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2224.739
+            },
+            {
+              "region": "westus2",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-000024",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2409,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10488,
+                  "durationMs": 1113
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6167,
+                  "durationMs": 1825
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 145
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 294
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8688,
+                      "durationMs": 539
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4345,
+                      "durationMs": 529
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1492,
+                      "durationMs": 429
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1514,
+                      "durationMs": 1002
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2436.276
+            }
+          ],
+          "write-medium-two-duplicate": [
+            {
+              "region": "westus2",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000037",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5175,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294442,
+                  "durationMs": 1790
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148519,
+                  "durationMs": 5138
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 209
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 917
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291904,
+                      "durationMs": 833
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145962,
+                      "durationMs": 1753
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2228,
+                      "durationMs": 748
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2248,
+                      "durationMs": 2468
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5195.773
+            },
+            {
+              "region": "westus2",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001014",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5216,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294909,
+                  "durationMs": 1943
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148989,
+                  "durationMs": 5088
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 253
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 1011
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291924,
+                      "durationMs": 1010
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145978,
+                      "durationMs": 1815
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2676,
+                      "durationMs": 680
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2700,
+                      "durationMs": 2262
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5237.982
+            },
+            {
+              "region": "westus2",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-001991",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2633,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294604,
+                  "durationMs": 1332
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148643,
+                  "durationMs": 2022
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 152
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 307,
+                      "durationMs": 393
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291956,
+                      "durationMs": 661
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145982,
+                      "durationMs": 721
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2337,
+                      "durationMs": 519
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2354,
+                      "durationMs": 908
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2678.583
+            },
+            {
+              "region": "westus2",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-002968",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2721,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294899,
+                  "durationMs": 1461
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148956,
+                  "durationMs": 1938
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 307,
+                      "durationMs": 278
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 364
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291964,
+                      "durationMs": 612
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145994,
+                      "durationMs": 678
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2628,
+                      "durationMs": 571
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2652,
+                      "durationMs": 896
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2763.823
+            }
+          ],
+          "write-large-two-duplicate": [
+            {
+              "region": "westus2",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000037",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6290,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450550,
+                  "durationMs": 2570
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727542,
+                  "durationMs": 6709
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 372
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 966
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446096,
+                      "durationMs": 1078
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723061,
+                      "durationMs": 2989
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4142,
+                      "durationMs": 1120
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4168,
+                      "durationMs": 2754
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6320.868
+            },
+            {
+              "region": "westus2",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001014",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6256,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450840,
+                  "durationMs": 2582
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727818,
+                  "durationMs": 6884
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 229
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 1048
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446122,
+                      "durationMs": 1181
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723076,
+                      "durationMs": 3210
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4405,
+                      "durationMs": 1172
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4430,
+                      "durationMs": 2626
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6289.779
+            },
+            {
+              "region": "westus2",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-001991",
+              "mode": "duplicate",
+              "workerIoTimerMs": 3485,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450601,
+                  "durationMs": 1883
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727567,
+                  "durationMs": 3472
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 149
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 351
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446152,
+                      "durationMs": 691
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723093,
+                      "durationMs": 1870
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4137,
+                      "durationMs": 1043
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4162,
+                      "durationMs": 1251
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 3590.119
+            },
+            {
+              "region": "westus2",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-002968",
+              "mode": "duplicate",
+              "workerIoTimerMs": 3330,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1451003,
+                  "durationMs": 1822
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727949,
+                  "durationMs": 2756
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 117
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 374
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446186,
+                      "durationMs": 787
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723103,
+                      "durationMs": 1248
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4505,
+                      "durationMs": 918
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4534,
+                      "durationMs": 1134
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 3434.709
+            }
+          ],
+          "write-small-two-reuse": [
+            {
+              "region": "westus2",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000037",
+              "mode": "reuse",
+              "workerIoTimerMs": 5013,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5963,
+                  "durationMs": 1457
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 5991,
+                  "durationMs": 5078
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 255
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 1022
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4337,
+                      "durationMs": 515
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4338,
+                      "durationMs": 1522
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1318,
+                      "durationMs": 687
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1344,
+                      "durationMs": 2534
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5030.692
+            },
+            {
+              "region": "westus2",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-000118",
+              "mode": "reuse",
+              "workerIoTimerMs": 4628,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6138,
+                  "durationMs": 1375
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6158,
+                  "durationMs": 5166
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 233
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 307,
+                      "durationMs": 918
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4338,
+                      "durationMs": 376
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4339,
+                      "durationMs": 1913
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1491,
+                      "durationMs": 766
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1512,
+                      "durationMs": 2335
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4645.37
+            },
+            {
+              "region": "westus2",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-000071",
+              "mode": "reuse",
+              "workerIoTimerMs": 2271,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6136,
+                  "durationMs": 1132
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6166,
+                  "durationMs": 1637
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 307,
+                      "durationMs": 180
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 311
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4339,
+                      "durationMs": 553
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4344,
+                      "durationMs": 498
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1490,
+                      "durationMs": 399
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1514,
+                      "durationMs": 828
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2298.133
+            },
+            {
+              "region": "westus2",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-000024",
+              "mode": "reuse",
+              "workerIoTimerMs": 2398,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6144,
+                  "durationMs": 1005
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6167,
+                  "durationMs": 1962
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 166
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 461
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4344,
+                      "durationMs": 244
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4345,
+                      "durationMs": 569
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1492,
+                      "durationMs": 595
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1514,
+                      "durationMs": 932
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2430.288
+            }
+          ],
+          "write-medium-two-reuse": [
+            {
+              "region": "westus2",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000037",
+              "mode": "reuse",
+              "workerIoTimerMs": 5233,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148490,
+                  "durationMs": 1674
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148519,
+                  "durationMs": 5352
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 220
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 1223
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145952,
+                      "durationMs": 748
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145962,
+                      "durationMs": 1793
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2228,
+                      "durationMs": 706
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2248,
+                      "durationMs": 2336
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5252.813
+            },
+            {
+              "region": "westus2",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001014",
+              "mode": "reuse",
+              "workerIoTimerMs": 2866,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148947,
+                  "durationMs": 1592
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148989,
+                  "durationMs": 2700
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 233
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 327
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145962,
+                      "durationMs": 531
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145978,
+                      "durationMs": 1426
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2676,
+                      "durationMs": 828
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2700,
+                      "durationMs": 947
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2903.181
+            },
+            {
+              "region": "westus2",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-001991",
+              "mode": "reuse",
+              "workerIoTimerMs": 2379,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148626,
+                  "durationMs": 1076
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148643,
+                  "durationMs": 2038
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 136
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 307,
+                      "durationMs": 352
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145978,
+                      "durationMs": 291
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145982,
+                      "durationMs": 735
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2337,
+                      "durationMs": 649
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2354,
+                      "durationMs": 951
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2416.584
+            },
+            {
+              "region": "westus2",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-002968",
+              "mode": "reuse",
+              "workerIoTimerMs": 2452,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148917,
+                  "durationMs": 1144
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148956,
+                  "durationMs": 2050
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 307,
+                      "durationMs": 229
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 290
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145982,
+                      "durationMs": 317
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145994,
+                      "durationMs": 742
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2628,
+                      "durationMs": 598
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2652,
+                      "durationMs": 1018
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2494.391
+            }
+          ],
+          "write-large-two-reuse": [
+            {
+              "region": "westus2",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000037",
+              "mode": "reuse",
+              "workerIoTimerMs": 5640,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727502,
+                  "durationMs": 1818
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727542,
+                  "durationMs": 6501
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 216
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 1163
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723048,
+                      "durationMs": 638
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723061,
+                      "durationMs": 2679
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4142,
+                      "durationMs": 964
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4168,
+                      "durationMs": 2659
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5666.715
+            },
+            {
+              "region": "westus2",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001014",
+              "mode": "reuse",
+              "workerIoTimerMs": 3227,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727779,
+                  "durationMs": 1749
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727818,
+                  "durationMs": 2948
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 143
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 354
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723061,
+                      "durationMs": 624
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723076,
+                      "durationMs": 1470
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4405,
+                      "durationMs": 982
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4430,
+                      "durationMs": 1124
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 3329.65
+            },
+            {
+              "region": "westus2",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-001991",
+              "mode": "reuse",
+              "workerIoTimerMs": 3048,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727525,
+                  "durationMs": 1674
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727567,
+                  "durationMs": 2839
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 146
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 345
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723076,
+                      "durationMs": 441
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723093,
+                      "durationMs": 1466
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4137,
+                      "durationMs": 1087
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4162,
+                      "durationMs": 1028
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 3151.541
+            },
+            {
+              "region": "westus2",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-002968",
+              "mode": "reuse",
+              "workerIoTimerMs": 2965,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727910,
+                  "durationMs": 1561
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727949,
+                  "durationMs": 2901
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 156
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 333
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723093,
+                      "durationMs": 497
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723103,
+                      "durationMs": 1497
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4505,
+                      "durationMs": 908
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4534,
+                      "durationMs": 1071
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 3089.38
+            }
+          ]
+        },
+        "verification": [
+          {
+            "region": "westus2",
+            "profile": "small",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "westus2",
+            "profile": "small",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "westus2",
+            "profile": "medium",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "westus2",
+            "profile": "medium",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "westus2",
+            "profile": "large",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "westus2",
+            "profile": "large",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          }
+        ]
+      }
+    },
+    {
+      "replicate": "a",
+      "region": "northeurope",
+      "result": {
+        "generatedAt": "2026-09-30T02:54:37.552Z",
+        "sourceCommit": "bd8af6eec98b8f4a745d90327e96534c4a09fac0",
+        "harnessCommit": "a1a1d02d9ce71318956e5a5cb9574eed43314c04",
+        "runId": "index-reuse-a",
+        "replicate": "a",
+        "region": "northeurope",
+        "colo": "DUB",
+        "runtime": "Node v22.23.3",
+        "iterations": 4,
+        "samples": {
+          "write-small-one-duplicate": [
+            {
+              "region": "northeurope",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000074",
+              "mode": "duplicate",
+              "workerIoTimerMs": 8730,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5772,
+                  "durationMs": 2950
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3779,
+                  "durationMs": 6963
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 657
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 1763
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4040,
+                      "durationMs": 825
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2022,
+                      "durationMs": 1183
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1489,
+                      "durationMs": 1468
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1515,
+                      "durationMs": 4017
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8739.036
+            },
+            {
+              "region": "northeurope",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-000027",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5189,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5774,
+                  "durationMs": 2232
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3772,
+                  "durationMs": 3548
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 379
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 633
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4044,
+                      "durationMs": 579
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2020,
+                      "durationMs": 591
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1488,
+                      "durationMs": 1274
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1510,
+                      "durationMs": 2324
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5198.019
+            },
+            {
+              "region": "northeurope",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-000108",
+              "mode": "duplicate",
+              "workerIoTimerMs": 7515,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5678,
+                  "durationMs": 2600
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3684,
+                  "durationMs": 6021
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 437
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 1636
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4040,
+                      "durationMs": 762
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2021,
+                      "durationMs": 1106
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1396,
+                      "durationMs": 1401
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1420,
+                      "durationMs": 3279
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7523.166
+            },
+            {
+              "region": "northeurope",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-000061",
+              "mode": "duplicate",
+              "workerIoTimerMs": 7612,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5733,
+                  "durationMs": 2628
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3732,
+                  "durationMs": 6146
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 452
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 1213
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4042,
+                      "durationMs": 749
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2023,
+                      "durationMs": 1162
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1448,
+                      "durationMs": 1427
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1467,
+                      "durationMs": 3771
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7620.376
+            }
+          ],
+          "write-medium-one-duplicate": [
+            {
+              "region": "northeurope",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000074",
+              "mode": "duplicate",
+              "workerIoTimerMs": 7532,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134240,
+                  "durationMs": 2652
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68425,
+                  "durationMs": 6162
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 435
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 1301
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131688,
+                      "durationMs": 766
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65848,
+                      "durationMs": 1282
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2309,
+                      "durationMs": 1451
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2334,
+                      "durationMs": 3579
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7541.946
+            },
+            {
+              "region": "northeurope",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001051",
+              "mode": "duplicate",
+              "workerIoTimerMs": 7248,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134333,
+                  "durationMs": 2736
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68510,
+                  "durationMs": 5724
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 526
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1323
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131696,
+                      "durationMs": 767
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65853,
+                      "durationMs": 1212
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2394,
+                      "durationMs": 1443
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2413,
+                      "durationMs": 3189
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7256.497
+            },
+            {
+              "region": "northeurope",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-002028",
+              "mode": "duplicate",
+              "workerIoTimerMs": 7382,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134304,
+                  "durationMs": 2713
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68474,
+                  "durationMs": 6492
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 420
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 241,
+                      "durationMs": 1300
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131706,
+                      "durationMs": 927
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65858,
+                      "durationMs": 1823
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2354,
+                      "durationMs": 1366
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2375,
+                      "durationMs": 3369
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7393.77
+            },
+            {
+              "region": "northeurope",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-003005",
+              "mode": "duplicate",
+              "workerIoTimerMs": 7337,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134420,
+                  "durationMs": 2642
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68593,
+                  "durationMs": 5956
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 241,
+                      "durationMs": 466
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1335
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131716,
+                      "durationMs": 684
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65864,
+                      "durationMs": 1261
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2463,
+                      "durationMs": 1492
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2485,
+                      "durationMs": 3360
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7346.207
+            }
+          ],
+          "write-large-one-duplicate": [
+            {
+              "region": "northeurope",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000074",
+              "mode": "duplicate",
+              "workerIoTimerMs": 7708,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656395,
+                  "durationMs": 3043
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330369,
+                  "durationMs": 6095
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 459
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1259
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652116,
+                      "durationMs": 859
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326065,
+                      "durationMs": 1430
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4035,
+                      "durationMs": 1725
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4060,
+                      "durationMs": 3406
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7718.142
+            },
+            {
+              "region": "northeurope",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001051",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6235,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656926,
+                  "durationMs": 3178
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330887,
+                  "durationMs": 4110
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 424
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 615
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652130,
+                      "durationMs": 957
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326066,
+                      "durationMs": 1053
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4552,
+                      "durationMs": 1797
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4577,
+                      "durationMs": 2442
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6247.715
+            },
+            {
+              "region": "northeurope",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-002028",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5413,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656586,
+                  "durationMs": 2615
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330558,
+                  "durationMs": 3664
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 373
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 847
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652132,
+                      "durationMs": 774
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326078,
+                      "durationMs": 866
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4210,
+                      "durationMs": 1468
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4237,
+                      "durationMs": 1951
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5429.253
+            },
+            {
+              "region": "northeurope",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-003005",
+              "mode": "duplicate",
+              "workerIoTimerMs": 8038,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656615,
+                  "durationMs": 3109
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330563,
+                  "durationMs": 6691
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 432
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1484
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652156,
+                      "durationMs": 871
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326082,
+                      "durationMs": 1762
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4216,
+                      "durationMs": 1806
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4237,
+                      "durationMs": 3445
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8048.382
+            }
+          ],
+          "write-small-one-reuse": [
+            {
+              "region": "northeurope",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000074",
+              "mode": "reuse",
+              "workerIoTimerMs": 7053,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3752,
+                  "durationMs": 2449
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3779,
+                  "durationMs": 5738
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 471
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 1279
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2020,
+                      "durationMs": 484
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2022,
+                      "durationMs": 1134
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1489,
+                      "durationMs": 1494
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1515,
+                      "durationMs": 3325
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7062.094
+            },
+            {
+              "region": "northeurope",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-000027",
+              "mode": "reuse",
+              "workerIoTimerMs": 4565,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3752,
+                  "durationMs": 1985
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3772,
+                  "durationMs": 3182
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 382
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 615
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2022,
+                      "durationMs": 456
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2020,
+                      "durationMs": 602
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1488,
+                      "durationMs": 1147
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1510,
+                      "durationMs": 1965
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4579.231
+            },
+            {
+              "region": "northeurope",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-000108",
+              "mode": "reuse",
+              "workerIoTimerMs": 4460,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3658,
+                  "durationMs": 2038
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3684,
+                  "durationMs": 3012
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 446
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 613
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2020,
+                      "durationMs": 390
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2021,
+                      "durationMs": 590
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1396,
+                      "durationMs": 1202
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1420,
+                      "durationMs": 1809
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4470.891
+            },
+            {
+              "region": "northeurope",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-000061",
+              "mode": "reuse",
+              "workerIoTimerMs": 6753,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3712,
+                  "durationMs": 2240
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3732,
+                  "durationMs": 5610
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 453
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 1295
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2021,
+                      "durationMs": 449
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2023,
+                      "durationMs": 1097
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1448,
+                      "durationMs": 1338
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1467,
+                      "durationMs": 3218
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6762.979
+            }
+          ],
+          "write-medium-one-reuse": [
+            {
+              "region": "northeurope",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000074",
+              "mode": "reuse",
+              "workerIoTimerMs": 7124,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68396,
+                  "durationMs": 2397
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68425,
+                  "durationMs": 6000
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 477
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 1301
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65844,
+                      "durationMs": 474
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65848,
+                      "durationMs": 1273
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2309,
+                      "durationMs": 1446
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2334,
+                      "durationMs": 3426
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7133.445
+            },
+            {
+              "region": "northeurope",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001051",
+              "mode": "reuse",
+              "workerIoTimerMs": 4562,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68485,
+                  "durationMs": 2082
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68510,
+                  "durationMs": 3156
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 426
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 610
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65848,
+                      "durationMs": 435
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65853,
+                      "durationMs": 676
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2394,
+                      "durationMs": 1221
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2413,
+                      "durationMs": 1870
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4573.792
+            },
+            {
+              "region": "northeurope",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-002028",
+              "mode": "reuse",
+              "workerIoTimerMs": 7132,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68451,
+                  "durationMs": 2455
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68474,
+                  "durationMs": 5803
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 440
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 241,
+                      "durationMs": 1299
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65853,
+                      "durationMs": 439
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65858,
+                      "durationMs": 1126
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2354,
+                      "durationMs": 1576
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2375,
+                      "durationMs": 3378
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7141.247
+            },
+            {
+              "region": "northeurope",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-003005",
+              "mode": "reuse",
+              "workerIoTimerMs": 6961,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68562,
+                  "durationMs": 2271
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68593,
+                  "durationMs": 5836
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 241,
+                      "durationMs": 447
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1322
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65858,
+                      "durationMs": 469
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65864,
+                      "durationMs": 1146
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2463,
+                      "durationMs": 1355
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2485,
+                      "durationMs": 3368
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6969.119
+            }
+          ],
+          "write-large-one-reuse": [
+            {
+              "region": "northeurope",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000074",
+              "mode": "reuse",
+              "workerIoTimerMs": 8389,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330337,
+                  "durationMs": 3115
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330369,
+                  "durationMs": 6864
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 442
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1239
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326058,
+                      "durationMs": 833
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326065,
+                      "durationMs": 1590
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4035,
+                      "durationMs": 1840
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4060,
+                      "durationMs": 4035
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8402.012
+            },
+            {
+              "region": "northeurope",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001051",
+              "mode": "reuse",
+              "workerIoTimerMs": 4918,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330861,
+                  "durationMs": 2397
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330887,
+                  "durationMs": 3560
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 378
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 636
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326065,
+                      "durationMs": 403
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326066,
+                      "durationMs": 1039
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4552,
+                      "durationMs": 1616
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4577,
+                      "durationMs": 1885
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4938.226
+            },
+            {
+              "region": "northeurope",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-002028",
+              "mode": "reuse",
+              "workerIoTimerMs": 7619,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330520,
+                  "durationMs": 2727
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330558,
+                  "durationMs": 6277
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 445
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 1365
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326066,
+                      "durationMs": 516
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326078,
+                      "durationMs": 1385
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4210,
+                      "durationMs": 1766
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4237,
+                      "durationMs": 3527
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7626.926
+            },
+            {
+              "region": "northeurope",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-003005",
+              "mode": "reuse",
+              "workerIoTimerMs": 7984,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330537,
+                  "durationMs": 2997
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330563,
+                  "durationMs": 6388
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 549
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1230
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326078,
+                      "durationMs": 779
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326082,
+                      "durationMs": 1401
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4216,
+                      "durationMs": 1669
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4237,
+                      "durationMs": 3757
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7992.437
+            }
+          ],
+          "write-small-two-duplicate": [
+            {
+              "region": "northeurope",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000074",
+              "mode": "duplicate",
+              "workerIoTimerMs": 8447,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10471,
+                  "durationMs": 3638
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6167,
+                  "durationMs": 7203
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 794
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 1351
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8674,
+                      "durationMs": 1396
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4343,
+                      "durationMs": 2394
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1489,
+                      "durationMs": 1448
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1515,
+                      "durationMs": 3458
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8456.861
+            },
+            {
+              "region": "northeurope",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-000027",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5209,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10483,
+                  "durationMs": 2773
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6162,
+                  "durationMs": 3693
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 394
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 306,
+                      "durationMs": 627
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8686,
+                      "durationMs": 1186
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4342,
+                      "durationMs": 1257
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1488,
+                      "durationMs": 1193
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1514,
+                      "durationMs": 1809
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5220.09
+            },
+            {
+              "region": "northeurope",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-000108",
+              "mode": "duplicate",
+              "workerIoTimerMs": 7905,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10387,
+                  "durationMs": 3303
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6069,
+                  "durationMs": 6779
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 306,
+                      "durationMs": 422
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 1364
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8684,
+                      "durationMs": 1419
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4341,
+                      "durationMs": 2177
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1397,
+                      "durationMs": 1462
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1419,
+                      "durationMs": 3238
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7913.379
+            },
+            {
+              "region": "northeurope",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-000061",
+              "mode": "duplicate",
+              "workerIoTimerMs": 8380,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10438,
+                  "durationMs": 3365
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6120,
+                  "durationMs": 7282
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 528
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 307,
+                      "durationMs": 1263
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8682,
+                      "durationMs": 1452
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4346,
+                      "durationMs": 2267
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1447,
+                      "durationMs": 1385
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1467,
+                      "durationMs": 3752
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8387.346
+            }
+          ],
+          "write-medium-two-duplicate": [
+            {
+              "region": "northeurope",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000074",
+              "mode": "duplicate",
+              "workerIoTimerMs": 8864,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294523,
+                  "durationMs": 3831
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148607,
+                  "durationMs": 7561
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 432
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 1270
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291904,
+                      "durationMs": 1517
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145963,
+                      "durationMs": 2528
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2309,
+                      "durationMs": 1882
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2334,
+                      "durationMs": 3763
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8873.549
+            },
+            {
+              "region": "northeurope",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001051",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5398,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294630,
+                  "durationMs": 2987
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148702,
+                  "durationMs": 3855
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 398
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 622
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291926,
+                      "durationMs": 1323
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145976,
+                      "durationMs": 1444
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2394,
+                      "durationMs": 1266
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2415,
+                      "durationMs": 1789
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5412.465
+            },
+            {
+              "region": "northeurope",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-002028",
+              "mode": "duplicate",
+              "workerIoTimerMs": 9013,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294618,
+                  "durationMs": 3630
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148683,
+                  "durationMs": 7960
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 427
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 1549
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291952,
+                      "durationMs": 1575
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145994,
+                      "durationMs": 2577
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2355,
+                      "durationMs": 1628
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2378,
+                      "durationMs": 3834
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 9021.386
+            },
+            {
+              "region": "northeurope",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-003005",
+              "mode": "duplicate",
+              "workerIoTimerMs": 8341,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294764,
+                  "durationMs": 3512
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148805,
+                  "durationMs": 7985
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 457
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 1438
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291988,
+                      "durationMs": 1468
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 146009,
+                      "durationMs": 3156
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2465,
+                      "durationMs": 1587
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2485,
+                      "durationMs": 3391
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8349.851
+            }
+          ],
+          "write-large-two-duplicate": [
+            {
+              "region": "northeurope",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000074",
+              "mode": "duplicate",
+              "workerIoTimerMs": 9794,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450443,
+                  "durationMs": 4394
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727436,
+                  "durationMs": 9159
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 469
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 1246
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446096,
+                      "durationMs": 1680
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723063,
+                      "durationMs": 3759
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4035,
+                      "durationMs": 2245
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4062,
+                      "durationMs": 4154
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 9804.279
+            },
+            {
+              "region": "northeurope",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001051",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6598,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450990,
+                  "durationMs": 4017
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727961,
+                  "durationMs": 4958
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 399
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 631
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446126,
+                      "durationMs": 1409
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723072,
+                      "durationMs": 2377
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4553,
+                      "durationMs": 2209
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4576,
+                      "durationMs": 1950
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6621.961
+            },
+            {
+              "region": "northeurope",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-002028",
+              "mode": "duplicate",
+              "workerIoTimerMs": 9403,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450667,
+                  "durationMs": 4563
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727650,
+                  "durationMs": 8342
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 470
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 1356
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446144,
+                      "durationMs": 2098
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723104,
+                      "durationMs": 3502
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4210,
+                      "durationMs": 1995
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4236,
+                      "durationMs": 3484
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 9412.509
+            },
+            {
+              "region": "northeurope",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-003005",
+              "mode": "duplicate",
+              "workerIoTimerMs": 9833,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450732,
+                  "durationMs": 4806
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727670,
+                  "durationMs": 8658
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 443
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 1515
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446208,
+                      "durationMs": 2282
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723119,
+                      "durationMs": 3631
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4214,
+                      "durationMs": 2081
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4239,
+                      "durationMs": 3512
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 9845.256
+            }
+          ],
+          "write-small-two-reuse": [
+            {
+              "region": "northeurope",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000074",
+              "mode": "reuse",
+              "workerIoTimerMs": 8833,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6134,
+                  "durationMs": 2989
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6167,
+                  "durationMs": 8123
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 458
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 1857
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4337,
+                      "durationMs": 960
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4343,
+                      "durationMs": 2279
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1489,
+                      "durationMs": 1571
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1515,
+                      "durationMs": 3987
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8842.452
+            },
+            {
+              "region": "northeurope",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-000027",
+              "mode": "reuse",
+              "workerIoTimerMs": 5013,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6140,
+                  "durationMs": 2529
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6162,
+                  "durationMs": 3772
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 393
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 306,
+                      "durationMs": 596
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4343,
+                      "durationMs": 775
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4342,
+                      "durationMs": 1288
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1488,
+                      "durationMs": 1361
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1514,
+                      "durationMs": 1888
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5023.557
+            },
+            {
+              "region": "northeurope",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-000108",
+              "mode": "reuse",
+              "workerIoTimerMs": 7887,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6045,
+                  "durationMs": 3012
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6069,
+                  "durationMs": 7051
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 306,
+                      "durationMs": 519
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 1380
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4342,
+                      "durationMs": 931
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4341,
+                      "durationMs": 2176
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1397,
+                      "durationMs": 1562
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1419,
+                      "durationMs": 3495
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7895.638
+            },
+            {
+              "region": "northeurope",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-000061",
+              "mode": "reuse",
+              "workerIoTimerMs": 8189,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6097,
+                  "durationMs": 3153
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6120,
+                  "durationMs": 7412
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 437
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 307,
+                      "durationMs": 1446
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4341,
+                      "durationMs": 963
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4346,
+                      "durationMs": 2376
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1447,
+                      "durationMs": 1753
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1467,
+                      "durationMs": 3590
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8201.547
+            }
+          ],
+          "write-medium-two-reuse": [
+            {
+              "region": "northeurope",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000074",
+              "mode": "reuse",
+              "workerIoTimerMs": 7725,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148571,
+                  "durationMs": 3167
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148607,
+                  "durationMs": 7048
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 540
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 1304
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145952,
+                      "durationMs": 1133
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145963,
+                      "durationMs": 2490
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2309,
+                      "durationMs": 1494
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2334,
+                      "durationMs": 3254
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7736.66
+            },
+            {
+              "region": "northeurope",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001051",
+              "mode": "reuse",
+              "workerIoTimerMs": 4976,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148667,
+                  "durationMs": 2475
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148702,
+                  "durationMs": 3895
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 404
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 620
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145963,
+                      "durationMs": 803
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145976,
+                      "durationMs": 1394
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2394,
+                      "durationMs": 1268
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2415,
+                      "durationMs": 1881
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4989.421
+            },
+            {
+              "region": "northeurope",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-002028",
+              "mode": "reuse",
+              "workerIoTimerMs": 7589,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148642,
+                  "durationMs": 2826
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148683,
+                  "durationMs": 7856
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 438
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 1313
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145976,
+                      "durationMs": 959
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145994,
+                      "durationMs": 3093
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2355,
+                      "durationMs": 1429
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2378,
+                      "durationMs": 3450
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7599.723
+            },
+            {
+              "region": "northeurope",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-003005",
+              "mode": "reuse",
+              "workerIoTimerMs": 7845,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148770,
+                  "durationMs": 2949
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148805,
+                  "durationMs": 7425
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 436
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 1386
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145994,
+                      "durationMs": 905
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 146009,
+                      "durationMs": 2529
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2465,
+                      "durationMs": 1608
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2485,
+                      "durationMs": 3510
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7854.83
+            }
+          ],
+          "write-large-two-reuse": [
+            {
+              "region": "northeurope",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000074",
+              "mode": "reuse",
+              "workerIoTimerMs": 8834,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727395,
+                  "durationMs": 3968
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727436,
+                  "durationMs": 9917
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 488
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 1358
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723048,
+                      "durationMs": 1161
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723063,
+                      "durationMs": 5051
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4035,
+                      "durationMs": 2319
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4062,
+                      "durationMs": 3508
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8844.258
+            },
+            {
+              "region": "northeurope",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001051",
+              "mode": "reuse",
+              "workerIoTimerMs": 5910,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727927,
+                  "durationMs": 3169
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727961,
+                  "durationMs": 4962
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 363
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 692
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723063,
+                      "durationMs": 1023
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723072,
+                      "durationMs": 2221
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4553,
+                      "durationMs": 1783
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4576,
+                      "durationMs": 2049
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5930.262
+            },
+            {
+              "region": "northeurope",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-002028",
+              "mode": "reuse",
+              "workerIoTimerMs": 9288,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727595,
+                  "durationMs": 3700
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727650,
+                  "durationMs": 9007
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 461
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 1424
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723072,
+                      "durationMs": 1208
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723104,
+                      "durationMs": 3419
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4210,
+                      "durationMs": 2031
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4236,
+                      "durationMs": 4164
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 9297.354
+            },
+            {
+              "region": "northeurope",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-003005",
+              "mode": "reuse",
+              "workerIoTimerMs": 8671,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727628,
+                  "durationMs": 3577
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727670,
+                  "durationMs": 8622
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 601
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 1622
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723104,
+                      "durationMs": 1020
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723119,
+                      "durationMs": 3528
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4214,
+                      "durationMs": 1956
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4239,
+                      "durationMs": 3472
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8680.961
+            }
+          ]
+        },
+        "verification": [
+          {
+            "region": "northeurope",
+            "profile": "small",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "northeurope",
+            "profile": "small",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "northeurope",
+            "profile": "medium",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "northeurope",
+            "profile": "medium",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "northeurope",
+            "profile": "large",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "northeurope",
+            "profile": "large",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          }
+        ]
+      }
+    },
+    {
+      "replicate": "a",
+      "region": "southeastasia",
+      "result": {
+        "generatedAt": "2026-09-30T02:56:48.614Z",
+        "sourceCommit": "bd8af6eec98b8f4a745d90327e96534c4a09fac0",
+        "harnessCommit": "a1a1d02d9ce71318956e5a5cb9574eed43314c04",
+        "runId": "index-reuse-a",
+        "replicate": "a",
+        "region": "southeastasia",
+        "colo": "HKG",
+        "runtime": "Node v22.23.3",
+        "iterations": 4,
+        "samples": {
+          "write-small-one-duplicate": [
+            {
+              "region": "southeastasia",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000111",
+              "mode": "duplicate",
+              "workerIoTimerMs": 8886,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5642,
+                  "durationMs": 3652
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3646,
+                  "durationMs": 6531
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 908
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 1432
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4040,
+                      "durationMs": 929
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2022,
+                      "durationMs": 1297
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1359,
+                      "durationMs": 1815
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1381,
+                      "durationMs": 3802
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8931.25
+            },
+            {
+              "region": "southeastasia",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-000064",
+              "mode": "duplicate",
+              "workerIoTimerMs": 8605,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5738,
+                  "durationMs": 3362
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3741,
+                  "durationMs": 6577
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 543
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 1423
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4044,
+                      "durationMs": 906
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2024,
+                      "durationMs": 1334
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1451,
+                      "durationMs": 1913
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1475,
+                      "durationMs": 3820
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8653.219
+            },
+            {
+              "region": "southeastasia",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-000017",
+              "mode": "duplicate",
+              "workerIoTimerMs": 8637,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5892,
+                  "durationMs": 3051
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3892,
+                  "durationMs": 6744
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 580
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1564
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4048,
+                      "durationMs": 820
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2027,
+                      "durationMs": 1158
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1602,
+                      "durationMs": 1651
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1621,
+                      "durationMs": 4022
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8685.49
+            },
+            {
+              "region": "southeastasia",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-000098",
+              "mode": "duplicate",
+              "workerIoTimerMs": 8457,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5828,
+                  "durationMs": 3012
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3819,
+                  "durationMs": 6672
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 552
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1465
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4054,
+                      "durationMs": 805
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2029,
+                      "durationMs": 1227
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1530,
+                      "durationMs": 1655
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1546,
+                      "durationMs": 3980
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8499.731
+            }
+          ],
+          "write-medium-one-duplicate": [
+            {
+              "region": "southeastasia",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000111",
+              "mode": "duplicate",
+              "workerIoTimerMs": 8454,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134394,
+                  "durationMs": 3280
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68576,
+                  "durationMs": 6519
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 557
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1484
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131688,
+                      "durationMs": 880
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65847,
+                      "durationMs": 1345
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2463,
+                      "durationMs": 1843
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2485,
+                      "durationMs": 3690
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8497.837
+            },
+            {
+              "region": "southeastasia",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001088",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6356,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134286,
+                  "durationMs": 2880
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68463,
+                  "durationMs": 4287
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 452
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 735
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131694,
+                      "durationMs": 817
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65853,
+                      "durationMs": 811
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2348,
+                      "durationMs": 1611
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2366,
+                      "durationMs": 2741
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6399.23
+            },
+            {
+              "region": "southeastasia",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-002065",
+              "mode": "duplicate",
+              "workerIoTimerMs": 8274,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134416,
+                  "durationMs": 3171
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68587,
+                  "durationMs": 6435
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 504
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1392
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131706,
+                      "durationMs": 823
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65859,
+                      "durationMs": 1332
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2466,
+                      "durationMs": 1844
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2484,
+                      "durationMs": 3711
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8317.069
+            },
+            {
+              "region": "southeastasia",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-003042",
+              "mode": "duplicate",
+              "workerIoTimerMs": 8402,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134264,
+                  "durationMs": 3323
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68433,
+                  "durationMs": 6487
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 511
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1497
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131718,
+                      "durationMs": 886
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65867,
+                      "durationMs": 1408
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2302,
+                      "durationMs": 1926
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2322,
+                      "durationMs": 3582
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8447.262
+            }
+          ],
+          "write-large-one-duplicate": [
+            {
+              "region": "southeastasia",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000111",
+              "mode": "duplicate",
+              "workerIoTimerMs": 9145,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656598,
+                  "durationMs": 3648
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330568,
+                  "durationMs": 7239
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 589
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1562
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652116,
+                      "durationMs": 903
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326061,
+                      "durationMs": 1742
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4238,
+                      "durationMs": 2156
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4263,
+                      "durationMs": 3935
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 9199.397
+            },
+            {
+              "region": "southeastasia",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001088",
+              "mode": "duplicate",
+              "workerIoTimerMs": 7481,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656833,
+                  "durationMs": 3599
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330803,
+                  "durationMs": 5216
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 485
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 773
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652122,
+                      "durationMs": 758
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326065,
+                      "durationMs": 1334
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4467,
+                      "durationMs": 2356
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4496,
+                      "durationMs": 3109
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7526.675
+            },
+            {
+              "region": "southeastasia",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-002065",
+              "mode": "duplicate",
+              "workerIoTimerMs": 10052,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656787,
+                  "durationMs": 3834
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330755,
+                  "durationMs": 7932
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 487
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 1477
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652130,
+                      "durationMs": 1155
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326076,
+                      "durationMs": 1714
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4415,
+                      "durationMs": 2192
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4437,
+                      "durationMs": 4741
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 10097.646
+            },
+            {
+              "region": "southeastasia",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-003042",
+              "mode": "duplicate",
+              "workerIoTimerMs": 9534,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656437,
+                  "durationMs": 4123
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330393,
+                  "durationMs": 7550
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 526
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 1496
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652152,
+                      "durationMs": 1409
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326081,
+                      "durationMs": 2139
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4043,
+                      "durationMs": 2188
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4067,
+                      "durationMs": 3915
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 9576.269
+            }
+          ],
+          "write-small-one-reuse": [
+            {
+              "region": "southeastasia",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000111",
+              "mode": "reuse",
+              "workerIoTimerMs": 7943,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3622,
+                  "durationMs": 2815
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3646,
+                  "durationMs": 6970
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 502
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 1390
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2020,
+                      "durationMs": 509
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2022,
+                      "durationMs": 1842
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1359,
+                      "durationMs": 1804
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1381,
+                      "durationMs": 3738
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7985.344
+            },
+            {
+              "region": "southeastasia",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-000064",
+              "mode": "reuse",
+              "workerIoTimerMs": 5683,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3716,
+                  "durationMs": 2757
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3741,
+                  "durationMs": 3650
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 513
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 747
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2022,
+                      "durationMs": 581
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2024,
+                      "durationMs": 724
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1451,
+                      "durationMs": 1663
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1475,
+                      "durationMs": 2179
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5729.068
+            },
+            {
+              "region": "southeastasia",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-000017",
+              "mode": "reuse",
+              "workerIoTimerMs": 8623,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3868,
+                  "durationMs": 2876
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3892,
+                  "durationMs": 6961
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 546
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1372
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2024,
+                      "durationMs": 500
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2027,
+                      "durationMs": 1214
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1602,
+                      "durationMs": 1830
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1621,
+                      "durationMs": 4375
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8670.088
+            },
+            {
+              "region": "southeastasia",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-000098",
+              "mode": "reuse",
+              "workerIoTimerMs": 8062,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3801,
+                  "durationMs": 2731
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3819,
+                  "durationMs": 6603
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 574
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1513
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2027,
+                      "durationMs": 494
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2029,
+                      "durationMs": 1272
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1530,
+                      "durationMs": 1663
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1546,
+                      "durationMs": 3818
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8103.06
+            }
+          ],
+          "write-medium-one-reuse": [
+            {
+              "region": "southeastasia",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000111",
+              "mode": "reuse",
+              "workerIoTimerMs": 8723,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68550,
+                  "durationMs": 3373
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68576,
+                  "durationMs": 6945
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 692
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1498
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65844,
+                      "durationMs": 876
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65847,
+                      "durationMs": 1595
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2463,
+                      "durationMs": 1805
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2485,
+                      "durationMs": 3852
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8766.196
+            },
+            {
+              "region": "southeastasia",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001088",
+              "mode": "reuse",
+              "workerIoTimerMs": 5539,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68439,
+                  "durationMs": 2544
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68463,
+                  "durationMs": 3839
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 547
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 769
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65847,
+                      "durationMs": 485
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65853,
+                      "durationMs": 844
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2348,
+                      "durationMs": 1512
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2366,
+                      "durationMs": 2226
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5589.191
+            },
+            {
+              "region": "southeastasia",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-002065",
+              "mode": "reuse",
+              "workerIoTimerMs": 8363,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68563,
+                  "durationMs": 3139
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68587,
+                  "durationMs": 6565
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 556
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1403
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65853,
+                      "durationMs": 644
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65859,
+                      "durationMs": 1341
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2466,
+                      "durationMs": 1939
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2484,
+                      "durationMs": 3821
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8409.791
+            },
+            {
+              "region": "southeastasia",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-003042",
+              "mode": "reuse",
+              "workerIoTimerMs": 8860,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68405,
+                  "durationMs": 2973
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68433,
+                  "durationMs": 7462
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 648
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1733
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65859,
+                      "durationMs": 653
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65867,
+                      "durationMs": 1575
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2302,
+                      "durationMs": 1672
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2322,
+                      "durationMs": 4154
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8901.203
+            }
+          ],
+          "write-large-one-reuse": [
+            {
+              "region": "southeastasia",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000111",
+              "mode": "reuse",
+              "workerIoTimerMs": 8911,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330540,
+                  "durationMs": 3481
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330568,
+                  "durationMs": 7359
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 558
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1498
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326058,
+                      "durationMs": 668
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326061,
+                      "durationMs": 1929
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4238,
+                      "durationMs": 2255
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4263,
+                      "durationMs": 3932
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8956.486
+            },
+            {
+              "region": "southeastasia",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001088",
+              "mode": "reuse",
+              "workerIoTimerMs": 7631,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330772,
+                  "durationMs": 3213
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330803,
+                  "durationMs": 5844
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 513
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 1304
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326061,
+                      "durationMs": 548
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326065,
+                      "durationMs": 1426
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4467,
+                      "durationMs": 2152
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4496,
+                      "durationMs": 3114
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7677.083
+            },
+            {
+              "region": "southeastasia",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-002065",
+              "mode": "reuse",
+              "workerIoTimerMs": 9367,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330722,
+                  "durationMs": 3596
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330755,
+                  "durationMs": 7798
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 594
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 1514
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326065,
+                      "durationMs": 624
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326076,
+                      "durationMs": 2027
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4415,
+                      "durationMs": 2378
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4437,
+                      "durationMs": 4257
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 9409.368
+            },
+            {
+              "region": "southeastasia",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-003042",
+              "mode": "reuse",
+              "workerIoTimerMs": 8953,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330361,
+                  "durationMs": 3585
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330393,
+                  "durationMs": 7142
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 554
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 1522
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326076,
+                      "durationMs": 701
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326081,
+                      "durationMs": 1774
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4043,
+                      "durationMs": 2330
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4067,
+                      "durationMs": 3846
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8995.041
+            }
+          ],
+          "write-small-two-duplicate": [
+            {
+              "region": "southeastasia",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000111",
+              "mode": "duplicate",
+              "workerIoTimerMs": 10082,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10341,
+                  "durationMs": 4330
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6031,
+                  "durationMs": 8184
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 591
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 307,
+                      "durationMs": 1472
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8674,
+                      "durationMs": 2037
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4342,
+                      "durationMs": 2432
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1359,
+                      "durationMs": 1702
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1382,
+                      "durationMs": 4280
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 10125.045
+            },
+            {
+              "region": "southeastasia",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-000064",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6754,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10443,
+                  "durationMs": 3604
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6136,
+                  "durationMs": 5735
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 307,
+                      "durationMs": 564
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 853
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8684,
+                      "durationMs": 1549
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4348,
+                      "durationMs": 2585
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1452,
+                      "durationMs": 1491
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1478,
+                      "durationMs": 2297
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6802.855
+            },
+            {
+              "region": "southeastasia",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-000017",
+              "mode": "duplicate",
+              "workerIoTimerMs": 9352,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10609,
+                  "durationMs": 4065
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6284,
+                  "durationMs": 7784
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 529
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 1476
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8696,
+                      "durationMs": 1783
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4354,
+                      "durationMs": 2497
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1603,
+                      "durationMs": 1753
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1621,
+                      "durationMs": 3811
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 9396.323
+            },
+            {
+              "region": "southeastasia",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-000098",
+              "mode": "duplicate",
+              "workerIoTimerMs": 9465,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10547,
+                  "durationMs": 4296
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6211,
+                  "durationMs": 8271
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 509
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 1413
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8708,
+                      "durationMs": 2002
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4356,
+                      "durationMs": 3102
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1530,
+                      "durationMs": 1785
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1547,
+                      "durationMs": 3756
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 9508.005
+            }
+          ],
+          "write-medium-two-duplicate": [
+            {
+              "region": "southeastasia",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000111",
+              "mode": "duplicate",
+              "workerIoTimerMs": 9550,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294677,
+                  "durationMs": 4454
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148756,
+                  "durationMs": 7999
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 765
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 1502
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291904,
+                      "durationMs": 1811
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145960,
+                      "durationMs": 2903
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2463,
+                      "durationMs": 1878
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2485,
+                      "durationMs": 3594
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 9595.138
+            },
+            {
+              "region": "southeastasia",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001088",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6845,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294578,
+                  "durationMs": 3748
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148658,
+                  "durationMs": 4902
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 584
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 823
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291920,
+                      "durationMs": 1646
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145976,
+                      "durationMs": 1805
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2347,
+                      "durationMs": 1518
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2371,
+                      "durationMs": 2274
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6891.497
+            },
+            {
+              "region": "southeastasia",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-002065",
+              "mode": "duplicate",
+              "workerIoTimerMs": 9656,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294730,
+                  "durationMs": 4267
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148793,
+                  "durationMs": 9594
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 564
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 1373
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291952,
+                      "durationMs": 1918
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145995,
+                      "durationMs": 4205
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2467,
+                      "durationMs": 1785
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2488,
+                      "durationMs": 4016
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 9702.225
+            },
+            {
+              "region": "southeastasia",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-003042",
+              "mode": "duplicate",
+              "workerIoTimerMs": 9597,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294604,
+                  "durationMs": 4064
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148651,
+                  "durationMs": 8304
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 597
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 1355
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291990,
+                      "durationMs": 1719
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 146014,
+                      "durationMs": 2771
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2304,
+                      "durationMs": 1748
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2327,
+                      "durationMs": 4178
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 9640.223
+            }
+          ],
+          "write-large-two-duplicate": [
+            {
+              "region": "southeastasia",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000111",
+              "mode": "duplicate",
+              "workerIoTimerMs": 11622,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450646,
+                  "durationMs": 6042
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727634,
+                  "durationMs": 10971
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 562
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 1485
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446096,
+                      "durationMs": 2425
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723056,
+                      "durationMs": 5391
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4238,
+                      "durationMs": 3055
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4266,
+                      "durationMs": 4095
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 11673.193
+            },
+            {
+              "region": "southeastasia",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001088",
+              "mode": "duplicate",
+              "workerIoTimerMs": 8231,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450893,
+                  "durationMs": 4905
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727882,
+                  "durationMs": 6833
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 487
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 792
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446112,
+                      "durationMs": 1956
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723073,
+                      "durationMs": 3507
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4469,
+                      "durationMs": 2462
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4496,
+                      "durationMs": 2534
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8285.631
+            },
+            {
+              "region": "southeastasia",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-002065",
+              "mode": "duplicate",
+              "workerIoTimerMs": 11693,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450873,
+                  "durationMs": 5844
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727848,
+                  "durationMs": 10695
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 591
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 1520
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446146,
+                      "durationMs": 2549
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723102,
+                      "durationMs": 4846
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4414,
+                      "durationMs": 2704
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4434,
+                      "durationMs": 4329
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 11736.38
+            },
+            {
+              "region": "southeastasia",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-003042",
+              "mode": "duplicate",
+              "workerIoTimerMs": 10652,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450557,
+                  "durationMs": 5279
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727500,
+                  "durationMs": 10160
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 504
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 1452
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446204,
+                      "durationMs": 2007
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723119,
+                      "durationMs": 4787
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4041,
+                      "durationMs": 2768
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4069,
+                      "durationMs": 3921
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 10695.022
+            }
+          ],
+          "write-small-two-reuse": [
+            {
+              "region": "southeastasia",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000111",
+              "mode": "reuse",
+              "workerIoTimerMs": 8567,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6004,
+                  "durationMs": 3328
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6031,
+                  "durationMs": 8250
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 542
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 307,
+                      "durationMs": 1479
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4337,
+                      "durationMs": 1232
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4342,
+                      "durationMs": 3011
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1359,
+                      "durationMs": 1554
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1382,
+                      "durationMs": 3760
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8615.256
+            },
+            {
+              "region": "southeastasia",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-000064",
+              "mode": "reuse",
+              "workerIoTimerMs": 9106,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6101,
+                  "durationMs": 3627
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6136,
+                  "durationMs": 8246
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 307,
+                      "durationMs": 554
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 1427
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4342,
+                      "durationMs": 1348
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4348,
+                      "durationMs": 2767
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1452,
+                      "durationMs": 1725
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1478,
+                      "durationMs": 4052
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 9147.509
+            },
+            {
+              "region": "southeastasia",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-000017",
+              "mode": "reuse",
+              "workerIoTimerMs": 8524,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6261,
+                  "durationMs": 3308
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6284,
+                  "durationMs": 7793
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 540
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 1446
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4348,
+                      "durationMs": 1033
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4354,
+                      "durationMs": 2577
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1603,
+                      "durationMs": 1735
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1621,
+                      "durationMs": 3770
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8564.386
+            },
+            {
+              "region": "southeastasia",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-000098",
+              "mode": "reuse",
+              "workerIoTimerMs": 8956,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6193,
+                  "durationMs": 3363
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6211,
+                  "durationMs": 9058
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 571
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 1543
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4354,
+                      "durationMs": 1092
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4356,
+                      "durationMs": 3465
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1530,
+                      "durationMs": 1700
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1547,
+                      "durationMs": 4050
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8998.601
+            }
+          ],
+          "write-medium-two-reuse": [
+            {
+              "region": "southeastasia",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000111",
+              "mode": "reuse",
+              "workerIoTimerMs": 6844,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148725,
+                  "durationMs": 3833
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148756,
+                  "durationMs": 6191
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 670
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 723
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145952,
+                      "durationMs": 1214
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145960,
+                      "durationMs": 3180
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2463,
+                      "durationMs": 1949
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2485,
+                      "durationMs": 2288
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6890.794
+            },
+            {
+              "region": "southeastasia",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001088",
+              "mode": "reuse",
+              "workerIoTimerMs": 9067,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148618,
+                  "durationMs": 3831
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148658,
+                  "durationMs": 8329
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 496
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 1516
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145960,
+                      "durationMs": 1139
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145976,
+                      "durationMs": 3093
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2347,
+                      "durationMs": 2196
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2371,
+                      "durationMs": 3720
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 9108.066
+            },
+            {
+              "region": "southeastasia",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-002065",
+              "mode": "reuse",
+              "workerIoTimerMs": 8892,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148754,
+                  "durationMs": 3652
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148793,
+                  "durationMs": 8230
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 502
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 1469
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145976,
+                      "durationMs": 1155
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145995,
+                      "durationMs": 2990
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2467,
+                      "durationMs": 1995
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2488,
+                      "durationMs": 3771
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8939.918
+            },
+            {
+              "region": "southeastasia",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-003042",
+              "mode": "reuse",
+              "workerIoTimerMs": 9938,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148609,
+                  "durationMs": 3898
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148651,
+                  "durationMs": 9668
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 638
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 1474
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145995,
+                      "durationMs": 1354
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 146014,
+                      "durationMs": 3628
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2304,
+                      "durationMs": 1906
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2327,
+                      "durationMs": 4566
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 9981.078
+            }
+          ],
+          "write-large-two-reuse": [
+            {
+              "region": "southeastasia",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000111",
+              "mode": "reuse",
+              "workerIoTimerMs": 7880,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727598,
+                  "durationMs": 4537
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727634,
+                  "durationMs": 7025
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 580
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 814
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723048,
+                      "durationMs": 1332
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723056,
+                      "durationMs": 3682
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4238,
+                      "durationMs": 2625
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4266,
+                      "durationMs": 2529
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7933.816
+            },
+            {
+              "region": "southeastasia",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001088",
+              "mode": "reuse",
+              "workerIoTimerMs": 9862,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727837,
+                  "durationMs": 4581
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727882,
+                  "durationMs": 10059
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 513
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 1472
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723056,
+                      "durationMs": 1289
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723073,
+                      "durationMs": 4778
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4469,
+                      "durationMs": 2779
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4496,
+                      "durationMs": 3809
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 9904.511
+            },
+            {
+              "region": "southeastasia",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-002065",
+              "mode": "reuse",
+              "workerIoTimerMs": 11101,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727800,
+                  "durationMs": 5535
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727848,
+                  "durationMs": 11470
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 595
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 1505
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723073,
+                      "durationMs": 1597
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723102,
+                      "durationMs": 5904
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4414,
+                      "durationMs": 3343
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4434,
+                      "durationMs": 4061
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 11146.876
+            },
+            {
+              "region": "southeastasia",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-003042",
+              "mode": "reuse",
+              "workerIoTimerMs": 10615,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727455,
+                  "durationMs": 5124
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727500,
+                  "durationMs": 10416
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 493
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 1434
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723102,
+                      "durationMs": 1481
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723119,
+                      "durationMs": 4925
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4041,
+                      "durationMs": 3150
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4069,
+                      "durationMs": 4057
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 10657.092
+            }
+          ]
+        },
+        "verification": [
+          {
+            "region": "southeastasia",
+            "profile": "small",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "southeastasia",
+            "profile": "small",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "southeastasia",
+            "profile": "medium",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "southeastasia",
+            "profile": "medium",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "southeastasia",
+            "profile": "large",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "southeastasia",
+            "profile": "large",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          }
+        ]
+      }
+    },
+    {
+      "replicate": "a",
+      "region": "japaneast",
+      "result": {
+        "generatedAt": "2026-09-30T02:54:50.518Z",
+        "sourceCommit": "bd8af6eec98b8f4a745d90327e96534c4a09fac0",
+        "harnessCommit": "a1a1d02d9ce71318956e5a5cb9574eed43314c04",
+        "runId": "index-reuse-a",
+        "replicate": "a",
+        "region": "japaneast",
+        "colo": "NRT",
+        "runtime": "Node v22.23.3",
+        "iterations": 4,
+        "samples": {
+          "write-small-one-duplicate": [
+            {
+              "region": "japaneast",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000020",
+              "mode": "duplicate",
+              "workerIoTimerMs": 7364,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5639,
+                  "durationMs": 2945
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3640,
+                  "durationMs": 5868
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 825
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1299
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4040,
+                      "durationMs": 826
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2020,
+                      "durationMs": 1449
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1356,
+                      "durationMs": 1294
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1376,
+                      "durationMs": 3120
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7376.867
+            },
+            {
+              "region": "japaneast",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-000101",
+              "mode": "duplicate",
+              "workerIoTimerMs": 4506,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5734,
+                  "durationMs": 2364
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3734,
+                  "durationMs": 2692
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 445
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 539
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4040,
+                      "durationMs": 623
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2020,
+                      "durationMs": 550
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1450,
+                      "durationMs": 1296
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1471,
+                      "durationMs": 1603
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4516.903
+            },
+            {
+              "region": "japaneast",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-000054",
+              "mode": "duplicate",
+              "workerIoTimerMs": 7652,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5866,
+                  "durationMs": 2842
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3873,
+                  "durationMs": 5815
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 509
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 1318
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4040,
+                      "durationMs": 747
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2023,
+                      "durationMs": 1005
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1583,
+                      "durationMs": 1586
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1607,
+                      "durationMs": 3492
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7663.158
+            },
+            {
+              "region": "japaneast",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-000007",
+              "mode": "duplicate",
+              "workerIoTimerMs": 7302,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5892,
+                  "durationMs": 2768
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3894,
+                  "durationMs": 5605
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 599
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 1240
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4046,
+                      "durationMs": 635
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2024,
+                      "durationMs": 1071
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1603,
+                      "durationMs": 1534
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1627,
+                      "durationMs": 3294
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7311.81
+            }
+          ],
+          "write-medium-one-duplicate": [
+            {
+              "region": "japaneast",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000148",
+              "mode": "duplicate",
+              "workerIoTimerMs": 7562,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134259,
+                  "durationMs": 2829
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68445,
+                  "durationMs": 5936
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 380
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 1278
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131688,
+                      "durationMs": 653
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65847,
+                      "durationMs": 1203
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2328,
+                      "durationMs": 1796
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2355,
+                      "durationMs": 3455
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7575.296
+            },
+            {
+              "region": "japaneast",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001125",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6101,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134567,
+                  "durationMs": 2847
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68755,
+                  "durationMs": 4321
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 418
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 594
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131694,
+                      "durationMs": 806
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65855,
+                      "durationMs": 1067
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2630,
+                      "durationMs": 1623
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2657,
+                      "durationMs": 2660
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6111.869
+            },
+            {
+              "region": "japaneast",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-002102",
+              "mode": "duplicate",
+              "workerIoTimerMs": 7186,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134487,
+                  "durationMs": 2799
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68655,
+                  "durationMs": 5441
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 492
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 1349
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131710,
+                      "durationMs": 786
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65856,
+                      "durationMs": 1054
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2534,
+                      "durationMs": 1521
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2556,
+                      "durationMs": 3038
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7198.017
+            },
+            {
+              "region": "japaneast",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-003079",
+              "mode": "duplicate",
+              "workerIoTimerMs": 7894,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134465,
+                  "durationMs": 2677
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68643,
+                  "durationMs": 6281
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 490
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1282
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131712,
+                      "durationMs": 731
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65864,
+                      "durationMs": 1064
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2510,
+                      "durationMs": 1456
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2535,
+                      "durationMs": 3935
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7905.845
+            }
+          ],
+          "write-large-one-duplicate": [
+            {
+              "region": "japaneast",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000148",
+              "mode": "duplicate",
+              "workerIoTimerMs": 7574,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656232,
+                  "durationMs": 2933
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330210,
+                  "durationMs": 6594
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 506
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1456
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652116,
+                      "durationMs": 818
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326060,
+                      "durationMs": 1953
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 3872,
+                      "durationMs": 1609
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 3906,
+                      "durationMs": 3185
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7585.37
+            },
+            {
+              "region": "japaneast",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001125",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5294,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656870,
+                  "durationMs": 2540
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330844,
+                  "durationMs": 4427
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 325
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 549
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652120,
+                      "durationMs": 550
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326064,
+                      "durationMs": 1673
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4506,
+                      "durationMs": 1665
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4536,
+                      "durationMs": 2205
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5314.065
+            },
+            {
+              "region": "japaneast",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-002102",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5858,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656739,
+                  "durationMs": 3130
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330704,
+                  "durationMs": 3465
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 486
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 532
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652128,
+                      "durationMs": 645
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326064,
+                      "durationMs": 737
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4367,
+                      "durationMs": 1999
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4396,
+                      "durationMs": 2196
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5871.732
+            },
+            {
+              "region": "japaneast",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-003079",
+              "mode": "duplicate",
+              "workerIoTimerMs": 7970,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656899,
+                  "durationMs": 3159
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330874,
+                  "durationMs": 6815
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 544
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1275
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652128,
+                      "durationMs": 799
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326074,
+                      "durationMs": 2004
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4527,
+                      "durationMs": 1816
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4556,
+                      "durationMs": 3536
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7981.337
+            }
+          ],
+          "write-small-one-reuse": [
+            {
+              "region": "japaneast",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000020",
+              "mode": "reuse",
+              "workerIoTimerMs": 6833,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3619,
+                  "durationMs": 2459
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3640,
+                  "durationMs": 5884
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 613
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1292
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2020,
+                      "durationMs": 373
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2020,
+                      "durationMs": 1510
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1356,
+                      "durationMs": 1473
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1376,
+                      "durationMs": 3082
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6846.979
+            },
+            {
+              "region": "japaneast",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-000101",
+              "mode": "reuse",
+              "workerIoTimerMs": 4274,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3714,
+                  "durationMs": 2083
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3734,
+                  "durationMs": 2758
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 409
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 601
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2020,
+                      "durationMs": 303
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2020,
+                      "durationMs": 567
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1450,
+                      "durationMs": 1371
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1471,
+                      "durationMs": 1590
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4287.35
+            },
+            {
+              "region": "japaneast",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-000054",
+              "mode": "reuse",
+              "workerIoTimerMs": 6716,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3846,
+                  "durationMs": 2311
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3873,
+                  "durationMs": 4932
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 327
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 1317
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2020,
+                      "durationMs": 494
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2023,
+                      "durationMs": 527
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1583,
+                      "durationMs": 1490
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1607,
+                      "durationMs": 3088
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6726.658
+            },
+            {
+              "region": "japaneast",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-000007",
+              "mode": "reuse",
+              "workerIoTimerMs": 7254,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3869,
+                  "durationMs": 2244
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3894,
+                  "durationMs": 6111
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 542
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 1295
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2023,
+                      "durationMs": 515
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2024,
+                      "durationMs": 1101
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1603,
+                      "durationMs": 1187
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1627,
+                      "durationMs": 3715
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7265.315
+            }
+          ],
+          "write-medium-one-reuse": [
+            {
+              "region": "japaneast",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000148",
+              "mode": "reuse",
+              "workerIoTimerMs": 7238,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68415,
+                  "durationMs": 2504
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68445,
+                  "durationMs": 5897
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 479
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 1164
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65844,
+                      "durationMs": 509
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65847,
+                      "durationMs": 1163
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2328,
+                      "durationMs": 1516
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2355,
+                      "durationMs": 3570
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7251.297
+            },
+            {
+              "region": "japaneast",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001125",
+              "mode": "reuse",
+              "workerIoTimerMs": 4372,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68720,
+                  "durationMs": 2124
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68755,
+                  "durationMs": 2797
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 412
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 591
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65847,
+                      "durationMs": 455
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65855,
+                      "durationMs": 549
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2630,
+                      "durationMs": 1257
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2657,
+                      "durationMs": 1657
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4385.266
+            },
+            {
+              "region": "japaneast",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-002102",
+              "mode": "reuse",
+              "workerIoTimerMs": 6686,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68632,
+                  "durationMs": 2517
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68655,
+                  "durationMs": 5320
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 485
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 1189
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65855,
+                      "durationMs": 505
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65856,
+                      "durationMs": 1151
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2534,
+                      "durationMs": 1527
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2556,
+                      "durationMs": 2980
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6698.121
+            },
+            {
+              "region": "japaneast",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-003079",
+              "mode": "reuse",
+              "workerIoTimerMs": 7549,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68609,
+                  "durationMs": 2755
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68643,
+                  "durationMs": 5841
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 507
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1269
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65856,
+                      "durationMs": 357
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65864,
+                      "durationMs": 1047
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2510,
+                      "durationMs": 1891
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2535,
+                      "durationMs": 3525
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7559.02
+            }
+          ],
+          "write-large-one-reuse": [
+            {
+              "region": "japaneast",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000148",
+              "mode": "reuse",
+              "workerIoTimerMs": 7694,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330174,
+                  "durationMs": 3087
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330210,
+                  "durationMs": 6047
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 559
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1209
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326058,
+                      "durationMs": 572
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326060,
+                      "durationMs": 1440
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 3872,
+                      "durationMs": 1956
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 3906,
+                      "durationMs": 3398
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7706.446
+            },
+            {
+              "region": "japaneast",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001125",
+              "mode": "reuse",
+              "workerIoTimerMs": 4628,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330810,
+                  "durationMs": 2424
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330844,
+                  "durationMs": 2899
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 441
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 625
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326060,
+                      "durationMs": 327
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326064,
+                      "durationMs": 695
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4506,
+                      "durationMs": 1656
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4536,
+                      "durationMs": 1579
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4658.305
+            },
+            {
+              "region": "japaneast",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-002102",
+              "mode": "reuse",
+              "workerIoTimerMs": 7237,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330675,
+                  "durationMs": 2833
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330704,
+                  "durationMs": 5709
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 388
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1238
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326064,
+                      "durationMs": 574
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326064,
+                      "durationMs": 1305
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4367,
+                      "durationMs": 1871
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4396,
+                      "durationMs": 3166
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7249.468
+            },
+            {
+              "region": "japaneast",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-003079",
+              "mode": "reuse",
+              "workerIoTimerMs": 7728,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330835,
+                  "durationMs": 3370
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330874,
+                  "durationMs": 5625
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 483
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1148
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326064,
+                      "durationMs": 1264
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326074,
+                      "durationMs": 1267
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4527,
+                      "durationMs": 1623
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4556,
+                      "durationMs": 3210
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7739.067
+            }
+          ],
+          "write-small-two-duplicate": [
+            {
+              "region": "japaneast",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000020",
+              "mode": "duplicate",
+              "workerIoTimerMs": 8068,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10338,
+                  "durationMs": 4072
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6021,
+                  "durationMs": 6028
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 580
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 306,
+                      "durationMs": 1120
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8674,
+                      "durationMs": 1466
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4339,
+                      "durationMs": 2032
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1356,
+                      "durationMs": 2026
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1376,
+                      "durationMs": 2876
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8081.634
+            },
+            {
+              "region": "japaneast",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-000101",
+              "mode": "duplicate",
+              "workerIoTimerMs": 4853,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10434,
+                  "durationMs": 2814
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6110,
+                  "durationMs": 3071
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 306,
+                      "durationMs": 426
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 528
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8678,
+                      "durationMs": 1105
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4334,
+                      "durationMs": 1032
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1450,
+                      "durationMs": 1283
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1468,
+                      "durationMs": 1511
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4866.265
+            },
+            {
+              "region": "japaneast",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-000054",
+              "mode": "duplicate",
+              "workerIoTimerMs": 7968,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10557,
+                  "durationMs": 3270
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6254,
+                  "durationMs": 6851
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 517
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 1157
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8668,
+                      "durationMs": 1487
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4341,
+                      "durationMs": 2153
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1581,
+                      "durationMs": 1266
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1605,
+                      "durationMs": 3541
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7980.84
+            },
+            {
+              "region": "japaneast",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-000007",
+              "mode": "duplicate",
+              "workerIoTimerMs": 7844,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10592,
+                  "durationMs": 3483
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6273,
+                  "durationMs": 6572
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 456
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 1292
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8682,
+                      "durationMs": 1361
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4341,
+                      "durationMs": 2211
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1602,
+                      "durationMs": 1666
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1624,
+                      "durationMs": 3069
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7853.763
+            }
+          ],
+          "write-medium-two-duplicate": [
+            {
+              "region": "japaneast",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000148",
+              "mode": "duplicate",
+              "workerIoTimerMs": 8428,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294542,
+                  "durationMs": 3862
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148626,
+                  "durationMs": 7032
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 523
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 1271
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291904,
+                      "durationMs": 1536
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145963,
+                      "durationMs": 2466
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2328,
+                      "durationMs": 1803
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2354,
+                      "durationMs": 3295
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8439.009
+            },
+            {
+              "region": "japaneast",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001125",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5526,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294863,
+                  "durationMs": 2743
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148945,
+                  "durationMs": 3989
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 297
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 626
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291926,
+                      "durationMs": 1145
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145980,
+                      "durationMs": 1206
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2628,
+                      "durationMs": 1301
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2656,
+                      "durationMs": 2157
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5541.325
+            },
+            {
+              "region": "japaneast",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-002102",
+              "mode": "duplicate",
+              "workerIoTimerMs": 8453,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294803,
+                  "durationMs": 3627
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148855,
+                  "durationMs": 7498
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 539
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 1262
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291960,
+                      "durationMs": 1577
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145988,
+                      "durationMs": 2672
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2534,
+                      "durationMs": 1511
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2555,
+                      "durationMs": 3564
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8464.166
+            },
+            {
+              "region": "japaneast",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-003079",
+              "mode": "duplicate",
+              "workerIoTimerMs": 8533,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294797,
+                  "durationMs": 3651
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148853,
+                  "durationMs": 7559
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 405
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 1349
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291976,
+                      "durationMs": 1507
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 146008,
+                      "durationMs": 2677
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2509,
+                      "durationMs": 1739
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2534,
+                      "durationMs": 3533
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8545.85
+            }
+          ],
+          "write-large-two-duplicate": [
+            {
+              "region": "japaneast",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000148",
+              "mode": "duplicate",
+              "workerIoTimerMs": 8614,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450280,
+                  "durationMs": 4085
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727275,
+                  "durationMs": 8257
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 397
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 1277
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446096,
+                      "durationMs": 1688
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723057,
+                      "durationMs": 3728
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 3872,
+                      "durationMs": 2000
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 3907,
+                      "durationMs": 3252
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8625.926
+            },
+            {
+              "region": "japaneast",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001125",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6628,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450931,
+                  "durationMs": 3985
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727921,
+                  "durationMs": 5043
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 513
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 599
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446114,
+                      "durationMs": 1363
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723071,
+                      "durationMs": 2400
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4506,
+                      "durationMs": 2109
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4540,
+                      "durationMs": 2044
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6649.309
+            },
+            {
+              "region": "japaneast",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-002102",
+              "mode": "duplicate",
+              "workerIoTimerMs": 9149,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450820,
+                  "durationMs": 4032
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727783,
+                  "durationMs": 8696
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 504
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 1361
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446142,
+                      "durationMs": 1557
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723077,
+                      "durationMs": 3579
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4368,
+                      "durationMs": 1971
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4394,
+                      "durationMs": 3756
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 9162.073
+            },
+            {
+              "region": "japaneast",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-003079",
+              "mode": "duplicate",
+              "workerIoTimerMs": 8740,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450994,
+                  "durationMs": 4316
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727969,
+                  "durationMs": 7642
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 492
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 1301
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446154,
+                      "durationMs": 1594
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723102,
+                      "durationMs": 3218
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4528,
+                      "durationMs": 2230
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4555,
+                      "durationMs": 3123
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8753.619
+            }
+          ],
+          "write-small-two-reuse": [
+            {
+              "region": "japaneast",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000020",
+              "mode": "reuse",
+              "workerIoTimerMs": 7773,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6001,
+                  "durationMs": 3229
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6021,
+                  "durationMs": 6577
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 478
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 306,
+                      "durationMs": 1244
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4337,
+                      "durationMs": 1053
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4339,
+                      "durationMs": 2033
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1356,
+                      "durationMs": 1698
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1376,
+                      "durationMs": 3300
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7783.357
+            },
+            {
+              "region": "japaneast",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-000101",
+              "mode": "reuse",
+              "workerIoTimerMs": 5293,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6095,
+                  "durationMs": 2673
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6110,
+                  "durationMs": 4338
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 306,
+                      "durationMs": 446
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 535
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4339,
+                      "durationMs": 909
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4334,
+                      "durationMs": 1718
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1450,
+                      "durationMs": 1318
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1468,
+                      "durationMs": 2085
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5303.121
+            },
+            {
+              "region": "japaneast",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-000054",
+              "mode": "reuse",
+              "workerIoTimerMs": 7584,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6223,
+                  "durationMs": 3179
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6254,
+                  "durationMs": 6624
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 520
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 1162
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4334,
+                      "durationMs": 1039
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4341,
+                      "durationMs": 2219
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1581,
+                      "durationMs": 1620
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1605,
+                      "durationMs": 3243
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7597.704
+            },
+            {
+              "region": "japaneast",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-000007",
+              "mode": "reuse",
+              "workerIoTimerMs": 8224,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6251,
+                  "durationMs": 3119
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6273,
+                  "durationMs": 7253
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 540
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 1246
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4341,
+                      "durationMs": 989
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4341,
+                      "durationMs": 2148
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1602,
+                      "durationMs": 1590
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1624,
+                      "durationMs": 3859
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8235.105
+            }
+          ],
+          "write-medium-two-reuse": [
+            {
+              "region": "japaneast",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000148",
+              "mode": "reuse",
+              "workerIoTimerMs": 7649,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148590,
+                  "durationMs": 3215
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148626,
+                  "durationMs": 6749
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 398
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 1286
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145952,
+                      "durationMs": 1224
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145963,
+                      "durationMs": 2315
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2328,
+                      "durationMs": 1593
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2354,
+                      "durationMs": 3148
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7659.715
+            },
+            {
+              "region": "japaneast",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001125",
+              "mode": "reuse",
+              "workerIoTimerMs": 5799,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148900,
+                  "durationMs": 3618
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148945,
+                  "durationMs": 4007
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 555
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 558
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145963,
+                      "durationMs": 1740
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145980,
+                      "durationMs": 1826
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2628,
+                      "durationMs": 1323
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2656,
+                      "durationMs": 1623
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5813.797
+            },
+            {
+              "region": "japaneast",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-002102",
+              "mode": "reuse",
+              "workerIoTimerMs": 8014,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148823,
+                  "durationMs": 3350
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148855,
+                  "durationMs": 7265
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 549
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 1240
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145980,
+                      "durationMs": 1086
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145988,
+                      "durationMs": 2601
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2534,
+                      "durationMs": 1715
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2555,
+                      "durationMs": 3424
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8024.339
+            },
+            {
+              "region": "japaneast",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-003079",
+              "mode": "reuse",
+              "workerIoTimerMs": 7479,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148809,
+                  "durationMs": 3096
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148853,
+                  "durationMs": 6645
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 510
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 1292
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145988,
+                      "durationMs": 1091
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 146008,
+                      "durationMs": 2262
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2509,
+                      "durationMs": 1495
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2534,
+                      "durationMs": 3091
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7490.046
+            }
+          ],
+          "write-large-two-reuse": [
+            {
+              "region": "japaneast",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000148",
+              "mode": "reuse",
+              "workerIoTimerMs": 8704,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727232,
+                  "durationMs": 4173
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727275,
+                  "durationMs": 8120
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 596
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 1279
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723048,
+                      "durationMs": 1713
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723057,
+                      "durationMs": 3589
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 3872,
+                      "durationMs": 1864
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 3907,
+                      "durationMs": 3252
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8715.809
+            },
+            {
+              "region": "japaneast",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001125",
+              "mode": "reuse",
+              "workerIoTimerMs": 5321,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727874,
+                  "durationMs": 3041
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727921,
+                  "durationMs": 4520
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 463
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 584
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723057,
+                      "durationMs": 1089
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723071,
+                      "durationMs": 2240
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4506,
+                      "durationMs": 1489
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4540,
+                      "durationMs": 1696
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5352.982
+            },
+            {
+              "region": "japaneast",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-002102",
+              "mode": "reuse",
+              "workerIoTimerMs": 8936,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727749,
+                  "durationMs": 3696
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727783,
+                  "durationMs": 8532
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 371
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 1277
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723071,
+                      "durationMs": 1265
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723077,
+                      "durationMs": 3292
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4368,
+                      "durationMs": 2060
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4394,
+                      "durationMs": 3963
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8950.587
+            },
+            {
+              "region": "japaneast",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-003079",
+              "mode": "reuse",
+              "workerIoTimerMs": 8513,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727917,
+                  "durationMs": 3579
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727969,
+                  "durationMs": 8155
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 526
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 1203
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723077,
+                      "durationMs": 1204
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723102,
+                      "durationMs": 3221
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4528,
+                      "durationMs": 1849
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4555,
+                      "durationMs": 3731
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8523.11
+            }
+          ]
+        },
+        "verification": [
+          {
+            "region": "japaneast",
+            "profile": "small",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "japaneast",
+            "profile": "small",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "japaneast",
+            "profile": "medium",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "japaneast",
+            "profile": "medium",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "japaneast",
+            "profile": "large",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "japaneast",
+            "profile": "large",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          }
+        ]
+      }
+    },
+    {
+      "replicate": "a",
+      "region": "australiaeast",
+      "result": {
+        "generatedAt": "2026-09-30T02:55:53.699Z",
+        "sourceCommit": "bd8af6eec98b8f4a745d90327e96534c4a09fac0",
+        "harnessCommit": "a1a1d02d9ce71318956e5a5cb9574eed43314c04",
+        "runId": "index-reuse-a",
+        "replicate": "a",
+        "region": "australiaeast",
+        "colo": "SYD",
+        "runtime": "Node v22.23.3",
+        "iterations": 4,
+        "samples": {
+          "write-small-one-duplicate": [
+            {
+              "region": "australiaeast",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000057",
+              "mode": "duplicate",
+              "workerIoTimerMs": 9101,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5733,
+                  "durationMs": 3058
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3739,
+                  "durationMs": 7214
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 763
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1935
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4040,
+                      "durationMs": 801
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2021,
+                      "durationMs": 1171
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1450,
+                      "durationMs": 1494
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1474,
+                      "durationMs": 4108
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 9125.474
+            },
+            {
+              "region": "australiaeast",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-000010",
+              "mode": "duplicate",
+              "workerIoTimerMs": 8250,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5691,
+                  "durationMs": 2760
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3690,
+                  "durationMs": 7181
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 509
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1858
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4042,
+                      "durationMs": 770
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2021,
+                      "durationMs": 1691
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1405,
+                      "durationMs": 1481
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1425,
+                      "durationMs": 3632
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8262.993
+            },
+            {
+              "region": "australiaeast",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-000091",
+              "mode": "duplicate",
+              "workerIoTimerMs": 8455,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5645,
+                  "durationMs": 2882
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3650,
+                  "durationMs": 6783
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 471
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 1403
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4042,
+                      "durationMs": 953
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2023,
+                      "durationMs": 1210
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1359,
+                      "durationMs": 1458
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1385,
+                      "durationMs": 4170
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8470.266
+            },
+            {
+              "region": "australiaeast",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-000044",
+              "mode": "duplicate",
+              "workerIoTimerMs": 8366,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5775,
+                  "durationMs": 2711
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3779,
+                  "durationMs": 6870
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 583
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 1870
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4046,
+                      "durationMs": 675
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2025,
+                      "durationMs": 1215
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1487,
+                      "durationMs": 1453
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1511,
+                      "durationMs": 3785
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8384.223
+            }
+          ],
+          "write-medium-one-duplicate": [
+            {
+              "region": "australiaeast",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000185",
+              "mode": "duplicate",
+              "workerIoTimerMs": 8032,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134449,
+                  "durationMs": 2999
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68630,
+                  "durationMs": 6990
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 495
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 1482
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131688,
+                      "durationMs": 930
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65846,
+                      "durationMs": 1957
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2518,
+                      "durationMs": 1574
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2539,
+                      "durationMs": 3551
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8047.34
+            },
+            {
+              "region": "australiaeast",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001162",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5343,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134176,
+                  "durationMs": 2550
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68359,
+                  "durationMs": 3570
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 390
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 697
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131692,
+                      "durationMs": 659
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65854,
+                      "durationMs": 777
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2239,
+                      "durationMs": 1501
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2261,
+                      "durationMs": 2096
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5364.894
+            },
+            {
+              "region": "australiaeast",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-002139",
+              "mode": "duplicate",
+              "workerIoTimerMs": 8247,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134425,
+                  "durationMs": 3015
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68595,
+                  "durationMs": 6516
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 541
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 1415
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131708,
+                      "durationMs": 877
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65858,
+                      "durationMs": 1284
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2473,
+                      "durationMs": 1597
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2494,
+                      "durationMs": 3817
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8263.114
+            },
+            {
+              "region": "australiaeast",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-003116",
+              "mode": "duplicate",
+              "workerIoTimerMs": 8781,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134289,
+                  "durationMs": 2728
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68459,
+                  "durationMs": 7345
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 463
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 1449
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131716,
+                      "durationMs": 752
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65863,
+                      "durationMs": 1292
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2330,
+                      "durationMs": 1513
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2353,
+                      "durationMs": 4604
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8800.966
+            }
+          ],
+          "write-large-one-duplicate": [
+            {
+              "region": "australiaeast",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000185",
+              "mode": "duplicate",
+              "workerIoTimerMs": 8909,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656690,
+                  "durationMs": 3215
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330661,
+                  "durationMs": 8361
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 488
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1897
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652116,
+                      "durationMs": 836
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326059,
+                      "durationMs": 2667
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4330,
+                      "durationMs": 1891
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4358,
+                      "durationMs": 3797
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8931.986
+            },
+            {
+              "region": "australiaeast",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001162",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5645,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656739,
+                  "durationMs": 2753
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330711,
+                  "durationMs": 4936
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 421
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 709
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652118,
+                      "durationMs": 752
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326063,
+                      "durationMs": 2044
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4377,
+                      "durationMs": 1580
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4405,
+                      "durationMs": 2183
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5671.172
+            },
+            {
+              "region": "australiaeast",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-002139",
+              "mode": "duplicate",
+              "workerIoTimerMs": 8200,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656509,
+                  "durationMs": 3326
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330480,
+                  "durationMs": 6528
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 476
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 1348
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652126,
+                      "durationMs": 835
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326071,
+                      "durationMs": 1654
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4140,
+                      "durationMs": 2015
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4164,
+                      "durationMs": 3526
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8215.26
+            },
+            {
+              "region": "australiaeast",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-003116",
+              "mode": "duplicate",
+              "workerIoTimerMs": 9492,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656566,
+                  "durationMs": 3292
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330523,
+                  "durationMs": 8872
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 524
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1995
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652142,
+                      "durationMs": 759
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326074,
+                      "durationMs": 2672
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4179,
+                      "durationMs": 2009
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4205,
+                      "durationMs": 4205
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 9505.719
+            }
+          ],
+          "write-small-one-reuse": [
+            {
+              "region": "australiaeast",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000057",
+              "mode": "reuse",
+              "workerIoTimerMs": 9267,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3713,
+                  "durationMs": 2731
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3739,
+                  "durationMs": 7788
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 522
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1905
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2020,
+                      "durationMs": 604
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2021,
+                      "durationMs": 1252
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1450,
+                      "durationMs": 1605
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1474,
+                      "durationMs": 4631
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 9285.271
+            },
+            {
+              "region": "australiaeast",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-000010",
+              "mode": "reuse",
+              "workerIoTimerMs": 5715,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3670,
+                  "durationMs": 2359
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3690,
+                  "durationMs": 4066
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 420
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 857
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2021,
+                      "durationMs": 438
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2021,
+                      "durationMs": 710
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1405,
+                      "durationMs": 1501
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1425,
+                      "durationMs": 2499
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5735.012
+            },
+            {
+              "region": "australiaeast",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-000091",
+              "mode": "reuse",
+              "workerIoTimerMs": 7408,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3624,
+                  "durationMs": 2418
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3650,
+                  "durationMs": 6818
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 524
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 1323
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2021,
+                      "durationMs": 458
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2023,
+                      "durationMs": 1828
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1359,
+                      "durationMs": 1436
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1385,
+                      "durationMs": 3667
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7421.851
+            },
+            {
+              "region": "australiaeast",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-000044",
+              "mode": "reuse",
+              "workerIoTimerMs": 7571,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3752,
+                  "durationMs": 2496
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3779,
+                  "durationMs": 6273
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 489
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 1500
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2023,
+                      "durationMs": 478
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2025,
+                      "durationMs": 1198
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1487,
+                      "durationMs": 1529
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1511,
+                      "durationMs": 3575
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7588.633
+            }
+          ],
+          "write-medium-one-reuse": [
+            {
+              "region": "australiaeast",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000185",
+              "mode": "reuse",
+              "workerIoTimerMs": 8542,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68605,
+                  "durationMs": 2580
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68630,
+                  "durationMs": 7186
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 533
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 2431
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65844,
+                      "durationMs": 529
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65846,
+                      "durationMs": 1224
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2518,
+                      "durationMs": 1518
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2539,
+                      "durationMs": 3531
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8558.276
+            },
+            {
+              "region": "australiaeast",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001162",
+              "mode": "reuse",
+              "workerIoTimerMs": 4913,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68330,
+                  "durationMs": 2141
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68359,
+                  "durationMs": 3545
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 401
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 689
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65846,
+                      "durationMs": 407
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65854,
+                      "durationMs": 773
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2239,
+                      "durationMs": 1333
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2261,
+                      "durationMs": 2083
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4930.634
+            },
+            {
+              "region": "australiaeast",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-002139",
+              "mode": "reuse",
+              "workerIoTimerMs": 7524,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68571,
+                  "durationMs": 2551
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68595,
+                  "durationMs": 6352
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 471
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 1457
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65854,
+                      "durationMs": 468
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65858,
+                      "durationMs": 1379
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2473,
+                      "durationMs": 1612
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2494,
+                      "durationMs": 3516
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7542.315
+            },
+            {
+              "region": "australiaeast",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-003116",
+              "mode": "reuse",
+              "workerIoTimerMs": 8449,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68431,
+                  "durationMs": 3048
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68459,
+                  "durationMs": 6734
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 488
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 1319
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65858,
+                      "durationMs": 617
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65863,
+                      "durationMs": 1333
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2330,
+                      "durationMs": 1943
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2353,
+                      "durationMs": 4082
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8467.112
+            }
+          ],
+          "write-large-one-reuse": [
+            {
+              "region": "australiaeast",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000185",
+              "mode": "reuse",
+              "workerIoTimerMs": 8716,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330632,
+                  "durationMs": 3128
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330661,
+                  "durationMs": 7232
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 531
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1881
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326058,
+                      "durationMs": 724
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326059,
+                      "durationMs": 1644
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4330,
+                      "durationMs": 1873
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4358,
+                      "durationMs": 3707
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8734.666
+            },
+            {
+              "region": "australiaeast",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001162",
+              "mode": "reuse",
+              "workerIoTimerMs": 5840,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330680,
+                  "durationMs": 2515
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330711,
+                  "durationMs": 4794
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 401
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 696
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326059,
+                      "durationMs": 453
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326063,
+                      "durationMs": 1469
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4377,
+                      "durationMs": 1661
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4405,
+                      "durationMs": 2629
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5863.385
+            },
+            {
+              "region": "australiaeast",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-002139",
+              "mode": "reuse",
+              "workerIoTimerMs": 8403,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330446,
+                  "durationMs": 3389
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330480,
+                  "durationMs": 6564
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 815
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 1451
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326063,
+                      "durationMs": 791
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326071,
+                      "durationMs": 1550
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4140,
+                      "durationMs": 1783
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4164,
+                      "durationMs": 3563
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8420.996
+            },
+            {
+              "region": "australiaeast",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-003116",
+              "mode": "reuse",
+              "workerIoTimerMs": 8725,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330495,
+                  "durationMs": 3175
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330523,
+                  "durationMs": 7689
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 523
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1306
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326071,
+                      "durationMs": 593
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326074,
+                      "durationMs": 2139
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4179,
+                      "durationMs": 2059
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4205,
+                      "durationMs": 4244
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8739.421
+            }
+          ],
+          "write-small-two-duplicate": [
+            {
+              "region": "australiaeast",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000057",
+              "mode": "duplicate",
+              "workerIoTimerMs": 9566,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10432,
+                  "durationMs": 3821
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6121,
+                  "durationMs": 9192
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 491
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 1613
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8674,
+                      "durationMs": 1854
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4341,
+                      "durationMs": 3447
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1450,
+                      "durationMs": 1476
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1472,
+                      "durationMs": 4132
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 9581.24
+            },
+            {
+              "region": "australiaeast",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-000010",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5970,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10393,
+                  "durationMs": 3009
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6079,
+                  "durationMs": 4354
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 410
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 718
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8682,
+                      "durationMs": 1316
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4344,
+                      "durationMs": 1394
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1403,
+                      "durationMs": 1283
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1425,
+                      "durationMs": 2242
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5987.631
+            },
+            {
+              "region": "australiaeast",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-000091",
+              "mode": "duplicate",
+              "workerIoTimerMs": 9403,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10356,
+                  "durationMs": 3463
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6038,
+                  "durationMs": 9332
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 534
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 1404
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8688,
+                      "durationMs": 1473
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4348,
+                      "durationMs": 3392
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1358,
+                      "durationMs": 1456
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1382,
+                      "durationMs": 4536
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 9422.108
+            },
+            {
+              "region": "australiaeast",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-000044",
+              "mode": "duplicate",
+              "workerIoTimerMs": 8978,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10489,
+                  "durationMs": 3789
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6172,
+                  "durationMs": 8080
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 597
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 1513
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8696,
+                      "durationMs": 1732
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4353,
+                      "durationMs": 2891
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1485,
+                      "durationMs": 1460
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1510,
+                      "durationMs": 3676
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8996.226
+            }
+          ],
+          "write-medium-two-duplicate": [
+            {
+              "region": "australiaeast",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000185",
+              "mode": "duplicate",
+              "workerIoTimerMs": 9739,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294732,
+                  "durationMs": 3859
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148813,
+                  "durationMs": 9229
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 591
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 1420
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291904,
+                      "durationMs": 1593
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145962,
+                      "durationMs": 3349
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2518,
+                      "durationMs": 1675
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2540,
+                      "durationMs": 4460
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 9754.07
+            },
+            {
+              "region": "australiaeast",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001162",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6239,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294472,
+                  "durationMs": 3310
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148540,
+                  "durationMs": 4709
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 441
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 718
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291924,
+                      "durationMs": 1359
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145977,
+                      "durationMs": 1780
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2237,
+                      "durationMs": 1510
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2255,
+                      "durationMs": 2211
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6260.516
+            },
+            {
+              "region": "australiaeast",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-002139",
+              "mode": "duplicate",
+              "workerIoTimerMs": 9823,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294730,
+                  "durationMs": 4097
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148797,
+                  "durationMs": 8539
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 486
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 1934
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291954,
+                      "durationMs": 1949
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145993,
+                      "durationMs": 2813
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2468,
+                      "durationMs": 1662
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2494,
+                      "durationMs": 3792
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 9837.282
+            },
+            {
+              "region": "australiaeast",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-003116",
+              "mode": "duplicate",
+              "workerIoTimerMs": 9558,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294627,
+                  "durationMs": 3998
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148662,
+                  "durationMs": 8348
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 486
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 1391
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291986,
+                      "durationMs": 1741
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 146002,
+                      "durationMs": 2788
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2331,
+                      "durationMs": 1771
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2351,
+                      "durationMs": 4169
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 9575.467
+            }
+          ],
+          "write-large-two-duplicate": [
+            {
+              "region": "australiaeast",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000185",
+              "mode": "duplicate",
+              "workerIoTimerMs": 10820,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450738,
+                  "durationMs": 5083
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727730,
+                  "durationMs": 11455
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 565
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 1481
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446096,
+                      "durationMs": 2146
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723057,
+                      "durationMs": 5718
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4330,
+                      "durationMs": 2372
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4362,
+                      "durationMs": 4256
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 10839.057
+            },
+            {
+              "region": "australiaeast",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001162",
+              "mode": "duplicate",
+              "workerIoTimerMs": 7649,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450804,
+                  "durationMs": 4171
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727789,
+                  "durationMs": 6733
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 441
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 695
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446114,
+                      "durationMs": 1646
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723071,
+                      "durationMs": 3255
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4379,
+                      "durationMs": 2084
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4406,
+                      "durationMs": 2783
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7674.981
+            },
+            {
+              "region": "australiaeast",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-002139",
+              "mode": "duplicate",
+              "workerIoTimerMs": 9941,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450595,
+                  "durationMs": 4734
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727569,
+                  "durationMs": 9517
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 513
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 1445
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446142,
+                      "durationMs": 1849
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723091,
+                      "durationMs": 4310
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4141,
+                      "durationMs": 2372
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4165,
+                      "durationMs": 3762
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 9956.143
+            },
+            {
+              "region": "australiaeast",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-003116",
+              "mode": "duplicate",
+              "workerIoTimerMs": 9987,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450674,
+                  "durationMs": 4821
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727624,
+                  "durationMs": 9341
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 502
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 1324
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446182,
+                      "durationMs": 2053
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723102,
+                      "durationMs": 4175
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4179,
+                      "durationMs": 2266
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4210,
+                      "durationMs": 3842
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 10004.668
+            }
+          ],
+          "write-small-two-reuse": [
+            {
+              "region": "australiaeast",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000057",
+              "mode": "reuse",
+              "workerIoTimerMs": 8328,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6095,
+                  "durationMs": 3008
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6121,
+                  "durationMs": 7744
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 517
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 1282
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4337,
+                      "durationMs": 964
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4341,
+                      "durationMs": 2424
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1450,
+                      "durationMs": 1527
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1472,
+                      "durationMs": 4038
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8343.095
+            },
+            {
+              "region": "australiaeast",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-000010",
+              "mode": "reuse",
+              "workerIoTimerMs": 5982,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6052,
+                  "durationMs": 2547
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6079,
+                  "durationMs": 4846
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 426
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 1343
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4341,
+                      "durationMs": 823
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4344,
+                      "durationMs": 1411
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1403,
+                      "durationMs": 1298
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1425,
+                      "durationMs": 2092
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5998.198
+            },
+            {
+              "region": "australiaeast",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-000091",
+              "mode": "reuse",
+              "workerIoTimerMs": 7838,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6012,
+                  "durationMs": 2862
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6038,
+                  "durationMs": 7888
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 469
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 1313
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4344,
+                      "durationMs": 937
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4348,
+                      "durationMs": 2912
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1358,
+                      "durationMs": 1456
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1382,
+                      "durationMs": 3663
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7857.357
+            },
+            {
+              "region": "australiaeast",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-000044",
+              "mode": "reuse",
+              "workerIoTimerMs": 9113,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6141,
+                  "durationMs": 3071
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6172,
+                  "durationMs": 8915
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 480
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 1472
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4348,
+                      "durationMs": 995
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4353,
+                      "durationMs": 2873
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1485,
+                      "durationMs": 1596
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1510,
+                      "durationMs": 4570
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 9128.445
+            }
+          ],
+          "write-medium-two-reuse": [
+            {
+              "region": "australiaeast",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000185",
+              "mode": "reuse",
+              "workerIoTimerMs": 6691,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148780,
+                  "durationMs": 2812
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148813,
+                  "durationMs": 6838
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 403
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 793
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145952,
+                      "durationMs": 867
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145962,
+                      "durationMs": 2959
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2518,
+                      "durationMs": 1542
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2540,
+                      "durationMs": 3086
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6709.206
+            },
+            {
+              "region": "australiaeast",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001162",
+              "mode": "reuse",
+              "workerIoTimerMs": 8348,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148510,
+                  "durationMs": 3197
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148540,
+                  "durationMs": 8436
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 552
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 1427
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145962,
+                      "durationMs": 933
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145977,
+                      "durationMs": 3285
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2237,
+                      "durationMs": 1712
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2255,
+                      "durationMs": 3724
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8362.153
+            },
+            {
+              "region": "australiaeast",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-002139",
+              "mode": "reuse",
+              "workerIoTimerMs": 8965,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148753,
+                  "durationMs": 3088
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148797,
+                  "durationMs": 8645
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 476
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 1905
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145977,
+                      "durationMs": 992
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145993,
+                      "durationMs": 2768
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2468,
+                      "durationMs": 1620
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2494,
+                      "durationMs": 3972
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8980.712
+            },
+            {
+              "region": "australiaeast",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-003116",
+              "mode": "reuse",
+              "workerIoTimerMs": 8746,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148634,
+                  "durationMs": 3328
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148662,
+                  "durationMs": 8171
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 473
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 1417
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145993,
+                      "durationMs": 1134
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 146002,
+                      "durationMs": 2753
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2331,
+                      "durationMs": 1721
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2351,
+                      "durationMs": 4001
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8760.937
+            }
+          ],
+          "write-large-two-reuse": [
+            {
+              "region": "australiaeast",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000185",
+              "mode": "reuse",
+              "workerIoTimerMs": 7037,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727690,
+                  "durationMs": 3680
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727730,
+                  "durationMs": 6271
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 428
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 740
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723048,
+                      "durationMs": 1187
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723057,
+                      "durationMs": 2914
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4330,
+                      "durationMs": 2065
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4362,
+                      "durationMs": 2617
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7064.388
+            },
+            {
+              "region": "australiaeast",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001162",
+              "mode": "reuse",
+              "workerIoTimerMs": 9479,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727747,
+                  "durationMs": 4310
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727789,
+                  "durationMs": 9462
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 514
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 1423
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723057,
+                      "durationMs": 1240
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723071,
+                      "durationMs": 4293
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4379,
+                      "durationMs": 2556
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4406,
+                      "durationMs": 3746
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 9498.189
+            },
+            {
+              "region": "australiaeast",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-002139",
+              "mode": "reuse",
+              "workerIoTimerMs": 9691,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727524,
+                  "durationMs": 4065
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727569,
+                  "durationMs": 10193
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 543
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 1434
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723071,
+                      "durationMs": 1257
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723091,
+                      "durationMs": 4567
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4141,
+                      "durationMs": 2265
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4165,
+                      "durationMs": 4192
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 9706.283
+            },
+            {
+              "region": "australiaeast",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-003116",
+              "mode": "reuse",
+              "workerIoTimerMs": 9406,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727583,
+                  "durationMs": 3846
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727624,
+                  "durationMs": 10687
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 471
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 1419
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723091,
+                      "durationMs": 1167
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723102,
+                      "durationMs": 5127
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4179,
+                      "durationMs": 2208
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4210,
+                      "durationMs": 4141
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 9434.998
+            }
+          ]
+        },
+        "verification": [
+          {
+            "region": "australiaeast",
+            "profile": "small",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "australiaeast",
+            "profile": "small",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "australiaeast",
+            "profile": "medium",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "australiaeast",
+            "profile": "medium",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "australiaeast",
+            "profile": "large",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "australiaeast",
+            "profile": "large",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          }
+        ]
+      }
+    },
+    {
+      "replicate": "a",
+      "region": "brazilsouth",
+      "result": {
+        "generatedAt": "2026-09-30T02:55:34.299Z",
+        "sourceCommit": "bd8af6eec98b8f4a745d90327e96534c4a09fac0",
+        "harnessCommit": "a1a1d02d9ce71318956e5a5cb9574eed43314c04",
+        "runId": "index-reuse-a",
+        "replicate": "a",
+        "region": "brazilsouth",
+        "colo": "GRU",
+        "runtime": "Node v22.23.3",
+        "iterations": 4,
+        "samples": {
+          "write-small-one-duplicate": [
+            {
+              "region": "brazilsouth",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000094",
+              "mode": "duplicate",
+              "workerIoTimerMs": 7706,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5724,
+                  "durationMs": 2998
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3725,
+                  "durationMs": 5916
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 738
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 1404
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4040,
+                      "durationMs": 750
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2022,
+                      "durationMs": 1208
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1441,
+                      "durationMs": 1510
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1460,
+                      "durationMs": 3304
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7726.893
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-000047",
+              "mode": "duplicate",
+              "workerIoTimerMs": 7270,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5905,
+                  "durationMs": 2635
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3906,
+                  "durationMs": 5840
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 477
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 1278
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4044,
+                      "durationMs": 747
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2023,
+                      "durationMs": 1205
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1618,
+                      "durationMs": 1411
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1640,
+                      "durationMs": 3357
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7284.331
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-000000",
+              "mode": "duplicate",
+              "workerIoTimerMs": 8060,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5653,
+                  "durationMs": 2735
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3649,
+                  "durationMs": 6501
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 500
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 1343
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4046,
+                      "durationMs": 731
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2023,
+                      "durationMs": 1176
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1364,
+                      "durationMs": 1504
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1383,
+                      "durationMs": 3982
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8076.56
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-000081",
+              "mode": "duplicate",
+              "workerIoTimerMs": 7731,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5686,
+                  "durationMs": 3114
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3687,
+                  "durationMs": 5761
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 516
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 1359
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4046,
+                      "durationMs": 765
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2025,
+                      "durationMs": 1144
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1397,
+                      "durationMs": 1833
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1419,
+                      "durationMs": 3258
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7746.91
+            }
+          ],
+          "write-medium-one-duplicate": [
+            {
+              "region": "brazilsouth",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000222",
+              "mode": "duplicate",
+              "workerIoTimerMs": 8386,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134350,
+                  "durationMs": 2762
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68532,
+                  "durationMs": 6795
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 483
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 1804
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131688,
+                      "durationMs": 755
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65846,
+                      "durationMs": 1171
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2419,
+                      "durationMs": 1524
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2443,
+                      "durationMs": 3820
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8401.722
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001199",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5622,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134594,
+                  "durationMs": 2505
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68784,
+                  "durationMs": 3823
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 391
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 1199
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131692,
+                      "durationMs": 767
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65854,
+                      "durationMs": 706
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2659,
+                      "durationMs": 1347
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2687,
+                      "durationMs": 1918
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5639.974
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-002176",
+              "mode": "duplicate",
+              "workerIoTimerMs": 7775,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134581,
+                  "durationMs": 2867
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68755,
+                  "durationMs": 6056
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 509
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1366
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131708,
+                      "durationMs": 808
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65858,
+                      "durationMs": 1148
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2630,
+                      "durationMs": 1550
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2653,
+                      "durationMs": 3542
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7790.086
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-003153",
+              "mode": "duplicate",
+              "workerIoTimerMs": 8519,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134434,
+                  "durationMs": 2948
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68602,
+                  "durationMs": 6798
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 579
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 1365
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131716,
+                      "durationMs": 822
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65866,
+                      "durationMs": 1227
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2474,
+                      "durationMs": 1547
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2494,
+                      "durationMs": 4206
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8533.866
+            }
+          ],
+          "write-large-one-duplicate": [
+            {
+              "region": "brazilsouth",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000222",
+              "mode": "duplicate",
+              "workerIoTimerMs": 8065,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656518,
+                  "durationMs": 3151
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330497,
+                  "durationMs": 6531
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 621
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 1362
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652116,
+                      "durationMs": 733
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326061,
+                      "durationMs": 1617
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4158,
+                      "durationMs": 1797
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4191,
+                      "durationMs": 3552
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8080.135
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001199",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5942,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656839,
+                  "durationMs": 2691
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330810,
+                  "durationMs": 4275
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 420
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 649
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652122,
+                      "durationMs": 748
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326065,
+                      "durationMs": 1024
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4472,
+                      "durationMs": 1523
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4500,
+                      "durationMs": 2602
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5972.511
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-002176",
+              "mode": "duplicate",
+              "workerIoTimerMs": 8101,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656881,
+                  "durationMs": 3066
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330848,
+                  "durationMs": 6532
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 545
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1387
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652130,
+                      "durationMs": 730
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326072,
+                      "durationMs": 1497
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4506,
+                      "durationMs": 1791
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4532,
+                      "durationMs": 3648
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8119.632
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-003153",
+              "mode": "duplicate",
+              "workerIoTimerMs": 7935,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656842,
+                  "durationMs": 3178
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330802,
+                  "durationMs": 6877
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 522
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 1331
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652144,
+                      "durationMs": 848
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326078,
+                      "durationMs": 2120
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4454,
+                      "durationMs": 1808
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4481,
+                      "durationMs": 3426
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7953.093
+            }
+          ],
+          "write-small-one-reuse": [
+            {
+              "region": "brazilsouth",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000094",
+              "mode": "reuse",
+              "workerIoTimerMs": 7885,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3704,
+                  "durationMs": 2433
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3725,
+                  "durationMs": 6597
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 497
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 1394
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2020,
+                      "durationMs": 483
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2022,
+                      "durationMs": 1145
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1441,
+                      "durationMs": 1453
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1460,
+                      "durationMs": 4058
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7904.944
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-000047",
+              "mode": "reuse",
+              "workerIoTimerMs": 5716,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3883,
+                  "durationMs": 2071
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3906,
+                  "durationMs": 4251
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 430
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 1250
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2022,
+                      "durationMs": 384
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2023,
+                      "durationMs": 606
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1618,
+                      "durationMs": 1257
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1640,
+                      "durationMs": 2395
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5730.224
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-000000",
+              "mode": "reuse",
+              "workerIoTimerMs": 7137,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3630,
+                  "durationMs": 2393
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3649,
+                  "durationMs": 6136
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 498
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 1348
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2023,
+                      "durationMs": 421
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2023,
+                      "durationMs": 1392
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1364,
+                      "durationMs": 1474
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1383,
+                      "durationMs": 3396
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7154.342
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-000081",
+              "mode": "reuse",
+              "workerIoTimerMs": 9366,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3663,
+                  "durationMs": 2683
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3687,
+                  "durationMs": 7931
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 462
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 1865
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2023,
+                      "durationMs": 437
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2025,
+                      "durationMs": 1248
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1397,
+                      "durationMs": 1784
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1419,
+                      "durationMs": 4818
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 9380.755
+            }
+          ],
+          "write-medium-one-reuse": [
+            {
+              "region": "brazilsouth",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000222",
+              "mode": "reuse",
+              "workerIoTimerMs": 8491,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68506,
+                  "durationMs": 2574
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68532,
+                  "durationMs": 7095
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 502
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 1509
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65844,
+                      "durationMs": 489
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65846,
+                      "durationMs": 1178
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2419,
+                      "durationMs": 1583
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2443,
+                      "durationMs": 4408
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8508.538
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001199",
+              "mode": "reuse",
+              "workerIoTimerMs": 5216,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68748,
+                  "durationMs": 2195
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68784,
+                  "durationMs": 3679
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 485
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 647
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65846,
+                      "durationMs": 393
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65854,
+                      "durationMs": 658
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2659,
+                      "durationMs": 1317
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2687,
+                      "durationMs": 2374
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5233.898
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-002176",
+              "mode": "reuse",
+              "workerIoTimerMs": 7595,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68727,
+                  "durationMs": 2651
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68755,
+                  "durationMs": 6138
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 499
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1318
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65854,
+                      "durationMs": 488
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65858,
+                      "durationMs": 1194
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2630,
+                      "durationMs": 1664
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2653,
+                      "durationMs": 3626
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7613.895
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-003153",
+              "mode": "reuse",
+              "workerIoTimerMs": 8304,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68576,
+                  "durationMs": 2582
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68602,
+                  "durationMs": 6845
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 531
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 1481
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65858,
+                      "durationMs": 496
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65866,
+                      "durationMs": 1123
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2474,
+                      "durationMs": 1555
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2494,
+                      "durationMs": 4241
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8320.017
+            }
+          ],
+          "write-large-one-reuse": [
+            {
+              "region": "brazilsouth",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000222",
+              "mode": "reuse",
+              "workerIoTimerMs": 7784,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330460,
+                  "durationMs": 2976
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330497,
+                  "durationMs": 6311
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 637
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 1327
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326058,
+                      "durationMs": 535
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326061,
+                      "durationMs": 1503
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4158,
+                      "durationMs": 1804
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4191,
+                      "durationMs": 3481
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7800.951
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001199",
+              "mode": "reuse",
+              "workerIoTimerMs": 5912,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330778,
+                  "durationMs": 2571
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330810,
+                  "durationMs": 4307
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 428
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 670
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326061,
+                      "durationMs": 469
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326065,
+                      "durationMs": 966
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4472,
+                      "durationMs": 1674
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4500,
+                      "durationMs": 2671
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5936.52
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-002176",
+              "mode": "reuse",
+              "workerIoTimerMs": 7954,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330816,
+                  "durationMs": 3168
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330848,
+                  "durationMs": 6587
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 521
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1272
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326065,
+                      "durationMs": 479
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326072,
+                      "durationMs": 1801
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4506,
+                      "durationMs": 2168
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4532,
+                      "durationMs": 3514
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7969.278
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-003153",
+              "mode": "reuse",
+              "workerIoTimerMs": 7909,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330770,
+                  "durationMs": 2927
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330802,
+                  "durationMs": 6670
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 563
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 1357
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326072,
+                      "durationMs": 524
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326078,
+                      "durationMs": 1688
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4454,
+                      "durationMs": 1840
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4481,
+                      "durationMs": 3625
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7925.542
+            }
+          ],
+          "write-small-two-duplicate": [
+            {
+              "region": "brazilsouth",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000094",
+              "mode": "duplicate",
+              "workerIoTimerMs": 10305,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10423,
+                  "durationMs": 3844
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6110,
+                  "durationMs": 8855
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 477
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 1929
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8674,
+                      "durationMs": 1718
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4342,
+                      "durationMs": 2394
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1441,
+                      "durationMs": 1649
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1460,
+                      "durationMs": 4532
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 10321.589
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-000047",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5549,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10609,
+                  "durationMs": 2985
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6296,
+                  "durationMs": 3911
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 396
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 666
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8684,
+                      "durationMs": 1277
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4346,
+                      "durationMs": 1347
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1617,
+                      "durationMs": 1312
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1641,
+                      "durationMs": 1898
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5567.049
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-000000",
+              "mode": "duplicate",
+              "workerIoTimerMs": 9093,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10366,
+                  "durationMs": 3322
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6036,
+                  "durationMs": 8137
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 469
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 305,
+                      "durationMs": 1884
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8692,
+                      "durationMs": 1415
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4347,
+                      "durationMs": 2366
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1365,
+                      "durationMs": 1438
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1384,
+                      "durationMs": 3887
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 9108.67
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-000081",
+              "mode": "duplicate",
+              "workerIoTimerMs": 9233,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10396,
+                  "durationMs": 3793
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6080,
+                  "durationMs": 7777
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 305,
+                      "durationMs": 530
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 1359
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8694,
+                      "durationMs": 1563
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4352,
+                      "durationMs": 2337
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1397,
+                      "durationMs": 1700
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1419,
+                      "durationMs": 4081
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 9250.141
+            }
+          ],
+          "write-medium-two-duplicate": [
+            {
+              "region": "brazilsouth",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000222",
+              "mode": "duplicate",
+              "workerIoTimerMs": 8548,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294633,
+                  "durationMs": 3581
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148711,
+                  "durationMs": 7485
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 465
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 1375
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291904,
+                      "durationMs": 1591
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145960,
+                      "durationMs": 2518
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2419,
+                      "durationMs": 1525
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2442,
+                      "durationMs": 3592
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8565.694
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001199",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6251,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294888,
+                  "durationMs": 3231
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148974,
+                  "durationMs": 5239
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 384
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 1194
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291920,
+                      "durationMs": 1208
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145977,
+                      "durationMs": 2219
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2659,
+                      "durationMs": 1639
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2687,
+                      "durationMs": 1826
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6272.745
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-002176",
+              "mode": "duplicate",
+              "workerIoTimerMs": 9184,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294892,
+                  "durationMs": 3901
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148952,
+                  "durationMs": 7932
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 478
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 1306
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291954,
+                      "durationMs": 1644
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145992,
+                      "durationMs": 2649
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2628,
+                      "durationMs": 1779
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2650,
+                      "durationMs": 3977
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 9199.518
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-003153",
+              "mode": "duplicate",
+              "workerIoTimerMs": 9314,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294765,
+                  "durationMs": 3768
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148812,
+                  "durationMs": 8900
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 744
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 1370
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291984,
+                      "durationMs": 1426
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 146008,
+                      "durationMs": 3354
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2471,
+                      "durationMs": 1598
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2494,
+                      "durationMs": 4176
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 9328.616
+            }
+          ],
+          "write-large-two-duplicate": [
+            {
+              "region": "brazilsouth",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000222",
+              "mode": "duplicate",
+              "workerIoTimerMs": 9866,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450566,
+                  "durationMs": 4997
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727559,
+                  "durationMs": 9122
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 717
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 1297
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446096,
+                      "durationMs": 2028
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723056,
+                      "durationMs": 4253
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4158,
+                      "durationMs": 2252
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4192,
+                      "durationMs": 3572
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 9883.934
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001199",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6586,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450894,
+                  "durationMs": 3667
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727885,
+                  "durationMs": 5680
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 394
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 672
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446112,
+                      "durationMs": 1429
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723070,
+                      "durationMs": 2761
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4471,
+                      "durationMs": 1844
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4502,
+                      "durationMs": 2247
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6619.084
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-002176",
+              "mode": "duplicate",
+              "workerIoTimerMs": 9740,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450959,
+                  "durationMs": 4643
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727933,
+                  "durationMs": 8922
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 451
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 1270
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446140,
+                      "durationMs": 1895
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723090,
+                      "durationMs": 3825
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4506,
+                      "durationMs": 2297
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4532,
+                      "durationMs": 3827
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 9759.439
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-003153",
+              "mode": "duplicate",
+              "workerIoTimerMs": 10876,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450944,
+                  "durationMs": 4782
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727901,
+                  "durationMs": 12017
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 464
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 1869
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446180,
+                      "durationMs": 1764
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723107,
+                      "durationMs": 5923
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4453,
+                      "durationMs": 2554
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4482,
+                      "durationMs": 4225
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 10901.264
+            }
+          ],
+          "write-small-two-reuse": [
+            {
+              "region": "brazilsouth",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000094",
+              "mode": "reuse",
+              "workerIoTimerMs": 8852,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6086,
+                  "durationMs": 3002
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6110,
+                  "durationMs": 8213
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 527
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 1356
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4337,
+                      "durationMs": 1050
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4342,
+                      "durationMs": 2363
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1441,
+                      "durationMs": 1425
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1460,
+                      "durationMs": 4494
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8869.341
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-000047",
+              "mode": "reuse",
+              "workerIoTimerMs": 5554,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6267,
+                  "durationMs": 2497
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6296,
+                  "durationMs": 4600
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 392
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 645
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4342,
+                      "durationMs": 838
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4346,
+                      "durationMs": 1543
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1617,
+                      "durationMs": 1267
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1641,
+                      "durationMs": 2412
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5571.379
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-000000",
+              "mode": "reuse",
+              "workerIoTimerMs": 7983,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6020,
+                  "durationMs": 2812
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6036,
+                  "durationMs": 7575
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 467
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 305,
+                      "durationMs": 1871
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4346,
+                      "durationMs": 927
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4347,
+                      "durationMs": 2404
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1365,
+                      "durationMs": 1418
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1384,
+                      "durationMs": 3300
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8001.11
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-000081",
+              "mode": "reuse",
+              "workerIoTimerMs": 8537,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6049,
+                  "durationMs": 3721
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6080,
+                  "durationMs": 7338
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 305,
+                      "durationMs": 933
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 1357
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4347,
+                      "durationMs": 998
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4352,
+                      "durationMs": 2522
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1397,
+                      "durationMs": 1790
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1419,
+                      "durationMs": 3459
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8552.629
+            }
+          ],
+          "write-medium-two-reuse": [
+            {
+              "region": "brazilsouth",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000222",
+              "mode": "reuse",
+              "workerIoTimerMs": 7298,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148681,
+                  "durationMs": 2951
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148711,
+                  "durationMs": 7745
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 519
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 1166
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145952,
+                      "durationMs": 948
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145960,
+                      "durationMs": 3398
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2419,
+                      "durationMs": 1484
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2442,
+                      "durationMs": 3181
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7313.744
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001199",
+              "mode": "reuse",
+              "workerIoTimerMs": 5995,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148928,
+                  "durationMs": 2796
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148974,
+                  "durationMs": 4800
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 393
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 1267
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145960,
+                      "durationMs": 838
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145977,
+                      "durationMs": 1601
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2659,
+                      "durationMs": 1565
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2687,
+                      "durationMs": 1932
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6011.7
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-002176",
+              "mode": "reuse",
+              "workerIoTimerMs": 7935,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148915,
+                  "durationMs": 3293
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148952,
+                  "durationMs": 7856
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 447
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 1258
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145977,
+                      "durationMs": 1108
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145992,
+                      "durationMs": 3214
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2628,
+                      "durationMs": 1738
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2650,
+                      "durationMs": 3384
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7952.112
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-003153",
+              "mode": "reuse",
+              "workerIoTimerMs": 7688,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148773,
+                  "durationMs": 3113
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148812,
+                  "durationMs": 7197
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 433
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 1301
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145992,
+                      "durationMs": 988
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 146008,
+                      "durationMs": 2622
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2471,
+                      "durationMs": 1692
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2494,
+                      "durationMs": 3274
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7713.737
+            }
+          ],
+          "write-large-two-reuse": [
+            {
+              "region": "brazilsouth",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000222",
+              "mode": "reuse",
+              "workerIoTimerMs": 6127,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727518,
+                  "durationMs": 3483
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727559,
+                  "durationMs": 5796
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 397
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 623
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723048,
+                      "durationMs": 1085
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723056,
+                      "durationMs": 3152
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4158,
+                      "durationMs": 2001
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4192,
+                      "durationMs": 2021
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6164.567
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001199",
+              "mode": "reuse",
+              "workerIoTimerMs": 9518,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727838,
+                  "durationMs": 3985
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727885,
+                  "durationMs": 9236
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 494
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 1915
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723056,
+                      "durationMs": 1336
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723070,
+                      "durationMs": 3703
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4471,
+                      "durationMs": 2155
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4502,
+                      "durationMs": 3618
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 9533.916
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-002176",
+              "mode": "reuse",
+              "workerIoTimerMs": 10315,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727889,
+                  "durationMs": 3871
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727933,
+                  "durationMs": 11496
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 463
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 1848
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723070,
+                      "durationMs": 1186
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723090,
+                      "durationMs": 5052
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4506,
+                      "durationMs": 2222
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4532,
+                      "durationMs": 4596
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 10331.675
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-003153",
+              "mode": "reuse",
+              "workerIoTimerMs": 10930,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727854,
+                  "durationMs": 4902
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727901,
+                  "durationMs": 10769
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 505
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 1352
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723090,
+                      "durationMs": 1527
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723107,
+                      "durationMs": 4741
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4453,
+                      "durationMs": 2870
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4482,
+                      "durationMs": 4676
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 10944.592
+            }
+          ]
+        },
+        "verification": [
+          {
+            "region": "brazilsouth",
+            "profile": "small",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "brazilsouth",
+            "profile": "small",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "brazilsouth",
+            "profile": "medium",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "brazilsouth",
+            "profile": "medium",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "brazilsouth",
+            "profile": "large",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "brazilsouth",
+            "profile": "large",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          }
+        ]
+      }
+    },
+    {
+      "replicate": "b",
+      "region": "eastus",
+      "result": {
+        "generatedAt": "2026-09-30T03:24:19.679Z",
+        "sourceCommit": "bd8af6eec98b8f4a745d90327e96534c4a09fac0",
+        "harnessCommit": "a1a1d02d9ce71318956e5a5cb9574eed43314c04",
+        "runId": "index-reuse-b",
+        "replicate": "b",
+        "region": "eastus",
+        "colo": "IAD",
+        "runtime": "Node v22.23.3",
+        "iterations": 4,
+        "samples": {
+          "write-small-one-duplicate": [
+            {
+              "region": "eastus",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000000",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2380,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5646,
+                  "durationMs": 1088
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3649,
+                  "durationMs": 1547
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 228
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 264
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4040,
+                      "durationMs": 266
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2021,
+                      "durationMs": 255
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1363,
+                      "durationMs": 594
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1384,
+                      "durationMs": 1028
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2398.247
+            },
+            {
+              "region": "eastus",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-000081",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2354,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5682,
+                  "durationMs": 1168
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3686,
+                  "durationMs": 1451
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 393
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 258
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4042,
+                      "durationMs": 276
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2024,
+                      "durationMs": 265
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1396,
+                      "durationMs": 499
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1418,
+                      "durationMs": 928
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2371.406
+            },
+            {
+              "region": "eastus",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-000034",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2012,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5742,
+                  "durationMs": 963
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3744,
+                  "durationMs": 1304
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 181
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 281
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4048,
+                      "durationMs": 307
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2026,
+                      "durationMs": 255
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1450,
+                      "durationMs": 475
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1475,
+                      "durationMs": 768
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2027.716
+            },
+            {
+              "region": "eastus",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-000115",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2087,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5706,
+                  "durationMs": 1060
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3699,
+                  "durationMs": 1318
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 267
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 272
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4052,
+                      "durationMs": 276
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2027,
+                      "durationMs": 291
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1411,
+                      "durationMs": 517
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1429,
+                      "durationMs": 755
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2106.156
+            }
+          ],
+          "write-medium-one-duplicate": [
+            {
+              "region": "eastus",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000000",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2101,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134248,
+                  "durationMs": 1033
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68434,
+                  "durationMs": 1387
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 161
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 267
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131688,
+                      "durationMs": 255
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65850,
+                      "durationMs": 319
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2317,
+                      "durationMs": 617
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2340,
+                      "durationMs": 801
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2137.047
+            },
+            {
+              "region": "eastus",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-000977",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2285,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134482,
+                  "durationMs": 1094
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68657,
+                  "durationMs": 1457
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 156
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 256
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131700,
+                      "durationMs": 315
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65854,
+                      "durationMs": 266
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2538,
+                      "durationMs": 623
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2559,
+                      "durationMs": 935
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2308.08
+            },
+            {
+              "region": "eastus",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-001954",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2054,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134514,
+                  "durationMs": 1013
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68683,
+                  "durationMs": 1334
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 155
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 268
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131708,
+                      "durationMs": 282
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65856,
+                      "durationMs": 293
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2562,
+                      "durationMs": 576
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2584,
+                      "durationMs": 773
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2080.911
+            },
+            {
+              "region": "eastus",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-002931",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2190,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134419,
+                  "durationMs": 1118
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68587,
+                  "durationMs": 1416
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 158
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 260
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131712,
+                      "durationMs": 270
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65860,
+                      "durationMs": 344
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2464,
+                      "durationMs": 690
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2484,
+                      "durationMs": 812
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2219.772
+            }
+          ],
+          "write-large-one-duplicate": [
+            {
+              "region": "eastus",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000000",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2729,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656367,
+                  "durationMs": 1620
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330341,
+                  "durationMs": 1984
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 217
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 273
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652116,
+                      "durationMs": 431
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326061,
+                      "durationMs": 875
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4007,
+                      "durationMs": 972
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4036,
+                      "durationMs": 836
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2797.224
+            },
+            {
+              "region": "eastus",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-000977",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2280,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656564,
+                  "durationMs": 1171
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330531,
+                  "durationMs": 1548
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 174
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 277
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652122,
+                      "durationMs": 293
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326062,
+                      "durationMs": 439
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4198,
+                      "durationMs": 704
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4225,
+                      "durationMs": 832
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2342.737
+            },
+            {
+              "region": "eastus",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-001954",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2679,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 657042,
+                  "durationMs": 1426
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 331012,
+                  "durationMs": 1881
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 150
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 313
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652124,
+                      "durationMs": 351
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326067,
+                      "durationMs": 628
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4674,
+                      "durationMs": 925
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4700,
+                      "durationMs": 940
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2744.08
+            },
+            {
+              "region": "eastus",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-002931",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2390,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656618,
+                  "durationMs": 1268
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330578,
+                  "durationMs": 1693
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 156
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 290
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652134,
+                      "durationMs": 377
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326069,
+                      "durationMs": 571
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4239,
+                      "durationMs": 735
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4265,
+                      "durationMs": 832
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2469.406
+            }
+          ],
+          "write-small-one-reuse": [
+            {
+              "region": "eastus",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000000",
+              "mode": "reuse",
+              "workerIoTimerMs": 2135,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3626,
+                  "durationMs": 994
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3649,
+                  "durationMs": 1389
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 186
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 283
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2020,
+                      "durationMs": 178
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2021,
+                      "durationMs": 248
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1363,
+                      "durationMs": 630
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1384,
+                      "durationMs": 858
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2153.369
+            },
+            {
+              "region": "eastus",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-000081",
+              "mode": "reuse",
+              "workerIoTimerMs": 1927,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3661,
+                  "durationMs": 878
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3686,
+                  "durationMs": 1290
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 178
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 287
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2021,
+                      "durationMs": 139
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2024,
+                      "durationMs": 241
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1396,
+                      "durationMs": 561
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1418,
+                      "durationMs": 762
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 1949.185
+            },
+            {
+              "region": "eastus",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-000034",
+              "mode": "reuse",
+              "workerIoTimerMs": 1989,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3718,
+                  "durationMs": 850
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3744,
+                  "durationMs": 1410
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 154
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 324
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2024,
+                      "durationMs": 160
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2026,
+                      "durationMs": 271
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1450,
+                      "durationMs": 536
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1475,
+                      "durationMs": 815
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2007.043
+            },
+            {
+              "region": "eastus",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-000115",
+              "mode": "reuse",
+              "workerIoTimerMs": 1890,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3680,
+                  "durationMs": 880
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3699,
+                  "durationMs": 1255
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 174
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 264
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2026,
+                      "durationMs": 184
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2027,
+                      "durationMs": 245
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1411,
+                      "durationMs": 522
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1429,
+                      "durationMs": 746
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 1909.051
+            }
+          ],
+          "write-medium-one-reuse": [
+            {
+              "region": "eastus",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000000",
+              "mode": "reuse",
+              "workerIoTimerMs": 2097,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68404,
+                  "durationMs": 1030
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68434,
+                  "durationMs": 1428
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 157
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 281
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65844,
+                      "durationMs": 261
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65850,
+                      "durationMs": 361
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2317,
+                      "durationMs": 612
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2340,
+                      "durationMs": 786
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2126.434
+            },
+            {
+              "region": "eastus",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-000977",
+              "mode": "reuse",
+              "workerIoTimerMs": 1958,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68632,
+                  "durationMs": 904
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68657,
+                  "durationMs": 1356
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 150
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 261
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65850,
+                      "durationMs": 155
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65854,
+                      "durationMs": 302
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2538,
+                      "durationMs": 599
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2559,
+                      "durationMs": 793
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 1985.57
+            },
+            {
+              "region": "eastus",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-001954",
+              "mode": "reuse",
+              "workerIoTimerMs": 2197,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68660,
+                  "durationMs": 1163
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68683,
+                  "durationMs": 1403
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 161
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 253
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65854,
+                      "durationMs": 180
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65856,
+                      "durationMs": 369
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2562,
+                      "durationMs": 822
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2584,
+                      "durationMs": 781
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2222.555
+            },
+            {
+              "region": "eastus",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-002931",
+              "mode": "reuse",
+              "workerIoTimerMs": 2099,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68563,
+                  "durationMs": 1000
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68587,
+                  "durationMs": 1378
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 156
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 275
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65856,
+                      "durationMs": 171
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65860,
+                      "durationMs": 279
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2464,
+                      "durationMs": 673
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2484,
+                      "durationMs": 824
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2121.792
+            }
+          ],
+          "write-large-one-reuse": [
+            {
+              "region": "eastus",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000000",
+              "mode": "reuse",
+              "workerIoTimerMs": 2333,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330309,
+                  "durationMs": 1186
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330341,
+                  "durationMs": 1622
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 172
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 299
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326058,
+                      "durationMs": 195
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326061,
+                      "durationMs": 475
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4007,
+                      "durationMs": 819
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4036,
+                      "durationMs": 848
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2410.305
+            },
+            {
+              "region": "eastus",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-000977",
+              "mode": "reuse",
+              "workerIoTimerMs": 2376,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330503,
+                  "durationMs": 1180
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330531,
+                  "durationMs": 1615
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 147
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 326
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326061,
+                      "durationMs": 204
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326062,
+                      "durationMs": 419
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4198,
+                      "durationMs": 829
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4225,
+                      "durationMs": 870
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2442.825
+            },
+            {
+              "region": "eastus",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-001954",
+              "mode": "reuse",
+              "workerIoTimerMs": 2187,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330980,
+                  "durationMs": 1037
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 331012,
+                  "durationMs": 1576
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 171
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 270
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326062,
+                      "durationMs": 220
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326067,
+                      "durationMs": 426
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4674,
+                      "durationMs": 646
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4700,
+                      "durationMs": 880
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2263.274
+            },
+            {
+              "region": "eastus",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-002931",
+              "mode": "reuse",
+              "workerIoTimerMs": 2457,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330551,
+                  "durationMs": 1145
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330578,
+                  "durationMs": 1723
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 133
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 361
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326067,
+                      "durationMs": 242
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326069,
+                      "durationMs": 411
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4239,
+                      "durationMs": 770
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4265,
+                      "durationMs": 951
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2531.495
+            }
+          ],
+          "write-small-two-duplicate": [
+            {
+              "region": "eastus",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000000",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2284,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10345,
+                  "durationMs": 1241
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6035,
+                  "durationMs": 1547
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 172
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 253
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8674,
+                      "durationMs": 530
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4340,
+                      "durationMs": 504
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1363,
+                      "durationMs": 539
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1386,
+                      "durationMs": 790
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2302.08
+            },
+            {
+              "region": "eastus",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-000081",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2571,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10386,
+                  "durationMs": 1514
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6072,
+                  "durationMs": 1574
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 196
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 256
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8680,
+                      "durationMs": 811
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4347,
+                      "durationMs": 517
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1397,
+                      "durationMs": 507
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1416,
+                      "durationMs": 801
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2588.938
+            },
+            {
+              "region": "eastus",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-000034",
+              "mode": "duplicate",
+              "workerIoTimerMs": 3023,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10453,
+                  "durationMs": 1490
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6133,
+                  "durationMs": 2098
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 172
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 287
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8694,
+                      "durationMs": 835
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4351,
+                      "durationMs": 565
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1450,
+                      "durationMs": 483
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1473,
+                      "durationMs": 1246
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 3040.009
+            },
+            {
+              "region": "eastus",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-000115",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2694,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10421,
+                  "durationMs": 1584
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6091,
+                  "durationMs": 1610
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 180
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 264
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8702,
+                      "durationMs": 547
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4353,
+                      "durationMs": 500
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1410,
+                      "durationMs": 857
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1429,
+                      "durationMs": 846
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2711.051
+            }
+          ],
+          "write-medium-two-duplicate": [
+            {
+              "region": "eastus",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000000",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2699,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294531,
+                  "durationMs": 1555
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148611,
+                  "durationMs": 1972
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 186
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 307,
+                      "durationMs": 281
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291904,
+                      "durationMs": 638
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145962,
+                      "durationMs": 828
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2317,
+                      "durationMs": 731
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2342,
+                      "durationMs": 863
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2737.044
+            },
+            {
+              "region": "eastus",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-000977",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2543,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294772,
+                  "durationMs": 1375
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148842,
+                  "durationMs": 1878
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 307,
+                      "durationMs": 200
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 311
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291924,
+                      "durationMs": 518
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145971,
+                      "durationMs": 710
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2541,
+                      "durationMs": 657
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2560,
+                      "durationMs": 857
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2583.815
+            },
+            {
+              "region": "eastus",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-001954",
+              "mode": "duplicate",
+              "workerIoTimerMs": 3250,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294815,
+                  "durationMs": 2107
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148874,
+                  "durationMs": 1889
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 893
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 267
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291942,
+                      "durationMs": 604
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145978,
+                      "durationMs": 746
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2562,
+                      "durationMs": 610
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2584,
+                      "durationMs": 876
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 3291.176
+            },
+            {
+              "region": "eastus",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-002931",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2444,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294731,
+                  "durationMs": 1288
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148782,
+                  "durationMs": 1917
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 155
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 313
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291956,
+                      "durationMs": 538
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145988,
+                      "durationMs": 761
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2463,
+                      "durationMs": 595
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2484,
+                      "durationMs": 843
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2481.52
+            }
+          ],
+          "write-large-two-duplicate": [
+            {
+              "region": "eastus",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000000",
+              "mode": "duplicate",
+              "workerIoTimerMs": 3770,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450415,
+                  "durationMs": 2411
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727401,
+                  "durationMs": 2696
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 183
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 322
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446096,
+                      "durationMs": 873
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723051,
+                      "durationMs": 1338
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4007,
+                      "durationMs": 1355
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4037,
+                      "durationMs": 1036
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 3887.638
+            },
+            {
+              "region": "eastus",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-000977",
+              "mode": "duplicate",
+              "workerIoTimerMs": 3280,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450614,
+                  "durationMs": 1952
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727597,
+                  "durationMs": 2538
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 161
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 390
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446102,
+                      "durationMs": 800
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723057,
+                      "durationMs": 1210
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4199,
+                      "durationMs": 991
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4228,
+                      "durationMs": 938
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 3408.305
+            },
+            {
+              "region": "eastus",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-001954",
+              "mode": "duplicate",
+              "workerIoTimerMs": 3490,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1451101,
+                  "durationMs": 2245
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 728082,
+                  "durationMs": 2454
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 255
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 291
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446114,
+                      "durationMs": 820
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723070,
+                      "durationMs": 1209
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4675,
+                      "durationMs": 1170
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4700,
+                      "durationMs": 954
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 3602.46
+            },
+            {
+              "region": "eastus",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-002931",
+              "mode": "duplicate",
+              "workerIoTimerMs": 3395,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450691,
+                  "durationMs": 2159
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727656,
+                  "durationMs": 2503
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 137
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 301
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446140,
+                      "durationMs": 998
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723079,
+                      "durationMs": 1267
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4239,
+                      "durationMs": 1024
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4265,
+                      "durationMs": 935
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 3547.488
+            }
+          ],
+          "write-small-two-reuse": [
+            {
+              "region": "eastus",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000000",
+              "mode": "reuse",
+              "workerIoTimerMs": 2534,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6008,
+                  "durationMs": 1437
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6035,
+                  "durationMs": 1908
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 385
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 264
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4337,
+                      "durationMs": 375
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4340,
+                      "durationMs": 811
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1363,
+                      "durationMs": 677
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1386,
+                      "durationMs": 833
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2558.815
+            },
+            {
+              "region": "eastus",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-000081",
+              "mode": "reuse",
+              "workerIoTimerMs": 2154,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6046,
+                  "durationMs": 1096
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6072,
+                  "durationMs": 1785
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 170
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 258
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4340,
+                      "durationMs": 389
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4347,
+                      "durationMs": 727
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1397,
+                      "durationMs": 537
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1416,
+                      "durationMs": 800
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2172.486
+            },
+            {
+              "region": "eastus",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-000034",
+              "mode": "reuse",
+              "workerIoTimerMs": 2338,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6106,
+                  "durationMs": 1254
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6133,
+                  "durationMs": 1619
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 318
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 278
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4347,
+                      "durationMs": 292
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4351,
+                      "durationMs": 535
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1450,
+                      "durationMs": 644
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1473,
+                      "durationMs": 806
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2355.249
+            },
+            {
+              "region": "eastus",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-000115",
+              "mode": "reuse",
+              "workerIoTimerMs": 2364,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6070,
+                  "durationMs": 1378
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6091,
+                  "durationMs": 1517
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 456
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 257
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4351,
+                      "durationMs": 330
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4353,
+                      "durationMs": 531
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1410,
+                      "durationMs": 592
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1429,
+                      "durationMs": 729
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2382.522
+            }
+          ],
+          "write-medium-two-reuse": [
+            {
+              "region": "eastus",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000000",
+              "mode": "reuse",
+              "workerIoTimerMs": 2569,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148579,
+                  "durationMs": 1441
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148611,
+                  "durationMs": 1785
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 181
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 307,
+                      "durationMs": 328
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145952,
+                      "durationMs": 646
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145962,
+                      "durationMs": 657
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2317,
+                      "durationMs": 614
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2342,
+                      "durationMs": 800
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2602.669
+            },
+            {
+              "region": "eastus",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-000977",
+              "mode": "reuse",
+              "workerIoTimerMs": 2461,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148810,
+                  "durationMs": 1432
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148842,
+                  "durationMs": 1668
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 307,
+                      "durationMs": 193
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 256
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145962,
+                      "durationMs": 348
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145971,
+                      "durationMs": 639
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2541,
+                      "durationMs": 891
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2560,
+                      "durationMs": 773
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2496.609
+            },
+            {
+              "region": "eastus",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-001954",
+              "mode": "reuse",
+              "workerIoTimerMs": 2178,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148844,
+                  "durationMs": 1133
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148874,
+                  "durationMs": 1682
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 164
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 277
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145971,
+                      "durationMs": 375
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145978,
+                      "durationMs": 637
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2562,
+                      "durationMs": 594
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2584,
+                      "durationMs": 768
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2226.188
+            },
+            {
+              "region": "eastus",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-002931",
+              "mode": "reuse",
+              "workerIoTimerMs": 2595,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148753,
+                  "durationMs": 1303
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148782,
+                  "durationMs": 1998
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 296
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 503
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145978,
+                      "durationMs": 429
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145988,
+                      "durationMs": 706
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2463,
+                      "durationMs": 578
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2484,
+                      "durationMs": 789
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2631.764
+            }
+          ],
+          "write-large-two-reuse": [
+            {
+              "region": "eastus",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000000",
+              "mode": "reuse",
+              "workerIoTimerMs": 2937,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727367,
+                  "durationMs": 1750
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727401,
+                  "durationMs": 2483
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 210
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 286
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723048,
+                      "durationMs": 521
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723051,
+                      "durationMs": 1296
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4007,
+                      "durationMs": 1019
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4037,
+                      "durationMs": 901
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 3066.661
+            },
+            {
+              "region": "eastus",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-000977",
+              "mode": "reuse",
+              "workerIoTimerMs": 3264,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727563,
+                  "durationMs": 1964
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727597,
+                  "durationMs": 2661
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 279
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 310
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723051,
+                      "durationMs": 640
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723057,
+                      "durationMs": 1361
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4199,
+                      "durationMs": 1045
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4228,
+                      "durationMs": 990
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 3416.926
+            },
+            {
+              "region": "eastus",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-001954",
+              "mode": "reuse",
+              "workerIoTimerMs": 2904,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 728044,
+                  "durationMs": 1609
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 728082,
+                  "durationMs": 2457
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 148
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 321
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723057,
+                      "durationMs": 532
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723070,
+                      "durationMs": 1162
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4675,
+                      "durationMs": 929
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4700,
+                      "durationMs": 974
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 3009.301
+            },
+            {
+              "region": "eastus",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-002931",
+              "mode": "reuse",
+              "workerIoTimerMs": 3215,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727621,
+                  "durationMs": 1889
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727656,
+                  "durationMs": 2514
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 209
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 310
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723070,
+                      "durationMs": 884
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723079,
+                      "durationMs": 1188
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4239,
+                      "durationMs": 796
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4265,
+                      "durationMs": 1016
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 3317.894
+            }
+          ]
+        },
+        "verification": [
+          {
+            "region": "eastus",
+            "profile": "small",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "eastus",
+            "profile": "small",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "eastus",
+            "profile": "medium",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "eastus",
+            "profile": "medium",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "eastus",
+            "profile": "large",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "eastus",
+            "profile": "large",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          }
+        ]
+      }
+    },
+    {
+      "replicate": "b",
+      "region": "westus2",
+      "result": {
+        "generatedAt": "2026-09-30T03:24:23.528Z",
+        "sourceCommit": "bd8af6eec98b8f4a745d90327e96534c4a09fac0",
+        "harnessCommit": "a1a1d02d9ce71318956e5a5cb9574eed43314c04",
+        "runId": "index-reuse-b",
+        "replicate": "b",
+        "region": "westus2",
+        "colo": "SEA",
+        "runtime": "Node v22.23.3",
+        "iterations": 4,
+        "samples": {
+          "write-small-one-duplicate": [
+            {
+              "region": "westus2",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000037",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2482,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5601,
+                  "durationMs": 1240
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3604,
+                  "durationMs": 1554
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 203
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 313
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4040,
+                      "durationMs": 338
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2019,
+                      "durationMs": 312
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1318,
+                      "durationMs": 699
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1342,
+                      "durationMs": 929
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2547.242
+            },
+            {
+              "region": "westus2",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-000118",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2197,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5772,
+                  "durationMs": 1044
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3776,
+                  "durationMs": 1471
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 194
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 311
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4038,
+                      "durationMs": 320
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2020,
+                      "durationMs": 318
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1491,
+                      "durationMs": 530
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1512,
+                      "durationMs": 842
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2227.438
+            },
+            {
+              "region": "westus2",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-000071",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2110,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5775,
+                  "durationMs": 931
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3779,
+                  "durationMs": 1465
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 169
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 333
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4040,
+                      "durationMs": 258
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2022,
+                      "durationMs": 286
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1491,
+                      "durationMs": 504
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1514,
+                      "durationMs": 846
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2147.956
+            },
+            {
+              "region": "westus2",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-000024",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2186,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5779,
+                  "durationMs": 1022
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3779,
+                  "durationMs": 1505
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 241
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 270
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4044,
+                      "durationMs": 321
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2024,
+                      "durationMs": 341
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1492,
+                      "durationMs": 460
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1513,
+                      "durationMs": 894
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2216.887
+            }
+          ],
+          "write-medium-one-duplicate": [
+            {
+              "region": "westus2",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000037",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2454,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134159,
+                  "durationMs": 1153
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68337,
+                  "durationMs": 1725
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 244
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 359
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131688,
+                      "durationMs": 350
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65848,
+                      "durationMs": 424
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2228,
+                      "durationMs": 559
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2247,
+                      "durationMs": 942
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2533.771
+            },
+            {
+              "region": "westus2",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001014",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2434,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134613,
+                  "durationMs": 1031
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68791,
+                  "durationMs": 1777
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 160
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 381
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131696,
+                      "durationMs": 318
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65854,
+                      "durationMs": 374
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2675,
+                      "durationMs": 553
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2694,
+                      "durationMs": 1022
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2474.798
+            },
+            {
+              "region": "westus2",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-001991",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2196,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134284,
+                  "durationMs": 946
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68453,
+                  "durationMs": 1768
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 154
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 332
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131708,
+                      "durationMs": 303
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65855,
+                      "durationMs": 518
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2333,
+                      "durationMs": 489
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2354,
+                      "durationMs": 918
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2239.849
+            },
+            {
+              "region": "westus2",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-002968",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2222,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134582,
+                  "durationMs": 1013
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68751,
+                  "durationMs": 1552
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 142
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 269
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131710,
+                      "durationMs": 322
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65859,
+                      "durationMs": 343
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2628,
+                      "durationMs": 549
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2649,
+                      "durationMs": 940
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2268.73
+            }
+          ],
+          "write-large-one-duplicate": [
+            {
+              "region": "westus2",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000037",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2783,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656502,
+                  "durationMs": 1405
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330475,
+                  "durationMs": 1913
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 155
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 316
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652116,
+                      "durationMs": 397
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326064,
+                      "durationMs": 535
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4142,
+                      "durationMs": 853
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4167,
+                      "durationMs": 1062
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2911.641
+            },
+            {
+              "region": "westus2",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001014",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2761,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656777,
+                  "durationMs": 1398
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330739,
+                  "durationMs": 1904
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 154
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 394
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652128,
+                      "durationMs": 374
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326067,
+                      "durationMs": 541
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4405,
+                      "durationMs": 870
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4428,
+                      "durationMs": 969
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2882.575
+            },
+            {
+              "region": "westus2",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-001991",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2822,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656515,
+                  "durationMs": 1449
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330477,
+                  "durationMs": 1984
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 141
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 338
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652134,
+                      "durationMs": 468
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326073,
+                      "durationMs": 611
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4137,
+                      "durationMs": 840
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4161,
+                      "durationMs": 1035
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2923.445
+            },
+            {
+              "region": "westus2",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-002968",
+              "mode": "duplicate",
+              "workerIoTimerMs": 3024,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656895,
+                  "durationMs": 1425
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330854,
+                  "durationMs": 2421
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 151
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 597
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652146,
+                      "durationMs": 498
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326076,
+                      "durationMs": 822
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4506,
+                      "durationMs": 776
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4533,
+                      "durationMs": 1002
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 3126.079
+            }
+          ],
+          "write-small-one-reuse": [
+            {
+              "region": "westus2",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000037",
+              "mode": "reuse",
+              "workerIoTimerMs": 2013,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3581,
+                  "durationMs": 773
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3604,
+                  "durationMs": 1524
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 176
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 357
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2020,
+                      "durationMs": 156
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2019,
+                      "durationMs": 284
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1318,
+                      "durationMs": 441
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1342,
+                      "durationMs": 883
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2083.967
+            },
+            {
+              "region": "westus2",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-000118",
+              "mode": "reuse",
+              "workerIoTimerMs": 2249,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3753,
+                  "durationMs": 963
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3776,
+                  "durationMs": 1570
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 166
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 310
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2019,
+                      "durationMs": 219
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2020,
+                      "durationMs": 284
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1491,
+                      "durationMs": 578
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1512,
+                      "durationMs": 976
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2302.785
+            },
+            {
+              "region": "westus2",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-000071",
+              "mode": "reuse",
+              "workerIoTimerMs": 2486,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3755,
+                  "durationMs": 857
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3779,
+                  "durationMs": 2051
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 180
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 493
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2020,
+                      "durationMs": 152
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2022,
+                      "durationMs": 422
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1491,
+                      "durationMs": 525
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1514,
+                      "durationMs": 1136
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2543.82
+            },
+            {
+              "region": "westus2",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-000024",
+              "mode": "reuse",
+              "workerIoTimerMs": 2077,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3757,
+                  "durationMs": 905
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3779,
+                  "durationMs": 1450
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 167
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 325
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2022,
+                      "durationMs": 145
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2024,
+                      "durationMs": 278
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1492,
+                      "durationMs": 593
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1513,
+                      "durationMs": 847
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2115.198
+            }
+          ],
+          "write-medium-one-reuse": [
+            {
+              "region": "westus2",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000037",
+              "mode": "reuse",
+              "workerIoTimerMs": 2149,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68315,
+                  "durationMs": 915
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68337,
+                  "durationMs": 1722
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 148
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 315
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65844,
+                      "durationMs": 176
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65848,
+                      "durationMs": 488
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2228,
+                      "durationMs": 591
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2247,
+                      "durationMs": 919
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2212.174
+            },
+            {
+              "region": "westus2",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001014",
+              "mode": "reuse",
+              "workerIoTimerMs": 2138,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68765,
+                  "durationMs": 898
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68791,
+                  "durationMs": 1554
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 166
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 334
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65848,
+                      "durationMs": 176
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65854,
+                      "durationMs": 314
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2675,
+                      "durationMs": 556
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2694,
+                      "durationMs": 906
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2186.357
+            },
+            {
+              "region": "westus2",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-001991",
+              "mode": "reuse",
+              "workerIoTimerMs": 2256,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68430,
+                  "durationMs": 878
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68453,
+                  "durationMs": 1720
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 168
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 301
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65854,
+                      "durationMs": 134
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65855,
+                      "durationMs": 342
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2333,
+                      "durationMs": 576
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2354,
+                      "durationMs": 1077
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2299.443
+            },
+            {
+              "region": "westus2",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-002968",
+              "mode": "reuse",
+              "workerIoTimerMs": 2175,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68727,
+                  "durationMs": 855
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68751,
+                  "durationMs": 1655
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 165
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 312
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65855,
+                      "durationMs": 184
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65859,
+                      "durationMs": 335
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2628,
+                      "durationMs": 506
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2649,
+                      "durationMs": 1008
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2212.284
+            }
+          ],
+          "write-large-one-reuse": [
+            {
+              "region": "westus2",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000037",
+              "mode": "reuse",
+              "workerIoTimerMs": 2502,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330444,
+                  "durationMs": 1112
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330475,
+                  "durationMs": 2006
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 173
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 363
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326058,
+                      "durationMs": 178
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326064,
+                      "durationMs": 616
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4142,
+                      "durationMs": 761
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4167,
+                      "durationMs": 1027
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2636.11
+            },
+            {
+              "region": "westus2",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001014",
+              "mode": "reuse",
+              "workerIoTimerMs": 2604,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330713,
+                  "durationMs": 1337
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330739,
+                  "durationMs": 1824
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 436
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 315
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326064,
+                      "durationMs": 208
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326067,
+                      "durationMs": 557
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4405,
+                      "durationMs": 693
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4428,
+                      "durationMs": 952
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2733.863
+            },
+            {
+              "region": "westus2",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-001991",
+              "mode": "reuse",
+              "workerIoTimerMs": 2560,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330448,
+                  "durationMs": 1071
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330477,
+                  "durationMs": 2106
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 174
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 358
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326067,
+                      "durationMs": 166
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326073,
+                      "durationMs": 617
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4137,
+                      "durationMs": 731
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4161,
+                      "durationMs": 1131
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2678.914
+            },
+            {
+              "region": "westus2",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-002968",
+              "mode": "reuse",
+              "workerIoTimerMs": 2577,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330822,
+                  "durationMs": 1216
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330854,
+                  "durationMs": 1925
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 225
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 345
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326073,
+                      "durationMs": 193
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326076,
+                      "durationMs": 564
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4506,
+                      "durationMs": 798
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4533,
+                      "durationMs": 1016
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2688.597
+            }
+          ],
+          "write-small-two-duplicate": [
+            {
+              "region": "westus2",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000037",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2574,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10300,
+                  "durationMs": 1278
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 5991,
+                  "durationMs": 1905
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 166
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 303
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8674,
+                      "durationMs": 560
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4338,
+                      "durationMs": 609
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1318,
+                      "durationMs": 552
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1344,
+                      "durationMs": 993
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2603.036
+            },
+            {
+              "region": "westus2",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-000118",
+              "mode": "duplicate",
+              "workerIoTimerMs": 3118,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10476,
+                  "durationMs": 1834
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6158,
+                  "durationMs": 1931
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 160
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 307,
+                      "durationMs": 422
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8676,
+                      "durationMs": 981
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4339,
+                      "durationMs": 647
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1491,
+                      "durationMs": 693
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1512,
+                      "durationMs": 862
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 3148.558
+            },
+            {
+              "region": "westus2",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-000071",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2641,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10475,
+                  "durationMs": 1453
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6166,
+                  "durationMs": 1862
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 307,
+                      "durationMs": 167
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 301
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8678,
+                      "durationMs": 793
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4344,
+                      "durationMs": 674
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1490,
+                      "durationMs": 493
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1514,
+                      "durationMs": 887
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2670.994
+            },
+            {
+              "region": "westus2",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-000024",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2867,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10488,
+                  "durationMs": 1478
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6167,
+                  "durationMs": 2063
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 161
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 373
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8688,
+                      "durationMs": 720
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4345,
+                      "durationMs": 674
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1492,
+                      "durationMs": 597
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1514,
+                      "durationMs": 1016
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2897.411
+            }
+          ],
+          "write-medium-two-duplicate": [
+            {
+              "region": "westus2",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000037",
+              "mode": "duplicate",
+              "workerIoTimerMs": 3274,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294442,
+                  "durationMs": 1966
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148519,
+                  "durationMs": 2298
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 577
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 316
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291904,
+                      "durationMs": 740
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145962,
+                      "durationMs": 990
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2228,
+                      "durationMs": 649
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2248,
+                      "durationMs": 992
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 3349.598
+            },
+            {
+              "region": "westus2",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001014",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2779,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294909,
+                  "durationMs": 1481
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148989,
+                  "durationMs": 2081
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 208
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 366
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291924,
+                      "durationMs": 688
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145978,
+                      "durationMs": 783
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2676,
+                      "durationMs": 585
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2700,
+                      "durationMs": 932
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2865.619
+            },
+            {
+              "region": "westus2",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-001991",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2950,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294604,
+                  "durationMs": 1517
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148643,
+                  "durationMs": 2254
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 219
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 307,
+                      "durationMs": 309
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291956,
+                      "durationMs": 663
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145982,
+                      "durationMs": 821
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2337,
+                      "durationMs": 635
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2354,
+                      "durationMs": 1124
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 3022.086
+            },
+            {
+              "region": "westus2",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-002968",
+              "mode": "duplicate",
+              "workerIoTimerMs": 2876,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294899,
+                  "durationMs": 1518
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148956,
+                  "durationMs": 2330
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 307,
+                      "durationMs": 201
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 310
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291964,
+                      "durationMs": 700
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145994,
+                      "durationMs": 972
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2628,
+                      "durationMs": 617
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2652,
+                      "durationMs": 1048
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2935.256
+            }
+          ],
+          "write-large-two-duplicate": [
+            {
+              "region": "westus2",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000037",
+              "mode": "duplicate",
+              "workerIoTimerMs": 3986,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450550,
+                  "durationMs": 2294
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727542,
+                  "durationMs": 3715
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 167
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 457
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446096,
+                      "durationMs": 822
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723061,
+                      "durationMs": 2023
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4142,
+                      "durationMs": 1305
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4168,
+                      "durationMs": 1235
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4172.622
+            },
+            {
+              "region": "westus2",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001014",
+              "mode": "duplicate",
+              "workerIoTimerMs": 4450,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450840,
+                  "durationMs": 2468
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727818,
+                  "durationMs": 3832
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 130
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 797
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446122,
+                      "durationMs": 1216
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723076,
+                      "durationMs": 1850
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4405,
+                      "durationMs": 1122
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4430,
+                      "durationMs": 1185
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4589.534
+            },
+            {
+              "region": "westus2",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-001991",
+              "mode": "duplicate",
+              "workerIoTimerMs": 4279,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450601,
+                  "durationMs": 2452
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727567,
+                  "durationMs": 3739
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 139
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 487
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446152,
+                      "durationMs": 1109
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723093,
+                      "durationMs": 1912
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4137,
+                      "durationMs": 1204
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4162,
+                      "durationMs": 1340
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4474.394
+            },
+            {
+              "region": "westus2",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-002968",
+              "mode": "duplicate",
+              "workerIoTimerMs": 4436,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1451003,
+                  "durationMs": 2793
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727949,
+                  "durationMs": 3555
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 172
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 405
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446186,
+                      "durationMs": 1306
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723103,
+                      "durationMs": 1912
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4505,
+                      "durationMs": 1315
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4534,
+                      "durationMs": 1238
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4667.243
+            }
+          ],
+          "write-small-two-reuse": [
+            {
+              "region": "westus2",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000037",
+              "mode": "reuse",
+              "workerIoTimerMs": 2446,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5963,
+                  "durationMs": 1237
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 5991,
+                  "durationMs": 2164
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 143
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 317
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4337,
+                      "durationMs": 325
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4338,
+                      "durationMs": 955
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1318,
+                      "durationMs": 769
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1344,
+                      "durationMs": 892
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2474.897
+            },
+            {
+              "region": "westus2",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-000118",
+              "mode": "reuse",
+              "workerIoTimerMs": 2317,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6138,
+                  "durationMs": 1132
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6158,
+                  "durationMs": 1726
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 131
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 307,
+                      "durationMs": 300
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4338,
+                      "durationMs": 407
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4339,
+                      "durationMs": 541
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1491,
+                      "durationMs": 594
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1512,
+                      "durationMs": 885
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2373.99
+            },
+            {
+              "region": "westus2",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-000071",
+              "mode": "reuse",
+              "workerIoTimerMs": 2241,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6136,
+                  "durationMs": 931
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6166,
+                  "durationMs": 1923
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 307,
+                      "durationMs": 172
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 388
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4339,
+                      "durationMs": 311
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4344,
+                      "durationMs": 613
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1490,
+                      "durationMs": 448
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1514,
+                      "durationMs": 922
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2269.434
+            },
+            {
+              "region": "westus2",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-000024",
+              "mode": "reuse",
+              "workerIoTimerMs": 2522,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6144,
+                  "durationMs": 1337
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6167,
+                  "durationMs": 1837
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 143
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 298
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4344,
+                      "durationMs": 591
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4345,
+                      "durationMs": 652
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1492,
+                      "durationMs": 603
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1514,
+                      "durationMs": 887
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2559.229
+            }
+          ],
+          "write-medium-two-reuse": [
+            {
+              "region": "westus2",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000037",
+              "mode": "reuse",
+              "workerIoTimerMs": 2388,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148490,
+                  "durationMs": 1146
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148519,
+                  "durationMs": 2048
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 128
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 336
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145952,
+                      "durationMs": 383
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145962,
+                      "durationMs": 806
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2228,
+                      "durationMs": 635
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2248,
+                      "durationMs": 906
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2455.406
+            },
+            {
+              "region": "westus2",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001014",
+              "mode": "reuse",
+              "workerIoTimerMs": 2331,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148947,
+                  "durationMs": 1052
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148989,
+                  "durationMs": 2159
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 150
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 358
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145962,
+                      "durationMs": 316
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145978,
+                      "durationMs": 880
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2676,
+                      "durationMs": 586
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2700,
+                      "durationMs": 921
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2405.29
+            },
+            {
+              "region": "westus2",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-001991",
+              "mode": "reuse",
+              "workerIoTimerMs": 2592,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148626,
+                  "durationMs": 1104
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148643,
+                  "durationMs": 2252
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 124
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 307,
+                      "durationMs": 336
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145978,
+                      "durationMs": 334
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145982,
+                      "durationMs": 764
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2337,
+                      "durationMs": 646
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2354,
+                      "durationMs": 1152
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2640.318
+            },
+            {
+              "region": "westus2",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-002968",
+              "mode": "reuse",
+              "workerIoTimerMs": 2207,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148917,
+                  "durationMs": 999
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148956,
+                  "durationMs": 2069
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 307,
+                      "durationMs": 155
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 295
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145982,
+                      "durationMs": 310
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145994,
+                      "durationMs": 861
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2628,
+                      "durationMs": 534
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2652,
+                      "durationMs": 913
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 2266.339
+            }
+          ],
+          "write-large-two-reuse": [
+            {
+              "region": "westus2",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000037",
+              "mode": "reuse",
+              "workerIoTimerMs": 3530,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727502,
+                  "durationMs": 1962
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727542,
+                  "durationMs": 3536
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 138
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 401
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723048,
+                      "durationMs": 459
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723061,
+                      "durationMs": 1968
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4142,
+                      "durationMs": 1365
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4168,
+                      "durationMs": 1167
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 3695.608
+            },
+            {
+              "region": "westus2",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001014",
+              "mode": "reuse",
+              "workerIoTimerMs": 3679,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727779,
+                  "durationMs": 2126
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727818,
+                  "durationMs": 3265
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 389
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 329
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723061,
+                      "durationMs": 584
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723076,
+                      "durationMs": 1712
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4405,
+                      "durationMs": 1153
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4430,
+                      "durationMs": 1224
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 3889.249
+            },
+            {
+              "region": "westus2",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-001991",
+              "mode": "reuse",
+              "workerIoTimerMs": 3314,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727525,
+                  "durationMs": 1724
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727567,
+                  "durationMs": 3325
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 142
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 354
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723076,
+                      "durationMs": 531
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723093,
+                      "durationMs": 1735
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4137,
+                      "durationMs": 1051
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4162,
+                      "durationMs": 1236
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 3491.576
+            },
+            {
+              "region": "westus2",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-002968",
+              "mode": "reuse",
+              "workerIoTimerMs": 3545,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727910,
+                  "durationMs": 1997
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727949,
+                  "durationMs": 3581
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 143
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 329
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723093,
+                      "durationMs": 455
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723103,
+                      "durationMs": 2033
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4505,
+                      "durationMs": 1399
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4534,
+                      "durationMs": 1219
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 3680.528
+            }
+          ]
+        },
+        "verification": [
+          {
+            "region": "westus2",
+            "profile": "small",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "westus2",
+            "profile": "small",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "westus2",
+            "profile": "medium",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "westus2",
+            "profile": "medium",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "westus2",
+            "profile": "large",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "westus2",
+            "profile": "large",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          }
+        ]
+      }
+    },
+    {
+      "replicate": "b",
+      "region": "northeurope",
+      "result": {
+        "generatedAt": "2026-09-30T03:28:07.812Z",
+        "sourceCommit": "bd8af6eec98b8f4a745d90327e96534c4a09fac0",
+        "harnessCommit": "a1a1d02d9ce71318956e5a5cb9574eed43314c04",
+        "runId": "index-reuse-b",
+        "replicate": "b",
+        "region": "northeurope",
+        "colo": "DUB",
+        "runtime": "Node v22.23.3",
+        "iterations": 4,
+        "samples": {
+          "write-small-one-duplicate": [
+            {
+              "region": "northeurope",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000074",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5012,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5772,
+                  "durationMs": 2554
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3779,
+                  "durationMs": 3065
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 787
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 595
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4040,
+                      "durationMs": 605
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2022,
+                      "durationMs": 607
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1489,
+                      "durationMs": 1162
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1515,
+                      "durationMs": 1863
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5024.774
+            },
+            {
+              "region": "northeurope",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-000027",
+              "mode": "duplicate",
+              "workerIoTimerMs": 4973,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5774,
+                  "durationMs": 2385
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3772,
+                  "durationMs": 3608
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 385
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 699
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4044,
+                      "durationMs": 584
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2020,
+                      "durationMs": 1020
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1488,
+                      "durationMs": 1416
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1510,
+                      "durationMs": 1889
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4983.839
+            },
+            {
+              "region": "northeurope",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-000108",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5359,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5678,
+                  "durationMs": 2455
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3684,
+                  "durationMs": 3521
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 429
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 608
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4040,
+                      "durationMs": 591
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2021,
+                      "durationMs": 617
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1396,
+                      "durationMs": 1435
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1420,
+                      "durationMs": 2296
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5370.461
+            },
+            {
+              "region": "northeurope",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-000061",
+              "mode": "duplicate",
+              "workerIoTimerMs": 4500,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5733,
+                  "durationMs": 2112
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3732,
+                  "durationMs": 2980
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 374
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 611
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4042,
+                      "durationMs": 596
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2023,
+                      "durationMs": 592
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1448,
+                      "durationMs": 1142
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1467,
+                      "durationMs": 1777
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4510.221
+            }
+          ],
+          "write-medium-one-duplicate": [
+            {
+              "region": "northeurope",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000074",
+              "mode": "duplicate",
+              "workerIoTimerMs": 4872,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134240,
+                  "durationMs": 2472
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68425,
+                  "durationMs": 3045
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 409
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 597
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131688,
+                      "durationMs": 577
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65848,
+                      "durationMs": 645
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2309,
+                      "durationMs": 1486
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2334,
+                      "durationMs": 1803
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4886.982
+            },
+            {
+              "region": "northeurope",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001051",
+              "mode": "duplicate",
+              "workerIoTimerMs": 4852,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134333,
+                  "durationMs": 2379
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68510,
+                  "durationMs": 3116
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 386
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 635
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131696,
+                      "durationMs": 609
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65853,
+                      "durationMs": 643
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2394,
+                      "durationMs": 1384
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2413,
+                      "durationMs": 1838
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4862.263
+            },
+            {
+              "region": "northeurope",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-002028",
+              "mode": "duplicate",
+              "workerIoTimerMs": 4570,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134304,
+                  "durationMs": 2188
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68474,
+                  "durationMs": 3666
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 389
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 241,
+                      "durationMs": 609
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131706,
+                      "durationMs": 573
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65858,
+                      "durationMs": 1284
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2354,
+                      "durationMs": 1226
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2375,
+                      "durationMs": 1773
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4581.365
+            },
+            {
+              "region": "northeurope",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-003005",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5049,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134420,
+                  "durationMs": 2588
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68593,
+                  "durationMs": 3393
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 241,
+                      "durationMs": 412
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 643
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131716,
+                      "durationMs": 824
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65864,
+                      "durationMs": 932
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2463,
+                      "durationMs": 1352
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2485,
+                      "durationMs": 1818
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5061.474
+            }
+          ],
+          "write-large-one-duplicate": [
+            {
+              "region": "northeurope",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000074",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5119,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656395,
+                  "durationMs": 2595
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330369,
+                  "durationMs": 3393
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 356
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 614
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652116,
+                      "durationMs": 681
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326065,
+                      "durationMs": 869
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4035,
+                      "durationMs": 1558
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4060,
+                      "durationMs": 1910
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5139.459
+            },
+            {
+              "region": "northeurope",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001051",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5487,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656926,
+                  "durationMs": 2508
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330887,
+                  "durationMs": 3796
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 373
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1060
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652130,
+                      "durationMs": 601
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326066,
+                      "durationMs": 817
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4552,
+                      "durationMs": 1534
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4577,
+                      "durationMs": 1919
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5503.287
+            },
+            {
+              "region": "northeurope",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-002028",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5106,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656586,
+                  "durationMs": 2573
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330558,
+                  "durationMs": 3426
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 464
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 608
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652132,
+                      "durationMs": 648
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326078,
+                      "durationMs": 893
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4210,
+                      "durationMs": 1461
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4237,
+                      "durationMs": 1925
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5124.078
+            },
+            {
+              "region": "northeurope",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-003005",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5112,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656615,
+                  "durationMs": 2679
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330563,
+                  "durationMs": 3288
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 347
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 593
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652156,
+                      "durationMs": 726
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326082,
+                      "durationMs": 855
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4216,
+                      "durationMs": 1606
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4237,
+                      "durationMs": 1840
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5133.223
+            }
+          ],
+          "write-small-one-reuse": [
+            {
+              "region": "northeurope",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000074",
+              "mode": "reuse",
+              "workerIoTimerMs": 4355,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3752,
+                  "durationMs": 1964
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3779,
+                  "durationMs": 3005
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 369
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 636
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2020,
+                      "durationMs": 385
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2022,
+                      "durationMs": 614
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1489,
+                      "durationMs": 1210
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1515,
+                      "durationMs": 1755
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4364.082
+            },
+            {
+              "region": "northeurope",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-000027",
+              "mode": "reuse",
+              "workerIoTimerMs": 4300,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3752,
+                  "durationMs": 1970
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3772,
+                  "durationMs": 2908
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 390
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 580
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2022,
+                      "durationMs": 377
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2020,
+                      "durationMs": 578
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1488,
+                      "durationMs": 1203
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1510,
+                      "durationMs": 1750
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4312.194
+            },
+            {
+              "region": "northeurope",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-000108",
+              "mode": "reuse",
+              "workerIoTimerMs": 4331,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3658,
+                  "durationMs": 1928
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3684,
+                  "durationMs": 3008
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 406
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 579
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2020,
+                      "durationMs": 363
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2021,
+                      "durationMs": 605
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1396,
+                      "durationMs": 1159
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1420,
+                      "durationMs": 1824
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4341.805
+            },
+            {
+              "region": "northeurope",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-000061",
+              "mode": "reuse",
+              "workerIoTimerMs": 4395,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3712,
+                  "durationMs": 2014
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3732,
+                  "durationMs": 2998
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 441
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 618
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2021,
+                      "durationMs": 402
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2023,
+                      "durationMs": 617
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1448,
+                      "durationMs": 1171
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1467,
+                      "durationMs": 1763
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4406.234
+            }
+          ],
+          "write-medium-one-reuse": [
+            {
+              "region": "northeurope",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000074",
+              "mode": "reuse",
+              "workerIoTimerMs": 6133,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68396,
+                  "durationMs": 2096
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68425,
+                  "durationMs": 4700
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 410
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 1166
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65844,
+                      "durationMs": 393
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65848,
+                      "durationMs": 663
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2309,
+                      "durationMs": 1293
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2334,
+                      "durationMs": 2871
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6142.344
+            },
+            {
+              "region": "northeurope",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001051",
+              "mode": "reuse",
+              "workerIoTimerMs": 4411,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68485,
+                  "durationMs": 2046
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68510,
+                  "durationMs": 2994
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 369
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 610
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65848,
+                      "durationMs": 460
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65853,
+                      "durationMs": 629
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2394,
+                      "durationMs": 1217
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2413,
+                      "durationMs": 1755
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4422.056
+            },
+            {
+              "region": "northeurope",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-002028",
+              "mode": "reuse",
+              "workerIoTimerMs": 4858,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68451,
+                  "durationMs": 2090
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68474,
+                  "durationMs": 3394
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 436
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 241,
+                      "durationMs": 874
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65853,
+                      "durationMs": 396
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65858,
+                      "durationMs": 626
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2354,
+                      "durationMs": 1258
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2375,
+                      "durationMs": 1894
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4868.451
+            },
+            {
+              "region": "northeurope",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-003005",
+              "mode": "reuse",
+              "workerIoTimerMs": 4450,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68562,
+                  "durationMs": 2075
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68593,
+                  "durationMs": 3021
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 241,
+                      "durationMs": 426
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 585
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65858,
+                      "durationMs": 409
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65864,
+                      "durationMs": 646
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2463,
+                      "durationMs": 1240
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2485,
+                      "durationMs": 1790
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4460.853
+            }
+          ],
+          "write-large-one-reuse": [
+            {
+              "region": "northeurope",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000074",
+              "mode": "reuse",
+              "workerIoTimerMs": 5007,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330337,
+                  "durationMs": 2545
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330369,
+                  "durationMs": 3271
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 368
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 610
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326058,
+                      "durationMs": 464
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326065,
+                      "durationMs": 809
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4035,
+                      "durationMs": 1713
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4060,
+                      "durationMs": 1852
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5025.038
+            },
+            {
+              "region": "northeurope",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001051",
+              "mode": "reuse",
+              "workerIoTimerMs": 4657,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330861,
+                  "durationMs": 2199
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330887,
+                  "durationMs": 4343
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 365
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 594
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326065,
+                      "durationMs": 443
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326066,
+                      "durationMs": 1885
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4552,
+                      "durationMs": 1391
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4577,
+                      "durationMs": 1864
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4673.814
+            },
+            {
+              "region": "northeurope",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-002028",
+              "mode": "reuse",
+              "workerIoTimerMs": 4866,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330520,
+                  "durationMs": 2480
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330558,
+                  "durationMs": 3137
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 358
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 596
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326066,
+                      "durationMs": 420
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326078,
+                      "durationMs": 751
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4210,
+                      "durationMs": 1702
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4237,
+                      "durationMs": 1790
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4881.833
+            },
+            {
+              "region": "northeurope",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-003005",
+              "mode": "reuse",
+              "workerIoTimerMs": 5055,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330537,
+                  "durationMs": 2498
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330563,
+                  "durationMs": 3456
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 433
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 649
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326078,
+                      "durationMs": 434
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326082,
+                      "durationMs": 899
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4216,
+                      "durationMs": 1631
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4237,
+                      "durationMs": 1908
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5078.04
+            }
+          ],
+          "write-small-two-duplicate": [
+            {
+              "region": "northeurope",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000074",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5400,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10471,
+                  "durationMs": 3046
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6167,
+                  "durationMs": 3560
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 424
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 603
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8674,
+                      "durationMs": 1255
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4343,
+                      "durationMs": 1206
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1489,
+                      "durationMs": 1367
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1515,
+                      "durationMs": 1751
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5410.547
+            },
+            {
+              "region": "northeurope",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-000027",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5931,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10483,
+                  "durationMs": 3463
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6162,
+                  "durationMs": 3633
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 487
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 306,
+                      "durationMs": 660
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8686,
+                      "durationMs": 1489
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4342,
+                      "durationMs": 1165
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1488,
+                      "durationMs": 1487
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1514,
+                      "durationMs": 1808
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5940.472
+            },
+            {
+              "region": "northeurope",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-000108",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5559,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10387,
+                  "durationMs": 3136
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6069,
+                  "durationMs": 3663
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 306,
+                      "durationMs": 442
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 620
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8684,
+                      "durationMs": 1250
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4341,
+                      "durationMs": 1240
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1397,
+                      "durationMs": 1444
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1419,
+                      "durationMs": 1803
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5568.111
+            },
+            {
+              "region": "northeurope",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-000061",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5868,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10438,
+                  "durationMs": 2791
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6120,
+                  "durationMs": 4280
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 392
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 307,
+                      "durationMs": 607
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8682,
+                      "durationMs": 1156
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4346,
+                      "durationMs": 1203
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1447,
+                      "durationMs": 1243
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1467,
+                      "durationMs": 2470
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5876.551
+            }
+          ],
+          "write-medium-two-duplicate": [
+            {
+              "region": "northeurope",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000074",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5648,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294523,
+                  "durationMs": 3036
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148607,
+                  "durationMs": 4163
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 378
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 601
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291904,
+                      "durationMs": 1401
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145963,
+                      "durationMs": 1551
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2309,
+                      "durationMs": 1257
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2334,
+                      "durationMs": 2011
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5661.422
+            },
+            {
+              "region": "northeurope",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001051",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6277,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294630,
+                  "durationMs": 3181
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148702,
+                  "durationMs": 4589
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 396
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 674
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291926,
+                      "durationMs": 1336
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145976,
+                      "durationMs": 1493
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2394,
+                      "durationMs": 1449
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2415,
+                      "durationMs": 2422
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6288.919
+            },
+            {
+              "region": "northeurope",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-002028",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5518,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294618,
+                  "durationMs": 3125
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148683,
+                  "durationMs": 3793
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 397
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 603
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291952,
+                      "durationMs": 1323
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145994,
+                      "durationMs": 1400
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2355,
+                      "durationMs": 1405
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2378,
+                      "durationMs": 1790
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5530.591
+            },
+            {
+              "region": "northeurope",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-003005",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5211,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294764,
+                  "durationMs": 2742
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148805,
+                  "durationMs": 3817
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 365
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 661
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291988,
+                      "durationMs": 1167
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 146009,
+                      "durationMs": 1348
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2465,
+                      "durationMs": 1210
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2485,
+                      "durationMs": 1808
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5224.324
+            }
+          ],
+          "write-large-two-duplicate": [
+            {
+              "region": "northeurope",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000074",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6966,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450443,
+                  "durationMs": 3928
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727436,
+                  "durationMs": 5329
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 383
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 606
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446096,
+                      "durationMs": 1550
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723063,
+                      "durationMs": 2291
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4035,
+                      "durationMs": 1995
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4062,
+                      "durationMs": 2432
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6986.206
+            },
+            {
+              "region": "northeurope",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001051",
+              "mode": "duplicate",
+              "workerIoTimerMs": 7349,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450990,
+                  "durationMs": 4227
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727961,
+                  "durationMs": 6647
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 383
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 703
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446126,
+                      "durationMs": 1894
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723072,
+                      "durationMs": 3525
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4553,
+                      "durationMs": 1950
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4576,
+                      "durationMs": 2419
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7383.378
+            },
+            {
+              "region": "northeurope",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-002028",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6431,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450667,
+                  "durationMs": 3918
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727650,
+                  "durationMs": 5379
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 412
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 614
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446144,
+                      "durationMs": 1724
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723104,
+                      "durationMs": 2866
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4210,
+                      "durationMs": 1782
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4236,
+                      "durationMs": 1899
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6453.591
+            },
+            {
+              "region": "northeurope",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-003005",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6808,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450732,
+                  "durationMs": 3828
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727670,
+                  "durationMs": 5164
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 369
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 1117
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446208,
+                      "durationMs": 1693
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723119,
+                      "durationMs": 2184
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4214,
+                      "durationMs": 1766
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4239,
+                      "durationMs": 1863
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6837.341
+            }
+          ],
+          "write-small-two-reuse": [
+            {
+              "region": "northeurope",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000074",
+              "mode": "reuse",
+              "workerIoTimerMs": 4905,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6134,
+                  "durationMs": 2519
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6167,
+                  "durationMs": 3659
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 404
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 632
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4337,
+                      "durationMs": 928
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4343,
+                      "durationMs": 1273
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1489,
+                      "durationMs": 1187
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1515,
+                      "durationMs": 1754
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4918.202
+            },
+            {
+              "region": "northeurope",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-000027",
+              "mode": "reuse",
+              "workerIoTimerMs": 5449,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6140,
+                  "durationMs": 2284
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6162,
+                  "durationMs": 5144
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 384
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 306,
+                      "durationMs": 588
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4343,
+                      "durationMs": 733
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4342,
+                      "durationMs": 1979
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1488,
+                      "durationMs": 1167
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1514,
+                      "durationMs": 2577
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5458.044
+            },
+            {
+              "region": "northeurope",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-000108",
+              "mode": "reuse",
+              "workerIoTimerMs": 5361,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6045,
+                  "durationMs": 2486
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6069,
+                  "durationMs": 4067
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 306,
+                      "durationMs": 366
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 612
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4342,
+                      "durationMs": 750
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4341,
+                      "durationMs": 1192
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1397,
+                      "durationMs": 1370
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1419,
+                      "durationMs": 2263
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5370.845
+            },
+            {
+              "region": "northeurope",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-000061",
+              "mode": "reuse",
+              "workerIoTimerMs": 4977,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6097,
+                  "durationMs": 2582
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6120,
+                  "durationMs": 3581
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 420
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 307,
+                      "durationMs": 630
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4341,
+                      "durationMs": 1000
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4346,
+                      "durationMs": 1186
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1447,
+                      "durationMs": 1162
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1467,
+                      "durationMs": 1765
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4986.648
+            }
+          ],
+          "write-medium-two-reuse": [
+            {
+              "region": "northeurope",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000074",
+              "mode": "reuse",
+              "workerIoTimerMs": 5505,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148571,
+                  "durationMs": 2534
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148607,
+                  "durationMs": 4567
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 383
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 612
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145952,
+                      "durationMs": 833
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145963,
+                      "durationMs": 1596
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2309,
+                      "durationMs": 1318
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2334,
+                      "durationMs": 2359
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5517.097
+            },
+            {
+              "region": "northeurope",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001051",
+              "mode": "reuse",
+              "workerIoTimerMs": 4996,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148667,
+                  "durationMs": 2568
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148702,
+                  "durationMs": 3899
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 378
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 593
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145963,
+                      "durationMs": 801
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145976,
+                      "durationMs": 1471
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2394,
+                      "durationMs": 1389
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2415,
+                      "durationMs": 1835
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5007.533
+            },
+            {
+              "region": "northeurope",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-002028",
+              "mode": "reuse",
+              "workerIoTimerMs": 5204,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148642,
+                  "durationMs": 2706
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148683,
+                  "durationMs": 3907
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 603
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 610
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145976,
+                      "durationMs": 726
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145994,
+                      "durationMs": 1409
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2355,
+                      "durationMs": 1377
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2378,
+                      "durationMs": 1888
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5216.384
+            },
+            {
+              "region": "northeurope",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-003005",
+              "mode": "reuse",
+              "workerIoTimerMs": 5046,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148770,
+                  "durationMs": 2638
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148805,
+                  "durationMs": 3762
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 376
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 606
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145994,
+                      "durationMs": 910
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 146009,
+                      "durationMs": 1354
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2465,
+                      "durationMs": 1352
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2485,
+                      "durationMs": 1802
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5058.221
+            }
+          ],
+          "write-large-two-reuse": [
+            {
+              "region": "northeurope",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000074",
+              "mode": "reuse",
+              "workerIoTimerMs": 5969,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727395,
+                  "durationMs": 3350
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727436,
+                  "durationMs": 4773
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 412
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 695
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723048,
+                      "durationMs": 1189
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723063,
+                      "durationMs": 2154
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4035,
+                      "durationMs": 1749
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4062,
+                      "durationMs": 1924
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5993.113
+            },
+            {
+              "region": "northeurope",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001051",
+              "mode": "reuse",
+              "workerIoTimerMs": 5671,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727927,
+                  "durationMs": 3045
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727961,
+                  "durationMs": 4850
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 372
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 670
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723063,
+                      "durationMs": 895
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723072,
+                      "durationMs": 2224
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4553,
+                      "durationMs": 1778
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4576,
+                      "durationMs": 1956
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5693.169
+            },
+            {
+              "region": "northeurope",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-002028",
+              "mode": "reuse",
+              "workerIoTimerMs": 5739,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727595,
+                  "durationMs": 3169
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727650,
+                  "durationMs": 4823
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 351
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 631
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723072,
+                      "durationMs": 1007
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723104,
+                      "durationMs": 2253
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4210,
+                      "durationMs": 1811
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4236,
+                      "durationMs": 1939
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5763.11
+            },
+            {
+              "region": "northeurope",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-003005",
+              "mode": "reuse",
+              "workerIoTimerMs": 5725,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727628,
+                  "durationMs": 3189
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727670,
+                  "durationMs": 4921
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 376
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 635
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723104,
+                      "durationMs": 963
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723119,
+                      "durationMs": 2385
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4214,
+                      "durationMs": 1850
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4239,
+                      "durationMs": 1901
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5747.572
+            }
+          ]
+        },
+        "verification": [
+          {
+            "region": "northeurope",
+            "profile": "small",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "northeurope",
+            "profile": "small",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "northeurope",
+            "profile": "medium",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "northeurope",
+            "profile": "medium",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "northeurope",
+            "profile": "large",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "northeurope",
+            "profile": "large",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          }
+        ]
+      }
+    },
+    {
+      "replicate": "b",
+      "region": "southeastasia",
+      "result": {
+        "generatedAt": "2026-09-30T03:30:32.105Z",
+        "sourceCommit": "bd8af6eec98b8f4a745d90327e96534c4a09fac0",
+        "harnessCommit": "a1a1d02d9ce71318956e5a5cb9574eed43314c04",
+        "runId": "index-reuse-b",
+        "replicate": "b",
+        "region": "southeastasia",
+        "colo": "HKG",
+        "runtime": "Node v22.23.3",
+        "iterations": 4,
+        "samples": {
+          "write-small-one-duplicate": [
+            {
+              "region": "southeastasia",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000111",
+              "mode": "duplicate",
+              "workerIoTimerMs": 7081,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5642,
+                  "durationMs": 3144
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3646,
+                  "durationMs": 4658
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 651
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 1258
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4040,
+                      "durationMs": 683
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2022,
+                      "durationMs": 721
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1359,
+                      "durationMs": 1810
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1381,
+                      "durationMs": 2679
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7125.411
+            },
+            {
+              "region": "southeastasia",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-000064",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6249,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5738,
+                  "durationMs": 2666
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3741,
+                  "durationMs": 4299
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 469
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 710
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4044,
+                      "durationMs": 815
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2024,
+                      "durationMs": 716
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1451,
+                      "durationMs": 1382
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1475,
+                      "durationMs": 2873
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6290.98
+            },
+            {
+              "region": "southeastasia",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-000017",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5470,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5892,
+                  "durationMs": 2609
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3892,
+                  "durationMs": 3572
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 402
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 731
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4048,
+                      "durationMs": 681
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2027,
+                      "durationMs": 711
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1602,
+                      "durationMs": 1526
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1621,
+                      "durationMs": 2130
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5514.015
+            },
+            {
+              "region": "southeastasia",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-000098",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6041,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5828,
+                  "durationMs": 2677
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3819,
+                  "durationMs": 4095
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 433
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 724
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4054,
+                      "durationMs": 651
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2029,
+                      "durationMs": 731
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1530,
+                      "durationMs": 1593
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1546,
+                      "durationMs": 2640
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6083.041
+            }
+          ],
+          "write-medium-one-duplicate": [
+            {
+              "region": "southeastasia",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000111",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5864,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134394,
+                  "durationMs": 3011
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68576,
+                  "durationMs": 4277
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 642
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 720
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131688,
+                      "durationMs": 766
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65847,
+                      "durationMs": 1424
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2463,
+                      "durationMs": 1603
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2485,
+                      "durationMs": 2133
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5908.524
+            },
+            {
+              "region": "southeastasia",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001088",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6248,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134286,
+                  "durationMs": 2799
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68463,
+                  "durationMs": 4241
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 503
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 739
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131694,
+                      "durationMs": 702
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65853,
+                      "durationMs": 792
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2348,
+                      "durationMs": 1594
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2366,
+                      "durationMs": 2710
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6288.691
+            },
+            {
+              "region": "southeastasia",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-002065",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6716,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134416,
+                  "durationMs": 2678
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68587,
+                  "durationMs": 4844
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 508
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1321
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131706,
+                      "durationMs": 790
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65859,
+                      "durationMs": 806
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2466,
+                      "durationMs": 1380
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2484,
+                      "durationMs": 2717
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6758.569
+            },
+            {
+              "region": "southeastasia",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-003042",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5911,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134264,
+                  "durationMs": 2481
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68433,
+                  "durationMs": 4164
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 425
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 698
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131718,
+                      "durationMs": 649
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65867,
+                      "durationMs": 734
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2302,
+                      "durationMs": 1407
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2322,
+                      "durationMs": 2732
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5954.671
+            }
+          ],
+          "write-large-one-duplicate": [
+            {
+              "region": "southeastasia",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000111",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6415,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656598,
+                  "durationMs": 3428
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330568,
+                  "durationMs": 3918
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 628
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 766
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652116,
+                      "durationMs": 919
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326061,
+                      "durationMs": 931
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4238,
+                      "durationMs": 1881
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4263,
+                      "durationMs": 2221
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6464.085
+            },
+            {
+              "region": "southeastasia",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001088",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5914,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656833,
+                  "durationMs": 3041
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330803,
+                  "durationMs": 4022
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 551
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 689
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652122,
+                      "durationMs": 774
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326065,
+                      "durationMs": 1149
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4467,
+                      "durationMs": 1716
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4496,
+                      "durationMs": 2184
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5965.5
+            },
+            {
+              "region": "southeastasia",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-002065",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6454,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656787,
+                  "durationMs": 2997
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330755,
+                  "durationMs": 4360
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 688
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 1240
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652130,
+                      "durationMs": 725
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326076,
+                      "durationMs": 903
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4415,
+                      "durationMs": 1584
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4437,
+                      "durationMs": 2217
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6501.811
+            },
+            {
+              "region": "southeastasia",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-003042",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6587,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656437,
+                  "durationMs": 3101
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330393,
+                  "durationMs": 4481
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 419
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 741
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652152,
+                      "durationMs": 856
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326081,
+                      "durationMs": 995
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4043,
+                      "durationMs": 1826
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4067,
+                      "durationMs": 2745
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6630.599
+            }
+          ],
+          "write-small-one-reuse": [
+            {
+              "region": "southeastasia",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000111",
+              "mode": "reuse",
+              "workerIoTimerMs": 5124,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3622,
+                  "durationMs": 2310
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3646,
+                  "durationMs": 3559
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 439
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 698
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2020,
+                      "durationMs": 435
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2022,
+                      "durationMs": 745
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1359,
+                      "durationMs": 1436
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1381,
+                      "durationMs": 2116
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5170.441
+            },
+            {
+              "region": "southeastasia",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-000064",
+              "mode": "reuse",
+              "workerIoTimerMs": 5319,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3716,
+                  "durationMs": 2481
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3741,
+                  "durationMs": 3668
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 523
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 711
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2022,
+                      "durationMs": 463
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2024,
+                      "durationMs": 830
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1451,
+                      "durationMs": 1495
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1475,
+                      "durationMs": 2127
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5364.343
+            },
+            {
+              "region": "southeastasia",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-000017",
+              "mode": "reuse",
+              "workerIoTimerMs": 5456,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3868,
+                  "durationMs": 2497
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3892,
+                  "durationMs": 3897
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 424
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 762
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2024,
+                      "durationMs": 496
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2027,
+                      "durationMs": 938
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1602,
+                      "durationMs": 1577
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1621,
+                      "durationMs": 2197
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5497.489
+            },
+            {
+              "region": "southeastasia",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-000098",
+              "mode": "reuse",
+              "workerIoTimerMs": 5908,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3801,
+                  "durationMs": 2582
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3819,
+                  "durationMs": 4034
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 538
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1207
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2027,
+                      "durationMs": 496
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2029,
+                      "durationMs": 708
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1530,
+                      "durationMs": 1548
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1546,
+                      "durationMs": 2119
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5948.822
+            }
+          ],
+          "write-medium-one-reuse": [
+            {
+              "region": "southeastasia",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000111",
+              "mode": "reuse",
+              "workerIoTimerMs": 5261,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68550,
+                  "durationMs": 2379
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68576,
+                  "durationMs": 3852
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 528
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 680
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65844,
+                      "durationMs": 445
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65847,
+                      "durationMs": 970
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2463,
+                      "durationMs": 1406
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2485,
+                      "durationMs": 2202
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5308.403
+            },
+            {
+              "region": "southeastasia",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001088",
+              "mode": "reuse",
+              "workerIoTimerMs": 5635,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68439,
+                  "durationMs": 2454
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68463,
+                  "durationMs": 3953
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 532
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 755
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65847,
+                      "durationMs": 435
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65853,
+                      "durationMs": 772
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2348,
+                      "durationMs": 1487
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2366,
+                      "durationMs": 2426
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5677.357
+            },
+            {
+              "region": "southeastasia",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-002065",
+              "mode": "reuse",
+              "workerIoTimerMs": 5234,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68563,
+                  "durationMs": 2394
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68587,
+                  "durationMs": 3563
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 474
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 747
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65853,
+                      "durationMs": 481
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65859,
+                      "durationMs": 723
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2466,
+                      "durationMs": 1439
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2484,
+                      "durationMs": 2093
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5277.813
+            },
+            {
+              "region": "southeastasia",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-003042",
+              "mode": "reuse",
+              "workerIoTimerMs": 5356,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68405,
+                  "durationMs": 2378
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68433,
+                  "durationMs": 3737
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 494
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 723
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65859,
+                      "durationMs": 462
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65867,
+                      "durationMs": 759
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2302,
+                      "durationMs": 1422
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2322,
+                      "durationMs": 2255
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5399.01
+            }
+          ],
+          "write-large-one-reuse": [
+            {
+              "region": "southeastasia",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000111",
+              "mode": "reuse",
+              "workerIoTimerMs": 5699,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330540,
+                  "durationMs": 2695
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330568,
+                  "durationMs": 3971
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 464
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 722
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326058,
+                      "durationMs": 533
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326061,
+                      "durationMs": 967
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4238,
+                      "durationMs": 1698
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4263,
+                      "durationMs": 2282
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5744.626
+            },
+            {
+              "region": "southeastasia",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001088",
+              "mode": "reuse",
+              "workerIoTimerMs": 5867,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330772,
+                  "durationMs": 2964
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330803,
+                  "durationMs": 4193
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 584
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 691
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326061,
+                      "durationMs": 584
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326065,
+                      "durationMs": 1290
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4467,
+                      "durationMs": 1796
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4496,
+                      "durationMs": 2212
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5914.329
+            },
+            {
+              "region": "southeastasia",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-002065",
+              "mode": "reuse",
+              "workerIoTimerMs": 6045,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330722,
+                  "durationMs": 3061
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330755,
+                  "durationMs": 3912
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 695
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 766
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326065,
+                      "durationMs": 573
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326076,
+                      "durationMs": 928
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4415,
+                      "durationMs": 1793
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4437,
+                      "durationMs": 2218
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6089.189
+            },
+            {
+              "region": "southeastasia",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-003042",
+              "mode": "reuse",
+              "workerIoTimerMs": 6184,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330361,
+                  "durationMs": 2742
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330393,
+                  "durationMs": 4388
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 538
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 720
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326076,
+                      "durationMs": 542
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326081,
+                      "durationMs": 946
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4043,
+                      "durationMs": 1662
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4067,
+                      "durationMs": 2722
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6233.708
+            }
+          ],
+          "write-small-two-duplicate": [
+            {
+              "region": "southeastasia",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000111",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6510,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10341,
+                  "durationMs": 3628
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6031,
+                  "durationMs": 4332
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 504
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 307,
+                      "durationMs": 715
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8674,
+                      "durationMs": 1607
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4342,
+                      "durationMs": 1450
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1359,
+                      "durationMs": 1517
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1382,
+                      "durationMs": 2167
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6560.044
+            },
+            {
+              "region": "southeastasia",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-000064",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6293,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10443,
+                  "durationMs": 3412
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6136,
+                  "durationMs": 4780
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 307,
+                      "durationMs": 489
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 702
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8684,
+                      "durationMs": 1571
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4348,
+                      "durationMs": 1899
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1452,
+                      "durationMs": 1352
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1478,
+                      "durationMs": 2179
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6333.547
+            },
+            {
+              "region": "southeastasia",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-000017",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6981,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10609,
+                  "durationMs": 3293
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6284,
+                  "durationMs": 5146
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 409
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 768
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8696,
+                      "durationMs": 1476
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4354,
+                      "durationMs": 1458
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1603,
+                      "durationMs": 1408
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1621,
+                      "durationMs": 2920
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7022.41
+            },
+            {
+              "region": "southeastasia",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-000098",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6757,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10547,
+                  "durationMs": 3254
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6211,
+                  "durationMs": 5997
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 455
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 737
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8708,
+                      "durationMs": 1422
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4356,
+                      "durationMs": 2494
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1530,
+                      "durationMs": 1377
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1547,
+                      "durationMs": 2766
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6798.169
+            }
+          ],
+          "write-medium-two-duplicate": [
+            {
+              "region": "southeastasia",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000111",
+              "mode": "duplicate",
+              "workerIoTimerMs": 7404,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294677,
+                  "durationMs": 3766
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148756,
+                  "durationMs": 5440
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 727
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 1389
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291904,
+                      "durationMs": 1440
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145960,
+                      "durationMs": 1802
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2463,
+                      "durationMs": 1599
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2485,
+                      "durationMs": 2249
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7446.02
+            },
+            {
+              "region": "southeastasia",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001088",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6338,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294578,
+                  "durationMs": 3345
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148658,
+                  "durationMs": 4540
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 432
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 748
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291920,
+                      "durationMs": 1400
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145976,
+                      "durationMs": 1547
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2347,
+                      "durationMs": 1513
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2371,
+                      "durationMs": 2245
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6384.134
+            },
+            {
+              "region": "southeastasia",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-002065",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6594,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294730,
+                  "durationMs": 3631
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148793,
+                  "durationMs": 4616
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 498
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 769
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291952,
+                      "durationMs": 1548
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145995,
+                      "durationMs": 1653
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2467,
+                      "durationMs": 1585
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2488,
+                      "durationMs": 2194
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6637.77
+            },
+            {
+              "region": "southeastasia",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-003042",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6402,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294604,
+                  "durationMs": 3544
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148651,
+                  "durationMs": 4748
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 415
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 699
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291990,
+                      "durationMs": 1504
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 146014,
+                      "durationMs": 1890
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2304,
+                      "durationMs": 1625
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2327,
+                      "durationMs": 2159
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6444.552
+            }
+          ],
+          "write-large-two-duplicate": [
+            {
+              "region": "southeastasia",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000111",
+              "mode": "duplicate",
+              "workerIoTimerMs": 8185,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450646,
+                  "durationMs": 4793
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727634,
+                  "durationMs": 6017
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 734
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 722
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446096,
+                      "durationMs": 1932
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723056,
+                      "durationMs": 2625
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4238,
+                      "durationMs": 2127
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4266,
+                      "durationMs": 2670
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8232.854
+            },
+            {
+              "region": "southeastasia",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001088",
+              "mode": "duplicate",
+              "workerIoTimerMs": 7763,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450893,
+                  "durationMs": 4287
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727882,
+                  "durationMs": 8490
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 420
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 765
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446112,
+                      "durationMs": 1679
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723073,
+                      "durationMs": 5014
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4469,
+                      "durationMs": 2188
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4496,
+                      "durationMs": 2711
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7811.599
+            },
+            {
+              "region": "southeastasia",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-002065",
+              "mode": "duplicate",
+              "workerIoTimerMs": 8572,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450873,
+                  "durationMs": 4591
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727848,
+                  "durationMs": 6578
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 440
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 1245
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446146,
+                      "durationMs": 1848
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723102,
+                      "durationMs": 2597
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4414,
+                      "durationMs": 2303
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4434,
+                      "durationMs": 2736
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 8616.069
+            },
+            {
+              "region": "southeastasia",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-003042",
+              "mode": "duplicate",
+              "workerIoTimerMs": 7581,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450557,
+                  "durationMs": 4555
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727500,
+                  "durationMs": 5804
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 436
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 763
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446204,
+                      "durationMs": 1898
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723119,
+                      "durationMs": 2778
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4041,
+                      "durationMs": 2221
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4069,
+                      "durationMs": 2263
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7630.434
+            }
+          ],
+          "write-small-two-reuse": [
+            {
+              "region": "southeastasia",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000111",
+              "mode": "reuse",
+              "workerIoTimerMs": 6189,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6004,
+                  "durationMs": 3290
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6031,
+                  "durationMs": 4718
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 538
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 307,
+                      "durationMs": 727
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4337,
+                      "durationMs": 1147
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4342,
+                      "durationMs": 1819
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1359,
+                      "durationMs": 1605
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1382,
+                      "durationMs": 2172
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6231.551
+            },
+            {
+              "region": "southeastasia",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-000064",
+              "mode": "reuse",
+              "workerIoTimerMs": 5817,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6101,
+                  "durationMs": 2905
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6136,
+                  "durationMs": 4303
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 307,
+                      "durationMs": 488
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 704
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4342,
+                      "durationMs": 982
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4348,
+                      "durationMs": 1391
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1452,
+                      "durationMs": 1435
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1478,
+                      "durationMs": 2208
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5858.533
+            },
+            {
+              "region": "southeastasia",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-000017",
+              "mode": "reuse",
+              "workerIoTimerMs": 5713,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6261,
+                  "durationMs": 2858
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6284,
+                  "durationMs": 4266
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 422
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 703
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4348,
+                      "durationMs": 1002
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4354,
+                      "durationMs": 1411
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1603,
+                      "durationMs": 1434
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1621,
+                      "durationMs": 2152
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5755.385
+            },
+            {
+              "region": "southeastasia",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-000098",
+              "mode": "reuse",
+              "workerIoTimerMs": 5675,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6193,
+                  "durationMs": 2824
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6211,
+                  "durationMs": 4329
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 447
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 736
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4354,
+                      "durationMs": 942
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4356,
+                      "durationMs": 1478
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1530,
+                      "durationMs": 1435
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1547,
+                      "durationMs": 2115
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5715.355
+            }
+          ],
+          "write-medium-two-reuse": [
+            {
+              "region": "southeastasia",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000111",
+              "mode": "reuse",
+              "workerIoTimerMs": 6004,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148725,
+                  "durationMs": 3129
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148756,
+                  "durationMs": 5249
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 514
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 752
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145952,
+                      "durationMs": 993
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145960,
+                      "durationMs": 2374
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2463,
+                      "durationMs": 1622
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2485,
+                      "durationMs": 2123
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6047.9
+            },
+            {
+              "region": "southeastasia",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001088",
+              "mode": "reuse",
+              "workerIoTimerMs": 6255,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148618,
+                  "durationMs": 3334
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148658,
+                  "durationMs": 4504
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 448
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 756
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145960,
+                      "durationMs": 1218
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145976,
+                      "durationMs": 1583
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2347,
+                      "durationMs": 1668
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2371,
+                      "durationMs": 2165
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6298.736
+            },
+            {
+              "region": "southeastasia",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-002065",
+              "mode": "reuse",
+              "workerIoTimerMs": 6245,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148754,
+                  "durationMs": 2823
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148793,
+                  "durationMs": 5804
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 446
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 720
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145976,
+                      "durationMs": 865
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145995,
+                      "durationMs": 2382
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2467,
+                      "durationMs": 1512
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2488,
+                      "durationMs": 2702
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6289.902
+            },
+            {
+              "region": "southeastasia",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-003042",
+              "mode": "reuse",
+              "workerIoTimerMs": 5960,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148609,
+                  "durationMs": 3083
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148651,
+                  "durationMs": 5297
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 427
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 703
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145995,
+                      "durationMs": 1141
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 146014,
+                      "durationMs": 2420
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2304,
+                      "durationMs": 1515
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2327,
+                      "durationMs": 2174
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6007.507
+            }
+          ],
+          "write-large-two-reuse": [
+            {
+              "region": "southeastasia",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000111",
+              "mode": "reuse",
+              "workerIoTimerMs": 6713,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727598,
+                  "durationMs": 3703
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727634,
+                  "durationMs": 6339
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 449
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 720
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723048,
+                      "durationMs": 1099
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723056,
+                      "durationMs": 3329
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4238,
+                      "durationMs": 2155
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4266,
+                      "durationMs": 2290
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6762.456
+            },
+            {
+              "region": "southeastasia",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001088",
+              "mode": "reuse",
+              "workerIoTimerMs": 6841,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727837,
+                  "durationMs": 3704
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727882,
+                  "durationMs": 5953
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 430
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 702
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723056,
+                      "durationMs": 1186
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723073,
+                      "durationMs": 2816
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4469,
+                      "durationMs": 2088
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4496,
+                      "durationMs": 2435
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6890.164
+            },
+            {
+              "region": "southeastasia",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-002065",
+              "mode": "reuse",
+              "workerIoTimerMs": 7756,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727800,
+                  "durationMs": 3712
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727848,
+                  "durationMs": 7122
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 418
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 742
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723073,
+                      "durationMs": 1292
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723102,
+                      "durationMs": 3078
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4414,
+                      "durationMs": 2002
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4434,
+                      "durationMs": 3302
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7799.964
+            },
+            {
+              "region": "southeastasia",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-003042",
+              "mode": "reuse",
+              "workerIoTimerMs": 7145,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727455,
+                  "durationMs": 4136
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727500,
+                  "durationMs": 5782
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 497
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 717
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723102,
+                      "durationMs": 1272
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723119,
+                      "durationMs": 2773
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4041,
+                      "durationMs": 2367
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4069,
+                      "durationMs": 2292
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7195.22
+            }
+          ]
+        },
+        "verification": [
+          {
+            "region": "southeastasia",
+            "profile": "small",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "southeastasia",
+            "profile": "small",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "southeastasia",
+            "profile": "medium",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "southeastasia",
+            "profile": "medium",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "southeastasia",
+            "profile": "large",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "southeastasia",
+            "profile": "large",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          }
+        ]
+      }
+    },
+    {
+      "replicate": "b",
+      "region": "japaneast",
+      "result": {
+        "generatedAt": "2026-09-30T03:28:40.629Z",
+        "sourceCommit": "bd8af6eec98b8f4a745d90327e96534c4a09fac0",
+        "harnessCommit": "a1a1d02d9ce71318956e5a5cb9574eed43314c04",
+        "runId": "index-reuse-b",
+        "replicate": "b",
+        "region": "japaneast",
+        "colo": "NRT",
+        "runtime": "Node v22.23.3",
+        "iterations": 4,
+        "samples": {
+          "write-small-one-duplicate": [
+            {
+              "region": "japaneast",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000020",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6161,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5639,
+                  "durationMs": 3629
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3640,
+                  "durationMs": 3144
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 706
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 885
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4040,
+                      "durationMs": 758
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2020,
+                      "durationMs": 612
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1356,
+                      "durationMs": 2165
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1376,
+                      "durationMs": 1647
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6174.138
+            },
+            {
+              "region": "japaneast",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-000101",
+              "mode": "duplicate",
+              "workerIoTimerMs": 4546,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5734,
+                  "durationMs": 2397
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3734,
+                  "durationMs": 2715
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 441
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 513
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4040,
+                      "durationMs": 468
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2020,
+                      "durationMs": 566
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1450,
+                      "durationMs": 1488
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1471,
+                      "durationMs": 1636
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4560.277
+            },
+            {
+              "region": "japaneast",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-000054",
+              "mode": "duplicate",
+              "workerIoTimerMs": 4449,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5866,
+                  "durationMs": 2323
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3873,
+                  "durationMs": 2688
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 463
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 523
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4040,
+                      "durationMs": 477
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2023,
+                      "durationMs": 562
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1583,
+                      "durationMs": 1383
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1607,
+                      "durationMs": 1603
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4463.423
+            },
+            {
+              "region": "japaneast",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-000007",
+              "mode": "duplicate",
+              "workerIoTimerMs": 4690,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5892,
+                  "durationMs": 2483
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3894,
+                  "durationMs": 2811
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 346
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 604
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4046,
+                      "durationMs": 638
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2024,
+                      "durationMs": 604
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1603,
+                      "durationMs": 1499
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1627,
+                      "durationMs": 1603
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4703.311
+            }
+          ],
+          "write-medium-one-duplicate": [
+            {
+              "region": "japaneast",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000148",
+              "mode": "duplicate",
+              "workerIoTimerMs": 4729,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134259,
+                  "durationMs": 2439
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68445,
+                  "durationMs": 2881
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 353
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 575
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131688,
+                      "durationMs": 663
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65847,
+                      "durationMs": 591
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2328,
+                      "durationMs": 1423
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2355,
+                      "durationMs": 1715
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4744.178
+            },
+            {
+              "region": "japaneast",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001125",
+              "mode": "duplicate",
+              "workerIoTimerMs": 4311,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134567,
+                  "durationMs": 2253
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68755,
+                  "durationMs": 2654
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 321
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 553
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131694,
+                      "durationMs": 622
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65855,
+                      "durationMs": 596
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2630,
+                      "durationMs": 1310
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2657,
+                      "durationMs": 1505
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4327.587
+            },
+            {
+              "region": "japaneast",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-002102",
+              "mode": "duplicate",
+              "workerIoTimerMs": 4533,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134487,
+                  "durationMs": 2277
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68655,
+                  "durationMs": 2866
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 445
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 563
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131710,
+                      "durationMs": 507
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65856,
+                      "durationMs": 610
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2534,
+                      "durationMs": 1325
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2556,
+                      "durationMs": 1693
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4548.448
+            },
+            {
+              "region": "japaneast",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-003079",
+              "mode": "duplicate",
+              "workerIoTimerMs": 4824,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134465,
+                  "durationMs": 2570
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68643,
+                  "durationMs": 2767
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 305
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 596
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131712,
+                      "durationMs": 637
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65864,
+                      "durationMs": 513
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2510,
+                      "durationMs": 1628
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2535,
+                      "durationMs": 1658
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4840.112
+            }
+          ],
+          "write-large-one-duplicate": [
+            {
+              "region": "japaneast",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000148",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5183,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656232,
+                  "durationMs": 3007
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330210,
+                  "durationMs": 2977
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 478
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 529
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652116,
+                      "durationMs": 595
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326060,
+                      "durationMs": 801
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 3872,
+                      "durationMs": 1934
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 3906,
+                      "durationMs": 1647
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5204.082
+            },
+            {
+              "region": "japaneast",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001125",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5388,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656870,
+                  "durationMs": 2577
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330844,
+                  "durationMs": 3556
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 463
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 945
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652120,
+                      "durationMs": 683
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326064,
+                      "durationMs": 745
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4506,
+                      "durationMs": 1431
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4536,
+                      "durationMs": 1866
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5405.209
+            },
+            {
+              "region": "japaneast",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-002102",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5189,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656739,
+                  "durationMs": 2883
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330704,
+                  "durationMs": 3171
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 466
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 598
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652128,
+                      "durationMs": 924
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326064,
+                      "durationMs": 865
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4367,
+                      "durationMs": 1493
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4396,
+                      "durationMs": 1708
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5205.978
+            },
+            {
+              "region": "japaneast",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-003079",
+              "mode": "duplicate",
+              "workerIoTimerMs": 4823,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656899,
+                  "durationMs": 2322
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330874,
+                  "durationMs": 3200
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 409
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 540
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652128,
+                      "durationMs": 704
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326074,
+                      "durationMs": 699
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4527,
+                      "durationMs": 1209
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4556,
+                      "durationMs": 1961
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4843.904
+            }
+          ],
+          "write-small-one-reuse": [
+            {
+              "region": "japaneast",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000020",
+              "mode": "reuse",
+              "workerIoTimerMs": 4588,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3619,
+                  "durationMs": 2453
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3640,
+                  "durationMs": 2655
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 475
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 518
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2020,
+                      "durationMs": 468
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2020,
+                      "durationMs": 520
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1356,
+                      "durationMs": 1510
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1376,
+                      "durationMs": 1617
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4601.84
+            },
+            {
+              "region": "japaneast",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-000101",
+              "mode": "reuse",
+              "workerIoTimerMs": 4506,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3714,
+                  "durationMs": 2383
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3734,
+                  "durationMs": 2724
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 465
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 517
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2020,
+                      "durationMs": 482
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2020,
+                      "durationMs": 601
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1450,
+                      "durationMs": 1436
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1471,
+                      "durationMs": 1606
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4520.85
+            },
+            {
+              "region": "japaneast",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-000054",
+              "mode": "reuse",
+              "workerIoTimerMs": 4502,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3846,
+                  "durationMs": 2245
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3873,
+                  "durationMs": 2786
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 448
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 600
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2020,
+                      "durationMs": 413
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2023,
+                      "durationMs": 529
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1583,
+                      "durationMs": 1384
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1607,
+                      "durationMs": 1657
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4513.287
+            },
+            {
+              "region": "japaneast",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-000007",
+              "mode": "reuse",
+              "workerIoTimerMs": 4753,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3869,
+                  "durationMs": 2543
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3894,
+                  "durationMs": 2711
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 462
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 571
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2023,
+                      "durationMs": 540
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2024,
+                      "durationMs": 501
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1603,
+                      "durationMs": 1541
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1627,
+                      "durationMs": 1639
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4765.401
+            }
+          ],
+          "write-medium-one-reuse": [
+            {
+              "region": "japaneast",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000148",
+              "mode": "reuse",
+              "workerIoTimerMs": 4455,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68415,
+                  "durationMs": 2298
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68445,
+                  "durationMs": 2820
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 339
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 541
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65844,
+                      "durationMs": 530
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65847,
+                      "durationMs": 663
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2328,
+                      "durationMs": 1429
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2355,
+                      "durationMs": 1616
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4470.298
+            },
+            {
+              "region": "japaneast",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001125",
+              "mode": "reuse",
+              "workerIoTimerMs": 4505,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68720,
+                  "durationMs": 2356
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68755,
+                  "durationMs": 2702
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 444
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 520
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65847,
+                      "durationMs": 473
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65855,
+                      "durationMs": 553
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2630,
+                      "durationMs": 1439
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2657,
+                      "durationMs": 1629
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4519.853
+            },
+            {
+              "region": "japaneast",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-002102",
+              "mode": "reuse",
+              "workerIoTimerMs": 4752,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68632,
+                  "durationMs": 2247
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68655,
+                  "durationMs": 3089
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 457
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 530
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65855,
+                      "durationMs": 308
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65856,
+                      "durationMs": 584
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2534,
+                      "durationMs": 1482
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2556,
+                      "durationMs": 1975
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4765.445
+            },
+            {
+              "region": "japaneast",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-003079",
+              "mode": "reuse",
+              "workerIoTimerMs": 4321,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68609,
+                  "durationMs": 2168
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68643,
+                  "durationMs": 2711
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 324
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 506
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65856,
+                      "durationMs": 490
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65864,
+                      "durationMs": 558
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2510,
+                      "durationMs": 1354
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2535,
+                      "durationMs": 1647
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4338.465
+            }
+          ],
+          "write-large-one-reuse": [
+            {
+              "region": "japaneast",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000148",
+              "mode": "reuse",
+              "workerIoTimerMs": 4544,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330174,
+                  "durationMs": 2293
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330210,
+                  "durationMs": 3101
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 457
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 553
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326058,
+                      "durationMs": 499
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326060,
+                      "durationMs": 850
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 3872,
+                      "durationMs": 1337
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 3906,
+                      "durationMs": 1698
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4567.888
+            },
+            {
+              "region": "japaneast",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001125",
+              "mode": "reuse",
+              "workerIoTimerMs": 4794,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330810,
+                  "durationMs": 2475
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330844,
+                  "durationMs": 3139
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 316
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 606
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326060,
+                      "durationMs": 411
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326064,
+                      "durationMs": 820
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4506,
+                      "durationMs": 1748
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4536,
+                      "durationMs": 1713
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4810.336
+            },
+            {
+              "region": "japaneast",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-002102",
+              "mode": "reuse",
+              "workerIoTimerMs": 4973,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330675,
+                  "durationMs": 2849
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330704,
+                  "durationMs": 2892
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 559
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 537
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326064,
+                      "durationMs": 470
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326064,
+                      "durationMs": 768
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4367,
+                      "durationMs": 1820
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4396,
+                      "durationMs": 1587
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4996.215
+            },
+            {
+              "region": "japaneast",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-003079",
+              "mode": "reuse",
+              "workerIoTimerMs": 5117,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330835,
+                  "durationMs": 2974
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330874,
+                  "durationMs": 2931
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 443
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 539
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326064,
+                      "durationMs": 496
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326074,
+                      "durationMs": 788
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4527,
+                      "durationMs": 2035
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4556,
+                      "durationMs": 1604
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5135.238
+            }
+          ],
+          "write-small-two-duplicate": [
+            {
+              "region": "japaneast",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000020",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5881,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10338,
+                  "durationMs": 3533
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6021,
+                  "durationMs": 3396
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 317
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 306,
+                      "durationMs": 842
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8674,
+                      "durationMs": 1446
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4339,
+                      "durationMs": 1048
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1356,
+                      "durationMs": 1770
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1376,
+                      "durationMs": 1506
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5892.857
+            },
+            {
+              "region": "japaneast",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-000101",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5286,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10434,
+                  "durationMs": 3245
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6110,
+                  "durationMs": 3086
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 306,
+                      "durationMs": 454
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 525
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8678,
+                      "durationMs": 1588
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4334,
+                      "durationMs": 1045
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1450,
+                      "durationMs": 1203
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1468,
+                      "durationMs": 1516
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5299.788
+            },
+            {
+              "region": "japaneast",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-000054",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5077,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10557,
+                  "durationMs": 2946
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6254,
+                  "durationMs": 3709
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 448
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 550
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8668,
+                      "durationMs": 1116
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4341,
+                      "durationMs": 1578
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1581,
+                      "durationMs": 1382
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1605,
+                      "durationMs": 1581
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5089.691
+            },
+            {
+              "region": "japaneast",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-000007",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5704,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10592,
+                  "durationMs": 3203
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6273,
+                  "durationMs": 4206
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 456
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 564
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8682,
+                      "durationMs": 1367
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4341,
+                      "durationMs": 1705
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1602,
+                      "durationMs": 1380
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1624,
+                      "durationMs": 1937
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5715.647
+            }
+          ],
+          "write-medium-two-duplicate": [
+            {
+              "region": "japaneast",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000148",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5509,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294542,
+                  "durationMs": 3379
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148626,
+                  "durationMs": 3890
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 446
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 523
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291904,
+                      "durationMs": 1350
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145963,
+                      "durationMs": 1760
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2328,
+                      "durationMs": 1583
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2354,
+                      "durationMs": 1607
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5527.41
+            },
+            {
+              "region": "japaneast",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001125",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5937,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294863,
+                  "durationMs": 3464
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148945,
+                  "durationMs": 3663
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 447
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 529
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291926,
+                      "durationMs": 1295
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145980,
+                      "durationMs": 1190
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2628,
+                      "durationMs": 1722
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2656,
+                      "durationMs": 1944
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5950.512
+            },
+            {
+              "region": "japaneast",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-002102",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6250,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294803,
+                  "durationMs": 3858
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148855,
+                  "durationMs": 3583
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 522
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 881
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291960,
+                      "durationMs": 1603
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145988,
+                      "durationMs": 1191
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2534,
+                      "durationMs": 1733
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2555,
+                      "durationMs": 1511
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6266.517
+            },
+            {
+              "region": "japaneast",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-003079",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5862,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294797,
+                  "durationMs": 3413
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148853,
+                  "durationMs": 3896
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 458
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 574
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291976,
+                      "durationMs": 1200
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 146008,
+                      "durationMs": 1447
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2509,
+                      "durationMs": 1755
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2534,
+                      "durationMs": 1875
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5875.732
+            }
+          ],
+          "write-large-two-duplicate": [
+            {
+              "region": "japaneast",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000148",
+              "mode": "duplicate",
+              "workerIoTimerMs": 7205,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450280,
+                  "durationMs": 4560
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727275,
+                  "durationMs": 5086
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 558
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 596
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446096,
+                      "durationMs": 1648
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723057,
+                      "durationMs": 2441
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 3872,
+                      "durationMs": 2354
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 3907,
+                      "durationMs": 2049
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7226.699
+            },
+            {
+              "region": "japaneast",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001125",
+              "mode": "duplicate",
+              "workerIoTimerMs": 11446,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450931,
+                  "durationMs": 8875
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727921,
+                  "durationMs": 4777
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 485
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 592
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446114,
+                      "durationMs": 6437
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723071,
+                      "durationMs": 2206
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4506,
+                      "durationMs": 1953
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4540,
+                      "durationMs": 1979
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 11467.727
+            },
+            {
+              "region": "japaneast",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-002102",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6856,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450820,
+                  "durationMs": 4568
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727783,
+                  "durationMs": 4084
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 386
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 512
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446142,
+                      "durationMs": 1796
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723077,
+                      "durationMs": 1796
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4368,
+                      "durationMs": 2386
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4394,
+                      "durationMs": 1776
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6876.678
+            },
+            {
+              "region": "japaneast",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-003079",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6516,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450994,
+                  "durationMs": 4321
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727969,
+                  "durationMs": 4010
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 469
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 544
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446154,
+                      "durationMs": 1818
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723102,
+                      "durationMs": 1815
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4528,
+                      "durationMs": 2034
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4555,
+                      "durationMs": 1651
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6541.423
+            }
+          ],
+          "write-small-two-reuse": [
+            {
+              "region": "japaneast",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000020",
+              "mode": "reuse",
+              "workerIoTimerMs": 4509,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6001,
+                  "durationMs": 2284
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6021,
+                  "durationMs": 3404
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 331
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 306,
+                      "durationMs": 548
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4337,
+                      "durationMs": 970
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4339,
+                      "durationMs": 1179
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1356,
+                      "durationMs": 983
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1376,
+                      "durationMs": 1677
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4521.083
+            },
+            {
+              "region": "japaneast",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-000101",
+              "mode": "reuse",
+              "workerIoTimerMs": 5677,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6095,
+                  "durationMs": 2837
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6110,
+                  "durationMs": 4224
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 306,
+                      "durationMs": 482
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 539
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4339,
+                      "durationMs": 867
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4334,
+                      "durationMs": 1384
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1450,
+                      "durationMs": 1488
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1468,
+                      "durationMs": 2301
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5688.677
+            },
+            {
+              "region": "japaneast",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-000054",
+              "mode": "reuse",
+              "workerIoTimerMs": 5272,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6223,
+                  "durationMs": 2288
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6254,
+                  "durationMs": 4204
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 459
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 678
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4334,
+                      "durationMs": 717
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4341,
+                      "durationMs": 1220
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1581,
+                      "durationMs": 1112
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1605,
+                      "durationMs": 2306
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5283.623
+            },
+            {
+              "region": "japaneast",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-000007",
+              "mode": "reuse",
+              "workerIoTimerMs": 4996,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6251,
+                  "durationMs": 2815
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6273,
+                  "durationMs": 3580
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 442
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 571
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4341,
+                      "durationMs": 952
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4341,
+                      "durationMs": 1399
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1602,
+                      "durationMs": 1421
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1624,
+                      "durationMs": 1610
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5007.293
+            }
+          ],
+          "write-medium-two-reuse": [
+            {
+              "region": "japaneast",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000148",
+              "mode": "reuse",
+              "workerIoTimerMs": 4963,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148590,
+                  "durationMs": 2792
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148626,
+                  "durationMs": 4628
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 555
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 541
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145952,
+                      "durationMs": 850
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145963,
+                      "durationMs": 2457
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2328,
+                      "durationMs": 1387
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2354,
+                      "durationMs": 1630
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4978.201
+            },
+            {
+              "region": "japaneast",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001125",
+              "mode": "reuse",
+              "workerIoTimerMs": 4837,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148900,
+                  "durationMs": 2556
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148945,
+                  "durationMs": 3439
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 521
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 547
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145963,
+                      "durationMs": 806
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145980,
+                      "durationMs": 1158
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2628,
+                      "durationMs": 1229
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2656,
+                      "durationMs": 1734
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4851.577
+            },
+            {
+              "region": "japaneast",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-002102",
+              "mode": "reuse",
+              "workerIoTimerMs": 4970,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148823,
+                  "durationMs": 2870
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148855,
+                  "durationMs": 3265
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 333
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 534
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145980,
+                      "durationMs": 1197
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145988,
+                      "durationMs": 1165
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2534,
+                      "durationMs": 1340
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2555,
+                      "durationMs": 1566
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4985.96
+            },
+            {
+              "region": "japaneast",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-003079",
+              "mode": "reuse",
+              "workerIoTimerMs": 5140,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148809,
+                  "durationMs": 3025
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148853,
+                  "durationMs": 3814
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 490
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 576
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145988,
+                      "durationMs": 797
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 146008,
+                      "durationMs": 1699
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2509,
+                      "durationMs": 1738
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2534,
+                      "durationMs": 1539
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5156.84
+            }
+          ],
+          "write-large-two-reuse": [
+            {
+              "region": "japaneast",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000148",
+              "mode": "reuse",
+              "workerIoTimerMs": 6207,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727232,
+                  "durationMs": 3341
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727275,
+                  "durationMs": 4642
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 419
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 545
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723048,
+                      "durationMs": 916
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723057,
+                      "durationMs": 1776
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 3872,
+                      "durationMs": 2006
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 3907,
+                      "durationMs": 2321
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6226.906
+            },
+            {
+              "region": "japaneast",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001125",
+              "mode": "reuse",
+              "workerIoTimerMs": 5719,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727874,
+                  "durationMs": 3517
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727921,
+                  "durationMs": 4153
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 594
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 542
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723057,
+                      "durationMs": 1050
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723071,
+                      "durationMs": 1951
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4506,
+                      "durationMs": 1873
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4540,
+                      "durationMs": 1660
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5744.689
+            },
+            {
+              "region": "japaneast",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-002102",
+              "mode": "reuse",
+              "workerIoTimerMs": 6577,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727749,
+                  "durationMs": 3641
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727783,
+                  "durationMs": 4836
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 792
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 599
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723071,
+                      "durationMs": 1048
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723077,
+                      "durationMs": 1900
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4368,
+                      "durationMs": 1801
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4394,
+                      "durationMs": 2337
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6597.28
+            },
+            {
+              "region": "japaneast",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-003079",
+              "mode": "reuse",
+              "workerIoTimerMs": 5973,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727917,
+                  "durationMs": 3813
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727969,
+                  "durationMs": 4475
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 299
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 522
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723077,
+                      "durationMs": 1167
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723102,
+                      "durationMs": 2315
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4528,
+                      "durationMs": 2347
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4555,
+                      "durationMs": 1638
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5995.042
+            }
+          ]
+        },
+        "verification": [
+          {
+            "region": "japaneast",
+            "profile": "small",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "japaneast",
+            "profile": "small",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "japaneast",
+            "profile": "medium",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "japaneast",
+            "profile": "medium",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "japaneast",
+            "profile": "large",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "japaneast",
+            "profile": "large",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          }
+        ]
+      }
+    },
+    {
+      "replicate": "b",
+      "region": "australiaeast",
+      "result": {
+        "generatedAt": "2026-09-30T03:28:56.848Z",
+        "sourceCommit": "bd8af6eec98b8f4a745d90327e96534c4a09fac0",
+        "harnessCommit": "a1a1d02d9ce71318956e5a5cb9574eed43314c04",
+        "runId": "index-reuse-b",
+        "replicate": "b",
+        "region": "australiaeast",
+        "colo": "SYD",
+        "runtime": "Node v22.23.3",
+        "iterations": 4,
+        "samples": {
+          "write-small-one-duplicate": [
+            {
+              "region": "australiaeast",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000057",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5780,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5733,
+                  "durationMs": 2967
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3739,
+                  "durationMs": 3507
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 598
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 714
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4040,
+                      "durationMs": 684
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2021,
+                      "durationMs": 694
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1450,
+                      "durationMs": 1685
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1474,
+                      "durationMs": 2099
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5792.251
+            },
+            {
+              "region": "australiaeast",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-000010",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5477,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5691,
+                  "durationMs": 2513
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3690,
+                  "durationMs": 3636
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 435
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 687
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4042,
+                      "durationMs": 722
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2021,
+                      "durationMs": 672
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1405,
+                      "durationMs": 1356
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1425,
+                      "durationMs": 2277
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5488.661
+            },
+            {
+              "region": "australiaeast",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-000091",
+              "mode": "duplicate",
+              "workerIoTimerMs": 4968,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5645,
+                  "durationMs": 2278
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3650,
+                  "durationMs": 3353
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 437
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 676
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4042,
+                      "durationMs": 619
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2023,
+                      "durationMs": 663
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1359,
+                      "durationMs": 1222
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1385,
+                      "durationMs": 2014
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4978.936
+            },
+            {
+              "region": "australiaeast",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-000044",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5404,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5775,
+                  "durationMs": 2518
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3779,
+                  "durationMs": 3544
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 497
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 698
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4046,
+                      "durationMs": 631
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2025,
+                      "durationMs": 658
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1487,
+                      "durationMs": 1390
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1511,
+                      "durationMs": 2188
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5413.927
+            }
+          ],
+          "write-medium-one-duplicate": [
+            {
+              "region": "australiaeast",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000185",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5119,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134449,
+                  "durationMs": 2423
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68630,
+                  "durationMs": 3477
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 408
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 681
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131688,
+                      "durationMs": 663
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65846,
+                      "durationMs": 781
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2518,
+                      "durationMs": 1352
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2539,
+                      "durationMs": 2015
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5143.684
+            },
+            {
+              "region": "australiaeast",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001162",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5237,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134176,
+                  "durationMs": 2418
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68359,
+                  "durationMs": 3535
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 415
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 672
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131692,
+                      "durationMs": 673
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65854,
+                      "durationMs": 716
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2239,
+                      "durationMs": 1330
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2261,
+                      "durationMs": 2147
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5249.765
+            },
+            {
+              "region": "australiaeast",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-002139",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5388,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134425,
+                  "durationMs": 2682
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68595,
+                  "durationMs": 3401
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 585
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 728
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131708,
+                      "durationMs": 627
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65858,
+                      "durationMs": 695
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2473,
+                      "durationMs": 1470
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2494,
+                      "durationMs": 1978
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5400.743
+            },
+            {
+              "region": "australiaeast",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-003116",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5843,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134289,
+                  "durationMs": 2691
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68459,
+                  "durationMs": 3927
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 485
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 678
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131716,
+                      "durationMs": 822
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65863,
+                      "durationMs": 775
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2330,
+                      "durationMs": 1384
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2353,
+                      "durationMs": 2474
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5855.524
+            }
+          ],
+          "write-large-one-duplicate": [
+            {
+              "region": "australiaeast",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000185",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5391,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656690,
+                  "durationMs": 2623
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330661,
+                  "durationMs": 3688
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 388
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 683
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652116,
+                      "durationMs": 718
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326059,
+                      "durationMs": 920
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4330,
+                      "durationMs": 1517
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4358,
+                      "durationMs": 2085
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5408.328
+            },
+            {
+              "region": "australiaeast",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001162",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5376,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656739,
+                  "durationMs": 2583
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330711,
+                  "durationMs": 3996
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 399
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 675
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652118,
+                      "durationMs": 663
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326063,
+                      "durationMs": 1203
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4377,
+                      "durationMs": 1521
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4405,
+                      "durationMs": 2118
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5394.458
+            },
+            {
+              "region": "australiaeast",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-002139",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5402,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656509,
+                  "durationMs": 2646
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330480,
+                  "durationMs": 3780
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 410
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 677
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652126,
+                      "durationMs": 690
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326071,
+                      "durationMs": 1024
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4140,
+                      "durationMs": 1546
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4164,
+                      "durationMs": 2079
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5418.358
+            },
+            {
+              "region": "australiaeast",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-003116",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5571,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656566,
+                  "durationMs": 2820
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330523,
+                  "durationMs": 3680
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 387
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 702
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652142,
+                      "durationMs": 924
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326074,
+                      "durationMs": 929
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4179,
+                      "durationMs": 1509
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4205,
+                      "durationMs": 2049
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5588.196
+            }
+          ],
+          "write-small-one-reuse": [
+            {
+              "region": "australiaeast",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000057",
+              "mode": "reuse",
+              "workerIoTimerMs": 5235,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3713,
+                  "durationMs": 2265
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3739,
+                  "durationMs": 3669
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 418
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 808
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2020,
+                      "durationMs": 390
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2021,
+                      "durationMs": 699
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1450,
+                      "durationMs": 1457
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1474,
+                      "durationMs": 2162
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5254.724
+            },
+            {
+              "region": "australiaeast",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-000010",
+              "mode": "reuse",
+              "workerIoTimerMs": 4839,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3670,
+                  "durationMs": 2089
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3690,
+                  "durationMs": 3410
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 426
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 696
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2021,
+                      "durationMs": 377
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2021,
+                      "durationMs": 660
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1405,
+                      "durationMs": 1286
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1425,
+                      "durationMs": 2054
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4851.344
+            },
+            {
+              "region": "australiaeast",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-000091",
+              "mode": "reuse",
+              "workerIoTimerMs": 4669,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3624,
+                  "durationMs": 2021
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3650,
+                  "durationMs": 3317
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 400
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 681
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2021,
+                      "durationMs": 389
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2023,
+                      "durationMs": 669
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1359,
+                      "durationMs": 1232
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1385,
+                      "durationMs": 1967
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4680.51
+            },
+            {
+              "region": "australiaeast",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-000044",
+              "mode": "reuse",
+              "workerIoTimerMs": 5233,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3752,
+                  "durationMs": 2079
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3779,
+                  "durationMs": 3812
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 454
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 665
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2023,
+                      "durationMs": 422
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2025,
+                      "durationMs": 658
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1487,
+                      "durationMs": 1203
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1511,
+                      "durationMs": 2489
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5243.473
+            }
+          ],
+          "write-medium-one-reuse": [
+            {
+              "region": "australiaeast",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000185",
+              "mode": "reuse",
+              "workerIoTimerMs": 5001,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68605,
+                  "durationMs": 2323
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68630,
+                  "durationMs": 3558
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 462
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 656
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65844,
+                      "durationMs": 454
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65846,
+                      "durationMs": 880
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2518,
+                      "durationMs": 1407
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2539,
+                      "durationMs": 2022
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5016.965
+            },
+            {
+              "region": "australiaeast",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001162",
+              "mode": "reuse",
+              "workerIoTimerMs": 5091,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68330,
+                  "durationMs": 2249
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68359,
+                  "durationMs": 3554
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 398
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 683
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65846,
+                      "durationMs": 395
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65854,
+                      "durationMs": 712
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2239,
+                      "durationMs": 1456
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2261,
+                      "durationMs": 2159
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5103.61
+            },
+            {
+              "region": "australiaeast",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-002139",
+              "mode": "reuse",
+              "workerIoTimerMs": 5108,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68571,
+                  "durationMs": 2378
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68595,
+                  "durationMs": 3506
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 408
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 694
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65854,
+                      "durationMs": 401
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65858,
+                      "durationMs": 776
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2473,
+                      "durationMs": 1569
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2494,
+                      "durationMs": 2036
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5122.549
+            },
+            {
+              "region": "australiaeast",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-003116",
+              "mode": "reuse",
+              "workerIoTimerMs": 4996,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68431,
+                  "durationMs": 2240
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68459,
+                  "durationMs": 3614
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 508
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 697
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65858,
+                      "durationMs": 427
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65863,
+                      "durationMs": 858
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2330,
+                      "durationMs": 1305
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2353,
+                      "durationMs": 2059
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5007.626
+            }
+          ],
+          "write-large-one-reuse": [
+            {
+              "region": "australiaeast",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000185",
+              "mode": "reuse",
+              "workerIoTimerMs": 5441,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330632,
+                  "durationMs": 2499
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330661,
+                  "durationMs": 3860
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 409
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 656
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326058,
+                      "durationMs": 504
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326059,
+                      "durationMs": 918
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4330,
+                      "durationMs": 1586
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4358,
+                      "durationMs": 2286
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5458.115
+            },
+            {
+              "region": "australiaeast",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001162",
+              "mode": "reuse",
+              "workerIoTimerMs": 5173,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330680,
+                  "durationMs": 2381
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330711,
+                  "durationMs": 3647
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 409
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 712
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326059,
+                      "durationMs": 542
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326063,
+                      "durationMs": 855
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4377,
+                      "durationMs": 1430
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4405,
+                      "durationMs": 2080
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5188.63
+            },
+            {
+              "region": "australiaeast",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-002139",
+              "mode": "reuse",
+              "workerIoTimerMs": 5143,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330446,
+                  "durationMs": 2449
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330480,
+                  "durationMs": 3729
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 444
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 669
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326063,
+                      "durationMs": 434
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326071,
+                      "durationMs": 1035
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4140,
+                      "durationMs": 1571
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4164,
+                      "durationMs": 2025
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5156.894
+            },
+            {
+              "region": "australiaeast",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-003116",
+              "mode": "reuse",
+              "workerIoTimerMs": 6292,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330495,
+                  "durationMs": 2565
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330523,
+                  "durationMs": 4587
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 449
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 1170
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326071,
+                      "durationMs": 508
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326074,
+                      "durationMs": 860
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4179,
+                      "durationMs": 1608
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4205,
+                      "durationMs": 2557
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6303.523
+            }
+          ],
+          "write-small-two-duplicate": [
+            {
+              "region": "australiaeast",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000057",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5740,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10432,
+                  "durationMs": 3077
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6121,
+                  "durationMs": 3957
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 442
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 664
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8674,
+                      "durationMs": 1346
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4341,
+                      "durationMs": 1294
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1450,
+                      "durationMs": 1289
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1472,
+                      "durationMs": 1999
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5754.999
+            },
+            {
+              "region": "australiaeast",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-000010",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5525,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10393,
+                  "durationMs": 2874
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6079,
+                  "durationMs": 3991
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 394
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 671
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8682,
+                      "durationMs": 1230
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4344,
+                      "durationMs": 1340
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1403,
+                      "durationMs": 1250
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1425,
+                      "durationMs": 1980
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5537.334
+            },
+            {
+              "region": "australiaeast",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-000091",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5669,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10356,
+                  "durationMs": 3016
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6038,
+                  "durationMs": 3972
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 432
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 678
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8688,
+                      "durationMs": 1294
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4348,
+                      "durationMs": 1319
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1358,
+                      "durationMs": 1290
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1382,
+                      "durationMs": 1975
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5683.805
+            },
+            {
+              "region": "australiaeast",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-000044",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5705,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10489,
+                  "durationMs": 2893
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6172,
+                  "durationMs": 4172
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 422
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 760
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8696,
+                      "durationMs": 1241
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4353,
+                      "durationMs": 1360
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1485,
+                      "durationMs": 1230
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1510,
+                      "durationMs": 2052
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5716.928
+            }
+          ],
+          "write-medium-two-duplicate": [
+            {
+              "region": "australiaeast",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000185",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5758,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294732,
+                  "durationMs": 3096
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148813,
+                  "durationMs": 4185
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 445
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 683
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291904,
+                      "durationMs": 1306
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145962,
+                      "durationMs": 1523
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2518,
+                      "durationMs": 1345
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2540,
+                      "durationMs": 1979
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5771.87
+            },
+            {
+              "region": "australiaeast",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001162",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5707,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294472,
+                  "durationMs": 2960
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148540,
+                  "durationMs": 4316
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 396
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 760
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291924,
+                      "durationMs": 1242
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145977,
+                      "durationMs": 1569
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2237,
+                      "durationMs": 1322
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2255,
+                      "durationMs": 1987
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5720.435
+            },
+            {
+              "region": "australiaeast",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-002139",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5748,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294730,
+                  "durationMs": 3018
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148797,
+                  "durationMs": 4317
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 409
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 670
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291954,
+                      "durationMs": 1299
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145993,
+                      "durationMs": 1587
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2468,
+                      "durationMs": 1310
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2494,
+                      "durationMs": 2060
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5760.792
+            },
+            {
+              "region": "australiaeast",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-003116",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6767,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294627,
+                  "durationMs": 2975
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148662,
+                  "durationMs": 5358
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 398
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 686
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291986,
+                      "durationMs": 1262
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 146002,
+                      "durationMs": 1566
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2331,
+                      "durationMs": 1315
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2351,
+                      "durationMs": 3106
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6778.458
+            }
+          ],
+          "write-large-two-duplicate": [
+            {
+              "region": "australiaeast",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000185",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6805,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450738,
+                  "durationMs": 3859
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727730,
+                  "durationMs": 5354
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 393
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 658
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446096,
+                      "durationMs": 1531
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723057,
+                      "durationMs": 2408
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4330,
+                      "durationMs": 1935
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4362,
+                      "durationMs": 2288
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6825.799
+            },
+            {
+              "region": "australiaeast",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001162",
+              "mode": "duplicate",
+              "workerIoTimerMs": 7107,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450804,
+                  "durationMs": 4051
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727789,
+                  "durationMs": 5379
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 404
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 931
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446114,
+                      "durationMs": 1871
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723071,
+                      "durationMs": 2323
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4379,
+                      "durationMs": 1776
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4406,
+                      "durationMs": 2125
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7125.824
+            },
+            {
+              "region": "australiaeast",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-002139",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6697,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450595,
+                  "durationMs": 3916
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727569,
+                  "durationMs": 5139
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 438
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 685
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446142,
+                      "durationMs": 1713
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723091,
+                      "durationMs": 2358
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4141,
+                      "durationMs": 1765
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4165,
+                      "durationMs": 2096
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6715.46
+            },
+            {
+              "region": "australiaeast",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-003116",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6635,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450674,
+                  "durationMs": 3755
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727624,
+                  "durationMs": 6300
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 404
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 700
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446182,
+                      "durationMs": 1624
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723102,
+                      "durationMs": 3420
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4179,
+                      "durationMs": 1727
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4210,
+                      "durationMs": 2180
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6656.279
+            }
+          ],
+          "write-small-two-reuse": [
+            {
+              "region": "australiaeast",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000057",
+              "mode": "reuse",
+              "workerIoTimerMs": 5197,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6095,
+                  "durationMs": 2530
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6121,
+                  "durationMs": 3992
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 412
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 663
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4337,
+                      "durationMs": 806
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4341,
+                      "durationMs": 1325
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1450,
+                      "durationMs": 1312
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1472,
+                      "durationMs": 2004
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5210.651
+            },
+            {
+              "region": "australiaeast",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-000010",
+              "mode": "reuse",
+              "workerIoTimerMs": 5690,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6052,
+                  "durationMs": 2605
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6079,
+                  "durationMs": 4512
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 393
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 660
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4341,
+                      "durationMs": 872
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4344,
+                      "durationMs": 1427
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1403,
+                      "durationMs": 1340
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1425,
+                      "durationMs": 2425
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5701.483
+            },
+            {
+              "region": "australiaeast",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-000091",
+              "mode": "reuse",
+              "workerIoTimerMs": 5219,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6012,
+                  "durationMs": 2520
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6038,
+                  "durationMs": 4001
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 465
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 670
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4344,
+                      "durationMs": 814
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4348,
+                      "durationMs": 1302
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1358,
+                      "durationMs": 1241
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1382,
+                      "durationMs": 2029
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5229.902
+            },
+            {
+              "region": "australiaeast",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-000044",
+              "mode": "reuse",
+              "workerIoTimerMs": 5702,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6141,
+                  "durationMs": 2567
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6172,
+                  "durationMs": 4476
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 414
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 662
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4348,
+                      "durationMs": 852
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4353,
+                      "durationMs": 1341
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1485,
+                      "durationMs": 1301
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1510,
+                      "durationMs": 2473
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5713.243
+            }
+          ],
+          "write-medium-two-reuse": [
+            {
+              "region": "australiaeast",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000185",
+              "mode": "reuse",
+              "workerIoTimerMs": 5490,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148780,
+                  "durationMs": 2786
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148813,
+                  "durationMs": 4183
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 449
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 693
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145952,
+                      "durationMs": 834
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145962,
+                      "durationMs": 1479
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2518,
+                      "durationMs": 1503
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2540,
+                      "durationMs": 2011
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5503.139
+            },
+            {
+              "region": "australiaeast",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001162",
+              "mode": "reuse",
+              "workerIoTimerMs": 5343,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148510,
+                  "durationMs": 2576
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148540,
+                  "durationMs": 4325
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 400
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 718
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145962,
+                      "durationMs": 805
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145977,
+                      "durationMs": 1558
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2237,
+                      "durationMs": 1371
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2255,
+                      "durationMs": 2049
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5357.229
+            },
+            {
+              "region": "australiaeast",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-002139",
+              "mode": "reuse",
+              "workerIoTimerMs": 5447,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148753,
+                  "durationMs": 2728
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148797,
+                  "durationMs": 4185
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 396
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 683
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145977,
+                      "durationMs": 818
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145993,
+                      "durationMs": 1466
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2468,
+                      "durationMs": 1514
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2494,
+                      "durationMs": 2036
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5458.999
+            },
+            {
+              "region": "australiaeast",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-003116",
+              "mode": "reuse",
+              "workerIoTimerMs": 6566,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148634,
+                  "durationMs": 2663
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148662,
+                  "durationMs": 5451
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 381
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 677
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145993,
+                      "durationMs": 910
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 146002,
+                      "durationMs": 1548
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2331,
+                      "durationMs": 1372
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2351,
+                      "durationMs": 3226
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6576.373
+            }
+          ],
+          "write-large-two-reuse": [
+            {
+              "region": "australiaeast",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000185",
+              "mode": "reuse",
+              "workerIoTimerMs": 7293,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727690,
+                  "durationMs": 3602
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727730,
+                  "durationMs": 5981
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 617
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 676
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723048,
+                      "durationMs": 1251
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723057,
+                      "durationMs": 2290
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4330,
+                      "durationMs": 1734
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4362,
+                      "durationMs": 3015
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7307.776
+            },
+            {
+              "region": "australiaeast",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001162",
+              "mode": "reuse",
+              "workerIoTimerMs": 6037,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727747,
+                  "durationMs": 3166
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727789,
+                  "durationMs": 5237
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 390
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 704
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723057,
+                      "durationMs": 1030
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723071,
+                      "durationMs": 2366
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4379,
+                      "durationMs": 1746
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4406,
+                      "durationMs": 2167
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6056.5
+            },
+            {
+              "region": "australiaeast",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-002139",
+              "mode": "reuse",
+              "workerIoTimerMs": 6450,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727524,
+                  "durationMs": 3641
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727569,
+                  "durationMs": 5231
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 425
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 679
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723071,
+                      "durationMs": 1395
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723091,
+                      "durationMs": 2422
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4141,
+                      "durationMs": 1821
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4165,
+                      "durationMs": 2130
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6472.945
+            },
+            {
+              "region": "australiaeast",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-003116",
+              "mode": "reuse",
+              "workerIoTimerMs": 7009,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727583,
+                  "durationMs": 3573
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727624,
+                  "durationMs": 5842
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 802
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 1166
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723091,
+                      "durationMs": 1054
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723102,
+                      "durationMs": 2406
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4179,
+                      "durationMs": 1717
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4210,
+                      "durationMs": 2270
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 7026.298
+            }
+          ]
+        },
+        "verification": [
+          {
+            "region": "australiaeast",
+            "profile": "small",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "australiaeast",
+            "profile": "small",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "australiaeast",
+            "profile": "medium",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "australiaeast",
+            "profile": "medium",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "australiaeast",
+            "profile": "large",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "australiaeast",
+            "profile": "large",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          }
+        ]
+      }
+    },
+    {
+      "replicate": "b",
+      "region": "brazilsouth",
+      "result": {
+        "generatedAt": "2026-09-30T03:28:54.269Z",
+        "sourceCommit": "bd8af6eec98b8f4a745d90327e96534c4a09fac0",
+        "harnessCommit": "a1a1d02d9ce71318956e5a5cb9574eed43314c04",
+        "runId": "index-reuse-b",
+        "replicate": "b",
+        "region": "brazilsouth",
+        "colo": "GRU",
+        "runtime": "Node v22.23.3",
+        "iterations": 4,
+        "samples": {
+          "write-small-one-duplicate": [
+            {
+              "region": "brazilsouth",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000094",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5951,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5724,
+                  "durationMs": 2435
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3725,
+                  "durationMs": 4111
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 551
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 622
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4040,
+                      "durationMs": 549
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2022,
+                      "durationMs": 595
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1441,
+                      "durationMs": 1335
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1460,
+                      "durationMs": 2894
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5965.38
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-000047",
+              "mode": "duplicate",
+              "workerIoTimerMs": 4859,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5905,
+                  "durationMs": 2380
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3906,
+                  "durationMs": 3127
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 409
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 635
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4044,
+                      "durationMs": 723
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2023,
+                      "durationMs": 648
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1618,
+                      "durationMs": 1248
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1640,
+                      "durationMs": 1844
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4870.392
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-000000",
+              "mode": "duplicate",
+              "workerIoTimerMs": 4610,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5653,
+                  "durationMs": 2206
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3649,
+                  "durationMs": 3581
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 397
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 594
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4046,
+                      "durationMs": 568
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2023,
+                      "durationMs": 1177
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1364,
+                      "durationMs": 1241
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1383,
+                      "durationMs": 1810
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4622.079
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-000081",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5536,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 5686,
+                  "durationMs": 2407
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3687,
+                  "durationMs": 3711
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 409
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 605
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4046,
+                      "durationMs": 592
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2025,
+                      "durationMs": 582
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1397,
+                      "durationMs": 1406
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1419,
+                      "durationMs": 2524
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5555.631
+            }
+          ],
+          "write-medium-one-duplicate": [
+            {
+              "region": "brazilsouth",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000222",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5544,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134350,
+                  "durationMs": 2548
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68532,
+                  "durationMs": 3662
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 400
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 1162
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131688,
+                      "durationMs": 593
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65846,
+                      "durationMs": 666
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2419,
+                      "durationMs": 1555
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2443,
+                      "durationMs": 1834
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5559.079
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001199",
+              "mode": "duplicate",
+              "workerIoTimerMs": 4837,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134594,
+                  "durationMs": 2276
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68784,
+                  "durationMs": 3986
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 418
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 640
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131692,
+                      "durationMs": 609
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65854,
+                      "durationMs": 1425
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2659,
+                      "durationMs": 1249
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2687,
+                      "durationMs": 1921
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4850.469
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-002176",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5221,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134581,
+                  "durationMs": 2528
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68755,
+                  "durationMs": 3356
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 406
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 624
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131708,
+                      "durationMs": 622
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65858,
+                      "durationMs": 663
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2630,
+                      "durationMs": 1500
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2653,
+                      "durationMs": 2069
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5232.978
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-003153",
+              "mode": "duplicate",
+              "workerIoTimerMs": 4888,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 134434,
+                  "durationMs": 2318
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68602,
+                  "durationMs": 3499
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 393
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 625
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 131716,
+                      "durationMs": 601
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65866,
+                      "durationMs": 929
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2474,
+                      "durationMs": 1324
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2494,
+                      "durationMs": 1945
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4902.628
+            }
+          ],
+          "write-large-one-duplicate": [
+            {
+              "region": "brazilsouth",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000222",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5477,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656518,
+                  "durationMs": 2708
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330497,
+                  "durationMs": 4691
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 434
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 894
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652116,
+                      "durationMs": 649
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326061,
+                      "durationMs": 1922
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4158,
+                      "durationMs": 1625
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4191,
+                      "durationMs": 1875
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5492.553
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001199",
+              "mode": "duplicate",
+              "workerIoTimerMs": 4999,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656839,
+                  "durationMs": 2464
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330810,
+                  "durationMs": 3458
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 393
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 675
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652122,
+                      "durationMs": 640
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326065,
+                      "durationMs": 923
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4472,
+                      "durationMs": 1431
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4500,
+                      "durationMs": 1860
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5017.604
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-002176",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5539,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656881,
+                  "durationMs": 2511
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330848,
+                  "durationMs": 4424
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 380
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 606
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652130,
+                      "durationMs": 676
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326072,
+                      "durationMs": 1396
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4506,
+                      "durationMs": 1455
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4532,
+                      "durationMs": 2422
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5556.951
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-003153",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5356,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 656842,
+                  "durationMs": 2661
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330802,
+                  "durationMs": 3508
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 460
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 684
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 652144,
+                      "durationMs": 777
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326078,
+                      "durationMs": 813
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4454,
+                      "durationMs": 1424
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4481,
+                      "durationMs": 2011
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5373.941
+            }
+          ],
+          "write-small-one-reuse": [
+            {
+              "region": "brazilsouth",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000094",
+              "mode": "reuse",
+              "workerIoTimerMs": 4453,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3704,
+                  "durationMs": 2031
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3725,
+                  "durationMs": 3020
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 425
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 616
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2020,
+                      "durationMs": 419
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2022,
+                      "durationMs": 598
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1441,
+                      "durationMs": 1187
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1460,
+                      "durationMs": 1806
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4466.135
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-000047",
+              "mode": "reuse",
+              "workerIoTimerMs": 4496,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3883,
+                  "durationMs": 1999
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3906,
+                  "durationMs": 3089
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 381
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 603
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2022,
+                      "durationMs": 380
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2023,
+                      "durationMs": 592
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1618,
+                      "durationMs": 1238
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1640,
+                      "durationMs": 1894
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4508.986
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-000000",
+              "mode": "reuse",
+              "workerIoTimerMs": 4443,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3630,
+                  "durationMs": 1989
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3649,
+                  "durationMs": 3029
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 378
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 641
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2023,
+                      "durationMs": 393
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2023,
+                      "durationMs": 575
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1364,
+                      "durationMs": 1218
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1383,
+                      "durationMs": 1813
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4456.662
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "small",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-000081",
+              "mode": "reuse",
+              "workerIoTimerMs": 5070,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 3663,
+                  "durationMs": 1996
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 3687,
+                  "durationMs": 3681
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 426
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 706
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 2023,
+                      "durationMs": 404
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 2025,
+                      "durationMs": 607
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1397,
+                      "durationMs": 1166
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1419,
+                      "durationMs": 2368
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5082.522
+            }
+          ],
+          "write-medium-one-reuse": [
+            {
+              "region": "brazilsouth",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000222",
+              "mode": "reuse",
+              "workerIoTimerMs": 4549,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68506,
+                  "durationMs": 2074
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68532,
+                  "durationMs": 3896
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 387
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 612
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65844,
+                      "durationMs": 381
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65846,
+                      "durationMs": 1421
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2419,
+                      "durationMs": 1306
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2443,
+                      "durationMs": 1863
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4562.661
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001199",
+              "mode": "reuse",
+              "workerIoTimerMs": 4991,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68748,
+                  "durationMs": 2018
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68784,
+                  "durationMs": 3641
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 360
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 652
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65846,
+                      "durationMs": 441
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65854,
+                      "durationMs": 668
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2659,
+                      "durationMs": 1217
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2687,
+                      "durationMs": 2321
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5002.49
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-002176",
+              "mode": "reuse",
+              "workerIoTimerMs": 4413,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68727,
+                  "durationMs": 2024
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68755,
+                  "durationMs": 3015
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 374
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 617
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65854,
+                      "durationMs": 454
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65858,
+                      "durationMs": 626
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2630,
+                      "durationMs": 1196
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2653,
+                      "durationMs": 1772
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4429.296
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "medium",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-003153",
+              "mode": "reuse",
+              "workerIoTimerMs": 5123,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 68576,
+                  "durationMs": 2147
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 68602,
+                  "durationMs": 3615
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 395
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 242,
+                      "durationMs": 618
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 65858,
+                      "durationMs": 429
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 65866,
+                      "durationMs": 639
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2474,
+                      "durationMs": 1323
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2494,
+                      "durationMs": 2358
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5136.007
+            }
+          ],
+          "write-large-one-reuse": [
+            {
+              "region": "brazilsouth",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 0,
+              "id": "note-000222",
+              "mode": "reuse",
+              "workerIoTimerMs": 4865,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330460,
+                  "durationMs": 2287
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330497,
+                  "durationMs": 3627
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 418
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 627
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326058,
+                      "durationMs": 438
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326061,
+                      "durationMs": 1049
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4158,
+                      "durationMs": 1431
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4191,
+                      "durationMs": 1951
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4883.408
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 1,
+              "id": "note-001199",
+              "mode": "reuse",
+              "workerIoTimerMs": 4811,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330778,
+                  "durationMs": 2333
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330810,
+                  "durationMs": 4407
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 377
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 648
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326061,
+                      "durationMs": 423
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326065,
+                      "durationMs": 1929
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4472,
+                      "durationMs": 1533
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4500,
+                      "durationMs": 1830
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4826.792
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 2,
+              "id": "note-002176",
+              "mode": "reuse",
+              "workerIoTimerMs": 4948,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330816,
+                  "durationMs": 2381
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330848,
+                  "durationMs": 3451
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 245,
+                      "durationMs": 369
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 618
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326065,
+                      "durationMs": 599
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326072,
+                      "durationMs": 884
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4506,
+                      "durationMs": 1413
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4532,
+                      "durationMs": 1949
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4965.594
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "large",
+              "indexSet": "one",
+              "indexCount": 1,
+              "iteration": 3,
+              "id": "note-003153",
+              "mode": "reuse",
+              "workerIoTimerMs": 5675,
+              "storage": {
+                "reads": {
+                  "count": 5,
+                  "bytes": 330770,
+                  "durationMs": 2690
+                },
+                "writes": {
+                  "count": 5,
+                  "bytes": 330802,
+                  "durationMs": 4313
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 244,
+                      "durationMs": 432
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 243,
+                      "durationMs": 647
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 326072,
+                      "durationMs": 426
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 326078,
+                      "durationMs": 1328
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4454,
+                      "durationMs": 1832
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4481,
+                      "durationMs": 2338
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5689.518
+            }
+          ],
+          "write-small-two-duplicate": [
+            {
+              "region": "brazilsouth",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000094",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5675,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10423,
+                  "durationMs": 3277
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6110,
+                  "durationMs": 4215
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 430
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 611
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8674,
+                      "durationMs": 1326
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4342,
+                      "durationMs": 1817
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1441,
+                      "durationMs": 1521
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1460,
+                      "durationMs": 1787
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5691.772
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-000047",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5370,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10609,
+                  "durationMs": 2932
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6296,
+                  "durationMs": 4055
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 453
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 620
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8684,
+                      "durationMs": 1154
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4346,
+                      "durationMs": 1617
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1617,
+                      "durationMs": 1325
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1641,
+                      "durationMs": 1818
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5382.009
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-000000",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5815,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10366,
+                  "durationMs": 2812
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6036,
+                  "durationMs": 4260
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 370
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 305,
+                      "durationMs": 1195
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8692,
+                      "durationMs": 1144
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4347,
+                      "durationMs": 1257
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1365,
+                      "durationMs": 1298
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1384,
+                      "durationMs": 1808
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5829.436
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-000081",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6171,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 10396,
+                  "durationMs": 3147
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6080,
+                  "durationMs": 4270
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 305,
+                      "durationMs": 418
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 599
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 8694,
+                      "durationMs": 1201
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4352,
+                      "durationMs": 1246
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1397,
+                      "durationMs": 1528
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1419,
+                      "durationMs": 2425
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6182.258
+            }
+          ],
+          "write-medium-two-duplicate": [
+            {
+              "region": "brazilsouth",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000222",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5920,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294633,
+                  "durationMs": 2884
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148711,
+                  "durationMs": 5178
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 439
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 677
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291904,
+                      "durationMs": 1192
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145960,
+                      "durationMs": 2142
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2419,
+                      "durationMs": 1253
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2442,
+                      "durationMs": 2359
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5933.391
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001199",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5502,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294888,
+                  "durationMs": 2896
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148974,
+                  "durationMs": 3956
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 385
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 693
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291920,
+                      "durationMs": 1202
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145977,
+                      "durationMs": 1350
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2659,
+                      "durationMs": 1309
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2687,
+                      "durationMs": 1913
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5517.519
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-002176",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5685,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294892,
+                  "durationMs": 3076
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148952,
+                  "durationMs": 3923
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 395
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 676
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291954,
+                      "durationMs": 1340
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145992,
+                      "durationMs": 1314
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2628,
+                      "durationMs": 1341
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2650,
+                      "durationMs": 1933
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5699.831
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-003153",
+              "mode": "duplicate",
+              "workerIoTimerMs": 5547,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 294765,
+                  "durationMs": 3094
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148812,
+                  "durationMs": 4682
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 406
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 597
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 291984,
+                      "durationMs": 1414
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 146008,
+                      "durationMs": 2229
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2471,
+                      "durationMs": 1274
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2494,
+                      "durationMs": 1856
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5562.229
+            }
+          ],
+          "write-large-two-duplicate": [
+            {
+              "region": "brazilsouth",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000222",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6278,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450566,
+                  "durationMs": 3650
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727559,
+                  "durationMs": 7652
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 427
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 623
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446096,
+                      "durationMs": 1432
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723056,
+                      "durationMs": 5024
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4158,
+                      "durationMs": 1791
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4192,
+                      "durationMs": 2005
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6306.735
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001199",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6626,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450894,
+                  "durationMs": 3464
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727885,
+                  "durationMs": 6771
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 419
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 624
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446112,
+                      "durationMs": 1328
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723070,
+                      "durationMs": 3609
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4471,
+                      "durationMs": 1717
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4502,
+                      "durationMs": 2538
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6648.776
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-002176",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6372,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450959,
+                  "durationMs": 3820
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727933,
+                  "durationMs": 6014
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 420
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 643
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446140,
+                      "durationMs": 1376
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723090,
+                      "durationMs": 3462
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4506,
+                      "durationMs": 2024
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4532,
+                      "durationMs": 1909
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6395.887
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-003153",
+              "mode": "duplicate",
+              "workerIoTimerMs": 6288,
+              "storage": {
+                "reads": {
+                  "count": 8,
+                  "bytes": 1450944,
+                  "durationMs": 3571
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727901,
+                  "durationMs": 5095
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 402
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 732
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 4,
+                      "bytes": 1446180,
+                      "durationMs": 1401
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723107,
+                      "durationMs": 2378
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4453,
+                      "durationMs": 1768
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4482,
+                      "durationMs": 1985
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6313.625
+            }
+          ],
+          "write-small-two-reuse": [
+            {
+              "region": "brazilsouth",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000094",
+              "mode": "reuse",
+              "workerIoTimerMs": 5293,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6086,
+                  "durationMs": 2700
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6110,
+                  "durationMs": 4339
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 403
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 778
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4337,
+                      "durationMs": 785
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4342,
+                      "durationMs": 1746
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1441,
+                      "durationMs": 1512
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1460,
+                      "durationMs": 1815
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5309.08
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-000047",
+              "mode": "reuse",
+              "workerIoTimerMs": 4986,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6267,
+                  "durationMs": 2392
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6296,
+                  "durationMs": 3835
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 308,
+                      "durationMs": 392
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 646
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4342,
+                      "durationMs": 761
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4346,
+                      "durationMs": 1241
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1617,
+                      "durationMs": 1239
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1641,
+                      "durationMs": 1948
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4998.86
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-000000",
+              "mode": "reuse",
+              "workerIoTimerMs": 5097,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6020,
+                  "durationMs": 2695
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6036,
+                  "durationMs": 3659
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 391
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 305,
+                      "durationMs": 623
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4346,
+                      "durationMs": 901
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4347,
+                      "durationMs": 1257
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1365,
+                      "durationMs": 1403
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1384,
+                      "durationMs": 1779
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5110.246
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "small",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-000081",
+              "mode": "reuse",
+              "workerIoTimerMs": 4967,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 6049,
+                  "durationMs": 2537
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 6080,
+                  "durationMs": 3661
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 305,
+                      "durationMs": 518
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 637
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 4347,
+                      "durationMs": 767
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 4352,
+                      "durationMs": 1231
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 1397,
+                      "durationMs": 1252
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 1419,
+                      "durationMs": 1793
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 4980.283
+            }
+          ],
+          "write-medium-two-reuse": [
+            {
+              "region": "brazilsouth",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000222",
+              "mode": "reuse",
+              "workerIoTimerMs": 5128,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148681,
+                  "durationMs": 2678
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148711,
+                  "durationMs": 3775
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 450
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 595
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145952,
+                      "durationMs": 976
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145960,
+                      "durationMs": 1325
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2419,
+                      "durationMs": 1252
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2442,
+                      "durationMs": 1855
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5144.504
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001199",
+              "mode": "reuse",
+              "workerIoTimerMs": 5920,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148928,
+                  "durationMs": 2945
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148974,
+                  "durationMs": 4331
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 309,
+                      "durationMs": 395
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 598
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145960,
+                      "durationMs": 839
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145977,
+                      "durationMs": 1356
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2659,
+                      "durationMs": 1711
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2687,
+                      "durationMs": 2377
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5934.972
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-002176",
+              "mode": "reuse",
+              "workerIoTimerMs": 5928,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148915,
+                  "durationMs": 3097
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148952,
+                  "durationMs": 4296
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 384
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 618
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145977,
+                      "durationMs": 1370
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 145992,
+                      "durationMs": 1465
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2628,
+                      "durationMs": 1343
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2650,
+                      "durationMs": 2213
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5942.5
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "medium",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-003153",
+              "mode": "reuse",
+              "workerIoTimerMs": 5507,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 148773,
+                  "durationMs": 2857
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 148812,
+                  "durationMs": 4774
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 401
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 310,
+                      "durationMs": 648
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 145992,
+                      "durationMs": 1137
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 146008,
+                      "durationMs": 2124
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 2471,
+                      "durationMs": 1319
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 2494,
+                      "durationMs": 2002
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5521.751
+            }
+          ],
+          "write-large-two-reuse": [
+            {
+              "region": "brazilsouth",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 0,
+              "id": "note-000222",
+              "mode": "reuse",
+              "workerIoTimerMs": 5914,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727518,
+                  "durationMs": 3370
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727559,
+                  "durationMs": 4499
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 424
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 610
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723048,
+                      "durationMs": 1084
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723056,
+                      "durationMs": 1955
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4158,
+                      "durationMs": 1862
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4192,
+                      "durationMs": 1934
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5934.933
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 1,
+              "id": "note-001199",
+              "mode": "reuse",
+              "workerIoTimerMs": 6583,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727838,
+                  "durationMs": 3204
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727885,
+                  "durationMs": 5461
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 391
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 884
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723056,
+                      "durationMs": 1081
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723070,
+                      "durationMs": 2082
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4471,
+                      "durationMs": 1732
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4502,
+                      "durationMs": 2495
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 6601.699
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 2,
+              "id": "note-002176",
+              "mode": "reuse",
+              "workerIoTimerMs": 5455,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727889,
+                  "durationMs": 2906
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727933,
+                  "durationMs": 4666
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 313,
+                      "durationMs": 380
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 602
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723070,
+                      "durationMs": 898
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723090,
+                      "durationMs": 2117
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4506,
+                      "durationMs": 1628
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4532,
+                      "durationMs": 1947
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5481.522
+            },
+            {
+              "region": "brazilsouth",
+              "profile": "large",
+              "indexSet": "two",
+              "indexCount": 2,
+              "iteration": 3,
+              "id": "note-003153",
+              "mode": "reuse",
+              "workerIoTimerMs": 5644,
+              "storage": {
+                "reads": {
+                  "count": 6,
+                  "bytes": 727854,
+                  "durationMs": 3101
+                },
+                "writes": {
+                  "count": 6,
+                  "bytes": 727901,
+                  "durationMs": 4629
+                },
+                "preconditionFailures": 0,
+                "byKind": {
+                  "head": {
+                    "reads": {
+                      "count": 1,
+                      "bytes": 311,
+                      "durationMs": 470
+                    },
+                    "writes": {
+                      "count": 1,
+                      "bytes": 312,
+                      "durationMs": 638
+                    }
+                  },
+                  "index": {
+                    "reads": {
+                      "count": 2,
+                      "bytes": 723090,
+                      "durationMs": 895
+                    },
+                    "writes": {
+                      "count": 2,
+                      "bytes": 723107,
+                      "durationMs": 2086
+                    }
+                  },
+                  "node": {
+                    "reads": {
+                      "count": 3,
+                      "bytes": 4453,
+                      "durationMs": 1736
+                    },
+                    "writes": {
+                      "count": 3,
+                      "bytes": 4482,
+                      "durationMs": 1905
+                    }
+                  }
+                }
+              },
+              "diagnostics": {
+                "casRetries": 0,
+                "nodesCreated": 3,
+                "reusedNodes": 0,
+                "garbageCollected": 0
+              },
+              "success": true,
+              "status": 200,
+              "clientElapsedMs": 5667.303
+            }
+          ]
+        },
+        "verification": [
+          {
+            "region": "brazilsouth",
+            "profile": "small",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "brazilsouth",
+            "profile": "small",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "brazilsouth",
+            "profile": "medium",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "brazilsouth",
+            "profile": "medium",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "brazilsouth",
+            "profile": "large",
+            "indexSet": "one",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          },
+          {
+            "region": "brazilsouth",
+            "profile": "large",
+            "indexSet": "two",
+            "documentsEqual": true,
+            "headsEqual": true,
+            "equivalent": true,
+            "success": true,
+            "status": 200
+          }
+        ]
+      }
+    }
+  ]
+}
diff --git a/evidence/trie-index-page-reuse-summary-2026-09-30.csv b/evidence/trie-index-page-reuse-summary-2026-09-30.csv
new file mode 100644
index 0000000..f1da055
--- /dev/null
+++ b/evidence/trie-index-page-reuse-summary-2026-09-30.csv
@@ -0,0 +1,7 @@
+profile,documents,index_set,index_count,baseline_p50_ms,candidate_p50_ms,p50_change_percent,baseline_p95_ms,candidate_p95_ms,p95_change_percent,baseline_reads,candidate_reads,read_byte_change_percent
+small,128,one,1,5370.461,4666.812,-13.1,8739.036,8670.088,-0.79,6,5,-35.22
+small,128,two,2,5765.41,5309.08,-7.91,9581.24,8998.601,-6.08,8,6,-41.57
+medium,5000,one,1,5250.03,5002.49,-4.72,8497.837,8558.276,0.71,6,5,-49
+medium,5000,two,2,5875.732,5503.139,-6.34,9702.225,8980.712,-7.44,8,6,-49.53
+large,25000,one,1,5418.358,5188.63,-4.24,9505.719,8956.486,-5.78,6,5,-49.65
+large,25000,two,2,6825.799,6164.567,-9.69,11467.727,10657.092,-7.07,8,6,-49.84
diff --git a/package.json b/package.json
index 4d81c9e..a17d600 100644
--- a/package.json
+++ b/package.json
@@ -121,6 +121,7 @@
     "benchmark:trie-index-reuse:regional:build": "tsc -p benchmarks/trie-index-page-reuse/regional/tsconfig.json --noEmit && vite build --config benchmarks/trie-index-page-reuse/regional/vite.config.ts",
     "benchmark:trie-index-reuse:regional:upload": "tsx benchmarks/trie-index-page-reuse/regional/upload.mjs",
     "benchmark:trie-index-reuse:regional:aggregate": "tsx benchmarks/trie-index-page-reuse/regional/aggregate.mjs",
+    "benchmark:trie-index-reuse:publish": "node benchmarks/trie-index-page-reuse/publish.mjs",
     "benchmark:write-scaling:regional:generate": "tsx benchmarks/write-scaling/regional/generate-data.mjs",
     "benchmark:write-scaling:regional:build": "tsc -p benchmarks/write-scaling/regional/tsconfig.json --noEmit && vite build --config benchmarks/write-scaling/regional/vite.config.ts",
     "benchmark:write-scaling:regional:upload": "tsx benchmarks/write-scaling/regional/upload.mjs",
diff --git a/site/public/benchmarks/trie-index-page-reuse-p50.svg b/site/public/benchmarks/trie-index-page-reuse-p50.svg
new file mode 100644
index 0000000..db9905c
--- /dev/null
+++ b/site/public/benchmarks/trie-index-page-reuse-p50.svg
@@ -0,0 +1,46 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="1050" height="590" viewBox="0 0 1050 590" role="img" aria-labelledby="title description">
+<title id="title">Trie index page reuse p50 latency</title>
+<desc id="description">Control with duplicate index reads and candidate with reused validated pages across collection sizes and index counts.</desc>
+<rect width="1050" height="590" fill="#f5f8fd"/>
+<text x="90" y="36" font-size="25" font-weight="700" fill="#0b1f3a">Reusing validated index pages reduces every regional p50</text>
+<text x="90" y="61" font-size="14" fill="#526274">Pooled p50 across seven Azure regions and two pristine R2 replicates. Lower is better.</text>
+<line x1="90" y1="485" x2="1010" y2="485" stroke="#d8e1ee"/><text x="78" y="489" text-anchor="end" font-size="12" fill="#526274">0</text>
+<line x1="90" y1="427.14" x2="1010" y2="427.14" stroke="#d8e1ee"/><text x="78" y="431.14" text-anchor="end" font-size="12" fill="#526274">1,000</text>
+<line x1="90" y1="369.29" x2="1010" y2="369.29" stroke="#d8e1ee"/><text x="78" y="373.29" text-anchor="end" font-size="12" fill="#526274">2,000</text>
+<line x1="90" y1="311.43" x2="1010" y2="311.43" stroke="#d8e1ee"/><text x="78" y="315.43" text-anchor="end" font-size="12" fill="#526274">3,000</text>
+<line x1="90" y1="253.57" x2="1010" y2="253.57" stroke="#d8e1ee"/><text x="78" y="257.57" text-anchor="end" font-size="12" fill="#526274">4,000</text>
+<line x1="90" y1="195.71" x2="1010" y2="195.71" stroke="#d8e1ee"/><text x="78" y="199.71" text-anchor="end" font-size="12" fill="#526274">5,000</text>
+<line x1="90" y1="137.86" x2="1010" y2="137.86" stroke="#d8e1ee"/><text x="78" y="141.86" text-anchor="end" font-size="12" fill="#526274">6,000</text>
+<line x1="90" y1="80" x2="1010" y2="80" stroke="#d8e1ee"/><text x="78" y="84" text-anchor="end" font-size="12" fill="#526274">7,000</text>
+<line x1="90" y1="485" x2="1010" y2="485" stroke="#0b1f3a"/>
+<rect x="125.67" y="174.28" width="38" height="310.72" fill="#0b1f3a"/>
+<rect x="169.67" y="214.99" width="38" height="270.01" fill="#1677ff"/>
+<text x="166.67" y="520" text-anchor="middle" font-size="14" fill="#0b1f3a">S1</text>
+<text x="166.67" y="541" text-anchor="middle" font-size="12" fill="#526274">-13.1%</text>
+<rect x="279" y="151.43" width="38" height="333.57" fill="#0b1f3a"/>
+<rect x="323" y="177.83" width="38" height="307.17" fill="#1677ff"/>
+<text x="320" y="520" text-anchor="middle" font-size="14" fill="#0b1f3a">S2</text>
+<text x="320" y="541" text-anchor="middle" font-size="12" fill="#526274">-7.91%</text>
+<rect x="432.33" y="181.25" width="38" height="303.75" fill="#0b1f3a"/>
+<rect x="476.33" y="195.57" width="38" height="289.43" fill="#1677ff"/>
+<text x="473.33" y="520" text-anchor="middle" font-size="14" fill="#0b1f3a">M1</text>
+<text x="473.33" y="541" text-anchor="middle" font-size="12" fill="#526274">-4.72%</text>
+<rect x="585.67" y="145.05" width="38" height="339.95" fill="#0b1f3a"/>
+<rect x="629.67" y="166.6" width="38" height="318.4" fill="#1677ff"/>
+<text x="626.67" y="520" text-anchor="middle" font-size="14" fill="#0b1f3a">M2</text>
+<text x="626.67" y="541" text-anchor="middle" font-size="12" fill="#526274">-6.34%</text>
+<rect x="739" y="171.51" width="38" height="313.49" fill="#0b1f3a"/>
+<rect x="783" y="184.8" width="38" height="300.2" fill="#1677ff"/>
+<text x="780" y="520" text-anchor="middle" font-size="14" fill="#0b1f3a">L1</text>
+<text x="780" y="541" text-anchor="middle" font-size="12" fill="#526274">-4.24%</text>
+<rect x="892.33" y="90.08" width="38" height="394.92" fill="#0b1f3a"/>
+<rect x="936.33" y="128.34" width="38" height="356.66" fill="#1677ff"/>
+<text x="933.33" y="520" text-anchor="middle" font-size="14" fill="#0b1f3a">L2</text>
+<text x="933.33" y="541" text-anchor="middle" font-size="12" fill="#526274">-9.69%</text>
+<rect x="740" y="24" width="16" height="16" fill="#0b1f3a"/>
+<text x="764" y="37" font-size="13" fill="#0b1f3a">Duplicate reads</text>
+<rect x="880" y="24" width="16" height="16" fill="#1677ff"/>
+<text x="904" y="37" font-size="13" fill="#0b1f3a">Reuse</text>
+<text x="24" y="282.5" transform="rotate(-90 24 282.5)" text-anchor="middle" font-size="14" fill="#526274">p50 latency (ms)</text>
+<text x="525" y="576" text-anchor="middle" font-size="12" fill="#526274">S/M/L = 128 / 5,000 / 25,000 documents; number = index count.</text>
+</svg>
diff --git a/site/scripts/prepare-assets.mjs b/site/scripts/prepare-assets.mjs
index ee27092..9bb745b 100644
--- a/site/scripts/prepare-assets.mjs
+++ b/site/scripts/prepare-assets.mjs
@@ -40,6 +40,9 @@ for (const file of [
   "write-scaling-local-2026-09-28.json",
   "write-scaling-local-baseline-rerun-2026-09-28.json",
   "write-scaling-comparison-2026-09-28.csv",
+  "trie-index-page-reuse-regional-worker-2026-09-30.json",
+  "trie-index-page-reuse-local-2026-09-30.json",
+  "trie-index-page-reuse-summary-2026-09-30.csv",
 ]) {
   const source = await readFile(
     path.join(repositoryRoot, "evidence", file),

From 05188f0b1ff37bba5aae9770d643273e345c068f Mon Sep 17 00:00:00 2001
From: Jason Doyle <46789294+Jason-Doyle@users.noreply.github.com>
Date: Tue, 29 Sep 2026 20:43:16 -0700
Subject: [PATCH 4/4] Update benchmark graph assertion

---
 site/tests/site.spec.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/site/tests/site.spec.ts b/site/tests/site.spec.ts
index c89ad0b..54ba3a8 100644
--- a/site/tests/site.spec.ts
+++ b/site/tests/site.spec.ts
@@ -367,7 +367,7 @@ test("benchmark page publishes tables, graphs, and raw evidence", async ({
   ).toBeVisible();
   await expect(
     page.locator('.prose img[src*="/benchmarks/"]'),
-  ).toHaveCount(5);
+  ).toHaveCount(6);
   await expect(page.locator(".prose table")).toHaveCount(12);
 
   const jsonResponse = await request.get(