@adcp/sdk 15.4.0 → 15.6.0

package/dist/lib/reporting/gcs/row-provider.mjs

@@ -0,0 +1,188 @@
+import { createHash } from "node:crypto";
+import { ReportingRowStoreError } from "../ledger/row-storage-errors.mjs";
+import {
+  assertReportingRowLocationKeys,
+  assertReportingRowReadBounds,
+  readReportingRowStream,
+  reportingRowClientMap,
+  reportingRowPrefixFilterOverlaps,
+  runReportingRowProviderOperation,
+  selectReportingRowClient
+} from "../ledger/row-storage-provider-io.mjs";
+const BUCKET = /^[a-z0-9][a-z0-9._-]{1,220}[a-z0-9]$/;
+const GENERATION = /^[1-9][0-9]{0,15}$/;
+const NONCURRENT_ONLY_CONDITIONS = ["numNewerVersions", "daysSinceNoncurrentTime", "noncurrentTimeBefore"];
+function status(error) {
+  if (!error || typeof error !== "object" || !("code" in error)) return void 0;
+  const code = Number(error.code);
+  return Number.isInteger(code) ? code : void 0;
+}
+function generationOf(metadata) {
+  const generation = metadata?.generation === void 0 ? "" : String(metadata.generation);
+  if (!GENERATION.test(generation) || !Number.isSafeInteger(Number(generation))) {
+    throw new ReportingRowStoreError("PROVIDER_UNAVAILABLE", "object generation is missing");
+  }
+  return generation;
+}
+function pinnedGeneration(nativeVersion) {
+  return typeof nativeVersion === "string" && GENERATION.test(nativeVersion) && Number.isSafeInteger(Number(nativeVersion)) ? nativeVersion : null;
+}
+function assertGcsReportingRowBucketPolicyV1(metadata, prefix) {
+  if (!metadata || typeof metadata !== "object") {
+    throw new ReportingRowStoreError("UNSAFE_BINDING", "bucket policy is unavailable");
+  }
+  if (metadata.iamConfiguration?.uniformBucketLevelAccess?.enabled !== true) {
+    throw new ReportingRowStoreError("UNSAFE_BINDING", "bucket must enable uniform bucket-level access");
+  }
+  if (metadata.iamConfiguration?.publicAccessPrevention !== "enforced") {
+    throw new ReportingRowStoreError("UNSAFE_BINDING", "bucket must enforce public access prevention");
+  }
+  for (const rule of metadata.lifecycle?.rule ?? []) {
+    if (rule?.action?.type !== "Delete") continue;
+    const condition = rule.condition ?? {};
+    if (condition.isLive === false) continue;
+    if (NONCURRENT_ONLY_CONDITIONS.some((name) => condition[name] !== void 0 && condition[name] !== null)) continue;
+    const prefixes = condition.matchesPrefix ?? [];
+    if (prefixes.length === 0 || prefixes.some((filter) => reportingRowPrefixFilterOverlaps(filter, prefix))) {
+      throw new ReportingRowStoreError("UNSAFE_BINDING", "a bucket lifecycle rule can delete live row objects");
+    }
+  }
+}
+function createGcsReportingRowObjectProviderV1(options) {
+  if (!options || typeof options !== "object") {
+    throw new ReportingRowStoreError("INVALID_INPUT", "GCS row provider options are required");
+  }
+  const clients = reportingRowClientMap(options.clients);
+  const isStorage = (value) => !!value && typeof value === "object" && typeof value.bucket === "function";
+  if (options.storage !== void 0 && !isStorage(options.storage) || [...clients.values()].some((client) => !isStorage(client)) || options.storage === void 0 && clients.size === 0) {
+    throw new ReportingRowStoreError("INVALID_INPUT", "inject an official Storage client as storage or clients");
+  }
+  const validateLocation = (location) => {
+    assertReportingRowLocationKeys(location, ["bucket"]);
+    if (!BUCKET.test(location.bucket) || location.bucket.includes("..")) {
+      throw new ReportingRowStoreError("INVALID_INPUT", "GCS bucket name is invalid");
+    }
+  };
+  const bucketFor = (input) => {
+    validateLocation(input.location);
+    return selectReportingRowClient(options.storage, clients, input.credentialRef).bucket(input.location.bucket);
+  };
+  const assertKey = (key) => {
+    if (typeof key !== "string" || key.length === 0 || Buffer.byteLength(key) > 1024) {
+      throw new ReportingRowStoreError("INVALID_INPUT", "object key is invalid");
+    }
+  };
+  return {
+    name: "gcs",
+    rangedReads: true,
+    validateLocation,
+    probe(input, context) {
+      return runReportingRowProviderOperation(context.signal, async () => {
+        const bucket = bucketFor(input);
+        let metadata;
+        try {
+          [metadata] = await bucket.getMetadata();
+        } catch (error) {
+          const code = status(error);
+          if (code === 404) throw new ReportingRowStoreError("UNSAFE_BINDING", "bucket does not exist");
+          if (code === 401 || code === 403) {
+            throw new ReportingRowStoreError("UNSAFE_BINDING", "bucket policy cannot be read with this client");
+          }
+          throw error;
+        }
+        assertGcsReportingRowBucketPolicyV1(metadata, input.prefix);
+      });
+    },
+    putIfAbsent(input, context) {
+      return runReportingRowProviderOperation(context.signal, async () => {
+        const bucket = bucketFor(input);
+        assertKey(input.key);
+        const file = bucket.file(input.key);
+        try {
+          const bytes = Buffer.from(input.bytes);
+          await file.save(bytes, {
+            resumable: false,
+            gzip: false,
+            // GCS verifies the declared MD5 before creating the object, so a corrupted upload
+            // is refused server-side. Client-side validation is off because on mismatch the
+            // client deletes the key without a generation precondition.
+            validation: false,
+            contentType: input.contentType,
+            metadata: {
+              contentType: input.contentType,
+              md5Hash: createHash("md5").update(bytes).digest("base64"),
+              cacheControl: "no-store",
+              metadata: { ...input.metadata }
+            },
+            preconditionOpts: { ifGenerationMatch: 0 }
+          });
+        } catch (error) {
+          if (status(error) !== 412) throw error;
+          context.signal.throwIfAborted();
+          const [existing] = await bucket.file(input.key).getMetadata();
+          return { created: false, nativeVersion: generationOf(existing) };
+        }
+        if (file.metadata?.generation !== void 0) {
+          return { created: true, nativeVersion: generationOf(file.metadata) };
+        }
+        const [created] = await file.getMetadata();
+        return { created: true, nativeVersion: generationOf(created) };
+      });
+    },
+    get(input, context) {
+      return runReportingRowProviderOperation(context.signal, async () => {
+        const bucket = bucketFor(input);
+        assertKey(input.key);
+        assertReportingRowReadBounds(input);
+        const generation = pinnedGeneration(input.nativeVersion);
+        if (generation === null) return null;
+        const file = bucket.file(input.key, { generation });
+        try {
+          if (input.range?.length === 0) {
+            const [metadata] = await file.getMetadata();
+            if (input.range.offset > Number(metadata.size)) {
+              throw new ReportingRowStoreError("ROWS_INTEGRITY_FAILED", "requested range exceeds the stored object");
+            }
+            return Buffer.alloc(0);
+          }
+          const stream = file.createReadStream({
+            // The client always sends `Accept-Encoding: gzip`; with `decompress: false`
+            // neither GCS nor the client transcodes, so these are the stored bytes.
+            decompress: false,
+            // Digests recorded in PostgreSQL verify every byte returned.
+            validation: false,
+            ...input.range ? { start: input.range.offset, end: input.range.offset + input.range.length - 1 } : {}
+          });
+          return await readReportingRowStream(stream, input.maxBytes, context.signal);
+        } catch (error) {
+          const code = status(error);
+          if (code === 404) return null;
+          if (code === 416) {
+            throw new ReportingRowStoreError("ROWS_INTEGRITY_FAILED", "requested range exceeds the stored object");
+          }
+          throw error;
+        }
+      });
+    },
+    delete(input, context) {
+      return runReportingRowProviderOperation(context.signal, async () => {
+        const bucket = bucketFor(input);
+        assertKey(input.key);
+        const generation = pinnedGeneration(input.nativeVersion);
+        if (generation === null) return "absent";
+        try {
+          await bucket.file(input.key, { generation }).delete();
+          return "deleted";
+        } catch (error) {
+          const code = status(error);
+          if (code === 404 || code === 412) return "absent";
+          throw error;
+        }
+      });
+    }
+  };
+}
+export {
+  assertGcsReportingRowBucketPolicyV1,
+  createGcsReportingRowObjectProviderV1
+};

