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

package/dist/lib/reporting/ledger/handler.d.mts

@@ -1,4 +1,6 @@
-import type { ReportingConsumerMismatchEscalationV1, ReportingLedgerCoverageV1, ReportingLedgerStore, ReportingDeliveryHandlerV1, ReportingStatusHandlerV1 } from './types.mjs';
+import type { ReportingAdjustmentReceipt, ReportingMaterialization, ReportingReceipt } from '../../types/index.mjs';
+import { projectReportingObligationHealthV1 } from './health.mjs';
+import type { ReportingConsumerMismatchEscalationV1, ReportingHealthV1, ReportingLedgerAdjustmentSnapshotV1, ReportingLedgerCoverageV1, ReportingLedgerObligationV1, ReportingLedgerRevisionSnapshotV1, ReportingLedgerStore, ReportingManagedDeliveryBindingV1, ReportingDeliveryHandlerV1, ReportingStatusHandlerV1 } from './types.mjs';
 export interface ReportingStatusConsumerScopeOptionsV1<TContext = unknown> {
     resolveConsumerId(context: TContext): string | Promise<string>;
     /**
@@ -14,6 +16,54 @@ export interface ReportingStatusConsumerScopeOptionsV1<TContext = unknown> {
 export declare function createReportingStatusHandler<TContext = unknown>(store: ReportingLedgerStore, options?: ReportingStatusConsumerScopeOptionsV1<TContext>): ReportingStatusHandlerV1;
 /** Exact revision reader for createAdcpServer's getMediaBuyDelivery slot. */
 export declare function createReportingDeliveryHandler(store: ReportingLedgerStore): ReportingDeliveryHandlerV1;
+export interface ProjectManagedDeliveryInputV1 {
+    obligation: ReportingLedgerObligationV1;
+    binding?: ReportingManagedDeliveryBindingV1;
+    revisions: ReportingLedgerRevisionSnapshotV1[];
+    adjustments: ReportingLedgerAdjustmentSnapshotV1[];
+    materializations: ReportingMaterialization[];
+    materializationHistory: ReportingMaterialization[];
+    receipts: ReportingReceipt[];
+    adjustmentReceipts: ReportingAdjustmentReceipt[];
+    base: ReturnType<typeof projectReportingObligationHealthV1>;
+    ledgerAsOf: string;
+    /**
+     * Subjects whose accepted receipt body has aged out of retention.
+     *
+     * An accepted leaf is terminal, so the acceptance keeps counting after the
+     * body is gone — otherwise letting evidence expire silently reopens a
+     * settled subject and the obligation degrades on its own.
+     */
+    tombstonedAcceptedSubjects?: ReadonlyArray<{
+        kind: 'revision' | 'adjustment';
+        subjectId: string;
+        consumerId?: string;
+    }>;
+    /**
+     * Revisions whose successful materialization row has been pruned.
+     *
+     * `deliveredEver` is read from history, and pruning removes that history,
+     * so without this a delivered revision reads as never delivered and an
+     * accepted subject is dragged back to `pending`.
+     */
+    tombstonedDeliveredRevisionIds?: readonly string[];
+}
+/** Project Managed Delivery state without positional array arguments that can be accidentally transposed. */
+export declare function projectManagedDelivery(input: ProjectManagedDeliveryInputV1): {
+    binding: ReportingManagedDeliveryBindingV1;
+    projection: import("./health.mjs").ReportingObligationHealthProjectionV1;
+    reconciliationStatus: "rejected" | "pending" | "accepted" | "not_required";
+    materializationCount: number;
+    successfulMaterializationCount: number;
+    resourceRetainedUntil: string | undefined;
+    receiptCount: number;
+    acceptedReceiptCount: number;
+    adjustmentReceiptCount: number;
+    acceptedAdjustmentReceiptCount: number;
+    pendingAdjustmentReceiptCount: number;
+} | undefined;
+/** Combines independent seller/consumer degradation without allowing one to hide the other. */
+export declare function moreSevereReportingHealthV1(left: ReportingHealthV1, right: ReportingHealthV1): ReportingHealthV1;
 export declare class ReportingReadCapacityError extends Error {
 }
 export declare function acquireAccountReadSlot(active: Map<string, number>, accountId: string, perAccountLimit?: number, globalLimit?: number): () => void;

package/dist/lib/reporting/ledger/handler.d.ts

@@ -1,4 +1,6 @@
-import type { ReportingConsumerMismatchEscalationV1, ReportingLedgerCoverageV1, ReportingLedgerStore, ReportingDeliveryHandlerV1, ReportingStatusHandlerV1 } from './types';
+import type { ReportingAdjustmentReceipt, ReportingMaterialization, ReportingReceipt } from '../../types';
+import { projectReportingObligationHealthV1 } from './health';
+import type { ReportingConsumerMismatchEscalationV1, ReportingHealthV1, ReportingLedgerAdjustmentSnapshotV1, ReportingLedgerCoverageV1, ReportingLedgerObligationV1, ReportingLedgerRevisionSnapshotV1, ReportingLedgerStore, ReportingManagedDeliveryBindingV1, ReportingDeliveryHandlerV1, ReportingStatusHandlerV1 } from './types';
 export interface ReportingStatusConsumerScopeOptionsV1<TContext = unknown> {
     resolveConsumerId(context: TContext): string | Promise<string>;
     /**
@@ -14,6 +16,54 @@ export interface ReportingStatusConsumerScopeOptionsV1<TContext = unknown> {
 export declare function createReportingStatusHandler<TContext = unknown>(store: ReportingLedgerStore, options?: ReportingStatusConsumerScopeOptionsV1<TContext>): ReportingStatusHandlerV1;
 /** Exact revision reader for createAdcpServer's getMediaBuyDelivery slot. */
 export declare function createReportingDeliveryHandler(store: ReportingLedgerStore): ReportingDeliveryHandlerV1;
+export interface ProjectManagedDeliveryInputV1 {
+    obligation: ReportingLedgerObligationV1;
+    binding?: ReportingManagedDeliveryBindingV1;
+    revisions: ReportingLedgerRevisionSnapshotV1[];
+    adjustments: ReportingLedgerAdjustmentSnapshotV1[];
+    materializations: ReportingMaterialization[];
+    materializationHistory: ReportingMaterialization[];
+    receipts: ReportingReceipt[];
+    adjustmentReceipts: ReportingAdjustmentReceipt[];
+    base: ReturnType<typeof projectReportingObligationHealthV1>;
+    ledgerAsOf: string;
+    /**
+     * Subjects whose accepted receipt body has aged out of retention.
+     *
+     * An accepted leaf is terminal, so the acceptance keeps counting after the
+     * body is gone — otherwise letting evidence expire silently reopens a
+     * settled subject and the obligation degrades on its own.
+     */
+    tombstonedAcceptedSubjects?: ReadonlyArray<{
+        kind: 'revision' | 'adjustment';
+        subjectId: string;
+        consumerId?: string;
+    }>;
+    /**
+     * Revisions whose successful materialization row has been pruned.
+     *
+     * `deliveredEver` is read from history, and pruning removes that history,
+     * so without this a delivered revision reads as never delivered and an
+     * accepted subject is dragged back to `pending`.
+     */
+    tombstonedDeliveredRevisionIds?: readonly string[];
+}
+/** Project Managed Delivery state without positional array arguments that can be accidentally transposed. */
+export declare function projectManagedDelivery(input: ProjectManagedDeliveryInputV1): {
+    binding: ReportingManagedDeliveryBindingV1;
+    projection: import("./health").ReportingObligationHealthProjectionV1;
+    reconciliationStatus: "rejected" | "pending" | "accepted" | "not_required";
+    materializationCount: number;
+    successfulMaterializationCount: number;
+    resourceRetainedUntil: string | undefined;
+    receiptCount: number;
+    acceptedReceiptCount: number;
+    adjustmentReceiptCount: number;
+    acceptedAdjustmentReceiptCount: number;
+    pendingAdjustmentReceiptCount: number;
+} | undefined;
+/** Combines independent seller/consumer degradation without allowing one to hide the other. */
+export declare function moreSevereReportingHealthV1(left: ReportingHealthV1, right: ReportingHealthV1): ReportingHealthV1;
 export declare class ReportingReadCapacityError extends Error {
 }
 export declare function acquireAccountReadSlot(active: Map<string, number>, accountId: string, perAccountLimit?: number, globalLimit?: number): () => void;

package/dist/lib/reporting/ledger/handler.js

@@ -22,7 +22,9 @@ __export(handler_exports, {
   acquireAccountReadSlot: () => acquireAccountReadSlot,
   aggregateReportingCoverageV1: () => aggregateReportingCoverageV1,
   createReportingDeliveryHandler: () => createReportingDeliveryHandler,
-  createReportingStatusHandler: () => createReportingStatusHandler
+  createReportingStatusHandler: () => createReportingStatusHandler,
+  moreSevereReportingHealthV1: () => moreSevereReportingHealthV1,
+  projectManagedDelivery: () => projectManagedDelivery
 });
 module.exports = __toCommonJS(handler_exports);
 var import_node_crypto = require("node:crypto");
@@ -35,7 +37,11 @@ var import_instant = require('./instant.js');
 var import_types = require('./types.js');
 function createReportingStatusHandler(store, options) {
   const consumerMismatchEscalation = (0, import_health.assertReportingConsumerMismatchEscalation)(
-    resolveConsumerMismatchEscalation(options?.consumerMismatchEscalation, store)
+    (0, import_health.reportingEffectiveConsumerMismatchEscalationV1)(
+      options?.consumerMismatchEscalation,
+      store,
+      "createReportingStatusHandler"
+    )
   );
   const activeReadsByAccount = /* @__PURE__ */ new Map();
   return async (request, context) => {
@@ -179,6 +185,28 @@ function createReportingStatusHandler(store, options) {
         const consumerStatusPending = consumerId !== void 0 && consumerStatusProjection.length === 0 && // Strictly after: the duty is to post "no later than" the deadline, so
         // a buyer that posts at exactly that instant has met it.
         (0, import_instant.compareReportingInstants)(page.snapshot.ledgerAsOf, obligation.recoveryDeadlineAt) > 0;
+        const baseProjection = {
+          ...projection,
+          issues: uniqueIssues([...persistedIssues, ...projection.issues, ...mismatch ? [mismatch.issue] : []])
+        };
+        const managed = projectManagedDelivery({
+          obligation,
+          binding: page.snapshot.managedBindings?.find((value) => value.configurationId === obligation.configurationId),
+          revisions,
+          adjustments: page.snapshot.adjustments.filter(
+            (value) => value.reporting_obligation_id === obligation.reporting_obligation_id
+          ),
+          materializations: (page.snapshot.materializationProjection ?? page.snapshot.materializations ?? []).filter(
+            (value) => value.reporting_obligation_id === obligation.reporting_obligation_id
+          ),
+          materializationHistory: (page.snapshot.materializationHistoryProjection ?? page.snapshot.materializations ?? []).filter((value) => value.reporting_obligation_id === obligation.reporting_obligation_id),
+          receipts: page.snapshot.receiptProjection ?? page.snapshot.receipts ?? [],
+          adjustmentReceipts: page.snapshot.adjustmentReceiptProjection ?? page.snapshot.adjustmentReceipts ?? [],
+          base: baseProjection,
+          ledgerAsOf: page.snapshot.ledgerAsOf,
+          tombstonedAcceptedSubjects: page.snapshot.tombstonedAcceptedSubjects,
+          tombstonedDeliveredRevisionIds: page.snapshot.tombstonedDeliveredRevisionIds
+        });
         return {
           obligation,
           revisions,
@@ -187,10 +215,15 @@ function createReportingStatusHandler(store, options) {
           currentConsumerStatus,
           consumerStatusPending,
           projection: {
-            ...projection,
-            ...mismatch ? { health: mismatch.health } : {},
-            issues: uniqueIssues([...persistedIssues, ...projection.issues, ...mismatch ? [mismatch.issue] : []])
-          }
+            ...managed?.projection ?? baseProjection,
+            ...mismatch ? {
+              health: moreSevereReportingHealthV1(
+                managed?.projection.health ?? baseProjection.health,
+                mismatch.health
+              )
+            } : {}
+          },
+          managed
         };
       });
       const healthFilter = view === "periods" && query.health ? new Set(query.health) : void 0;
@@ -204,6 +237,12 @@ function createReportingStatusHandler(store, options) {
         ledger_as_of: page.snapshot.ledgerAsOf,
         account_id: accountId
       };
+      const finality = page.snapshot.query.finality;
+      const visibleRevisionIds = new Set(
+        page.snapshot.revisions.filter((value) => !finality || finality.includes(value.finality)).map((value) => value.reporting_revision_id)
+      );
+      const visibleAdjustments = finality ? page.snapshot.adjustments.filter((value) => visibleRevisionIds.has(value.adjusts_reporting_revision_id)) : page.snapshot.adjustments;
+      const pageAdjustmentIds = new Set(page.adjustments.map((value) => value.reporting_adjustment_id));
       if (view === "revision") {
         const id = query.reporting_revision_id;
         const inSnapshot = id ? page.snapshot.revisions.some((value) => value.reporting_revision_id === id) : false;
@@ -219,6 +258,16 @@ function createReportingStatusHandler(store, options) {
         if (!revision) {
           return lookupUnavailable(view);
         }
+        const revisionAdjustmentIds = new Set(
+          visibleAdjustments.filter((value) => value.adjusts_reporting_revision_id === revision.reporting_revision_id).map((value) => value.reporting_adjustment_id)
+        );
+        const revisionAdjustmentReceipts = (page.adjustmentReceipts ?? []).filter(
+          (value) => revisionAdjustmentIds.has(value.reporting_adjustment_id)
+        );
+        const receiptAdjustmentIds = new Set(revisionAdjustmentReceipts.map((value) => value.reporting_adjustment_id));
+        const revisionAdjustments = visibleAdjustments.filter(
+          (value) => value.adjusts_reporting_revision_id === revision.reporting_revision_id && (pageAdjustmentIds.has(value.reporting_adjustment_id) || receiptAdjustmentIds.has(value.reporting_adjustment_id))
+        );
         return {
           ...base,
           view: "revision",
@@ -229,11 +278,20 @@ function createReportingStatusHandler(store, options) {
             row_count: revision.binding.rowCount
           },
           reporting_rows: revision.rows,
-          adjustments: page.adjustments.filter((value) => value.adjusts_reporting_revision_id === revision.reporting_revision_id).map((value) => value.wireAdjustment),
+          adjustments: revisionAdjustments.map((value) => value.wireAdjustment),
           ...consumerId ? { consumer_statuses: (page.consumerStatuses ?? []).map(wireConsumerStatus) } : {},
-          adjustment_receipts: [],
-          materializations: [],
-          receipts: [],
+          materializations: (page.materializations ?? []).filter(
+            (value) => value.reporting_revision_id === revision.reporting_revision_id
+          ),
+          receipts: (page.receipts ?? []).filter(
+            (value) => value.reporting_revision_id === revision.reporting_revision_id
+          ),
+          // RC3 `revision_adjustments`: "every adjustment_receipt, when
+          // supported, MUST name one of those adjustments. No unrelated status
+          // or correction may appear." Emitting the page's whole adjustment
+          // receipt set let a read of R1 return a receipt for an adjustment on
+          // R2 while `adjustments` was empty.
+          adjustment_receipts: revisionAdjustmentReceipts,
           errors: [],
           pagination: {
             has_more: page.hasMore,
@@ -245,6 +303,18 @@ function createReportingStatusHandler(store, options) {
       if (view === "periods") {
         const pageIds = new Set(page.obligations.map((value) => value.reporting_obligation_id));
         const pageProjected = selected.filter((value) => pageIds.has(value.obligation.reporting_obligation_id));
+        const selectedPageIds = new Set(selected.map((value) => value.obligation.reporting_obligation_id));
+        const scopedAdjustments = visibleAdjustments.filter(
+          (value) => selectedPageIds.has(value.reporting_obligation_id)
+        );
+        const scopedAdjustmentIds = new Set(scopedAdjustments.map((value) => value.reporting_adjustment_id));
+        const scopedAdjustmentReceipts = (page.adjustmentReceipts ?? []).filter(
+          (value) => scopedAdjustmentIds.has(value.reporting_adjustment_id)
+        );
+        const receiptAdjustmentIds = new Set(scopedAdjustmentReceipts.map((value) => value.reporting_adjustment_id));
+        const pageAdjustments = scopedAdjustments.filter(
+          (value) => pageAdjustmentIds.has(value.reporting_adjustment_id) || receiptAdjustmentIds.has(value.reporting_adjustment_id)
+        );
         return {
           ...base,
           view: "periods",
@@ -260,15 +330,27 @@ function createReportingStatusHandler(store, options) {
               ).length,
               value.projection,
               value.currentConsumerStatus,
-              consumerId ? value.consumerStatusProjection.length : void 0
+              consumerId ? value.consumerStatusProjection.length : void 0,
+              value.managed
             )
           ),
-          revisions: page.revisions.filter((value) => !query.finality || query.finality.includes(value.finality)).map((value) => value.wireRevision),
-          adjustments: page.adjustments.map((value) => value.wireAdjustment),
+          revisions: page.revisions.filter(
+            (value) => selectedPageIds.has(value.reporting_obligation_id) && (!query.finality || query.finality.includes(value.finality))
+          ).map((value) => value.wireRevision),
+          adjustments: pageAdjustments.map((value) => value.wireAdjustment),
           ...consumerId ? { consumer_statuses: (page.consumerStatuses ?? []).map(wireConsumerStatus) } : {},
-          adjustment_receipts: [],
-          materializations: [],
-          receipts: [],
+          // Same scoping rule as the revision view: a receipt may only appear
+          // beside the correction or revision it names.
+          adjustment_receipts: scopedAdjustmentReceipts,
+          // Managed evidence names a revision, so the finality filter that
+          // scopes `revisions` scopes these too — otherwise the response
+          // carries public references to a revision it does not contain.
+          materializations: (page.materializations ?? []).filter(
+            (value) => selectedPageIds.has(value.reporting_obligation_id) && visibleRevisionIds.has(value.reporting_revision_id)
+          ),
+          receipts: (page.receipts ?? []).filter(
+            (value) => selectedPageIds.has(value.reporting_obligation_id) && visibleRevisionIds.has(value.reporting_revision_id)
+          ),
           pagination: {
             has_more: page.hasMore,
             total_count: page.totalCount,
@@ -307,17 +389,6 @@ function createReportingStatusHandler(store, options) {
     }
   };
 }
-function resolveConsumerMismatchEscalation(fromOptions, store) {
-  const fromStore = store.consumerMismatchEscalation;
-  if (!fromOptions) return fromStore;
-  if (!fromStore) return fromOptions;
-  if (fromOptions.escalationSeconds !== fromStore.escalationSeconds || fromOptions.operationsContact.url !== fromStore.operationsContact.url || fromOptions.operationsContact.email !== fromStore.operationsContact.email) {
-    throw new TypeError(
-      "consumerMismatchEscalation differs between createReportingStatusHandler and the reporting ledger store; configure one value so a health-filtered periods read cannot disagree with the summary"
-    );
-  }
-  return fromOptions;
-}
 function createReportingDeliveryHandler(store) {
   const activeReadsByAccount = /* @__PURE__ */ new Map();
   return async (request, context) => {
@@ -400,7 +471,7 @@ function resolvedAccountId(account) {
   if (!accountId) throw new Error("Reporting reads require a resolved account");
   return accountId;
 }
-function wireObligation(obligation, revisionCount, adjustmentCount, projection, currentConsumerStatus, consumerStatusCount) {
+function wireObligation(obligation, revisionCount, adjustmentCount, projection, currentConsumerStatus, consumerStatusCount, managed) {
   return {
     reporting_obligation_id: obligation.reporting_obligation_id,
     delivery_config_id: obligation.delivery_config_id,
@@ -418,20 +489,27 @@ function wireObligation(obligation, revisionCount, adjustmentCount, projection,
       source_timezone: obligation.period.sourceTimezone
     },
     expected_at: obligation.expectedAt,
-    schedule: {
-      period_duration: `PT${obligation.schedule.periodMilliseconds / 1e3}S`,
-      alignment: "billing_cycle",
-      period_anchor: obligation.schedule.anchor,
-      period_timezone: obligation.period.sourceTimezone,
-      delivery_sla: `PT${(Date.parse(obligation.expectedAt) - Date.parse(obligation.period.end)) / 1e3}S`
-    },
+    schedule: wireSchedule(obligation),
     required_finality: obligation.requiredFinality,
-    reconciliation_mode: "delivery_only",
-    reconciliation_status: "not_required",
+    reconciliation_mode: managed?.binding.reconciliation_mode ?? "delivery_only",
+    reconciliation_status: managed?.reconciliationStatus ?? "not_required",
     health: projection.health,
     production_status: projection.productionStatus,
     revision_count: revisionCount,
     adjustment_count: adjustmentCount,
+    ...managed ? {
+      destination_ref: managed.binding.destination_ref,
+      materialization_count: managed.materializationCount,
+      successful_materialization_count: managed.successfulMaterializationCount,
+      ...managed.resourceRetainedUntil ? { resource_retained_until: managed.resourceRetainedUntil } : {},
+      ...managed.binding.reconciliation_mode === "consumer_receipt" ? {
+        receipt_count: managed.receiptCount,
+        accepted_receipt_count: managed.acceptedReceiptCount,
+        adjustment_receipt_count: managed.adjustmentReceiptCount,
+        accepted_adjustment_receipt_count: managed.acceptedAdjustmentReceiptCount,
+        pending_adjustment_count: managed.pendingAdjustmentReceiptCount
+      } : {}
+    } : {},
     ...consumerStatusCount !== void 0 ? {
       consumer_status_count: consumerStatusCount,
       ...currentConsumerStatus ? { current_consumer_status_id: currentConsumerStatus.reporting_status_id } : {}
@@ -439,6 +517,176 @@ function wireObligation(obligation, revisionCount, adjustmentCount, projection,
     issues: projection.issues.map(wireIssue)
   };
 }
+function projectManagedDelivery(input) {
+  const {
+    obligation,
+    binding,
+    revisions,
+    adjustments,
+    materializations,
+    materializationHistory,
+    receipts,
+    adjustmentReceipts,
+    base,
+    ledgerAsOf,
+    tombstonedAcceptedSubjects = [],
+    tombstonedDeliveredRevisionIds = []
+  } = input;
+  if (!binding) return void 0;
+  const supersededRevisionIds = new Set(
+    revisions.map((value) => value.supersedes_reporting_revision_id).filter((value) => Boolean(value))
+  );
+  const requiredRevision = revisions.filter((value) => !supersededRevisionIds.has(value.reporting_revision_id)).filter((value) => obligation.requiredFinality !== "official" || value.finality === "official").sort((left, right) => left.revisionNumber - right.revisionNumber).at(-1);
+  const successful = materializations.filter(
+    (value) => value.reporting_revision_id === requiredRevision?.reporting_revision_id && (value.status === "available" || value.status === "delivered") && value.resource !== void 0 && value.verification !== void 0
+  );
+  const readable = successful.filter(
+    (value) => value.resource && (0, import_instant.compareReportingInstants)(value.resource.expires_at, ledgerAsOf) > 0
+  );
+  const failed = materializations.filter((value) => value.status === "failed");
+  let projection = base;
+  if (requiredRevision && !readable.length) {
+    const afterExpected = (0, import_instant.compareReportingInstants)(ledgerAsOf, obligation.expectedAt) >= 0;
+    const afterRecovery = (0, import_instant.compareReportingInstants)(ledgerAsOf, obligation.recoveryDeadlineAt) >= 0;
+    const issue = {
+      issueId: `reporting-issue.managed-delivery.${obligation.reporting_obligation_id}`,
+      reporting_obligation_id: obligation.reporting_obligation_id,
+      code: failed.length ? "DELIVERY_FAILED" : successful.length ? "RESOURCE_EXPIRED" : "REPORT_OVERDUE",
+      severity: afterRecovery ? "action_required" : "delayed",
+      responsibleParty: "seller",
+      recommendedAction: afterRecovery ? "contact_seller" : "wait_for_retry",
+      openedAt: successful[0]?.resource?.expires_at ?? failed[0]?.failed_at ?? obligation.expectedAt,
+      observedAt: ledgerAsOf
+    };
+    projection = {
+      ...base,
+      // Managed delivery is an independent degradation source, exactly like the
+      // consumer-status mismatch composed at the call sites. Overwriting
+      // `base.health` let an installed managed table suppress Core degradation:
+      // an obligation with incomplete coverage (`action_required`) read before
+      // its `expectedAt` came back `waiting` while still carrying the
+      // action_required issue, which both contradicts itself and makes the
+      // period unreachable under every `health` filter.
+      health: moreSevereReportingHealthV1(
+        base.health,
+        afterExpected ? afterRecovery ? "action_required" : "delayed" : "waiting"
+      ),
+      satisfied: false,
+      issues: afterExpected ? uniqueIssues([...base.issues, issue]) : base.issues
+    };
+  }
+  const relevantReceipts = requiredRevision ? receipts.filter((value) => value.reporting_revision_id === requiredRevision.reporting_revision_id) : [];
+  const obligationReceipts = receipts.filter(
+    (value) => value.reporting_obligation_id === obligation.reporting_obligation_id
+  );
+  const obligationAdjustmentReceipts = adjustmentReceipts.filter(
+    (value) => adjustments.some((adjustment) => adjustment.reporting_adjustment_id === value.reporting_adjustment_id)
+  );
+  const revisionLeaf = currentReceiptLeaf(relevantReceipts);
+  const adjustmentLeaves = adjustments.map(
+    (adjustment) => currentAdjustmentReceiptLeaf(
+      adjustmentReceipts.filter((value) => value.reporting_adjustment_id === adjustment.reporting_adjustment_id)
+    )
+  );
+  const revisionAcceptedByTombstone = requiredRevision !== void 0 && tombstonedAcceptedSubjects.some(
+    (value) => value.kind === "revision" && value.subjectId === requiredRevision.reporting_revision_id
+  );
+  const tombstonedAdjustmentIds = new Set(
+    adjustments.map((adjustment) => adjustment.reporting_adjustment_id).filter((id) => tombstonedAcceptedSubjects.some((value) => value.kind === "adjustment" && value.subjectId === id))
+  );
+  let reconciliationStatus = "not_required";
+  if (binding.reconciliation_mode === "consumer_receipt" && requiredRevision) {
+    const rejectedAdjustment = adjustments.some(
+      (adjustment, index) => adjustmentLeaves[index]?.status === "rejected" && !tombstonedAdjustmentIds.has(adjustment.reporting_adjustment_id)
+    );
+    const deliveredEver = tombstonedDeliveredRevisionIds.includes(requiredRevision.reporting_revision_id) || materializationHistory.some(
+      (value) => value.reporting_revision_id === requiredRevision.reporting_revision_id && (value.status === "available" || value.status === "delivered") && value.resource !== void 0 && value.verification !== void 0
+    );
+    const missingAdjustmentAfterTombstones = adjustments.some(
+      (adjustment, index) => adjustmentLeaves[index] === void 0 && !tombstonedAdjustmentIds.has(adjustment.reporting_adjustment_id)
+    );
+    const revisionAccepted = revisionLeaf?.status === "accepted" || revisionAcceptedByTombstone;
+    const revisionRejectedNow = revisionLeaf?.status === "rejected" && !revisionAcceptedByTombstone;
+    if (revisionRejectedNow || rejectedAdjustment) reconciliationStatus = "rejected";
+    else if (!deliveredEver) reconciliationStatus = "pending";
+    else if (!revisionAccepted || missingAdjustmentAfterTombstones) reconciliationStatus = "pending";
+    else reconciliationStatus = "accepted";
+    if (reconciliationStatus !== "accepted") {
+      const code = revisionRejectedNow ? "RECEIPT_REJECTED" : rejectedAdjustment ? "ADJUSTMENT_RECEIPT_REJECTED" : !revisionAccepted ? "RECEIPT_REQUIRED" : "ADJUSTMENT_RECEIPT_REQUIRED";
+      const sellerAction = code === "RECEIPT_REJECTED" || code === "ADJUSTMENT_RECEIPT_REJECTED";
+      const issue = {
+        issueId: `reporting-issue.${code.toLowerCase().replaceAll("_", "-")}.${obligation.reporting_obligation_id}`,
+        reporting_obligation_id: obligation.reporting_obligation_id,
+        code,
+        severity: "action_required",
+        responsibleParty: sellerAction ? "seller" : "buyer",
+        recommendedAction: sellerAction ? "contact_seller" : "contact_buyer",
+        openedAt: revisionLeaf?.received_at ?? adjustmentLeaves.find((value) => value?.status === "rejected")?.received_at ?? successful[0]?.ready_at ?? obligation.expectedAt,
+        observedAt: ledgerAsOf
+      };
+      projection = {
+        ...projection,
+        health: "action_required",
+        satisfied: false,
+        issues: uniqueIssues([...projection.issues, issue])
+      };
+    }
+  }
+  return {
+    binding,
+    projection,
+    reconciliationStatus,
+    materializationCount: materializationHistory.length,
+    successfulMaterializationCount: materializationHistory.filter(
+      (value) => value.status === "available" || value.status === "delivered"
+    ).length,
+    resourceRetainedUntil: readable.map((value) => value.resource.expires_at).sort(import_instant.compareReportingInstants).at(-1),
+    // Tombstones move the counters as well as the verdict. RC3 requires a
+    // `consumer_receipt` obligation that reads healthy or complete to report
+    // at least one receipt, at least one accepted receipt, and zero pending
+    // adjustments — so counting only live rows emitted a schema-invalid
+    // `complete` with `receipt_count: 0` the moment an acceptance was pruned,
+    // and left a tombstoned adjustment counted as still pending.
+    // Counters describe exactly the records this response emits, nothing
+    // more and nothing less. Counting only the required revision's receipts
+    // undercounted a superseded revision's receipts, which the periods view
+    // does emit; adding tombstones overcounted records that no longer exist.
+    // Either way a buyer recomputing the association reports
+    // ASSOCIATED_HISTORY_INCOMPLETE. Tombstones keep their real job — they
+    // stop a settled subject reopening on the write path — and retention now
+    // refuses to prune a receipt whose resource is still readable, so a
+    // period can never read complete with nothing to show for it.
+    receiptCount: obligationReceipts.length,
+    acceptedReceiptCount: obligationReceipts.filter((value) => value.status === "accepted").length,
+    adjustmentReceiptCount: obligationAdjustmentReceipts.length,
+    acceptedAdjustmentReceiptCount: obligationAdjustmentReceipts.filter((value) => value.status === "accepted").length,
+    pendingAdjustmentReceiptCount: adjustments.filter(
+      (adjustment, index) => adjustmentLeaves[index]?.status !== "accepted" && !tombstonedAdjustmentIds.has(adjustment.reporting_adjustment_id)
+    ).length
+  };
+}
+function currentReceiptLeaf(receipts) {
+  const superseded = new Set(
+    receipts.map((value) => value.supersedes_reporting_receipt_id).filter((value) => Boolean(value))
+  );
+  return receipts.find((value) => !superseded.has(value.reporting_receipt_id));
+}
+function currentAdjustmentReceiptLeaf(receipts) {
+  const superseded = new Set(
+    receipts.map((value) => value.supersedes_reporting_receipt_id).filter((value) => Boolean(value))
+  );
+  return receipts.find((value) => !superseded.has(value.reporting_receipt_id));
+}
+function moreSevereReportingHealthV1(left, right) {
+  const severity = {
+    complete: 0,
+    healthy: 0,
+    waiting: 1,
+    delayed: 2,
+    action_required: 3
+  };
+  return severity[left] >= severity[right] ? left : right;
+}
 function consumerStatusMatchesObligation(status, obligation) {
   return status.delivery_config_id === obligation.delivery_config_id && status.delivery_config_version === obligation.delivery_config_version && status.report_definition_id === obligation.report_definition_id && (0, import_instant.compareReportingInstants)(status.period.start, obligation.period.start) === 0 && (0, import_instant.compareReportingInstants)(status.period.end, obligation.period.end) === 0 && status.period.source_timezone === obligation.period.sourceTimezone;
 }
@@ -639,11 +887,31 @@ function copyArray(raw, key) {
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function wireSchedule(obligation) {
+  const alignment = obligation.schedule.alignment ?? "billing_cycle";
+  const periodTimezone = obligation.schedule.periodTimezone ?? obligation.period.sourceTimezone;
+  return {
+    period_duration: obligation.schedule.periodDuration ?? `PT${obligation.schedule.periodMilliseconds / 1e3}S`,
+    alignment,
+    // reporting-schedule.json: billing_cycle requires both fields,
+    // source_timezone requires period_timezone and forbids period_anchor, and
+    // utc/account_timezone forbid both. Emitting period_timezone for
+    // account_timezone fails the whole strict get_reporting_status response.
+    ...alignment === "billing_cycle" ? { period_anchor: obligation.schedule.anchor } : {},
+    ...alignment === "billing_cycle" || alignment === "source_timezone" ? { period_timezone: periodTimezone } : {},
+    // Echo the installed lexical duration. Recomputing it from expected_at
+    // would answer PT3600S where the offering advertised PT1H — the same
+    // instant, but not the same value installed_schedule_match compares.
+    delivery_sla: obligation.schedule.deliverySlaDuration ?? `PT${(Date.parse(obligation.expectedAt) - Date.parse(obligation.period.end)) / 1e3}S`
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ReportingReadCapacityError,
   acquireAccountReadSlot,
   aggregateReportingCoverageV1,
   createReportingDeliveryHandler,
-  createReportingStatusHandler
+  createReportingStatusHandler,
+  moreSevereReportingHealthV1,
+  projectManagedDelivery
 });