@adcp/sdk 16.0.0-beta.2 → 16.0.0-beta.4

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

@@ -1,21 +1,7 @@
 import { scanArgsForCredentials } from "../../server/credential-policy.mjs";
 import { canonicalize } from "../../utils/jcs.mjs";
-import { redactCredentialPatterns } from "../../utils/redact-credential-patterns.mjs";
-import { ReportingDeliveryCapabilitiesSchema, ReportingDeliveryOfferingSchema } from "../../types/schemas.generated.mjs";
+import { ReportingDeliveryOfferingSchema } from "../../types/schemas.generated.mjs";
 import {
-  createPostgresPersistentNotificationRuntime
-} from "../../server/notification-subscriptions/index.mjs";
-import {
-  REPORTING_LEDGER_MIGRATION,
-  REPORTING_MANAGED_DELIVERY_MIGRATION,
-  REPORTING_ROW_STORAGE_MIGRATION,
-  REPORTING_LEDGER_CHANGES_MIGRATION,
-  PostgresReportingLedgerStore,
-  sweepExpiredReportingLedgerState,
-  PostgresReportingManagedDeliveryStore,
-  createPostgresReportingNotificationActivityRuntime,
-  createPostgresReportingNotificationAttemptCheckpoint,
-  createReportingManagedDeliveryRuntime,
   assertReportingConsumerMismatchEscalation,
   reportingConsumerStatusCapabilityV1,
   reportingEffectiveConsumerMismatchEscalationV1,
@@ -25,15 +11,11 @@ import {
   createSyncReportingStatusHandler
 } from "../ledger/index.mjs";
 import {
-  composeNotificationDeliveryAttemptCheckpoints,
-  composeWebhookAttemptResultObservers,
-  createPostgresReportingWebhookActivityV1,
-  projectListAccountsReportingWebhookActivityV1
-} from "../webhook-activity.mjs";
-import {
-  assertReportingLedgerMaintenanceOptions,
-  runReportingLedgerMaintenance
-} from "./maintenance.mjs";
+  reportReportingSchedulerError,
+  reportingDeploymentWideAccountIds,
+  reportingSchedulerDelay,
+  rotateReportingRoster
+} from "./scheduler-support.mjs";
 import { assertReportingCalendarDaySource, reportingCalendarDayOrigin } from "../ledger/schedule.mjs";
 import {
   ReportingCoverageConstituentIdentityV1Schema,
@@ -48,10 +30,11 @@ import {
   reportingSourceCapabilitiesV1
 } from "../source/index.mjs";
 const ADAPTER_SCOPE_KEY = "_adcp_reporting_adapter";
-const PRODUCTION_MANAGED_COMPOSITION = /* @__PURE__ */ Symbol("production-managed-reporting-composition");
-const DEFAULT_MAINTENANCE_INTERVAL_MILLISECONDS = 3e5;
+const REPORTING_MANAGED_DELIVERY_COMPOSITION_V1 = /* @__PURE__ */ Symbol.for(
+  "@adcp/sdk/reporting/managed-delivery-composition"
+);
 function createReliableReportingService(options) {
-  const allowManagedDelivery = options[PRODUCTION_MANAGED_COMPOSITION] === true;
+  const allowManagedDelivery = options[REPORTING_MANAGED_DELIVERY_COMPOSITION_V1] === options.store;
   const adapterEntries = Object.entries(options.adapters);
   if (adapterEntries.length === 0) throw new TypeError("Reliable reporting requires at least one adapter");
   positiveInteger(options.automatedRecoveryWindowSeconds, "automatedRecoveryWindowSeconds");
@@ -111,52 +94,25 @@ function createReliableReportingService(options) {
   if (hasConsumerStatus) assertConsumerStatusStore(options.store);
   const retentionDays = options.statusRetentionDays;
   positiveInteger(retentionDays, "statusRetentionDays");
-  const maintenance = options.maintenance;
-  let maintenanceStore;
-  let maintenanceIntervalMilliseconds = DEFAULT_MAINTENANCE_INTERVAL_MILLISECONDS;
-  if (maintenance !== void 0) {
-    if (maintenance === null || typeof maintenance !== "object") {
-      throw new TypeError("maintenance must be an options object");
-    }
-    const candidate = options.store;
-    for (const method of [
-      "retireExpiredPeriods",
-      "pruneChanges",
-      "sweepRowWriteIntents",
-      ...maintenance.compaction ? ["compactSupersededSnapshots"] : []
-    ]) {
-      if (typeof candidate[method] !== "function") {
-        throw new TypeError(
-          `maintenance requires a PostgresReportingLedgerStore (or a store with ${method}); the configured store cannot run ledger maintenance`
-        );
-      }
-    }
-    maintenanceStore = candidate;
-    if (maintenance.compaction) {
-      candidate.assertCompactionSafeRowBindings?.();
-    }
-    if (maintenance.changeFeed && maintenanceStore.changeFeedEnabled === false) {
+  let maintenance;
+  if (options.maintenance !== void 0) {
+    if (typeof options.maintenance !== "function") {
       throw new TypeError(
-        "maintenance.changeFeed requires the store to be built with changeFeed: true; otherwise pruning silently does nothing"
+        "createReliableReportingService: `maintenance` must be a factory, not an options object. For a PostgreSQL ledger wrap your options with `reportingLedgerMaintenance({ ... })` from the `@adcp/reporting-storage` package, for example `maintenance: reportingLedgerMaintenance({ retention: { enabled: true } })`. See docs/migration-reporting-storage-package.md."
       );
     }
-    if (maintenance.intervalMilliseconds !== void 0) {
-      positiveInteger(maintenance.intervalMilliseconds, "maintenance.intervalMilliseconds");
-      maintenanceIntervalMilliseconds = maintenance.intervalMilliseconds;
+    maintenance = options.maintenance({
+      store: options.store,
+      statusRetentionDays: retentionDays,
+      automatedRecoveryWindowSeconds: options.automatedRecoveryWindowSeconds
+    });
+    if (!maintenance || typeof maintenance.run !== "function" || !Number.isSafeInteger(maintenance.intervalMilliseconds) || maintenance.intervalMilliseconds <= 0) {
+      throw new TypeError(
+        "maintenance factory must return { intervalMilliseconds: positive integer, run(): Promise<results> }"
+      );
     }
-    assertReportingLedgerMaintenanceOptions(maintenance, retentionDays);
   }
-  const runLedgerMaintenance = (signal, report) => runReportingLedgerMaintenance({
-    store: maintenanceStore,
-    ...typeof maintenanceStore.sweepExpiredState === "function" ? { sweepSnapshots: (limit) => maintenanceStore.sweepExpiredState(limit) } : {},
-    statusRetentionDays: retentionDays,
-    automatedRecoveryWindowSeconds: options.automatedRecoveryWindowSeconds,
-    retention: maintenance.retention,
-    compaction: maintenance.compaction,
-    changeFeed: maintenance.changeFeed,
-    signal,
-    ...report ? { report } : {}
-  });
+  const runLedgerMaintenance = (signal, report) => maintenance.run({ signal, ...report ? { report } : {} });
   const capabilities = deepFreeze({
     supported: true,
     reliable_reporting_version: "1.0",
@@ -197,7 +153,7 @@ function createReliableReportingService(options) {
   const service = {
     setup: Object.freeze({
       component: "reliable-reporting-core",
-      migrations: Object.freeze([REPORTING_LEDGER_MIGRATION]),
+      migrations: Object.freeze([...options.store.migrations ?? []]),
       requiresIsolatedLedgerDatabaseAcknowledgement: true
     }),
     capabilities,
@@ -345,10 +301,10 @@ function createReliableReportingService(options) {
       schedulerAbort = new AbortController();
       const signal = schedulerAbort.signal;
       const scheduledMaintenance = maintenance === void 0 ? void 0 : {
-        intervalMilliseconds: maintenanceIntervalMilliseconds,
+        intervalMilliseconds: maintenance.intervalMilliseconds,
         run: () => runLedgerMaintenance(
           signal,
-          (error) => reportSchedulerError(scheduler, signal, error, { phase: "maintenance" })
+          (error) => reportReportingSchedulerError(scheduler, signal, error, { phase: "maintenance" })
         )
       };
       schedulerPromise = schedulerLoop(service, scheduler, signal, options.store, scheduledMaintenance).finally(() => {
@@ -364,346 +320,6 @@ function createReliableReportingService(options) {
   };
   return service;
 }
-async function createPostgresReliableReportingProductionService(options) {
-  if (!options.db || typeof options.db.query !== "function" || typeof options.db.connect !== "function") {
-    throw new TypeError("Reliable Reporting production service requires a PostgreSQL pool");
-  }
-  if (!/^[A-Za-z0-9_.:-]{1,255}$/.test(options.namespace)) {
-    throw new TypeError("Reliable Reporting production namespace must be a bounded non-secret identifier");
-  }
-  if (!/^[A-Za-z0-9_.:-]{1,255}$/.test(options.publisherScope)) {
-    throw new TypeError("Reliable Reporting publisherScope must be a bounded non-secret identifier");
-  }
-  if (typeof options.resolveWebhookActivityScope !== "function") {
-    throw new TypeError("Reliable Reporting production service requires resolveWebhookActivityScope");
-  }
-  if (typeof options.activity?.tenantScopeForAccount !== "function") {
-    throw new TypeError("Reliable Reporting production service requires activity.tenantScopeForAccount");
-  }
-  assertReportingLedgerMaintenanceOptions({ compaction: options.compaction }, options.statusRetentionDays);
-  if (Object.values(options.adapters).some(
-    (adapter) => adapter.deliveryOffering.reconciliation_mode === "consumer_receipt"
-  ) && typeof options.obligatedConsumers !== "function") {
-    throw new TypeError("Reconciled Billing production offerings require a trusted obligatedConsumers roster");
-  }
-  const recipientCheckpoint = createPostgresReportingNotificationAttemptCheckpoint({
-    db: options.db,
-    namespace: options.namespace,
-    ...options.activity?.tableName !== void 0 ? { tableName: options.activity.tableName } : {}
-  });
-  const webhookActivity = createPostgresReportingWebhookActivityV1({
-    db: options.db,
-    namespace: options.namespace,
-    ...options.webhookActivity?.tableName !== void 0 ? { tableName: options.webhookActivity.tableName } : {},
-    ...options.webhookActivity?.retentionDays !== void 0 ? { retentionDays: options.webhookActivity.retentionDays } : {}
-  });
-  const composedAttemptCheckpoint = composeNotificationDeliveryAttemptCheckpoints(
-    recipientCheckpoint,
-    webhookActivity.checkpointDeliveryAttempt
-  );
-  const attemptCheckpoint = Object.assign(
-    async (input) => composedAttemptCheckpoint(input),
-    { activityStore: recipientCheckpoint.activityStore }
-  );
-  const adopterAttemptResult = options.notifications.webhooks.onAttemptResult;
-  const adopterAttemptObserverError = options.notifications.webhooks.onAttemptObserverError;
-  const notifications = createPostgresPersistentNotificationRuntime({
-    ...options.notifications,
-    db: options.db,
-    publisherScope: options.publisherScope,
-    checkpointDeliveryAttempt: attemptCheckpoint,
-    supportedAccountEventTypes: ["reporting.ledger_changed", "reporting.status_changed", "reporting.delivery_ready"],
-    webhooks: {
-      ...options.notifications.webhooks,
-      onAttemptResult: composeWebhookAttemptResultObservers(
-        webhookActivity.emitterObservers.onAttemptResult,
-        adopterAttemptResult
-      ),
-      onAttemptObserverError(error, phase) {
-        if (adopterAttemptObserverError) {
-          try {
-            adopterAttemptObserverError(error, phase);
-            return;
-          } catch (observerError) {
-            console.warn(
-              `[adcp/reporting] webhook observer-error hook failed: ${safeMessage(observerError)}; original: ${safeMessage(error)}`
-            );
-            return;
-          }
-        }
-        console.warn(`[adcp/reporting] webhook ${phase} observer failed: ${safeMessage(error)}`);
-      }
-    }
-  });
-  const notificationActivity = createPostgresReportingNotificationActivityRuntime({
-    ...options.activity,
-    db: options.db,
-    notifications,
-    namespace: options.namespace,
-    attemptCheckpoint,
-    tenantScopeForAccount: options.activity.tenantScopeForAccount
-  });
-  const coreStore = new PostgresReportingLedgerStore(options.db, {
-    acknowledgeIsolatedDatabase: options.acknowledgeIsolatedDatabase,
-    managedDelivery: true,
-    ...options.obligatedConsumers ? { obligatedConsumers: options.obligatedConsumers } : {},
-    ...options.consumerMismatchEscalation ? { consumerMismatchEscalation: options.consumerMismatchEscalation } : {},
-    notificationActivityPort: notificationActivity.port,
-    ...options.rowStorage ? { rowStorage: options.rowStorage } : {},
-    ...options.changeFeed ? { changeFeed: true } : {}
-  });
-  if (options.compaction) coreStore.assertCompactionSafeRowBindings();
-  const managedStore = new PostgresReportingManagedDeliveryStore(options.db, {
-    ...options.managedDelivery.store,
-    statusRetentionDays: options.statusRetentionDays,
-    advertisedRecoveryWindowSeconds: options.automatedRecoveryWindowSeconds,
-    notificationActivityPort: notificationActivity.port
-  });
-  const coreOptions = {
-    ...options,
-    store: coreStore,
-    [PRODUCTION_MANAGED_COMPOSITION]: true
-  };
-  const core = createReliableReportingService(coreOptions);
-  const migrations = Object.freeze([
-    REPORTING_LEDGER_MIGRATION,
-    ...options.rowStorage ? [REPORTING_ROW_STORAGE_MIGRATION] : [],
-    ...options.changeFeed ? [REPORTING_LEDGER_CHANGES_MIGRATION] : [],
-    REPORTING_MANAGED_DELIVERY_MIGRATION,
-    ...notifications.migrations.all,
-    ...notificationActivity.migrations.all,
-    ...webhookActivity.migrations.all
-  ]);
-  await options.applyMigrations?.(migrations);
-  await coreStore.readyRowStorage();
-  await notifications.probe();
-  await notificationActivity.probe();
-  await webhookActivity.probe();
-  const managed = await createReportingManagedDeliveryRuntime({
-    coreStore,
-    ...options.legacyRevisionReader ? { legacyRevisionReader: options.legacyRevisionReader } : {},
-    store: managedStore,
-    adapter: options.managedDelivery.adapter,
-    offerings: core.capabilities.offerings,
-    automatedRecoveryWindowSeconds: options.automatedRecoveryWindowSeconds,
-    statusRetentionDays: options.statusRetentionDays,
-    resourceRetentionDays: options.managedDelivery.resourceRetentionDays,
-    authorizationRevocationSeconds: options.managedDelivery.authorizationRevocationSeconds,
-    ...options.resolveConsumerId ? { resolveConsumerId: options.resolveConsumerId } : {},
-    ...options.consumerMismatchEscalation ? { consumerMismatchEscalation: options.consumerMismatchEscalation } : {}
-  });
-  const capabilities = deepFreeze(
-    ReportingDeliveryCapabilitiesSchema.parse({
-      ...core.capabilities,
-      ...managed.reportingDeliveryCapabilities,
-      ledger_notification: "reporting.ledger_changed",
-      status_notification: "reporting.status_changed",
-      readiness_notification: "reporting.delivery_ready",
-      supports_webhook_activity: true
-    })
-  );
-  const platform = {
-    capabilities,
-    getReportingStatus: (request, context) => managed.getReportingStatus(request, context),
-    getMediaBuyDelivery: (request, context) => managed.getMediaBuyDelivery(request, context),
-    ...core.platform.syncReportingStatus ? {
-      syncReportingStatus: core.platform.syncReportingStatus,
-      resolveConsumerId: core.platform.resolveConsumerId
-    } : {},
-    ...managed.syncReportingReceipts ? {
-      syncReportingReceipts: (request, context) => managed.syncReportingReceipts(request, context)
-    } : {},
-    async projectListAccounts(request, response, context) {
-      const withoutDiagnostics = () => projectListAccountsReportingWebhookActivityV1({
-        request: { ...request, include_webhook_activity: false },
-        response,
-        tenantId: "diagnostics-not-requested",
-        principalId: "diagnostics-not-requested",
-        activity: webhookActivity
-      });
-      if (request.include_webhook_activity !== true) return withoutDiagnostics();
-      try {
-        const scope = await options.resolveWebhookActivityScope(context);
-        return await projectListAccountsReportingWebhookActivityV1({
-          request,
-          response,
-          tenantId: scope.tenantId,
-          principalId: scope.principalId,
-          activity: webhookActivity
-        });
-      } catch (error) {
-        defaultSchedulerWarn(`[adcp/reporting] webhook activity projection unavailable: ${safeMessage(error)}`);
-        return withoutDiagnostics();
-      }
-    }
-  };
-  let auxiliaryAbort;
-  let auxiliaryPromise;
-  let auxiliaryRotation = 0;
-  const reportAuxiliaryError = async (scheduler, error) => {
-    if (scheduler.onError) {
-      try {
-        await scheduler.onError(error);
-        return;
-      } catch (observerError) {
-        warnSchedulerFailure(scheduler, { phase: "cycle" }, error, observerError);
-        return;
-      }
-    }
-    warnSchedulerFailure(scheduler, { phase: "cycle" }, error);
-  };
-  const runAuxiliaryPass = async (scheduler, signal) => {
-    signal.throwIfAborted();
-    try {
-      const totalLimit = scheduler.notificationRecoveryLimit ?? 25;
-      const concurrency = Math.min(scheduler.notificationRecoveryConcurrency ?? 4, totalLimit);
-      const baseLimit = Math.floor(totalLimit / concurrency);
-      const remainder = totalLimit % concurrency;
-      await Promise.all(
-        Array.from(
-          { length: concurrency },
-          (_, index) => notificationActivity.recoverOnce({
-            limit: baseLimit + (index < remainder ? 1 : 0),
-            signal,
-            onError: (error) => reportAuxiliaryError(scheduler, error)
-          })
-        )
-      );
-    } catch (error) {
-      if (!signal.aborted) await reportAuxiliaryError(scheduler, error);
-    }
-    signal.throwIfAborted();
-    try {
-      await notifications.recoverOnce({ limit: scheduler.webhookRecoveryLimit ?? 10 });
-    } catch (error) {
-      if (!signal.aborted) await reportAuxiliaryError(scheduler, error);
-    }
-    signal.throwIfAborted();
-    const pruneResults = await Promise.allSettled([
-      notificationActivity.pruneProjected({ limit: 1e3 }),
-      webhookActivity.pruneCompleted({ limit: 1e3 })
-    ]);
-    for (const result of pruneResults) {
-      if (result.status === "rejected" && !signal.aborted) await reportAuxiliaryError(scheduler, result.reason);
-    }
-    await runReportingLedgerMaintenance({
-      store: coreStore,
-      sweepSnapshots: (limit) => sweepExpiredReportingLedgerState(options.db, limit),
-      statusRetentionDays: options.statusRetentionDays,
-      automatedRecoveryWindowSeconds: options.automatedRecoveryWindowSeconds,
-      retention: options.retention,
-      compaction: options.compaction,
-      changeFeed: options.changeFeed,
-      signal,
-      report: (error) => reportAuxiliaryError(scheduler, error)
-    });
-    const accountIds = rotate(await deploymentWideAccountIds(coreStore), auxiliaryRotation);
-    auxiliaryRotation += 1;
-    for (const accountId of accountIds) {
-      signal.throwIfAborted();
-      try {
-        await managed.runWorker({
-          signal,
-          ...accountId ? { account_id: accountId } : {},
-          ...scheduler.maxWorkerIterationsPerAccount !== void 0 ? { maxIterations: scheduler.maxWorkerIterationsPerAccount } : {}
-        });
-        if (accountId) await managedStore.pruneExpiredEvidence?.({ account_id: accountId, limit: 1e3 });
-      } catch (error) {
-        if (!signal.aborted) await reportAuxiliaryError(scheduler, error);
-      }
-    }
-  };
-  const service = {
-    setup: Object.freeze({ component: "reliable-reporting-production", migrations }),
-    capabilities,
-    platform,
-    core,
-    managed,
-    notifications,
-    notificationActivity,
-    webhookActivity,
-    stores: Object.freeze({ core: coreStore, managed: managedStore }),
-    get running() {
-      return core.running || auxiliaryPromise !== void 0;
-    },
-    installConfiguration: core.installConfiguration.bind(core),
-    install(target) {
-      if (typeof target.accounts.upsert !== "function") {
-        throw new TypeError("Reliable reporting requires accounts.upsert");
-      }
-      if (typeof target.accounts.list !== "function") {
-        throw new TypeError(
-          "Reliable reporting production webhook activity requires accounts.list so list_accounts can serve the advertised diagnostics"
-        );
-      }
-      if (target.reporting && target.reporting !== platform) {
-        throw new TypeError("DecisioningPlatform already has a reporting lifecycle installed");
-      }
-      if (!target.reporting) {
-        Object.defineProperty(target, "reporting", {
-          value: platform,
-          enumerable: true,
-          configurable: false,
-          writable: false
-        });
-      }
-      return target;
-    },
-    async runCycle(cycle) {
-      const coreResult = await core.runCycle(cycle);
-      const managedResult = await managed.runWorker({
-        ...cycle.signal ? { signal: cycle.signal } : {},
-        ...!cycle.deploymentWide ? { account_id: cycle.accountId } : {},
-        ...cycle.maxWorkerIterations !== void 0 ? { maxIterations: cycle.maxWorkerIterations } : {}
-      });
-      return { core: coreResult, managed: managedResult };
-    },
-    async recoverOnce(recoveryOptions) {
-      if (recoveryOptions?.deploymentWide !== true) {
-        throw new TypeError("Reliable Reporting production recovery requires deploymentWide: true");
-      }
-      const activityResult = await notificationActivity.recoverOnce();
-      const webhookOutbox = await notifications.recoverOnce();
-      return { activity: activityResult, webhookOutbox };
-    },
-    start(scheduler) {
-      if (auxiliaryPromise) throw new Error("Reliable Reporting production scheduler is already running");
-      if (scheduler.deploymentWide !== true) {
-        throw new TypeError("Reliable Reporting production scheduler requires deploymentWide: true");
-      }
-      if (scheduler.notificationRecoveryLimit !== void 0 && (!Number.isSafeInteger(scheduler.notificationRecoveryLimit) || scheduler.notificationRecoveryLimit < 1 || scheduler.notificationRecoveryLimit > 1e3)) {
-        throw new TypeError("notificationRecoveryLimit must be an integer from 1 through 1000");
-      }
-      if (scheduler.notificationRecoveryConcurrency !== void 0 && (!Number.isSafeInteger(scheduler.notificationRecoveryConcurrency) || scheduler.notificationRecoveryConcurrency < 1 || scheduler.notificationRecoveryConcurrency > 64)) {
-        throw new TypeError("notificationRecoveryConcurrency must be an integer from 1 through 64");
-      }
-      if (scheduler.webhookRecoveryLimit !== void 0 && (!Number.isSafeInteger(scheduler.webhookRecoveryLimit) || scheduler.webhookRecoveryLimit < 1 || scheduler.webhookRecoveryLimit > 1e3)) {
-        throw new TypeError("webhookRecoveryLimit must be an integer from 1 through 1000");
-      }
-      core.start(scheduler);
-      auxiliaryAbort = new AbortController();
-      const signal = auxiliaryAbort.signal;
-      auxiliaryPromise = (async () => {
-        while (!signal.aborted) {
-          try {
-            await runAuxiliaryPass(scheduler, signal);
-          } catch (error) {
-            if (!signal.aborted) await reportAuxiliaryError(scheduler, error);
-          }
-          if (!signal.aborted) await abortableDelay(scheduler.intervalMilliseconds, signal);
-        }
-      })().finally(() => {
-        auxiliaryAbort = void 0;
-        auxiliaryPromise = void 0;
-      });
-    },
-    async stop() {
-      auxiliaryAbort?.abort();
-      await Promise.all([core.stop(), auxiliaryPromise]);
-    }
-  };
-  return service;
-}
 function createRoutedSource(sources, offerings) {
   const capabilities = reportingSourceCapabilitiesV1([...offerings.values()], "reliable-reporting-service-v1");
   return {
@@ -734,15 +350,15 @@ async function schedulerLoop(service, options, signal, store, maintenance) {
         // it — the producer's own default cap starves the rest just as an
         // explicit per-account cap would. Enumerate the roster so each tenant
         // gets its own bounded cycle, and rotate the starting point each pass.
-        rotate(await deploymentWideAccountIds(store), rotation)
-      ) : rotate(
+        rotateReportingRoster(await reportingDeploymentWideAccountIds(store), rotation)
+      ) : rotateReportingRoster(
         validateAccountIds(
           typeof options.accountIds === "function" ? await options.accountIds() : options.accountIds
         ),
         rotation
       );
     } catch (error) {
-      await reportSchedulerError(options, signal, error, { phase: "roster" });
+      await reportReportingSchedulerError(options, signal, error, { phase: "roster" });
     }
     rotation += 1;
     for (const accountId of accountIds) {
@@ -758,7 +374,7 @@ async function schedulerLoop(service, options, signal, store, maintenance) {
           ...options.settlementGraceMilliseconds !== void 0 ? { settlementGraceMilliseconds: options.settlementGraceMilliseconds } : {}
         });
       } catch (error) {
-        await reportSchedulerError(options, signal, error, { phase: "cycle", accountId });
+        await reportReportingSchedulerError(options, signal, error, { phase: "cycle", accountId });
       }
     }
     if (maintenance && !signal.aborted && (lastMaintenanceAt === void 0 || Date.now() - lastMaintenanceAt >= maintenance.intervalMilliseconds)) {
@@ -766,99 +382,12 @@ async function schedulerLoop(service, options, signal, store, maintenance) {
       try {
         await maintenance.run();
       } catch (error) {
-        await reportSchedulerError(options, signal, error, { phase: "maintenance" });
+        await reportReportingSchedulerError(options, signal, error, { phase: "maintenance" });
       }
     }
-    if (!signal.aborted) await abortableDelay(options.intervalMilliseconds, signal);
+    if (!signal.aborted) await reportingSchedulerDelay(options.intervalMilliseconds, signal);
   }
 }
-async function reportSchedulerError(options, signal, error, site) {
-  if (signal.aborted) return;
-  if (options.onError) {
-    try {
-      await options.onError(error);
-    } catch (observerError) {
-      warnSchedulerFailure(options, site, error, observerError);
-    }
-    return;
-  }
-  warnSchedulerFailure(options, site, error);
-}
-function warnSchedulerFailure(options, site, error, observerError) {
-  const where = site.phase === "roster" ? "could not resolve its account roster, so this pass ran no tenants" : site.phase === "maintenance" ? "ledger maintenance failed; the scheduler continues" : site.accountId === void 0 ? "deployment-wide cycle failed; the scheduler continues" : `cycle failed for account ${site.accountId}; later tenants continue`;
-  const observed = observerError === void 0 ? "" : ` (the configured onError also threw: ${safeMessage(observerError)})`;
-  const message = `[adcp/reporting] scheduler ${where}: ${safeMessage(error)}${observed}`;
-  const logger = options.logger;
-  try {
-    if (logger !== void 0) logger.warn(message);
-    else defaultSchedulerWarn(message);
-  } catch {
-  }
-}
-function defaultSchedulerWarn(message) {
-  console.warn(message);
-}
-const MAX_SCHEDULER_MESSAGE_CHARS = 512;
-const MAX_SCHEDULER_SCAN_CHARS = 8192;
-const UNREPORTABLE_SCHEDULER_ERROR = "<unreportable error>";
-function safeMessage(error) {
-  try {
-    const raw = rawMessage(error);
-    const redacted = redactCredentialPatterns(raw.slice(0, MAX_SCHEDULER_SCAN_CHARS));
-    const text = typeof redacted === "string" && redacted.length > 0 ? redacted : UNREPORTABLE_SCHEDULER_ERROR;
-    return text.length > MAX_SCHEDULER_MESSAGE_CHARS ? `${text.slice(0, MAX_SCHEDULER_MESSAGE_CHARS)}\u2026` : text;
-  } catch {
-    return UNREPORTABLE_SCHEDULER_ERROR;
-  }
-}
-function rawMessage(error) {
-  switch (typeof error) {
-    case "string":
-      return error;
-    case "number":
-    case "boolean":
-    case "bigint":
-      return String(error);
-    case "undefined":
-      return "undefined";
-    case "symbol":
-      return error.description ?? "symbol";
-    default:
-      break;
-  }
-  if (error === null) return "null";
-  const message = error.message;
-  return typeof message === "string" ? message : "non-Error scheduler failure";
-}
-const MAX_TIMER_DELAY_MILLISECONDS = 2147483647;
-async function abortableDelay(milliseconds, signal) {
-  let remaining = milliseconds;
-  while (remaining > 0 && !signal.aborted) {
-    const chunk = Math.min(remaining, MAX_TIMER_DELAY_MILLISECONDS);
-    await abortableTimeout(chunk, signal);
-    remaining -= chunk;
-  }
-}
-function abortableTimeout(milliseconds, signal) {
-  return new Promise((resolve) => {
-    const timer = setTimeout(done, milliseconds);
-    function done() {
-      clearTimeout(timer);
-      signal.removeEventListener("abort", done);
-      resolve();
-    }
-    signal.addEventListener("abort", done, { once: true });
-  });
-}
-function rotate(values, by) {
-  if (values.length < 2) return [...values];
-  const offset = (by % values.length + values.length) % values.length;
-  return [...values.slice(offset), ...values.slice(0, offset)];
-}
-async function deploymentWideAccountIds(store) {
-  const configurations = await store.listConfigurations();
-  return [...new Set(configurations.map((value) => value.account.account_id))].sort();
-}
 function validateAccountIds(values) {
   if (!Array.isArray(values)) {
     throw new TypeError("Reporting scheduler accountIds resolver must return an array");
@@ -912,7 +441,7 @@ function validateDeliveryOffering(source, delivery, allowManagedDelivery = false
   }
   if (!allowManagedDelivery && (delivery.method !== void 0 || delivery.reconciliation_mode !== "delivery_only" || delivery.feed_purpose === "billing")) {
     throw new TypeError(
-      "Managed Delivery and Reconciled Billing require createPostgresReliableReportingProductionService from @adcp/sdk/reporting/service"
+      "Managed Delivery and Reconciled Billing require createPostgresReliableReportingProductionService from @adcp/reporting-storage/service"
     );
   }
   if (delivery.schedule.alignment !== "utc" && delivery.schedule.alignment !== "source_timezone") {
@@ -1254,11 +783,8 @@ function deepFreeze(value) {
   return value;
 }
 export * from "./conformance.mjs";
-import {
-  ReportingMaintenancePartialFailureError
-} from "./maintenance.mjs";
+export * from "./scheduler-support.mjs";
 export {
-  ReportingMaintenancePartialFailureError,
-  createPostgresReliableReportingProductionService,
+  REPORTING_MANAGED_DELIVERY_COMPOSITION_V1,
   createReliableReportingService
 };