package/dist/lib/reporting/ledger/change-feed.d.mts

@@ -0,0 +1,41 @@
+/**
+ * Host-facing reporting change feed (shared SDK persistence spec,
+ * adcontextprotocol/adcp#7996 §2.1 and §3.7).
+ *
+ * Apply after {@link REPORTING_LEDGER_MIGRATION}; PostgreSQL 13 or later
+ * (`xid8`). The store appends one row per committed obligation, revision,
+ * adjustment and retirement in the same transaction as the record, taking the
+ * sequence value only after the account lock, so per-account sequence order is
+ * commit order. Deployment-wide readers order by `(xid, seq)` and stop below
+ * the reading snapshot's `xmin`, so a slow commit is never skipped.
+ */
+export declare const REPORTING_LEDGER_CHANGES_MIGRATION: string;
+export type ReportingChangeKindV1 = 'obligation' | 'revision' | 'adjustment' | 'retirement';
+export interface ReportingChangeRecordV1 {
+    kind: ReportingChangeKindV1;
+    record_id: string;
+    reporting_obligation_id: string;
+    account_id: string;
+    recorded_at: string;
+}
+export interface ReportingChangesPageV1 {
+    records: ReportingChangeRecordV1[];
+    /** Pass back to resume. Always present; equal to the input when nothing new committed. */
+    cursor: string;
+}
+interface ChangeCursorV1 {
+    v: 1;
+    /** Account scope, or `null` for the deployment-wide feed. */
+    account: string | null;
+    seq: string;
+    /** Deployment-wide feeds only: the writing transaction of the last record returned. */
+    xid?: string;
+}
+export declare function encodeReportingChangeCursorV1(cursor: ChangeCursorV1): string;
+export declare function decodeReportingChangeCursorV1(value: string, account: string | null): ChangeCursorV1;
+/** Thrown when a change cursor is older than the retained change history. */
+export declare class ReportingChangeCursorExpiredError extends Error {
+    readonly code: "CURSOR_EXPIRED";
+    constructor();
+}
+export {};

