@conto_finance/sdk 0.5.4 → 0.6.0-beta.1

package/dist/index.mjs

@@ -17,7 +17,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "@conto_finance/sdk",
-      version: "0.5.4",
+      version: "0.6.0-beta.1",
       description: "Conto SDK for AI agent payment authorization",
       main: "./dist/index.js",
       module: "./dist/index.mjs",
@@ -42,10 +42,16 @@ 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"
+        access: "public",
+        tag: "beta"
       },
       engines: {
         node: ">=20.19.0"
@@ -54,11 +60,11 @@ var require_package = __commonJS({
         "dist"
       ],
       scripts: {
-        build: "tsup src/index.ts src/playwright.ts src/browserbase.ts src/checkout-verifier.ts --format cjs,esm --dts",
-        dev: "tsup src/index.ts src/playwright.ts src/browserbase.ts src/checkout-verifier.ts --format cjs,esm --dts --watch",
+        build: "tsup",
+        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: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: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"
@@ -887,7 +893,7 @@ function isValidBrowserActionObservation(value) {
   }
 }
 var ContoError = class extends Error {
-  constructor(message, metadata) {
+  constructor(message, metadata, diagnostics) {
     super(message);
     this.name = "ContoError";
     this.code = metadata.code;
@@ -898,6 +904,30 @@ var ContoError = class extends Error {
     this.actionUrl = metadata.actionUrl;
     this.fieldErrors = metadata.fieldErrors;
     this.reasons = metadata.reasons;
+    if (diagnostics !== null && typeof diagnostics === "object" && !Array.isArray(diagnostics) && "version" in diagnostics && diagnostics.version === "conto.setup-diagnostics.v1") {
+      this.diagnostics = diagnostics;
+    }
+  }
+};
+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 {
@@ -989,6 +1019,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.payments = new PaymentsClient(this);
     this.cards = new CardsClient(this);
     this.connectedCards = new ConnectedCardsClient(this);
@@ -1001,10 +1032,24 @@ var Conto = class {
    * explicitly bound to this agent. No Link token or payment artifact is
    * returned through the agent SDK.
    */
-  async listStripeLinkPaymentMethods(connectionId) {
+  async listStripeLinkPaymentMethods(connectionId, options) {
     return this.request(
       "GET",
-      withQuery("/api/sdk/stripe-link/payment-methods", { connectionId })
+      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
+      })
     );
   }
   /**
@@ -1267,7 +1312,10 @@ var Conto = class {
       rethrowAmbiguousCommerceMutation(error, executionId, "cancel");
     }
   }
-  /** Read credentials, linked wallets, effective policies, and scopes without creating a payment. */
+  /**
+   * Read credentials, linked wallets, effective policies, scopes, and setup
+   * diagnostics without creating a payment.
+   */
   async setup() {
     return this.request("GET", "/api/sdk/setup");
   }
@@ -1297,7 +1345,8 @@ var Conto = class {
       if (!response.ok) {
         throw new ContoError(
           responseErrorMessage(data, response.status),
-          responseErrorMetadata(response, data)
+          responseErrorMetadata(response, data),
+          data !== null && typeof data === "object" && "diagnostics" in data ? data.diagnostics : void 0
         );
       }
       return data;
@@ -1930,6 +1979,176 @@ var MppClient = class {
   }
 };
 var index_default = Conto;
+var _client, _defaults;
+var LinkClient = class {
+  constructor(client, defaults) {
+    __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.
+   */
+  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
+        }
+      );
+    }
+    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 }]
+      },
+      providerPresentation: {
+        approvalSummary: input.purpose.trim().slice(0, 500),
+        lineItemLabels: input.lineItems.map((item) => item.name.trim().slice(0, 120))
+      }
+    });
+    return this.executeIfReady(result);
+  }
+  /**
+   * Continue the existing payment after approval. Reads before any mutation and
+   * never submits an execution already processing or requiring reconciliation.
+   */
+  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);
+    }
+  }
+  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
+        }
+      );
+    }
+    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
+      });
+    }
+  }
+  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));
+    } catch (error) {
+      throw new LinkPaymentExecutionError(result.execution.id, 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 } : {}
+    };
+  }
+};
+_client = new WeakMap();
+_defaults = new WeakMap();
 export {
   BrowserActionFinalizationPendingError,
   BrowserCheckoutTargetVerificationError,
@@ -1942,6 +2161,8 @@ export {
   ControlledExternalCardPaymentTool,
   ExternalCardConfirmationPendingError,
   Conto as Giro,
+  LinkClient,
+  LinkPaymentExecutionError,
   TestCardsClient,
   canonicalizeBrowserCheckoutTarget,
   createVerifiedBrowserCheckoutDriver,

package/dist/link-testing.d.mts

@@ -0,0 +1,37 @@
+import { LinkPaymentResult, LinkSetupInput, LinkSetupResult, ListStripeLinkPaymentMethodsResult, LinkPaymentInput } from './index.mjs';
+
+type LinkTestScenario = 'approved' | 'denied' | 'expired' | 'interrupted';
+type SimulatedLinkPaymentResult = LinkPaymentResult & {
+    mode: 'SIMULATED';
+    settlementVerified: false;
+};
+interface LinkTestOptions {
+    scenario?: LinkTestScenario;
+    /** A local fixture limit, not a real Conto policy or available balance. Defaults to 5000 cents. */
+    maximumAmountMinor?: number;
+}
+/**
+ * Create an isolated in-memory test account with the same pay/resume/status API.
+ * Approval is explicit through link.approve(), a test-only method. Nothing settles.
+ */
+declare function createLinkTestClient(options?: LinkTestOptions): {
+    mode: "SIMULATED";
+    link: {
+        setup: (input?: LinkSetupInput) => Promise<LinkSetupResult & {
+            mode: "SIMULATED";
+            settlementVerified: false;
+        }>;
+        paymentMethods: () => Promise<ListStripeLinkPaymentMethodsResult & {
+            mode: "SIMULATED";
+            settlementVerified: false;
+        }>;
+        pay: (input: LinkPaymentInput) => Promise<SimulatedLinkPaymentResult>;
+        resume: (id: string) => Promise<SimulatedLinkPaymentResult>;
+        status: (id: string) => Promise<SimulatedLinkPaymentResult>;
+        cancel: (id: string) => Promise<SimulatedLinkPaymentResult>;
+        /** Test-only owner action. Never available on the live Link client. */
+        approve: (id: string) => Promise<SimulatedLinkPaymentResult>;
+    };
+};
+
+export { type LinkTestOptions, type LinkTestScenario, type SimulatedLinkPaymentResult, createLinkTestClient };

package/dist/link-testing.d.ts

@@ -0,0 +1,37 @@
+import { LinkPaymentResult, LinkSetupInput, LinkSetupResult, ListStripeLinkPaymentMethodsResult, LinkPaymentInput } from './index.js';
+
+type LinkTestScenario = 'approved' | 'denied' | 'expired' | 'interrupted';
+type SimulatedLinkPaymentResult = LinkPaymentResult & {
+    mode: 'SIMULATED';
+    settlementVerified: false;
+};
+interface LinkTestOptions {
+    scenario?: LinkTestScenario;
+    /** A local fixture limit, not a real Conto policy or available balance. Defaults to 5000 cents. */
+    maximumAmountMinor?: number;
+}
+/**
+ * Create an isolated in-memory test account with the same pay/resume/status API.
+ * Approval is explicit through link.approve(), a test-only method. Nothing settles.
+ */
+declare function createLinkTestClient(options?: LinkTestOptions): {
+    mode: "SIMULATED";
+    link: {
+        setup: (input?: LinkSetupInput) => Promise<LinkSetupResult & {
+            mode: "SIMULATED";
+            settlementVerified: false;
+        }>;
+        paymentMethods: () => Promise<ListStripeLinkPaymentMethodsResult & {
+            mode: "SIMULATED";
+            settlementVerified: false;
+        }>;
+        pay: (input: LinkPaymentInput) => Promise<SimulatedLinkPaymentResult>;
+        resume: (id: string) => Promise<SimulatedLinkPaymentResult>;
+        status: (id: string) => Promise<SimulatedLinkPaymentResult>;
+        cancel: (id: string) => Promise<SimulatedLinkPaymentResult>;
+        /** Test-only owner action. Never available on the live Link client. */
+        approve: (id: string) => Promise<SimulatedLinkPaymentResult>;
+    };
+};
+
+export { type LinkTestOptions, type LinkTestScenario, type SimulatedLinkPaymentResult, createLinkTestClient };

package/dist/link-testing.js

@@ -0,0 +1,264 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/link-testing.ts
+var link_testing_exports = {};
+__export(link_testing_exports, {
+  createLinkTestClient: () => createLinkTestClient
+});
+module.exports = __toCommonJS(link_testing_exports);
+var import_node_crypto = require("crypto");
+var import_index = require("./index.js");
+function canonical(value) {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  if (value && typeof value === "object") {
+    return `{${Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a.localeCompare(b)).map(([key, v]) => `${JSON.stringify(key)}:${canonical(v)}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function fail(code, message, status = 409) {
+  throw new import_index.ContoError(message, { code, status });
+}
+function createLinkTestClient(options = {}) {
+  const scenario = options.scenario ?? "approved";
+  const maximumAmountMinor = options.maximumAmountMinor ?? 5e3;
+  if (!["approved", "denied", "expired", "interrupted"].includes(scenario) || !Number.isSafeInteger(maximumAmountMinor) || maximumAmountMinor <= 0) {
+    throw new import_index.ContoError("Invalid Link simulation options", {
+      code: "INVALID_LINK_TEST_OPTIONS",
+      status: 0
+    });
+  }
+  const records = /* @__PURE__ */ new Map();
+  const intents = /* @__PURE__ */ new Map();
+  let sequence = 0;
+  const sessionId = (0, import_node_crypto.randomUUID)();
+  const read = (id) => {
+    const record = records.get(id);
+    if (!record)
+      return fail(
+        "SIMULATED_EXECUTION_NOT_FOUND",
+        "No such execution in this local simulation",
+        404
+      );
+    return record;
+  };
+  const response = (id) => ({
+    execution: structuredClone(read(id))
+  });
+  const setStatus = (id, status) => {
+    const record = read(id);
+    record.status = status;
+    record.evidence.status = status;
+    record.providerStatus = `SIMULATED_${status}`;
+    record.evidence.providerStatus = record.providerStatus;
+    delete record.approvalUrl;
+    return response(id);
+  };
+  const setup = async (_input = {}) => ({
+    version: "conto.link-setup.v1",
+    mode: "SIMULATED",
+    configurationStatus: "CONFIGURED",
+    checks: [
+      {
+        code: "LOCAL_SIMULATION",
+        status: "WARNING",
+        actor: "developer",
+        message: "Local workflow fixture only. No real Link account, Conto policy, checkout, budget, or settlement is tested."
+      }
+    ],
+    missingScopes: [],
+    paymentAuthorization: "NOT_EVALUATED",
+    providerVerified: false,
+    settlementVerified: false
+  });
+  const transport = {
+    getLinkSetup: setup,
+    async listStripeLinkPaymentMethods() {
+      return {
+        organizationId: "simulated_org",
+        connectionId: "simulated_connection",
+        paymentMethods: [
+          {
+            id: "simulated_method",
+            type: "SIMULATED",
+            isDefault: true,
+            displayLabel: "Simulated funding source \u2014 no funds",
+            eligibleCredentialTypes: ["LINK_PAY_TOKEN"]
+          }
+        ]
+      };
+    },
+    async beginCommerceExecution(input) {
+      if (input.executionMethod !== "LINK_PAY_TOKEN")
+        return fail(
+          "SIMULATED_METHOD_UNSUPPORTED",
+          "Only the Link Pay Token workflow is simulated"
+        );
+      const key = input.idempotencyKey?.trim();
+      if (!key || key.length < 8 || key.length > 255) {
+        return fail(
+          "INVALID_IDEMPOTENCY_KEY",
+          "idempotencyKey must contain 8 to 255 characters",
+          0
+        );
+      }
+      const fingerprint = canonical({ ...input, idempotencyKey: key });
+      const prior = intents.get(key);
+      if (prior) {
+        if (prior.fingerprint !== fingerprint)
+          return fail("IDEMPOTENCY_CONFLICT", "The key belongs to a different simulated purchase");
+        return response(prior.id);
+      }
+      if (scenario === "denied" || input.amountMinor > maximumAmountMinor) {
+        return fail(
+          "COMMERCE_POLICY_DENIED",
+          "The local simulated policy denied this purchase",
+          403
+        );
+      }
+      if (records.size >= 1e3)
+        return fail(
+          "SIMULATION_CAPACITY_REACHED",
+          "Create a new test client to start another simulation"
+        );
+      const id = `sim_link_${sessionId}_${++sequence}`;
+      const status = "AWAITING_APPROVAL";
+      const evidence = {
+        schemaVersion: "conto.commerce-evidence.v1",
+        traceId: `sim_trace_${sequence}`,
+        executionId: id,
+        intentId: `sim_intent_${sequence}`,
+        organizationId: "simulated_org",
+        actorUserId: "simulated_owner",
+        agentId: "simulated_agent",
+        provider: "STRIPE_LINK",
+        sourceKind: "STRIPE_LINK",
+        amountMinor: input.amountMinor,
+        currency: input.currency,
+        purpose: input.purpose,
+        counterpartyId: input.counterparty.canonicalId,
+        counterpartyName: "Simulated checkout",
+        intentFingerprint: `sim_fingerprint_${sequence}`,
+        policyDecisionId: `sim_policy_${sequence}`,
+        policySnapshotHash: "simulated_policy",
+        grantId: `sim_grant_${sequence}`,
+        status,
+        deliveryMode: "SERVER_ONLY_ARTIFACT",
+        artifactKind: "LINK_PAY_TOKEN",
+        providerStatus: "SIMULATED_AWAITING_APPROVAL"
+      };
+      records.set(id, {
+        id,
+        intentId: evidence.intentId,
+        organizationId: evidence.organizationId,
+        agentId: evidence.agentId,
+        provider: "STRIPE_LINK",
+        executionAdapter: "STRIPE_LINK",
+        executionChannel: "BROWSER",
+        checkoutMethod: "LINK",
+        status,
+        providerStatus: evidence.providerStatus,
+        artifactKind: "LINK_PAY_TOKEN",
+        deliveryMode: "SERVER_ONLY_ARTIFACT",
+        // Reserved .invalid domain. It cannot approve anything; call the test-only approve() method.
+        approvalUrl: `https://link-simulation.invalid/approve/${id}`,
+        amountMinor: input.amountMinor,
+        currency: input.currency,
+        purpose: input.purpose,
+        counterparty: { id: input.counterparty.canonicalId, name: "Simulated checkout" },
+        evidence,
+        evidenceFingerprint: `sim_evidence_${sequence}`
+      });
+      intents.set(key, { fingerprint, id });
+      return response(id);
+    },
+    async getCommerceExecution(id) {
+      return response(id);
+    },
+    async refreshCommerceExecution(id) {
+      return response(id);
+    },
+    async executeCommerceExecution(id) {
+      if (read(id).status !== "READY")
+        return fail("COMMERCE_EXECUTION_NOT_READY", "The simulated payment is not ready");
+      if (scenario === "interrupted") {
+        setStatus(id, "NEEDS_RECONCILIATION");
+        return fail(
+          "SIMULATED_EXECUTION_INTERRUPTED",
+          "Simulated lost execution response; inspect the existing execution",
+          0
+        );
+      }
+      return {
+        ...setStatus(id, "COMPLETED"),
+        checkout: {
+          submitted: false,
+          accepted: false,
+          deliveryMode: "SERVER_ONLY_ARTIFACT"
+        }
+      };
+    },
+    async cancelCommerceExecution(id) {
+      if (["PROCESSING", "NEEDS_RECONCILIATION", "COMPLETED", "SETTLED"].includes(read(id).status)) {
+        return fail(
+          "SIMULATED_CANCELLATION_UNAVAILABLE",
+          "This simulated execution must be reconciled and cannot be cancelled"
+        );
+      }
+      return setStatus(id, "CANCELLED");
+    }
+  };
+  const client = new import_index.LinkClient(transport, {
+    connectionId: "simulated_connection",
+    paymentMethodId: "simulated_method"
+  });
+  const marked = async (operation) => {
+    try {
+      return { ...await operation(), mode: "SIMULATED", settlementVerified: false };
+    } catch (error) {
+      const safe = error instanceof import_index.ContoError ? error : new import_index.ContoError("Local simulation failed", { code: "SIMULATION_FAILED", status: 0 });
+      throw Object.assign(safe, { mode: "SIMULATED", settlementVerified: false });
+    }
+  };
+  return {
+    mode: "SIMULATED",
+    link: {
+      setup: (input) => marked(() => client.setup(input)),
+      paymentMethods: () => marked(() => client.paymentMethods()),
+      pay: (input) => marked(() => client.pay(input)),
+      resume: (id) => marked(() => client.resume(id)),
+      status: (id) => marked(() => client.status(id)),
+      cancel: (id) => marked(() => client.cancel(id)),
+      /** Test-only owner action. Never available on the live Link client. */
+      approve: (id) => marked(async () => {
+        if (read(id).status !== "AWAITING_APPROVAL")
+          return fail(
+            "SIMULATED_APPROVAL_UNAVAILABLE",
+            "This simulation is not awaiting approval"
+          );
+        setStatus(id, scenario === "expired" ? "EXPIRED" : "READY");
+        return client.status(id);
+      })
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createLinkTestClient
+});