@fluidframework/container-runtime 2.118.0 → 3.0.0

package/lib/throttler.js

@@ -7,6 +7,10 @@
  * Delay is based on previous attempts within specified time window, subtracting delay time.
  */
 export class Throttler {
+    delayWindowMs;
+    maxDelayMs;
+    delayFn;
+    startTimes = [];
     get numAttempts() {
         return this.startTimes.length;
     }
@@ -44,7 +48,6 @@ export class Throttler {
         this.delayWindowMs = delayWindowMs;
         this.maxDelayMs = maxDelayMs;
         this.delayFn = delayFn;
-        this.startTimes = [];
     }
     getDelay() {
         const now = Date.now();

package/lib/throttler.js.map

@@ -1 +1 @@
-{"version":3,"file":"throttler.js","sourceRoot":"","sources":["../src/throttler.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nexport interface IThrottler {\n\t/**\n\t * Computes what the throttle delay should be, and records an attempt\n\t * which will be used for calculating future attempt delays.\n\t */\n\tgetDelay(): number;\n\n\t/**\n\t * Number of attempts that occurred within the sliding window as of\n\t * the most recent delay computation.\n\t */\n\treadonly numAttempts: number;\n\n\t/**\n\t * Width of sliding delay window in milliseconds.\n\t */\n\treadonly delayWindowMs: number;\n\t/**\n\t * Maximum delay allowed in milliseconds.\n\t */\n\treadonly maxDelayMs: number;\n\t/**\n\t * Delay function used to calculate what the delay should be.\n\t * The input is the number of attempts that occurred within the sliding window.\n\t * The result is the calculated delay in milliseconds.\n\t */\n\treadonly delayFn: (numAttempts: number) => number;\n}\n\n/**\n * Used to give increasing delay times for throttling a single functionality.\n * Delay is based on previous attempts within specified time window, subtracting delay time.\n */\nexport class Throttler implements IThrottler {\n\tprivate startTimes: number[] = [];\n\n\tpublic get numAttempts(): number {\n\t\treturn this.startTimes.length;\n\t}\n\n\t/**\n\t * Gets all attempt start times after compensating for the delay times\n\t * by adding the delay times to the actual times.\n\t */\n\tpublic getAttempts(): readonly number[] {\n\t\treturn [...this.startTimes];\n\t}\n\n\t/**\n\t * Latest attempt time after compensating for the delay time itself\n\t * by adding the delay time to the actual time.\n\t */\n\tpublic get latestAttemptTime(): number | undefined {\n\t\treturn this.startTimes.length > 0\n\t\t\t? this.startTimes[this.startTimes.length - 1]\n\t\t\t: undefined;\n\t}\n\n\tconstructor(\n\t\t/**\n\t\t * Width of sliding delay window in milliseconds.\n\t\t */\n\t\tpublic readonly delayWindowMs: number,\n\t\t/**\n\t\t * Maximum delay allowed in milliseconds.\n\t\t */\n\t\tpublic readonly maxDelayMs: number,\n\t\t/**\n\t\t * Delay function used to calculate what the delay should be.\n\t\t * The input is the number of attempts that occurred within the sliding window.\n\t\t * The result is the calculated delay in milliseconds.\n\t\t */\n\t\tpublic readonly delayFn: (numAttempts: number) => number,\n\t) {}\n\n\tpublic getDelay(): number {\n\t\tconst now = Date.now();\n\n\t\tconst latestAttemptTime = this.latestAttemptTime;\n\t\tif (latestAttemptTime !== undefined) {\n\t\t\t// If getDelay was called sooner than the most recent delay,\n\t\t\t// subtract the remaining time, since we previously added it.\n\t\t\tconst earlyMs = latestAttemptTime - now;\n\t\t\tif (earlyMs > 0) {\n\t\t\t\tthis.startTimes = this.startTimes.map((t) => t - earlyMs);\n\t\t\t}\n\t\t}\n\n\t\t// Remove all attempts that have already fallen out of the window.\n\t\tthis.startTimes = this.startTimes.filter((t) => now - t < this.delayWindowMs);\n\n\t\t// Compute delay, but do not exceed the specified max delay.\n\t\tconst delayMs = Math.min(this.delayFn(this.startTimes.length), this.maxDelayMs);\n\n\t\t// Record this attempt start time.\n\t\tthis.startTimes.push(now);\n\n\t\t// Account for the delay time, by effectively removing it from the delay window.\n\t\tthis.startTimes = this.startTimes.map((t) => t + delayMs);\n\n\t\tif (delayMs === this.maxDelayMs) {\n\t\t\t// We hit max delay, so adding more won't affect anything.\n\t\t\t// Shift off oldest time to stop this array from growing forever.\n\t\t\tthis.startTimes.shift();\n\t\t}\n\n\t\treturn delayMs;\n\t}\n}\n\n/**\n * Helper function to generate simple exponential throttle functions.\n * f(n) = [coefficient] x ([multiplier]^n) + [flatOffset]\n * where n = number of attempts, and f(n) = delay time in milliseconds.\n * If not provided, coefficient will default to 1, multiplier to 2,\n * minimum delay to 0, and the offset to 0, yielding:\n * 0 ms, 2 ms, 4 ms, 8 ms, ..., 2^n ms\n * where M = multiplier; an exponential back-off.\n * Use initialDelay to decide what should happen when numAttempts is 0,\n * leave it undefined to not special case.\n */\nexport const formExponentialFn =\n\t({\n\t\tmultiplier = 2,\n\t\tcoefficient = 1,\n\t\toffset = 0,\n\t\tinitialDelay = undefined as number | undefined,\n\t} = {}): IThrottler[\"delayFn\"] =>\n\t(numAttempts) =>\n\t\tMath.max(\n\t\t\t0,\n\t\t\tnumAttempts <= 0 && initialDelay !== undefined\n\t\t\t\t? initialDelay\n\t\t\t\t: coefficient * Math.pow(multiplier, numAttempts) + offset,\n\t\t);\n\n/**\n * f(n) = C x (B^(n+A)) + F = (C x B^A) x B^n + F\n */\nexport const formExponentialFnWithAttemptOffset = (\n\tattemptOffset: number,\n\t{\n\t\tmultiplier = 2,\n\t\tcoefficient = 1,\n\t\toffset = 0,\n\t\tinitialDelay = undefined as number | undefined,\n\t} = {},\n): IThrottler[\"delayFn\"] =>\n\tformExponentialFn({\n\t\tmultiplier,\n\t\tcoefficient: coefficient * Math.pow(multiplier, attemptOffset),\n\t\toffset,\n\t\tinitialDelay,\n\t});\n\n/**\n * Helper function to generate simple linear throttle functions.\n * f(n) = [coefficient] x n + [flatOffset]\n * where n = number of attempts, and f(n) = delay time in milliseconds.\n * If not provided, coefficient will default to 1, and offset to 0, yielding:\n * 0 ms, 1 ms, 2 ms, 3 ms, ..., n ms delays; a linear back-off.\n */\nexport const formLinearFn =\n\t({ coefficient = 1, offset = 0 } = {}): IThrottler[\"delayFn\"] =>\n\t(numAttempts) =>\n\t\tMath.max(0, coefficient * numAttempts + offset);\n\n/**\n * f(n) = C x (n+A) + F = C x n + (C x A + F)\n */\nexport const formLinearFnWithAttemptOffset = (\n\tattemptOffset: number,\n\t{ coefficient = 1, offset = 0 } = {},\n): IThrottler[\"delayFn\"] =>\n\tformLinearFn({\n\t\tcoefficient,\n\t\toffset: coefficient * attemptOffset + offset,\n\t});\n"]}
+{"version":3,"file":"throttler.js","sourceRoot":"","sources":["../src/throttler.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nexport interface IThrottler {\n\t/**\n\t * Computes what the throttle delay should be, and records an attempt\n\t * which will be used for calculating future attempt delays.\n\t */\n\tgetDelay(): number;\n\n\t/**\n\t * Number of attempts that occurred within the sliding window as of\n\t * the most recent delay computation.\n\t */\n\treadonly numAttempts: number;\n\n\t/**\n\t * Width of sliding delay window in milliseconds.\n\t */\n\treadonly delayWindowMs: number;\n\t/**\n\t * Maximum delay allowed in milliseconds.\n\t */\n\treadonly maxDelayMs: number;\n\t/**\n\t * Delay function used to calculate what the delay should be.\n\t * The input is the number of attempts that occurred within the sliding window.\n\t * The result is the calculated delay in milliseconds.\n\t */\n\treadonly delayFn: (numAttempts: number) => number;\n}\n\n/**\n * Used to give increasing delay times for throttling a single functionality.\n * Delay is based on previous attempts within specified time window, subtracting delay time.\n */\nexport class Throttler implements IThrottler {\n\tprivate startTimes: number[] = [];\n\n\tpublic get numAttempts(): number {\n\t\treturn this.startTimes.length;\n\t}\n\n\t/**\n\t * Gets all attempt start times after compensating for the delay times\n\t * by adding the delay times to the actual times.\n\t */\n\tpublic getAttempts(): readonly number[] {\n\t\treturn [...this.startTimes];\n\t}\n\n\t/**\n\t * Latest attempt time after compensating for the delay time itself\n\t * by adding the delay time to the actual time.\n\t */\n\tpublic get latestAttemptTime(): number | undefined {\n\t\treturn this.startTimes.length > 0\n\t\t\t? this.startTimes[this.startTimes.length - 1]\n\t\t\t: undefined;\n\t}\n\n\tconstructor(\n\t\t/**\n\t\t * Width of sliding delay window in milliseconds.\n\t\t */\n\t\tpublic readonly delayWindowMs: number,\n\t\t/**\n\t\t * Maximum delay allowed in milliseconds.\n\t\t */\n\t\tpublic readonly maxDelayMs: number,\n\t\t/**\n\t\t * Delay function used to calculate what the delay should be.\n\t\t * The input is the number of attempts that occurred within the sliding window.\n\t\t * The result is the calculated delay in milliseconds.\n\t\t */\n\t\tpublic readonly delayFn: (numAttempts: number) => number,\n\t) {}\n\n\tpublic getDelay(): number {\n\t\tconst now = Date.now();\n\n\t\tconst latestAttemptTime = this.latestAttemptTime;\n\t\tif (latestAttemptTime !== undefined) {\n\t\t\t// If getDelay was called sooner than the most recent delay,\n\t\t\t// subtract the remaining time, since we previously added it.\n\t\t\tconst earlyMs = latestAttemptTime - now;\n\t\t\tif (earlyMs > 0) {\n\t\t\t\tthis.startTimes = this.startTimes.map((t) => t - earlyMs);\n\t\t\t}\n\t\t}\n\n\t\t// Remove all attempts that have already fallen out of the window.\n\t\tthis.startTimes = this.startTimes.filter((t) => now - t < this.delayWindowMs);\n\n\t\t// Compute delay, but do not exceed the specified max delay.\n\t\tconst delayMs = Math.min(this.delayFn(this.startTimes.length), this.maxDelayMs);\n\n\t\t// Record this attempt start time.\n\t\tthis.startTimes.push(now);\n\n\t\t// Account for the delay time, by effectively removing it from the delay window.\n\t\tthis.startTimes = this.startTimes.map((t) => t + delayMs);\n\n\t\tif (delayMs === this.maxDelayMs) {\n\t\t\t// We hit max delay, so adding more won't affect anything.\n\t\t\t// Shift off oldest time to stop this array from growing forever.\n\t\t\tthis.startTimes.shift();\n\t\t}\n\n\t\treturn delayMs;\n\t}\n}\n\n/**\n * Helper function to generate simple exponential throttle functions.\n * f(n) = [coefficient] x ([multiplier]^n) + [flatOffset]\n * where n = number of attempts, and f(n) = delay time in milliseconds.\n * If not provided, coefficient will default to 1, multiplier to 2,\n * minimum delay to 0, and the offset to 0, yielding:\n * 0 ms, 2 ms, 4 ms, 8 ms, ..., 2^n ms\n * where M = multiplier; an exponential back-off.\n * Use initialDelay to decide what should happen when numAttempts is 0,\n * leave it undefined to not special case.\n */\nexport const formExponentialFn =\n\t({\n\t\tmultiplier = 2,\n\t\tcoefficient = 1,\n\t\toffset = 0,\n\t\tinitialDelay = undefined as number | undefined,\n\t} = {}): IThrottler[\"delayFn\"] =>\n\t(numAttempts) =>\n\t\tMath.max(\n\t\t\t0,\n\t\t\tnumAttempts <= 0 && initialDelay !== undefined\n\t\t\t\t? initialDelay\n\t\t\t\t: coefficient * Math.pow(multiplier, numAttempts) + offset,\n\t\t);\n\n/**\n * f(n) = C x (B^(n+A)) + F = (C x B^A) x B^n + F\n */\nexport const formExponentialFnWithAttemptOffset = (\n\tattemptOffset: number,\n\t{\n\t\tmultiplier = 2,\n\t\tcoefficient = 1,\n\t\toffset = 0,\n\t\tinitialDelay = undefined as number | undefined,\n\t} = {},\n): IThrottler[\"delayFn\"] =>\n\tformExponentialFn({\n\t\tmultiplier,\n\t\tcoefficient: coefficient * Math.pow(multiplier, attemptOffset),\n\t\toffset,\n\t\tinitialDelay,\n\t});\n\n/**\n * Helper function to generate simple linear throttle functions.\n * f(n) = [coefficient] x n + [flatOffset]\n * where n = number of attempts, and f(n) = delay time in milliseconds.\n * If not provided, coefficient will default to 1, and offset to 0, yielding:\n * 0 ms, 1 ms, 2 ms, 3 ms, ..., n ms delays; a linear back-off.\n */\nexport const formLinearFn =\n\t({ coefficient = 1, offset = 0 } = {}): IThrottler[\"delayFn\"] =>\n\t(numAttempts) =>\n\t\tMath.max(0, coefficient * numAttempts + offset);\n\n/**\n * f(n) = C x (n+A) + F = C x n + (C x A + F)\n */\nexport const formLinearFnWithAttemptOffset = (\n\tattemptOffset: number,\n\t{ coefficient = 1, offset = 0 } = {},\n): IThrottler[\"delayFn\"] =>\n\tformLinearFn({\n\t\tcoefficient,\n\t\toffset: coefficient * attemptOffset + offset,\n\t});\n"]}

package/lib/versionMarks/inboundBatch.d.ts

@@ -10,12 +10,14 @@ import { type InboundMessageResult } from "../opLifecycle/index.js";
  */
 export interface InboundVersionMarkUpdate {
     /**
-     * A completed batch to record via `processInboundBatch`: its id and its last op's sequence number.
-     * Undefined when no batch completed on this message (a piecemeal batch still in progress).
+     * A completed batch to record via `processInboundBatch`: its id and its last op's sequence
+     * number and timestamp. Undefined when no batch completed on this message (a piecemeal batch
+     * still in progress).
      */
     readonly sequenced?: {
         readonly batchId: string;
         readonly sequenceNumber: number;
+        readonly timestamp: number;
     };
     /**
      * The batch id to carry for a piecemeal batch still in progress, or undefined when none is pending.
@@ -25,10 +27,10 @@ export interface InboundVersionMarkUpdate {
 }
 /**
  * Maps an inbound batch result to the version-mark resolver update. A batch's resolved point is its last
- * op's sequence number, so this reports `(batchId, sequenceNumber)` only once a batch completes. It handles
- * both a batch delivered whole (`fullBatch`, incl. an empty grouped batch via the batch-start key message)
- * and one delivered piecemeal (`batchStartingMessage` then `nextBatchMessage` with `batchEnd`), carrying the
- * batch id across the piecemeal messages via `carriedBatchId`.
+ * op's sequence number and timestamp, so this reports `(batchId, sequenceNumber, timestamp)` only once a
+ * batch completes. It handles both a batch delivered whole (`fullBatch`, incl. an empty grouped batch via
+ * the batch-start key message) and one delivered piecemeal (`batchStartingMessage` then `nextBatchMessage`
+ * with `batchEnd`), carrying the batch id across the piecemeal messages via `carriedBatchId`.
  *
  * @internal
  */

package/lib/versionMarks/inboundBatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inboundBatch.d.ts","sourceRoot":"","sources":["../../src/versionMarks/inboundBatch.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAuB,KAAK,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAEzF;;;;GAIG;AACH,MAAM,WAAW,wBAAwB;IACxC;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE;QAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;KAAE,CAAC;IACnF;;;OAGG;IACH,QAAQ,CAAC,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC;CAC5C;AAED;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CACvC,aAAa,EAAE,oBAAoB,EACnC,cAAc,EAAE,MAAM,GAAG,SAAS,GAChC,wBAAwB,CAgC1B"}
+{"version":3,"file":"inboundBatch.d.ts","sourceRoot":"","sources":["../../src/versionMarks/inboundBatch.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAuB,KAAK,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAEzF;;;;GAIG;AACH,MAAM,WAAW,wBAAwB;IACxC;;;;OAIG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE;QACpB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QACzB,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;QAChC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;KAC3B,CAAC;IACF;;;OAGG;IACH,QAAQ,CAAC,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC;CAC5C;AAED;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CACvC,aAAa,EAAE,oBAAoB,EACnC,cAAc,EAAE,MAAM,GAAG,SAAS,GAChC,wBAAwB,CAqC1B"}

package/lib/versionMarks/inboundBatch.js

@@ -5,10 +5,10 @@
 import { getEffectiveBatchId } from "../opLifecycle/index.js";
 /**
  * Maps an inbound batch result to the version-mark resolver update. A batch's resolved point is its last
- * op's sequence number, so this reports `(batchId, sequenceNumber)` only once a batch completes. It handles
- * both a batch delivered whole (`fullBatch`, incl. an empty grouped batch via the batch-start key message)
- * and one delivered piecemeal (`batchStartingMessage` then `nextBatchMessage` with `batchEnd`), carrying the
- * batch id across the piecemeal messages via `carriedBatchId`.
+ * op's sequence number and timestamp, so this reports `(batchId, sequenceNumber, timestamp)` only once a
+ * batch completes. It handles both a batch delivered whole (`fullBatch`, incl. an empty grouped batch via
+ * the batch-start key message) and one delivered piecemeal (`batchStartingMessage` then `nextBatchMessage`
+ * with `batchEnd`), carrying the batch id across the piecemeal messages via `carriedBatchId`.
  *
  * @internal
  */
@@ -22,7 +22,11 @@ export function inboundVersionMarkUpdate(inboundResult, carriedBatchId) {
             inboundResult.messages[inboundResult.messages.length - 1] ??
                 inboundResult.batchStart.keyMessage;
             return {
-                sequenced: { batchId, sequenceNumber: lastMessage.sequenceNumber },
+                sequenced: {
+                    batchId,
+                    sequenceNumber: lastMessage.sequenceNumber,
+                    timestamp: lastMessage.timestamp,
+                },
                 carriedBatchId: undefined,
             };
         }
@@ -36,6 +40,7 @@ export function inboundVersionMarkUpdate(inboundResult, carriedBatchId) {
             sequenced: {
                 batchId: carriedBatchId,
                 sequenceNumber: inboundResult.nextMessage.sequenceNumber,
+                timestamp: inboundResult.nextMessage.timestamp,
             },
             carriedBatchId: undefined,
         };

package/lib/versionMarks/inboundBatch.js.map

@@ -1 +1 @@
-{"version":3,"file":"inboundBatch.js","sourceRoot":"","sources":["../../src/versionMarks/inboundBatch.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,mBAAmB,EAA6B,MAAM,yBAAyB,CAAC;AAoBzF;;;;;;;;GAQG;AACH,MAAM,UAAU,wBAAwB,CACvC,aAAmC,EACnC,cAAkC;IAElC,IAAI,YAAY,IAAI,aAAa,EAAE,CAAC;QACnC,MAAM,OAAO,GAAG,mBAAmB,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;QAC9D,IAAI,aAAa,CAAC,IAAI,KAAK,WAAW,EAAE,CAAC;YACxC,uGAAuG;YACvG,MAAM,WAAW;YAChB,uGAAuG;YACvG,aAAa,CAAC,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC;gBACzD,aAAa,CAAC,UAAU,CAAC,UAAU,CAAC;YACrC,OAAO;gBACN,SAAS,EAAE,EAAE,OAAO,EAAE,cAAc,EAAE,WAAW,CAAC,cAAc,EAAE;gBAClE,cAAc,EAAE,SAAS;aACzB,CAAC;QACH,CAAC;QACD,4EAA4E;QAC5E,OAAO,EAAE,cAAc,EAAE,OAAO,EAAE,CAAC;IACpC,CAAC;IACD,IACC,aAAa,CAAC,IAAI,KAAK,kBAAkB;QACzC,aAAa,CAAC,QAAQ,KAAK,IAAI;QAC/B,cAAc,KAAK,SAAS,EAC3B,CAAC;QACF,OAAO;YACN,SAAS,EAAE;gBACV,OAAO,EAAE,cAAc;gBACvB,cAAc,EAAE,aAAa,CAAC,WAAW,CAAC,cAAc;aACxD;YACD,cAAc,EAAE,SAAS;SACzB,CAAC;IACH,CAAC;IACD,qEAAqE;IACrE,OAAO,EAAE,cAAc,EAAE,CAAC;AAC3B,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { getEffectiveBatchId, type InboundMessageResult } from \"../opLifecycle/index.js\";\n\n/**\n * The version-mark resolver update derived from an inbound batch result.\n *\n * @internal\n */\nexport interface InboundVersionMarkUpdate {\n\t/**\n\t * A completed batch to record via `processInboundBatch`: its id and its last op's sequence number.\n\t * Undefined when no batch completed on this message (a piecemeal batch still in progress).\n\t */\n\treadonly sequenced?: { readonly batchId: string; readonly sequenceNumber: number };\n\t/**\n\t * The batch id to carry for a piecemeal batch still in progress, or undefined when none is pending.\n\t * The caller stores this and passes it back on the next inbound result.\n\t */\n\treadonly carriedBatchId: string | undefined;\n}\n\n/**\n * Maps an inbound batch result to the version-mark resolver update. A batch's resolved point is its last\n * op's sequence number, so this reports `(batchId, sequenceNumber)` only once a batch completes. It handles\n * both a batch delivered whole (`fullBatch`, incl. an empty grouped batch via the batch-start key message)\n * and one delivered piecemeal (`batchStartingMessage` then `nextBatchMessage` with `batchEnd`), carrying the\n * batch id across the piecemeal messages via `carriedBatchId`.\n *\n * @internal\n */\nexport function inboundVersionMarkUpdate(\n\tinboundResult: InboundMessageResult,\n\tcarriedBatchId: string | undefined,\n): InboundVersionMarkUpdate {\n\tif (\"batchStart\" in inboundResult) {\n\t\tconst batchId = getEffectiveBatchId(inboundResult.batchStart);\n\t\tif (inboundResult.type === \"fullBatch\") {\n\t\t\t// The last op is the batch's resolved point; an empty batch falls back to the batch-start key message.\n\t\t\tconst lastMessage =\n\t\t\t\t// eslint-disable-next-line unicorn/prefer-at -- Array.prototype.at is not in this package's lib target\n\t\t\t\tinboundResult.messages[inboundResult.messages.length - 1] ??\n\t\t\t\tinboundResult.batchStart.keyMessage;\n\t\t\treturn {\n\t\t\t\tsequenced: { batchId, sequenceNumber: lastMessage.sequenceNumber },\n\t\t\t\tcarriedBatchId: undefined,\n\t\t\t};\n\t\t}\n\t\t// batchStartingMessage: carry the id until the batch's end message arrives.\n\t\treturn { carriedBatchId: batchId };\n\t}\n\tif (\n\t\tinboundResult.type === \"nextBatchMessage\" &&\n\t\tinboundResult.batchEnd === true &&\n\t\tcarriedBatchId !== undefined\n\t) {\n\t\treturn {\n\t\t\tsequenced: {\n\t\t\t\tbatchId: carriedBatchId,\n\t\t\t\tsequenceNumber: inboundResult.nextMessage.sequenceNumber,\n\t\t\t},\n\t\t\tcarriedBatchId: undefined,\n\t\t};\n\t}\n\t// A mid-batch message, or a batch end with no carried id: no change.\n\treturn { carriedBatchId };\n}\n"]}
+{"version":3,"file":"inboundBatch.js","sourceRoot":"","sources":["../../src/versionMarks/inboundBatch.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,mBAAmB,EAA6B,MAAM,yBAAyB,CAAC;AAyBzF;;;;;;;;GAQG;AACH,MAAM,UAAU,wBAAwB,CACvC,aAAmC,EACnC,cAAkC;IAElC,IAAI,YAAY,IAAI,aAAa,EAAE,CAAC;QACnC,MAAM,OAAO,GAAG,mBAAmB,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;QAC9D,IAAI,aAAa,CAAC,IAAI,KAAK,WAAW,EAAE,CAAC;YACxC,uGAAuG;YACvG,MAAM,WAAW;YAChB,uGAAuG;YACvG,aAAa,CAAC,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC;gBACzD,aAAa,CAAC,UAAU,CAAC,UAAU,CAAC;YACrC,OAAO;gBACN,SAAS,EAAE;oBACV,OAAO;oBACP,cAAc,EAAE,WAAW,CAAC,cAAc;oBAC1C,SAAS,EAAE,WAAW,CAAC,SAAS;iBAChC;gBACD,cAAc,EAAE,SAAS;aACzB,CAAC;QACH,CAAC;QACD,4EAA4E;QAC5E,OAAO,EAAE,cAAc,EAAE,OAAO,EAAE,CAAC;IACpC,CAAC;IACD,IACC,aAAa,CAAC,IAAI,KAAK,kBAAkB;QACzC,aAAa,CAAC,QAAQ,KAAK,IAAI;QAC/B,cAAc,KAAK,SAAS,EAC3B,CAAC;QACF,OAAO;YACN,SAAS,EAAE;gBACV,OAAO,EAAE,cAAc;gBACvB,cAAc,EAAE,aAAa,CAAC,WAAW,CAAC,cAAc;gBACxD,SAAS,EAAE,aAAa,CAAC,WAAW,CAAC,SAAS;aAC9C;YACD,cAAc,EAAE,SAAS;SACzB,CAAC;IACH,CAAC;IACD,qEAAqE;IACrE,OAAO,EAAE,cAAc,EAAE,CAAC;AAC3B,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { getEffectiveBatchId, type InboundMessageResult } from \"../opLifecycle/index.js\";\n\n/**\n * The version-mark resolver update derived from an inbound batch result.\n *\n * @internal\n */\nexport interface InboundVersionMarkUpdate {\n\t/**\n\t * A completed batch to record via `processInboundBatch`: its id and its last op's sequence\n\t * number and timestamp. Undefined when no batch completed on this message (a piecemeal batch\n\t * still in progress).\n\t */\n\treadonly sequenced?: {\n\t\treadonly batchId: string;\n\t\treadonly sequenceNumber: number;\n\t\treadonly timestamp: number;\n\t};\n\t/**\n\t * The batch id to carry for a piecemeal batch still in progress, or undefined when none is pending.\n\t * The caller stores this and passes it back on the next inbound result.\n\t */\n\treadonly carriedBatchId: string | undefined;\n}\n\n/**\n * Maps an inbound batch result to the version-mark resolver update. A batch's resolved point is its last\n * op's sequence number and timestamp, so this reports `(batchId, sequenceNumber, timestamp)` only once a\n * batch completes. It handles both a batch delivered whole (`fullBatch`, incl. an empty grouped batch via\n * the batch-start key message) and one delivered piecemeal (`batchStartingMessage` then `nextBatchMessage`\n * with `batchEnd`), carrying the batch id across the piecemeal messages via `carriedBatchId`.\n *\n * @internal\n */\nexport function inboundVersionMarkUpdate(\n\tinboundResult: InboundMessageResult,\n\tcarriedBatchId: string | undefined,\n): InboundVersionMarkUpdate {\n\tif (\"batchStart\" in inboundResult) {\n\t\tconst batchId = getEffectiveBatchId(inboundResult.batchStart);\n\t\tif (inboundResult.type === \"fullBatch\") {\n\t\t\t// The last op is the batch's resolved point; an empty batch falls back to the batch-start key message.\n\t\t\tconst lastMessage =\n\t\t\t\t// eslint-disable-next-line unicorn/prefer-at -- Array.prototype.at is not in this package's lib target\n\t\t\t\tinboundResult.messages[inboundResult.messages.length - 1] ??\n\t\t\t\tinboundResult.batchStart.keyMessage;\n\t\t\treturn {\n\t\t\t\tsequenced: {\n\t\t\t\t\tbatchId,\n\t\t\t\t\tsequenceNumber: lastMessage.sequenceNumber,\n\t\t\t\t\ttimestamp: lastMessage.timestamp,\n\t\t\t\t},\n\t\t\t\tcarriedBatchId: undefined,\n\t\t\t};\n\t\t}\n\t\t// batchStartingMessage: carry the id until the batch's end message arrives.\n\t\treturn { carriedBatchId: batchId };\n\t}\n\tif (\n\t\tinboundResult.type === \"nextBatchMessage\" &&\n\t\tinboundResult.batchEnd === true &&\n\t\tcarriedBatchId !== undefined\n\t) {\n\t\treturn {\n\t\t\tsequenced: {\n\t\t\t\tbatchId: carriedBatchId,\n\t\t\t\tsequenceNumber: inboundResult.nextMessage.sequenceNumber,\n\t\t\t\ttimestamp: inboundResult.nextMessage.timestamp,\n\t\t\t},\n\t\t\tcarriedBatchId: undefined,\n\t\t};\n\t}\n\t// A mid-batch message, or a batch end with no carried id: no change.\n\treturn { carriedBatchId };\n}\n"]}

package/lib/versionMarks/versionMarkResolver.d.ts

@@ -15,13 +15,15 @@ export interface IHistoricalOpReader {
     fetchMessages(from: number, to?: number, abortSignal?: AbortSignal): Promise<IStream<ISequencedDocumentMessage[]>>;
 }
 /**
- * Result of resolving a pending batchId.
+ * Result of resolving a pending batchId. A resolved result includes the matched batch's last op server
+ * timestamp when available. The property is optional for compatibility with previously stored results.
  *
  * @legacy @beta
  */
 export type ResolveResult = {
     readonly kind: "resolved";
     readonly sequenceNumber: number;
+    readonly timestamp?: number;
 } | {
     readonly kind: "pending";
 } | {
@@ -42,6 +44,7 @@ export type VersionMarkCapture = {
 } | {
     readonly kind: "resolved";
     readonly sequenceNumber: number;
+    readonly timestamp?: number;
 };
 /**
  * Runtime-owned resolver for app-stored version mark locators.
@@ -53,40 +56,45 @@ export interface IVersionMarkResolver {
      * Captures a version mark at the current point. Seals the current outbound batch first (so a just-made
      * local edit has a stable `batchId`, which is only assigned when a batch is flushed), then returns the
      * mark data atomically: a `pending` capture (`batchId` + `sequenceNumberLowerBound`) when there is an
-     * unacked local batch, or a `resolved` capture (`sequenceNumber`) when there is no in-flight local work.
+     * unacked local batch, or a `resolved` capture (`sequenceNumber` + the last processed op's server
+     * `timestamp`) when there is no in-flight local work. The timestamp property is optional both for
+     * compatibility with previously stored captures and because it is `undefined` when neither a last
+     * processed message nor a last-summary message is available.
      *
      * @remarks Sealing the batch is a side effect (it submits the current batch), so capture at savepoint
      * boundaries, not per keystroke.
      *
-     * @returns The pending batch identity and exclusive sequence number lower bound, or the current sequence number
-     * when there is no pending local batch.
+     * @returns The pending batch identity and inclusive sequence number lower bound, or the current sequence
+     * number and corresponding op timestamp (when available) when there is no pending local batch.
      */
     sealAndCaptureVersionMark(): VersionMarkCapture;
     /**
      * Resolves a pending mark's batchId to a global sequence number (`sequenceNumberLowerBound` is the
-     * exclusive lower bound for a history read). A `resolved` sequence number feeds the loader's
+     * inclusive lower bound for a history read). A `resolved` sequence number feeds the loader's
      * `loadContainerToSequenceNumber`.
      *
      * @param batchId - The stable identity of the pending batch.
-     * @param sequenceNumberLowerBound - The exclusive lower bound for the historical op search.
-     * @returns The resolved sequence number, or a result indicating that the batch remains pending or can
-     * no longer be resolved.
+     * @param sequenceNumberLowerBound - The inclusive lower bound for the historical op search.
+     * @returns The resolved sequence number and server timestamp, or a result indicating that the batch
+     * remains pending or can no longer be resolved.
      */
     resolve(batchId: string, sequenceNumberLowerBound: number): Promise<ResolveResult>;
     /**
-     * Subscribes to inbound batch sequencing: fires `(batchId, sequenceNumber)` per batch so any connected
-     * client can promote a matching pending mark. Returns an unsubscribe function.
+     * Subscribes to inbound batch sequencing: fires `(batchId, sequenceNumber, timestamp)` per batch so any
+     * connected client can promote a matching pending mark. Returns an unsubscribe function.
      *
-     * @param listener - Called with the stable batch identity and its final sequence number.
+     * @param listener - Called with the stable batch identity, its final sequence number, and the final op's
+     * server timestamp.
      * @returns A function that unsubscribes the listener.
      */
-    onBatchSequenced(listener: (batchId: string, sequenceNumber: number) => void): () => void;
+    onBatchSequenced(listener: (batchId: string, sequenceNumber: number, timestamp?: number) => void): () => void;
 }
 /**
  * @internal
  */
 export interface VersionMarkResolverRuntimeHooks {
     readonly getCurrentSequenceNumber: () => number;
+    readonly getCurrentTimestamp: () => number | undefined;
     readonly getCurrentMinimumSequenceNumber: () => number;
     readonly getCurrentPendingBatchId: () => string | undefined;
     /** Logs faults from app-supplied `onBatchSequenced` listeners (see {@link VersionMarkResolver.processInboundBatch}). */
@@ -118,7 +126,7 @@ export interface VersionMarkResolverRuntimeHooks {
  */
 export declare class VersionMarkResolver implements IVersionMarkResolver {
     private readonly hooks;
-    private readonly sequenceNumberByBatchId;
+    private readonly resolvedBatchById;
     private readonly batchListeners;
     /**
      * Sticky flag: false until the feature is first used this session (a pending capture or a listener).
@@ -132,25 +140,24 @@ export declare class VersionMarkResolver implements IVersionMarkResolver {
     sealAndCaptureVersionMark(): VersionMarkCapture;
     resolve(batchId: string, sequenceNumberLowerBound: number): Promise<ResolveResult>;
     /**
-     * Scans sequenced ops after `sequenceNumberLowerBound` for `batchId`, returning its last op's
+     * Scans sequenced ops from `sequenceNumberLowerBound` (inclusive) for `batchId`, returning its last op's
      * sequence number when found and aborting the fetch once found or exhausted. Each op is routed through
      * the same unpack pipeline the live inbound path uses (chunk reassembly, ungroup, decompress) and
-     * {@link inboundVersionMarkUpdate} derives its batch identity, so chunked batches resolve here too. The
-     * scan anchor is not guaranteed to be a batch boundary, so a leading batch clipped by the anchor is
-     * tolerated (its orphan end marker is dropped rather than fed to the processor). On a miss,
-     * {@link classifyMiss} distinguishes `pending` (not sequenced yet) from `unresolvable` (ops trimmed).
-     * See DEV.md.
+     * {@link inboundVersionMarkUpdate} derives its batch identity, so virtualized batches resolve here too.
+     * The injected historical unpacker owns virtualization details, including tolerating a requested range
+     * that begins within an incomplete chunk stream. On a miss, {@link classifyMiss} distinguishes
+     * `pending` (not sequenced yet) from `unresolvable` (ops trimmed).
      */
     private resolveFromHistory;
     /**
      * Classifies a history-scan miss as `pending` or `unresolvable`. See {@link resolveFromHistory}.
      */
     private classifyMiss;
-    onBatchSequenced(listener: (batchId: string, sequenceNumber: number) => void): () => void;
-    /** The sequence number for a batch seen live this session, or undefined. */
-    private sessionSequenceFor;
+    onBatchSequenced(listener: (batchId: string, sequenceNumber: number, timestamp?: number) => void): () => void;
+    /** The resolved point for a batch seen live this session, or undefined. */
+    private sessionResolutionFor;
     /** Records an inbound batch and notifies listeners so any client can promote matching pending marks. */
-    processInboundBatch(batchId: string, sequenceNumber: number): void;
+    processInboundBatch(batchId: string, sequenceNumber: number, timestamp: number): void;
     /**
      * Bounds the map to the collaboration window by dropping entries below the MSN (mirrors
      * `DuplicateBatchDetector`). Safe because below the MSN every client has processed the batch, so its

package/lib/versionMarks/versionMarkResolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"versionMarkResolver.d.ts","sourceRoot":"","sources":["../../src/versionMarks/versionMarkResolver.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"versionMarkResolver.d.ts","sourceRoot":"","sources":["../../src/versionMarks/versionMarkResolver.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACX,yBAAyB,EACzB,OAAO,EACP,MAAM,6CAA6C,CAAC;AAGrD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0CAA0C,CAAC;AAEnF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAIpE;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IACnC,aAAa,CACZ,IAAI,EAAE,MAAM,EACZ,EAAE,CAAC,EAAE,MAAM,EACX,WAAW,CAAC,EAAE,WAAW,GACvB,OAAO,CAAC,OAAO,CAAC,yBAAyB,EAAE,CAAC,CAAC,CAAC;CACjD;AAED;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GACtB;IACA,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC3B,GACD;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;CAAE,GAC5B;IAAE,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAA;CAAE,CAAC;AAErC;;;;;;;GAOG;AACH,MAAM,MAAM,kBAAkB,GAC3B;IACA,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,wBAAwB,EAAE,MAAM,CAAC;CACzC,GACD;IACA,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEL;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACpC;;;;;;;;;;;;;;OAcG;IACH,yBAAyB,IAAI,kBAAkB,CAAC;IAChD;;;;;;;;;OASG;IACH,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,wBAAwB,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;IACnF;;;;;;;OAOG;IACH,gBAAgB,CACf,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,KAAK,IAAI,GAC7E,MAAM,IAAI,CAAC;CACd;AAED;;GAEG;AACH,MAAM,WAAW,+BAA+B;IAC/C,QAAQ,CAAC,wBAAwB,EAAE,MAAM,MAAM,CAAC;IAChD,QAAQ,CAAC,mBAAmB,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;IACvD,QAAQ,CAAC,+BAA+B,EAAE,MAAM,MAAM,CAAC;IACvD,QAAQ,CAAC,wBAAwB,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;IAC5D,wHAAwH;IACxH,QAAQ,CAAC,MAAM,EAAE,kBAAkB,CAAC;IACpC;;;;OAIG;IACH,QAAQ,CAAC,iBAAiB,EAAE,MAAM,IAAI,CAAC;IACvC;;OAEG;IACH,QAAQ,CAAC,qBAAqB,CAAC,EAAE,MAAM,mBAAmB,GAAG,SAAS,CAAC;IACvE;;;;;;OAMG;IACH,QAAQ,CAAC,0BAA0B,CAAC,EAAE,MAAM,CAC3C,EAAE,EAAE,yBAAyB,KACzB,oBAAoB,GAAG,SAAS,CAAC;CACtC;AAED;;;;;GAKG;AACH,qBAAa,mBAAoB,YAAW,oBAAoB;IAe5C,OAAO,CAAC,QAAQ,CAAC,KAAK;IAdzC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAG9B;IACJ,OAAO,CAAC,QAAQ,CAAC,cAAc,CAE3B;IACJ;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAS;gBAEW,KAAK,EAAE,+BAA+B;IAE1E,8GAA8G;IAC9G,IAAW,UAAU,IAAI,OAAO,CAE/B;IAEM,yBAAyB,IAAI,kBAAkB;IA8BzC,OAAO,CACnB,OAAO,EAAE,MAAM,EACf,wBAAwB,EAAE,MAAM,GAC9B,OAAO,CAAC,aAAa,CAAC;IAyDzB;;;;;;;;OAQG;YACW,kBAAkB;IA6ChC;;OAEG;IACH,OAAO,CAAC,YAAY;IA6Bb,gBAAgB,CACtB,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,KAAK,IAAI,GAC7E,MAAM,IAAI;IASb,2EAA2E;IAC3E,OAAO,CAAC,oBAAoB;IAM5B,wGAAwG;IACjG,mBAAmB,CACzB,OAAO,EAAE,MAAM,EACf,cAAc,EAAE,MAAM,EACtB,SAAS,EAAE,MAAM,GACf,IAAI;IAuBP;;;;;OAKG;IACH,OAAO,CAAC,+BAA+B;CASvC"}

package/lib/versionMarks/versionMarkResolver.js

@@ -3,7 +3,6 @@
  * Licensed under the MIT License.
  */
 import { assert } from "@fluidframework/core-utils/internal";
-import { asBatchMetadata } from "../metadata.js";
 import { inboundVersionMarkUpdate } from "./inboundBatch.js";
 /**
  * Resolves a mark's batchId to a global sequence number. The app owns mark storage and promotion; the
@@ -12,16 +11,17 @@ import { inboundVersionMarkUpdate } from "./inboundBatch.js";
  * @internal
  */
 export class VersionMarkResolver {
+    hooks;
+    resolvedBatchById = new Map();
+    batchListeners = new Set();
+    /**
+     * Sticky flag: false until the feature is first used this session (a pending capture or a listener).
+     * While false the runtime skips all per-inbound-batch tracking, so a container that never uses version
+     * marks pays nothing on the hot path (mirrors #22497 gating `DuplicateBatchDetector` on offline load).
+     */
+    tracking = false;
     constructor(hooks) {
         this.hooks = hooks;
-        this.sequenceNumberByBatchId = new Map();
-        this.batchListeners = new Set();
-        /**
-         * Sticky flag: false until the feature is first used this session (a pending capture or a listener).
-         * While false the runtime skips all per-inbound-batch tracking, so a container that never uses version
-         * marks pays nothing on the hot path (mirrors #22497 gating `DuplicateBatchDetector` on offline load).
-         */
-        this.tracking = false;
     }
     /** Whether inbound batches need tracking (see {@link tracking}). Read by the runtime to gate the hot path. */
     get isTracking() {
@@ -31,50 +31,106 @@ export class VersionMarkResolver {
         // Seal the current batch so a just-submitted local edit is flushed into the pending state with a
         // stable batchId (which is only assigned at flush) before we read it.
         this.hooks.flushPendingBatch();
-        const sequenceNumberLowerBound = this.hooks.getCurrentSequenceNumber();
+        const referenceSequenceNumber = this.hooks.getCurrentSequenceNumber();
         const batchId = this.hooks.getCurrentPendingBatchId();
+        let result;
         if (batchId === undefined) {
             // No unacked local batch: the mark already points at a durable sequence number.
-            return { kind: "resolved", sequenceNumber: sequenceNumberLowerBound };
+            result = {
+                kind: "resolved",
+                sequenceNumber: referenceSequenceNumber,
+                timestamp: this.hooks.getCurrentTimestamp(),
+            };
         }
-        // A pending mark needs its batch tracked so resolve() can promote it from the live map.
-        this.tracking = true;
-        return { kind: "pending", batchId, sequenceNumberLowerBound };
+        else {
+            // A pending mark needs its batch tracked so resolve() can promote it from the live map.
+            this.tracking = true;
+            // The pending batch is sequenced after the reference point, so its first possible sequence
+            // number is `referenceSequenceNumber + 1`. Store that as an inclusive lower bound so resolve()
+            // scans directly from it.
+            result = {
+                kind: "pending",
+                batchId,
+                sequenceNumberLowerBound: referenceSequenceNumber + 1,
+            };
+        }
+        this.hooks.logger.sendTelemetryEvent({ eventName: "Capture", kind: result.kind });
+        return result;
     }
     async resolve(batchId, sequenceNumberLowerBound) {
-        // Fast path: batch sequenced live this session.
-        const sequenceNumber = this.sessionSequenceFor(batchId);
-        if (sequenceNumber !== undefined) {
-            return { kind: "resolved", sequenceNumber };
+        const startTime = Date.now();
+        // Track from here so inbound batches are recorded even without a prior capture/subscribe; otherwise
+        // a batch sequencing during the scan (or live, in the no-reader case) is skipped and unrecoverable.
+        this.tracking = true;
+        // Defaults cover the throw path (only the history scan can throw — e.g. an unpacker
+        // DataCorruptionError or the 0xd1c reader-contract assert): the Resolve event still fires via
+        // `finally`, with outcome "error".
+        let path = "history";
+        let outcome = "error";
+        let resolvedSequenceNumber;
+        try {
+            // Fast path: batch sequenced live this session.
+            const resolvedBatch = this.sessionResolutionFor(batchId);
+            if (resolvedBatch === undefined) {
+                const reader = this.hooks.getHistoricalOpReader?.();
+                if (reader === undefined) {
+                    // No reader: the batch may still sequence live, so report pending.
+                    path = "noReader";
+                    outcome = "pending";
+                    return { kind: "pending" };
+                }
+                // Otherwise scan history from the mark's reference point.
+                path = "history";
+                let result = await this.resolveFromHistory(reader, batchId, sequenceNumberLowerBound);
+                if (result.kind !== "resolved") {
+                    // The batch may have sequenced live while the history scan was in progress. Prefer that
+                    // authoritative in-session result over a stale history miss.
+                    const liveResult = this.sessionResolutionFor(batchId);
+                    if (liveResult !== undefined) {
+                        path = "session";
+                        result = { kind: "resolved", ...liveResult };
+                    }
+                }
+                outcome = result.kind;
+                if (result.kind === "resolved") {
+                    resolvedSequenceNumber = result.sequenceNumber;
+                }
+                return result;
+            }
+            path = "session";
+            outcome = "resolved";
+            resolvedSequenceNumber = resolvedBatch.sequenceNumber;
+            return { kind: "resolved", ...resolvedBatch };
         }
-        // Otherwise scan history from the mark's reference point.
-        const reader = this.hooks.getHistoricalOpReader?.();
-        if (reader === undefined) {
-            // No reader: the batch may still sequence live, so report pending.
-            return { kind: "pending" };
+        finally {
+            this.hooks.logger.sendTelemetryEvent({
+                eventName: "Resolve",
+                outcome,
+                path,
+                durationMs: Date.now() - startTime,
+                ...(resolvedSequenceNumber === undefined
+                    ? {}
+                    : { sequenceNumber: resolvedSequenceNumber }),
+            });
         }
-        return this.resolveFromHistory(reader, batchId, sequenceNumberLowerBound);
     }
     /**
-     * Scans sequenced ops after `sequenceNumberLowerBound` for `batchId`, returning its last op's
+     * Scans sequenced ops from `sequenceNumberLowerBound` (inclusive) for `batchId`, returning its last op's
      * sequence number when found and aborting the fetch once found or exhausted. Each op is routed through
      * the same unpack pipeline the live inbound path uses (chunk reassembly, ungroup, decompress) and
-     * {@link inboundVersionMarkUpdate} derives its batch identity, so chunked batches resolve here too. The
-     * scan anchor is not guaranteed to be a batch boundary, so a leading batch clipped by the anchor is
-     * tolerated (its orphan end marker is dropped rather than fed to the processor). On a miss,
-     * {@link classifyMiss} distinguishes `pending` (not sequenced yet) from `unresolvable` (ops trimmed).
-     * See DEV.md.
+     * {@link inboundVersionMarkUpdate} derives its batch identity, so virtualized batches resolve here too.
+     * The injected historical unpacker owns virtualization details, including tolerating a requested range
+     * that begins within an incomplete chunk stream. On a miss, {@link classifyMiss} distinguishes
+     * `pending` (not sequenced yet) from `unresolvable` (ops trimmed).
      */
     async resolveFromHistory(reader, batchId, sequenceNumberLowerBound) {
-        const from = sequenceNumberLowerBound + 1;
+        const from = sequenceNumberLowerBound;
         const unpack = this.hooks.createHistoricalOpUnpacker?.();
         const abortController = new AbortController();
         try {
             const stream = await reader.fetchMessages(from, undefined, abortController.signal);
             let firstScannedSequenceNumber;
             let carriedBatchId;
-            // Mirrors the processor's batch-in-progress state so we can drop an orphan end marker (below).
-            let inBatch = false;
             while (true) {
                 const result = await stream.read();
                 if (result.done) {
@@ -82,31 +138,21 @@ export class VersionMarkResolver {
                 }
                 for (const op of result.value) {
                     firstScannedSequenceNumber ??= op.sequenceNumber;
-                    if (!inBatch && asBatchMetadata(op.metadata)?.batch === false) {
-                        // The anchor (`sequenceNumberLowerBound + 1`) may land inside a batch whose start
-                        // precedes the window; its orphan end marker would trip the processor's 0x9d5 assert.
-                        // Drop the clipped tail. The target batch is fully in-window, so this can't skip it.
-                        continue;
-                    }
-                    // undefined = a system op, or an incomplete chunk awaiting later fragments.
+                    // undefined = a system op or virtualized input that has not produced a complete result.
                     const inboundResult = unpack?.(op);
                     if (inboundResult === undefined) {
                         continue;
                     }
-                    // Track batch progress with the processor so the guard above skips only orphan ends.
-                    if (inboundResult.type === "batchStartingMessage") {
-                        inBatch = true;
-                    }
-                    else if (inboundResult.type === "nextBatchMessage" &&
-                        inboundResult.batchEnd === true) {
-                        inBatch = false;
-                    }
                     // Derive batch identity exactly as the live inbound path does, carrying the id across a
                     // piecemeal batch's messages.
                     const update = inboundVersionMarkUpdate(inboundResult, carriedBatchId);
                     carriedBatchId = update.carriedBatchId;
                     if (update.sequenced?.batchId === batchId) {
-                        return { kind: "resolved", sequenceNumber: update.sequenced.sequenceNumber };
+                        return {
+                            kind: "resolved",
+                            sequenceNumber: update.sequenced.sequenceNumber,
+                            timestamp: update.sequenced.timestamp,
+                        };
                     }
                 }
             }
@@ -127,7 +173,7 @@ export class VersionMarkResolver {
         assert(firstScannedSequenceNumber === undefined || firstScannedSequenceNumber >= from, 0xd1c /* historical op reader returned an op before the requested range start */);
         const tip = this.hooks.getCurrentSequenceNumber();
         if (from > tip) {
-            // Nothing is sequenced at/after the mark's reference point yet, so the batch cannot have landed.
+            // Nothing is sequenced at/after the mark's lower bound yet, so the batch cannot have landed.
             return { kind: "pending" };
         }
         if (firstScannedSequenceNumber === undefined) {
@@ -137,10 +183,10 @@ export class VersionMarkResolver {
             return { kind: "unresolvable" };
         }
         if (firstScannedSequenceNumber > from) {
-            // A trim gap at the anchor: the mark's ops (just after the reference point) are gone.
+            // A trim gap at the anchor: the mark's ops (at/after its lower bound) are gone.
             return { kind: "unresolvable" };
         }
-        // Ops are present from the reference point and the batch is not among them: not yet sequenced.
+        // Ops are present from the lower bound and the batch is not among them: not yet sequenced.
         return { kind: "pending" };
     }
     onBatchSequenced(listener) {
@@ -151,21 +197,24 @@ export class VersionMarkResolver {
             this.batchListeners.delete(listener);
         };
     }
-    /** The sequence number for a batch seen live this session, or undefined. */
-    sessionSequenceFor(batchId) {
-        return this.sequenceNumberByBatchId.get(batchId);
+    /** The resolved point for a batch seen live this session, or undefined. */
+    sessionResolutionFor(batchId) {
+        return this.resolvedBatchById.get(batchId);
     }
     /** Records an inbound batch and notifies listeners so any client can promote matching pending marks. */
-    processInboundBatch(batchId, sequenceNumber) {
-        const existingSequenceNumber = this.sequenceNumberByBatchId.get(batchId);
-        if (existingSequenceNumber === sequenceNumber) {
+    processInboundBatch(batchId, sequenceNumber, timestamp) {
+        const existingResolution = this.resolvedBatchById.get(batchId);
+        if (existingResolution !== undefined) {
+            // NOTE: It's possible (but exceedingly rare) that this is a spurious duplicated batch,
+            // with a different sequence number/timestamp.
+            // Rather than asserting or overwriting, we let the earlier version mark stand, it is sufficient.
             return;
         }
-        this.sequenceNumberByBatchId.set(batchId, sequenceNumber);
+        this.resolvedBatchById.set(batchId, { sequenceNumber, timestamp });
         this.evictBelowMinimumSequenceNumber();
         for (const listener of this.batchListeners) {
             try {
-                listener(batchId, sequenceNumber);
+                listener(batchId, sequenceNumber, timestamp);
             }
             catch (error) {
                 // Isolate each app listener (like the container's EventEmitterWithErrorHandling): one throw
@@ -183,11 +232,11 @@ export class VersionMarkResolver {
      */
     evictBelowMinimumSequenceNumber() {
         const minimumSequenceNumber = this.hooks.getCurrentMinimumSequenceNumber();
-        for (const [id, sequenceNumber] of this.sequenceNumberByBatchId) {
-            if (sequenceNumber >= minimumSequenceNumber) {
+        for (const [id, resolution] of this.resolvedBatchById) {
+            if (resolution.sequenceNumber >= minimumSequenceNumber) {
                 break;
             }
-            this.sequenceNumberByBatchId.delete(id);
+            this.resolvedBatchById.delete(id);
         }
     }
 }