package/dist/lib/reporting/ledger/change-feed.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Host-facing reporting change feed (shared SDK persistence spec,
+ * adcontextprotocol/adcp#7996 §2.1 and §3.7).
+ *
+ * Apply after {@link REPORTING_LEDGER_MIGRATION}; PostgreSQL 13 or later
+ * (`xid8`). The store appends one row per committed obligation, revision,
+ * adjustment and retirement in the same transaction as the record, taking the
+ * sequence value only after the account lock, so per-account sequence order is
+ * commit order. Deployment-wide readers order by `(xid, seq)` and stop below
+ * the reading snapshot's `xmin`, so a slow commit is never skipped.
+ */
+export declare const REPORTING_LEDGER_CHANGES_MIGRATION: string;
+export type ReportingChangeKindV1 = 'obligation' | 'revision' | 'adjustment' | 'retirement';
+export interface ReportingChangeRecordV1 {
+    kind: ReportingChangeKindV1;
+    record_id: string;
+    reporting_obligation_id: string;
+    account_id: string;
+    recorded_at: string;
+}
+export interface ReportingChangesPageV1 {
+    records: ReportingChangeRecordV1[];
+    /** Pass back to resume. Always present; equal to the input when nothing new committed. */
+    cursor: string;
+}
+interface ChangeCursorV1 {
+    v: 1;
+    /** Account scope, or `null` for the deployment-wide feed. */
+    account: string | null;
+    seq: string;
+    /** Deployment-wide feeds only: the writing transaction of the last record returned. */
+    xid?: string;
+}
+export declare function encodeReportingChangeCursorV1(cursor: ChangeCursorV1): string;
+export declare function decodeReportingChangeCursorV1(value: string, account: string | null): ChangeCursorV1;
+/** Thrown when a change cursor is older than the retained change history. */
+export declare class ReportingChangeCursorExpiredError extends Error {
+    readonly code: "CURSOR_EXPIRED";
+    constructor();
+}
+export {};

package/dist/lib/reporting/ledger/change-feed.js

@@ -0,0 +1,101 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var change_feed_exports = {};
+__export(change_feed_exports, {
+  REPORTING_LEDGER_CHANGES_MIGRATION: () => REPORTING_LEDGER_CHANGES_MIGRATION,
+  ReportingChangeCursorExpiredError: () => ReportingChangeCursorExpiredError,
+  decodeReportingChangeCursorV1: () => decodeReportingChangeCursorV1,
+  encodeReportingChangeCursorV1: () => encodeReportingChangeCursorV1
+});
+module.exports = __toCommonJS(change_feed_exports);
+var import_row_storage_errors = require('./row-storage-errors.js');
+const REPORTING_LEDGER_CHANGES_MIGRATION = `
+CREATE TABLE IF NOT EXISTS adcp_reporting_changes (
+  seq BIGSERIAL PRIMARY KEY,
+  xid xid8 NOT NULL DEFAULT pg_current_xact_id(),
+  account_id TEXT NOT NULL,
+  record_kind TEXT NOT NULL
+    CHECK (record_kind IN ('obligation', 'revision', 'adjustment', 'retirement')),
+  record_id TEXT NOT NULL,
+  obligation_id TEXT NOT NULL,
+  recorded_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp()
+);
+CREATE INDEX IF NOT EXISTS adcp_reporting_changes_account
+  ON adcp_reporting_changes (account_id, seq);
+CREATE INDEX IF NOT EXISTS adcp_reporting_changes_deployment
+  ON adcp_reporting_changes (xid, seq);
+CREATE INDEX IF NOT EXISTS adcp_reporting_changes_recorded
+  ON adcp_reporting_changes (recorded_at, seq);
+
+-- Highest (xid, seq) ever pruned: a deployment-wide cursor below it may have
+-- missed a deleted change and fails closed.
+CREATE TABLE IF NOT EXISTS adcp_reporting_change_horizon (
+  singleton BOOLEAN PRIMARY KEY DEFAULT TRUE CHECK (singleton),
+  pruned_through_xid xid8 NOT NULL DEFAULT '0',
+  pruned_through_seq BIGINT NOT NULL DEFAULT 0
+);
+INSERT INTO adcp_reporting_change_horizon (singleton) VALUES (TRUE) ON CONFLICT DO NOTHING;
+
+-- Highest seq ever pruned per account: an account cursor below it fails closed.
+CREATE TABLE IF NOT EXISTS adcp_reporting_change_account_horizon (
+  account_id TEXT PRIMARY KEY,
+  pruned_through_seq BIGINT NOT NULL
+);
+
+-- Registered consumers hold back pruning in their own feed order: account
+-- consumers by seq within their account, deployment consumers by (xid, seq).
+CREATE TABLE IF NOT EXISTS adcp_reporting_feed_consumers (
+  consumer_name TEXT PRIMARY KEY CHECK (consumer_name ~ '^[A-Za-z0-9_.:-]{1,128}$'),
+  account_id TEXT,
+  cursor_xid xid8,
+  cursor_seq BIGINT NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp(),
+  CHECK ((account_id IS NULL) = (cursor_xid IS NOT NULL))
+);
+`.trim();
+function encodeReportingChangeCursorV1(cursor) {
+  return Buffer.from(JSON.stringify(cursor), "utf8").toString("base64url");
+}
+function decodeReportingChangeCursorV1(value, account) {
+  let parsed;
+  try {
+    parsed = JSON.parse(Buffer.from(value, "base64url").toString("utf8"));
+  } catch {
+    throw new import_row_storage_errors.ReportingRowStoreError("INVALID_INPUT", "change cursor is malformed");
+  }
+  const cursor = parsed;
+  if (cursor.v !== 1 || (cursor.account ?? null) !== account || typeof cursor.seq !== "string" || !/^\d{1,19}$/.test(cursor.seq) || (account === null ? typeof cursor.xid !== "string" || !/^\d{1,20}$/.test(cursor.xid) : cursor.xid !== void 0)) {
+    throw new import_row_storage_errors.ReportingRowStoreError("INVALID_INPUT", "change cursor does not belong to this feed");
+  }
+  return cursor;
+}
+class ReportingChangeCursorExpiredError extends Error {
+  code = "CURSOR_EXPIRED";
+  constructor() {
+    super("Reporting change cursor is older than the retained change history; resynchronize from current revisions");
+    this.name = "ReportingChangeCursorExpiredError";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  REPORTING_LEDGER_CHANGES_MIGRATION,
+  ReportingChangeCursorExpiredError,
+  decodeReportingChangeCursorV1,
+  encodeReportingChangeCursorV1
+});

package/dist/lib/reporting/ledger/change-feed.mjs

@@ -0,0 +1,74 @@
+import { ReportingRowStoreError } from "./row-storage-errors.mjs";
+const REPORTING_LEDGER_CHANGES_MIGRATION = `
+CREATE TABLE IF NOT EXISTS adcp_reporting_changes (
+  seq BIGSERIAL PRIMARY KEY,
+  xid xid8 NOT NULL DEFAULT pg_current_xact_id(),
+  account_id TEXT NOT NULL,
+  record_kind TEXT NOT NULL
+    CHECK (record_kind IN ('obligation', 'revision', 'adjustment', 'retirement')),
+  record_id TEXT NOT NULL,
+  obligation_id TEXT NOT NULL,
+  recorded_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp()
+);
+CREATE INDEX IF NOT EXISTS adcp_reporting_changes_account
+  ON adcp_reporting_changes (account_id, seq);
+CREATE INDEX IF NOT EXISTS adcp_reporting_changes_deployment
+  ON adcp_reporting_changes (xid, seq);
+CREATE INDEX IF NOT EXISTS adcp_reporting_changes_recorded
+  ON adcp_reporting_changes (recorded_at, seq);
+
+-- Highest (xid, seq) ever pruned: a deployment-wide cursor below it may have
+-- missed a deleted change and fails closed.
+CREATE TABLE IF NOT EXISTS adcp_reporting_change_horizon (
+  singleton BOOLEAN PRIMARY KEY DEFAULT TRUE CHECK (singleton),
+  pruned_through_xid xid8 NOT NULL DEFAULT '0',
+  pruned_through_seq BIGINT NOT NULL DEFAULT 0
+);
+INSERT INTO adcp_reporting_change_horizon (singleton) VALUES (TRUE) ON CONFLICT DO NOTHING;
+
+-- Highest seq ever pruned per account: an account cursor below it fails closed.
+CREATE TABLE IF NOT EXISTS adcp_reporting_change_account_horizon (
+  account_id TEXT PRIMARY KEY,
+  pruned_through_seq BIGINT NOT NULL
+);
+
+-- Registered consumers hold back pruning in their own feed order: account
+-- consumers by seq within their account, deployment consumers by (xid, seq).
+CREATE TABLE IF NOT EXISTS adcp_reporting_feed_consumers (
+  consumer_name TEXT PRIMARY KEY CHECK (consumer_name ~ '^[A-Za-z0-9_.:-]{1,128}$'),
+  account_id TEXT,
+  cursor_xid xid8,
+  cursor_seq BIGINT NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp(),
+  CHECK ((account_id IS NULL) = (cursor_xid IS NOT NULL))
+);
+`.trim();
+function encodeReportingChangeCursorV1(cursor) {
+  return Buffer.from(JSON.stringify(cursor), "utf8").toString("base64url");
+}
+function decodeReportingChangeCursorV1(value, account) {
+  let parsed;
+  try {
+    parsed = JSON.parse(Buffer.from(value, "base64url").toString("utf8"));
+  } catch {
+    throw new ReportingRowStoreError("INVALID_INPUT", "change cursor is malformed");
+  }
+  const cursor = parsed;
+  if (cursor.v !== 1 || (cursor.account ?? null) !== account || typeof cursor.seq !== "string" || !/^\d{1,19}$/.test(cursor.seq) || (account === null ? typeof cursor.xid !== "string" || !/^\d{1,20}$/.test(cursor.xid) : cursor.xid !== void 0)) {
+    throw new ReportingRowStoreError("INVALID_INPUT", "change cursor does not belong to this feed");
+  }
+  return cursor;
+}
+class ReportingChangeCursorExpiredError extends Error {
+  code = "CURSOR_EXPIRED";
+  constructor() {
+    super("Reporting change cursor is older than the retained change history; resynchronize from current revisions");
+    this.name = "ReportingChangeCursorExpiredError";
+  }
+}
+export {
+  REPORTING_LEDGER_CHANGES_MIGRATION,
+  ReportingChangeCursorExpiredError,
+  decodeReportingChangeCursorV1,
+  encodeReportingChangeCursorV1
+};

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

@@ -36,6 +36,7 @@ var import_coverage = require('./coverage.js');
 var import_health = require('./health.js');
 var import_instant = require('./instant.js');
 var import_revision_metadata = require('./revision-metadata.js');
+var import_row_storage = require('./row-storage.js');
 var import_schedule = require('./schedule.js');
 var import_types = require('./types.js');
 function createReportingStatusHandler(store, options) {
@@ -267,7 +268,9 @@ function createReportingStatusHandler(store, options) {
               else revisionRows = page2.rows;
             }
           } catch (error) {
-            if (error instanceof ReportingReadCapacityError) return lookupUnavailable(view);
+            if (error instanceof ReportingReadCapacityError || (0, import_row_storage.isReportingRowStoreError)(error)) {
+              return lookupUnavailable(view);
+            }
             throw error;
           }
         }
