@alphawebai/hs-prism 0.1.0-rc.27

package/dist/src/alphaweb/stripe-connector.js

@@ -0,0 +1,1402 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrismStripeConnector = void 0;
+exports.verifyPrismStripeRuntimeCredential = verifyPrismStripeRuntimeCredential;
+const node_crypto_1 = require("node:crypto");
+const _generated_connector_client_flows_1 = require("../payments/_generated_connector_client_flows");
+const errors_1 = require("../payments/errors");
+const proto_1 = require("../payments/generated/proto");
+const error_1 = require("./error");
+const manifest_1 = require("./manifest");
+const money_1 = require("./money");
+const STRIPE_API_BASE = 'https://api.stripe.com/v1';
+const OPERATION_METADATA_KEYS = new Set(['medusa_payment_session_id', 'alphaweb_owner_id']);
+function recordOf(value) {
+    return typeof value === 'object' && value !== null ? value : {};
+}
+function stringOf(value) {
+    return typeof value === 'string' && value.length > 0 ? value : null;
+}
+function integerOf(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) ? value : null;
+}
+function secret(value) {
+    return { value };
+}
+function configurationError(safeMessage, code) {
+    return new error_1.PrismOperationError({
+        category: 'configuration',
+        providerCode: code,
+        retryable: false,
+        outcome: 'definitely_not_applied',
+        safeMessage,
+    });
+}
+function validationError(safeMessage, code) {
+    return new error_1.PrismOperationError({
+        category: 'validation',
+        providerCode: code,
+        retryable: false,
+        outcome: 'definitely_not_applied',
+        safeMessage,
+    });
+}
+function assertIdentifier(value, name) {
+    if (!/^[A-Za-z0-9:_-]{1,255}$/.test(value)) {
+        throw validationError(`${name} is invalid.`, 'PRISM_INVALID_IDENTIFIER');
+    }
+}
+function currencyEnum(currency) {
+    const normalized = currency.trim().toUpperCase();
+    const value = proto_1.types.Currency[normalized];
+    if (typeof value !== 'number') {
+        throw validationError('Currency is not supported by the native Prism contract.', 'PRISM_CURRENCY');
+    }
+    return value;
+}
+function moneyMessage(money) {
+    const normalized = (0, money_1.assertSafeProviderMoney)(money);
+    return { minorAmount: normalized.amountMinor, currency: currencyEnum(normalized.currency) };
+}
+function paymentStatus(status) {
+    switch (status) {
+        case proto_1.types.PaymentStatus.PAYMENT_METHOD_AWAITED:
+        case proto_1.types.PaymentStatus.CONFIRMATION_AWAITED:
+            return 'requires_payment_method';
+        case proto_1.types.PaymentStatus.AUTHENTICATION_PENDING:
+            return 'requires_customer_action';
+        case proto_1.types.PaymentStatus.AUTHORIZING:
+        case proto_1.types.PaymentStatus.STARTED:
+        case proto_1.types.PaymentStatus.PENDING:
+        case proto_1.types.PaymentStatus.CAPTURE_INITIATED:
+            return 'pending_authorization';
+        case proto_1.types.PaymentStatus.AUTHORIZED:
+        case proto_1.types.PaymentStatus.PARTIALLY_AUTHORIZED:
+            return 'authorized';
+        case proto_1.types.PaymentStatus.CHARGED:
+        case proto_1.types.PaymentStatus.PARTIAL_CHARGED:
+        case proto_1.types.PaymentStatus.PARTIAL_CHARGED_AND_CHARGEABLE:
+            return 'captured';
+        case proto_1.types.PaymentStatus.VOIDED:
+        case proto_1.types.PaymentStatus.VOIDED_POST_CAPTURE:
+        case proto_1.types.PaymentStatus.EXPIRED:
+            return 'canceled';
+        case proto_1.types.PaymentStatus.AUTHENTICATION_FAILED:
+        case proto_1.types.PaymentStatus.AUTHORIZATION_FAILED:
+        case proto_1.types.PaymentStatus.CAPTURE_FAILED:
+        case proto_1.types.PaymentStatus.VOID_FAILED:
+        case proto_1.types.PaymentStatus.ROUTER_DECLINED:
+        case proto_1.types.PaymentStatus.FAILURE:
+            return 'failed';
+        default:
+            return typeof status === 'string' ? stripePaymentStatus(status) : 'unknown';
+    }
+}
+function stripePaymentStatus(status) {
+    switch (status) {
+        case 'requires_payment_method':
+            return 'requires_payment_method';
+        case 'requires_action':
+        case 'requires_confirmation':
+            return 'requires_customer_action';
+        case 'processing':
+            return 'pending_authorization';
+        case 'requires_capture':
+            return 'authorized';
+        case 'succeeded':
+            return 'captured';
+        case 'canceled':
+            return 'canceled';
+        default:
+            return 'unknown';
+    }
+}
+function normalizedStripeIntentStatus(intent) {
+    const status = stripePaymentStatus(intent.status);
+    return status === 'requires_payment_method' && intent.failure?.category === 'customer_action'
+        ? 'requires_customer_action'
+        : status;
+}
+function operationMetadata(input) {
+    const metadata = {
+        alphaweb_operation_id: input.operationId,
+        alphaweb_operation_kind: input.kind,
+        alphaweb_contract_version: manifest_1.ALPHAWEB_PRISM_COMPATIBILITY_MANIFEST.release,
+    };
+    for (const key of OPERATION_METADATA_KEYS) {
+        const value = input.metadata[key];
+        if (typeof value === 'string' && value.length > 0)
+            metadata[key] = value;
+    }
+    return metadata;
+}
+function connectorPaymentIdFrom(response) {
+    const data = recordOf(response);
+    return stringOf(data.connectorTransactionId) ?? stringOf(data.connectorPaymentId);
+}
+function connectorPaymentIdFromError(error) {
+    if (!(error instanceof errors_1.ConnectorError))
+        return null;
+    const proto = recordOf(error.proto);
+    const errorInfo = recordOf(proto.errorInfo ?? proto.error_info);
+    const connectorDetails = recordOf(errorInfo.connectorDetails ?? errorInfo.connector_details);
+    return (stringOf(connectorDetails.connectorTransactionId) ??
+        stringOf(connectorDetails.connector_transaction_id));
+}
+function reconciliationRequiredError(code, safeMessage, cause, retryable = true) {
+    return new error_1.PrismOperationError({
+        category: 'conflict',
+        providerCode: code,
+        retryable,
+        outcome: 'ambiguous',
+        safeMessage,
+    }, cause instanceof Error ? { cause } : undefined);
+}
+function readSecret(value) {
+    return stringOf(recordOf(value).value);
+}
+function buildResult(response, money, fallbackConnectorPaymentId = null) {
+    const data = recordOf(response);
+    return {
+        connectorPaymentId: connectorPaymentIdFrom(response) ?? fallbackConnectorPaymentId,
+        status: paymentStatus(data.status),
+        money,
+    };
+}
+/**
+ * Package-owned intersection of Stripe's API support contract and the payment
+ * method types represented by Prism's recurring-payment ABI.
+ *
+ * An interactive PaymentIntent can still use any method Stripe exposes through
+ * automatic payment methods. This table only governs server-side reuse after
+ * Stripe has attached the method to the proven Customer.
+ */
+const STRIPE_REUSABLE_PAYMENT_METHOD_PROFILES = Object.freeze({
+    amazon_pay: {
+        prismPaymentMethodType: proto_1.types.PaymentMethodType.AMAZON_PAY,
+        supportsFutureUsage: true,
+        supportsManualCapture: true,
+    },
+    card: {
+        prismPaymentMethodType: proto_1.types.PaymentMethodType.CREDIT,
+        supportsFutureUsage: true,
+        supportsManualCapture: true,
+    },
+    cashapp: {
+        prismPaymentMethodType: proto_1.types.PaymentMethodType.CASHAPP,
+        supportsFutureUsage: true,
+        supportsManualCapture: true,
+    },
+    ideal: {
+        prismPaymentMethodType: proto_1.types.PaymentMethodType.IDEAL,
+        supportsFutureUsage: true,
+        supportsManualCapture: false,
+    },
+    link: {
+        prismPaymentMethodType: proto_1.types.PaymentMethodType.CREDIT,
+        supportsFutureUsage: true,
+        supportsManualCapture: true,
+    },
+    paypal: {
+        prismPaymentMethodType: proto_1.types.PaymentMethodType.PAY_PAL,
+        supportsFutureUsage: true,
+        supportsManualCapture: true,
+    },
+    revolut_pay: {
+        prismPaymentMethodType: proto_1.types.PaymentMethodType.REVOLUT_PAY,
+        supportsFutureUsage: true,
+        supportsManualCapture: true,
+    },
+    sepa_debit: {
+        prismPaymentMethodType: proto_1.types.PaymentMethodType.SEPA,
+        supportsFutureUsage: true,
+        supportsManualCapture: false,
+    },
+    twint: {
+        prismPaymentMethodType: proto_1.types.PaymentMethodType.TWINT,
+        supportsFutureUsage: true,
+        supportsManualCapture: false,
+    },
+    us_bank_account: {
+        prismPaymentMethodType: proto_1.types.PaymentMethodType.ACH,
+        supportsFutureUsage: true,
+        supportsManualCapture: false,
+    },
+});
+function reusablePaymentMethodProfile(type) {
+    const profile = STRIPE_REUSABLE_PAYMENT_METHOD_PROFILES[type];
+    if (!profile?.supportsFutureUsage) {
+        throw configurationError('The saved Stripe payment method is not supported for a reusable Prism payment.', 'PRISM_REUSABLE_METHOD_UNSUPPORTED');
+    }
+    return profile;
+}
+const STRIPE_HARD_DECLINE_CODES = new Set([
+    'authentication_required',
+    'highest_risk_level',
+    'incorrect_number',
+    'lost_card',
+    'pickup_card',
+    'revocation_of_all_authorizations',
+    'revocation_of_authorization',
+    'stolen_card',
+    'transaction_not_allowed',
+]);
+const STRIPE_RETRYABLE_DECLINE_CODES = new Set([
+    'approve_with_id',
+    'insufficient_funds',
+    'issuer_not_available',
+    'processing_error',
+    'try_again_later',
+]);
+function stripePaymentFailure(value) {
+    const failure = recordOf(value);
+    const providerCode = stringOf(failure.code);
+    const declineCode = stringOf(failure.decline_code);
+    const chargeOutcome = recordOf(recordOf(failure.charge).outcome);
+    const adviceCode = stringOf(failure.advice_code) ?? stringOf(chargeOutcome.advice_code);
+    if (!providerCode && !declineCode && !adviceCode)
+        return undefined;
+    const category = declineCode === 'authentication_required'
+        ? 'customer_action'
+        : declineCode || providerCode === 'card_declined'
+            ? 'declined'
+            : providerCode?.includes('payment_method') || providerCode?.includes('card')
+                ? 'invalid_payment_method'
+                : 'unknown';
+    const retryable = adviceCode === 'try_again_later' ||
+        (!adviceCode &&
+            !!declineCode &&
+            STRIPE_RETRYABLE_DECLINE_CODES.has(declineCode) &&
+            !STRIPE_HARD_DECLINE_CODES.has(declineCode));
+    return {
+        category,
+        ...(providerCode ? { providerCode } : {}),
+        ...(declineCode ? { declineCode } : {}),
+        ...(adviceCode ? { adviceCode } : {}),
+        retryable,
+    };
+}
+function parseStripePaymentIntent(value) {
+    const data = recordOf(value);
+    const id = stringOf(data.id);
+    const amount = integerOf(data.amount);
+    const currency = stringOf(data.currency);
+    const status = stringOf(data.status);
+    if (!id || amount === null || !currency || !status || typeof data.livemode !== 'boolean') {
+        throw validationError('Stripe returned an invalid PaymentIntent shape.', 'PRISM_STRIPE_SHAPE');
+    }
+    const failure = stripePaymentFailure(data.last_payment_error);
+    return {
+        id,
+        amount,
+        currency,
+        status,
+        customer: stringOf(data.customer),
+        payment_method: stringOf(data.payment_method),
+        mandate: stringOf(data.mandate),
+        setup_future_usage: stringOf(data.setup_future_usage),
+        livemode: data.livemode,
+        metadata: Object.fromEntries(Object.entries(recordOf(data.metadata)).filter((entry) => typeof entry[1] === 'string')),
+        ...(failure ? { failure } : {}),
+    };
+}
+function parseStripePaymentMethod(value) {
+    const data = recordOf(value);
+    const id = stringOf(data.id);
+    const type = stringOf(data.type);
+    if (!id || !type || typeof data.livemode !== 'boolean') {
+        throw validationError('Stripe returned an invalid PaymentMethod shape.', 'PRISM_STRIPE_SHAPE');
+    }
+    const card = recordOf(data.card);
+    const expMonth = integerOf(card.exp_month);
+    const expYear = integerOf(card.exp_year);
+    const brand = stringOf(card.brand);
+    const last4 = stringOf(card.last4);
+    const safeDisplay = type === 'card'
+        ? {
+            ...(brand ? { brand } : {}),
+            ...(last4 ? { last4 } : {}),
+            ...(expMonth !== null ? { expMonth } : {}),
+            ...(expYear !== null ? { expYear } : {}),
+        }
+        : undefined;
+    return {
+        id,
+        type,
+        customer: stringOf(data.customer),
+        livemode: data.livemode,
+        ...(safeDisplay && Object.keys(safeDisplay).length > 0 ? { safeDisplay } : {}),
+    };
+}
+function stringMetadata(value) {
+    return Object.fromEntries(Object.entries(recordOf(value)).filter((entry) => typeof entry[1] === 'string'));
+}
+function parseStripeRefund(value) {
+    const data = recordOf(value);
+    const id = stringOf(data.id);
+    const paymentIntentId = stringOf(data.payment_intent);
+    const amount = integerOf(data.amount);
+    const currency = stringOf(data.currency);
+    const status = stringOf(data.status);
+    if (!id ||
+        !paymentIntentId ||
+        amount === null ||
+        amount < 0 ||
+        !currency ||
+        !status) {
+        throw validationError('Stripe returned an invalid Refund shape.', 'PRISM_STRIPE_SHAPE');
+    }
+    return {
+        id,
+        paymentIntentId,
+        amount,
+        currency: currency.toLowerCase(),
+        status,
+        metadata: stringMetadata(data.metadata),
+    };
+}
+function parseStripeDispute(value) {
+    const data = recordOf(value);
+    const evidence = recordOf(data.evidence_details);
+    const id = stringOf(data.id);
+    const chargeId = stringOf(data.charge);
+    const paymentIntentId = stringOf(data.payment_intent);
+    const amount = integerOf(data.amount);
+    const currency = stringOf(data.currency);
+    const status = stringOf(data.status);
+    const created = integerOf(data.created);
+    const evidenceDueBy = integerOf(evidence.due_by);
+    if (!id ||
+        !chargeId ||
+        !paymentIntentId ||
+        amount === null ||
+        amount < 0 ||
+        !currency ||
+        !status ||
+        created === null ||
+        typeof data.livemode !== 'boolean') {
+        throw validationError('Stripe returned an invalid Dispute shape.', 'PRISM_STRIPE_SHAPE');
+    }
+    return {
+        id,
+        chargeId,
+        paymentIntentId,
+        amount,
+        currency: currency.toLowerCase(),
+        status,
+        reason: stringOf(data.reason),
+        livemode: data.livemode,
+        created,
+        evidenceDueBy,
+        isChargeRefundable: typeof data.is_charge_refundable === 'boolean' ? data.is_charge_refundable : null,
+    };
+}
+function normalizedRefundStatus(status) {
+    if (status === 'succeeded')
+        return 'succeeded';
+    if (status === 'failed' || status === 'canceled')
+        return 'failed';
+    if (status === 'pending' || status === 'requires_action')
+        return 'pending';
+    return 'unknown';
+}
+function normalizedDisputeStatus(status) {
+    if (status === 'warning_needs_response')
+        return 'warning_needs_response';
+    if (status === 'needs_response')
+        return 'needs_response';
+    if (status === 'under_review')
+        return 'under_review';
+    if (status === 'won')
+        return 'won';
+    if (status === 'lost')
+        return 'lost';
+    if (status === 'closed')
+        return 'closed';
+    return 'unknown';
+}
+function assertUniqueBindings(bindings) {
+    const bySecret = new Map();
+    for (const binding of bindings) {
+        const owner = `${binding.credentialBindingId}:${binding.providerAccountId}:${binding.endpointId}`;
+        const existing = bySecret.get(binding.secret);
+        if (existing && existing !== owner) {
+            throw configurationError('A Stripe webhook signing secret is assigned to more than one runtime binding.', 'PRISM_WEBHOOK_BINDING_AMBIGUOUS');
+        }
+        bySecret.set(binding.secret, owner);
+    }
+}
+function objectKind(type) {
+    if (type.startsWith('payment_intent.'))
+        return 'payment_intent';
+    if (type.startsWith('setup_intent.'))
+        return 'setup_intent';
+    if (type.startsWith('refund.'))
+        return 'refund';
+    if (type.startsWith('charge.dispute.'))
+        return 'dispute';
+    if (type.startsWith('mandate.'))
+        return 'mandate';
+    if (type.startsWith('payment_method.'))
+        return 'payment_method';
+    return 'unknown';
+}
+function webhookMoney(object) {
+    const amount = integerOf(object.amount);
+    const currency = stringOf(object.currency);
+    return amount !== null && amount >= 0 && currency
+        ? { amountMinor: amount.toString(), currency: currency.toLowerCase() }
+        : null;
+}
+function normalizedWebhookStatus(type, object) {
+    const status = stringOf(object.status);
+    if (type === 'payment_intent.amount_capturable_updated')
+        return 'authorized';
+    if (type === 'payment_intent.payment_failed') {
+        const failure = stripePaymentFailure(object.last_payment_error);
+        if (failure?.category === 'customer_action')
+            return 'requires_customer_action';
+        return status ? stripePaymentStatus(status) : 'failed';
+    }
+    if (type === 'setup_intent.setup_failed')
+        return 'failed';
+    if (type === 'payment_intent.canceled' || type === 'setup_intent.canceled')
+        return 'canceled';
+    if (type === 'payment_intent.requires_action' || type === 'setup_intent.requires_action') {
+        return 'requires_customer_action';
+    }
+    return status ? stripePaymentStatus(status) : null;
+}
+function safeWebhookData(type, object) {
+    const allowedByFamily = {
+        payment_intent: ['status', 'capture_method', 'cancellation_reason', 'amount_capturable'],
+        setup_intent: ['status', 'usage', 'cancellation_reason'],
+        refund: ['status', 'reason', 'failure_reason'],
+        dispute: ['status', 'reason', 'is_charge_refundable'],
+        mandate: ['status', 'type'],
+        payment_method: ['type', 'allow_redisplay'],
+    };
+    const family = objectKind(type);
+    const result = {};
+    for (const key of allowedByFamily[family] ?? []) {
+        const value = object[key];
+        if (value === null || ['string', 'number', 'boolean'].includes(typeof value)) {
+            result[key] = value;
+        }
+    }
+    if (family === 'payment_intent') {
+        const failure = stripePaymentFailure(object.last_payment_error);
+        if (failure) {
+            result.payment_failure_category = failure.category;
+            result.payment_failure_retryable = failure.retryable;
+            if (failure.providerCode)
+                result.payment_failure_provider_code = failure.providerCode;
+            if (failure.declineCode)
+                result.payment_failure_decline_code = failure.declineCode;
+            if (failure.adviceCode)
+                result.payment_failure_advice_code = failure.adviceCode;
+        }
+    }
+    return result;
+}
+function parseWebhookDocument(input, binding) {
+    let decoded;
+    try {
+        decoded = JSON.parse(Buffer.from(input.rawBody).toString('utf8'));
+    }
+    catch {
+        throw validationError('The verified Stripe webhook body is not valid JSON.', 'PRISM_WEBHOOK_JSON');
+    }
+    const event = recordOf(decoded);
+    const providerEventId = stringOf(event.id);
+    const type = stringOf(event.type);
+    const created = integerOf(event.created);
+    const apiVersion = event.api_version === null ? null : stringOf(event.api_version);
+    const livemode = event.livemode;
+    const object = recordOf(recordOf(event.data).object);
+    const objectId = stringOf(object.id);
+    if (!providerEventId ||
+        !type ||
+        created === null ||
+        !objectId ||
+        typeof livemode !== 'boolean') {
+        throw validationError('The verified Stripe event identity is incomplete.', 'PRISM_WEBHOOK_IDENTITY');
+    }
+    if (livemode !== binding.livemode) {
+        throw validationError('Stripe webhook livemode does not match its verified binding.', 'PRISM_WEBHOOK_MODE');
+    }
+    const eventAccount = stringOf(event.account);
+    if (eventAccount && eventAccount !== binding.providerAccountId) {
+        throw validationError('Stripe webhook account does not match its verified binding.', 'PRISM_WEBHOOK_ACCOUNT');
+    }
+    const kind = objectKind(type);
+    const paymentIntentId = kind === 'payment_intent' ? objectId : stringOf(object.payment_intent);
+    const bodyDigest = (0, node_crypto_1.createHash)('sha256').update(input.rawBody).digest('hex');
+    const envelope = {
+        provider: 'stripe',
+        providerEventId,
+        credentialBindingId: binding.credentialBindingId,
+        providerAccountId: binding.providerAccountId,
+        livemode: binding.livemode,
+        apiVersion,
+        type,
+        createdAt: new Date(created * 1000).toISOString(),
+        objectKind: kind,
+        objectId,
+        paymentIntentId,
+        bodyDigest,
+    };
+    if (apiVersion !== input.expectedApiVersion) {
+        return {
+            status: 'normalization_failed',
+            envelope,
+            error: {
+                code: 'WEBHOOK_SCHEMA_VERSION_MISMATCH',
+                safeMessage: 'The Stripe event uses an unsupported API schema version.',
+            },
+        };
+    }
+    if (!manifest_1.ALPHAWEB_STRIPE_WEBHOOK_EVENTS.includes(type)) {
+        return {
+            status: 'normalization_failed',
+            envelope,
+            error: {
+                code: 'WEBHOOK_EVENT_UNSUPPORTED',
+                safeMessage: 'The verified Stripe event type is not in the compatibility manifest.',
+            },
+        };
+    }
+    const metadata = recordOf(object.metadata);
+    const money = webhookMoney(object);
+    const refundMerchantOperationId = kind === 'refund' && metadata.is_refund_id_as_reference === 'true'
+        ? stringOf(metadata.order_id)
+        : null;
+    const normalized = {
+        ...envelope,
+        customerId: stringOf(object.customer),
+        paymentMethodId: stringOf(object.payment_method),
+        mandateId: stringOf(object.mandate),
+        merchantOperationId: refundMerchantOperationId ?? stringOf(metadata.alphaweb_operation_id),
+        medusaPaymentSessionId: stringOf(metadata.medusa_payment_session_id),
+        status: normalizedWebhookStatus(type, object),
+        money,
+        refunds: kind === 'refund' && money
+            ? [
+                {
+                    refundId: objectId,
+                    chargeId: stringOf(object.charge),
+                    paymentIntentId,
+                    status: (() => {
+                        const status = stringOf(object.status);
+                        if (status === 'succeeded')
+                            return 'succeeded';
+                        if (status === 'failed')
+                            return 'failed';
+                        if (status === 'canceled')
+                            return 'canceled';
+                        if (status === 'pending' || status === 'requires_action')
+                            return 'pending';
+                        return 'unknown';
+                    })(),
+                    money,
+                },
+            ]
+            : [],
+        safeData: safeWebhookData(type, object),
+    };
+    if (kind === 'refund' && !money) {
+        return {
+            status: 'normalization_failed',
+            envelope,
+            error: {
+                code: 'WEBHOOK_OBJECT_INVALID',
+                safeMessage: 'The Stripe refund event is missing amount or currency.',
+            },
+        };
+    }
+    return { status: 'normalized', event: normalized };
+}
+class PrismStripeConnector {
+    options;
+    dependencies;
+    constructor(options, dependencies) {
+        this.options = Object.freeze({ ...options });
+        this.validateOptions();
+        const config = {
+            options: {
+                environment: options.environment === 'test' ? proto_1.types.Environment.SANDBOX : proto_1.types.Environment.PRODUCTION,
+            },
+            connectorConfig: { stripe: { apiKey: secret(options.secretKey) } },
+        };
+        this.dependencies = dependencies ?? {
+            merchantAuthentication: new _generated_connector_client_flows_1.MerchantAuthenticationClient(config, {}, options.nativeLibraryPath),
+            payments: new _generated_connector_client_flows_1.PaymentClient(config, {}, options.nativeLibraryPath),
+            recurringPayments: new _generated_connector_client_flows_1.RecurringPaymentClient(config, {}, options.nativeLibraryPath),
+            events: new _generated_connector_client_flows_1.EventClient(config, {}, options.nativeLibraryPath),
+            fetch,
+        };
+    }
+    validateOptions() {
+        assertIdentifier(this.options.credentialBindingId, 'credentialBindingId');
+        assertIdentifier(this.options.providerAccountId, 'providerAccountId');
+        const test = this.options.environment === 'test';
+        if (!this.options.secretKey.startsWith(test ? 'sk_test_' : 'sk_live_')) {
+            throw configurationError('Stripe secret key mode does not match Prism environment.', 'PRISM_KEY_MODE');
+        }
+        if (this.options.publishableKey &&
+            !this.options.publishableKey.startsWith(test ? 'pk_test_' : 'pk_live_')) {
+            throw configurationError('Stripe publishable key mode does not match Prism environment.', 'PRISM_PUBLISHABLE_KEY_MODE');
+        }
+    }
+    assertOperation(input) {
+        assertIdentifier(input.operationId, 'operationId');
+        assertIdentifier(input.idempotencyKey, 'idempotencyKey');
+        if (input.credentialBindingId !== this.options.credentialBindingId) {
+            throw configurationError('Payment operation credential binding is stale.', 'PRISM_BINDING_MISMATCH');
+        }
+    }
+    async recoverRepeatPayment(connectorPaymentId, input, expectedOwnerId, expectedConnectorCustomerId) {
+        try {
+            return await this.retrievePayment({
+                connectorPaymentId,
+                money: input.money,
+                operationId: input.operationId,
+                expectedOwnerId,
+                expectedConnectorCustomerId,
+            });
+        }
+        catch (recoveryError) {
+            const normalizedRecovery = (0, error_1.normalizePrismError)(recoveryError);
+            const ownershipConflict = normalizedRecovery.shape.providerCode === 'PRISM_PAYMENT_OWNERSHIP';
+            throw reconciliationRequiredError(ownershipConflict ? 'PRISM_REPEAT_RESULT_CONFLICT' : 'PRISM_REPEAT_RESULT_UNRESOLVED', ownershipConflict
+                ? 'The provider payment identity does not match the reusable payment operation.'
+                : 'The reusable payment result must be reconciled before retrying.', recoveryError, !ownershipConflict);
+        }
+    }
+    async stripeRequest(method, path, body, idempotencyKey) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.options.requestTimeoutMs ?? 15_000);
+        try {
+            const response = await this.dependencies.fetch(`${STRIPE_API_BASE}${path}`, {
+                method,
+                headers: {
+                    Authorization: `Bearer ${this.options.secretKey}`,
+                    'Stripe-Version': manifest_1.ALPHAWEB_PRISM_COMPATIBILITY_MANIFEST.stripeApiVersion,
+                    ...(body ? { 'Content-Type': 'application/x-www-form-urlencoded' } : {}),
+                    ...(idempotencyKey ? { 'Idempotency-Key': idempotencyKey } : {}),
+                },
+                body: body?.toString(),
+                signal: controller.signal,
+            });
+            const requestId = response.headers.get('request-id') ?? undefined;
+            const text = await response.text();
+            let payload = null;
+            if (text.length > 0) {
+                try {
+                    payload = JSON.parse(text);
+                }
+                catch {
+                    payload = null;
+                }
+            }
+            if (!response.ok) {
+                const provider = recordOf(recordOf(payload).error);
+                const declinedIntent = recordOf(provider.payment_intent);
+                if (response.status === 402 &&
+                    method === 'POST' &&
+                    path.endsWith('/confirm') &&
+                    stringOf(declinedIntent.id)) {
+                    const lastPaymentError = recordOf(declinedIntent.last_payment_error);
+                    return {
+                        ...declinedIntent,
+                        last_payment_error: {
+                            ...lastPaymentError,
+                            ...(stringOf(lastPaymentError.code) || !stringOf(provider.code)
+                                ? {}
+                                : { code: stringOf(provider.code) }),
+                            ...(stringOf(lastPaymentError.decline_code) || !stringOf(provider.decline_code)
+                                ? {}
+                                : { decline_code: stringOf(provider.decline_code) }),
+                            ...(stringOf(lastPaymentError.advice_code) || !stringOf(provider.advice_code)
+                                ? {}
+                                : { advice_code: stringOf(provider.advice_code) }),
+                        },
+                    };
+                }
+                const providerCode = stringOf(provider.code);
+                throw new error_1.PrismOperationError({
+                    category: response.status === 401 || response.status === 403
+                        ? 'authentication'
+                        : response.status === 429
+                            ? 'rate_limited'
+                            : response.status >= 500
+                                ? 'provider_server'
+                                : 'validation',
+                    ...(providerCode ? { providerCode } : {}),
+                    ...(requestId ? { providerRequestId: requestId } : {}),
+                    retryable: response.status === 429 || response.status >= 500,
+                    outcome: response.status >= 500 ? 'ambiguous' : 'definitely_not_applied',
+                    safeMessage: 'Stripe rejected the payment operation.',
+                });
+            }
+            return payload;
+        }
+        catch (error) {
+            throw (0, error_1.normalizePrismError)(error);
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    async createPayment(input) {
+        this.assertOperation(input);
+        if (input.methodSelection.kind !== 'interactive_dynamic' || input.reusableReference) {
+            throw validationError('Interactive payment input is invalid.', 'PRISM_INTERACTIVE_INPUT');
+        }
+        if (!this.options.publishableKey) {
+            throw configurationError('Interactive Stripe checkout requires a publishable key.', 'PRISM_PUBLISHABLE_KEY_REQUIRED');
+        }
+        try {
+            const response = await this.dependencies.merchantAuthentication.createClientAuthenticationToken({
+                merchantClientSessionId: input.idempotencyKey,
+                testMode: this.options.environment === 'test',
+                payment: {
+                    amount: moneyMessage(input.money),
+                    connectorCustomerId: input.customerReference,
+                    setupFutureUsage: input.metadata.alphaweb_setup_future_usage === 'off_session'
+                        ? proto_1.types.FutureUsage.OFF_SESSION
+                        : proto_1.types.FutureUsage.FUTURE_USAGE_UNSPECIFIED,
+                    captureMethod: input.metadata.alphaweb_capture_method === 'manual'
+                        ? proto_1.types.CaptureMethod.MANUAL
+                        : proto_1.types.CaptureMethod.AUTOMATIC,
+                    paymentMethodConfigurationId: input.methodSelection.paymentMethodConfigurationId,
+                    merchantMetadata: operationMetadata(input),
+                },
+            });
+            const stripe = response.sessionData?.connectorSpecific?.stripe;
+            const clientSecret = readSecret(stripe?.clientSecret);
+            const connectorPaymentId = stringOf(stripe?.connectorPaymentId);
+            if (!clientSecret || !connectorPaymentId) {
+                throw validationError('Prism did not return a usable Stripe client session.', 'PRISM_SESSION');
+            }
+            if (stripe?.livemode !== (this.options.environment === 'live')) {
+                throw configurationError('Stripe PaymentIntent mode does not match runtime mode.', 'PRISM_MODE');
+            }
+            return {
+                connectorPaymentId,
+                status: 'requires_payment_method',
+                money: input.money,
+                clientSecret,
+                publishableKey: this.options.publishableKey,
+            };
+        }
+        catch (error) {
+            throw (0, error_1.normalizePrismError)(error);
+        }
+    }
+    async repeatPayment(input) {
+        this.assertOperation(input);
+        const expectedOwnerId = input.metadata.alphaweb_owner_id;
+        assertIdentifier(expectedOwnerId, 'alphaweb_owner_id');
+        const reference = input.reusableReference;
+        if (input.methodSelection.kind !== 'reusable_reference' || !reference) {
+            throw validationError('Reusable payment input is invalid.', 'PRISM_REUSABLE_INPUT');
+        }
+        if (reference.connector !== 'stripe' ||
+            reference.credentialBindingId !== this.options.credentialBindingId ||
+            reference.providerAccountId !== this.options.providerAccountId ||
+            reference.livemode !== (this.options.environment === 'live')) {
+            throw configurationError('Reusable payment reference ownership does not match runtime.', 'PRISM_REFERENCE_OWNER');
+        }
+        const paymentMethod = parseStripePaymentMethod(await this.stripeRequest('GET', `/payment_methods/${encodeURIComponent(reference.connectorPaymentMethodId)}`));
+        if (paymentMethod.id !== reference.connectorPaymentMethodId ||
+            paymentMethod.customer !== reference.connectorCustomerId ||
+            paymentMethod.livemode !== reference.livemode) {
+            throw configurationError('Saved Stripe payment method ownership validation failed.', 'PRISM_REFERENCE_STALE');
+        }
+        try {
+            const response = await this.dependencies.recurringPayments.charge({
+                merchantChargeId: input.idempotencyKey,
+                connectorRecurringPaymentId: {
+                    connectorMandateId: {
+                        connectorMandateId: reference.connectorMandateId ?? reference.connectorPaymentMethodId,
+                        paymentMethodId: reference.connectorPaymentMethodId,
+                    },
+                },
+                amount: moneyMessage(input.money),
+                merchantOrderId: input.operationId,
+                captureMethod: input.metadata.alphaweb_capture_method === 'manual'
+                    ? proto_1.types.CaptureMethod.MANUAL
+                    : proto_1.types.CaptureMethod.AUTOMATIC,
+                connectorCustomerId: reference.connectorCustomerId,
+                paymentMethodType: reusablePaymentMethodProfile(paymentMethod.type).prismPaymentMethodType,
+                offSession: true,
+                metadata: secret(JSON.stringify(operationMetadata(input))),
+            });
+            const result = buildResult(response, input.money);
+            if (result.status === 'failed' && result.connectorPaymentId) {
+                return this.recoverRepeatPayment(result.connectorPaymentId, input, expectedOwnerId, reference.connectorCustomerId);
+            }
+            return result;
+        }
+        catch (error) {
+            if (error instanceof errors_1.ConnectorError) {
+                const connectorPaymentId = connectorPaymentIdFromError(error);
+                if (connectorPaymentId) {
+                    return this.recoverRepeatPayment(connectorPaymentId, input, expectedOwnerId, reference.connectorCustomerId);
+                }
+                throw reconciliationRequiredError('PRISM_REPEAT_RESULT_UNRESOLVED', 'The reusable payment result must be reconciled before retrying.', error, false);
+            }
+            throw (0, error_1.normalizePrismError)(error);
+        }
+    }
+    async retryPayment(input) {
+        this.assertOperation(input);
+        assertIdentifier(input.connectorPaymentId, 'connectorPaymentId');
+        const expectedOwnerId = input.metadata.alphaweb_owner_id;
+        assertIdentifier(expectedOwnerId, 'alphaweb_owner_id');
+        const reference = input.reusableReference;
+        if (input.methodSelection.kind !== 'reusable_reference' || !reference) {
+            throw validationError('Reusable payment input is invalid.', 'PRISM_REUSABLE_INPUT');
+        }
+        if (reference.connector !== 'stripe' ||
+            reference.credentialBindingId !== this.options.credentialBindingId ||
+            reference.providerAccountId !== this.options.providerAccountId ||
+            reference.livemode !== (this.options.environment === 'live')) {
+            throw configurationError('Reusable payment reference ownership does not match runtime.', 'PRISM_REFERENCE_OWNER');
+        }
+        const expectedMoney = (0, money_1.assertSafeProviderMoney)(input.money);
+        const intent = parseStripePaymentIntent(await this.stripeRequest('GET', `/payment_intents/${encodeURIComponent(input.connectorPaymentId)}`));
+        if (intent.id !== input.connectorPaymentId ||
+            intent.status !== 'requires_payment_method' ||
+            intent.metadata.alphaweb_operation_id !== input.operationId ||
+            intent.metadata.alphaweb_owner_id !== expectedOwnerId ||
+            intent.customer !== reference.connectorCustomerId ||
+            intent.livemode !== reference.livemode ||
+            intent.amount !== expectedMoney.amountMinor ||
+            intent.currency.toLowerCase() !== expectedMoney.currency) {
+            throw configurationError('Existing Stripe PaymentIntent is not eligible for this retry.', 'PRISM_RETRY_OWNERSHIP');
+        }
+        const paymentMethod = parseStripePaymentMethod(await this.stripeRequest('GET', `/payment_methods/${encodeURIComponent(reference.connectorPaymentMethodId)}`));
+        if (paymentMethod.id !== reference.connectorPaymentMethodId ||
+            paymentMethod.customer !== reference.connectorCustomerId ||
+            paymentMethod.livemode !== reference.livemode) {
+            throw configurationError('Existing Stripe PaymentIntent is not eligible for this retry.', 'PRISM_RETRY_OWNERSHIP');
+        }
+        reusablePaymentMethodProfile(paymentMethod.type);
+        const body = new URLSearchParams({
+            payment_method: reference.connectorPaymentMethodId,
+            off_session: 'true',
+        });
+        const retried = parseStripePaymentIntent(await this.stripeRequest('POST', `/payment_intents/${encodeURIComponent(input.connectorPaymentId)}/confirm`, body, input.idempotencyKey));
+        if (retried.id !== input.connectorPaymentId ||
+            retried.metadata.alphaweb_operation_id !== input.operationId ||
+            retried.metadata.alphaweb_owner_id !== expectedOwnerId ||
+            retried.customer !== reference.connectorCustomerId ||
+            retried.livemode !== reference.livemode ||
+            retried.amount !== expectedMoney.amountMinor ||
+            retried.currency.toLowerCase() !== expectedMoney.currency) {
+            throw configurationError('Stripe retry response does not match the payment operation.', 'PRISM_RETRY_RESULT_CONFLICT');
+        }
+        return {
+            connectorPaymentId: retried.id,
+            status: normalizedStripeIntentStatus(retried),
+            money: input.money,
+            ...(retried.failure ? { failure: retried.failure } : {}),
+        };
+    }
+    async retrievePayment(input) {
+        assertIdentifier(input.operationId, 'operationId');
+        if (input.expectedOwnerId || input.expectedConnectorCustomerId) {
+            if (input.expectedOwnerId)
+                assertIdentifier(input.expectedOwnerId, 'expectedOwnerId');
+            if (input.expectedConnectorCustomerId) {
+                assertIdentifier(input.expectedConnectorCustomerId, 'expectedConnectorCustomerId');
+            }
+            const expectedMoney = (0, money_1.assertSafeProviderMoney)(input.money);
+            const intent = parseStripePaymentIntent(await this.stripeRequest('GET', `/payment_intents/${encodeURIComponent(input.connectorPaymentId)}`));
+            if (intent.id !== input.connectorPaymentId ||
+                intent.metadata.alphaweb_operation_id !== input.operationId ||
+                (input.expectedOwnerId &&
+                    intent.metadata.alphaweb_owner_id !== input.expectedOwnerId) ||
+                (input.expectedConnectorCustomerId &&
+                    intent.customer !== input.expectedConnectorCustomerId) ||
+                intent.livemode !== (this.options.environment === 'live') ||
+                intent.amount !== expectedMoney.amountMinor ||
+                intent.currency !== expectedMoney.currency) {
+                throw configurationError('Stripe payment ownership does not match the payment operation.', 'PRISM_PAYMENT_OWNERSHIP');
+            }
+            return {
+                connectorPaymentId: intent.id,
+                status: normalizedStripeIntentStatus(intent),
+                money: {
+                    amountMinor: intent.amount.toString(),
+                    currency: intent.currency,
+                },
+                ...(intent.failure ? { failure: intent.failure } : {}),
+            };
+        }
+        try {
+            const response = await this.dependencies.payments.get({
+                merchantTransactionId: input.operationId,
+                connectorTransactionId: input.connectorPaymentId,
+                amount: moneyMessage(input.money),
+                merchantRequestId: `${input.operationId}:retrieve:v1`,
+            });
+            return buildResult(response, input.money, input.connectorPaymentId);
+        }
+        catch (error) {
+            throw (0, error_1.normalizePrismError)(error);
+        }
+    }
+    async establishReusableReference(input) {
+        assertIdentifier(input.operationId, 'operationId');
+        assertIdentifier(input.expectedOwnerId, 'expectedOwnerId');
+        const expectedMoney = (0, money_1.assertSafeProviderMoney)(input.money);
+        const intent = parseStripePaymentIntent(await this.stripeRequest('GET', `/payment_intents/${encodeURIComponent(input.connectorPaymentId)}`));
+        if (intent.id !== input.connectorPaymentId ||
+            intent.metadata.alphaweb_operation_id !== input.operationId ||
+            intent.metadata.alphaweb_owner_id !== input.expectedOwnerId ||
+            intent.livemode !== (this.options.environment === 'live') ||
+            intent.amount !== expectedMoney.amountMinor ||
+            intent.currency.toLowerCase() !== expectedMoney.currency ||
+            (intent.status !== 'succeeded' && intent.status !== 'requires_capture')) {
+            throw configurationError('Stripe reusable-payment ownership proof does not match checkout.', 'PRISM_REFERENCE_OWNERSHIP');
+        }
+        if (intent.setup_future_usage !== 'off_session' ||
+            !intent.customer ||
+            !intent.payment_method) {
+            throw validationError('Stripe has not established future-use payment ownership.', 'PRISM_REFERENCE_NOT_READY');
+        }
+        const paymentMethod = parseStripePaymentMethod(await this.stripeRequest('GET', `/payment_methods/${encodeURIComponent(intent.payment_method)}`));
+        if (paymentMethod.id !== intent.payment_method ||
+            paymentMethod.customer !== intent.customer ||
+            paymentMethod.livemode !== intent.livemode) {
+            throw configurationError('Stripe reusable payment method ownership does not match checkout.', 'PRISM_REFERENCE_OWNERSHIP');
+        }
+        const profile = STRIPE_REUSABLE_PAYMENT_METHOD_PROFILES[paymentMethod.type];
+        if (!profile?.supportsFutureUsage) {
+            return { status: 'not_supported', reason: 'payment_method_not_reusable' };
+        }
+        const requested = new Set(input.purposes);
+        const capabilities = ['off_session'];
+        if (requested.has('post_purchase') && profile.supportsManualCapture) {
+            capabilities.push('post_purchase', 'manual_capture');
+        }
+        if (requested.has('subscription'))
+            capabilities.push('subscription');
+        if ((requested.has('post_purchase') && !capabilities.includes('post_purchase')) ||
+            (requested.has('subscription') && !capabilities.includes('subscription'))) {
+            if (capabilities.length === 1) {
+                return {
+                    status: 'not_supported',
+                    reason: 'requested_capability_not_supported',
+                };
+            }
+        }
+        return {
+            status: 'established',
+            reference: {
+                version: 1,
+                connector: 'stripe',
+                credentialBindingId: this.options.credentialBindingId,
+                providerAccountId: this.options.providerAccountId,
+                livemode: this.options.environment === 'live',
+                connectorCustomerId: intent.customer,
+                connectorPaymentMethodId: paymentMethod.id,
+                ...(intent.mandate ? { connectorMandateId: intent.mandate } : {}),
+                sourcePaymentIntentId: intent.id,
+                capabilities,
+            },
+            ...(paymentMethod.safeDisplay ? { safeDisplay: paymentMethod.safeDisplay } : {}),
+        };
+    }
+    async findPaymentsByMerchantOperation(input) {
+        assertIdentifier(input.operationId, 'operationId');
+        if (input.expectedOwnerId)
+            assertIdentifier(input.expectedOwnerId, 'expectedOwnerId');
+        if (input.expectedConnectorCustomerId) {
+            assertIdentifier(input.expectedConnectorCustomerId, 'expectedConnectorCustomerId');
+        }
+        const expectedMoney = input.money ? (0, money_1.assertSafeProviderMoney)(input.money) : null;
+        const clauses = [`metadata['alphaweb_operation_id']:'${input.operationId}'`];
+        if (input.createdAfter) {
+            const createdAfter = Date.parse(input.createdAfter);
+            if (!Number.isFinite(createdAfter)) {
+                throw validationError('Payment search boundary is invalid.', 'PRISM_SEARCH_BOUNDARY');
+            }
+            clauses.push(`created>=${Math.floor(createdAfter / 1000)}`);
+        }
+        const matches = [];
+        let page = null;
+        for (let pageCount = 0; pageCount < 100; pageCount += 1) {
+            const search = new URLSearchParams({ query: clauses.join(' AND '), limit: '100' });
+            if (page)
+                search.set('page', page);
+            const payload = recordOf(await this.stripeRequest('GET', `/payment_intents/search?${search}`));
+            const data = Array.isArray(payload.data) ? payload.data : [];
+            for (const entry of data) {
+                const intent = parseStripePaymentIntent(entry);
+                if (intent.metadata.alphaweb_operation_id !== input.operationId ||
+                    (input.expectedOwnerId &&
+                        intent.metadata.alphaweb_owner_id !== input.expectedOwnerId) ||
+                    (input.expectedConnectorCustomerId &&
+                        intent.customer !== input.expectedConnectorCustomerId) ||
+                    intent.livemode !== (this.options.environment === 'live') ||
+                    (expectedMoney && intent.amount !== expectedMoney.amountMinor) ||
+                    (expectedMoney && intent.currency !== expectedMoney.currency)) {
+                    throw validationError('Stripe search returned a payment outside the requested operation ownership.', 'PRISM_SEARCH_OWNERSHIP');
+                }
+                matches.push({
+                    connectorPaymentId: intent.id,
+                    status: normalizedStripeIntentStatus(intent),
+                    money: { amountMinor: intent.amount.toString(), currency: intent.currency },
+                    ...(intent.failure ? { failure: intent.failure } : {}),
+                });
+            }
+            if (payload.has_more !== true)
+                return matches;
+            const nextPage = stringOf(payload.next_page);
+            if (!nextPage || nextPage === page) {
+                throw validationError('Stripe payment search pagination is invalid.', 'PRISM_SEARCH_PAGE');
+            }
+            page = nextPage;
+        }
+        throw validationError('Stripe payment search exceeded the bounded reconciliation window.', 'PRISM_SEARCH_LIMIT');
+    }
+    async capturePayment(input) {
+        assertIdentifier(input.idempotencyKey, 'idempotencyKey');
+        try {
+            const response = await this.dependencies.payments.capture({
+                merchantCaptureId: input.operationId,
+                connectorTransactionId: input.connectorPaymentId,
+                amountToCapture: moneyMessage(input.money),
+                captureMethod: proto_1.types.CaptureMethod.MANUAL,
+                merchantRequestId: input.idempotencyKey,
+            });
+            return buildResult(response, input.money, input.connectorPaymentId);
+        }
+        catch (error) {
+            throw (0, error_1.normalizePrismError)(error);
+        }
+    }
+    async cancelPayment(input) {
+        assertIdentifier(input.idempotencyKey, 'idempotencyKey');
+        try {
+            const response = await this.dependencies.payments.void({
+                merchantVoidId: input.operationId,
+                connectorTransactionId: input.connectorPaymentId,
+                merchantRequestId: input.idempotencyKey,
+            });
+            return buildResult(response, { amountMinor: '0', currency: 'unknown' }, input.connectorPaymentId);
+        }
+        catch (error) {
+            throw (0, error_1.normalizePrismError)(error);
+        }
+    }
+    async refundPayment(input) {
+        assertIdentifier(input.idempotencyKey, 'idempotencyKey');
+        try {
+            const response = await this.dependencies.payments.refund({
+                merchantRefundId: input.refundId,
+                connectorTransactionId: input.connectorPaymentId,
+                refundAmount: moneyMessage(input.money),
+                merchantRequestId: input.idempotencyKey,
+            });
+            return {
+                connectorRefundId: stringOf(response.connectorRefundId),
+                status: response.status === proto_1.types.RefundStatus.REFUND_SUCCESS
+                    ? 'succeeded'
+                    : response.status === proto_1.types.RefundStatus.REFUND_PENDING
+                        ? 'pending'
+                        : response.status === proto_1.types.RefundStatus.REFUND_FAILURE ||
+                            response.status === proto_1.types.RefundStatus.REFUND_TRANSACTION_FAILURE
+                            ? 'failed'
+                            : 'unknown',
+                money: input.money,
+            };
+        }
+        catch (error) {
+            throw (0, error_1.normalizePrismError)(error);
+        }
+    }
+    async retrieveRefund(input) {
+        if (input.operationId)
+            assertIdentifier(input.operationId, 'operationId');
+        const expected = input.money ? (0, money_1.assertSafeProviderMoney)(input.money) : null;
+        const refund = parseStripeRefund(await this.stripeRequest('GET', `/refunds/${encodeURIComponent(input.connectorRefundId)}`));
+        if (refund.id !== input.connectorRefundId ||
+            refund.paymentIntentId !== input.connectorPaymentId ||
+            (expected && refund.amount !== expected.amountMinor) ||
+            (expected && refund.currency !== expected.currency) ||
+            (refund.metadata.alphaweb_operation_id &&
+                input.operationId &&
+                refund.metadata.alphaweb_operation_id !== input.operationId)) {
+            throw configurationError('Stripe refund ownership does not match the payment operation.', 'PRISM_REFUND_OWNERSHIP');
+        }
+        return {
+            connectorRefundId: refund.id,
+            connectorPaymentId: refund.paymentIntentId,
+            status: normalizedRefundStatus(refund.status),
+            money: {
+                amountMinor: refund.amount.toString(),
+                currency: refund.currency,
+            },
+        };
+    }
+    async findRefundsByMerchantOperation(input) {
+        assertIdentifier(input.operationId, 'operationId');
+        const expected = (0, money_1.assertSafeProviderMoney)(input.money);
+        const matches = [];
+        let startingAfter = null;
+        for (let pageCount = 0; pageCount < 100; pageCount += 1) {
+            const query = new URLSearchParams({
+                payment_intent: input.connectorPaymentId,
+                limit: '100',
+            });
+            if (startingAfter)
+                query.set('starting_after', startingAfter);
+            const payload = recordOf(await this.stripeRequest('GET', `/refunds?${query.toString()}`));
+            const data = Array.isArray(payload.data) ? payload.data : [];
+            for (const entry of data) {
+                const refund = parseStripeRefund(entry);
+                if (refund.paymentIntentId !== input.connectorPaymentId) {
+                    throw validationError('Stripe refund list returned an object outside the requested payment ownership.', 'PRISM_REFUND_SEARCH_OWNERSHIP');
+                }
+                const ownsOperation = refund.metadata.order_id === input.operationId &&
+                    refund.metadata.is_refund_id_as_reference === 'true';
+                if (!ownsOperation)
+                    continue;
+                if (refund.amount !== expected.amountMinor || refund.currency !== expected.currency) {
+                    throw validationError('Stripe refund search returned conflicting operation money.', 'PRISM_REFUND_SEARCH_OWNERSHIP');
+                }
+                matches.push({
+                    connectorRefundId: refund.id,
+                    connectorPaymentId: refund.paymentIntentId,
+                    status: normalizedRefundStatus(refund.status),
+                    money: {
+                        amountMinor: refund.amount.toString(),
+                        currency: refund.currency,
+                    },
+                });
+            }
+            if (payload.has_more !== true)
+                return matches;
+            const last = data.length > 0 ? parseStripeRefund(data[data.length - 1]) : null;
+            if (!last || last.id === startingAfter) {
+                throw validationError('Stripe refund pagination is invalid.', 'PRISM_REFUND_SEARCH_PAGE');
+            }
+            startingAfter = last.id;
+        }
+        throw validationError('Stripe refund search exceeded the bounded reconciliation window.', 'PRISM_REFUND_SEARCH_LIMIT');
+    }
+    async retrieveDispute(input) {
+        const dispute = parseStripeDispute(await this.stripeRequest('GET', `/disputes/${encodeURIComponent(input.connectorDisputeId)}`));
+        if (dispute.id !== input.connectorDisputeId ||
+            dispute.livemode !== (this.options.environment === 'live')) {
+            throw configurationError('Stripe dispute ownership does not match the credential binding.', 'PRISM_DISPUTE_OWNERSHIP');
+        }
+        return {
+            connectorDisputeId: dispute.id,
+            connectorChargeId: dispute.chargeId,
+            connectorPaymentId: dispute.paymentIntentId,
+            status: normalizedDisputeStatus(dispute.status),
+            money: {
+                amountMinor: dispute.amount.toString(),
+                currency: dispute.currency,
+            },
+            ...(dispute.reason ? { reason: dispute.reason } : {}),
+            ...(dispute.evidenceDueBy !== null
+                ? { evidenceDueAt: new Date(dispute.evidenceDueBy * 1000).toISOString() }
+                : {}),
+            providerCreatedAt: new Date(dispute.created * 1000).toISOString(),
+            safeData: {
+                ...(dispute.isChargeRefundable !== null
+                    ? { is_charge_refundable: dispute.isChargeRefundable }
+                    : {}),
+            },
+        };
+    }
+    async parseWebhookEvent(input) {
+        if (input.rawBody.length === 0 || input.signingSecretBindings.length === 0) {
+            throw validationError('Stripe webhook verification input is incomplete.', 'PRISM_WEBHOOK_INPUT');
+        }
+        assertUniqueBindings(input.signingSecretBindings);
+        const matches = [];
+        let nativeProcessingFailures = 0;
+        for (const binding of input.signingSecretBindings) {
+            try {
+                const response = await this.dependencies.events.handleEvent({
+                    merchantEventId: 'alphaweb-webhook-verification',
+                    requestDetails: {
+                        method: proto_1.types.HttpMethod.HTTP_METHOD_POST,
+                        uri: '/webhooks/prism/stripe',
+                        headers: { 'stripe-signature': input.signatureHeader },
+                        body: input.rawBody,
+                    },
+                    webhookSecrets: { secret: binding.secret },
+                });
+                if (response.sourceVerified)
+                    matches.push(binding);
+            }
+            catch {
+                nativeProcessingFailures += 1;
+            }
+        }
+        if (matches.length === 0 && nativeProcessingFailures > 0) {
+            throw new error_1.PrismOperationError({
+                category: 'configuration',
+                providerCode: 'PRISM_WEBHOOK_NATIVE_PROCESSING',
+                retryable: true,
+                outcome: 'definitely_not_applied',
+                safeMessage: 'The pinned native Stripe webhook parser could not process this event.',
+            });
+        }
+        if (matches.length !== 1) {
+            throw validationError(matches.length === 0
+                ? 'Stripe webhook signature verification failed.'
+                : 'Stripe webhook signature matched more than one runtime binding.', matches.length === 0 ? 'PRISM_WEBHOOK_SIGNATURE' : 'PRISM_WEBHOOK_BINDING_AMBIGUOUS');
+        }
+        return parseWebhookDocument(input, matches[0]);
+    }
+    async createWebhookEndpoint(input) {
+        assertIdentifier(input.idempotencyKey, 'idempotencyKey');
+        const body = new URLSearchParams({
+            url: input.callbackUrl,
+            api_version: manifest_1.ALPHAWEB_PRISM_COMPATIBILITY_MANIFEST.stripeApiVersion,
+        });
+        for (const event of manifest_1.ALPHAWEB_STRIPE_WEBHOOK_EVENTS)
+            body.append('enabled_events[]', event);
+        for (const [key, value] of Object.entries(input.metadata)) {
+            if (/^[A-Za-z0-9_]{1,40}$/.test(key) && value.length <= 500) {
+                body.append(`metadata[${key}]`, value);
+            }
+        }
+        const payload = recordOf(await this.stripeRequest('POST', '/webhook_endpoints', body, input.idempotencyKey));
+        const endpoint = this.normalizeEndpoint(payload);
+        const signingSecret = stringOf(payload.secret);
+        if (!signingSecret) {
+            throw validationError('Stripe did not return a webhook signing secret.', 'PRISM_WEBHOOK_SECRET');
+        }
+        return { ...endpoint, signingSecret };
+    }
+    async updateWebhookEndpoint(input) {
+        assertIdentifier(input.idempotencyKey, 'idempotencyKey');
+        const body = new URLSearchParams();
+        if (input.callbackUrl)
+            body.set('url', input.callbackUrl);
+        if (input.enabled !== undefined)
+            body.set('disabled', input.enabled ? 'false' : 'true');
+        for (const event of manifest_1.ALPHAWEB_STRIPE_WEBHOOK_EVENTS)
+            body.append('enabled_events[]', event);
+        return this.normalizeEndpoint(await this.stripeRequest('POST', `/webhook_endpoints/${encodeURIComponent(input.endpointId)}`, body, input.idempotencyKey));
+    }
+    async deleteWebhookEndpoint(input) {
+        assertIdentifier(input.idempotencyKey, 'idempotencyKey');
+        await this.stripeRequest('DELETE', `/webhook_endpoints/${encodeURIComponent(input.endpointId)}`, undefined, input.idempotencyKey);
+    }
+    async retrieveWebhookEndpoint(input) {
+        return this.normalizeEndpoint(await this.stripeRequest('GET', `/webhook_endpoints/${encodeURIComponent(input.endpointId)}`));
+    }
+    normalizeEndpoint(value) {
+        const data = recordOf(value);
+        const endpointId = stringOf(data.id);
+        const url = stringOf(data.url);
+        const apiVersion = stringOf(data.api_version);
+        if (!endpointId || !url || !apiVersion || !Array.isArray(data.enabled_events)) {
+            throw validationError('Stripe returned an invalid webhook endpoint shape.', 'PRISM_WEBHOOK_ENDPOINT');
+        }
+        return {
+            endpointId,
+            url,
+            enabled: data.status === 'enabled',
+            apiVersion,
+            events: data.enabled_events.filter((event) => typeof event === 'string'),
+            metadata: Object.fromEntries(Object.entries(recordOf(data.metadata)).filter((entry) => typeof entry[1] === 'string')),
+        };
+    }
+}
+exports.PrismStripeConnector = PrismStripeConnector;
+/**
+ * Verifies that one Stripe key pair resolves to the expected merchant account
+ * and that the pinned native Prism runtime can be constructed for it. Consumer
+ * applications receive only the verified account identity and mode.
+ */
+async function verifyPrismStripeRuntimeCredential(input, dependencies) {
+    const test = input.environment === 'test';
+    if (!input.secretKey.startsWith(test ? 'sk_test_' : 'sk_live_')) {
+        throw configurationError('Stripe secret key mode does not match Prism environment.', 'PRISM_KEY_MODE');
+    }
+    if (input.publishableKey &&
+        !input.publishableKey.startsWith(test ? 'pk_test_' : 'pk_live_')) {
+        throw configurationError('Stripe publishable key mode does not match Prism environment.', 'PRISM_PUBLISHABLE_KEY_MODE');
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), input.requestTimeoutMs ?? 15_000);
+    try {
+        const request = dependencies?.fetch ?? fetch;
+        const response = await request(`${STRIPE_API_BASE}/account`, {
+            method: 'GET',
+            headers: {
+                Authorization: `Bearer ${input.secretKey}`,
+                'Stripe-Version': manifest_1.ALPHAWEB_PRISM_COMPATIBILITY_MANIFEST.stripeApiVersion,
+            },
+            signal: controller.signal,
+        });
+        const requestId = response.headers.get('request-id') ?? undefined;
+        const text = await response.text();
+        let payload = null;
+        if (text.length > 0) {
+            try {
+                payload = JSON.parse(text);
+            }
+            catch {
+                payload = null;
+            }
+        }
+        if (!response.ok) {
+            throw new error_1.PrismOperationError({
+                category: response.status === 401 || response.status === 403
+                    ? 'authentication'
+                    : response.status === 429
+                        ? 'rate_limited'
+                        : response.status >= 500
+                            ? 'provider_server'
+                            : 'validation',
+                ...(requestId ? { providerRequestId: requestId } : {}),
+                retryable: response.status === 429 || response.status >= 500,
+                outcome: response.status >= 500 ? 'ambiguous' : 'definitely_not_applied',
+                safeMessage: 'Stripe runtime verification failed.',
+            });
+        }
+        const providerAccountId = stringOf(recordOf(payload).id);
+        if (!providerAccountId?.startsWith('acct_')) {
+            throw validationError('Stripe returned an invalid account identity.', 'PRISM_ACCOUNT_IDENTITY');
+        }
+        if (input.expectedProviderAccountId &&
+            input.expectedProviderAccountId !== providerAccountId) {
+            throw configurationError('Stripe account does not match the runtime credential binding.', 'PRISM_ACCOUNT_MISMATCH');
+        }
+        new PrismStripeConnector({
+            environment: input.environment,
+            credentialBindingId: 'binding_runtime_verification',
+            providerAccountId,
+            secretKey: input.secretKey,
+            ...(input.publishableKey ? { publishableKey: input.publishableKey } : {}),
+            ...(input.nativeLibraryPath
+                ? { nativeLibraryPath: input.nativeLibraryPath }
+                : {}),
+            ...(input.requestTimeoutMs
+                ? { requestTimeoutMs: input.requestTimeoutMs }
+                : {}),
+        }, dependencies);
+        return { providerAccountId, livemode: !test };
+    }
+    catch (error) {
+        throw (0, error_1.normalizePrismError)(error);
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+//# sourceMappingURL=stripe-connector.js.map