@adcp/sdk 14.0.0 → 14.1.0

package/dist/lib/core/account-resolution.d.ts

@@ -16,6 +16,8 @@ export interface ResolveAccountOptions {
     forTask?: string;
     /** Billing party for buyer-declared accounts when the seller has no default. */
     billing?: 'operator' | 'agent' | 'advertiser';
+    paymentTerms?: import('../types/tools.generated').PaymentTerms;
+    billingEntity?: import('../types/tools.generated').BusinessEntity;
     /** An account_id or a callback choosing one of the eligible list_accounts rows. */
     select?: string | ((accounts: readonly ListedAccount[]) => string);
 }

package/dist/lib/core/buyer-account-registry.d.mts

@@ -0,0 +1,65 @@
+import type { AccountReference, BusinessEntity, PaymentTerms, SyncAccountsResponse } from '../types/tools.generated.mjs';
+import type { TaskOptions, TaskResult } from './ConversationTypes.mjs';
+export type AccountPolicy = 'auto' | 'strict' | 'off';
+export interface EnsureAccountOptions {
+    billing?: 'operator' | 'agent' | 'advertiser';
+    paymentTerms?: PaymentTerms;
+    billingEntity?: BusinessEntity;
+}
+export interface ProvisionedAccount {
+    account: AccountReference;
+    account_id?: string;
+    status: string;
+    pendingTaskId?: string;
+    /** Hashes of explicitly selected setup options; billing identities themselves are never persisted. */
+    setupTerms?: Partial<Record<keyof EnsureAccountOptions, string>>;
+    /** Stored reference aliases for authoritative repair after restart. */
+    aliases?: AccountReference[];
+}
+/** Partitioned by seller and caller scope. Implementations must provide read-your-writes. */
+export interface BuyerAccountStorage {
+    get(key: string): Promise<ProvisionedAccount | undefined>;
+    set(key: string, account: ProvisionedAccount): Promise<void>;
+}
+export interface BuyerAccountRegistryOptions {
+    maxEntries?: number;
+    normalizeOptions?: (options: EnsureAccountOptions, taskOptions?: TaskOptions) => Promise<EnsureAccountOptions>;
+}
+export declare class BuyerAccountRegistry {
+    private scope;
+    private provision;
+    private storage?;
+    private repair?;
+    private entries;
+    private pending;
+    private writes;
+    private repairs;
+    private repairWaiters;
+    private invalidatedHandles;
+    private observationEpoch;
+    private observationFloor;
+    private statusEpochs;
+    private readonly maxEntries;
+    private readonly normalizeOptions?;
+    constructor(scope: () => string, provision: (key: AccountReference, options: EnsureAccountOptions, taskOptions?: TaskOptions) => Promise<TaskResult<SyncAccountsResponse>>, storage?: BuyerAccountStorage | undefined, repair?: ((accountId: string, taskOptions?: TaskOptions) => Promise<readonly unknown[]>) | undefined, options?: BuyerAccountRegistryOptions);
+    private key;
+    /** Capture before a seller request; observations older than a status repair are ignored. */
+    captureObservation(): number;
+    private observationIsCurrent;
+    private remember;
+    get(account: AccountReference): Promise<ProvisionedAccount | undefined>;
+    ensure(account: AccountReference, options?: EnsureAccountOptions, taskOptions?: TaskOptions, onTaskResult?: (result: TaskResult<unknown>) => void): Promise<ProvisionedAccount>;
+    private write;
+    private record;
+    private enqueue;
+    observeSync(refs: readonly AccountReference[], rows: readonly unknown[], dryRun?: boolean, observationEpoch?: number): Promise<void>;
+    private reconcileId;
+    observeList(rows: readonly unknown[], queriedAccountId?: string, observationEpoch?: number): Promise<void>;
+    private observeListAtScope;
+    /** After verifying account.status_changed, repair aliases by handle from the authoritative seller. */
+    applyStatusChange(notification: {
+        account_id: string;
+    }, options?: TaskOptions): Promise<void>;
+    private repairStatus;
+    private runRepair;
+}