@@ -450,13 +453,24 @@ function createReportingDeliveryHandler(store) {
       }
       let reportingRows = [];
       if (totalCount > 0) {
-        const page = await (0, import_revision_metadata.readRevisionRowsFromStore)(store, {
-          reporting_revision_id: revision.reporting_revision_id,
-          account_id: accountId,
-          offset,
-          limit: maxResults,
-          ...context.signal ? { signal: context.signal } : {}
-        });
+        let page;
+        try {
+          page = await (0, import_revision_metadata.readRevisionRowsFromStore)(store, {
+            reporting_revision_id: revision.reporting_revision_id,
+            account_id: accountId,
+            offset,
+            limit: maxResults,
+            ...context.signal ? { signal: context.signal } : {}
+          });
+        } catch (error) {
+          if ((0, import_row_storage.isReportingRowStoreError)(error)) {
+            if (error.code === "ROWS_EXPIRED") throw new Error("Reporting revision is unavailable");
+            throw new import_async_outcome.AdcpError("SERVICE_UNAVAILABLE", {
+              message: "Reporting revision rows are temporarily unavailable"
+            });
+          }
+          throw error;
+        }
         if (!page || page.total !== totalCount) throw new Error("Reporting revision is unavailable");
         reportingRows = page.rows;
       }

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

