@proxy-checkout/stripe-server-js 0.0.0-pr-76.17.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Linus Labs, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,58 @@
+# @proxy-checkout/stripe-server-js
+
+Server-side Stripe adapter for Proxy Checkout. It owns the Stripe-specific integration protocol so merchant backends never hand-roll it:
+
+- **`requiredMetadata(proxySession)`** — the `proxy_session_id` metadata Proxy needs on the Checkout Session, Subscription, and PaymentIntent.
+- **`assertCheckoutSessionBelongsToProxy` / `assertSubscriptionBelongsToProxy` / `assertPaymentIntentBelongsToProxy`** — provider-object ownership checks.
+- **`openCheckout(...)`** — records payer-opened, validates the typed cart, supplies required metadata, records the Proxy provider binding, and returns the client secret. The merchant only supplies an app-specific Stripe-session builder.
+- **`syncCheckoutCart(...)`** — validates the stored Proxy provider binding, then updates the Proxy cart and the Stripe Checkout `line_items` in the safest order with deterministic rollback/reconciliation (`ProxyStripeCartSyncError`).
+
+PSP-agnostic primitives (sessions, subscriptions, webhooks, lifecycle) live in [`@proxy-checkout/server-js`](https://www.npmjs.com/package/@proxy-checkout/server-js). This package is an additive adapter on top and is dependency-free: you inject your own `Stripe` instance and your `@proxy-checkout/server-js` client.
+
+## Install
+
+```bash
+npm install --save-exact @proxy-checkout/stripe-server-js @proxy-checkout/server-js stripe
+```
+
+## Usage
+
+```ts
+import Stripe from "stripe";
+import { createProxyCheckoutServerClient } from "@proxy-checkout/server-js";
+import { openCheckout, syncCheckoutCart } from "@proxy-checkout/stripe-server-js";
+
+const proxy = createProxyCheckoutServerClient({ apiKey: process.env.PROXY_SECRET_KEY! });
+const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!, { apiVersion: "2025-12-15.clover" });
+
+// Create the merchant-owned Stripe checkout, correctly linked to the Proxy session.
+const checkout = await openCheckout({
+  proxy,
+  stripe,
+  proxySessionId,
+  cartSchema, // a zod-style schema, or any (value) => Cart validator
+  validateCart: ({ cart }) => buildMerchantOffer(cart),
+  createCheckoutSession: ({ stripe, cart, metadata }) =>
+    stripe.checkout.sessions.create({
+      ...buildMerchantStripeParams(cart),
+      ui_mode: "embedded",
+      metadata: { ...metadata.checkoutSession },
+      subscription_data: { metadata: metadata.subscriptionData.metadata },
+    }),
+});
+// checkout.clientSecret -> render Stripe Elements
+
+// Cart edits go through the binding-validated sync helper.
+await syncCheckoutCart({
+  proxy,
+  stripe,
+  proxySessionId,
+  checkoutSessionId: checkout.checkoutSession.id,
+  cartSchema,
+  input: { interval: "year" },
+  buildNextCart: ({ currentCart, input }) => buildMerchantCart(currentCart, input),
+  buildStripeLineItems: (cart) => cart.lineItems,
+});
+```
+
+See the [agentic delegated-checkout guide](https://github.com/linuslabs/proxy/blob/main/docs/integration/agentic-delegated-checkout-guide.md) for the full four-route integration recipe.

package/dist/errors.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Adapter-specific error raised when a Stripe/Proxy cart synchronization cannot
+ * complete cleanly. The `reconciled` flag states whether the Proxy cart was
+ * restored to its prior state, so callers can react deterministically.
+ */
+export type ProxyStripeCartSyncCode = "reconciliation_failed" | "stripe_update_failed";
+export declare class ProxyStripeCartSyncError extends Error {
+    readonly name = "ProxyStripeCartSyncError";
+    readonly code: ProxyStripeCartSyncCode;
+    /** True when the Proxy cart was rolled back to its prior state after the failure. */
+    readonly reconciled: boolean;
+    readonly cause: unknown;
+    readonly rollbackCause: unknown;
+    constructor(message: string, details: {
+        code: ProxyStripeCartSyncCode;
+        reconciled: boolean;
+        cause: unknown;
+        rollbackCause?: unknown;
+    });
+}

package/dist/errors.js

@@ -0,0 +1,15 @@
+export class ProxyStripeCartSyncError extends Error {
+    name = "ProxyStripeCartSyncError";
+    code;
+    /** True when the Proxy cart was rolled back to its prior state after the failure. */
+    reconciled;
+    cause;
+    rollbackCause;
+    constructor(message, details) {
+        super(message);
+        this.code = details.code;
+        this.reconciled = details.reconciled;
+        this.cause = details.cause;
+        this.rollbackCause = details.rollbackCause;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { type ProxyStripeCartSyncCode, ProxyStripeCartSyncError, } from "./errors.js";
+export { assertCheckoutSessionBelongsToProxy, assertPaymentIntentBelongsToProxy, assertSubscriptionBelongsToProxy, PROXY_SESSION_METADATA_KEY, type ProxySessionMetadata, type ProxyStripeRequiredMetadata, requiredMetadata, } from "./metadata.js";
+export { type OpenCheckoutOptions, type OpenCheckoutResult, openCheckout, } from "./open-checkout.js";
+export { type SyncCheckoutCartOptions, type SyncCheckoutCartResult, type SyncedCart, syncCheckoutCart, } from "./sync-checkout-cart.js";
+export type { StripeCheckoutSessionLike, StripeCheckoutSessionsApiLike, StripeCheckoutSessionUpdateParams, StripeClientLike, StripeMetadata, StripePaymentIntentLike, StripeSubscriptionLike, } from "./types.js";
+export { proxyCheckoutStripeServerSdkName, proxyCheckoutStripeServerSdkVersion, } from "./version.js";

package/dist/index.js

@@ -0,0 +1,5 @@
+export { ProxyStripeCartSyncError, } from "./errors.js";
+export { assertCheckoutSessionBelongsToProxy, assertPaymentIntentBelongsToProxy, assertSubscriptionBelongsToProxy, PROXY_SESSION_METADATA_KEY, requiredMetadata, } from "./metadata.js";
+export { openCheckout, } from "./open-checkout.js";
+export { syncCheckoutCart, } from "./sync-checkout-cart.js";
+export { proxyCheckoutStripeServerSdkName, proxyCheckoutStripeServerSdkVersion, } from "./version.js";

package/dist/metadata.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Required Stripe metadata placement + provider-object ownership assertions.
+ *
+ * Proxy correlates Stripe objects to a session solely through
+ * `metadata.proxy_session_id`. This module centralizes that placement so
+ * customers never have to remember which Stripe objects need the key, and
+ * provides assertions that a Stripe object actually belongs to a Proxy session.
+ */
+import type { StripeCheckoutSessionLike, StripePaymentIntentLike, StripeSubscriptionLike } from "./types.js";
+/** The single metadata key Proxy reads to correlate a Stripe object to a session. */
+export declare const PROXY_SESSION_METADATA_KEY = "proxy_session_id";
+export type ProxySessionMetadata = Readonly<Record<"proxy_session_id", string>>;
+/**
+ * The metadata each Stripe object must carry, ready to spread into Stripe params.
+ *
+ * - `checkoutSession` → `metadata` on `checkout.sessions.create`
+ * - `subscriptionData` → `subscription_data` for subscription-mode Checkout
+ * - `paymentIntentData` → `payment_intent_data` for payment-mode Checkout / PaymentIntents
+ */
+export interface ProxyStripeRequiredMetadata {
+    readonly checkoutSession: ProxySessionMetadata;
+    readonly paymentIntent: ProxySessionMetadata;
+    readonly paymentIntentData: {
+        readonly metadata: ProxySessionMetadata;
+    };
+    readonly subscription: ProxySessionMetadata;
+    readonly subscriptionData: {
+        readonly metadata: ProxySessionMetadata;
+    };
+}
+/** Build the required Stripe metadata placements for a Proxy session. */
+export declare function requiredMetadata(proxySession: {
+    id: string;
+}): ProxyStripeRequiredMetadata;
+/** Assert a Stripe Checkout Session carries the expected `proxy_session_id` metadata. */
+export declare function assertCheckoutSessionBelongsToProxy(checkoutSession: Pick<StripeCheckoutSessionLike, "metadata">, proxySessionId: string): void;
+/** Assert a Stripe Subscription carries the expected `proxy_session_id` metadata. */
+export declare function assertSubscriptionBelongsToProxy(subscription: Pick<StripeSubscriptionLike, "metadata">, proxySessionId: string): void;
+/** Assert a Stripe PaymentIntent carries the expected `proxy_session_id` metadata. */
+export declare function assertPaymentIntentBelongsToProxy(paymentIntent: Pick<StripePaymentIntentLike, "metadata">, proxySessionId: string): void;

package/dist/metadata.js

@@ -0,0 +1,40 @@
+/**
+ * Required Stripe metadata placement + provider-object ownership assertions.
+ *
+ * Proxy correlates Stripe objects to a session solely through
+ * `metadata.proxy_session_id`. This module centralizes that placement so
+ * customers never have to remember which Stripe objects need the key, and
+ * provides assertions that a Stripe object actually belongs to a Proxy session.
+ */
+import { ProxyCheckoutValidationError } from "@proxy-checkout/server-js";
+/** The single metadata key Proxy reads to correlate a Stripe object to a session. */
+export const PROXY_SESSION_METADATA_KEY = "proxy_session_id";
+/** Build the required Stripe metadata placements for a Proxy session. */
+export function requiredMetadata(proxySession) {
+    const metadata = { proxy_session_id: proxySession.id };
+    return {
+        checkoutSession: metadata,
+        paymentIntent: metadata,
+        paymentIntentData: { metadata },
+        subscription: metadata,
+        subscriptionData: { metadata },
+    };
+}
+/** Assert a Stripe Checkout Session carries the expected `proxy_session_id` metadata. */
+export function assertCheckoutSessionBelongsToProxy(checkoutSession, proxySessionId) {
+    assertProxyMetadata(checkoutSession.metadata, proxySessionId, "Stripe checkout session");
+}
+/** Assert a Stripe Subscription carries the expected `proxy_session_id` metadata. */
+export function assertSubscriptionBelongsToProxy(subscription, proxySessionId) {
+    assertProxyMetadata(subscription.metadata, proxySessionId, "Stripe subscription");
+}
+/** Assert a Stripe PaymentIntent carries the expected `proxy_session_id` metadata. */
+export function assertPaymentIntentBelongsToProxy(paymentIntent, proxySessionId) {
+    assertProxyMetadata(paymentIntent.metadata, proxySessionId, "Stripe payment intent");
+}
+function assertProxyMetadata(metadata, proxySessionId, objectLabel) {
+    const value = metadata?.[PROXY_SESSION_METADATA_KEY];
+    if (value !== proxySessionId) {
+        throw new ProxyCheckoutValidationError(`${objectLabel} metadata.${PROXY_SESSION_METADATA_KEY} (${value ?? "missing"}) does not match Proxy session ${proxySessionId}.`, { code: "provider_binding_mismatch", field: `metadata.${PROXY_SESSION_METADATA_KEY}` });
+    }
+}

package/dist/open-checkout.d.ts

@@ -0,0 +1,48 @@
+/**
+ * `openCheckout` — the payer-opened + provider-object creation workflow.
+ *
+ * It performs the Proxy protocol steps (record payer-opened, validate the cart,
+ * supply required metadata, record the provider binding) and delegates only the
+ * app-specific Stripe object creation to the merchant callback. This makes it
+ * hard to create a Stripe checkout that is not correctly linked to a session.
+ */
+import type { PayerOpenedResult, ProxyCartValidator, ProxyCheckoutServerClient } from "@proxy-checkout/server-js";
+import type { ProxyStripeRequiredMetadata } from "./metadata.js";
+import type { StripeCheckoutSessionLike } from "./types.js";
+export interface OpenCheckoutOptions<TStripe, TCart, TOffer, TSession> {
+    /** Optional schema validating the session cart snapshot into a typed cart. */
+    readonly cartSchema?: ProxyCartValidator<TCart>;
+    /** Builds the Stripe checkout object. Must place `metadata.checkoutSession` (and subscription/payment-intent metadata) on the created object. */
+    readonly createCheckoutSession: (input: {
+        cart: TCart;
+        metadata: ProxyStripeRequiredMetadata;
+        offer: TOffer;
+        proxySession: PayerOpenedResult;
+        stripe: TStripe;
+    }) => Promise<TSession> | TSession;
+    /** Optional extractor used to assert the cart buyer reference matches the session. */
+    readonly getCartBuyerReference?: (cart: TCart) => string | null | undefined;
+    /** A Proxy server SDK client. */
+    readonly proxy: ProxyCheckoutServerClient;
+    readonly proxySessionId: string;
+    /** Provider identifier recorded with the binding. Defaults to "stripe". */
+    readonly psp?: string;
+    readonly requestId?: string;
+    /** The merchant's Stripe instance, forwarded to `createCheckoutSession`. */
+    readonly stripe: TStripe;
+    /** Optional merchant cart validation that derives an app-specific offer. */
+    readonly validateCart?: (input: {
+        cart: TCart;
+        session: PayerOpenedResult;
+    }) => Promise<TOffer> | TOffer;
+}
+export interface OpenCheckoutResult<TCart, TOffer, TSession> {
+    readonly binding: Awaited<ReturnType<ProxyCheckoutServerClient["sessions"]["recordProviderBinding"]>>;
+    readonly cart: TCart;
+    readonly checkoutSession: TSession;
+    readonly clientSecret: string | null;
+    readonly offer: TOffer;
+    readonly proxySession: PayerOpenedResult;
+    readonly proxySessionId: string;
+}
+export declare function openCheckout<TStripe, TCart = unknown, TOffer = undefined, TSession extends StripeCheckoutSessionLike = StripeCheckoutSessionLike>(options: OpenCheckoutOptions<TStripe, TCart, TOffer, TSession>): Promise<OpenCheckoutResult<TCart, TOffer, TSession>>;

package/dist/open-checkout.js

@@ -0,0 +1,48 @@
+/**
+ * `openCheckout` — the payer-opened + provider-object creation workflow.
+ *
+ * It performs the Proxy protocol steps (record payer-opened, validate the cart,
+ * supply required metadata, record the provider binding) and delegates only the
+ * app-specific Stripe object creation to the merchant callback. This makes it
+ * hard to create a Stripe checkout that is not correctly linked to a session.
+ */
+import { assertCheckoutSessionBelongsToProxy, requiredMetadata } from "./metadata.js";
+export async function openCheckout(options) {
+    const psp = options.psp ?? "stripe";
+    const proxySession = await options.proxy.sessions.payerOpened(options.proxySessionId, {
+        requestId: options.requestId,
+    });
+    // Parse the cart (and run the buyer-reference check) whenever a schema OR a
+    // buyer-reference extractor is provided, so the consistency check is never
+    // silently skipped just because no custom schema was passed.
+    const cart = options.cartSchema || options.getCartBuyerReference
+        ? options.proxy.sessions.parseCart(proxySession, options.cartSchema ?? ((value) => value), { getBuyerReference: options.getCartBuyerReference })
+        : proxySession.cartSnapshot;
+    const offer = options.validateCart
+        ? await options.validateCart({ cart, session: proxySession })
+        : undefined;
+    const metadata = requiredMetadata(proxySession);
+    const checkoutSession = await options.createCheckoutSession({
+        cart,
+        metadata,
+        offer,
+        proxySession,
+        stripe: options.stripe,
+    });
+    // Fail closed if the merchant forgot to place proxy_session_id metadata.
+    assertCheckoutSessionBelongsToProxy(checkoutSession, proxySession.id);
+    const binding = await options.proxy.sessions.recordProviderBinding(proxySession.id, {
+        providerCheckoutSessionId: checkoutSession.id,
+        psp,
+        requestId: options.requestId,
+    });
+    return {
+        binding,
+        cart,
+        checkoutSession,
+        clientSecret: checkoutSession.client_secret ?? null,
+        offer,
+        proxySession,
+        proxySessionId: proxySession.id,
+    };
+}

package/dist/sync-checkout-cart.d.ts

@@ -0,0 +1,45 @@
+/**
+ * `syncCheckoutCart` — coordinated Proxy + Stripe cart update.
+ *
+ * Validates ownership against the first-class Proxy provider binding (not just
+ * Stripe metadata), then updates the Proxy cart and the Stripe checkout in the
+ * safest order with deterministic rollback/reconciliation on failure.
+ */
+import { type JsonObject, type MerchantProxySession, type ProxyCartValidator, type ProxyCheckoutServerClient } from "@proxy-checkout/server-js";
+import type { StripeCheckoutSessionLike, StripeClientLike } from "./types.js";
+/** The next cart, expressed both as Proxy state and the typed merchant cart. */
+export interface SyncedCart<TCart> {
+    readonly amountMinor: number;
+    readonly cart: TCart;
+    readonly cartSnapshot: JsonObject;
+    readonly currency: string;
+}
+export interface SyncCheckoutCartOptions<TStripe extends StripeClientLike, TCart, TInput> {
+    /** Compute the next cart from current state and the merchant input. */
+    readonly buildNextCart: (input: {
+        currentCart: TCart;
+        currentSession: MerchantProxySession;
+        input: TInput;
+    }) => Promise<SyncedCart<TCart>> | SyncedCart<TCart>;
+    /** Derive the Stripe `line_items` update from the next typed cart. */
+    readonly buildStripeLineItems: (cart: TCart) => unknown;
+    /** Optional schema validating the current cart snapshot into a typed cart. */
+    readonly cartSchema?: ProxyCartValidator<TCart>;
+    readonly checkoutSessionId: string;
+    /** Merchant-supplied change request (e.g. new interval/quantity). */
+    readonly input: TInput;
+    readonly proxy: ProxyCheckoutServerClient;
+    readonly proxySessionId: string;
+    /** Provider identifier the session must be bound under. Defaults to "stripe". */
+    readonly psp?: string;
+    readonly requestId?: string;
+    readonly stripe: TStripe;
+}
+export interface SyncCheckoutCartResult<TCart> {
+    readonly amountMinor: number;
+    readonly cart: TCart;
+    readonly cartSnapshot: JsonObject;
+    readonly checkoutSession: StripeCheckoutSessionLike;
+    readonly currency: string;
+}
+export declare function syncCheckoutCart<TStripe extends StripeClientLike, TCart, TInput>(options: SyncCheckoutCartOptions<TStripe, TCart, TInput>): Promise<SyncCheckoutCartResult<TCart>>;

package/dist/sync-checkout-cart.js

@@ -0,0 +1,74 @@
+/**
+ * `syncCheckoutCart` — coordinated Proxy + Stripe cart update.
+ *
+ * Validates ownership against the first-class Proxy provider binding (not just
+ * Stripe metadata), then updates the Proxy cart and the Stripe checkout in the
+ * safest order with deterministic rollback/reconciliation on failure.
+ */
+import { ProxyCheckoutValidationError, } from "@proxy-checkout/server-js";
+import { ProxyStripeCartSyncError } from "./errors.js";
+import { assertCheckoutSessionBelongsToProxy } from "./metadata.js";
+export async function syncCheckoutCart(options) {
+    const psp = options.psp ?? "stripe";
+    const session = await options.proxy.sessions.retrieve(options.proxySessionId, {
+        requestId: options.requestId,
+    });
+    // Ownership: validate against the stored binding first, then defensively
+    // against the Stripe object's own metadata.
+    assertSessionBoundTo(session, options.checkoutSessionId, psp);
+    const stripeSession = await options.stripe.checkout.sessions.retrieve(options.checkoutSessionId);
+    assertCheckoutSessionBelongsToProxy(stripeSession, options.proxySessionId);
+    const currentCart = options.cartSchema
+        ? options.proxy.sessions.parseCart(session, options.cartSchema)
+        : session.cartSnapshot;
+    const next = await options.buildNextCart({
+        currentCart,
+        currentSession: session,
+        input: options.input,
+    });
+    const prior = {
+        amountMinor: session.amountMinor,
+        cartSnapshot: session.cartSnapshot,
+        currency: session.currency,
+    };
+    // Update Proxy first; the API rejects a non-editable session before Stripe is touched.
+    await options.proxy.sessions.cart.set(options.proxySessionId, {
+        amountMinor: next.amountMinor,
+        cartSnapshot: next.cartSnapshot,
+        currency: next.currency,
+        requestId: options.requestId,
+    });
+    let updatedCheckout;
+    try {
+        updatedCheckout = await options.stripe.checkout.sessions.update(options.checkoutSessionId, {
+            line_items: options.buildStripeLineItems(next.cart),
+        });
+    }
+    catch (cause) {
+        try {
+            await options.proxy.sessions.cart.set(options.proxySessionId, {
+                amountMinor: prior.amountMinor,
+                cartSnapshot: prior.cartSnapshot,
+                currency: prior.currency,
+                requestId: options.requestId,
+            });
+        }
+        catch (rollbackCause) {
+            throw new ProxyStripeCartSyncError("Stripe checkout update failed and the Proxy cart rollback failed; carts may be out of sync.", { cause, code: "reconciliation_failed", reconciled: false, rollbackCause });
+        }
+        throw new ProxyStripeCartSyncError("Stripe checkout update failed; the Proxy cart was rolled back to its prior state.", { cause, code: "stripe_update_failed", reconciled: true });
+    }
+    return {
+        amountMinor: next.amountMinor,
+        cart: next.cart,
+        cartSnapshot: next.cartSnapshot,
+        checkoutSession: updatedCheckout,
+        currency: next.currency,
+    };
+}
+function assertSessionBoundTo(session, checkoutSessionId, psp) {
+    if (session.providerCheckoutSessionId !== checkoutSessionId ||
+        session.providerCheckoutSessionPsp !== psp) {
+        throw new ProxyCheckoutValidationError(`Proxy session ${session.id} is not bound to provider checkout session ${checkoutSessionId}.`, { code: "provider_binding_mismatch", field: "provider_checkout_session_id" });
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Minimal structural Stripe types.
+ *
+ * The adapter is dependency-free: merchants inject their own `Stripe` instance
+ * and objects, which are structurally compatible with these narrow interfaces.
+ * This avoids a runtime/build dependency on the `stripe` package while keeping
+ * the bits the adapter actually touches type-safe.
+ */
+export type StripeMetadata = Record<string, string | null> | null | undefined;
+export interface StripeCheckoutSessionLike {
+    readonly client_secret?: string | null;
+    readonly id: string;
+    readonly metadata?: StripeMetadata;
+}
+export interface StripeSubscriptionLike {
+    readonly id: string;
+    readonly metadata?: StripeMetadata;
+}
+export interface StripePaymentIntentLike {
+    readonly id: string;
+    readonly metadata?: StripeMetadata;
+}
+export interface StripeCheckoutSessionUpdateParams {
+    readonly line_items?: unknown;
+    readonly metadata?: Record<string, string>;
+}
+export interface StripeCheckoutSessionsApiLike {
+    retrieve(id: string, params?: unknown, options?: unknown): Promise<StripeCheckoutSessionLike>;
+    update(id: string, params: StripeCheckoutSessionUpdateParams, options?: unknown): Promise<StripeCheckoutSessionLike>;
+}
+export interface StripeClientLike {
+    readonly checkout: {
+        readonly sessions: StripeCheckoutSessionsApiLike;
+    };
+}

package/dist/types.js

@@ -0,0 +1,9 @@
+/**
+ * Minimal structural Stripe types.
+ *
+ * The adapter is dependency-free: merchants inject their own `Stripe` instance
+ * and objects, which are structurally compatible with these narrow interfaces.
+ * This avoids a runtime/build dependency on the `stripe` package while keeping
+ * the bits the adapter actually touches type-safe.
+ */
+export {};

package/dist/version.d.ts

@@ -0,0 +1,2 @@
+export declare const proxyCheckoutStripeServerSdkName = "@proxy-checkout/stripe-server-js";
+export declare const proxyCheckoutStripeServerSdkVersion = "0.0.0-pr-76.17.1";

package/dist/version.js

@@ -0,0 +1,2 @@
+export const proxyCheckoutStripeServerSdkName = "@proxy-checkout/stripe-server-js";
+export const proxyCheckoutStripeServerSdkVersion = "0.0.0-pr-76.17.1";

package/package.json

@@ -0,0 +1,58 @@
+{
+  "description": "Server-side Stripe adapter for Proxy Checkout: required metadata, provider binding, openCheckout, and cart sync.",
+  "license": "MIT",
+  "module": "./dist/index.js",
+  "name": "@proxy-checkout/stripe-server-js",
+  "private": false,
+  "sideEffects": false,
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "version": "0.0.0-pr-76.17.1",
+  "devDependencies": {
+    "@types/node": "^24.12.4",
+    "@vitest/coverage-v8": "4.1.7",
+    "typescript": "^6.0.3",
+    "vitest": "4.1.7",
+    "@proxy-checkout/server-js": "0.0.4-pr-76.17.1"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "keywords": [
+    "proxy-checkout",
+    "stripe",
+    "checkout",
+    "payments",
+    "sdk"
+  ],
+  "peerDependencies": {
+    "@proxy-checkout/server-js": "0.0.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "directory": "sdks/stripe-server-js",
+    "type": "git",
+    "url": "git+https://github.com/linuslabs/proxy.git"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "test:all": "vitest run",
+    "test:coverage": "vitest run --coverage.enabled --coverage.reportsDirectory=coverage/all",
+    "test:coverage:changed": "vitest run --coverage.enabled --coverage.reportsDirectory=coverage/changed",
+    "test:coverage:integration": "vitest run --project integration --coverage.enabled --coverage.reportsDirectory=coverage/integration",
+    "test:coverage:unit": "vitest run --project unit --coverage.enabled --coverage.reportsDirectory=coverage/unit",
+    "test:integration": "vitest run --project integration",
+    "test:unit": "vitest run --project unit",
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  }
+}