package/dist/lib/core/buyer-account-registry.d.ts

@@ -0,0 +1,65 @@
+import type { AccountReference, BusinessEntity, PaymentTerms, SyncAccountsResponse } from '../types/tools.generated';
+import type { TaskOptions, TaskResult } from './ConversationTypes';
+export type AccountPolicy = 'auto' | 'strict' | 'off';
+export interface EnsureAccountOptions {
+    billing?: 'operator' | 'agent' | 'advertiser';
+    paymentTerms?: PaymentTerms;
+    billingEntity?: BusinessEntity;
+}
+export interface ProvisionedAccount {
+    account: AccountReference;
+    account_id?: string;
+    status: string;
+    pendingTaskId?: string;
+    /** Hashes of explicitly selected setup options; billing identities themselves are never persisted. */
+    setupTerms?: Partial<Record<keyof EnsureAccountOptions, string>>;
+    /** Stored reference aliases for authoritative repair after restart. */
+    aliases?: AccountReference[];
+}
+/** Partitioned by seller and caller scope. Implementations must provide read-your-writes. */
+export interface BuyerAccountStorage {
+    get(key: string): Promise<ProvisionedAccount | undefined>;
+    set(key: string, account: ProvisionedAccount): Promise<void>;
+}
+export interface BuyerAccountRegistryOptions {
+    maxEntries?: number;
+    normalizeOptions?: (options: EnsureAccountOptions, taskOptions?: TaskOptions) => Promise<EnsureAccountOptions>;
+}
+export declare class BuyerAccountRegistry {
+    private scope;
+    private provision;
+    private storage?;
+    private repair?;
+    private entries;
+    private pending;
+    private writes;
+    private repairs;
+    private repairWaiters;
+    private invalidatedHandles;
+    private observationEpoch;
+    private observationFloor;
+    private statusEpochs;
+    private readonly maxEntries;
+    private readonly normalizeOptions?;
+    constructor(scope: () => string, provision: (key: AccountReference, options: EnsureAccountOptions, taskOptions?: TaskOptions) => Promise<TaskResult<SyncAccountsResponse>>, storage?: BuyerAccountStorage | undefined, repair?: ((accountId: string, taskOptions?: TaskOptions) => Promise<readonly unknown[]>) | undefined, options?: BuyerAccountRegistryOptions);
+    private key;
+    /** Capture before a seller request; observations older than a status repair are ignored. */
+    captureObservation(): number;
+    private observationIsCurrent;
+    private remember;
+    get(account: AccountReference): Promise<ProvisionedAccount | undefined>;
+    ensure(account: AccountReference, options?: EnsureAccountOptions, taskOptions?: TaskOptions, onTaskResult?: (result: TaskResult<unknown>) => void): Promise<ProvisionedAccount>;
+    private write;
+    private record;
+    private enqueue;
+    observeSync(refs: readonly AccountReference[], rows: readonly unknown[], dryRun?: boolean, observationEpoch?: number): Promise<void>;
+    private reconcileId;
+    observeList(rows: readonly unknown[], queriedAccountId?: string, observationEpoch?: number): Promise<void>;
+    private observeListAtScope;
+    /** After verifying account.status_changed, repair aliases by handle from the authoritative seller. */
+    applyStatusChange(notification: {
+        account_id: string;
+    }, options?: TaskOptions): Promise<void>;
+    private repairStatus;
+    private runRepair;
+}

package/dist/lib/core/buyer-account-registry.js