@@ -19,6 +19,7 @@ import {
 } from "./health.mjs";
 import { compareReportingInstants } from "./instant.mjs";
 import { getRevisionMetadataFromStore, readRevisionRowsFromStore } from "./revision-metadata.mjs";
+import { isReportingRowStoreError } from "./row-storage.mjs";
 import { reportingPeriodSchedule } from "./schedule.mjs";
 import { ReportingLedgerSnapshotUnavailableError } from "./types.mjs";
 function createReportingStatusHandler(store, options) {
@@ -250,7 +251,9 @@ function createReportingStatusHandler(store, options) {
               else revisionRows = page2.rows;
             }
           } catch (error) {
-            if (error instanceof ReportingReadCapacityError) return lookupUnavailable(view);
+            if (error instanceof ReportingReadCapacityError || isReportingRowStoreError(error)) {
+              return lookupUnavailable(view);
+            }
             throw error;
           }
         }
@@ -433,13 +436,24 @@ function createReportingDeliveryHandler(store) {
       }
       let reportingRows = [];
       if (totalCount > 0) {
-        const page = await readRevisionRowsFromStore(store, {
-          reporting_revision_id: revision.reporting_revision_id,
-          account_id: accountId,
-          offset,
-          limit: maxResults,
-          ...context.signal ? { signal: context.signal } : {}
-        });
+        let page;
+        try {
+          page = await readRevisionRowsFromStore(store, {
+            reporting_revision_id: revision.reporting_revision_id,
+            account_id: accountId,
+            offset,
+            limit: maxResults,
+            ...context.signal ? { signal: context.signal } : {}
+          });
+        } catch (error) {
+          if (isReportingRowStoreError(error)) {
+            if (error.code === "ROWS_EXPIRED") throw new Error("Reporting revision is unavailable");
+            throw new AdcpError("SERVICE_UNAVAILABLE", {
+              message: "Reporting revision rows are temporarily unavailable"
+            });
+          }
+          throw error;
+        }
         if (!page || page.total !== totalCount) throw new Error("Reporting revision is unavailable");
         reportingRows = page.rows;
       }

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

