@agent-cards/checkout 0.18.0 → 0.19.0

package/dist/merchant-total.d.ts

@@ -0,0 +1,257 @@
+/** One merchant request this browser saw answered, as payment-core reads it. */
+export interface MerchantExchange {
+    method: string;
+    /** The request's full URL, serialized. */
+    url: string;
+    /** The response's HTTP status. */
+    status: number;
+    /** When the response finished: ms since the epoch, this browser's clock. */
+    completedAt: number;
+    /** When the request left, same clock. */
+    sentAt?: number;
+    /** An opaque id of the tab and document the request came from. */
+    page?: string;
+    /** The request's JSON text. */
+    requestBody?: string;
+    /** The response text. */
+    body: string;
+}
+/** The paused card request the total is read for (payment-core MerchantAmountCard). */
+export interface MerchantAmountCard {
+    url: string;
+    method: string;
+    body: string;
+    pausedAt: number;
+    checkoutOrigin?: string;
+    page?: string;
+    /** A sandbox declaration's endpoint: its own responses price it. */
+    declaredEndpoint?: string;
+}
+export type MerchantAmountStage = 'source' | 'charged';
+type Refusal = {
+    ok: false;
+    code: string;
+    reason: string;
+};
+type Reading = {
+    ok: true;
+    amount: {
+        amount: number;
+        currency: string;
+    };
+    source: Record<string, unknown>;
+} | Refusal;
+/**
+ * A priced profile whose requests the log records: its id alone reads them at the profile's
+ * reviewed origins; with `declaredEndpoint` (this client's sandbox declaration for the
+ * profile, VaultClientOptions.sandboxMerchants) at that endpoint's origin instead.
+ */
+export type MerchantTotalScope = string | {
+    id: string;
+    declaredEndpoint?: string;
+};
+/** How many exchanges one read takes: the API's limit on merchant_total and merchant_charge. */
+export declare const MERCHANT_EXCHANGES_MAX: number;
+/** The exchanges one read of a stage sends: its shapes at its origin, projected, the newest MERCHANT_EXCHANGES_MAX. */
+export declare const merchantAmountExchanges: (profileId: string, stage: MerchantAmountStage, input: {
+    card: MerchantAmountCard;
+    responses: MerchantExchange[];
+}) => {
+    ok: true;
+    responses: MerchantExchange[];
+} | Refusal;
+/** The reading the API makes of the merchant's total for a paused card request, its total as `{amount, currency}`. */
+export declare const merchantAmountFromResponses: (profileId: string, input: {
+    card: MerchantAmountCard;
+    responses: MerchantExchange[];
+}) => Reading;
+/** Whether a reviewed profile is priced by the merchant's own responses (it names an amount source). */
+export declare function merchantProfilePricedBySource(profileId: string): boolean;
+/** What the adapter knows of a request when it leaves. */
+export interface MerchantRequestSeen {
+    method: string;
+    url: string;
+    /** The request's JSON text, when it has one. */
+    requestBody?: string;
+    /** An opaque id of the tab and document the request came from. */
+    page?: string;
+}
+/** A response body past this many characters is recorded as unreadable (''). */
+export declare const MERCHANT_BODY_READ_MAX: number;
+/**
+ * The most request and response text the log holds at once, in characters: room for the
+ * MERCHANT_EXCHANGES_MAX newest exchanges one read sends at MERCHANT_BODY_READ_MAX each.
+ * Past it the oldest answered exchanges go first; a request still waiting for its answer
+ * goes only when waiting ones alone fill it, and reads refuse as stale until it ends.
+ */
+export declare const MERCHANT_LOG_TEXT_MAX: number;
+/**
+ * Every request this browser sent that a reviewed profile's amount rules could read, and
+ * its answer. The adapters feed it from their network events: sent() when a request
+ * leaves (recorded only when some profile's amount stage reads its shape at an origin that
+ * stage reads, payment-core merchantAmountRequestStages, so another shop's /checkout is
+ * never read or held), answered() with the status and the time the response finished,
+ * then read() with the response text (null when it could not be read), or failed(). It
+ * holds at most LOG_MAX requests and MERCHANT_LOG_TEXT_MAX characters of their text.
+ * Read-only: nothing here pauses, changes or answers a request.
+ */
+export declare class MerchantExchangeLog {
+    /** The reviewed profiles whose amount rules decide what is recorded, and where (MerchantTotalScope). */
+    private readonly profiles;
+    private readonly now;
+    private readonly textMax;
+    /** Told after each answer the log reads (MerchantTotalWatch reports a confirmation that came late). */
+    private readonly onRead?;
+    private readonly entries;
+    private readonly waiters;
+    private text;
+    /**
+     * The requests the log dropped while they still waited for their answer, by key, with when
+     * they left and the stages they are read for (the newest LOST_MAX). Each one can still move
+     * what its stage reads, so every wait for that stage counts it as unanswered until the
+     * adapter reports it failed or answered.
+     */
+    private readonly lostWaiting;
+    /** More requests were lost at once than lostWaiting holds: no read of a total is trusted again. */
+    private lostOverflow;
+    /**
+     * When the newest answer came to a dropped request that is read for the total (a 'source'
+     * stage request), or null. The log never read that answer, which could carry another total,
+     * so every read of the total refuses as stale until a total request the page sent after it
+     * answers: the merchant's later word on its total, read in full. An answer of any other
+     * stage (a payment's) says nothing about the total and never clears it.
+     */
+    private unreadSourceAnswerAt;
+    constructor(
+    /** The reviewed profiles whose amount rules decide what is recorded, and where (MerchantTotalScope). */
+    profiles: () => readonly MerchantTotalScope[], now?: () => number, textMax?: number, 
+    /** Told after each answer the log reads (MerchantTotalWatch reports a confirmation that came late). */
+    onRead?: (() => void) | undefined);
+    /** A request left; true when it is recorded. */
+    sent(key: string, request: MerchantRequestSeen, sentAt?: number): boolean;
+    /** Forgets one request and its text. */
+    private drop;
+    /**
+     * Past LOG_MAX requests or MERCHANT_LOG_TEXT_MAX characters, drops the oldest answered
+     * exchanges first. Only when the requests still waiting fill the log on their own do the
+     * oldest of them go too: the log keeps only their keys (lostWaiting), so it stays bounded
+     * while every read still waits for them and refuses the total as unknown.
+     */
+    private trim;
+    /** Whether a request is recorded (its answer is then worth reading). */
+    tracks(key: string): boolean;
+    /** The response's status arrived. */
+    answered(key: string, status: number): void;
+    /** The page a request's answer belongs to, when only its answer says (a document the frame then shows). */
+    repage(key: string, page: string): void;
+    /**
+     * The response finished at `completedAt` (taken when it finished, before its text was
+     * read), with this text, or null when it could not be read (it then reads as empty).
+     */
+    read(key: string, body: string | null, completedAt?: number): void;
+    /** The request failed or was cancelled: it has no answer to read. */
+    failed(key: string): void;
+    /** Every answered exchange, in the order the requests left. */
+    exchanges(): MerchantExchange[];
+    /** The unanswered requests, sent at or before `before`, that can change what a stage reads for this card request. */
+    pending(profileId: string, stage: MerchantAmountStage, card: MerchantAmountCard, before: number): number;
+    /**
+     * Resolves once no request sent at or before `before` that can change what the stage
+     * reads is unanswered, with every answered exchange; rejects with a MerchantTotalWait
+     * when one is still unanswered after `timeoutMs`, or when `signal` aborts first.
+     */
+    settle(profileId: string, stage: MerchantAmountStage, card: MerchantAmountCard, before: number, timeoutMs: number, signal?: AbortSignal): Promise<MerchantExchange[]>;
+    /** The capture the client reads for a card request that paused now, on `page`. */
+    capture(pausedAt: number, page: string | undefined, waitMs?: number): MerchantTotalCapture;
+    private changed;
+}
+/** How long the SDK waits for the merchant's own requests to answer before it reads the total. */
+export declare const MERCHANT_TOTAL_WAIT_MS = 5000;
+/** A request that can change the total was still unanswered when the SDK had to read it. */
+export declare class MerchantTotalWait extends Error {
+    readonly open: number;
+    constructor(open: number);
+}
+/**
+ * What an adapter hands the client for a card request priced by the merchant's total:
+ * when it paused, on which page, and the exchanges it recorded once the requests that can
+ * change the total have answered (bounded; see MerchantExchangeLog.settle). A raw CDP
+ * runtime that calls authorize() itself builds one from its own network events.
+ */
+export interface MerchantTotalCapture {
+    /** When the card request paused: ms since the epoch, this browser's clock. */
+    pausedAt: number;
+    /** An opaque id of the tab and document the card request came from. */
+    page?: string;
+    exchanges(profileId: string, stage: MerchantAmountStage, card: MerchantAmountCard, signal?: AbortSignal): Promise<MerchantExchange[]>;
+}
+/** The merchant's total a merchant-hosted approval was created at, for the check at release. */
+export interface MerchantTotalApproved {
+    card: MerchantAmountCard;
+    /** The approved total: `amount` in the currency's smallest unit. */
+    amount: {
+        amount: number;
+        currency: string;
+    };
+}
+/** merchant_total on the create's wire: snake_case, as the API takes it. */
+export declare function merchantTotalWire(pausedAt: number, page: string | undefined, responses: readonly MerchantExchange[]): {
+    responses: {
+        body: string;
+        request_body?: string | undefined;
+        page?: string | undefined;
+        sent_at?: number | undefined;
+        method: string;
+        url: string;
+        status: number;
+        completed_at: number;
+    }[];
+    page?: string | undefined;
+    paused_at: number;
+};
+/** One exchange on the wire. */
+export declare function exchangeWire(exchange: MerchantExchange): {
+    body: string;
+    request_body?: string | undefined;
+    page?: string | undefined;
+    sent_at?: number | undefined;
+    method: string;
+    url: string;
+    status: number;
+    completed_at: number;
+};
+/**
+ * The read at release: the same reading as at the create, with the release moment as the
+ * pause, over what the log holds once the requests that can move the total have answered.
+ * null when the card request may go out; otherwise why it is held: a request still
+ * unanswered ('stale'), a reading that fails, or a total that is not the approved amount
+ * ('changed'). The API bounds the total's age when it serves the card, but never sees the
+ * responses between the pause and the release: this read does.
+ */
+export declare function merchantTotalAtRelease(log: MerchantExchangeLog, profileId: string, approved: MerchantTotalApproved, releasedAt: number, waitMs?: number, signal?: AbortSignal): Promise<Refusal | null>;
+/** How long after the merchant answers the card request the SDK waits for the rest of its confirmation. */
+export declare const MERCHANT_CHARGE_SETTLE_MS = 500;
+/**
+ * The after-payment report (POST /v2/checkout/authorizations/:id/merchant_charge): the
+ * paused card request the create read and the merchant's answers after it that the
+ * profile's after-payment rules read, projected; null when the profile reads none, none
+ * came, or none the API's reading ties to this card request.
+ */
+export declare function merchantChargeReport(log: MerchantExchangeLog, profileId: string, approved: MerchantTotalApproved): {
+    request: {
+        url: string;
+        method: string;
+        body: string;
+    };
+    responses: {
+        body: string;
+        request_body?: string | undefined;
+        page?: string | undefined;
+        sent_at?: number | undefined;
+        method: string;
+        url: string;
+        status: number;
+        completed_at: number;
+    }[];
+} | null;
+export {};

