@adcp/sdk 14.0.0-rc.37 → 14.0.0-rc.39

package/dist/lib/reporting/reconciliation.mjs

@@ -1,10 +1,19 @@
 import { createHash } from "crypto";
 import { generateIdempotencyKey } from "../utils/idempotency.mjs";
+import { canonicalize } from "../utils/jcs.mjs";
+import {
+  detectReportingContentMismatch
+} from "./content-mismatch.mjs";
 import { isReportingControlTotals, isReportingReceiptEvidence, isReportingVerificationEvidence } from "./evidence.mjs";
 import {
   createReportingManifestInspector,
   ReportingInspectionError
 } from "./inspection.mjs";
+const CONSUMER_STATUS_BATCH_MAX = 100;
+const MAX_CONSUMED_REVISION_BYTES = 256 * 1024 * 1024;
+const MAX_ROW_ESTIMATE_CONTAINERS = 262144;
+const OVERFLOWED_INSTANT = "\0overflow";
+const MAX_ROW_ESTIMATE_DEPTH = 64;
 class ReportingReconciliationError extends Error {
   constructor(code, message) {
     super(message);
@@ -227,6 +236,7 @@ async function loadReportingLedger(client, request, maxSnapshotRestarts = 2, lim
       const revisions = /* @__PURE__ */ new Map();
       const materializations = /* @__PURE__ */ new Map();
       const receipts = /* @__PURE__ */ new Map();
+      const consumerStatuses = /* @__PURE__ */ new Map();
       const seenCursors = /* @__PURE__ */ new Set();
       let cursor;
       let snapshotId;
@@ -316,6 +326,14 @@ async function loadReportingLedger(client, request, maxSnapshotRestarts = 2, lim
         for (const item of response.materializations ?? [])
           addImmutable(materializations, item.reporting_materialization_id, item, "materialization");
         for (const item of response.receipts ?? []) addImmutable(receipts, item.reporting_receipt_id, item, "receipt");
+        for (const item of response.consumer_statuses ?? [])
+          addImmutable(consumerStatuses, item.reporting_status_id, item, "consumer status");
+        if (consumerStatuses.size > maxRecords) {
+          throw new ReportingReconciliationError(
+            "LEDGER_LIMIT_EXCEEDED",
+            "reporting consumer status history exceeds record limit"
+          );
+        }
         if (obligations.size + revisions.size + materializations.size + receipts.size > maxRecords) {
           throw new ReportingReconciliationError("LEDGER_LIMIT_EXCEEDED", "reporting ledger exceeds record limit");
         }
@@ -345,6 +363,7 @@ async function loadReportingLedger(client, request, maxSnapshotRestarts = 2, lim
         ledgerAsOf,
         accountId,
         scope,
+        consumerStatuses: [...consumerStatuses.values()],
         obligations: [...obligations.values()],
         revisions: [...revisions.values()],
         materializations: [...materializations.values()],
@@ -485,7 +504,7 @@ function selectCurrent(obligation, ledger, expected) {
   if (revision.account_id !== obligation.account_id || revision.report_definition_id !== obligation.report_definition_id || revision.reporting_profile !== obligation.reporting_profile || !Array.isArray(revision.media_buy_ids) || !Array.isArray(obligation.media_buy_ids) || !same([...revision.media_buy_ids].sort(), [...obligation.media_buy_ids].sort()) || !same(revision.period, obligation.period)) {
     reasons.push("REVISION_SCOPE_MISMATCH");
   }
-  if (obligation.scope_resolved_at !== obligation.period.end) reasons.push("SCOPE_CUTOFF_MISMATCH");
+  if (obligation.scope_resolved_at !== obligation.period?.end) reasons.push("SCOPE_CUTOFF_MISMATCH");
   if (!isReportingCoverageEvidence(obligation.coverage) || obligation.coverage.evaluated_at !== obligation.scope_resolved_at || !sameStringSet(obligation.coverage.media_buy_ids, obligation.media_buy_ids ?? []) || !isReportingCoverageEvidence(revision.coverage) || !same(revision.coverage, obligation.coverage)) {
     reasons.push("COVERAGE_SCOPE_MISMATCH");
   }
@@ -569,7 +588,505 @@ function selectCurrent(obligation, ledger, expected) {
 function countMismatch(declared, observed, required) {
   return declared === void 0 ? required : declared !== observed;
 }
+function planReportingConsumerStatuses(ledger, expectedPeriods, missingExpectedPeriods, now) {
+  const missing = new Set(missingExpectedPeriods);
+  return expectedPeriods.map((expected) => {
+    const obligationForPeriod = ledger.obligations.find(
+      (candidate) => expectedPeriodMatches(expected, candidate, ledger)
+    );
+    const declaredSourceTimezone = obligationForPeriod?.period?.source_timezone;
+    const resolvedSourceTimezone = ianaTimeZone(expected.periodSourceTimezone) ?? ianaTimeZone(declaredSourceTimezone);
+    const periodIdentityUnknown = resolvedSourceTimezone === void 0 && declaredSourceTimezone !== void 0;
+    const period = {
+      start: expected.periodStart,
+      end: expected.periodEnd,
+      source_timezone: resolvedSourceTimezone ?? "UTC"
+    };
+    const base = {
+      deliveryConfigId: expected.deliveryConfigId,
+      deliveryConfigVersion: expected.deliveryConfigVersion,
+      reportDefinitionId: expected.reportDefinitionId,
+      period
+    };
+    const derivedExpectedAt = reportingExpectedAt(obligationForPeriod, expected);
+    const expectedAtOverflowed = derivedExpectedAt === OVERFLOWED_INSTANT;
+    const expectedAt = expectedAtOverflowed || derivedExpectedAt === void 0 ? void 0 : latestInstant([derivedExpectedAt, expected.periodEnd]);
+    const declaredExpectedAt = obligationForPeriod?.expected_at;
+    const malformedExpectedAt = expectedAt === void 0 && !expectedAtOverflowed && declaredExpectedAt !== void 0 ? typeof declaredExpectedAt === "string" ? declaredExpectedAt : `<${typeof declaredExpectedAt}>` : void 0;
+    const schedule = consumerStatusSchedule(expectedAt, expected, now, malformedExpectedAt, expectedAtOverflowed);
+    const pinnedExpectation = pinnedExpectedAt(expected);
+    const deadlineBeyondPin = expectedAt !== void 0 && pinnedExpectation !== void 0 && Date.parse(expectedAt) > Date.parse(pinnedExpectation) + (expected.automatedRecoveryWindowSeconds ?? 0) * 1e3 ? { declared: expectedAt, pinned: pinnedExpectation } : void 0;
+    const leaf = currentConsumerLeaf(
+      ledger,
+      base,
+      obligationForPeriod?.current_consumer_status_id
+    );
+    const establishedAt = latestInstant([expectedAt, expected.periodEnd]) ?? expected.periodEnd;
+    if (missing.has(expected) || !obligationForPeriod) {
+      return finalizeConsumerStatusPlan(
+        {
+          ...base,
+          ...schedule,
+          ...periodIdentityUnknown ? { periodIdentityUnknown: true } : {},
+          ...deadlineBeyondPin ? { deadlineBeyondPin } : {},
+          ...deadlineBeyondPin ? { deadlineBeyondPin } : {},
+          consumerStatus: "obligation_missing",
+          establishedAt,
+          reason: missing.has(expected) ? "the independently expected period is absent from the seller ledger" : "no obligation in the ledger matches this expected period"
+        },
+        leaf,
+        now
+      );
+    }
+    const obligation = obligationForPeriod;
+    const selected = selectCurrent(obligation, ledger, expected);
+    const revision = selected.revision;
+    const forked = selected.reasons.includes("AMBIGUOUS_REVISION_CHAIN");
+    const predecessorMissing = selected.reasons.includes("REVISION_PREDECESSOR_MISSING");
+    const indeterminate = forked || predecessorMissing;
+    if (!revision || indeterminate) {
+      return finalizeConsumerStatusPlan(
+        {
+          ...base,
+          ...schedule,
+          ...periodIdentityUnknown ? { periodIdentityUnknown: true } : {},
+          ...deadlineBeyondPin ? { deadlineBeyondPin } : {},
+          ...deadlineBeyondPin ? { deadlineBeyondPin } : {},
+          reportingObligationId: obligation.reporting_obligation_id,
+          consumerStatus: "revision_missing",
+          ...indeterminate ? { indeterminate: true } : {},
+          establishedAt,
+          reason: forked ? "the revision chain forks, so no single current revision could be resolved" : predecessorMissing ? `a revision names a predecessor the buyer never saw, so ${revision ? `the head ${boundedDiagnostic(revision.reporting_revision_id)} ` : "no head "}could not be proven current` : "the obligation exists but no required revision was available"
+        },
+        leaf,
+        now
+      );
+    }
+    const disqualifying = selected.reasons.filter((reason) => REVISION_DISQUALIFYING_REASONS.has(reason));
+    if (disqualifying.length > 0) {
+      return finalizeConsumerStatusPlan(
+        {
+          ...base,
+          ...schedule,
+          ...periodIdentityUnknown ? { periodIdentityUnknown: true } : {},
+          ...deadlineBeyondPin ? { deadlineBeyondPin } : {},
+          ...deadlineBeyondPin ? { deadlineBeyondPin } : {},
+          reportingObligationId: obligation.reporting_obligation_id,
+          consumerStatus: "revision_missing",
+          establishedAt,
+          reason: `the published revision does not satisfy the accepted generation (${disqualifying.join(", ")})`
+        },
+        leaf,
+        now
+      );
+    }
+    const mismatch = detectReportingContentMismatch(contractFactsFor(obligation, expected), revision);
+    return finalizeConsumerStatusPlan(
+      {
+        ...base,
+        ...schedule,
+        ...periodIdentityUnknown ? { periodIdentityUnknown: true } : {},
+        ...deadlineBeyondPin ? { deadlineBeyondPin } : {},
+        reportingObligationId: obligation.reporting_obligation_id,
+        reportingRevisionId: revision.reporting_revision_id,
+        consumerStatus: mismatch ? "content_mismatch" : "received",
+        ...mismatch ? { mismatchCode: mismatch.mismatchCode } : {},
+        // Not the revision's own `observed_at`: `status_as_of` is when the
+        // revision became consumable *to this consumer*, and the spec is
+        // explicit that sellers must not silently substitute publication time.
+        // The floor stands in until the buyer has actually read it.
+        establishedAt,
+        requiresConsumption: true,
+        reason: mismatch?.detail ?? "the named revision is ready to consume and honors every frozen contract fact"
+      },
+      leaf,
+      now
+    );
+  });
+}
+const REVISION_DISQUALIFYING_REASONS = /* @__PURE__ */ new Set([
+  "FINALITY_NOT_MET",
+  "EXPECTED_FINALITY_POLICY_MISMATCH",
+  "EXPECTED_CONTRACT_MISMATCH",
+  "EXPECTED_CONTRACT_MISSING",
+  "REVISION_SCOPE_MISMATCH"
+  // Deliberately *not* REVISION_CHAIN_SCOPE_MISMATCH: it fires when any
+  // candidate in the chain is off-scope, including a long-superseded one, so a
+  // perfectly valid current revision would be reported as missing. Nothing is
+  // lost by dropping it — the head-only predicate REVISION_SCOPE_MISMATCH
+  // tests the same fields against the revision actually being named.
+  //
+  // It is a live path, not defence in depth: for a direct-Core obligation the
+  // graph assertion does refuse an off-scope revision, but a revision joined
+  // through a materialization is checked only for `account_id`, so under
+  // managed delivery an off-scope predecessor survives the load and becomes a
+  // candidate. The test builds exactly that fixture.
+]);
+function finalizeConsumerStatusPlan(draft, leaf, now) {
+  const statusAsOfFloor = latestInstant([draft.establishedAt, usableLeafInstant(leaf.statement, now)]) ?? draft.establishedAt;
+  const { establishedAt: _establishedAt, deadlineGap, indeterminate, periodIdentityUnknown, ...carried } = draft;
+  const plan = {
+    ...carried,
+    ...leaf.statusId ? { supersedesReportingStatusId: leaf.statusId } : {},
+    statusAsOfFloor,
+    // A statement the buyer can already date is dated now; one that still owes
+    // a read is left open for `attestConsumerStatusPlan`.
+    ...draft.requiresConsumption ? {} : { statusAsOf: statusAsOfFloor }
+  };
+  if (periodIdentityUnknown) {
+    return {
+      ...plan,
+      suppressed: "period_identity_unknown",
+      reason: suppressionReason("period_identity_unknown", plan.reason)
+    };
+  }
+  if (indeterminate) {
+    return {
+      ...plan,
+      suppressed: "chain_indeterminate",
+      reason: suppressionReason("chain_indeterminate", plan.reason)
+    };
+  }
+  if (deadlineGap) {
+    return {
+      ...plan,
+      suppressed: "deadline_unknown",
+      reason: deadlineGapReason(deadlineGap)
+    };
+  }
+  const suppressed = consumerStatusSuppression(plan, leaf);
+  return suppressed ? { ...plan, suppressed, reason: suppressionReason(suppressed, plan.reason) } : plan;
+}
+function deadlineGapReason(gap) {
+  switch (gap.cause) {
+    case "missing_pin":
+      return `no posting deadline: record ExpectedReportingPeriod.${gap.pin} to derive one`;
+    case "deadline_overflow":
+      return `no posting deadline: ${gap.field} puts it outside the representable range`;
+    default:
+      return `no posting deadline: the seller's obligation.expected_at (${boundedDiagnostic(gap.value)}) is not a readable instant, and a present expected_at is never overridden locally \u2014 the seller has to correct it`;
+  }
+}
+function suppressionReason(suppressed, reason) {
+  switch (suppressed) {
+    case "unchanged":
+      return `not posted: the current leaf already says this (${reason})`;
+    case "leaf_undisclosed":
+      return "not posted: the buyer's status chain has more than one unsuperseded leaf, or the seller named a current leaf it did not disclose \u2014 either way the buyer cannot tell whether it has anything new to say";
+    case "consumption_unavailable":
+      return "not posted: no client.getMediaBuyDelivery is wired, so consumption cannot be attested";
+    case "posting_unavailable":
+      return "not posted: no client.syncReportingStatus is wired, so the buyer cannot append to the status chain";
+    case "period_identity_unknown":
+      return "not posted: the seller's period.source_timezone is not a recognized IANA zone, and that value is part of the chain's logical key \u2014 record ExpectedReportingPeriod.periodSourceTimezone, or have the seller correct it";
+    case "local_budget_exhausted":
+      return "not posted: the buyer's own ledgerLimits read budget ran out before the revision could be consumed";
+    case "chain_indeterminate":
+      return `not posted: ${reason}`;
+    default:
+      return reason;
+  }
+}
+function consumerStatusSuppression(plan, leaf) {
+  if (leaf.undisclosed) return "leaf_undisclosed";
+  if (plan.requiresConsumption) return void 0;
+  if (leaf.statement && sameConsumerStatement(plan, leaf.statement)) return "unchanged";
+  return void 0;
+}
+function sameConsumerStatement(plan, statement) {
+  return statement.consumer_status === plan.consumerStatus && (statement.reporting_revision_id ?? void 0) === plan.reportingRevisionId && (statement.mismatch_code ?? void 0) === plan.mismatchCode && (statement.failure_code ?? void 0) === plan.failureCode && sameOptionalSha256(statement.observed_revision_content_sha256, plan.observedRevisionContentSha256);
+}
+function sameOptionalSha256(left, right) {
+  if (left === void 0 || right === void 0) return left === right;
+  return sameSha256(left, right);
+}
+function currentConsumerLeaf(ledger, key, declaredLeafId) {
+  const declared = typeof declaredLeafId === "string" ? declaredLeafId : void 0;
+  const chain = (ledger.consumerStatuses ?? []).filter(
+    (statement2) => statement2.delivery_config_id === key.deliveryConfigId && statement2.delivery_config_version === key.deliveryConfigVersion && statement2.report_definition_id === key.reportDefinitionId && statement2.period?.start === key.period.start && statement2.period?.end === key.period.end
+  );
+  if (declared) {
+    const statement2 = chain.find((candidate) => candidate.reporting_status_id === declared);
+    return statement2 ? { statusId: declared, statement: statement2, undisclosed: false } : { statusId: declared, undisclosed: true };
+  }
+  const superseded = new Set(
+    chain.map((statement2) => statement2.supersedes_reporting_status_id).filter((value) => typeof value === "string")
+  );
+  const leaves = chain.filter((statement2) => !superseded.has(statement2.reporting_status_id));
+  if (leaves.length !== 1) return { undisclosed: leaves.length > 1 };
+  const statement = leaves[0];
+  return { statusId: statement.reporting_status_id, statement, undisclosed: false };
+}
+function reportingExpectedAt(obligation, expected) {
+  const declared = normalizedInstant(obligation?.expected_at);
+  if (declared !== void 0) return declared;
+  if (obligation?.expected_at !== void 0) return void 0;
+  const slaSeconds = expected.requiredFinality === "official" ? expected.officialAfterSeconds ?? expected.deliverySlaSeconds : expected.deliverySlaSeconds;
+  const periodEnd = Date.parse(expected.periodEnd);
+  if (typeof slaSeconds === "number" && Number.isFinite(slaSeconds) && slaSeconds >= 0 && Number.isFinite(periodEnd)) {
+    const pinned = periodEnd + slaSeconds * 1e3;
+    return isRepresentableInstant(pinned) ? new Date(pinned).toISOString() : OVERFLOWED_INSTANT;
+  }
+  return reportingScheduledExpectedAt(obligation, expected.periodEnd);
+}
+function pinnedExpectedAt(expected) {
+  const slaSeconds = expected.requiredFinality === "official" ? expected.officialAfterSeconds ?? expected.deliverySlaSeconds : expected.deliverySlaSeconds;
+  const periodEnd = Date.parse(expected.periodEnd);
+  if (typeof slaSeconds !== "number" || !Number.isFinite(slaSeconds) || slaSeconds < 0) return void 0;
+  if (!Number.isFinite(periodEnd)) return void 0;
+  const pinned = periodEnd + slaSeconds * 1e3;
+  return isRepresentableInstant(pinned) ? new Date(pinned).toISOString() : void 0;
+}
+function localExpectedAtPin(expected) {
+  return expected.requiredFinality === "official" ? "officialAfterSeconds" : "deliverySlaSeconds";
+}
+function reportingScheduledExpectedAt(obligation, periodEnd) {
+  const schedule = obligation?.schedule;
+  if (typeof schedule?.delivery_sla !== "string") return void 0;
+  const duration = parseIso8601Duration(schedule.delivery_sla);
+  const anchor = Date.parse(periodEnd);
+  if (!duration || !Number.isFinite(anchor)) return void 0;
+  if (duration.years === 0 && duration.months === 0 && duration.days === 0) {
+    const exact = anchor + duration.seconds * 1e3;
+    return isRepresentableInstant(exact) ? new Date(exact).toISOString() : OVERFLOWED_INSTANT;
+  }
+  const timeZone = calendarTimeZone(obligation, schedule);
+  if (timeZone === void 0) return void 0;
+  const shifted = addCalendarDuration(anchor, duration, timeZone);
+  if (shifted === void 0) return void 0;
+  return isRepresentableInstant(shifted) ? new Date(shifted).toISOString() : OVERFLOWED_INSTANT;
+}
+function calendarTimeZone(obligation, schedule) {
+  if (schedule.period_timezone !== void 0) return ianaTimeZone(schedule.period_timezone);
+  if (schedule.alignment === "utc") return "UTC";
+  return ianaTimeZone(obligation?.period?.source_timezone);
+}
+function ianaTimeZone(value) {
+  const name = boundedSourceTimezone(value);
+  if (name === void 0) return void 0;
+  if (/^[+-]/.test(name)) return void 0;
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: name });
+    return name;
+  } catch {
+    return void 0;
+  }
+}
+function parseIso8601Duration(value) {
+  const match = /^P(?=\d|T)(?=.*\d)(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)D)?(?:T(?=\d)(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?)?$/.exec(value);
+  if (!match) return void 0;
+  const [, years, months, days, hours, minutes, seconds] = match;
+  return {
+    years: Number(years ?? 0),
+    months: Number(months ?? 0),
+    days: Number(days ?? 0),
+    seconds: Number(hours ?? 0) * 3600 + Number(minutes ?? 0) * 60 + Number(seconds ?? 0)
+  };
+}
+function addCalendarDuration(instant, duration, timeZone) {
+  const parts = zonedParts(instant, timeZone);
+  if (!parts) return void 0;
+  const totalMonths = parts.month - 1 + duration.years * 12 + duration.months;
+  const year = parts.year + Math.floor(totalMonths / 12);
+  const month = totalMonths % 12 + 1;
+  const clamped = Math.min(parts.day, daysInMonth(year, month));
+  const wall = utcWallTime(year, month, clamped + duration.days, parts.hour, parts.minute, parts.second);
+  if (wall === void 0) return void 0;
+  const resolved = instantForWallTime(wall, timeZone);
+  if (resolved === void 0) return void 0;
+  const subSecond = (instant % 1e3 + 1e3) % 1e3;
+  return resolved + subSecond + duration.seconds * 1e3;
+}
+function isRepresentableInstant(value) {
+  return Number.isFinite(value) && value >= MIN_RFC3339_INSTANT && value <= MAX_RFC3339_INSTANT;
+}
+const MIN_RFC3339_INSTANT = -621672192e5;
+const MAX_RFC3339_INSTANT = 253402300799999;
+function daysInMonth(year, month) {
+  const probe = /* @__PURE__ */ new Date(0);
+  probe.setUTCFullYear(year, month, 0);
+  return probe.getUTCDate();
+}
+function utcWallTime(year, month, day, hour, minute, second) {
+  const value = /* @__PURE__ */ new Date(0);
+  value.setUTCFullYear(year, month - 1, day);
+  value.setUTCHours(hour, minute, second, 0);
+  const time = value.getTime();
+  return isRepresentableInstant(time) ? time : void 0;
+}
+function zonedParts(instant, timeZone) {
+  try {
+    const formatted = new Intl.DateTimeFormat("en-US", {
+      timeZone,
+      // Read the era so a proleptic year can be refused rather than silently
+      // relocated: without it `en-US` renders year 0 (1 BC) as year `1`.
+      era: "short",
+      hour12: false,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit"
+    }).formatToParts(new Date(instant));
+    const field = (type) => Number(formatted.find((part) => part.type === type)?.value);
+    if (/^b/i.test(formatted.find((part) => part.type === "era")?.value ?? "")) return void 0;
+    const parts = {
+      year: field("year"),
+      month: field("month"),
+      day: field("day"),
+      // Intl renders midnight as hour 24 in some locales' hourCycle.
+      hour: field("hour") % 24,
+      minute: field("minute"),
+      second: field("second")
+    };
+    return Object.values(parts).every(Number.isFinite) ? parts : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function instantForWallTime(wall, timeZone) {
+  const dayMs = 864e5;
+  const offsetBefore = zoneOffset(wall - dayMs, timeZone);
+  const offsetAfter = zoneOffset(wall + dayMs, timeZone);
+  if (offsetBefore === void 0 || offsetAfter === void 0) return void 0;
+  const fromBefore = wall - offsetBefore;
+  const fromAfter = wall - offsetAfter;
+  if (readsBackAs(fromBefore, wall, timeZone)) return fromBefore;
+  if (readsBackAs(fromAfter, wall, timeZone)) return fromAfter;
+  return fromBefore;
+}
+function zoneOffset(instant, timeZone) {
+  if (!isRepresentableInstant(instant)) return void 0;
+  const parts = zonedParts(instant, timeZone);
+  if (!parts) return void 0;
+  const asUtc = utcWallTime(parts.year, parts.month, parts.day, parts.hour, parts.minute, parts.second);
+  return asUtc === void 0 ? void 0 : asUtc - instant;
+}
+function readsBackAs(instant, wall, timeZone) {
+  if (!isRepresentableInstant(instant)) return false;
+  const parts = zonedParts(instant, timeZone);
+  if (!parts) return false;
+  return utcWallTime(parts.year, parts.month, parts.day, parts.hour, parts.minute, parts.second) === wall;
+}
+function consumerStatusSchedule(expectedAt, expected, now, malformedExpectedAt, expectedAtOverflowed = false, overflowField = "the derived expected_at") {
+  const windowSeconds = expected.automatedRecoveryWindowSeconds;
+  if (expectedAtOverflowed) {
+    return {
+      overdue: false,
+      deadlineGap: { cause: "deadline_overflow", field: overflowField }
+    };
+  }
+  if (expectedAt === void 0) {
+    return {
+      overdue: false,
+      deadlineGap: malformedExpectedAt !== void 0 ? { cause: "unreadable_expected_at", value: malformedExpectedAt } : { cause: "missing_pin", pin: localExpectedAtPin(expected) }
+    };
+  }
+  if (typeof windowSeconds !== "number" || !Number.isFinite(windowSeconds) || windowSeconds < 0) {
+    return { overdue: false, deadlineGap: { cause: "missing_pin", pin: "automatedRecoveryWindowSeconds" } };
+  }
+  const deadlineAt = Date.parse(expectedAt) + windowSeconds * 1e3;
+  if (!isRepresentableInstant(deadlineAt)) {
+    return {
+      overdue: false,
+      deadlineGap: { cause: "deadline_overflow", field: "ExpectedReportingPeriod.automatedRecoveryWindowSeconds" }
+    };
+  }
+  const deadline = new Date(deadlineAt).toISOString();
+  return { deadline, overdue: now.getTime() >= Date.parse(deadline) };
+}
+const RFC3339_INSTANT = /^(\d{4})-(\d{2})-(\d{2})[Tt\s](\d{2}):(\d{2}):(\d{2})(?:\.\d+)?(?:[Zz]|[+-]\d{2}(?::?(\d{2}))?)$/;
+function normalizedInstant(value) {
+  if (typeof value !== "string") return void 0;
+  const match = RFC3339_INSTANT.exec(value);
+  if (!match) return void 0;
+  const [, isoYear, isoMonth, isoDay, isoHour, isoMinute, isoSecond, offsetMinute] = match;
+  const year = Number(isoYear);
+  const month = Number(isoMonth);
+  const day = Number(isoDay);
+  if (month < 1 || month > 12 || day < 1 || day > daysInMonth(year, month)) return void 0;
+  if (Number(isoHour) > 23 || Number(isoMinute) > 59) return void 0;
+  if (offsetMinute !== void 0 && Number(offsetMinute) > 59) return void 0;
+  const leapSecond = isoSecond === "60";
+  if (leapSecond && utcMinuteOfDay(value, Number(isoHour), Number(isoMinute)) !== 23 * 60 + 59) return void 0;
+  let candidate = value.replace(/([+-]\d{2})$/, "$1:00");
+  if (leapSecond) candidate = candidate.replace(/:60/, ":59");
+  const parsed = Date.parse(candidate);
+  if (!Number.isFinite(parsed)) return void 0;
+  const instant = parsed + (leapSecond ? 1e3 : 0);
+  return isRepresentableInstant(instant) ? new Date(instant).toISOString() : void 0;
+}
+function boundedSourceTimezone(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 255 ? value : void 0;
+}
+function utcMinuteOfDay(value, hour, minute) {
+  const offset = /([+-])(\d{2}):?(\d{2})?$/.exec(value);
+  const offsetMinutes = offset ? (offset[1] === "-" ? -1 : 1) * (Number(offset[2]) * 60 + Number(offset[3] ?? 0)) : 0;
+  return ((hour * 60 + minute - offsetMinutes) % 1440 + 1440) % 1440;
+}
+function boundedDiagnostic(value) {
+  if (typeof value !== "string") return "";
+  return value.slice(0, 256).replace(/[\u0000-\u001f\u007f]+/g, " ");
+}
+function latestInstant(values) {
+  let latest;
+  for (const value of values) {
+    const normalized = normalizedInstant(value);
+    if (normalized === void 0) continue;
+    const parsed = Date.parse(normalized);
+    if (latest === void 0 || parsed > Date.parse(latest)) latest = normalized;
+  }
+  return latest;
+}
+function usableLeafInstant(statement, now) {
+  const value = normalizedInstant(statement?.status_as_of);
+  if (value === void 0 || Date.parse(value) > now.getTime()) return void 0;
+  return value;
+}
+function contractFactsFor(obligation, expected) {
+  return {
+    ...Array.isArray(obligation.media_buy_ids) ? { mediaBuyIds: obligation.media_buy_ids } : {},
+    ...obligation.coverage?.covered_package_ids ? { coveredPackageIds: obligation.coverage.covered_package_ids } : {},
+    period: { start: expected.periodStart, end: expected.periodEnd },
+    ...expected.committedMetrics ? { committedMetrics: expected.committedMetrics } : {},
+    ...expected.metricUnits ? { metricUnits: expected.metricUnits } : {}
+  };
+}
+function collectReportingEscalations(ledger, options) {
+  const operationsContact = options?.operationsContact;
+  const escalations = [];
+  for (const obligation of ledger.obligations) {
+    const declaredIssues = obligation.issues;
+    for (const candidate of Array.isArray(declaredIssues) ? declaredIssues : []) {
+      if (typeof candidate !== "object" || candidate === null || Array.isArray(candidate)) continue;
+      const issue = candidate;
+      const recommendedAction = boundedDiagnostic(String(issue.recommended_action ?? ""));
+      escalations.push({
+        reportingObligationId: obligation.reporting_obligation_id,
+        issueId: boundedDiagnostic(String(issue.issue_id ?? "")),
+        code: boundedDiagnostic(String(issue.code ?? "")),
+        severity: boundedDiagnostic(String(issue.severity ?? "")),
+        responsibleParty: boundedDiagnostic(String(issue.responsible_party ?? "")),
+        recommendedAction,
+        ...typeof issue.opened_at === "string" ? { openedAt: issue.opened_at } : {},
+        ...typeof issue.issue_state === "string" ? { issueState: issue.issue_state } : {},
+        ...typeof issue.external_ref === "string" ? { externalRef: boundedDiagnostic(issue.external_ref) } : {},
+        ...typeof issue.reporting_status_id === "string" ? { reportingStatusId: issue.reporting_status_id } : {},
+        ...operationsContact ? { operationsContact } : {},
+        requiresHumanContact: recommendedAction.startsWith("contact_")
+      });
+    }
+  }
+  return escalations;
+}
+function isReportingPeriodShape(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const period = value;
+  return typeof period.start === "string" && typeof period.end === "string";
+}
 function expectedPeriodMatches(expected, obligation, ledger) {
+  if (!isReportingPeriodShape(obligation.period)) return false;
   if (obligation.delivery_config_id !== expected.deliveryConfigId || obligation.delivery_config_version !== expected.deliveryConfigVersion || obligation.report_definition_id !== expected.reportDefinitionId || obligation.feed_purpose !== expected.feedPurpose || obligation.reporting_profile !== expected.reportingProfile || !Array.isArray(obligation.media_buy_ids) || !same([...obligation.media_buy_ids].sort(), [...expected.mediaBuyIds].sort()) || obligation.destination_ref !== expected.destinationRef || obligation.required_finality !== expected.requiredFinality || obligation.reconciliation_mode !== expected.reconciliationMode || expected.coverageRequirement === "full" && obligation.coverage?.status !== "full" || obligation.period.start !== expected.periodStart || obligation.period.end !== expected.periodEnd || !isReportingCoverageEvidence(obligation.coverage) || !coverageMatchesExpected(obligation.coverage, expected.coverage)) {
     return false;
   }
@@ -598,8 +1115,8 @@ function expectedIdentityKey(value) {
     value.feed_purpose,
     value.reporting_profile,
     value.destination_ref,
-    value.period.start,
-    value.period.end
+    value.period?.start,
+    value.period?.end
   ]);
 }
 function buildExpectedIdentityIndex(obligations, expectedPeriods) {
@@ -615,7 +1132,7 @@ function buildExpectedIdentityIndex(obligations, expectedPeriods) {
   }
   return { expectedByIdentity, obligationCounts };
 }
-function evaluateReportingLedger(ledger, expectedPeriods, now = /* @__PURE__ */ new Date()) {
+function evaluateReportingLedger(ledger, expectedPeriods, now = /* @__PURE__ */ new Date(), operationsContact) {
   assertDirectReportingLedgerGraph(ledger);
   const obligationResults = [];
   const uniqueRevisions = /* @__PURE__ */ new Map();
@@ -631,7 +1148,10 @@ function evaluateReportingLedger(ledger, expectedPeriods, now = /* @__PURE__ */
     const selected = selectCurrent(obligation, ledger, expected);
     const reasons = [...selected.reasons];
     if (matchingExpected.length > 0 && !bijective) reasons.push("EXPECTED_PERIOD_NOT_BIJECTIVE");
-    if (obligation.health !== "complete") reasons.push(`OBLIGATION_${obligation.health.toUpperCase()}`);
+    if (obligation.health !== "complete") {
+      const health = typeof obligation.health === "string" ? boundedDiagnostic(obligation.health) : "UNKNOWN";
+      reasons.push(`OBLIGATION_${health.toUpperCase()}`);
+    }
     if (selected.materialization?.resource && new Date(selected.materialization.resource.expires_at) <= now)
       reasons.push("RESOURCE_EXPIRED");
     if (!obligation.resource_retained_until || selected.materialization?.resource && Date.parse(selected.materialization.resource.expires_at) < Date.parse(obligation.resource_retained_until)) {
@@ -655,12 +1175,18 @@ function evaluateReportingLedger(ledger, expectedPeriods, now = /* @__PURE__ */
   const missingExpectedPeriods = (expectedPeriods ?? []).filter(
     (expected) => !ledger.obligations.some((obligation) => expectedPeriodMatches(expected, obligation, ledger))
   );
+  const consumerStatuses = planReportingConsumerStatuses(ledger, expectedPeriods ?? [], missingExpectedPeriods, now);
+  const escalations = collectReportingEscalations(ledger, { ...operationsContact ? { operationsContact } : {} });
   const scopeDefinitive = ledger.scope.scope_closed && ledger.scope.coverage_complete;
   return {
     definitive: expectedPeriods !== void 0 && scopeDefinitive && missingExpectedPeriods.length === 0 && obligationResults.every((item) => item.definitive),
     ledger,
     obligations: obligationResults,
     missingExpectedPeriods,
+    consumerStatuses,
+    postedConsumerStatuses: [],
+    failedConsumerStatuses: [],
+    escalations,
     totalsByRevision: [...uniqueRevisions.values()].map((item) => ({
       reportingRevisionId: item.reporting_revision_id,
       rowCount: item.row_count,
@@ -871,11 +1397,531 @@ async function reconcileReporting(options) {
       options.ledgerLimits
     );
   }
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const evaluated = evaluateReportingLedger(ledger, options.expectedPeriods, now, options.operationsContact);
+  const readDeadline = Date.now() + (options.ledgerLimits?.maxLoadMs ?? 6e4);
+  const attested = [];
+  let budgetExhausted = false;
+  for (const plan of evaluated.consumerStatuses) {
+    if (!plan.overdue) {
+      attested.push(plan);
+      continue;
+    }
+    if (plan.suppressed !== void 0) {
+      attested.push(plan);
+      continue;
+    }
+    if (budgetExhausted || plan.requiresConsumption && Date.now() >= readDeadline) {
+      attested.push(
+        plan.requiresConsumption ? {
+          ...plan,
+          suppressed: "local_budget_exhausted",
+          reason: suppressionReason("local_budget_exhausted", plan.reason)
+        } : plan
+      );
+      continue;
+    }
+    const next = await attestConsumerStatusPlan(plan, ledger, options, readDeadline, now);
+    if (next.suppressed === "local_budget_exhausted" && next.budgetScope === "run") budgetExhausted = true;
+    const { budgetScope: _scope, ...carried } = next;
+    attested.push(carried);
+  }
+  const consumerStatuses = attested;
+  const postedConsumerStatuses = [];
+  const failedConsumerStatuses = [];
+  const confirmed = [];
+  if (!options.client.syncReportingStatus) {
+    for (const [index, plan] of consumerStatuses.entries()) {
+      if (!plan.overdue || plan.suppressed !== void 0) continue;
+      consumerStatuses[index] = {
+        ...plan,
+        suppressed: "posting_unavailable",
+        reason: suppressionReason("posting_unavailable", plan.reason)
+      };
+    }
+  }
+  const owed = [];
+  const claimedChains = /* @__PURE__ */ new Set();
+  for (const plan of consumerStatuses) {
+    if (!plan.overdue || plan.suppressed !== void 0) continue;
+    const chain = canonical(pendingConsumerStatusKey(ledger.accountId, plan));
+    if (claimedChains.has(chain)) {
+      failedConsumerStatuses.push({
+        plan,
+        errors: [
+          {
+            code: "DUPLICATE_STATUS_CHAIN",
+            message: "two expected periods resolve to one consumer-status chain; a batch may carry at most one statement per chain"
+          }
+        ]
+      });
+      continue;
+    }
+    claimedChains.add(chain);
+    owed.push(plan);
+  }
+  if (owed.length > 0 && options.client.syncReportingStatus) {
+    for (let offset = 0; offset < owed.length; offset += CONSUMER_STATUS_BATCH_MAX) {
+      const batch = owed.slice(offset, offset + CONSUMER_STATUS_BATCH_MAX);
+      const deadline = Date.now() + (options.ledgerLimits?.maxLoadMs ?? 6e4);
+      const wireStatuses = [];
+      const posted = [];
+      for (const plan of batch) {
+        const key = pendingConsumerStatusKey(ledger.accountId, plan);
+        const fingerprint = consumerStatusClaimFingerprint(plan);
+        const pending = await options.pendingConsumerStatusStore?.get(key);
+        if (pending && pending.claimFingerprint === fingerprint && replayMatchesPlan(pending.statement, plan, now)) {
+          wireStatuses.push(pending.statement);
+          posted.push({
+            ...plan,
+            statusAsOf: String(pending.statement.status_as_of),
+            ...typeof pending.statement.observed_revision_content_sha256 === "string" ? { observedRevisionContentSha256: pending.statement.observed_revision_content_sha256 } : {}
+          });
+          continue;
+        }
+        const statement = wireConsumerStatus(plan);
+        await options.pendingConsumerStatusStore?.put(key, { statement, claimFingerprint: fingerprint });
+        wireStatuses.push(statement);
+        posted.push(plan);
+      }
+      let response;
+      try {
+        response = await callBeforeDeadline(
+          (signal) => options.client.syncReportingStatus(
+            {
+              ...options.request.account ? { account: options.request.account } : {},
+              idempotency_key: consumerStatusBatchKey(wireStatuses),
+              statuses: wireStatuses
+            },
+            { signal }
+          ),
+          deadline,
+          "CONSUMER_STATUS_WRITE_FAILED",
+          "sync_reporting_status exceeded the reporting request deadline"
+        );
+      } catch (error) {
+        recordConsumerStatusBatchFailure(
+          failedConsumerStatuses,
+          posted.length === batch.length ? posted : batch,
+          boundedDiagnostic(error instanceof Error ? error.message : "sync_reporting_status failed")
+        );
+        break;
+      }
+      const results = Array.isArray(response.results) ? response.results : [];
+      if (response.status !== "completed" || results.length !== batch.length) {
+        recordConsumerStatusBatchFailure(
+          failedConsumerStatuses,
+          batch,
+          "seller did not return one result per submitted consumer status"
+        );
+        break;
+      }
+      posted.forEach((plan, index) => {
+        const result = results[index];
+        if (result && ["recorded", "unchanged"].includes(result.result ?? "")) {
+          postedConsumerStatuses.push(plan);
+          confirmed.push(pendingConsumerStatusKey(ledger.accountId, plan));
+          return;
+        }
+        failedConsumerStatuses.push({
+          plan,
+          ...typeof result?.reporting_status_id === "string" ? { reportingStatusId: result.reporting_status_id } : {},
+          // Bounded: seller objects of arbitrary size and shape that land
+          // wherever the adopter logs its reconciliation result.
+          errors: Array.isArray(result?.errors) ? result.errors.slice(0, 16) : []
+        });
+      });
+    }
+  }
+  for (const key of confirmed) await options.pendingConsumerStatusStore?.clear(key);
+  const consumerStatusPending = await readReportingConsumerStatusPending(options);
+  return {
+    ...evaluated,
+    consumerStatuses,
+    submittedReceipts: newReceipts,
+    postedConsumerStatuses,
+    failedConsumerStatuses,
+    ...consumerStatusPending !== void 0 ? { consumerStatusPending } : {}
+  };
+}
+async function attestConsumerStatusPlan(plan, ledger, options, deadline, now) {
+  if (!plan.requiresConsumption || !plan.reportingRevisionId) return plan;
+  if (!options.client.getMediaBuyDelivery) {
+    return {
+      ...plan,
+      suppressed: "consumption_unavailable",
+      reason: suppressionReason("consumption_unavailable", plan.reason)
+    };
+  }
+  const outcome = await consumeReportingRevision(options, plan.reportingRevisionId, deadline, now);
+  const leaf = currentConsumerLeaf(ledger, plan, plan.supersedesReportingStatusId);
+  if ("budgetExhausted" in outcome) {
+    return {
+      ...plan,
+      suppressed: "local_budget_exhausted",
+      reason: suppressionReason("local_budget_exhausted", plan.reason),
+      budgetScope: outcome.budgetExhausted
+    };
+  }
+  if ("failureCode" in outcome) {
+    return withSuppression(
+      {
+        ...plan,
+        consumerStatus: "unreadable",
+        failureCode: outcome.failureCode,
+        mismatchCode: void 0,
+        observedRevisionContentSha256: void 0,
+        requiresConsumption: false,
+        statusAsOf: latestInstant([now.toISOString(), plan.statusAsOfFloor]) ?? plan.statusAsOfFloor,
+        reason: outcome.detail
+      },
+      leaf
+    );
+  }
+  const declared = ledger.revisions.find(
+    (revision2) => revision2.reporting_revision_id === plan.reportingRevisionId
+  )?.revision_content_sha256;
+  if (declared !== void 0 && !sameSha256(outcome.digest, declared)) {
+    return withSuppression(
+      {
+        ...plan,
+        consumerStatus: "unreadable",
+        failureCode: "integrity_mismatch",
+        mismatchCode: void 0,
+        observedRevisionContentSha256: void 0,
+        requiresConsumption: false,
+        statusAsOf: latestInstant([outcome.consumedAt, plan.statusAsOfFloor]) ?? plan.statusAsOfFloor,
+        reason: "the consumed rows do not hash to the revision_content_sha256 the ledger declares"
+      },
+      leaf
+    );
+  }
+  const expected = options.expectedPeriods.find(
+    (candidate) => candidate.deliveryConfigId === plan.deliveryConfigId && candidate.deliveryConfigVersion === plan.deliveryConfigVersion && candidate.reportDefinitionId === plan.reportDefinitionId && candidate.periodStart === plan.period.start && candidate.periodEnd === plan.period.end
+  );
+  const obligation = ledger.obligations.find(
+    (candidate) => candidate.reporting_obligation_id === plan.reportingObligationId
+  );
+  const revision = ledger.revisions.find((candidate) => candidate.reporting_revision_id === plan.reportingRevisionId);
+  const mismatch = expected && obligation && revision ? detectReportingContentMismatch(
+    contractFactsFor(obligation, expected),
+    revision,
+    rowEvidenceFor(contractFactsFor(obligation, expected), revision, outcome.rows)
+  ) : void 0;
+  return withSuppression(
+    {
+      ...plan,
+      consumerStatus: mismatch ? "content_mismatch" : "received",
+      mismatchCode: mismatch?.mismatchCode,
+      observedRevisionContentSha256: outcome.digest,
+      requiresConsumption: false,
+      // `status_as_of` is when the revision became consumable to *this*
+      // consumer, floored by the superseded leaf so the chain never moves
+      // backwards.
+      statusAsOf: latestInstant([outcome.consumedAt, plan.statusAsOfFloor]) ?? plan.statusAsOfFloor,
+      reason: mismatch?.detail ?? "the exact revision content was consumed and honors every frozen contract fact"
+    },
+    leaf
+  );
+}
+function withSuppression(plan, leaf) {
+  const suppressed = consumerStatusSuppression(plan, leaf);
+  if (suppressed) return { ...plan, suppressed, reason: suppressionReason(suppressed, plan.reason) };
+  const { suppressed: _cleared, ...unsuppressed } = plan;
+  return unsuppressed;
+}
+async function consumeReportingRevision(options, reportingRevisionId, deadline, now) {
+  const read = options.client.getMediaBuyDelivery;
+  const maxPages = options.ledgerLimits?.maxPages ?? 1e3;
+  const maxRows = options.ledgerLimits?.maxRevisionRows ?? 1e5;
+  const rows = [];
+  let bytes = 0;
+  let totalCount;
+  const seenCursors = /* @__PURE__ */ new Set();
+  let binding;
+  let cursor;
+  let pages = 0;
+  try {
+    do {
+      pages += 1;
+      if (pages > maxPages) return { budgetExhausted: "revision" };
+      const response = await callBeforeDeadline(
+        (signal) => read(
+          {
+            ...options.request.account ? { account: options.request.account } : {},
+            reporting_revision_id: reportingRevisionId,
+            ...cursor ? { pagination: { cursor } } : {}
+          },
+          { signal }
+        ),
+        deadline,
+        "CONSUMER_STATUS_READ_FAILED",
+        "get_media_buy_delivery exceeded the reporting request deadline"
+      );
+      if (response.status !== void 0 && response.status !== "completed") {
+        return { failureCode: "reader_incompatible", detail: "the exact-revision read did not complete" };
+      }
+      const page = response.reporting_revision_binding;
+      if (!page || page.reporting_revision_id !== reportingRevisionId || typeof page.content_sha256 !== "string" || typeof page.row_count !== "number" || !Array.isArray(page.control_totals)) {
+        return {
+          failureCode: "reader_incompatible",
+          detail: "the seller did not return a reporting_revision_binding for the exact revision requested"
+        };
+      }
+      if (binding && !same(binding, page)) {
+        return { failureCode: "integrity_mismatch", detail: "the revision binding changed between cursor pages" };
+      }
+      binding = page;
+      if (typeof response.pagination?.total_count === "number") totalCount = response.pagination.total_count;
+      for (const row of response.reporting_rows ?? []) {
+        rows.push(row);
+        const sized = approximateRowBytes(row);
+        if (sized === TOO_DEEP_TO_SIZE) {
+          return {
+            failureCode: "reader_incompatible",
+            detail: "a revision row nests deeper than this reader will walk"
+          };
+        }
+        if (sized === void 0) {
+          return { budgetExhausted: "revision" };
+        }
+        bytes += sized;
+        if (rows.length > maxRows || bytes > MAX_CONSUMED_REVISION_BYTES) {
+          return { budgetExhausted: "revision" };
+        }
+      }
+      if (response.pagination?.has_more) {
+        const next = response.pagination.cursor;
+        if (!next || seenCursors.has(next)) {
+          return { failureCode: "transport_failed", detail: "revision row pagination did not advance" };
+        }
+        seenCursors.add(next);
+        cursor = next;
+      } else {
+        cursor = void 0;
+      }
+    } while (cursor);
+  } catch (error) {
+    if (error instanceof ReportingReconciliationError && error.code === "CONSUMER_STATUS_READ_FAILED") {
+      return { budgetExhausted: "run" };
+    }
+    return { failureCode: "transport_failed", detail: "the exact-revision read failed before the rows were complete" };
+  }
+  const consumedAt = now.toISOString();
+  if (!binding) {
+    return { failureCode: "reader_incompatible", detail: "the exact-revision read returned no binding" };
+  }
+  if (totalCount !== void 0 && totalCount !== binding.row_count) {
+    return {
+      failureCode: "integrity_mismatch",
+      detail: `the read declares ${totalCount} total rows and the binding declares ${binding.row_count}`
+    };
+  }
+  if (rows.length !== binding.row_count) {
+    return {
+      failureCode: "integrity_mismatch",
+      detail: `the revision declares ${binding.row_count} rows and the read returned ${rows.length}`
+    };
+  }
+  let digest;
+  try {
+    digest = createHash("sha256").update(
+      canonicalize({
+        reporting_revision_id: reportingRevisionId,
+        row_count: binding.row_count,
+        control_totals: binding.control_totals,
+        reporting_rows: rows
+      }),
+      "utf8"
+    ).digest("hex");
+  } catch (error) {
+    if (error instanceof RangeError) return { budgetExhausted: "revision" };
+    const detail = error instanceof Error ? boundedDiagnostic(error.message) : "";
+    return {
+      failureCode: "reader_incompatible",
+      detail: detail ? `the revision rows could not be canonicalized: ${detail}` : "the revision rows could not be canonicalized"
+    };
+  }
+  if (!sameSha256(digest, binding.content_sha256)) {
+    return {
+      failureCode: "integrity_mismatch",
+      detail: "the recomputed revision binding digest does not match the content_sha256 the seller published"
+    };
+  }
+  return { digest, consumedAt, rowCount: rows.length, rows };
+}
+const TOO_DEEP_TO_SIZE = -1;
+function approximateRowBytes(row) {
+  let containers = MAX_ROW_ESTIMATE_CONTAINERS;
+  const visit = (value, depth) => {
+    if (typeof value === "string") return 16 + value.length * 2;
+    if (value === null || typeof value !== "object") return 8;
+    if (depth >= MAX_ROW_ESTIMATE_DEPTH) return TOO_DEEP_TO_SIZE;
+    containers -= 1;
+    if (containers < 0) return void 0;
+    if (Array.isArray(value)) {
+      let total2 = 40 + 8 * value.length;
+      for (const item of value) {
+        const child = visit(item, depth + 1);
+        if (child === void 0 || child === TOO_DEEP_TO_SIZE) return child;
+        total2 += child;
+      }
+      return total2;
+    }
+    const entries = Object.entries(value);
+    let total = 40 + 8 * entries.length;
+    for (const [key, child] of entries) {
+      const sized = visit(child, depth + 1);
+      if (sized === void 0 || sized === TOO_DEEP_TO_SIZE) return sized;
+      total += key.length * 2 + sized;
+    }
+    return total;
+  };
+  return visit(row, 0);
+}
+function rowEvidenceFor(facts, revision, rows) {
+  if (!facts.committedMetrics) return {};
+  const observed = new Set((revision.control_totals ?? []).map((total) => total.name));
+  const record = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+  for (const row of rows) {
+    const fields = record(row);
+    if (!fields) continue;
+    for (const key of Object.keys(fields)) observed.add(key);
+    const totals = record(fields.totals);
+    if (totals) for (const key of Object.keys(totals)) observed.add(key);
+  }
+  return { observedMetricNames: [...observed] };
+}
+const REPLAYABLE_STATEMENT_KEYS = /* @__PURE__ */ new Set([
+  "reporting_status_id",
+  "supersedes_reporting_status_id",
+  "delivery_config_id",
+  "delivery_config_version",
+  "report_definition_id",
+  "period",
+  "consumer_status",
+  "status_as_of",
+  "reporting_obligation_id",
+  "reporting_revision_id",
+  "observed_revision_content_sha256",
+  "mismatch_code",
+  "failure_code"
+]);
+function replayMatchesPlan(statement, plan, now) {
+  const period = statement.period;
+  if (typeof statement.status_as_of !== "string") return false;
+  if (usableLeafInstant({ status_as_of: statement.status_as_of }, now) === void 0) {
+    return false;
+  }
+  if (Object.keys(statement).some((key) => !REPLAYABLE_STATEMENT_KEYS.has(key))) return false;
+  if (!sameOptionalSha256(
+    statement.observed_revision_content_sha256,
+    plan.observedRevisionContentSha256
+  )) {
+    return false;
+  }
+  if (statement.reporting_status_id !== consumerStatusId({ ...plan, statusAsOf: statement.status_as_of })) {
+    return false;
+  }
+  return statement.delivery_config_id === plan.deliveryConfigId && statement.delivery_config_version === plan.deliveryConfigVersion && statement.report_definition_id === plan.reportDefinitionId && period?.start === plan.period.start && period?.end === plan.period.end && period?.source_timezone === plan.period.source_timezone && statement.consumer_status === plan.consumerStatus && (statement.reporting_revision_id ?? void 0) === plan.reportingRevisionId && (statement.mismatch_code ?? void 0) === plan.mismatchCode && (statement.failure_code ?? void 0) === plan.failureCode && (statement.supersedes_reporting_status_id ?? void 0) === plan.supersedesReportingStatusId && typeof statement.reporting_status_id === "string" && typeof statement.status_as_of === "string";
+}
+function recordConsumerStatusBatchFailure(failed, batch, message) {
+  for (const plan of batch) {
+    failed.push({ plan, errors: [{ code: "CONSUMER_STATUS_WRITE_FAILED", message }] });
+  }
+}
+function consumerStatusId(plan) {
+  return `adcp-sdk.${createHash("sha256").update(canonicalize([...consumerStatusClaim(plan), plan.statusAsOf ?? null])).digest("hex").slice(0, 32)}`;
+}
+function consumerStatusClaim(plan) {
+  return [
+    plan.deliveryConfigId,
+    plan.deliveryConfigVersion,
+    plan.reportDefinitionId,
+    plan.period,
+    plan.consumerStatus,
+    plan.mismatchCode ?? null,
+    plan.failureCode ?? null,
+    plan.reportingRevisionId ?? null,
+    plan.observedRevisionContentSha256 ?? null,
+    plan.supersedesReportingStatusId ?? null
+  ];
+}
+function consumerStatusClaimFingerprint(plan) {
+  return createHash("sha256").update(canonicalize(consumerStatusClaim(plan))).digest("hex");
+}
+function pendingConsumerStatusKey(accountId, plan) {
   return {
-    ...evaluateReportingLedger(ledger, options.expectedPeriods, options.now),
-    submittedReceipts: newReceipts
+    accountId,
+    deliveryConfigId: plan.deliveryConfigId,
+    deliveryConfigVersion: plan.deliveryConfigVersion,
+    reportDefinitionId: plan.reportDefinitionId,
+    periodStart: plan.period.start,
+    periodEnd: plan.period.end
   };
 }
+function consumerStatusBatchKey(statuses) {
+  return `adcp-sdk-batch.${createHash("sha256").update(canonicalize(statuses)).digest("hex").slice(0, 32)}`;
+}
+function wireConsumerStatus(plan) {
+  if (!plan.statusAsOf) {
+    throw new ReportingReconciliationError(
+      "CONSUMER_STATUS_UNATTESTED",
+      "cannot post a consumer status before its status_as_of is established"
+    );
+  }
+  if ((plan.consumerStatus === "received" || plan.consumerStatus === "content_mismatch") && !plan.observedRevisionContentSha256) {
+    throw new ReportingReconciliationError(
+      "CONSUMER_STATUS_UNATTESTED",
+      "received and content_mismatch require a locally recomputed revision binding digest"
+    );
+  }
+  return {
+    reporting_status_id: consumerStatusId(plan),
+    ...plan.supersedesReportingStatusId ? { supersedes_reporting_status_id: plan.supersedesReportingStatusId } : {},
+    delivery_config_id: plan.deliveryConfigId,
+    delivery_config_version: plan.deliveryConfigVersion,
+    report_definition_id: plan.reportDefinitionId,
+    period: plan.period,
+    consumer_status: plan.consumerStatus,
+    // The buyer's own instant, and part of the ID derivation above so the two
+    // can never disagree. For `received` the spec wants when the revision
+    // became consumable to this consumer, which genuinely moves between
+    // re-plans; `pendingConsumerStatusStore` is what makes a retry reuse it.
+    status_as_of: plan.statusAsOf,
+    ...plan.reportingObligationId ? { reporting_obligation_id: plan.reportingObligationId } : {},
+    ...plan.reportingRevisionId ? { reporting_revision_id: plan.reportingRevisionId } : {},
+    ...plan.observedRevisionContentSha256 ? { observed_revision_content_sha256: plan.observedRevisionContentSha256 } : {},
+    ...plan.mismatchCode ? { mismatch_code: plan.mismatchCode } : {},
+    ...plan.failureCode ? { failure_code: plan.failureCode } : {}
+  };
+}
+async function readReportingConsumerStatusPending(options) {
+  if (!options.client.syncReportingStatus) return void 0;
+  const {
+    health: _health,
+    changes_after: _changesAfter,
+    pagination: _pagination,
+    reporting_revision_id: _revisionId,
+    ...summaryRequest
+  } = options.request;
+  try {
+    const summary = await callBeforeDeadline(
+      (signal) => options.client.getReportingStatus(
+        { ...summaryRequest, view: "summary" },
+        { signal }
+      ),
+      Date.now() + (options.ledgerLimits?.maxLoadMs ?? 6e4),
+      "CONSUMER_STATUS_PENDING_READ_FAILED",
+      "summary get_reporting_status exceeded the reporting request deadline"
+    );
+    const counts = summary.obligation_counts;
+    const pending = counts?.consumer_status_pending;
+    return typeof pending === "number" && Number.isInteger(pending) && pending >= 0 ? pending : void 0;
+  } catch {
+    return void 0;
+  }
+}
 export {
   ReportingReconciliationError,
   buildReportingReceipt,