@@ -12,3 +12,7 @@ export * from './managed-postgres.mjs';
 export * from './object-writes.mjs';
 export * from './notification-activity.mjs';
 export * from './row-encoding.mjs';
+export * from './row-storage-migration.mjs';
+export * from './row-storage.mjs';
+export * from './row-storage-object.mjs';
+export * from './change-feed.mjs';

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

@@ -12,3 +12,7 @@ export * from './managed-postgres';
 export * from './object-writes';
 export * from './notification-activity';
 export * from './row-encoding';
+export * from './row-storage-migration';
+export * from './row-storage';
+export * from './row-storage-object';
+export * from './change-feed';

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

@@ -29,6 +29,10 @@ __reExport(ledger_exports, require('./managed-postgres.js'), module.exports);
 __reExport(ledger_exports, require('./object-writes.js'), module.exports);
 __reExport(ledger_exports, require('./notification-activity.js'), module.exports);
 __reExport(ledger_exports, require('./row-encoding.js'), module.exports);
+__reExport(ledger_exports, require('./row-storage-migration.js'), module.exports);
+__reExport(ledger_exports, require('./row-storage.js'), module.exports);
+__reExport(ledger_exports, require('./row-storage-object.js'), module.exports);
+__reExport(ledger_exports, require('./change-feed.js'), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ...require('./types.js'),
@@ -44,5 +48,9 @@ __reExport(ledger_exports, require('./row-encoding.js'), module.exports);
   ...require('./managed-postgres.js'),
   ...require('./object-writes.js'),
   ...require('./notification-activity.js'),
-  ...require('./row-encoding.js')
+  ...require('./row-encoding.js'),
+  ...require('./row-storage-migration.js'),
+  ...require('./row-storage.js'),
+  ...require('./row-storage-object.js'),
+  ...require('./change-feed.js')
 });