package/dist/merchant-total.js

@@ -0,0 +1,383 @@
+/**
+ * The merchant's own total, as this browser saw it (payment-core merchant-amount.js).
+ *
+ * A reviewed Adyen merchant-hosted profile's card request goes to the merchant's own
+ * server, which picks what it charges, and several merchants' card bodies name no amount
+ * at all. So a profile can name an amount source: the merchant's own checkout responses
+ * that carry the grand total. The adapters record those responses read-only from the
+ * moment they attach (they never pause, change or answer one), the client sends the ones
+ * the profile's rules read with the create, and the API refuses a payment whose agent
+ * amount is not that total. After payment the adapters report what the merchant's
+ * confirmation says it charged, and the API alerts on a higher charge.
+ *
+ * What this proves: the total is what the agent's browser session saw. It catches a
+ * mistyped amount and a cart that changed under the agent; it cannot tell a merchant's
+ * response from one the agent wrote, so every profile priced this way stays in observe.
+ *
+ * What the SDK owes payment-core (the header of merchant-amount.js): every exchange of
+ * the profile's shapes, projected, with the time it left; a wait for any such request
+ * still unanswered before it reads the total; the newest MERCHANT_EXCHANGES_MAX; and at
+ * release the same read with the release moment as the pause, the card request held
+ * unless the total is still the approved amount.
+ */
+import { MERCHANT_EXCHANGES_MAX as SHARED_MAX, MERCHANT_PROFILE_RECOGNIZERS as SHARED_PROFILES, merchantAmountExchanges as sharedExchanges, merchantChargedFromResponses as sharedCharged, merchantTotalFromResponses as sharedRead, merchantAmountPending as sharedPending, merchantAmountStagesOf as sharedStages, } from './adyen-merchant-hosted.generated.js';
+/** How many exchanges one read takes: the API's limit on merchant_total and merchant_charge. */
+export const MERCHANT_EXCHANGES_MAX = SHARED_MAX;
+const stagesOf = sharedStages;
+const pendingFor = sharedPending;
+/** The exchanges one read of a stage sends: its shapes at its origin, projected, the newest MERCHANT_EXCHANGES_MAX. */
+export const merchantAmountExchanges = sharedExchanges;
+/** The reading the API makes of the merchant's total for a paused card request, its total as `{amount, currency}`. */
+export const merchantAmountFromResponses = sharedRead;
+/** Whether the API's own after-payment reading reads a charge from these exchanges for this card request. */
+const chargeReads = (profileId, input) => sharedCharged(profileId, input).ok === true;
+const PRICED = new Set(SHARED_PROFILES
+    .filter((profile) => profile.amountSource !== undefined && profile.amountSource !== null).map((profile) => profile.id));
+/** Whether a reviewed profile is priced by the merchant's own responses (it names an amount source). */
+export function merchantProfilePricedBySource(profileId) {
+    return PRICED.has(profileId);
+}
+/** How many dropped, still unanswered requests the log keeps the keys of; past it, every read refuses. */
+const LOST_MAX = 4096;
+/**
+ * The most requests the log keeps, the oldest answered one dropped first: far more than any
+ * profile's rules read. A request still waiting for its answer goes only when waiting ones
+ * alone fill the log, and the log then counts it as unanswered until it ends (see trim).
+ */
+const LOG_MAX = 256;
+/** A response body past this many characters is recorded as unreadable (''). */
+export const MERCHANT_BODY_READ_MAX = 1024 * 1024;
+/**
+ * The most request and response text the log holds at once, in characters: room for the
+ * MERCHANT_EXCHANGES_MAX newest exchanges one read sends at MERCHANT_BODY_READ_MAX each.
+ * Past it the oldest answered exchanges go first; a request still waiting for its answer
+ * goes only when waiting ones alone fill it, and reads refuse as stale until it ends.
+ */
+export const MERCHANT_LOG_TEXT_MAX = MERCHANT_EXCHANGES_MAX * MERCHANT_BODY_READ_MAX;
+const scopeId = (scope) => (typeof scope === 'string' ? scope : scope.id);
+const entryText = (entry) => (entry.body?.length ?? 0) + (entry.requestBody?.length ?? 0);
+/**
+ * Every request this browser sent that a reviewed profile's amount rules could read, and
+ * its answer. The adapters feed it from their network events: sent() when a request
+ * leaves (recorded only when some profile's amount stage reads its shape at an origin that
+ * stage reads, payment-core merchantAmountRequestStages, so another shop's /checkout is
+ * never read or held), answered() with the status and the time the response finished,
+ * then read() with the response text (null when it could not be read), or failed(). It
+ * holds at most LOG_MAX requests and MERCHANT_LOG_TEXT_MAX characters of their text.
+ * Read-only: nothing here pauses, changes or answers a request.
+ */
+export class MerchantExchangeLog {
+    profiles;
+    now;
+    textMax;
+    onRead;
+    entries = new Map();
+    waiters = new Set();
+    text = 0;
+    /**
+     * The requests the log dropped while they still waited for their answer, by key, with when
+     * they left and the stages they are read for (the newest LOST_MAX). Each one can still move
+     * what its stage reads, so every wait for that stage counts it as unanswered until the
+     * adapter reports it failed or answered.
+     */
+    lostWaiting = new Map();
+    /** More requests were lost at once than lostWaiting holds: no read of a total is trusted again. */
+    lostOverflow = false;
+    /**
+     * When the newest answer came to a dropped request that is read for the total (a 'source'
+     * stage request), or null. The log never read that answer, which could carry another total,
+     * so every read of the total refuses as stale until a total request the page sent after it
+     * answers: the merchant's later word on its total, read in full. An answer of any other
+     * stage (a payment's) says nothing about the total and never clears it.
+     */
+    unreadSourceAnswerAt = null;
+    constructor(
+    /** The reviewed profiles whose amount rules decide what is recorded, and where (MerchantTotalScope). */
+    profiles, now = Date.now, textMax = MERCHANT_LOG_TEXT_MAX, 
+    /** Told after each answer the log reads (MerchantTotalWatch reports a confirmation that came late). */
+    onRead) {
+        this.profiles = profiles;
+        this.now = now;
+        this.textMax = textMax;
+        this.onRead = onRead;
+    }
+    /** A request left; true when it is recorded. */
+    sent(key, request, sentAt = this.now()) {
+        if (typeof request?.url !== 'string' || typeof request.method !== 'string')
+            return false;
+        const probe = { method: request.method.toUpperCase(), url: request.url,
+            ...(typeof request.requestBody === 'string' ? { requestBody: request.requestBody } : {}) };
+        const stages = new Set();
+        for (const scope of this.profiles()) {
+            try {
+                for (const stage of stagesOf(scopeId(scope), probe, typeof scope === 'string' || scope.declaredEndpoint === undefined
+                    ? undefined : { declaredEndpoint: scope.declaredEndpoint }))
+                    stages.add(stage);
+            }
+            catch { /* not a request this profile reads */ }
+        }
+        if (stages.size === 0)
+            return false;
+        this.drop(key);
+        const entry = { ...probe, ...(request.page ? { page: request.page } : {}), sentAt, stages: [...stages], settled: false, failed: false };
+        this.entries.set(key, entry);
+        this.text += entryText(entry);
+        this.trim();
+        this.changed();
+        return true;
+    }
+    /** Forgets one request and its text. */
+    drop(key) {
+        const entry = this.entries.get(key);
+        if (!entry)
+            return;
+        this.text -= entryText(entry);
+        this.entries.delete(key);
+    }
+    /**
+     * Past LOG_MAX requests or MERCHANT_LOG_TEXT_MAX characters, drops the oldest answered
+     * exchanges first. Only when the requests still waiting fill the log on their own do the
+     * oldest of them go too: the log keeps only their keys (lostWaiting), so it stays bounded
+     * while every read still waits for them and refuses the total as unknown.
+     */
+    trim() {
+        const over = () => this.entries.size > LOG_MAX || this.text > this.textMax;
+        if (!over())
+            return;
+        for (const [key, entry] of this.entries) {
+            if (!over())
+                return;
+            if (entry.settled)
+                this.drop(key);
+        }
+        for (const [key, entry] of this.entries) {
+            if (!over())
+                return;
+            this.lostWaiting.set(key, { sentAt: entry.sentAt, stages: entry.stages });
+            if (this.lostWaiting.size > LOST_MAX) {
+                this.lostWaiting.delete(this.lostWaiting.keys().next().value);
+                this.lostOverflow = true;
+            }
+            this.drop(key);
+        }
+    }
+    /** Whether a request is recorded (its answer is then worth reading). */
+    tracks(key) {
+        return this.entries.has(key);
+    }
+    /** The response's status arrived. */
+    answered(key, status) {
+        const entry = this.entries.get(key);
+        if (!entry) {
+            // A request the log dropped got its answer, which the log will never read.
+            const lost = this.lostWaiting.get(key);
+            if (lost) {
+                this.lostWaiting.delete(key);
+                if (lost.stages.includes('source'))
+                    this.unreadSourceAnswerAt = Math.max(this.unreadSourceAnswerAt ?? 0, this.now());
+                this.changed();
+            }
+            return;
+        }
+        if (entry.settled || !Number.isInteger(status))
+            return;
+        entry.status = status;
+    }
+    /** The page a request's answer belongs to, when only its answer says (a document the frame then shows). */
+    repage(key, page) {
+        const entry = this.entries.get(key);
+        if (entry && !entry.settled)
+            entry.page = page;
+    }
+    /**
+     * The response finished at `completedAt` (taken when it finished, before its text was
+     * read), with this text, or null when it could not be read (it then reads as empty).
+     */
+    read(key, body, completedAt = this.now()) {
+        const entry = this.entries.get(key);
+        if (!entry || entry.settled)
+            return;
+        entry.completedAt = completedAt;
+        entry.body = typeof body === 'string' && body.length <= MERCHANT_BODY_READ_MAX ? body : '';
+        this.text += entry.body.length;
+        entry.settled = true;
+        if (this.unreadSourceAnswerAt !== null && entry.stages.includes('source') && entry.sentAt > this.unreadSourceAnswerAt) {
+            this.unreadSourceAnswerAt = null;
+        }
+        this.trim();
+        this.changed();
+        try {
+            this.onRead?.();
+        }
+        catch { /* a listener never breaks the log */ }
+    }
+    /** The request failed or was cancelled: it has no answer to read. */
+    failed(key) {
+        const entry = this.entries.get(key);
+        if (!entry) {
+            // A request the log dropped failed: no answer came, so it moved nothing.
+            if (this.lostWaiting.delete(key))
+                this.changed();
+            return;
+        }
+        if (entry.settled)
+            return;
+        entry.settled = true;
+        entry.failed = true;
+        this.trim();
+        this.changed();
+    }
+    /** Every answered exchange, in the order the requests left. */
+    exchanges() {
+        const out = [];
+        for (const entry of this.entries.values()) {
+            if (!entry.settled || entry.failed || entry.status === undefined || entry.completedAt === undefined)
+                continue;
+            out.push({ method: entry.method, url: entry.url, status: entry.status, completedAt: entry.completedAt, sentAt: entry.sentAt,
+                ...(entry.page ? { page: entry.page } : {}), ...(entry.requestBody !== undefined ? { requestBody: entry.requestBody } : {}),
+                body: entry.body ?? '' });
+        }
+        return out;
+    }
+    /** The unanswered requests, sent at or before `before`, that can change what a stage reads for this card request. */
+    pending(profileId, stage, card, before) {
+        // What the log dropped still counts: a request of this stage still waiting, and a total it never read.
+        let count = this.lostOverflow ? 1 : 0;
+        for (const lost of this.lostWaiting.values())
+            if (lost.sentAt <= before && lost.stages.includes(stage))
+                count += 1;
+        if (stage === 'source' && this.unreadSourceAnswerAt !== null && this.unreadSourceAnswerAt <= before)
+            count += 1;
+        for (const entry of this.entries.values()) {
+            if (entry.settled || entry.sentAt > before)
+                continue;
+            try {
+                if (pendingFor(profileId, stage, card, entry))
+                    count += 1;
+            }
+            catch {
+                count += 1;
+            }
+        }
+        return count;
+    }
+    /**
+     * Resolves once no request sent at or before `before` that can change what the stage
+     * reads is unanswered, with every answered exchange; rejects with a MerchantTotalWait
+     * when one is still unanswered after `timeoutMs`, or when `signal` aborts first.
+     */
+    async settle(profileId, stage, card, before, timeoutMs, signal) {
+        const deadline = this.now() + timeoutMs;
+        for (;;) {
+            if (signal?.aborted)
+                throw signal.reason ?? new Error('aborted');
+            const open = this.pending(profileId, stage, card, before);
+            if (open === 0)
+                return this.exchanges();
+            const left = deadline - this.now();
+            if (left <= 0)
+                throw new MerchantTotalWait(open);
+            await new Promise((resolve) => {
+                const done = () => { clearTimeout(timer); this.waiters.delete(done); signal?.removeEventListener('abort', done); resolve(); };
+                const timer = setTimeout(done, Math.min(left, 250));
+                this.waiters.add(done);
+                signal?.addEventListener('abort', done, { once: true });
+            });
+        }
+    }
+    /** The capture the client reads for a card request that paused now, on `page`. */
+    capture(pausedAt, page, waitMs = MERCHANT_TOTAL_WAIT_MS) {
+        return {
+            pausedAt,
+            ...(page ? { page } : {}),
+            exchanges: (profileId, stage, card, signal) => this.settle(profileId, stage, card, card.pausedAt, waitMs, signal),
+        };
+    }
+    changed() {
+        for (const waiter of [...this.waiters])
+            waiter();
+    }
+}
+/** How long the SDK waits for the merchant's own requests to answer before it reads the total. */
+export const MERCHANT_TOTAL_WAIT_MS = 5_000;
+/** A request that can change the total was still unanswered when the SDK had to read it. */
+export class MerchantTotalWait extends Error {
+    open;
+    constructor(open) {
+        super(`${open} of the merchant's own checkout requests had not answered, so its total was not known`);
+        this.open = open;
+        this.name = 'MerchantTotalWait';
+    }
+}
+/** merchant_total on the create's wire: snake_case, as the API takes it. */
+export function merchantTotalWire(pausedAt, page, responses) {
+    return {
+        paused_at: pausedAt,
+        ...(page ? { page } : {}),
+        responses: responses.map(exchangeWire),
+    };
+}
+/** One exchange on the wire. */
+export function exchangeWire(exchange) {
+    return {
+        method: exchange.method, url: exchange.url, status: exchange.status, completed_at: exchange.completedAt,
+        ...(exchange.sentAt !== undefined ? { sent_at: exchange.sentAt } : {}),
+        ...(exchange.page !== undefined ? { page: exchange.page } : {}),
+        ...(exchange.requestBody !== undefined ? { request_body: exchange.requestBody } : {}),
+        body: exchange.body,
+    };
+}
+/**
+ * The read at release: the same reading as at the create, with the release moment as the
+ * pause, over what the log holds once the requests that can move the total have answered.
+ * null when the card request may go out; otherwise why it is held: a request still
+ * unanswered ('stale'), a reading that fails, or a total that is not the approved amount
+ * ('changed'). The API bounds the total's age when it serves the card, but never sees the
+ * responses between the pause and the release: this read does.
+ */
+export async function merchantTotalAtRelease(log, profileId, approved, releasedAt, waitMs = MERCHANT_TOTAL_WAIT_MS, signal) {
+    const card = { ...approved.card, pausedAt: releasedAt };
+    let seen;
+    try {
+        seen = await log.settle(profileId, 'source', card, releasedAt, waitMs, signal);
+    }
+    catch (error) {
+        if (error instanceof MerchantTotalWait)
+            return { ok: false, code: 'stale', reason: error.message };
+        throw error;
+    }
+    const sent = merchantAmountExchanges(profileId, 'source', { card, responses: seen });
+    if (!sent.ok)
+        return sent;
+    const read = merchantAmountFromResponses(profileId, { card, responses: sent.responses });
+    if (!read.ok)
+        return read;
+    const want = approved.amount;
+    if (read.amount.amount !== want.amount || read.amount.currency.toLowerCase() !== want.currency.toLowerCase()) {
+        return { ok: false, code: 'changed',
+            reason: `the merchant's total is now ${read.amount.amount} ${read.amount.currency}, not the ${want.amount} ${want.currency.toLowerCase()} the cardholder approved` };
+    }
+    return null;
+}
+/** How long after the merchant answers the card request the SDK waits for the rest of its confirmation. */
+export const MERCHANT_CHARGE_SETTLE_MS = 500;
+/**
+ * The after-payment report (POST /v2/checkout/authorizations/:id/merchant_charge): the
+ * paused card request the create read and the merchant's answers after it that the
+ * profile's after-payment rules read, projected; null when the profile reads none, none
+ * came, or none the API's reading ties to this card request.
+ */
+export function merchantChargeReport(log, profileId, approved) {
+    const after = log.exchanges().filter((exchange) => exchange.completedAt >= approved.card.pausedAt);
+    const sent = merchantAmountExchanges(profileId, 'charged', { card: approved.card, responses: after });
+    if (!sent.ok || sent.responses.length === 0)
+        return null;
+    // Only a confirmation the API's own reading ties to this card request counts: another
+    // payment's on the same page (another order) is never sent under this approval.
+    if (!chargeReads(profileId, { card: approved.card, responses: sent.responses }))
+        return null;
+    return {
+        request: { url: approved.card.url, method: approved.card.method, body: approved.card.body },
+        responses: sent.responses.map(exchangeWire),
+    };
+}