@agent-cards/checkout 0.19.0 → 0.22.0

package/dist/merchant-total.d.ts

@@ -1,257 +0,0 @@
-/** 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

@@ -1,383 +0,0 @@
-/**
- * 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),
-    };
-}

package/dist/owned-shop.generated.d.ts

@@ -1,24 +0,0 @@
-declare var OWNED_SHOP_OPERATION: string;
-declare var OWNED_SHOP_SKU: string;
-declare var OWNED_SHOP_AMOUNT_CENTS: number;
-declare var OWNED_SHOP_CURRENCY: string;
-declare var OWNED_SHOP_ORDER_FIELD: string;
-declare function isOwnedShopPaymentIntentId(value: any): boolean;
-declare function serializeOwnedShopOrder(value: any): string;
-declare function hasOwnedShopMarker(request: any): any;
-declare function parseOwnedShopOrder(request: any): {
-    order_id: any;
-    sku: string;
-    amount: number;
-    currency: string;
-} | null;
-declare function parseOwnedShopReceipt(value: any, expectedOrder: any): {
-    object: string;
-    order_id: any;
-    payment_intent_id: any;
-    status: string;
-    amount: number;
-    currency: string;
-    livemode: boolean;
-} | null;
-export { OWNED_SHOP_AMOUNT_CENTS, OWNED_SHOP_CURRENCY, OWNED_SHOP_OPERATION, OWNED_SHOP_ORDER_FIELD, OWNED_SHOP_SKU, hasOwnedShopMarker, isOwnedShopPaymentIntentId, parseOwnedShopOrder, parseOwnedShopReceipt, serializeOwnedShopOrder };