Merger Predecessor/Successor Mapping: Preserve Identity and Entitlements Without Inventing Continuity

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433

/** Point-in-time merger identity and entitlement mapping.
 *
 * Decimal strings are converted to exact bigint fractions. Public values are
 * rounded to six decimals, ties away from zero. No price history is created.
 */

type JsonObject = Record<string, any>;

const SCALE = 1_000_000n;
const PRICE_REASON =
  "Identity and entitlement mapping does not create a historical price-adjustment series.";

function gcd(a: bigint, b: bigint): bigint {
  a = a < 0n ? -a : a;
  b = b < 0n ? -b : b;
  while (b !== 0n) [a, b] = [b, a % b];
  return a || 1n;
}

class Rational {
  readonly n: bigint;
  readonly d: bigint;

  constructor(n: bigint, d: bigint = 1n) {
    if (d === 0n) throw new Error("zero denominator");
    if (d < 0n) [n, d] = [-n, -d];
    const divisor = gcd(n, d);
    this.n = n / divisor;
    this.d = d / divisor;
  }

  static parse(value: unknown, field: string, nonnegative = true): Rational {
    if (typeof value === "number") {
      if (!Number.isSafeInteger(value)) throw new Error(`${field} must be an integer or decimal string`);
      value = String(value);
    }
    if (typeof value !== "string" || !/^[+-]?\d+(?:\.\d+)?$/.test(value)) {
      throw new Error(`${field} must be an exact decimal`);
    }
    const sign = value.startsWith("-") ? -1n : 1n;
    const unsigned = value.replace(/^[+-]/, "");
    const [whole, decimals = ""] = unsigned.split(".");
    const denominator = 10n ** BigInt(decimals.length);
    const result = new Rational(sign * BigInt(whole + decimals), denominator);
    if (nonnegative && result.n < 0n) throw new Error(`${field} must be non-negative`);
    return result;
  }

  add(other: Rational): Rational {
    return new Rational(this.n * other.d + other.n * this.d, this.d * other.d);
  }
  sub(other: Rational): Rational {
    return new Rational(this.n * other.d - other.n * this.d, this.d * other.d);
  }
  mul(other: Rational): Rational {
    return new Rational(this.n * other.n, this.d * other.d);
  }
  div(other: Rational): Rational {
    return new Rational(this.n * other.d, this.d * other.n);
  }
  compare(other: Rational): number {
    const delta = this.n * other.d - other.n * this.d;
    return delta < 0n ? -1 : delta > 0n ? 1 : 0;
  }
  floor(): bigint {
    if (this.n < 0n) throw new Error("floor is only used for non-negative entitlements");
    return this.n / this.d;
  }
  format6(): string {
    const negative = this.n < 0n;
    const absolute = negative ? -this.n : this.n;
    let scaled = (absolute * SCALE) / this.d;
    const remainder = (absolute * SCALE) % this.d;
    if (remainder * 2n >= this.d) scaled += 1n;
    const text = scaled.toString().padStart(7, "0");
    return `${negative ? "-" : ""}${text.slice(0, -6)}.${text.slice(-6)}`;
  }
}

const ZERO = new Rational(0n);
const ONE = new Rational(1n);

function instant(value: unknown, field: string): number {
  if (typeof value !== "string" || value.length === 0) throw new Error(`${field} must be a non-empty ISO 8601 instant`);
  const match = value.match(/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d+)?(Z|[+-]\d{2}:\d{2})$/);
  if (!match) throw new Error(`${field} must be a valid ISO 8601 instant with an offset`);
  const [, yText, moText, dText, hText, miText, sText, zone] = match;
  const y = Number(yText), mo = Number(moText), d = Number(dText);
  const h = Number(hText), mi = Number(miText), s = Number(sText);
  const days = new Date(Date.UTC(y, mo, 0)).getUTCDate();
  if (mo < 1 || mo > 12 || d < 1 || d > days || h > 23 || mi > 59 || s > 59) {
    throw new Error(`${field} must be a valid calendar instant`);
  }
  if (zone !== "Z") {
    const [zh, zm] = zone.slice(1).split(":").map(Number);
    if (zh > 23 || zm > 59) throw new Error(`${field} has an invalid UTC offset`);
  }
  const parsed = Date.parse(value);
  if (!Number.isFinite(parsed)) throw new Error(`${field} must be a valid ISO 8601 instant`);
  return parsed;
}

