@conto_finance/sdk 0.6.0-beta.1 → 0.6.0

package/dist/index.js

@@ -46,7 +46,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@conto_finance/sdk",
-      version: "0.6.0-beta.1",
+      version: "0.6.0",
       description: "Conto SDK for AI agent payment authorization",
       main: "./dist/index.js",
       module: "./dist/index.mjs",
@@ -71,16 +71,10 @@ var require_package = __commonJS({
           types: "./dist/checkout-verifier.d.ts",
           import: "./dist/checkout-verifier.mjs",
           require: "./dist/checkout-verifier.js"
-        },
-        "./link-testing": {
-          types: "./dist/link-testing.d.ts",
-          import: "./dist/link-testing.mjs",
-          require: "./dist/link-testing.js"
         }
       },
       publishConfig: {
-        access: "public",
-        tag: "beta"
+        access: "public"
       },
       engines: {
         node: ">=20.19.0"
@@ -93,7 +87,7 @@ var require_package = __commonJS({
         dev: "tsup --watch",
         lint: "tsc --noEmit",
         test: "npm run lint && npm run test:contract && npm run test:consumer",
-        "test:contract": "npm run build && node --test test/contract.test.mjs test/playwright.test.mjs test/browserbase.test.mjs test/checkout-verifier.test.mjs test/developer-experience.test.mjs test/link.test.mjs test/link-testing.test.mjs",
+        "test:contract": "npm run build && node --test test/contract.test.mjs test/playwright.test.mjs test/browserbase.test.mjs test/checkout-verifier.test.mjs test/developer-experience.test.mjs test/checkout.test.mjs",
         "test:consumer": "npm run build && node --test test/consumer.test.mjs",
         "verify:release": "node scripts/verify-release.mjs",
         prepublishOnly: "npm run verify:release && npm run lint && npm run test:contract && npm run test:consumer"
@@ -159,6 +153,12 @@ __export(index_exports, {
   BrowserActionFinalizationPendingError: () => BrowserActionFinalizationPendingError,
   BrowserCheckoutTargetVerificationError: () => BrowserCheckoutTargetVerificationError,
   CardsClient: () => CardsClient,
+  CheckoutApprovalDeniedError: () => CheckoutApprovalDeniedError,
+  CheckoutApprovalExpiredError: () => CheckoutApprovalExpiredError,
+  CheckoutApprovalPendingError: () => CheckoutApprovalPendingError,
+  CheckoutApprovalTimeoutError: () => CheckoutApprovalTimeoutError,
+  CheckoutCheckpointClosedError: () => CheckoutCheckpointClosedError,
+  CheckoutClient: () => CheckoutClient,
   ConnectedCardsClient: () => ConnectedCardsClient,
   Conto: () => Conto,
   ContoAdmin: () => ContoAdmin,
@@ -167,8 +167,6 @@ __export(index_exports, {
   ControlledExternalCardPaymentTool: () => ControlledExternalCardPaymentTool,
   ExternalCardConfirmationPendingError: () => ExternalCardConfirmationPendingError,
   Giro: () => Conto,
-  LinkClient: () => LinkClient,
-  LinkPaymentExecutionError: () => LinkPaymentExecutionError,
   TestCardsClient: () => TestCardsClient,
   canonicalizeBrowserCheckoutTarget: () => canonicalizeBrowserCheckoutTarget,
   createVerifiedBrowserCheckoutDriver: () => createVerifiedBrowserCheckoutDriver,
@@ -554,7 +552,6 @@ var ContoAdmin = class {
     this.cards = new AdminCardsClient(this);
     this.policies = new PoliciesClient(this);
     this.team = new TeamClient(this);
-    this.paymentRails = new PaymentRailsClient(this);
   }
   /** Make an authenticated request to the Conto API */
   async request(method, path, body) {
@@ -610,22 +607,6 @@ var ContoAdmin = class {
   }
 };
 _orgApiKey = new WeakMap();
-var PaymentRailsClient = class {
-  constructor(client) {
-    this.client = client;
-  }
-  /** Read gate and configuration readiness without calling Stripe. */
-  async getStripeLinkCheckoutReadiness() {
-    return this.client.request("GET", "/api/stripe-link/checkout-readiness");
-  }
-  /**
-   * Ask Conto to verify that its configured Stripe credential resolves to its
-   * configured merchant account. This call never returns either identifier.
-   */
-  async verifyStripeLinkCheckoutAccount() {
-    return this.client.request("POST", "/api/stripe-link/checkout-readiness");
-  }
-};
 var AdminCardsClient = class {
   constructor(client) {
     this.client = client;
@@ -696,8 +677,11 @@ var AdminCardsClient = class {
     return this.client.request("GET", `/api/external-cards/requests${suffix ? `?${suffix}` : ""}`);
   }
   /**
-   * Resolve a claimed execution after checking the customer's processor or
-   * receipt. Resolving NOT_EXECUTED releases the reserved policy amount.
+   * @deprecated Resolution requires a signed-in user. SDK admin keys and
+   * organization API keys receive HTTP 403 INSUFFICIENT_PERMISSIONS from this
+   * endpoint. Have a signed-in organization owner or admin review the processor
+   * evidence and resolve the request through Conto's authenticated interface.
+   * Retained for source compatibility; this method does not bypass that restriction.
    */
   async resolveRequest(requestId, input) {
     return this.client.request(
@@ -1077,27 +1061,6 @@ var ContoError = class extends Error {
     }
   }
 };
-var LinkPaymentExecutionError = class extends ContoError {
-  constructor(executionId, error) {
-    const original = error instanceof ContoError ? error : void 0;
-    super(
-      original?.message ?? "Link execution could not be confirmed",
-      {
-        code: original?.code ?? "LINK_EXECUTION_UNCONFIRMED",
-        status: original?.status ?? 0,
-        requestId: original?.requestId,
-        retryAfter: original?.retryAfter,
-        fieldErrors: original?.fieldErrors,
-        reasons: original?.reasons,
-        retryGuidance: "Call link.status(executionId) to reconcile. Do not create another purchase or retry execution blindly."
-      },
-      original?.diagnostics
-    );
-    this.nextAction = "RECONCILE";
-    this.name = "LinkPaymentExecutionError";
-    this.executionId = executionId;
-  }
-};
 var ExternalCardConfirmationPendingError = class extends ContoError {
   constructor(requestId, confirmationInput, receipt) {
     super("External card execution completed but confirmation is pending", {
@@ -1125,6 +1088,52 @@ var BrowserActionFinalizationPendingError = class extends ContoError {
     this.observation = input.observation;
   }
 };
+var CheckoutCheckpointClosedError = class extends ContoError {
+  constructor(checkpoint, message = `The checkpoint is ${checkpoint.stage.toLowerCase().replace(/_/g, " ")}. Stop this checkout.`, code = "CHECKOUT_CHECKPOINT_CLOSED") {
+    super(message, { code, status: 0 });
+    this.name = "CheckoutCheckpointClosedError";
+    this.checkpoint = checkpoint;
+    this.stage = checkpoint.stage;
+  }
+};
+var CheckoutApprovalDeniedError = class extends CheckoutCheckpointClosedError {
+  constructor(checkpoint) {
+    super(checkpoint, "The owner rejected this purchase. Do not pay.", "CHECKOUT_APPROVAL_DENIED");
+    this.name = "CheckoutApprovalDeniedError";
+  }
+};
+var CheckoutApprovalExpiredError = class extends CheckoutCheckpointClosedError {
+  constructor(checkpoint) {
+    super(
+      checkpoint,
+      "The owner did not approve this purchase in time. Do not pay.",
+      "CHECKOUT_APPROVAL_EXPIRED"
+    );
+    this.name = "CheckoutApprovalExpiredError";
+  }
+};
+var CheckoutApprovalPendingError = class extends ContoError {
+  constructor(checkpoint) {
+    super("The owner has not approved this purchase yet. Do not pay.", {
+      code: "CHECKOUT_APPROVAL_PENDING",
+      status: 0,
+      retryGuidance: "Call checkout.waitForApproval(error.checkpoint), then confirm the approved checkpoint."
+    });
+    this.name = "CheckoutApprovalPendingError";
+    this.checkpoint = checkpoint;
+  }
+};
+var CheckoutApprovalTimeoutError = class extends ContoError {
+  constructor(checkpoint) {
+    super("The owner has not decided yet. Do not pay.", {
+      code: "CHECKOUT_APPROVAL_TIMEOUT",
+      status: 0,
+      retryGuidance: "Wait again with checkout.waitForApproval, or call checkout.cancel to release the held spend."
+    });
+    this.name = "CheckoutApprovalTimeoutError";
+    this.checkpoint = checkpoint;
+  }
+};
 function generatedIdempotencyKey(prefix) {
   return `${prefix}_${(0, import_node_crypto2.randomUUID)()}`;
 }
@@ -1187,7 +1196,7 @@ var Conto = class {
     this.baseUrl = (config.baseUrl || "https://conto.finance").replace(/\/$/, "");
     assertSecureBaseUrl(this.baseUrl);
     this.timeout = config.timeout || 3e4;
-    this.link = new LinkClient(this, config.link);
+    this.checkout = new CheckoutClient(this);
     this.payments = new PaymentsClient(this);
     this.cards = new CardsClient(this);
     this.connectedCards = new ConnectedCardsClient(this);
@@ -1195,31 +1204,6 @@ var Conto = class {
     this.x402 = new X402Client(this);
     this.mpp = new MppClient(this);
   }
-  /**
-   * List masked Link payment methods for a session-created connection that is
-   * explicitly bound to this agent. No Link token or payment artifact is
-   * returned through the agent SDK.
-   */
-  async listStripeLinkPaymentMethods(connectionId, options) {
-    return this.request(
-      "GET",
-      withQuery("/api/sdk/stripe-link/payment-methods", {
-        connectionId,
-        ...options?.mode ? { mode: options.mode } : {}
-      })
-    );
-  }
-  /** Read live Link configuration diagnostics without retrieving credentials or authorizing payment. */
-  async getLinkSetup(input = {}) {
-    return this.request(
-      "GET",
-      withQuery("/api/sdk/stripe-link/setup", {
-        connectionId: input.connectionId,
-        paymentMethodId: input.paymentMethodId,
-        merchantId: input.merchantId
-      })
-    );
-  }
   /**
    * Normalize and durably revise a partial agent purchase proposal without
    * creating a payment side effect. Missing facts return as NEEDS_CONTEXT
@@ -1300,6 +1284,22 @@ var Conto = class {
       rethrowAmbiguousCommerceMutation(error, executionId, "authorize");
     }
   }
+  /**
+   * Report whether an authorized guarded browser checkout was paid. PAID keeps
+   * the held spend counted, NOT_PAID releases it, and UNKNOWN keeps it held for
+   * the owner to review. Safe to repeat with the same outcome.
+   */
+  async reportCommerceExecutionOutcome(executionId, input) {
+    return this.request(
+      "POST",
+      `/api/sdk/commerce-executions/${encodeURIComponent(executionId)}/outcome`,
+      {
+        outcome: input.outcome,
+        ...input.reference ? { reference: input.reference } : {}
+      },
+      { idempotent: true }
+    );
+  }
   /** Claim a durable browser action for one stable privileged-runtime attempt. */
   async claimBrowserAction(authorizationId, dispatchAttemptId, browserSessionId, action) {
     return this.request(
@@ -2147,181 +2147,222 @@ var MppClient = class {
   }
 };
 var index_default = Conto;
-var _client, _defaults;
-var LinkClient = class {
-  constructor(client, defaults) {
+function checkoutError(message, code = "INVALID_CHECKOUT_CHECKPOINT") {
+  return new ContoError(message, { code, status: 0 });
+}
+function checkpointCart(amountMinor, lineItems, totals) {
+  if (!Number.isSafeInteger(amountMinor) || amountMinor <= 0) {
+    throw checkoutError("amountMinor must be a positive integer number of cents");
+  }
+  if (!Array.isArray(lineItems) || lineItems.length === 0) {
+    throw checkoutError("Supply at least one line item");
+  }
+  return {
+    lineItems,
+    totals: totals ?? [{ type: "total", label: "Total", amountMinor }]
+  };
+}
+var CLOSED_CHECKPOINT_STAGES = [
+  "DENIED",
+  "CANCELLED",
+  "EXPIRED",
+  "NOT_PAID"
+];
+function closedCheckpointError(checkpoint) {
+  if (checkpoint.approval?.status === "DENIED") return new CheckoutApprovalDeniedError(checkpoint);
+  if (checkpoint.approval?.status === "EXPIRED") {
+    return new CheckoutApprovalExpiredError(checkpoint);
+  }
+  return new CheckoutCheckpointClosedError(checkpoint);
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(signal.reason ?? new Error("Aborted"));
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal?.reason ?? new Error("Aborted"));
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+var _client;
+var CheckoutClient = class {
+  constructor(client) {
     __privateAdd(this, _client);
-    __privateAdd(this, _defaults);
     __privateSet(this, _client, client);
-    __privateSet(this, _defaults, defaults ? { ...defaults } : void 0);
-  }
-  /** Inspect the configured live path. This is not a payment authorization or provider connectivity test. */
-  async setup(input = {}) {
-    return __privateGet(this, _client).getLinkSetup({
-      connectionId: input.connectionId ?? __privateGet(this, _defaults)?.connectionId,
-      paymentMethodId: input.paymentMethodId ?? __privateGet(this, _defaults)?.paymentMethodId,
-      merchantId: input.merchantId
-    });
-  }
-  /** Read masked LIVE funding sources; never selects a source or initiates payment. */
-  async paymentMethods(connectionId) {
-    return __privateGet(this, _client).listStripeLinkPaymentMethods(
-      this.identifier(connectionId ?? __privateGet(this, _defaults)?.connectionId, "connectionId"),
-      { mode: "LIVE" }
-    );
   }
   /**
-   * Begin one exact intent and execute only if already READY. Otherwise return
-   * the owner's approval action or existing state immediately, without polling.
+   * First checkpoint. Open the payment method only when the stage is APPROVED.
+   * AWAITING_APPROVAL means the owner must decide first: call waitForApproval().
+   * A ContoError means Conto did not approve: stop the checkout. A
+   * CheckoutCheckpointClosedError means this idempotency key belongs to a
+   * checkpoint that already closed.
    */
-  async pay(input) {
-    const connectionId = this.identifier(
-      input.connectionId ?? __privateGet(this, _defaults)?.connectionId,
-      "connectionId"
-    );
-    const paymentMethodId = this.identifier(
-      input.paymentMethodId ?? __privateGet(this, _defaults)?.paymentMethodId,
-      "paymentMethodId"
-    );
-    if (!Number.isSafeInteger(input.amountMinor) || input.amountMinor <= 0 || input.currency !== void 0 && input.currency !== "USD" || !Array.isArray(input.lineItems) || input.lineItems.length === 0 || typeof input.purpose !== "string" || !input.purpose.trim()) {
-      throw new ContoError("Supply a positive USD amount in cents, purpose, and line items", {
-        code: "INVALID_LINK_PURCHASE",
-        status: 0
-      });
-    }
-    const itemTotal = input.lineItems.reduce((sum, item) => {
-      if (!item || typeof item.name !== "string" || !item.name.trim() || !Number.isSafeInteger(item.quantity) || item.quantity <= 0 || !Number.isSafeInteger(item.unitAmountMinor) || item.unitAmountMinor < 0) {
-        throw new ContoError(
-          "Each line item needs a name, positive integer quantity, and price in cents",
-          {
-            code: "INVALID_LINK_PURCHASE",
-            status: 0
-          }
-        );
-      }
-      return sum + item.quantity * item.unitAmountMinor;
-    }, 0);
-    if (!input.totals && (!Number.isSafeInteger(itemTotal) || itemTotal !== input.amountMinor)) {
-      throw new ContoError(
-        "Supply the exact totals breakdown when the amount differs from the line items",
-        {
-          code: "LINK_TOTALS_REQUIRED",
-          status: 0
-        }
+  async begin(input) {
+    const idempotencyKey = input.idempotencyKey?.trim();
+    if (!idempotencyKey || idempotencyKey.length < 8 || idempotencyKey.length > 255) {
+      throw checkoutError(
+        "idempotencyKey must contain 8 to 255 characters",
+        "INVALID_IDEMPOTENCY_KEY"
       );
     }
-    const result = await __privateGet(this, _client).beginCommerceExecution({
-      executionMethod: "LINK_PAY_TOKEN",
-      connectionId,
-      paymentMethodId,
-      idempotencyKey: input.idempotencyKey,
-      amountMinor: input.amountMinor,
-      currency: input.currency ?? "USD",
-      purpose: input.purpose,
-      category: input.category,
-      counterparty: { canonicalId: input.merchantId, checkoutUrl: input.checkoutUrl },
-      cart: {
-        lineItems: input.lineItems,
-        totals: input.totals ?? [{ type: "total", label: "Total", amountMinor: input.amountMinor }]
+    if (input.currency !== void 0 && input.currency !== "USD") {
+      throw checkoutError("Only USD checkouts are supported");
+    }
+    const result = await __privateGet(this, _client).request(
+      "POST",
+      "/api/sdk/checkout-checkpoints",
+      {
+        idempotencyKey,
+        merchant: input.merchant,
+        amountMinor: input.amountMinor,
+        currency: "USD",
+        purpose: input.purpose,
+        ...input.category ? { category: input.category } : {},
+        ...input.checkoutMethod ? { checkoutMethod: input.checkoutMethod } : {},
+        cart: checkpointCart(input.amountMinor, input.lineItems, input.totals)
       },
-      providerPresentation: {
-        approvalSummary: input.purpose.trim().slice(0, 500),
-        lineItemLabels: input.lineItems.map((item) => item.name.trim().slice(0, 120))
-      }
-    });
-    return this.executeIfReady(result);
+      { idempotent: true }
+    );
+    if (CLOSED_CHECKPOINT_STAGES.includes(result.checkpoint.stage)) {
+      throw closedCheckpointError(result.checkpoint);
+    }
+    return result.checkpoint;
   }
   /**
-   * Continue the existing payment after approval. Reads before any mutation and
-   * never submits an execution already processing or requiring reconciliation.
+   * Waits while the owner decides on a checkpoint in AWAITING_APPROVAL and
+   * resolves to the approved checkpoint. Throws CheckoutApprovalDeniedError,
+   * CheckoutApprovalExpiredError, CheckoutCheckpointClosedError, or
+   * CheckoutApprovalTimeoutError (the spend stays held until you cancel).
    */
-  async resume(executionId) {
-    const id = this.identifier(executionId, "executionId");
-    const current = await __privateGet(this, _client).getCommerceExecution(id);
-    this.assertLinkExecution(current);
-    if (["AUTHORIZING", "AWAITING_APPROVAL", "ACTION_REQUIRED"].includes(current.execution.status)) {
-      return this.executeIfReady(await __privateGet(this, _client).refreshCommerceExecution(id));
-    }
-    return this.executeIfReady(current);
-  }
-  /** Observe and reconcile provider state. This method never submits a payment. */
-  async status(executionId) {
-    const id = this.identifier(executionId, "executionId");
-    this.assertLinkExecution(await __privateGet(this, _client).getCommerceExecution(id));
-    return this.result(await __privateGet(this, _client).refreshCommerceExecution(id));
-  }
-  /** Request cancellation of this existing Link payment; never retried automatically. */
-  async cancel(executionId) {
-    const id = this.identifier(executionId, "executionId");
-    this.assertLinkExecution(await __privateGet(this, _client).getCommerceExecution(id));
-    try {
-      return this.result(await __privateGet(this, _client).cancelCommerceExecution(id));
-    } catch (error) {
-      throw new LinkPaymentExecutionError(id, error);
+  async waitForApproval(checkpoint, options = {}) {
+    const timeoutMs = options.timeoutMs ?? 10 * 6e4;
+    const pollIntervalMs = Math.max(1e3, options.pollIntervalMs ?? 5e3);
+    const deadline = Date.now() + timeoutMs;
+    let current = checkpoint;
+    for (; ; ) {
+      if (current.stage !== "AWAITING_APPROVAL") {
+        if (CLOSED_CHECKPOINT_STAGES.includes(current.stage)) throw closedCheckpointError(current);
+        return current;
+      }
+      const remaining = deadline - Date.now();
+      if (remaining <= 0) throw new CheckoutApprovalTimeoutError(current);
+      await sleep(Math.min(pollIntervalMs, remaining), options.signal);
+      current = await this.get(current.id);
     }
   }
-  identifier(value, field) {
-    if (typeof value !== "string" || !value.trim() || value.length > 255) {
-      throw new ContoError(
-        field === "executionId" ? "executionId is required; use the existing ID returned by link.pay()" : `${field} is required; configure the owner-provisioned Link IDs or supply them explicitly`,
-        {
-          code: "LINK_CONFIGURATION_REQUIRED",
-          status: 0
-        }
-      );
+  /**
+   * Second checkpoint, right before the payment is submitted. If the total
+   * changed since begin() (tax or shipping, for example), this cancels the
+   * approved checkpoint and starts a new one at the final total, so the agent's
+   * rules see the amount actually being paid. Pay only if this resolves. A
+   * CheckoutApprovalPendingError means the owner must approve first: call
+   * waitForApproval(error.checkpoint), then confirm the checkpoint it returns.
+   */
+  async confirm(checkpoint, input) {
+    if (input.currency !== void 0 && input.currency !== "USD") {
+      throw checkoutError("Only USD checkouts are supported");
     }
-    return value.trim();
-  }
-  assertLinkExecution(result) {
-    const execution = result.execution;
-    if (execution?.provider !== "STRIPE_LINK" || execution.executionAdapter !== "STRIPE_LINK" || execution.executionChannel !== "BROWSER" || execution.artifactKind !== void 0 && execution.artifactKind !== "LINK_PAY_TOKEN" || execution.deliveryMode !== void 0 && execution.deliveryMode !== "SERVER_ONLY_ARTIFACT") {
-      throw new ContoError("This execution is not a Link Pay Token checkout", {
-        code: "LINK_EXECUTION_MISMATCH",
-        status: 0
+    if (!Number.isSafeInteger(input.amountMinor) || input.amountMinor <= 0) {
+      throw checkoutError("amountMinor must be a positive integer number of cents");
+    }
+    let current = checkpoint;
+    if (input.amountMinor !== checkpoint.amountMinor) {
+      try {
+        await this.cancel(checkpoint.id);
+      } catch (error) {
+        const closed = error instanceof ContoError && error.status === 409 && ["CANCELLED", "EXPIRED", "DENIED"].includes((await this.get(checkpoint.id)).stage);
+        if (!closed) throw error;
+      }
+      current = await this.begin({
+        idempotencyKey: `${checkpoint.idempotencyKey.slice(0, 200)}:final-${input.amountMinor}`,
+        merchant: {
+          id: checkpoint.merchant.id,
+          name: checkpoint.merchant.name,
+          checkoutUrl: checkpoint.merchant.checkoutUrl ?? ""
+        },
+        amountMinor: input.amountMinor,
+        purpose: checkpoint.purpose,
+        ...checkpoint.category ? { category: checkpoint.category } : {},
+        checkoutMethod: checkpoint.checkoutMethod,
+        lineItems: input.lineItems ?? checkpoint.cart.lineItems,
+        totals: input.totals
       });
+      if (current.stage === "AWAITING_APPROVAL") throw new CheckoutApprovalPendingError(current);
     }
-  }
-  async executeIfReady(result) {
-    this.assertLinkExecution(result);
-    if (result.execution.status !== "READY") return this.result(result);
     try {
-      return this.result(await __privateGet(this, _client).executeCommerceExecution(result.execution.id));
+      const result = await __privateGet(this, _client).request(
+        "POST",
+        `/api/sdk/checkout-checkpoints/${encodeURIComponent(current.id)}/confirm`,
+        {
+          amountMinor: input.amountMinor,
+          currency: "USD",
+          ...input.pageUrl ? { pageUrl: input.pageUrl } : {}
+        },
+        { idempotent: true }
+      );
+      return result.checkpoint;
     } catch (error) {
-      throw new LinkPaymentExecutionError(result.execution.id, error);
+      if (error instanceof ContoError && error.status === 409 && error.code === "APPROVAL_REQUIRED") {
+        const latest = await this.get(current.id);
+        if (latest.stage === "AWAITING_APPROVAL") throw new CheckoutApprovalPendingError(latest);
+      }
+      throw error;
     }
   }
-  result(result) {
-    this.assertLinkExecution(result);
-    const { execution } = result;
-    const awaitingApproval = ["AUTHORIZING", "AWAITING_APPROVAL", "ACTION_REQUIRED"].includes(
-      execution.status
-    );
-    const nextAction = execution.status === "READY" ? "RESUME" : execution.status === "NEEDS_RECONCILIATION" ? "RECONCILE" : awaitingApproval && execution.approvalUrl ? "APPROVE_IN_LINK" : awaitingApproval || ["DRAFT", "PROCESSING"].includes(execution.status) ? "WAIT" : [
-      "SETTLED",
-      "COMPLETED",
-      "DENIED",
-      "CANCELLED",
-      "FAILED",
-      "RETURNED",
-      "EXPIRED"
-    ].includes(execution.status) ? "NONE" : "RECONCILE";
-    return {
-      executionId: execution.id,
-      status: execution.status,
-      nextAction,
-      ...nextAction === "APPROVE_IN_LINK" ? { approvalUrl: execution.approvalUrl } : {},
-      execution,
-      ..."checkout" in result ? { checkout: result.checkout } : {}
-    };
+  /** Report what happened after a confirmed checkpoint. Safe to repeat with the same outcome. */
+  async reportOutcome(checkpointId, input) {
+    const result = await __privateGet(this, _client).request(
+      "POST",
+      `/api/sdk/checkout-checkpoints/${encodeURIComponent(checkpointId)}/outcome`,
+      {
+        outcome: input.outcome,
+        ...input.reference ? { reference: input.reference } : {}
+      },
+      { idempotent: true }
+    );
+    return result.checkpoint;
+  }
+  /**
+   * Cancel a checkpoint that was not confirmed and release its spend. A
+   * checkpoint waiting for the owner can be cancelled too.
+   */
+  async cancel(checkpointId) {
+    const result = await __privateGet(this, _client).request(
+      "POST",
+      `/api/sdk/checkout-checkpoints/${encodeURIComponent(checkpointId)}/cancel`,
+      {},
+      { idempotent: true }
+    );
+    return result.checkpoint;
+  }
+  async get(checkpointId) {
+    const result = await __privateGet(this, _client).request(
+      "GET",
+      `/api/sdk/checkout-checkpoints/${encodeURIComponent(checkpointId)}`
+    );
+    return result.checkpoint;
   }
 };
 _client = new WeakMap();
-_defaults = new WeakMap();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BrowserActionFinalizationPendingError,
   BrowserCheckoutTargetVerificationError,
   CardsClient,
+  CheckoutApprovalDeniedError,
+  CheckoutApprovalExpiredError,
+  CheckoutApprovalPendingError,
+  CheckoutApprovalTimeoutError,
+  CheckoutCheckpointClosedError,
+  CheckoutClient,
   ConnectedCardsClient,
   Conto,
   ContoAdmin,
@@ -2330,8 +2371,6 @@ _defaults = new WeakMap();
   ControlledExternalCardPaymentTool,
   ExternalCardConfirmationPendingError,
   Giro,
-  LinkClient,
-  LinkPaymentExecutionError,
   TestCardsClient,
   canonicalizeBrowserCheckoutTarget,
   createVerifiedBrowserCheckoutDriver,