@conto_finance/sdk 0.6.0 → 0.6.2-beta.1

package/dist/index.js

@@ -40,13 +40,14 @@ var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot
 var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
 var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
 
 // package.json
 var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@conto_finance/sdk",
-      version: "0.6.0",
+      version: "0.6.2-beta.1",
       description: "Conto SDK for AI agent payment authorization",
       main: "./dist/index.js",
       module: "./dist/index.mjs",
@@ -71,10 +72,16 @@ var require_package = __commonJS({
           types: "./dist/checkout-verifier.d.ts",
           import: "./dist/checkout-verifier.mjs",
           require: "./dist/checkout-verifier.js"
+        },
+        "./link-wallet": {
+          types: "./dist/link-wallet.d.ts",
+          import: "./dist/link-wallet.mjs",
+          require: "./dist/link-wallet.js"
         }
       },
       publishConfig: {
-        access: "public"
+        access: "public",
+        tag: "beta"
       },
       engines: {
         node: ">=20.19.0"
@@ -87,7 +94,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/checkout.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/link-wallet.test.mjs test/purchases.test.mjs test/allowances.test.mjs test/purchase-watch-lifecycle.test.mjs ../../examples/link-wallet-agent/verify.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"
@@ -112,7 +119,7 @@ var require_package = __commonJS({
         email: "support@conto.finance"
       },
       dependencies: {
-        "@sentry/node": "^10.63.0"
+        "@sentry/node": "^10.73.0"
       },
       peerDependencies: {
         "playwright-core": ">=1.50.0"
@@ -150,6 +157,7 @@ var require_package_version = __commonJS({
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AdminPurchasingClient: () => AdminPurchasingClient,
   BrowserActionFinalizationPendingError: () => BrowserActionFinalizationPendingError,
   BrowserCheckoutTargetVerificationError: () => BrowserCheckoutTargetVerificationError,
   CardsClient: () => CardsClient,
@@ -167,17 +175,494 @@ __export(index_exports, {
   ControlledExternalCardPaymentTool: () => ControlledExternalCardPaymentTool,
   ExternalCardConfirmationPendingError: () => ExternalCardConfirmationPendingError,
   Giro: () => Conto,
+  LinkCardDeniedError: () => LinkCardDeniedError,
+  LinkCardError: () => LinkCardError,
+  LinkCardExpiredError: () => LinkCardExpiredError,
+  LinkCardTimeoutError: () => LinkCardTimeoutError,
+  LinkWalletUnavailableError: () => LinkWalletUnavailableError,
+  OrganizationPurchasesClient: () => OrganizationPurchasesClient,
+  OrganizationRecurringPurchasesClient: () => OrganizationRecurringPurchasesClient,
+  PurchasesClient: () => PurchasesClient,
+  RecurringPurchasesClient: () => RecurringPurchasesClient,
   TestCardsClient: () => TestCardsClient,
   canonicalizeBrowserCheckoutTarget: () => canonicalizeBrowserCheckoutTarget,
   createVerifiedBrowserCheckoutDriver: () => createVerifiedBrowserCheckoutDriver,
   default: () => index_default,
-  fingerprintBrowserCheckoutTarget: () => fingerprintBrowserCheckoutTarget
+  fingerprintBrowserCheckoutTarget: () => fingerprintBrowserCheckoutTarget,
+  isFinalPurchaseStatus: () => isFinalPurchaseStatus,
+  parseServerSentEvents: () => parseServerSentEvents,
+  verifyPurchaseWebhook: () => verifyPurchaseWebhook
 });
 module.exports = __toCommonJS(index_exports);
 var Sentry2 = __toESM(require("@sentry/node"));
-var import_node_crypto2 = require("crypto");
+var import_node_crypto3 = require("crypto");
 var import_package_version2 = __toESM(require_package_version());
 
+// src/purchases.ts
+var import_node_crypto = require("crypto");
+var TERMINAL = /* @__PURE__ */ new Set(["succeeded", "blocked", "failed", "cancelled"]);
+var isFinalPurchaseStatus = (status) => TERMINAL.has(status);
+async function* parseServerSentEvents(body, signal) {
+  const reader = body.getReader();
+  const cancel = () => {
+    void reader.cancel().catch(() => {
+    });
+  };
+  signal?.addEventListener("abort", cancel, { once: true });
+  if (signal?.aborted) cancel();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let frame = { data: [] };
+  try {
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done || signal?.aborted) break;
+      buffer += decoder.decode(value, { stream: true });
+      let newline;
+      while ((newline = buffer.search(/\r?\n/)) >= 0) {
+        if (signal?.aborted) return;
+        const line = buffer.slice(0, newline);
+        buffer = buffer.slice(newline + (buffer[newline] === "\r" ? 2 : 1));
+        if (line === "") {
+          if (frame.data.length || frame.event)
+            yield { id: frame.id, event: frame.event ?? "message", data: frame.data.join("\n") };
+          frame = { data: [] };
+          continue;
+        }
+        if (line.startsWith(":")) continue;
+        const colon = line.indexOf(":");
+        const field = colon < 0 ? line : line.slice(0, colon);
+        const raw = colon < 0 ? "" : line.slice(colon + 1).replace(/^ /, "");
+        if (field === "id") frame.id = raw;
+        else if (field === "event") frame.event = raw;
+        else if (field === "data") frame.data.push(raw);
+      }
+    }
+  } finally {
+    signal?.removeEventListener("abort", cancel);
+    await reader.cancel().catch(() => {
+    });
+    reader.releaseLock();
+  }
+}
+var sleep = (ms, signal) => new Promise((resolve) => {
+  if (signal?.aborted) return resolve();
+  const finish = () => {
+    clearTimeout(timer);
+    signal?.removeEventListener("abort", finish);
+    resolve();
+  };
+  const timer = setTimeout(finish, ms);
+  signal?.addEventListener("abort", finish, { once: true });
+});
+function watchRead(pending, signal) {
+  return new Promise((resolve, reject) => {
+    const abort = () => reject(new DOMException("Watch stopped", "AbortError"));
+    signal.addEventListener("abort", abort, { once: true });
+    if (signal.aborted) abort();
+    pending.then(resolve, reject).finally(() => signal.removeEventListener("abort", abort));
+  });
+}
+function requirePurchaseId(id) {
+  if (!/^[a-z0-9]{8,64}$/i.test(id)) throw new TypeError("purchase id is not valid");
+  return encodeURIComponent(id);
+}
+function requireCycleKey(key) {
+  if (!/^[A-Za-z0-9._:-]{1,100}$/.test(key)) throw new TypeError("cycleKey is not valid");
+  return encodeURIComponent(key);
+}
+var _transport, _base;
+var RecurringPurchasesClient = class {
+  constructor(transport, basePath = "/api/sdk/recurring-purchases") {
+    __privateAdd(this, _transport);
+    __privateAdd(this, _base);
+    __privateSet(this, _transport, transport);
+    __privateSet(this, _base, basePath);
+  }
+  async list(buyerId) {
+    return __privateGet(this, _transport).request(
+      "GET",
+      buyerId ? `${__privateGet(this, _base)}?buyerId=${encodeURIComponent(buyerId)}` : __privateGet(this, _base)
+    );
+  }
+  async get(id) {
+    return __privateGet(this, _transport).request("GET", `${__privateGet(this, _base)}/${requirePurchaseId(id)}`);
+  }
+  /** Starts one order. The same cycle key returns the same order. */
+  async startCycle(id, cycleKey) {
+    requireCycleKey(cycleKey);
+    return __privateGet(this, _transport).request(
+      "POST",
+      `${__privateGet(this, _base)}/${requirePurchaseId(id)}/cycles`,
+      { cycleKey },
+      { idempotent: true }
+    );
+  }
+  /** Skips one order, also before it starts. */
+  async skipCycle(id, cycleKey) {
+    return __privateGet(this, _transport).request(
+      "POST",
+      `${__privateGet(this, _base)}/${requirePurchaseId(id)}/cycles/${requireCycleKey(cycleKey)}/skip`
+    );
+  }
+};
+_transport = new WeakMap();
+_base = new WeakMap();
+var _client;
+var OrganizationRecurringPurchasesClient = class extends RecurringPurchasesClient {
+  constructor(client) {
+    super(client, "/api/purchasing/recurring-purchases");
+    __privateAdd(this, _client);
+    __privateSet(this, _client, client);
+  }
+  /** Stops a repeat order. An order waiting for its payment time closes unpaid. */
+  async cancel(id) {
+    return __privateGet(this, _client).request(
+      "POST",
+      `/api/purchasing/recurring-purchases/${requirePurchaseId(id)}/cancel`
+    );
+  }
+};
+_client = new WeakMap();
+var _transport2, _base2;
+var PurchasesClient = class {
+  constructor(transport, basePath = "/api/sdk/purchases") {
+    __privateAdd(this, _transport2);
+    __privateAdd(this, _base2);
+    __privateSet(this, _transport2, transport);
+    __privateSet(this, _base2, basePath);
+  }
+  /**
+   * Starts a purchase and returns at once. Reusing the idempotency key with the
+   * same input returns the same purchase, so retrying after a lost response is safe.
+   */
+  async create(input, options) {
+    const idempotencyKey = options?.idempotencyKey?.trim();
+    if (!idempotencyKey || idempotencyKey.length < 8 || idempotencyKey.length > 255)
+      throw new TypeError("idempotencyKey must contain 8 to 255 characters");
+    if (!Number.isSafeInteger(input.maxCost?.amountMinor) || input.maxCost.amountMinor <= 0)
+      throw new TypeError("maxCost.amountMinor must be a positive integer");
+    return __privateGet(this, _transport2).request(
+      "POST",
+      __privateGet(this, _base2),
+      { ...input, idempotencyKey },
+      { idempotent: true }
+    );
+  }
+  async list(params = {}) {
+    const query = new URLSearchParams();
+    for (const [key, value] of Object.entries(params))
+      if (value !== void 0) query.set(key, String(value));
+    const suffix = query.toString();
+    return __privateGet(this, _transport2).request("GET", `${__privateGet(this, _base2)}${suffix ? `?${suffix}` : ""}`);
+  }
+  async get(id) {
+    return __privateGet(this, _transport2).request("GET", `${__privateGet(this, _base2)}/${requirePurchaseId(id)}`);
+  }
+  /**
+   * Answers an open action whose authority is `agent_or_buyer` with the fields
+   * it lists. The acknowledgment means recorded; the purchase shows the result.
+   * The same answer again returns the same acknowledgment.
+   */
+  async respond(id, input) {
+    return __privateGet(this, _transport2).request(
+      "POST",
+      `${__privateGet(this, _base2)}/${requirePurchaseId(id)}/responses`,
+      input,
+      { idempotent: true }
+    );
+  }
+  async events(id, params = {}) {
+    const query = new URLSearchParams({ after: String(params.after ?? 0) });
+    if (params.limit) query.set("limit", String(params.limit));
+    return __privateGet(this, _transport2).request("GET", `${__privateGet(this, _base2)}/${requirePurchaseId(id)}/events?${query}`);
+  }
+  /**
+   * Requests cancellation. Before payment the purchase stops. Once payment may
+   * have been submitted, `cancellationOutcome` is `too_late` and the purchase
+   * stays in reconciliation. Nothing is refunded by this call.
+   */
+  async cancel(id) {
+    return __privateGet(this, _transport2).request(
+      "POST",
+      `${__privateGet(this, _base2)}/${requirePurchaseId(id)}/cancel`,
+      void 0,
+      { idempotent: true }
+    );
+  }
+  /**
+   * Yields the purchase's events in version order until it reaches a final
+   * status. Streams with server-sent events and reconnects from the last
+   * version; falls back to polling where streaming is unavailable. A duplicate
+   * after a reconnect is dropped. A `purchase.resync` event carries the
+   * current purchase when the cursor could not be resumed.
+   */
+  async *watch(id, options = {}) {
+    const path = `${__privateGet(this, _base2)}/${requirePurchaseId(id)}`;
+    const mode = options.mode ?? "auto";
+    const interval = Math.max(500, options.pollIntervalMs ?? 2e3);
+    if (options.maxWaitMs !== void 0 && (!Number.isFinite(options.maxWaitMs) || options.maxWaitMs < 0 || options.maxWaitMs > 2147483647))
+      throw new TypeError("maxWaitMs must be between 0 and 2147483647");
+    if (options.signal?.aborted || options.maxWaitMs === 0) return;
+    const controller = new AbortController();
+    const signal = controller.signal;
+    const abort = () => controller.abort();
+    options.signal?.addEventListener("abort", abort, { once: true });
+    const timeout = options.maxWaitMs === void 0 ? void 0 : setTimeout(abort, options.maxWaitMs);
+    try {
+      let cursor = Math.max(0, options.after ?? 0);
+      let streaming = mode !== "poll";
+      const emit = (event) => {
+        if (event.version <= cursor && event.type !== "purchase.resync") return null;
+        cursor = Math.max(cursor, event.version);
+        return event;
+      };
+      while (!signal.aborted) {
+        if (streaming) {
+          try {
+            const response = await __privateGet(this, _transport2).openStream(
+              `${path}/events/stream?after=${cursor}`,
+              { signal, lastEventId: String(cursor) }
+            );
+            if (!response.body) throw new Error("streaming unavailable");
+            for await (const frame of parseServerSentEvents(response.body, signal)) {
+              if (frame.event === "end") return;
+              if (frame.event === "error") break;
+              if (frame.event === "resync") {
+                const purchase = JSON.parse(frame.data);
+                const event2 = {
+                  id: `resync:${purchase.version}`,
+                  purchaseId: purchase.id,
+                  version: purchase.version,
+                  type: "purchase.resync",
+                  createdAt: purchase.updatedAt,
+                  data: purchase
+                };
+                cursor = purchase.version;
+                yield event2;
+                if (isFinalPurchaseStatus(purchase.status)) return;
+                continue;
+              }
+              if (!frame.data) continue;
+              const event = emit(JSON.parse(frame.data));
+              if (!event) continue;
+              yield event;
+              if (isFinalPurchaseStatus(event.data.status)) return;
+            }
+            await sleep(interval, signal);
+            continue;
+          } catch (error) {
+            if (signal.aborted) return;
+            if (isClientError(error)) throw error;
+            if (mode === "stream") {
+              await sleep(interval, signal);
+              continue;
+            }
+            streaming = false;
+          }
+        }
+        let page;
+        try {
+          page = await watchRead(this.events(id, { after: cursor, limit: 100 }), signal);
+        } catch (error) {
+          if (codeOf(error) !== "CURSOR_INVALID") throw error;
+          const purchase = await watchRead(this.get(id), signal);
+          cursor = purchase.version;
+          yield {
+            id: `resync:${purchase.version}`,
+            purchaseId: purchase.id,
+            version: purchase.version,
+            type: "purchase.resync",
+            createdAt: purchase.updatedAt,
+            data: purchase
+          };
+          if (isFinalPurchaseStatus(purchase.status)) return;
+          continue;
+        }
+        if (signal.aborted) return;
+        for (const item of page.items) {
+          if (signal.aborted) return;
+          const event = emit(item);
+          if (!event) continue;
+          yield event;
+          if (isFinalPurchaseStatus(event.data.status)) return;
+        }
+        if (!page.hasMore) await sleep(interval, signal);
+      }
+    } catch (error) {
+      if (!signal.aborted) throw error;
+    } finally {
+      if (timeout !== void 0) clearTimeout(timeout);
+      options.signal?.removeEventListener("abort", abort);
+      controller.abort();
+    }
+  }
+};
+_transport2 = new WeakMap();
+_base2 = new WeakMap();
+var codeOf = (error) => error && typeof error === "object" && "code" in error ? String(error.code) : "";
+var isClientError = (error) => {
+  const status = error && typeof error === "object" && "status" in error ? Number(error.status) : 0;
+  return status >= 400 && status < 500 && status !== 408 && status !== 429;
+};
+var enc = encodeURIComponent;
+var _client2;
+var OrganizationPurchasesClient = class extends PurchasesClient {
+  constructor(client) {
+    super(client, "/api/purchasing/purchases");
+    __privateAdd(this, _client2);
+    __privateSet(this, _client2, client);
+  }
+  async list(params = {}) {
+    const query = new URLSearchParams();
+    for (const [key, value] of Object.entries(params))
+      if (value !== void 0) query.set(key, String(value));
+    const suffix = query.toString();
+    return __privateGet(this, _client2).request("GET", `/api/purchasing/purchases${suffix ? `?${suffix}` : ""}`);
+  }
+  /** A single-use link that opens the purchase's buyer actions on Conto's hosted page. */
+  createActionLink(id, input = {}) {
+    return __privateGet(this, _client2).request(
+      "POST",
+      `/api/purchasing/purchases/${requirePurchaseId(id)}/action-sessions`,
+      input
+    );
+  }
+};
+_client2 = new WeakMap();
+var _client3;
+var AdminPurchasingClient = class {
+  constructor(client) {
+    __privateAdd(this, _client3);
+    /** Inspect or revoke buyer-approved allowances. Grants remain on the buyer's hosted page. */
+    this.allowances = {
+      /** Returns up to 50 allowances for this buyer, newest first. */
+      list: (params) => __privateGet(this, _client3).request(
+        "GET",
+        `/api/purchasing/allowances?${new URLSearchParams({ buyerId: params.buyerId })}`
+      ),
+      get: (id) => __privateGet(this, _client3).request("GET", `/api/purchasing/allowances/${enc(id)}`),
+      /** Stops future credential release; does not undo payments already submitted. */
+      revoke: (id) => __privateGet(this, _client3).request(
+        "POST",
+        `/api/purchasing/allowances/${enc(id)}/revoke`
+      )
+    };
+    this.buyers = {
+      /** Maps one of your users to a buyer with its own agent, or returns the existing one. */
+      create: (input) => __privateGet(this, _client3).request("POST", "/api/purchasing/buyers", input),
+      get: (id) => __privateGet(this, _client3).request("GET", `/api/purchasing/buyers/${enc(id)}`),
+      list: (params = {}) => __privateGet(this, _client3).request("GET", `/api/purchasing/buyers?limit=${params.limit ?? 20}&offset=${params.offset ?? 0}`),
+      /** Stops the buyer's agent. Purchases that may already be paid stay visible. */
+      stop: (id) => __privateGet(this, _client3).request("POST", `/api/purchasing/buyers/${enc(id)}/stop`),
+      /**
+       * Lets the buyer pay with your company card within limits you set for
+       * them, or replaces those limits. The buyer must not have their own card.
+       */
+      setCompanyCard: (id, input) => __privateGet(this, _client3).request(
+        "PUT",
+        `/api/purchasing/buyers/${enc(id)}/company-card`,
+        input
+      ),
+      /** The buyer stops paying with your company card. */
+      removeCompanyCard: (id) => __privateGet(this, _client3).request(
+        "DELETE",
+        `/api/purchasing/buyers/${enc(id)}/company-card`
+      ),
+      /**
+       * Replaces what the buyer has at home: inventory, usuals, preferences,
+       * chosen recipes and their list. The whole snapshot, every time. Needs
+       * Conto to enable kitchen context for your organization.
+       */
+      setKitchenContext: (id, context) => __privateGet(this, _client3).request(
+        "PUT",
+        `/api/purchasing/buyers/${enc(id)}/context`,
+        context
+      ),
+      /** The snapshot Conto holds, with context null when nothing was pushed. */
+      getKitchenContext: (id) => __privateGet(this, _client3).request(
+        "GET",
+        `/api/purchasing/buyers/${enc(id)}/context`
+      ),
+      clearKitchenContext: (id) => __privateGet(this, _client3).request(
+        "DELETE",
+        `/api/purchasing/buyers/${enc(id)}/context`
+      )
+    };
+    /** Cards your organization pays its buyers' purchases with. Test cards only for now. */
+    this.companyCards = {
+      create: (input) => __privateGet(this, _client3).request("POST", "/api/purchasing/company-cards", input),
+      list: () => __privateGet(this, _client3).request(
+        "GET",
+        "/api/purchasing/company-cards"
+      ),
+      get: (id) => __privateGet(this, _client3).request("GET", `/api/purchasing/company-cards/${enc(id)}`),
+      /** Changes the card's own caps. Each buyer's limits stay as they are. */
+      update: (id, input) => __privateGet(this, _client3).request(
+        "PATCH",
+        `/api/purchasing/company-cards/${enc(id)}`,
+        input
+      ),
+      /** No buyer can start or pay a purchase with the card after this. */
+      remove: (id) => __privateGet(this, _client3).request(
+        "DELETE",
+        `/api/purchasing/company-cards/${enc(id)}`
+      )
+    };
+    this.paymentMethods = {
+      /** A single-use link to the hosted setup page: limits, card and delegation. */
+      createSetupLink: (input) => __privateGet(this, _client3).request(
+        "POST",
+        "/api/purchasing/payment-methods/setup-sessions",
+        input
+      ),
+      list: (buyerId) => __privateGet(this, _client3).request(
+        "GET",
+        `/api/purchasing/payment-methods?buyerId=${enc(buyerId)}`
+      ),
+      remove: (id) => __privateGet(this, _client3).request(
+        "DELETE",
+        `/api/purchasing/payment-methods/${enc(id)}`
+      )
+    };
+    this.delegations = {
+      list: (buyerId) => __privateGet(this, _client3).request(
+        "GET",
+        `/api/purchasing/delegations?buyerId=${enc(buyerId)}`
+      ),
+      get: (id) => __privateGet(this, _client3).request("GET", `/api/purchasing/delegations/${enc(id)}`),
+      revoke: (id) => __privateGet(this, _client3).request(
+        "POST",
+        `/api/purchasing/delegations/${enc(id)}/revoke`
+      )
+    };
+    this.settings = {
+      get: () => __privateGet(this, _client3).request("GET", "/api/purchasing/settings"),
+      /** Changes only the fields you pass. */
+      update: (input) => __privateGet(this, _client3).request("PUT", "/api/purchasing/settings", input)
+    };
+    __privateSet(this, _client3, client);
+    this.purchases = new OrganizationPurchasesClient(client);
+    this.recurringPurchases = new OrganizationRecurringPurchasesClient(client);
+  }
+  /** What this organization can run now: test mode always, live once Conto enables it. */
+  capabilities() {
+    return __privateGet(this, _client3).request("GET", "/api/purchasing/capabilities");
+  }
+};
+_client3 = new WeakMap();
+function verifyPurchaseWebhook(input) {
+  const expected = (0, import_node_crypto.createHmac)("sha256", input.secret).update(input.body).digest();
+  const received = Buffer.from(input.signature ?? "", "hex");
+  if (received.length !== expected.length || !(0, import_node_crypto.timingSafeEqual)(received, expected))
+    throw new Error("Invalid webhook signature");
+  const payload = JSON.parse(input.body);
+  const age = ((input.now ?? /* @__PURE__ */ new Date()).getTime() - Date.parse(payload.timestamp)) / 1e3;
+  if (!Number.isFinite(age) || Math.abs(age) > (input.toleranceSeconds ?? 300))
+    throw new Error("Webhook timestamp is outside the tolerance");
+  return payload;
+}
+
 // src/http.ts
 var PUBLIC_PAYMENT_REASONS = /* @__PURE__ */ new Set([
   "The available balance is insufficient for this payment.",
@@ -395,7 +880,7 @@ function responseErrorMetadata(response, data) {
 }
 
 // src/browser-checkout.ts
-var import_node_crypto = require("crypto");
+var import_node_crypto2 = require("crypto");
 var MAX_URL_LENGTH = 2048;
 var MAX_LOCATOR_LENGTH = 1024;
 var MAX_TEXT_LENGTH = 500;
@@ -468,7 +953,7 @@ function canonicalizeBrowserCheckoutTarget(snapshot) {
 }
 function fingerprintBrowserCheckoutTarget(snapshot) {
   const canonical = canonicalizeBrowserCheckoutTarget(snapshot);
-  const digest = (0, import_node_crypto.createHash)("sha256").update(JSON.stringify(canonical)).digest("hex");
+  const digest = (0, import_node_crypto2.createHash)("sha256").update(JSON.stringify(canonical)).digest("hex");
   return `browser_target_sha256_${digest}`;
 }
 function createVerifiedBrowserCheckoutDriver(resolver) {
@@ -552,14 +1037,51 @@ var ContoAdmin = class {
     this.cards = new AdminCardsClient(this);
     this.policies = new PoliciesClient(this);
     this.team = new TeamClient(this);
+    this.purchasing = new AdminPurchasingClient(this);
   }
-  /** Make an authenticated request to the Conto API */
-  async request(method, path, body) {
+  /**
+   * Opens an authenticated server-sent event stream. Used by
+   * `purchasing.purchases.watch()`. The server closes it after about 50 seconds.
+   * @internal
+   */
+  async openStream(path, init = {}) {
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    init.signal?.addEventListener("abort", abort, { once: true });
+    const timeoutId = setTimeout(abort, Math.max(this.timeout, 7e4));
+    try {
+      const response = await fetch(`${this.baseUrl}${path}`, {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${__privateGet(this, _orgApiKey)}`,
+          Accept: "text/event-stream",
+          "User-Agent": `@conto_finance/sdk-admin/${import_package_version.SDK_PACKAGE_VERSION}`,
+          ...init.lastEventId ? { "Last-Event-ID": init.lastEventId } : {}
+        },
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        const data = await readResponseData(response);
+        throw new ContoAdminError(
+          responseErrorMessage(data, response.status),
+          responseErrorMetadata(response, data)
+        );
+      }
+      return response;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Make an authenticated request to the Conto API. Reads retry. A write retries
+   * only when `idempotent` says the API deduplicates it, as purchase creation does.
+   */
+  async request(method, path, body, options = {}) {
     const url = `${this.baseUrl}${path}`;
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), this.timeout);
     const normalizedMethod = method.toUpperCase();
-    const retryable = ["GET", "HEAD", "OPTIONS"].includes(normalizedMethod);
+    const retryable = ["GET", "HEAD", "OPTIONS"].includes(normalizedMethod) || options.idempotent === true;
     try {
       const response = await fetchWithRetry(
         url,
@@ -1134,8 +1656,45 @@ var CheckoutApprovalTimeoutError = class extends ContoError {
     this.checkpoint = checkpoint;
   }
 };
+var LinkCardError = class extends ContoError {
+  constructor(input) {
+    super(input.message, {
+      code: input.code,
+      status: 0,
+      retryGuidance: input.retryGuidance ?? (input.holdReleased ? "Start a new purchase with a new idempotency key if the buyer still wants it." : "Call checkout.cancel(error.checkpoint.id) to release the held spend.")
+    });
+    this.name = "LinkCardError";
+    this.checkpoint = input.checkpoint;
+    if (input.linkRequestId) this.linkRequestId = input.linkRequestId;
+    this.holdReleased = input.holdReleased;
+  }
+};
+var LinkCardDeniedError = class extends LinkCardError {
+  constructor(input) {
+    super(input);
+    this.name = "LinkCardDeniedError";
+  }
+};
+var LinkCardExpiredError = class extends LinkCardError {
+  constructor(input) {
+    super(input);
+    this.name = "LinkCardExpiredError";
+  }
+};
+var LinkCardTimeoutError = class extends LinkCardError {
+  constructor(input) {
+    super(input);
+    this.name = "LinkCardTimeoutError";
+  }
+};
+var LinkWalletUnavailableError = class extends LinkCardError {
+  constructor(input) {
+    super(input);
+    this.name = "LinkWalletUnavailableError";
+  }
+};
 function generatedIdempotencyKey(prefix) {
-  return `${prefix}_${(0, import_node_crypto2.randomUUID)()}`;
+  return `${prefix}_${(0, import_node_crypto3.randomUUID)()}`;
 }
 function requireFinancialIdentifier(value, field) {
   if (!value || value.trim().length === 0) {
@@ -1203,6 +1762,8 @@ var Conto = class {
     this.testCards = new TestCardsClient(this);
     this.x402 = new X402Client(this);
     this.mpp = new MppClient(this);
+    this.purchases = new PurchasesClient(this);
+    this.recurringPurchases = new RecurringPurchasesClient(this);
   }
   /**
    * Normalize and durably revise a partial agent purchase proposal without
@@ -1487,6 +2048,39 @@ var Conto = class {
   async setup() {
     return this.request("GET", "/api/sdk/setup");
   }
+  /**
+   * Opens an authenticated server-sent event stream. Used by
+   * `purchases.watch()`. The server closes it after about 50 seconds.
+   * @internal
+   */
+  async openStream(path, init = {}) {
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    init.signal?.addEventListener("abort", abort, { once: true });
+    const timeoutId = setTimeout(abort, Math.max(this.timeout, 7e4));
+    try {
+      const response = await fetch(`${this.baseUrl}${path}`, {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${__privateGet(this, _apiKey)}`,
+          Accept: "text/event-stream",
+          "User-Agent": `@conto_finance/sdk/${import_package_version2.SDK_PACKAGE_VERSION}`,
+          ...init.lastEventId ? { "Last-Event-ID": init.lastEventId } : {}
+        },
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        const data = await readResponseData(response);
+        throw new ContoError(
+          responseErrorMessage(data, response.status),
+          responseErrorMetadata(response, data)
+        );
+      }
+      return response;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
   /** Make an authenticated request to the Conto API */
   async request(method, path, body, options = {}) {
     const url = `${this.baseUrl}${path}`;
@@ -1759,12 +2353,6 @@ var ConnectedCardsClient = class {
       currency: input.currency ?? "USD"
     });
   }
-  /**
-   * List the connected cards and active mandates this agent may draw against.
-   *
-   * The response is masked: no PAN and no provider tokens. This is a read-only
-   * GET, so transport retry on transient failures is safe.
-   */
   /** Record receipt after a fresh draw. Does not confirm checkout or payment settlement. */
   async acknowledgeDelivery(requestId) {
     return this.client.request(
@@ -1774,6 +2362,39 @@ var ConnectedCardsClient = class {
       { idempotent: true }
     );
   }
+  /**
+   * Report what happened with the card number after checkout.
+   *
+   * `USED` at the full approved amount closes the draw. `NOT_USED`, or `USED`
+   * with a smaller `amountMinor`, is recorded and shown to a person, who
+   * confirms it before the held amount is released. A report never releases
+   * held spend by itself and does not confirm settlement. Safe to repeat with
+   * the same report. A different second report gets HTTP 409.
+   *
+   * @example
+   * ```typescript
+   * await conto.connectedCards.reportOutcome(draw.requestId, { outcome: 'USED' });
+   * await conto.connectedCards.reportOutcome(draw.requestId, { outcome: 'USED', amountMinor: 1850 });
+   * await conto.connectedCards.reportOutcome(draw.requestId, { outcome: 'NOT_USED' });
+   * ```
+   */
+  async reportOutcome(requestId, report) {
+    return this.client.request(
+      "POST",
+      `/api/sdk/connected-cards/draws/${encodeURIComponent(requestId)}/outcome`,
+      {
+        outcome: report.outcome,
+        ...report.amountMinor !== void 0 ? { amountMinor: report.amountMinor } : {}
+      },
+      { idempotent: true }
+    );
+  }
+  /**
+   * List the connected cards and active mandates this agent may draw against.
+   *
+   * The response is masked: no PAN and no provider tokens. This is a read-only
+   * GET, so transport retry on transient failures is safe.
+   */
   async list() {
     return this.client.request("GET", "/api/sdk/connected-cards");
   }
@@ -2175,7 +2796,7 @@ function closedCheckpointError(checkpoint) {
   }
   return new CheckoutCheckpointClosedError(checkpoint);
 }
-function sleep(ms, signal) {
+function sleep2(ms, signal) {
   return new Promise((resolve, reject) => {
     if (signal?.aborted) {
       reject(signal.reason ?? new Error("Aborted"));
@@ -2192,11 +2813,181 @@ function sleep(ms, signal) {
     signal?.addEventListener("abort", onAbort, { once: true });
   });
 }
-var _client;
+var LINK_REQUEST_ID = /^lsrq_[A-Za-z0-9]{1,64}$/;
+var LINK_WAITING_STATUSES = /* @__PURE__ */ new Set(["created", "pending_approval"]);
+var LINK_APPROVED_STATUSES = /* @__PURE__ */ new Set(["approved", "submitted", "succeeded"]);
+var LINK_CLOSED_STATUSES = /* @__PURE__ */ new Set(["denied", "expired", "canceled", "failed"]);
+var INSPECT = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+function assertPaymentReference(reference) {
+  if (reference === void 0) return;
+  if (reference === null || typeof reference !== "object" || reference.provider !== "LINK" || typeof reference.id !== "string" || !LINK_REQUEST_ID.test(reference.id) || /\d{12,}/.test(reference.id)) {
+    throw checkoutError(
+      'paymentReference must be { provider: "LINK", id } with a Link spend request id',
+      "INVALID_PAYMENT_REFERENCE"
+    );
+  }
+}
+function linkRequestWaiting(request) {
+  return LINK_WAITING_STATUSES.has(request.status) || // 3D Secure: Link continues on its own once the person finishes it.
+  request.status === "requires_action" && request.actionResolution === "auto_resume";
+}
+function usd(amountMinor) {
+  return `$${(amountMinor / 100).toFixed(2)}`;
+}
+function clip(value, maxLength) {
+  const single = value.replace(/\s+/g, " ").trim();
+  return single.length > maxLength ? `${single.slice(0, maxLength - 3).trimEnd()}...` : single;
+}
+function linkCardContext(checkpoint, merchantHost) {
+  const items = checkpoint.cart.lineItems;
+  const listed = items.slice(0, 5).map((item) => `${item.quantity} x ${clip(item.name, 80)}`).join(", ");
+  const more = items.length > 5 ? ` and ${items.length - 5} more` : "";
+  return `Your agent asked for a card to buy ${clip(listed, 300)}${more} from ${clip(checkpoint.merchant.name, 120)} (${merchantHost}) for ${usd(checkpoint.amountMinor)}. Purpose: ${clip(checkpoint.purpose, 200)}. Conto checked this purchase against your rules and approved it. The card is limited to this amount. Approve only if you expect this purchase.`;
+}
+function linkCardRequest(checkpoint) {
+  if (!checkpoint.merchant.checkoutUrl) {
+    throw checkoutError("The checkpoint has no checkout URL", "INVALID_CHECKOUT_CHECKPOINT");
+  }
+  const merchantUrl = new URL(checkpoint.merchant.checkoutUrl);
+  return {
+    amountMinor: checkpoint.amountMinor,
+    currency: "USD",
+    merchantName: checkpoint.merchant.name,
+    merchantUrl: merchantUrl.origin,
+    context: linkCardContext(checkpoint, merchantUrl.hostname),
+    lineItems: checkpoint.cart.lineItems.map((item) => ({
+      name: item.name,
+      quantity: item.quantity,
+      unitAmountMinor: item.unitAmountMinor
+    })),
+    // Conto approved amountMinor, so the Link total is exactly that.
+    totals: [
+      ...checkpoint.cart.totals.filter((total) => total.type !== "total").map((total) => ({ type: total.type, label: total.label, amountMinor: total.amountMinor })),
+      { type: "total", label: "Total", amountMinor: checkpoint.amountMinor }
+    ],
+    // One checkpoint and amount is one Link request, so a retry resumes it.
+    idempotencyKey: `conto_${(0, import_node_crypto3.createHash)("sha256").update(`${checkpoint.id}:${checkpoint.amountMinor}`).digest("hex").slice(0, 40)}`,
+    metadata: { conto_checkpoint: checkpoint.id }
+  };
+}
+function protectLinkCard(card) {
+  const safe = Object.freeze({
+    last4: card.number.slice(-4),
+    ...card.brand ? { brand: card.brand } : {},
+    expMonth: card.expMonth,
+    expYear: card.expYear,
+    ...card.validUntil ? { validUntil: card.validUntil } : {},
+    redacted: true
+  });
+  const result = {
+    number: card.number,
+    securityValue: card.securityValue,
+    expMonth: card.expMonth,
+    expYear: card.expYear,
+    ...card.validUntil ? { validUntil: card.validUntil } : {},
+    last4: card.number.slice(-4),
+    ...card.brand ? { brand: card.brand } : {}
+  };
+  Object.defineProperty(result, "toJSON", { value: () => safe, enumerable: false });
+  Object.defineProperty(result, INSPECT, { value: () => safe, enumerable: false });
+  return Object.freeze(result);
+}
+function errorCode(error) {
+  return error && typeof error === "object" && typeof error.code === "string" ? error.code : void 0;
+}
+function errorReason(error) {
+  return error && typeof error === "object" && typeof error.reason === "string" ? error.reason : void 0;
+}
+function linkFailure(error, signal) {
+  if (error instanceof LinkCardError) {
+    return {
+      kind: error.constructor,
+      code: error.code,
+      message: error.message
+    };
+  }
+  if (errorCode(error) === "LINK_WALLET_UNAVAILABLE") {
+    return {
+      kind: LinkWalletUnavailableError,
+      code: "LINK_WALLET_UNAVAILABLE",
+      message: errorReason(error) === "not_logged_in" ? 'link-cli is not logged in on this machine. Run "link-cli auth login".' : 'The Link wallet is not available here. Install link-cli with "npm i -g @stripe/link-cli", then run "link-cli auth login".'
+    };
+  }
+  if (signal?.aborted || errorReason(error) === "aborted") {
+    return {
+      kind: LinkCardError,
+      code: "LINK_CARD_ABORTED",
+      message: "The Link card request was stopped."
+    };
+  }
+  return {
+    kind: LinkCardError,
+    code: "LINK_CARD_FAILED",
+    message: "The Link card request failed."
+  };
+}
+function closedLinkFailure(request) {
+  switch (request.status) {
+    case "denied":
+      return {
+        kind: LinkCardDeniedError,
+        code: "LINK_CARD_DENIED",
+        message: "The person declined the Link card request.",
+        linkClosed: true
+      };
+    case "canceled":
+      return {
+        kind: LinkCardDeniedError,
+        code: "LINK_CARD_DENIED",
+        message: "The Link card request was cancelled in Link.",
+        linkClosed: true
+      };
+    case "expired":
+      return {
+        kind: LinkCardExpiredError,
+        code: "LINK_CARD_EXPIRED",
+        message: "The Link card request expired before the person approved it.",
+        linkClosed: true
+      };
+    case "requires_action":
+      return {
+        kind: LinkCardError,
+        code: "LINK_CARD_ACTION_REQUIRED",
+        message: "Link needs the person to finish a step in Link before it can issue a card."
+      };
+    default:
+      return {
+        kind: LinkCardError,
+        code: "LINK_CARD_FAILED",
+        message: "Link did not issue a card for this request.",
+        linkClosed: LINK_CLOSED_STATUSES.has(request.status)
+      };
+  }
+}
+async function closeLinkRequest(wallet, id) {
+  try {
+    await wallet.cancel(id);
+    return true;
+  } catch {
+    const status = await wallet.waitForApproval(id, { timeoutSeconds: 0 }).then((request) => request.status).catch(() => void 0);
+    return status !== void 0 && LINK_CLOSED_STATUSES.has(status);
+  }
+}
+function linkCreatedNothing(error) {
+  return errorCode(error) === "LINK_WALLET_UNAVAILABLE" || errorReason(error) === "invalid_input";
+}
+var LinkFailureSignal = class extends Error {
+  constructor(failure) {
+    super(failure.message);
+    this.failure = failure;
+  }
+};
+var _client4, _CheckoutClient_instances, linkCardFor_fn;
 var CheckoutClient = class {
   constructor(client) {
-    __privateAdd(this, _client);
-    __privateSet(this, _client, client);
+    __privateAdd(this, _CheckoutClient_instances);
+    __privateAdd(this, _client4);
+    __privateSet(this, _client4, client);
   }
   /**
    * First checkpoint. Open the payment method only when the stage is APPROVED.
@@ -2216,7 +3007,7 @@ var CheckoutClient = class {
     if (input.currency !== void 0 && input.currency !== "USD") {
       throw checkoutError("Only USD checkouts are supported");
     }
-    const result = await __privateGet(this, _client).request(
+    const result = await __privateGet(this, _client4).request(
       "POST",
       "/api/sdk/checkout-checkpoints",
       {
@@ -2254,7 +3045,7 @@ var CheckoutClient = class {
       }
       const remaining = deadline - Date.now();
       if (remaining <= 0) throw new CheckoutApprovalTimeoutError(current);
-      await sleep(Math.min(pollIntervalMs, remaining), options.signal);
+      await sleep2(Math.min(pollIntervalMs, remaining), options.signal);
       current = await this.get(current.id);
     }
   }
@@ -2273,8 +3064,16 @@ var CheckoutClient = class {
     if (!Number.isSafeInteger(input.amountMinor) || input.amountMinor <= 0) {
       throw checkoutError("amountMinor must be a positive integer number of cents");
     }
+    assertPaymentReference(input.paymentReference);
     let current = checkpoint;
     if (input.amountMinor !== checkpoint.amountMinor) {
+      if (input.paymentReference) {
+        throw new ContoError("The Link card covers the approved total, not this one. Do not pay.", {
+          code: "LINK_CARD_TOTAL_CHANGED",
+          status: 0,
+          retryGuidance: "Call checkout.replaceLinkCard(result, { wallet, amountMinor }) for a card at the final total, then confirm the checkpoint it returns."
+        });
+      }
       try {
         await this.cancel(checkpoint.id);
       } catch (error) {
@@ -2298,13 +3097,21 @@ var CheckoutClient = class {
       if (current.stage === "AWAITING_APPROVAL") throw new CheckoutApprovalPendingError(current);
     }
     try {
-      const result = await __privateGet(this, _client).request(
+      const result = await __privateGet(this, _client4).request(
         "POST",
         `/api/sdk/checkout-checkpoints/${encodeURIComponent(current.id)}/confirm`,
         {
           amountMinor: input.amountMinor,
           currency: "USD",
-          ...input.pageUrl ? { pageUrl: input.pageUrl } : {}
+          ...input.lineItems !== void 0 || input.totals !== void 0 ? {
+            cart: checkpointCart(
+              input.amountMinor,
+              input.lineItems ?? current.cart.lineItems,
+              input.totals ?? current.cart.totals
+            )
+          } : {},
+          ...input.pageUrl ? { pageUrl: input.pageUrl } : {},
+          ...input.paymentReference ? { paymentReference: { provider: "LINK", id: input.paymentReference.id } } : {}
         },
         { idempotent: true }
       );
@@ -2319,12 +3126,14 @@ var CheckoutClient = class {
   }
   /** 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(
+    assertPaymentReference(input.paymentReference);
+    const result = await __privateGet(this, _client4).request(
       "POST",
       `/api/sdk/checkout-checkpoints/${encodeURIComponent(checkpointId)}/outcome`,
       {
         outcome: input.outcome,
-        ...input.reference ? { reference: input.reference } : {}
+        ...input.reference ? { reference: input.reference } : {},
+        ...input.paymentReference ? { paymentReference: { provider: "LINK", id: input.paymentReference.id } } : {}
       },
       { idempotent: true }
     );
@@ -2335,7 +3144,7 @@ var CheckoutClient = class {
    * checkpoint waiting for the owner can be cancelled too.
    */
   async cancel(checkpointId) {
-    const result = await __privateGet(this, _client).request(
+    const result = await __privateGet(this, _client4).request(
       "POST",
       `/api/sdk/checkout-checkpoints/${encodeURIComponent(checkpointId)}/cancel`,
       {},
@@ -2344,16 +3153,198 @@ var CheckoutClient = class {
     return result.checkpoint;
   }
   async get(checkpointId) {
-    const result = await __privateGet(this, _client).request(
+    const result = await __privateGet(this, _client4).request(
       "GET",
       `/api/sdk/checkout-checkpoints/${encodeURIComponent(checkpointId)}`
     );
     return result.checkpoint;
   }
+  /**
+   * Get a Stripe Link card for one purchase, issued only after Conto approves
+   * it. Call this at the payment step, once the final total with shipping and
+   * tax is known.
+   *
+   * 1. Conto runs checkpoint 1 and holds the spend. When a rule requires the
+   *    owner's approval, this waits for it.
+   * 2. Only then does the wallet ask Link for a card for exactly the approved
+   *    amount at this merchant. The person approves it in their Link app.
+   * 3. The card is returned. It never reaches Conto.
+   *
+   * Then fill in the card, call confirm(result.checkpoint, { amountMinor,
+   * paymentReference: result.paymentReference }) right before paying, pay only
+   * if it resolves, and report the outcome. If the final total differs, call
+   * replaceLinkCard() instead of confirming.
+   *
+   * A Conto denial throws before Link is called. When Link declines, expires,
+   * times out, or is unavailable, this cancels the checkpoint to release the
+   * held spend and throws a LinkCardError. When Conto cannot cancel an open Link
+   * request, it keeps the hold and throws LINK_CARD_NOT_CANCELLED with the
+   * request id. Retrying with the same input resumes the same checkpoint and
+   * Link request.
+   */
+  async getLinkCard(input) {
+    const { wallet, ownerApprovalTimeoutMs, linkApprovalTimeoutMs, signal, ...beginInput } = input;
+    if (!wallet || typeof wallet.createCardRequest !== "function") {
+      throw checkoutError("wallet must be a LinkWallet, such as linkCliWallet()");
+    }
+    let checkpoint = await this.begin({ ...beginInput, checkoutMethod: "LINK" });
+    if (checkpoint.stage === "AWAITING_APPROVAL") {
+      checkpoint = await this.waitForApproval(checkpoint, {
+        ...ownerApprovalTimeoutMs !== void 0 ? { timeoutMs: ownerApprovalTimeoutMs } : {},
+        ...signal ? { signal } : {}
+      });
+    }
+    return __privateMethod(this, _CheckoutClient_instances, linkCardFor_fn).call(this, checkpoint, wallet, linkApprovalTimeoutMs, signal);
+  }
+  /**
+   * The final total differs from the one the Link card covers. This cancels
+   * the old Link request and checkpoint, begins a checkpoint at the final
+   * total (waiting for the owner when a rule requires it), and gets a new card
+   * for it. Confirm the returned checkpoint with the same total.
+   */
+  async replaceLinkCard(previous, input) {
+    const { wallet, amountMinor, ownerApprovalTimeoutMs, linkApprovalTimeoutMs, signal } = input;
+    if (!Number.isSafeInteger(amountMinor) || amountMinor <= 0) {
+      throw checkoutError("amountMinor must be a positive integer number of cents");
+    }
+    if (amountMinor === previous.checkpoint.amountMinor) return previous;
+    const old = previous.checkpoint;
+    if (!await closeLinkRequest(wallet, previous.linkRequestId)) {
+      throw new LinkCardError({
+        message: "Conto could not cancel the earlier Link card. Nothing changed. Do not pay.",
+        code: "LINK_CARD_NOT_CANCELLED",
+        checkpoint: old,
+        linkRequestId: previous.linkRequestId,
+        holdReleased: false,
+        retryGuidance: "Try replaceLinkCard again."
+      });
+    }
+    try {
+      await this.cancel(old.id);
+    } catch (error) {
+      const closed = error instanceof ContoError && error.status === 409 && ["CANCELLED", "EXPIRED", "DENIED"].includes((await this.get(old.id)).stage);
+      if (!closed) throw error;
+    }
+    let checkpoint = await this.begin({
+      idempotencyKey: `${old.idempotencyKey.slice(0, 200)}:final-${amountMinor}`,
+      merchant: {
+        id: old.merchant.id,
+        name: old.merchant.name,
+        checkoutUrl: old.merchant.checkoutUrl ?? ""
+      },
+      amountMinor,
+      purpose: old.purpose,
+      ...old.category ? { category: old.category } : {},
+      checkoutMethod: "LINK",
+      lineItems: input.lineItems ?? old.cart.lineItems,
+      totals: input.totals
+    });
+    if (checkpoint.stage === "AWAITING_APPROVAL") {
+      checkpoint = await this.waitForApproval(checkpoint, {
+        ...ownerApprovalTimeoutMs !== void 0 ? { timeoutMs: ownerApprovalTimeoutMs } : {},
+        ...signal ? { signal } : {}
+      });
+    }
+    return __privateMethod(this, _CheckoutClient_instances, linkCardFor_fn).call(this, checkpoint, wallet, linkApprovalTimeoutMs, signal);
+  }
+};
+_client4 = new WeakMap();
+_CheckoutClient_instances = new WeakSet();
+linkCardFor_fn = async function(checkpoint, wallet, linkApprovalTimeoutMs = 10 * 6e4, signal) {
+  if (checkpoint.stage !== "APPROVED") {
+    throw checkoutError(
+      `Conto has not approved a card for this checkpoint (stage ${checkpoint.stage}). Do not pay.`,
+      "CHECKOUT_CHECKPOINT_NOT_APPROVED"
+    );
+  }
+  const deadline = Date.now() + linkApprovalTimeoutMs;
+  const call = signal ? { signal } : {};
+  let linkRequestId;
+  let createStarted = false;
+  try {
+    const cardRequest = linkCardRequest(checkpoint);
+    createStarted = true;
+    let request = await wallet.createCardRequest(cardRequest, call);
+    if (!LINK_REQUEST_ID.test(request.id)) {
+      throw new LinkFailureSignal({
+        kind: LinkCardError,
+        code: "LINK_CARD_FAILED",
+        message: "The Link wallet returned an invalid request id."
+      });
+    }
+    linkRequestId = request.id;
+    if (request.amountMinor !== void 0 && request.amountMinor !== checkpoint.amountMinor) {
+      throw new LinkFailureSignal({
+        kind: LinkCardError,
+        code: "LINK_CARD_MISMATCH",
+        message: "Link returned a request for a different amount."
+      });
+    }
+    while (linkRequestWaiting(request)) {
+      const remainingSeconds = Math.floor((deadline - Date.now()) / 1e3);
+      if (remainingSeconds <= 0) {
+        throw new LinkFailureSignal({
+          kind: LinkCardTimeoutError,
+          code: "LINK_CARD_TIMEOUT",
+          message: "The person did not approve the Link card request in time."
+        });
+      }
+      const started = Date.now();
+      request = await wallet.waitForApproval(request.id, {
+        ...call,
+        timeoutSeconds: remainingSeconds
+      });
+      if (linkRequestWaiting(request) && Date.now() - started < 1e3) {
+        await sleep2(1e3, signal);
+      }
+    }
+    if (!LINK_APPROVED_STATUSES.has(request.status)) {
+      throw new LinkFailureSignal(closedLinkFailure(request));
+    }
+    const card = await wallet.retrieveCard(request.id, call);
+    return {
+      checkpoint,
+      card: protectLinkCard(card),
+      linkRequestId: request.id,
+      paymentReference: { provider: "LINK", id: request.id }
+    };
+  } catch (error) {
+    const failure = error instanceof LinkFailureSignal ? error.failure : linkFailure(error, signal);
+    if (!linkRequestId && createStarted && !linkCreatedNothing(error)) {
+      throw new LinkCardError({
+        message: `${failure.message} Conto could not tell whether Link created the card request, so the held spend stays in place. Do not pay.`,
+        code: "LINK_CARD_NOT_CANCELLED",
+        checkpoint,
+        holdReleased: false,
+        retryGuidance: "Retry with the same input to resume the Link request, or call checkout.cancel(error.checkpoint.id) once you know Link created none."
+      });
+    }
+    if (linkRequestId && !failure.linkClosed && !await closeLinkRequest(wallet, linkRequestId)) {
+      throw new LinkCardError({
+        message: `${failure.message} Conto could not cancel the Link request, so the held spend stays in place. Do not pay.`,
+        code: "LINK_CARD_NOT_CANCELLED",
+        checkpoint,
+        linkRequestId,
+        holdReleased: false,
+        retryGuidance: "Retry with the same input to resume this Link request, or cancel it with wallet.cancel(error.linkRequestId) and then call checkout.cancel(error.checkpoint.id)."
+      });
+    }
+    const holdReleased = await this.cancel(checkpoint.id).then(
+      () => true,
+      () => false
+    );
+    throw new failure.kind({
+      message: `${failure.message} ${holdReleased ? "Conto cancelled the checkpoint and released the held spend." : "Conto could not cancel the checkpoint yet."} Do not pay.`,
+      code: failure.code,
+      checkpoint,
+      ...linkRequestId ? { linkRequestId } : {},
+      holdReleased
+    });
+  }
 };
-_client = new WeakMap();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AdminPurchasingClient,
   BrowserActionFinalizationPendingError,
   BrowserCheckoutTargetVerificationError,
   CardsClient,
@@ -2371,8 +3362,20 @@ _client = new WeakMap();
   ControlledExternalCardPaymentTool,
   ExternalCardConfirmationPendingError,
   Giro,
+  LinkCardDeniedError,
+  LinkCardError,
+  LinkCardExpiredError,
+  LinkCardTimeoutError,
+  LinkWalletUnavailableError,
+  OrganizationPurchasesClient,
+  OrganizationRecurringPurchasesClient,
+  PurchasesClient,
+  RecurringPurchasesClient,
   TestCardsClient,
   canonicalizeBrowserCheckoutTarget,
   createVerifiedBrowserCheckoutDriver,
-  fingerprintBrowserCheckoutTarget
+  fingerprintBrowserCheckoutTarget,
+  isFinalPurchaseStatus,
+  parseServerSentEvents,
+  verifyPurchaseWebhook
 });