function status(state: string, reason: string, event?: JsonObject): JsonObject {
  const result: JsonObject = { state, reason };
  if (event) {
    result.eventId = event.eventId;
    result.selectedRevision = event.revision;
    result.effectiveAt = event.effectiveAt;
  }
  return result;
}

function requireIdentity(identity: unknown, field: string): JsonObject {
  if (!identity || typeof identity !== "object" || Array.isArray(identity)) throw new Error(`${field} must be an object`);
  const item = identity as JsonObject;
  for (const name of ["issuerId", "instrumentId", "shareClassId", "listingId"]) {
    if (typeof item[name] !== "string" || !item[name]) throw new Error(`${field}.${name} is required`);
  }
  if (!Array.isArray(item.identifiers) || item.identifiers.length === 0) throw new Error(`${field}.identifiers must be a non-empty list`);
  item.identifiers.forEach((identifier: unknown, index: number) => {
    if (!identifier || typeof identifier !== "object" || Array.isArray(identifier)) throw new Error(`${field}.identifiers[${index}] must be an object`);
    for (const name of ["scheme", "value", "sourceId"]) {
      if (typeof (identifier as JsonObject)[name] !== "string" || !(identifier as JsonObject)[name]) {
        throw new Error(`${field}.identifiers[${index}].${name} is required`);
      }
    }
  });
  return item;
}

function addSource(sources: Set<string>, sourceId: unknown, field: string): void {
  if (typeof sourceId !== "string" || !sourceId) throw new Error(`${field} is required`);
  sources.add(sourceId);
}

type CashBucket = {
  consideration: Rational;
  appraisal: Rational;
  withholding: Rational;
  fees: Rational;
  cashInLieu: Rational;
};

function newCashBucket(): CashBucket {
  return { consideration: ZERO, appraisal: ZERO, withholding: ZERO, fees: ZERO, cashInLieu: ZERO };
}

function stableStringify(value: unknown): string {
  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
  if (value && typeof value === "object") {
    const object = value as JsonObject;
    return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(object[key])}`).join(",")}}`;
  }
  return JSON.stringify(value);
}

function selectVersion(versions: unknown, asOf: number): { event?: JsonObject; issue?: string } {
  if (!Array.isArray(versions) || versions.length === 0) throw new Error("eventVersions must be a non-empty list");
  let eventId: string | undefined;
  let predecessorSignature: string | undefined;
  const normalized: Array<{ revision: number; availableAt: number }> = [];
  const available = versions.filter((version, index) => {
    if (!version || typeof version !== "object" || Array.isArray(version)) throw new Error(`eventVersions[${index}] must be an object`);
    const item = version as JsonObject;
    if (!Number.isInteger(item.revision) || item.revision < 1) throw new Error(`eventVersions[${index}].revision must be a positive integer`);
    if (typeof item.eventId !== "string" || !item.eventId) throw new Error(`eventVersions[${index}].eventId is required`);
    if (eventId === undefined) eventId = item.eventId;
    else if (item.eventId !== eventId) throw new Error("all eventVersions must describe the same eventId");
    const predecessor = requireIdentity(item.predecessor, `eventVersions[${index}].predecessor`);
    const signature = stableStringify(predecessor);
    if (predecessorSignature === undefined) predecessorSignature = signature;
    else if (signature !== predecessorSignature) throw new Error("predecessor identity must remain immutable across eventVersions");
    const availableAt = instant(item.availableAt, `eventVersions[${index}].availableAt`);
    normalized.push({ revision: item.revision, availableAt });
    return availableAt <= asOf;
  }) as JsonObject[];
  normalized.sort((a, b) => a.revision - b.revision);
  for (let index = 1; index < normalized.length; index += 1) {
    if (normalized[index].revision === normalized[index - 1].revision) throw new Error("eventVersions revisions must be unique");
    if (normalized[index].availableAt <= normalized[index - 1].availableAt) throw new Error("eventVersions availableAt must increase strictly in revision order");
  }
  if (available.length === 0) return { issue: "No event version was available by asOf." };
  const highest = Math.max(...available.map((item) => item.revision));
  const selected = available.filter((item) => item.revision === highest);
  if (selected.length !== 1) return { issue: "Multiple available versions share the highest revision." };
  return { event: selected[0] };
}

