@adcp/sdk 14.0.0-beta.27 → 14.0.0-beta.28

package/dist/lib/utils/reporting-status-response.mjs

@@ -0,0 +1,319 @@
+import { z } from "zod";
+import {
+  isReportingCanonicalDigest,
+  isReportingControlTotals,
+  isReportingReceiptEvidence,
+  isReportingVerificationEvidence
+} from "../reporting/evidence.mjs";
+import { isReportingCoverageEvidence } from "../reporting/reconciliation.mjs";
+const SHA256_HEX = /^[A-Fa-f0-9]{64}$/;
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function hasFields(value, fields) {
+  return fields.every((field) => value[field] !== void 0);
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function isOffsetDateTime(value) {
+  return typeof value === "string" && value.includes("T") && /(?:Z|[+-]\d{2}:\d{2})$/.test(value) && Number.isFinite(Date.parse(value));
+}
+function nonnegativeInteger(value) {
+  return Number.isInteger(value) && Number(value) >= 0;
+}
+function stringArray(value) {
+  return Array.isArray(value) && value.every(isNonEmptyString);
+}
+function isReportingStatusIssue(value) {
+  if (!isRecord(value) || !hasFields(value, ["code", "severity", "responsible_party", "recommended_action"])) {
+    return false;
+  }
+  return [
+    "REPORT_OVERDUE",
+    "PRODUCTION_FAILED",
+    "DELIVERY_FAILED",
+    "ACCESS_REQUIRED",
+    "CONFIGURATION_REQUIRED",
+    "REPORTING_COVERAGE_INCOMPLETE",
+    "RESOURCE_EXPIRED",
+    "READER_INCOMPATIBLE",
+    "HISTORY_UNAVAILABLE"
+  ].includes(String(value.code)) && ["delayed", "action_required"].includes(String(value.severity)) && ["buyer", "seller", "provider"].includes(String(value.responsible_party)) && [
+    "wait_for_retry",
+    "contact_buyer",
+    "contact_seller",
+    "contact_provider",
+    "repair_access",
+    "update_configuration",
+    "change_reporting_scope",
+    "use_supported_reader"
+  ].includes(String(value.recommended_action));
+}
+function isReportingSchedule(value) {
+  if (!isRecord(value)) return false;
+  const required = ["period_duration", "alignment", "delivery_sla"];
+  const optional = ["period_anchor", "period_timezone"];
+  if (!hasFields(value, required) || !Object.keys(value).every((key) => [...required, ...optional].includes(key)))
+    return false;
+  const periodDuration = /^P(?=.*[1-9])(?=\d|T)(?:\d+Y)?(?:\d+M)?(?:\d+D)?(?:T(?=\d)(?:\d+H)?(?:\d+M)?(?:\d+S)?)?$/;
+  const deliverySla = /^P(?=\d|T)(?=.*\d)(?:\d+Y)?(?:\d+M)?(?:\d+D)?(?:T(?=\d)(?:\d+H)?(?:\d+M)?(?:\d+S)?)?$/;
+  if (typeof value.period_duration !== "string" || !periodDuration.test(value.period_duration) || !["utc", "account_timezone", "billing_cycle"].includes(String(value.alignment)) || typeof value.delivery_sla !== "string" || !deliverySla.test(value.delivery_sla))
+    return false;
+  return value.alignment === "billing_cycle" ? isOffsetDateTime(value.period_anchor) && isNonEmptyString(value.period_timezone) && value.period_timezone.length <= 255 : value.period_anchor === void 0 && value.period_timezone === void 0;
+}
+function isReportingResource(value) {
+  if (!isRecord(value)) return false;
+  const required = ["resource_ref", "kind", "location", "immutability", "expires_at"];
+  const optional = ["native_version_ref", "manifest_version", "manifest_sha256", "reader_compatibility"];
+  if (!hasFields(value, required) || !Object.keys(value).every((key) => [...required, ...optional].includes(key)))
+    return false;
+  if (!isNonEmptyString(value.resource_ref) || value.resource_ref.length > 255 || !["manifest", "dataset", "warehouse_relation"].includes(String(value.kind)) || !isNonEmptyString(value.location) || value.location.length > 2048 || !["immutable_location", "native_version"].includes(String(value.immutability)) || !isOffsetDateTime(value.expires_at) || value.reader_compatibility !== void 0 && (!Array.isArray(value.reader_compatibility) || !value.reader_compatibility.every(isNonEmptyString) || new Set(value.reader_compatibility).size !== value.reader_compatibility.length))
+    return false;
+  if (value.kind === "manifest" && (value.manifest_version !== "1.0" || typeof value.manifest_sha256 !== "string" || !SHA256_HEX.test(value.manifest_sha256)))
+    return false;
+  return value.immutability !== "native_version" || isNonEmptyString(value.native_version_ref);
+}
+function isReportingMaterialization(value) {
+  const allowed = /* @__PURE__ */ new Set([
+    "reporting_materialization_id",
+    "reporting_revision_id",
+    "reporting_obligation_id",
+    "delivery_config_id",
+    "delivery_config_version",
+    "destination_ref",
+    "feed_purpose",
+    "method",
+    "transport",
+    "attempt",
+    "status",
+    "ready_at",
+    "failed_at",
+    "failure_code",
+    "resource",
+    "verification",
+    "created_at"
+  ]);
+  if (!isRecord(value) || Object.keys(value).some((key) => !allowed.has(key)) || !hasFields(value, [
+    "reporting_materialization_id",
+    "reporting_revision_id",
+    "reporting_obligation_id",
+    "delivery_config_id",
+    "delivery_config_version",
+    "destination_ref",
+    "feed_purpose",
+    "method",
+    "attempt",
+    "status",
+    "created_at"
+  ])) {
+    return false;
+  }
+  if (!isNonEmptyString(value.reporting_materialization_id) || !isNonEmptyString(value.reporting_revision_id) || !isNonEmptyString(value.reporting_obligation_id) || !isNonEmptyString(value.delivery_config_id) || !Number.isSafeInteger(value.delivery_config_version) || Number(value.delivery_config_version) < 1 || !isNonEmptyString(value.destination_ref) || !["pacing", "analytics", "billing"].includes(String(value.feed_purpose)) || !["file_transfer", "dataset_share", "warehouse_materialization"].includes(String(value.method)) || value.transport !== void 0 && (typeof value.transport !== "string" || !/^[a-z][a-z0-9_.-]{0,63}$/.test(value.transport)) || !Number.isSafeInteger(value.attempt) || Number(value.attempt) < 1 || !isOffsetDateTime(value.created_at))
+    return false;
+  if (value.resource !== void 0 && !isReportingResource(value.resource) || value.verification !== void 0 && !isReportingVerificationEvidence(value.verification) || value.ready_at !== void 0 && !isOffsetDateTime(value.ready_at) || value.failed_at !== void 0 && !isOffsetDateTime(value.failed_at))
+    return false;
+  if (!["pending", "available", "delivered", "failed"].includes(String(value.status))) return false;
+  if (value.status === "failed") return isOffsetDateTime(value.failed_at) && isNonEmptyString(value.failure_code);
+  if (value.status === "pending") return true;
+  if (!isOffsetDateTime(value.ready_at) || !isReportingResource(value.resource) || !isRecord(value.verification) || !isReportingVerificationEvidence(value.verification))
+    return false;
+  const resource = value.resource;
+  const verification = value.verification;
+  if (resource.immutability === "native_version" && !isNonEmptyString(resource.native_version_ref)) return false;
+  if (value.method === "file_transfer") {
+    return resource.kind === "manifest" && resource.manifest_version === "1.0" && typeof resource.manifest_sha256 === "string" && SHA256_HEX.test(resource.manifest_sha256) && Array.isArray(verification.physical_checksums) && verification.physical_checksums.length > 0;
+  }
+  if (value.method === "dataset_share") {
+    return resource.kind === "dataset" && verification.verification_path === "representative_consumer";
+  }
+  if (value.method === "warehouse_materialization") {
+    return resource.kind === "warehouse_relation" && verification.verification_path === "destination";
+  }
+  return false;
+}
+function isReportingReceipt(value) {
+  return isReportingReceiptEvidence(value);
+}
+function isReportingPeriod(value) {
+  return isRecord(value) && Object.keys(value).every((key) => ["start", "end", "source_timezone"].includes(key)) && isOffsetDateTime(value.start) && isOffsetDateTime(value.end) && isNonEmptyString(value.source_timezone);
+}
+function isReportingObligation(value) {
+  const fields = [
+    "reporting_obligation_id",
+    "delivery_config_id",
+    "delivery_config_version",
+    "report_definition_id",
+    "feed_purpose",
+    "reporting_profile",
+    "account_id",
+    "scope_resolved_at",
+    "media_buy_ids",
+    "coverage",
+    "period",
+    "expected_at",
+    "schedule",
+    "destination_ref",
+    "required_finality",
+    "reconciliation_mode",
+    "reconciliation_status",
+    "health",
+    "production_status",
+    "revision_count",
+    "materialization_count",
+    "successful_materialization_count",
+    "receipt_count",
+    "accepted_receipt_count",
+    "issues"
+  ];
+  if (!isRecord(value) || !hasFields(value, fields)) return false;
+  return isNonEmptyString(value.reporting_obligation_id) && isNonEmptyString(value.delivery_config_id) && Number.isInteger(value.delivery_config_version) && Number(value.delivery_config_version) >= 1 && isNonEmptyString(value.report_definition_id) && ["pacing", "analytics", "billing"].includes(String(value.feed_purpose)) && isNonEmptyString(value.reporting_profile) && isNonEmptyString(value.account_id) && isOffsetDateTime(value.scope_resolved_at) && stringArray(value.media_buy_ids) && isReportingCoverageEvidence(value.coverage) && isReportingPeriod(value.period) && isOffsetDateTime(value.expected_at) && isReportingSchedule(value.schedule) && isNonEmptyString(value.destination_ref) && ["snapshot", "official"].includes(String(value.required_finality)) && ["delivery_only", "consumer_receipt"].includes(String(value.reconciliation_mode)) && ["not_required", "pending", "accepted", "rejected"].includes(String(value.reconciliation_status)) && ["waiting", "healthy", "delayed", "action_required", "complete"].includes(String(value.health)) && ["not_due", "pending", "published", "failed"].includes(String(value.production_status)) && [
+    "revision_count",
+    "materialization_count",
+    "successful_materialization_count",
+    "receipt_count",
+    "accepted_receipt_count"
+  ].every((field) => nonnegativeInteger(value[field])) && Array.isArray(value.issues) && value.issues.every(isReportingStatusIssue);
+}
+function isCanonicalDigest(value) {
+  return isReportingCanonicalDigest(value);
+}
+function isReportingRevision(value) {
+  const fields = [
+    "reporting_revision_id",
+    "report_definition_id",
+    "report_definition_uri",
+    "report_definition_sha256",
+    "reporting_profile",
+    "schema_version",
+    "schema_uri",
+    "schema_sha256",
+    "schema_dialect",
+    "schema_ref_policy",
+    "account_id",
+    "media_buy_ids",
+    "coverage",
+    "period",
+    "finality",
+    "observed_at",
+    "data_through",
+    "data_through_precision",
+    "row_count",
+    "control_totals",
+    "created_at"
+  ];
+  if (!isRecord(value) || !hasFields(value, fields)) return false;
+  const officialFields = ["finality_basis", "finality_policy_id", "finalized_at"];
+  const official = value.finality === "official";
+  if (official !== officialFields.every((field) => value[field] !== void 0)) return false;
+  if (!official && officialFields.some((field) => value[field] !== void 0)) return false;
+  if (official && (!["source_final", "contractual_cutoff", "stabilized"].includes(String(value.finality_basis)) || !isNonEmptyString(value.finality_policy_id) || !isOffsetDateTime(value.finalized_at))) {
+    return false;
+  }
+  const precision = String(value.data_through_precision);
+  if (!["exact", "lower_bound", "unknown"].includes(precision) || (precision === "unknown" ? value.data_through !== null : !isOffsetDateTime(value.data_through))) {
+    return false;
+  }
+  return isNonEmptyString(value.reporting_revision_id) && isNonEmptyString(value.report_definition_id) && isNonEmptyString(value.report_definition_uri) && typeof value.report_definition_sha256 === "string" && SHA256_HEX.test(value.report_definition_sha256) && isNonEmptyString(value.reporting_profile) && isNonEmptyString(value.schema_version) && isNonEmptyString(value.schema_uri) && typeof value.schema_sha256 === "string" && SHA256_HEX.test(value.schema_sha256) && value.schema_dialect === "https://json-schema.org/draft/2020-12/schema" && value.schema_ref_policy === "local_fragment_only" && isNonEmptyString(value.account_id) && stringArray(value.media_buy_ids) && isReportingCoverageEvidence(value.coverage) && isReportingPeriod(value.period) && ["snapshot", "official"].includes(String(value.finality)) && isOffsetDateTime(value.observed_at) && nonnegativeInteger(value.row_count) && isReportingControlTotals(value.control_totals) && isOffsetDateTime(value.created_at) && (value.canonical_content_digest === void 0 || isCanonicalDigest(value.canonical_content_digest));
+}
+const scopeKeys = [
+  "period_start",
+  "period_end",
+  "scope_closed",
+  "media_buy_ids",
+  "all_accessible_media_buys",
+  "delivery_config_generations",
+  "feed_purposes",
+  "finality",
+  "ledger_retained_from",
+  "coverage_complete"
+];
+function isReportingScope(value) {
+  if (!isRecord(value) || !Object.keys(value).every((key) => scopeKeys.includes(key)) || !hasFields(
+    value,
+    scopeKeys.filter((key) => key !== "media_buy_ids")
+  )) {
+    return false;
+  }
+  const generations = value.delivery_config_generations;
+  return isOffsetDateTime(value.period_start) && isOffsetDateTime(value.period_end) && typeof value.scope_closed === "boolean" && typeof value.all_accessible_media_buys === "boolean" && (value.all_accessible_media_buys || stringArray(value.media_buy_ids)) && Array.isArray(generations) && generations.every(
+    (generation) => isRecord(generation) && Object.keys(generation).every(
+      (key) => ["delivery_config_id", "delivery_config_version", "feed_purpose"].includes(key)
+    ) && isNonEmptyString(generation.delivery_config_id) && Number.isInteger(generation.delivery_config_version) && Number(generation.delivery_config_version) >= 1 && ["pacing", "analytics", "billing"].includes(String(generation.feed_purpose))
+  ) && Array.isArray(value.feed_purposes) && value.feed_purposes.every((item) => ["pacing", "analytics", "billing"].includes(String(item))) && Array.isArray(value.finality) && value.finality.every((item) => ["snapshot", "official"].includes(String(item))) && isOffsetDateTime(value.ledger_retained_from) && typeof value.coverage_complete === "boolean";
+}
+function isPagination(value) {
+  return isRecord(value) && typeof value.has_more === "boolean" && nonnegativeInteger(value.total_count);
+}
+function lacksFields(value, fields) {
+  return fields.every((field) => value[field] === void 0);
+}
+function hasCompletedCommon(value) {
+  return value.status === "completed" && isNonEmptyString(value.ledger_snapshot_id) && isOffsetDateTime(value.ledger_as_of) && isNonEmptyString(value.account_id);
+}
+function isSummaryResponse(value) {
+  if (!isRecord(value.obligation_counts)) return false;
+  const obligationCounts = value.obligation_counts;
+  if (!hasCompletedCommon(value) || value.view !== "summary" || !isReportingScope(value.scope) || !isReportingCoverageEvidence(value.coverage) || !(value.data_through === null || isOffsetDateTime(value.data_through)) || !lacksFields(value, ["periods", "revisions", "pagination", "revision", "materializations", "receipts"]) || !["healthy", "waiting", "delayed", "action_required", "complete"].includes(String(value.health)) || !Array.isArray(value.issues) || !value.issues.every(isReportingStatusIssue) || !["total", "waiting", "healthy", "delayed", "action_required", "complete"].every(
+    (field) => nonnegativeInteger(obligationCounts[field])
+  )) {
+    return false;
+  }
+  const health = String(value.health);
+  if (health === "complete" && (!value.scope.scope_closed || !value.scope.coverage_complete || value.next_expected_at !== void 0)) {
+    return false;
+  }
+  if (["healthy", "waiting", "complete"].includes(health) && value.issues.length !== 0) return false;
+  if (health === "action_required" && !value.issues.some((issue) => isRecord(issue) && issue.severity === "action_required")) {
+    return false;
+  }
+  if (health === "delayed" && (value.issues.length === 0 || value.issues.some((issue) => !isRecord(issue) || issue.severity !== "delayed"))) {
+    return false;
+  }
+  if (!value.scope.coverage_complete && (health !== "action_required" || !value.issues.some(
+    (issue) => isRecord(issue) && issue.code === "HISTORY_UNAVAILABLE" && issue.severity === "action_required"
+  ))) {
+    return false;
+  }
+  return true;
+}
+function isGetReportingStatusResponse(value) {
+  if (!isRecord(value)) return false;
+  if (value.status === "failed") {
+    const allowed = /* @__PURE__ */ new Set([
+      "adcp_version",
+      "adcp_major_version",
+      "status",
+      "view",
+      "failure_kind",
+      "context_id",
+      "context",
+      "message",
+      "timestamp",
+      "replayed",
+      "adcp_error",
+      "errors"
+    ]);
+    if (Object.keys(value).some((key) => !allowed.has(key)) || !["summary", "periods", "revision"].includes(String(value.view)) || !["lookup_unavailable", "operational"].includes(String(value.failure_kind)) || !Array.isArray(value.errors) || value.errors.length === 0 || !value.errors.every((error) => isRecord(error) && isNonEmptyString(error.code) && isNonEmptyString(error.message)))
+      return false;
+    if (value.failure_kind === "lookup_unavailable") {
+      return value.errors.length === 1 && Object.keys(value.errors[0]).every((key) => ["code", "message"].includes(key)) && value.errors[0].code === "NOT_FOUND" && value.errors[0].message === "Reporting status resource is unavailable." && (value.message === void 0 || value.message === "Reporting status resource is unavailable.") && (value.adcp_error === void 0 || isRecord(value.adcp_error) && Object.keys(value.adcp_error).every((key) => ["code", "message"].includes(key)) && value.adcp_error.code === "NOT_FOUND" && value.adcp_error.message === "Reporting status resource is unavailable.");
+    }
+    return true;
+  }
+  if (value.status !== "completed") return false;
+  if (value.view === "summary") return isSummaryResponse(value);
+  if (value.view === "periods") {
+    return hasCompletedCommon(value) && isReportingScope(value.scope) && Array.isArray(value.periods) && value.periods.every(isReportingObligation) && Array.isArray(value.revisions) && value.revisions.every(isReportingRevision) && Array.isArray(value.materializations) && value.materializations.every(isReportingMaterialization) && Array.isArray(value.receipts) && value.receipts.every(isReportingReceipt) && isPagination(value.pagination) && lacksFields(value, ["revision"]);
+  }
+  if (value.view === "revision") {
+    return hasCompletedCommon(value) && isReportingRevision(value.revision) && Array.isArray(value.materializations) && value.materializations.every(isReportingMaterialization) && Array.isArray(value.receipts) && value.receipts.every(isReportingReceipt) && isPagination(value.pagination) && lacksFields(value, ["scope", "health", "periods", "revisions"]);
+  }
+  return false;
+}
+const GetReportingStatusResponseCurrentSchema = z.custom(isGetReportingStatusResponse, {
+  message: "get_reporting_status response does not satisfy the current reporting protocol"
+});
+export {
+  GetReportingStatusResponseCurrentSchema
+};

package/dist/lib/utils/response-schemas.js

@@ -36,6 +36,7 @@ var import_zod = require("zod");
 var schemas = __toESM(require('../types/schemas.generated.js'));
 var import_sync_creatives = require('../validation/sync-creatives.js');
 var import_adcp_version_config = require('./adcp-version-config.js');
+var import_reporting_status_response = require('./reporting-status-response.js');
 var import_version = require('../version.js');
 function declaresLegacy30xPayload(response) {
   const adcpVersion = response.adcp_version;
@@ -81,7 +82,11 @@ const TOOL_RESPONSE_SCHEMAS = {
   update_media_buy: schemas.UpdateMediaBuyResponseSchema,
   get_media_buys: schemas.GetMediaBuysResponseSchema,
   get_media_buy_delivery: schemas.GetMediaBuyDeliveryResponseSchema,
-  get_reporting_status: schemas.GetReportingStatusResponseSchema,
+  // The generated Zod schema does not retain every composed `allOf`
+  // requirement or nested `additionalProperties: false` boundary from the
+  // signed protocol schema. Preserve the stricter billing-evidence validator
+  // until code generation represents those constraints directly.
+  get_reporting_status: import_reporting_status_response.GetReportingStatusResponseCurrentSchema,
   sync_reporting_receipts: schemas.SyncReportingReceiptsResponseSchema,
   provide_performance_feedback: schemas.ProvidePerformanceFeedbackResponseSchema,
   // Creative

package/dist/lib/utils/response-schemas.mjs

@@ -2,6 +2,7 @@ import { z } from "zod";
 import * as schemas from "../types/schemas.generated.mjs";
 import { SyncCreativesResponseStrictSchema } from "../validation/sync-creatives.mjs";
 import { isPre31AdcpVersion } from "./adcp-version-config.mjs";
+import { GetReportingStatusResponseCurrentSchema } from "./reporting-status-response.mjs";
 import { toReleasePrecisionVersion } from "../version.mjs";
 function declaresLegacy30xPayload(response) {
   const adcpVersion = response.adcp_version;
@@ -47,7 +48,11 @@ const TOOL_RESPONSE_SCHEMAS = {
   update_media_buy: schemas.UpdateMediaBuyResponseSchema,
   get_media_buys: schemas.GetMediaBuysResponseSchema,
   get_media_buy_delivery: schemas.GetMediaBuyDeliveryResponseSchema,
-  get_reporting_status: schemas.GetReportingStatusResponseSchema,
+  // The generated Zod schema does not retain every composed `allOf`
+  // requirement or nested `additionalProperties: false` boundary from the
+  // signed protocol schema. Preserve the stricter billing-evidence validator
+  // until code generation represents those constraints directly.
+  get_reporting_status: GetReportingStatusResponseCurrentSchema,
   sync_reporting_receipts: schemas.SyncReportingReceiptsResponseSchema,
   provide_performance_feedback: schemas.ProvidePerformanceFeedbackResponseSchema,
   // Creative

package/dist/lib/version.d.mts

@@ -1,7 +1,7 @@
 /**
  * AdCP SDK library version
  */
-export declare const LIBRARY_VERSION = "14.0.0-beta.27";
+export declare const LIBRARY_VERSION = "14.0.0-beta.28";
 /**
  * AdCP specification version this library is built for
  */
@@ -33,10 +33,10 @@ export type AdcpVersion = (typeof COMPATIBLE_ADCP_VERSIONS)[number];
  * Full version information
  */
 export declare const VERSION_INFO: {
-    readonly library: "14.0.0-beta.27";
+    readonly library: "14.0.0-beta.28";
     readonly adcp: "3.2.0-beta.10";
     readonly compatibleVersions: readonly ["v2.5", "v2.6", "v3", "3.0.0-beta.1", "3.0-beta.1", "3.0-beta", "3.0.0-beta.3", "3.0-beta.3", "3.0.0", "3.0", "3.0.1", "3.0.2", "3.0.3", "3.0.4", "3.0.5", "3.0.6", "3.0.7", "3.0.8", "3.0.9", "3.0.10", "3.0.11", "3.0.12", "3.0.13", "3.0.14", "3.0.15", "3.0.16", "3.0.17", "3.0.18", "3.0.19", "3.0.20", "3.0.21", "3.0.22", "3.0.23", "3.0.24", "3.0.25", "3.1.0", "3.1", "3.1.1", "3.1.2", "3.1.3", "3.1.4", "3.1.5", "3.1.6", "3.1.7", "3.1.8", "3.1.9", "3.1.10", "3.1.11", "3.1.12", "3.1.13", "3.1.14", "3.1.15", "3.1.16", "3.1.17", "3.1.18", "3.2.0-beta.10", "3.2-beta.10"];
-    readonly generatedAt: "2026-09-02T01:42:03.563Z";
+    readonly generatedAt: "2026-09-02T09:57:23.680Z";
 };
 /**
  * Get the AdCP specification version this library is built for

package/dist/lib/version.d.ts

@@ -1,7 +1,7 @@
 /**
  * AdCP SDK library version
  */
-export declare const LIBRARY_VERSION = "14.0.0-beta.27";
+export declare const LIBRARY_VERSION = "14.0.0-beta.28";
 /**
  * AdCP specification version this library is built for
  */
@@ -33,10 +33,10 @@ export type AdcpVersion = (typeof COMPATIBLE_ADCP_VERSIONS)[number];
  * Full version information
  */
 export declare const VERSION_INFO: {
-    readonly library: "14.0.0-beta.27";
+    readonly library: "14.0.0-beta.28";
     readonly adcp: "3.2.0-beta.10";
     readonly compatibleVersions: readonly ["v2.5", "v2.6", "v3", "3.0.0-beta.1", "3.0-beta.1", "3.0-beta", "3.0.0-beta.3", "3.0-beta.3", "3.0.0", "3.0", "3.0.1", "3.0.2", "3.0.3", "3.0.4", "3.0.5", "3.0.6", "3.0.7", "3.0.8", "3.0.9", "3.0.10", "3.0.11", "3.0.12", "3.0.13", "3.0.14", "3.0.15", "3.0.16", "3.0.17", "3.0.18", "3.0.19", "3.0.20", "3.0.21", "3.0.22", "3.0.23", "3.0.24", "3.0.25", "3.1.0", "3.1", "3.1.1", "3.1.2", "3.1.3", "3.1.4", "3.1.5", "3.1.6", "3.1.7", "3.1.8", "3.1.9", "3.1.10", "3.1.11", "3.1.12", "3.1.13", "3.1.14", "3.1.15", "3.1.16", "3.1.17", "3.1.18", "3.2.0-beta.10", "3.2-beta.10"];
-    readonly generatedAt: "2026-09-02T01:42:03.563Z";
+    readonly generatedAt: "2026-09-02T09:57:23.680Z";
 };
 /**
  * Get the AdCP specification version this library is built for

package/dist/lib/version.js

@@ -31,7 +31,7 @@ __export(version_exports, {
   toReleasePrecisionVersion: () => toReleasePrecisionVersion
 });
 module.exports = __toCommonJS(version_exports);
-const LIBRARY_VERSION = "14.0.0-beta.27";
+const LIBRARY_VERSION = "14.0.0-beta.28";
 const ADCP_VERSION = "3.2.0-beta.10";
 const ADCP_MAJOR_VERSION = 3;
 const COMPATIBLE_ADCP_VERSIONS = [
@@ -94,10 +94,10 @@ const COMPATIBLE_ADCP_VERSIONS = [
   "3.2-beta.10"
 ];
 const VERSION_INFO = {
-  library: "14.0.0-beta.27",
+  library: "14.0.0-beta.28",
   adcp: "3.2.0-beta.10",
   compatibleVersions: COMPATIBLE_ADCP_VERSIONS,
-  generatedAt: "2026-09-02T01:42:03.563Z"
+  generatedAt: "2026-09-02T09:57:23.680Z"
 };
 function getAdcpVersion() {
   return ADCP_VERSION;

package/dist/lib/version.mjs

@@ -1,4 +1,4 @@
-const LIBRARY_VERSION = "14.0.0-beta.27";
+const LIBRARY_VERSION = "14.0.0-beta.28";
 const ADCP_VERSION = "3.2.0-beta.10";
 const ADCP_MAJOR_VERSION = 3;
 const COMPATIBLE_ADCP_VERSIONS = [
@@ -61,10 +61,10 @@ const COMPATIBLE_ADCP_VERSIONS = [
   "3.2-beta.10"
 ];
 const VERSION_INFO = {
-  library: "14.0.0-beta.27",
+  library: "14.0.0-beta.28",
   adcp: "3.2.0-beta.10",
   compatibleVersions: COMPATIBLE_ADCP_VERSIONS,
-  generatedAt: "2026-09-02T01:42:03.563Z"
+  generatedAt: "2026-09-02T09:57:23.680Z"
 };
 function getAdcpVersion() {
   return ADCP_VERSION;

package/docs/TYPE-SUMMARY.md

@@ -1,7 +1,7 @@
 # AdCP Type Summary
 
 > Generated at: 2026-09-02
-> @adcp/sdk v14.0.0-beta.27
+> @adcp/sdk v14.0.0-beta.28
 
 Curated reference of the types that matter for using the AdCP client. For full generated types see `src/lib/types/tools.generated.ts` and `src/lib/types/core.generated.ts`.
 

package/docs/guides/REPORTING-RECONCILIATION.md

@@ -0,0 +1,107 @@
+# Reporting reconciliation
+
+`reconcileReporting` turns the reporting ledger into a buyer-verifiable result. It reads one stable ledger snapshot, checks the expected period set, inspects each current destination materialization, submits any required consumer receipts, and then reads the seller's ledger back before returning.
+
+The helper only returns `definitive: true` when all of these conditions hold:
+
+- the buyer supplies its own complete `expectedPeriods` denominator;
+- the seller closes the requested scope and declares its coverage complete;
+- every expected report definition, feed, reporting profile, campaign set, and period has an obligation;
+- every obligation's history counts match the returned immutable records;
+- the current revision has the required finality;
+- a verified, unexpired materialization matches the obligation;
+- every consumer-receipt obligation has an accepted receipt for the same revision, materialization, row count, control totals, and required verification evidence.
+
+An omitted expected-period denominator can still diagnose delivery, but can never prove completeness. Pass `[]` only when the buyer independently knows that no periods are expected in the requested scope.
+
+```ts
+import {
+  createHttpsReportingResourceReader,
+  reconcileReporting,
+} from '@adcp/sdk';
+
+const result = await reconcileReporting({
+  client: seller,
+  request: {
+    account: { account_id: 'account-1' },
+    period: {
+      start: '2026-08-01T00:00:00Z',
+      end: '2026-09-01T00:00:00Z',
+    },
+  },
+  expectedPeriods: [{
+    deliveryConfigId: 'billing-feed',
+    deliveryConfigVersion: 3,
+    reportDefinitionId: 'billing-v1',
+    feedPurpose: 'billing',
+    reportingProfile: 'billing-v1',
+    mediaBuyIds: ['buy-1', 'buy-2'],
+    destinationRef: 'destination-billing-v3',
+    deliveryMethod: 'file_transfer',
+    requiredFinality: 'official',
+    reconciliationMode: 'consumer_receipt',
+    coverageRequirement: 'full',
+    coverage: {
+      status: 'full',
+      media_buy_ids: ['buy-1', 'buy-2'],
+      fully_covered_media_buy_ids: ['buy-1', 'buy-2'],
+      partially_covered_media_buy_ids: [],
+      unsupported_media_buy_ids: [],
+      unknown_media_buy_ids: [],
+      package_ids: ['package-1', 'package-2'],
+      covered_package_ids: ['package-1', 'package-2'],
+      unsupported_package_ids: [],
+      unknown_package_ids: [],
+    },
+    reportDefinitionUri: 'https://schemas.seller.example/report-definitions/billing-v1.json',
+    reportDefinitionSha256: savedBillingDefinitionSha256,
+    schemaVersion: '1',
+    schemaUri: 'https://schemas.seller.example/reporting/billing-v1.json',
+    schemaSha256: savedBillingSchemaSha256,
+    schemaDialect: 'https://json-schema.org/draft/2020-12/schema',
+    schemaRefPolicy: 'local_fragment_only',
+    officialFinality: {
+      policyId: 'billing-close-v1',
+      basis: 'contractual_cutoff',
+    },
+    verificationProfile: 'canonical_digest',
+    canonicalization: {
+      id: 'billing-rows-v1',
+      uri: 'https://schemas.seller.example/canonicalization/billing-rows-v1.json',
+      sha256: savedCanonicalizationSha256,
+      primaryKeys: ['media_buy_id', 'date'],
+    },
+    periodStart: '2026-08-01T00:00:00Z',
+    periodEnd: '2026-09-01T00:00:00Z',
+  }],
+  resourceReader: createHttpsReportingResourceReader(),
+  credentialProvider: {
+    async getCredentials({ obligation }) {
+      const destination = await loadSavedDestination(obligation.destination_ref);
+      return {
+        headers: {
+          authorization: `Bearer ${await destinationToken(obligation.destination_ref)}`,
+        },
+        allowedOrigins: [destination.readerOrigin],
+      };
+    },
+  },
+  manifestInspectorOptions: {
+    referenceAllowedOrigins: ['https://schemas.seller.example'],
+    consumerCommitRef: 'buyer-reporting-ledger:2026-08',
+    maxInspectionMs: 60_000,
+  },
+});
+
+if (!result.definitive) {
+  throw new Error('Reporting is not ready for billing');
+}
+```
+
+When `inspect` is omitted, `resourceReader` enables the built-in manifest path. It verifies the exact manifest bytes before parsing, manifest identity and completeness, every object size and SHA-256, declared compression and format, the pinned row schema and report definition, row count and control totals, and the pinned RFC 8785 canonical-content contract. The bundled decoders cover JSONL and CSV with `none` or `gzip` compression. Configure format/compression decoders for Parquet, Avro, ORC, Zstandard, or Snappy. The aggregate inspection deadline covers credential lookup, reads, reference resolution, custom adapters, validation, and canonicalization.
+
+The HTTPS reader applies the SDK's DNS-pinned SSRF controls, refuses redirects and cross-origin `object_ref` values, and accepts short-lived headers only through the credential provider. `allowedOrigins` must come from the consumer's saved destination configuration; the reader refuses to send credentials to an origin named only by the seller's resource descriptor. For S3, GCS, or Azure, implement `ReportingResourceReader`; it receives the destination-bound context and opaque credentials without placing either in the ledger or receipt. Complex control totals can supply `controlTotalCalculator`; the default handles only report-definition metrics whose declared aggregation is `sum` and whose `source_expression` resolves to numeric row values.
+
+Keep `inspect` as the advanced override for native snapshots. A BigQuery adapter can inspect a table version, while Snowflake or Databricks adapters can verify a shared relation. `ReportingInspectionError.retryable` distinguishes transport/readiness failures from permanent digest, schema, or integrity failures, so permanent failures are never retried. Store receipts in a durable `checkpointStore` so a process restart does not repeat destination work. Set `checkpointScope` to a stable, non-secret seller-and-authenticated-principal identifier; checkpoint keys also include account, obligation, revision, materialization, and destination. The checkpoint preserves the receipt-write idempotency key across uncertain retries.
+
+Totals are returned once per canonical reporting revision. Each entry includes its coverage status and covered/package denominators, so partial evidence cannot be mistaken for full billing totals. Delivering the same revision to a buyer, governance agent, and archive destination does not multiply its rows or financial control totals. Each consumer still authenticates independently and submits its own receipt; one consumer's acceptance never implies another's.

package/docs/llms.txt

@@ -1,7 +1,7 @@
 # Ad Context Protocol (AdCP)
 
 > Generated at: 2026-09-02
-> Library: @adcp/sdk v14.0.0-beta.27
+> Library: @adcp/sdk v14.0.0-beta.28
 > AdCP major version: 3
 > Canonical URL: https://adcontextprotocol.github.io/adcp-client/llms.txt
 > Note: the `Library` stamp reflects the package.json version at doc-generation time. The narrative below describes the surface that lands on the next-published minor — including any 6.7 helpers documented here ahead of the release tag.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adcp/sdk",
-  "version": "14.0.0-beta.27",
+  "version": "14.0.0-beta.28",
   "description": "AdCP SDK — client, server, and compliance harnesses for the AdContext Protocol (MCP + A2A)",
   "workspaces": [
     ".",