@@ -0,0 +1,518 @@
+"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 buyer_account_registry_exports = {};
+__export(buyer_account_registry_exports, {
+  BuyerAccountRegistry: () => BuyerAccountRegistry
+});
+module.exports = __toCommonJS(buyer_account_registry_exports);
+var import_node_util = require("node:util");
+var import_node_crypto = require("node:crypto");
+var import_account_key = require('./account-key.js');
+var import_account_resolution = require('./account-resolution.js');
+var import_errors = require('../errors/index.js');
+var import_abort = require('../protocols/abort.js');
+var import_task_deadline = require('./task-deadline.js');
+function setupTerms(options) {
+  const stable = (value) => Array.isArray(value) ? value.map(stable) : value && typeof value === "object" ? Object.fromEntries(
+    Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => [key, stable(item)])
+  ) : value;
+  return Object.fromEntries(
+    Object.entries(options).map(([key, value]) => [
+      key,
+      (0, import_node_crypto.createHash)("sha256").update(JSON.stringify(stable(value))).digest("hex")
+    ])
+  );
+}
+class BuyerAccountRegistry {
+  constructor(scope, provision, storage, repair, options = {}) {
+    this.scope = scope;
+    this.provision = provision;
+    this.storage = storage;
+    this.repair = repair;
+    this.maxEntries = options.maxEntries ?? 1e4;
+    this.normalizeOptions = options.normalizeOptions;
+    if (!Number.isSafeInteger(this.maxEntries) || this.maxEntries < 2)
+      throw new Error("Account registry maxEntries must be an integer >= 2.");
+  }
+  scope;
+  provision;
+  storage;
+  repair;
+  entries = /* @__PURE__ */ new Map();
+  pending = /* @__PURE__ */ new Map();
+  writes = Promise.resolve();
+  repairs = /* @__PURE__ */ new Map();
+  repairWaiters = /* @__PURE__ */ new Map();
+  invalidatedHandles = /* @__PURE__ */ new Set();
+  observationEpoch = 0;
+  observationFloor = 0;
+  statusEpochs = /* @__PURE__ */ new Map();
+  maxEntries;
+  normalizeOptions;
+  key(account, scope = this.scope()) {
+    return `${scope}:${(0, import_account_key.accountReferenceKey)(account)}`;
+  }
+  /** Capture before a seller request; observations older than a status repair are ignored. */
+  captureObservation() {
+    return this.observationEpoch;
+  }
+  observationIsCurrent(accountId, epoch, scope) {
+    return epoch === void 0 || epoch >= this.observationFloor && (!accountId || (this.statusEpochs.get(this.key({ account_id: accountId }, scope)) ?? 0) <= epoch);
+  }
+  remember(key, entry) {
+    if (!this.entries.has(key) && this.entries.size >= this.maxEntries) {
+      if (!this.storage)
+        throw new import_errors.AccountSetupRequiredError(
+          "Account registry capacity reached; configure durable storage or increase maxEntries."
+        );
+      this.entries.delete(this.entries.keys().next().value);
+    }
+    this.entries.set(key, structuredClone(entry));
+  }
+  async get(account) {
+    const key = this.key(account);
+    let entry = this.entries.get(key);
+    if (!entry) {
+      const persisted = await this.storage?.get(key);
+      entry = this.entries.get(key) ?? persisted;
+    }
+    if (key !== this.key(account) || entry && (0, import_account_key.accountReferenceKey)(entry.account) !== (0, import_account_key.accountReferenceKey)(account))
+      return void 0;
+    if (entry) this.remember(key, entry);
+    if (entry?.account_id && this.invalidatedHandles.has(this.key({ account_id: entry.account_id })))
+      return { ...structuredClone(entry), status: "unknown" };
+    return entry ? structuredClone(entry) : void 0;
+  }
+  async ensure(account, options = {}, taskOptions, onTaskResult) {
+    (0, import_abort.throwIfAborted)(taskOptions?.signal);
+    if (taskOptions?.timeout !== void 0 && (!Number.isFinite(taskOptions.timeout) || taskOptions.timeout < 0 || taskOptions.timeout > import_abort.MAX_TIMER_DELAY_MS))
+      throw new RangeError(`timeout must be a finite non-negative number <= ${import_abort.MAX_TIMER_DELAY_MS}`);
+    account = structuredClone(account);
+    if (this.normalizeOptions) options = await this.normalizeOptions(structuredClone(options), taskOptions);
+    options = structuredClone(Object.fromEntries(Object.entries(options).filter(([, value]) => value !== void 0)));
+    const scope = this.scope();
+    const key = this.key(account, scope);
+    const current = await this.get(account);
+    (0, import_abort.throwIfAborted)(taskOptions?.signal);
+    if (scope !== this.scope()) throw new import_errors.AccountNotFoundError("Caller credentials changed during provisioning.");
+    const shared = this.pending.get(key);
+    const wait = (promise) => (0, import_task_deadline.withTaskDeadline)(
+      taskOptions,
+      (options2) => (0, import_abort.withAbortSignal)([options2.signal], void 0, () => promise.then((entry2) => structuredClone(entry2)))
+    );
+    if (shared) {
+      if (!(0, import_node_util.isDeepStrictEqual)(shared.options, options))
+        throw new import_errors.AccountSetupRequiredError("Provisioning is already in progress with different billing terms.");
+      const entry2 = await wait(shared.promise);
+      if (shared.result) onTaskResult?.(shared.result);
+      return entry2;
+    }
+    const terms = setupTerms(options);
+    if (current?.status === "failed_provisioning" && current.setupTerms && !(0, import_node_util.isDeepStrictEqual)(current.setupTerms, terms))
+      throw new import_errors.AccountSetupRequiredError(
+        "The pending account was provisioned with different billing terms. Call syncAccounts explicitly to change terms."
+      );
+    if (current && current.status !== "failed_provisioning") {
+      if (Object.entries(terms ?? {}).some(
+        ([name, value]) => current.setupTerms?.[name] !== void 0 && current.setupTerms[name] !== value
+      ))
+        throw new import_errors.AccountSetupRequiredError(
+          "The account was provisioned with different billing terms. Call syncAccounts explicitly to change terms."
+        );
+      if (current.status !== "active" && current.account_id && this.repair) {
+        try {
+          await this.repairStatus(current.account_id, taskOptions, false);
+        } catch (error) {
+          (0, import_abort.throwIfAborted)(taskOptions?.signal);
+          if ((0, import_abort.isAbortOrTimeoutError)(error)) throw error;
+          if (scope !== this.scope())
+            throw new import_errors.AccountNotFoundError("Caller credentials changed during reconciliation.");
+          return current;
+        }
+        const refreshed = await this.get(account) ?? current;
+        if (scope !== this.scope()) throw new import_errors.AccountNotFoundError("Caller credentials changed during reconciliation.");
+        if (refreshed.status === "unknown")
+          throw new import_errors.AccountNotFoundError(
+            "The seller no longer lists this account. Call syncAccounts explicitly to reestablish it."
+          );
+        return refreshed;
+      }
+      if (current.status === "unknown")
+        throw new import_errors.AccountNotFoundError(
+          "Reconcile this account with listAccounts or explicitly reestablish it with syncAccounts."
+        );
+      if (current.status === "provisioning" && current.pendingTaskId)
+        throw new import_errors.AccountSetupRequiredError(
+          `Reconcile pending sync_accounts task ${current.pendingTaskId} and observe its completed account rows before provisioning again.`
+        );
+      if (current.status !== "pending_approval" || current.account_id) return current;
+      if (!current.setupTerms || !(0, import_node_util.isDeepStrictEqual)(current.setupTerms, terms))
+        throw new import_errors.AccountSetupRequiredError(
+          "Provide the original billing options to refresh a legacy account without a handle, or call syncAccounts explicitly."
+        );
+    }
+    const requiredEntries = current ? 1 : 2;
+    if (!this.storage && this.entries.size + this.pending.size * 2 + requiredEntries > this.maxEntries) {
+      throw new import_errors.AccountSetupRequiredError(
+        "Account registry capacity reached; configure durable storage or increase maxEntries."
+      );
+    }
+    const pending = { promise: void 0, options: structuredClone(options) };
+    let callbackFailed = false;
+    let callbackError;
+    const notify = (result) => {
+      try {
+        onTaskResult?.(result);
+      } catch (error) {
+        callbackFailed = true;
+        callbackError = error;
+      }
+    };
+    const operationOptions = { ...taskOptions, signal: void 0, timeout: void 0 };
+    const observationEpoch = this.captureObservation();
+    const request = this.provision(structuredClone(account), pending.options, operationOptions).then(async (initial) => {
+      let result = initial;
+      pending.result = result;
+      notify(result);
+      if (this.key(account) !== key) throw new import_errors.AccountNotFoundError("Caller credentials changed during provisioning.");
+      if (!result.success)
+        throw (0, import_errors.adcpErrorToTypedError)(result.adcpError ?? { code: "ACCOUNT_NOT_FOUND", message: result.error }) ?? new Error(result.error);
+      if (result.status !== "completed") {
+        const provisional = {
+          account: structuredClone(account),
+          status: "provisioning",
+          setupTerms: current?.setupTerms ?? terms,
+          ...result.metadata.taskId && { pendingTaskId: result.metadata.taskId }
+        };
+        await this.enqueue(async () => {
+          const latest = await this.get(account);
+          if (!latest || latest.status === "failed_provisioning" || latest.status === current?.status && latest.account_id === current?.account_id)
+            await this.write(provisional, scope);
+        });
+        if (!result.submitted) return provisional;
+        result = await result.submitted.waitForCompletion();
+        pending.result = result;
+        notify(result);
+        if (!result.success) {
+          await this.enqueue(async () => {
+            const latest = await this.get(account);
+            if (!latest || latest.status === "provisioning")
+              await this.write(
+                {
+                  account: structuredClone(account),
+                  status: "failed_provisioning",
+                  setupTerms: current?.setupTerms ?? terms
+                },
+                scope
+              );
+          });
+          throw (0, import_errors.adcpErrorToTypedError)(result.adcpError ?? { code: "ACCOUNT_SETUP_REQUIRED", message: result.error }) ?? new Error(result.error);
+        }
+      }
+      if (this.key(account) !== key) throw new import_errors.AccountNotFoundError("Caller credentials changed during provisioning.");
+      if (result.status !== "completed" || !result.data || !("accounts" in result.data))
+        throw new import_errors.AccountSetupRequiredError(
+          "sync_accounts has not completed; observe its completion before provisioning again."
+        );
+      await this.observeSync([account], result.data.accounts, false, observationEpoch);
+      const entry2 = await this.get(account);
+      if (scope !== this.scope()) throw new import_errors.AccountNotFoundError("Caller credentials changed during provisioning.");
+      if (!entry2 || entry2.status === "provisioning" || entry2.status === "failed_provisioning") {
+        await this.enqueue(async () => {
+          const latest = await this.get(account);
+          if (!latest || ["provisioning", "failed_provisioning"].includes(latest.status))
+            await this.write(
+              {
+                account,
+                status: "failed_provisioning",
+                setupTerms: current?.setupTerms ?? terms
+              },
+              scope
+            );
+        });
+        const failed = result.data.accounts.find((row) => row.action === "failed");
+        const error = failed?.errors?.[0];
+        throw (error && (0, import_errors.adcpErrorToTypedError)(error)) ?? new import_errors.AccountNotFoundError("sync_accounts did not establish the requested account.");
+      }
+      let settled = entry2;
+      await this.enqueue(async () => {
+        const latest = await this.get(account);
+        if (scope !== this.scope()) throw new import_errors.AccountNotFoundError("Caller credentials changed during provisioning.");
+        if (!latest) throw new import_errors.AccountNotFoundError("The provisioned account is no longer registered.");
+        settled = latest;
+        if (latest.account_id !== entry2.account_id) return;
+        settled = { ...latest, setupTerms: setupTerms(options) };
+        await this.write(settled, scope);
+        if (settled.account_id && !("account_id" in account)) {
+          const idEntry = await this.get({ account_id: settled.account_id });
+          if (scope !== this.scope()) throw new import_errors.AccountNotFoundError("Caller credentials changed during provisioning.");
+          if (idEntry) await this.write({ ...idEntry, setupTerms: settled.setupTerms }, scope);
+        }
+      });
+      return settled;
+    });
+    pending.promise = request;
+    this.pending.set(key, pending);
+    const cleanup = () => {
+      if (this.pending.get(key) === pending) this.pending.delete(key);
+    };
+    void request.then(cleanup, cleanup);
+    const entry = await wait(request);
+    if (callbackFailed) throw callbackError;
+    return entry;
+  }
+  async write(entry, scope, isCurrent = () => true) {
+    if (!isCurrent()) return;
+    const key = this.key(entry.account, scope);
+    if (scope === this.scope()) this.remember(key, entry);
+    await this.storage?.set(key, structuredClone(entry));
+  }
+  async record(ref, row, scope, preserveTerms = false, isCurrent = () => true) {
+    const entry = {
+      account: structuredClone(ref),
+      status: row.status,
+      ...row.account_id && { account_id: row.account_id }
+    };
+    const prior = await this.get(ref);
+    if (scope !== this.scope() || !isCurrent()) return;
+    const idRef = row.account_id && !("account_id" in ref) ? { account_id: row.account_id } : void 0;
+    const priorId = idRef ? await this.get(idRef) : void 0;
+    if (scope !== this.scope() || !isCurrent()) return;
+    const aliases = new Map((priorId?.aliases ?? []).map((alias) => [(0, import_account_key.accountReferenceKey)(alias), alias]));
+    if (idRef) {
+      aliases.set((0, import_account_key.accountReferenceKey)(ref), structuredClone(ref));
+      if (aliases.size > this.maxEntries)
+        throw new import_errors.AccountSetupRequiredError("Account alias capacity reached; increase registry maxEntries.");
+    }
+    if (!("account_id" in ref) && prior?.account_id && prior.account_id !== row.account_id) {
+      const oldId = await this.get({ account_id: prior.account_id });
+      if (scope !== this.scope() || !isCurrent()) return;
+      if (oldId?.aliases) {
+        await this.write(
+          { ...oldId, aliases: oldId.aliases.filter((alias) => (0, import_account_key.accountReferenceKey)(alias) !== (0, import_account_key.accountReferenceKey)(ref)) },
+          scope,
+          isCurrent
+        );
+      }
+    }
+    if (preserveTerms && prior?.setupTerms) entry.setupTerms = prior.setupTerms;
+    if ("account_id" in ref) {
+      if (prior?.aliases) entry.aliases = prior.aliases;
+    }
+    await this.write(entry, scope, isCurrent);
+    if (!idRef || scope !== this.scope() || !isCurrent()) return;
+    await this.write(
+      {
+        account: idRef,
+        account_id: row.account_id,
+        status: row.status,
+        aliases: [...aliases.values()],
+        ...preserveTerms && priorId?.setupTerms && { setupTerms: priorId.setupTerms }
+      },
+      scope,
+      isCurrent
+    );
+  }
+  enqueue(run) {
+    const next = this.writes.then(run);
+    this.writes = next.catch(() => {
+    });
+    return next;
+  }
+  async observeSync(refs, rows, dryRun = false, observationEpoch) {
+    if (dryRun) return;
+    const scope = this.scope();
+    return this.enqueue(async () => {
+      if (scope !== this.scope()) return;
+      for (const ref of refs) {
+        const candidates = rows.filter((value) => {
+          if (!value || typeof value !== "object") return false;
+          const row2 = value;
+          if ("account_id" in ref) return row2.account_id === ref.account_id;
+          return row2.brand?.domain === ref.brand.domain && row2.operator === ref.operator && (!ref.brand.brand_id || row2.brand.brand_id === ref.brand.brand_id) && (0, import_account_resolution.sameCountrySet)(ref.brand.countries, row2.brand.countries) && (!ref.operator_unit || row2.operator_unit?.id === ref.operator_unit.id) && (!ref.currency || row2.currency === ref.currency) && (!ref.timezone || row2.timezone === ref.timezone) && (row2.sandbox === void 0 || row2.sandbox === true === (ref.sandbox === true));
+        });
+        if (candidates.length !== 1) continue;
+        let row = candidates[0];
+        if (row.action === "failed" || typeof row.status !== "string") continue;
+        const prior = await this.get(ref);
+        if (scope !== this.scope()) return;
+        let rowEpoch = observationEpoch;
+        let repairedBinding = false;
+        if (!this.observationIsCurrent(row.account_id, rowEpoch, scope)) {
+          if (!row.account_id || prior?.account_id && prior.account_id !== row.account_id) continue;
+          const captured = this.captureObservation();
+          const authoritative = await this.get({ account_id: row.account_id });
+          if (scope !== this.scope()) return;
+          row = {
+            ...row,
+            status: captured === this.captureObservation() ? authoritative?.status ?? "unknown" : "unknown"
+          };
+          rowEpoch = this.captureObservation();
+          repairedBinding = true;
+        }
+        const isCurrent = () => scope === this.scope() && this.observationIsCurrent(row.account_id, rowEpoch, scope);
+        await this.record(ref, row, scope, false, isCurrent);
+        if (!isCurrent() || repairedBinding) continue;
+        for (const id of [row.account_id])
+          if (id) {
+            const key = this.key({ account_id: id }, scope);
+            this.repairs.delete(key);
+            this.invalidatedHandles.delete(key);
+          }
+      }
+    });
+  }
+  async reconcileId(accountId, status, scope, isCurrent = () => true) {
+    if (scope !== this.scope() || !isCurrent()) return;
+    const idRef = { account_id: accountId };
+    const indexed = await this.get(idRef);
+    if (scope !== this.scope() || !isCurrent()) return;
+    const aliases = new Map((indexed?.aliases ?? []).map((ref) => [(0, import_account_key.accountReferenceKey)(ref), ref]));
+    for (const [key, entry] of this.entries) {
+      if (key === this.key(entry.account, scope) && entry.account_id === accountId && !("account_id" in entry.account)) {
+        aliases.set((0, import_account_key.accountReferenceKey)(entry.account), entry.account);
+      }
+    }
+    for (const ref of aliases.values()) {
+      const prior = await this.get(ref);
+      if (scope !== this.scope() || !isCurrent()) return;
+      if (!prior || prior.account_id !== accountId) {
+        aliases.delete((0, import_account_key.accountReferenceKey)(ref));
+        continue;
+      }
+      await this.write({ ...prior, account: ref, account_id: accountId, status }, scope, isCurrent);
+    }
+    if (scope !== this.scope() || !isCurrent()) return;
+    if (indexed || aliases.size)
+      await this.write(
+        { ...indexed, account: idRef, account_id: accountId, status, aliases: [...aliases.values()] },
+        scope,
+        isCurrent
+      );
+  }
+  async observeList(rows, queriedAccountId, observationEpoch) {
+    const scope = this.scope();
+    return this.observeListAtScope(rows, queriedAccountId, scope, void 0, observationEpoch);
+  }
+  async observeListAtScope(rows, queriedAccountId, scope, isCurrent, observationEpoch) {
+    return this.enqueue(async () => {
+      if (scope !== this.scope() || isCurrent && !isCurrent()) return;
+      if (!this.observationIsCurrent(queriedAccountId, observationEpoch, scope)) return;
+      let foundQuery = false;
+      for (const value of rows) {
+        if (!value || typeof value !== "object") continue;
+        const row = value;
+        if (typeof row.account_id !== "string" || typeof row.status !== "string") continue;
+        if (!this.observationIsCurrent(row.account_id, observationEpoch, scope)) continue;
+        const current = () => scope === this.scope() && (!isCurrent || isCurrent()) && this.observationIsCurrent(row.account_id, observationEpoch, scope);
+        if (row.account_id === queriedAccountId) foundQuery = true;
+        await this.reconcileId(row.account_id, row.status, scope, current);
+        await this.record({ account_id: row.account_id }, row, scope, true, current);
+        if (row.brand?.domain && row.operator) {
+          const ref = {
+            brand: row.brand,
+            operator: row.operator,
+            ...row.operator_unit && { operator_unit: row.operator_unit },
+            ...row.currency && { currency: row.currency },
+            ...row.timezone && { timezone: row.timezone },
+            ...row.sandbox !== void 0 && { sandbox: row.sandbox }
+          };
+          const prior = await this.get(ref);
+          if (scope !== this.scope()) return;
+          if (!prior?.account_id || prior.account_id === row.account_id)
+            await this.record(ref, row, scope, true, current);
+        }
+        if (!isCurrent && current()) {
+          const key = this.key({ account_id: row.account_id }, scope);
+          this.repairs.delete(key);
+          this.invalidatedHandles.delete(key);
+        }
+      }
+      if (queriedAccountId && !foundQuery) {
+        const current = () => scope === this.scope() && (!isCurrent || isCurrent()) && this.observationIsCurrent(queriedAccountId, observationEpoch, scope);
+        await this.reconcileId(queriedAccountId, "unknown", scope, current);
+        if (!isCurrent && current()) {
+          const key = this.key({ account_id: queriedAccountId }, scope);
+          this.repairs.delete(key);
+          this.invalidatedHandles.delete(key);
+        }
+      }
+    });
+  }
+  /** After verifying account.status_changed, repair aliases by handle from the authoritative seller. */
+  async applyStatusChange(notification, options) {
+    return this.repairStatus(notification.account_id, options, true);
+  }
+  async repairStatus(accountId, options, invalidate) {
+    (0, import_abort.throwIfAborted)(options?.signal);
+    const key = this.key({ account_id: accountId });
+    let operation = !invalidate ? this.repairWaiters.get(key) : void 0;
+    if (!operation) {
+      operation = this.runRepair(accountId, { ...options, signal: void 0, timeout: void 0 }, invalidate);
+      this.repairWaiters.set(key, operation);
+      const cleanup = () => {
+        if (this.repairWaiters.get(key) === operation) this.repairWaiters.delete(key);
+      };
+      void operation.then(cleanup, cleanup);
+    }
+    const wait = (promise) => (0, import_task_deadline.withTaskDeadline)(options, (taskOptions) => (0, import_abort.withAbortSignal)([taskOptions.signal], void 0, () => promise));
+    await wait(operation);
+    let newer = this.repairWaiters.get(key);
+    while (newer && newer !== operation) {
+      operation = newer;
+      await wait(operation);
+      newer = this.repairWaiters.get(key);
+    }
+  }
+  async runRepair(accountId, options, invalidate) {
+    if (!this.repair) throw new Error("Account registry requires a list_accounts repair callback.");
+    const scope = this.scope();
+    const key = this.key({ account_id: accountId }, scope);
+    const token = {};
+    this.statusEpochs.delete(key);
+    this.statusEpochs.set(key, ++this.observationEpoch);
+    if (this.statusEpochs.size > this.maxEntries) {
+      const oldestKey = this.statusEpochs.keys().next().value;
+      this.observationFloor = this.statusEpochs.get(oldestKey);
+      this.statusEpochs.delete(oldestKey);
+    }
+    this.repairs.set(key, token);
+    if (invalidate) this.invalidatedHandles.add(key);
+    let invalidationPersisted = !invalidate;
+    try {
+      if (invalidate) {
+        await this.enqueue(() => this.reconcileId(accountId, "unknown", scope, () => this.repairs.get(key) === token));
+        invalidationPersisted = true;
+      }
+      const rows = (await this.repair(accountId, options)).filter(
+        (row) => row !== null && typeof row === "object" && row.account_id === accountId
+      );
+      await this.observeListAtScope(rows, accountId, scope, () => this.repairs.get(key) === token);
+    } finally {
+      if (this.repairs.get(key) === token) {
+        this.repairs.delete(key);
+        if (invalidationPersisted) this.invalidatedHandles.delete(key);
+      }
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BuyerAccountRegistry
+});