export function resolveMerger(payload: JsonObject): JsonObject {
  if (!payload || typeof payload !== "object" || Array.isArray(payload)) throw new Error("payload must be an object");
  const snapshot = JSON.stringify(payload);
  const asOf = instant(payload.asOf, "asOf");
  const selected = selectVersion(payload.eventVersions, asOf);
  if (!selected.event) {
    const state = selected.issue?.startsWith("Multiple") ? "ambiguous" : "pending";
    return status(state, selected.issue ?? "No resolvable event version.");
  }
  const event = selected.event;
  for (const field of ["eventId", "status", "announcedAt", "closingAt", "effectiveAt", "delistingAt"]) {
    if (typeof event[field] !== "string" || !event[field]) throw new Error(`selected event.${field} is required`);
  }
  const announced = instant(event.announcedAt, "selected event.announcedAt");
  const available = instant(event.availableAt, "selected event.availableAt");
  const closing = instant(event.closingAt, "selected event.closingAt");
  const effective = instant(event.effectiveAt, "selected event.effectiveAt");
  const delisting = instant(event.delistingAt, "selected event.delistingAt");
  if (announced > available) throw new Error("announcedAt must not be after availableAt");
  if (announced > closing) throw new Error("announcedAt must not be after closingAt");
  if (closing > effective || effective > delisting) throw new Error("timeline must satisfy closingAt <= effectiveAt <= delistingAt");

  if (event.status === "cancelled") return status("cancelled", "The latest available event version is cancelled.", event);
  if (!["confirmed", "pending"].includes(event.status)) return status("unsupported", "The event status is outside the supported state model.", event);
  if (event.status === "pending" || asOf < effective) return status("pending", "The merger is not yet effective at asOf.", event);
  if (event.termsSupported !== true) return status("unsupported", "The selected terms are explicitly marked unsupported.", event);

  const predecessor = requireIdentity(event.predecessor, "predecessor");
  if (!payload.position || typeof payload.position !== "object" || Array.isArray(payload.position)) throw new Error("position must be an object");
  const position = payload.position as JsonObject;
  const totalQuantity = Rational.parse(position.predecessorQuantity, "position.predecessorQuantity");
  if (totalQuantity.compare(ZERO) <= 0) throw new Error("position.predecessorQuantity must be positive");
  const appraisalQuantity = Rational.parse(position.appraisalQuantity ?? "0", "position.appraisalQuantity");
  if (appraisalQuantity.compare(totalQuantity) > 0) throw new Error("position.appraisalQuantity cannot exceed predecessorQuantity");

  const sources = new Set<string>();
  if (!Array.isArray(event.sourceIds) || event.sourceIds.length === 0) throw new Error("selected event.sourceIds must be a non-empty list");
  event.sourceIds.forEach((sourceId: unknown) => addSource(sources, sourceId, "selected event.sourceIds[]"));
  predecessor.identifiers.forEach((identifier: JsonObject) => addSource(sources, identifier.sourceId, "predecessor identifier.sourceId"));

  const cash = new Map<string, CashBucket>();
  const cashBucket = (currency: string): CashBucket => {
    if (!cash.has(currency)) cash.set(currency, newCashBucket());
    return cash.get(currency)!;
  };
  if (appraisalQuantity.compare(ZERO) > 0) {
    const resolution = event.appraisalResolution;
    if (!resolution || typeof resolution !== "object" || Array.isArray(resolution)) {
      return status("pending", "Appraisal quantity exists but no appraisal resolution is available.", event);
    }
    if (instant(resolution.availableAt, "appraisalResolution.availableAt") > asOf) {
      return status("pending", "The appraisal resolution was not available by asOf.", event);
    }
    if (typeof resolution.currency !== "string" || !resolution.currency) throw new Error("appraisalResolution.currency is required");
    addSource(sources, resolution.sourceId, "appraisalResolution.sourceId");
    const bucket = cashBucket(resolution.currency);
    bucket.appraisal = bucket.appraisal.add(appraisalQuantity.mul(Rational.parse(resolution.cashPerShare, "appraisalResolution.cashPerShare")));
    bucket.withholding = bucket.withholding.add(appraisalQuantity.mul(Rational.parse(resolution.withholdingPerShare ?? "0", "appraisalResolution.withholdingPerShare")));
    bucket.fees = bucket.fees.add(appraisalQuantity.mul(Rational.parse(resolution.feePerShare ?? "0", "appraisalResolution.feePerShare")));
  }

  const allocatable = totalQuantity.sub(appraisalQuantity);
  if (!Array.isArray(event.options) || event.options.length === 0) throw new Error("selected event.options must be a non-empty list");
  const optionMap = new Map<string, JsonObject>();
  const seenLegIds = new Set<string>();
  for (const option of event.options) {
    if (!option || typeof option !== "object" || Array.isArray(option) || typeof option.optionId !== "string") throw new Error("each option must have an optionId");
    if (optionMap.has(option.optionId)) throw new Error("optionId values must be unique");
    for (const collectionName of ["stockLegs", "cashLegs"]) {
      const collection = option[collectionName] ?? [];
      if (!Array.isArray(collection)) throw new Error(`${collectionName} must be a list`);
      for (const leg of collection) {
        if (!leg || typeof leg !== "object" || Array.isArray(leg)) throw new Error(`${collectionName} entries must be objects`);
        if (typeof leg.legId !== "string" || !leg.legId) throw new Error("every stock and cash leg requires a legId");
        if (seenLegIds.has(leg.legId)) throw new Error("legId values must be unique across the event");
        seenLegIds.add(leg.legId);
      }
    }
    optionMap.set(option.optionId, option);
  }
  const elected = position.electedOptionId || event.defaultOptionId;
  if (typeof elected !== "string" || !optionMap.has(elected)) return status("ambiguous", "No valid elected or default consideration option is known.", event);
  const rules = event.electionRules ?? {};
  if (!rules || typeof rules !== "object" || Array.isArray(rules)) throw new Error("electionRules must be an object");
  const fractions = rules.fulfilledFractions ?? {};
  if (!fractions || typeof fractions !== "object" || Array.isArray(fractions)) throw new Error("electionRules.fulfilledFractions must be an object");
  const fulfilled = Rational.parse(fractions[elected] ?? "1", `fulfilledFractions.${elected}`);
  if (fulfilled.compare(ONE) > 0) throw new Error("fulfilled fraction cannot exceed one");
  const allocations: Array<{ optionId: string; role: string; fraction: Rational; quantity: Rational }> = [
    { optionId: elected, role: "elected", fraction: fulfilled, quantity: allocatable.mul(fulfilled) },
  ];
  if (fulfilled.compare(ONE) < 0) {
    const fallback = rules.fallbackOptionId;
    if (typeof fallback !== "string" || !optionMap.has(fallback) || fallback === elected) {
      return status("ambiguous", "Proration requires a distinct known fallback option.", event);
    }
    const remainder = ONE.sub(fulfilled);
    allocations.push({ optionId: fallback, role: "fallback", fraction: remainder, quantity: allocatable.mul(remainder) });
  }

  const positions = new Map<string, { identity: JsonObject; quantity: Rational }>();
  const fractionalSettlements: JsonObject[] = [];
  const identityEdges = new Map<string, JsonObject>();

  for (const allocation of allocations) {
    const option = optionMap.get(allocation.optionId)!;
    const stockLegs = option.stockLegs ?? [];
    const cashLegs = option.cashLegs ?? [];
    if (!Array.isArray(stockLegs) || !Array.isArray(cashLegs)) throw new Error("stockLegs and cashLegs must be lists");
    if (allocation.quantity.compare(ZERO) > 0 && stockLegs.length === 0 && cashLegs.length === 0) {
      throw new Error("an option with positive allocation must contain at least one consideration leg");
    }
    for (const leg of cashLegs) {
      if (!leg || typeof leg !== "object" || Array.isArray(leg)) throw new Error("cash legs must be objects");
      const targetKey = ({ consideration: "consideration", appraisal: "appraisal", withholding: "withholding", fee: "fees" } as Record<string, keyof CashBucket>)[leg.kind];
      if (!targetKey) return status("unsupported", `Unsupported cash-leg kind: ${JSON.stringify(leg.kind)}.`, event);
      if (typeof leg.currency !== "string" || !leg.currency) throw new Error("cash leg currency is required");
      addSource(sources, leg.sourceId, "cash leg.sourceId");
      const amount = Rational.parse(leg.amountPerAllocatedPredecessorShare, "cash leg amount");
      const bucket = cashBucket(leg.currency);
      bucket[targetKey] = bucket[targetKey].add(allocation.quantity.mul(amount));
    }

    for (const leg of stockLegs) {
      if (!leg || typeof leg !== "object" || Array.isArray(leg)) throw new Error("stock legs must be objects");
      if (typeof leg.legId !== "string" || !leg.legId) throw new Error("stock leg.legId is required");
      addSource(sources, leg.sourceId, "stock leg.sourceId");
      const successor = requireIdentity(leg.successor, `stock leg ${leg.legId}.successor`);
      successor.identifiers.forEach((identifier: JsonObject) => addSource(sources, identifier.sourceId, "successor identifier.sourceId"));
      const ratio = Rational.parse(leg.ratioPerAllocatedPredecessorShare, "stock leg ratio");
      if (ratio.compare(ZERO) <= 0) throw new Error("stock leg ratio must be positive");
      const gross = allocation.quantity.mul(ratio);
      const policy = leg.fractionalPolicy;
      if (!policy || typeof policy !== "object" || Array.isArray(policy)) throw new Error("stock leg.fractionalPolicy must be an object");
      const mode = policy.mode;
      const lot = Rational.parse(policy.lotSize ?? "1", "fractionalPolicy.lotSize");
      if (lot.compare(ZERO) <= 0) throw new Error("fractionalPolicy.lotSize must be positive");
      const lots = gross.div(lot).floor();
      const deliverable = mode === "keep_fractional" ? gross : lot.mul(new Rational(lots));
      const fractional = gross.sub(deliverable);
      let cil = ZERO;
      let cilCurrency: string | null = null;
      let cilSource: string | null = null;
      if (mode === "cash_in_lieu" && fractional.compare(ZERO) > 0) {
        const observed = instant(policy.observedAt, "fractionalPolicy.observedAt");
        const priceAvailable = instant(policy.availableAt, "fractionalPolicy.availableAt");
        if (observed > priceAvailable) throw new Error("cash-in-lieu observedAt must not be after availableAt");
        if (priceAvailable > asOf) return status("pending", "Cash-in-lieu price was not available by asOf.", event);
        if (typeof policy.currency !== "string" || !policy.currency) throw new Error("cash-in-lieu currency is required");
        cilCurrency = policy.currency;
        cilSource = policy.sourceId;
        addSource(sources, cilSource, "fractionalPolicy.sourceId");
        const cilPrice = Rational.parse(policy.pricePerShare, "fractionalPolicy.pricePerShare");
        cil = fractional.mul(cilPrice);
        const bucket = cashBucket(cilCurrency);
        bucket.cashInLieu = bucket.cashInLieu.add(cil);
      } else if (mode === "reject" && fractional.compare(ZERO) > 0) {
        return status("unsupported", "A fractional entitlement conflicts with the reject policy.", event);
      } else if (!["cash_in_lieu", "keep_fractional", "round_down"].includes(mode)) {
        return status("unsupported", `Unsupported fractional-share policy: ${JSON.stringify(mode)}.`, event);
      }

      const key = [successor.issuerId, successor.instrumentId, successor.shareClassId, successor.listingId].join("\u0000");
      const current = positions.get(key) ?? { identity: successor, quantity: ZERO };
      current.quantity = current.quantity.add(deliverable);
      positions.set(key, current);
      const edgeKey = `${predecessor.instrumentId}\u0000${successor.instrumentId}`;
      if (!identityEdges.has(edgeKey)) {
        identityEdges.set(edgeKey, {
          relation: "predecessor_instrument_to_successor_instrument",
          fromInstrumentId: predecessor.instrumentId,
          toInstrumentId: successor.instrumentId,
          effectiveAt: event.effectiveAt,
          sourceId: leg.sourceId,
        });
      }
      if (fractional.compare(ZERO) > 0) {
        fractionalSettlements.push({
          stockLegId: leg.legId,
          grossQuantity: gross.format6(),
          deliverableQuantity: deliverable.format6(),
          fractionalQuantity: fractional.format6(),
          cashInLieu: cil.format6(),
          currency: cilCurrency,
          sourceId: cilSource,
        });
      }
    }
  }

  const cashByCurrency: JsonObject[] = [];
  for (const currency of [...cash.keys()].sort()) {
    const bucket = cash.get(currency)!;
    const net = bucket.consideration.add(bucket.appraisal).add(bucket.cashInLieu).sub(bucket.withholding).sub(bucket.fees);
    if (net.compare(ZERO) < 0) return status("unsupported", `Net cash is negative in ${currency}.`, event);
    cashByCurrency.push({
      currency,
      consideration: bucket.consideration.format6(),
      appraisal: bucket.appraisal.format6(),
      withholding: bucket.withholding.format6(),
      fees: bucket.fees.format6(),
      cashInLieu: bucket.cashInLieu.format6(),
      net: net.format6(),
    });
  }

  const successorPositions = [...positions.keys()].sort().map((key) => {
    const record = positions.get(key)!;
    return {
      issuerId: record.identity.issuerId,
      instrumentId: record.identity.instrumentId,
      shareClassId: record.identity.shareClassId,
      listingId: record.identity.listingId,
      quantity: record.quantity.format6(),
    };
  });

  const result = {
    state: "mapped",
    eventId: event.eventId,
    selectedRevision: event.revision,
    effectiveAt: event.effectiveAt,
    predecessor: JSON.parse(JSON.stringify(predecessor)),
    allocations: allocations.map((item) => ({
      optionId: item.optionId,
      role: item.role,
      fulfilledFraction: item.fraction.format6(),
      allocatedPredecessorQuantity: item.quantity.format6(),
    })),
    successorPositions,
    cashByCurrency,
    fractionalSettlements,
    identityEdges: [...identityEdges.keys()].sort().map((key) => identityEdges.get(key)),
    listingState: { predecessor: asOf >= delisting ? "inactive" : "active_until_delisting", successors: "not_established" },
    priceAdjustment: { state: "not_computed", reason: PRICE_REASON },
    diagnostics: {
      asOf: payload.asOf,
      selectedVersionAvailableAt: event.availableAt,
      sourceIds: [...sources].sort(),
    },
  };
  if (JSON.stringify(payload) !== snapshot) throw new Error("resolveMerger mutated its input");
  return result;
}