package/dist/lib/reporting/ledger/index.mjs

@@ -12,3 +12,7 @@ export * from "./managed-postgres.mjs";
 export * from "./object-writes.mjs";
 export * from "./notification-activity.mjs";
 export * from "./row-encoding.mjs";
+export * from "./row-storage-migration.mjs";
+export * from "./row-storage.mjs";
+export * from "./row-storage-object.mjs";
+export * from "./change-feed.mjs";

package/dist/lib/reporting/ledger/managed-postgres.d.mts

@@ -94,6 +94,8 @@ export declare class PostgresReportingManagedDeliveryStore implements ReportingM
     private validateRecoveryWindow;
     private readPolicyRow;
     private readPolicy;
+    /** Read-only access to PostgreSQL row chunks for claim hydration. */
+    private readonly rowStorage;
     constructor(pool: ReportingPgPool, options?: PostgresReportingManagedDeliveryStoreOptions);
     /** SQL fragment scoping a count to the active retention window, if one is set. */
     private activeScope;

package/dist/lib/reporting/ledger/managed-postgres.d.ts

@@ -94,6 +94,8 @@ export declare class PostgresReportingManagedDeliveryStore implements ReportingM
     private validateRecoveryWindow;
     private readPolicyRow;
     private readPolicy;
+    /** Read-only access to PostgreSQL row chunks for claim hydration. */
+    private readonly rowStorage;
     constructor(pool: ReportingPgPool, options?: PostgresReportingManagedDeliveryStoreOptions);
     /** SQL fragment scoping a count to the active retention window, if one is set. */
     private activeScope;