@vitrine-kit/vitrine 0.3.1 → 0.4.1

package/kit/registry/README.md

@@ -0,0 +1,9 @@
+# registry/ — copy-in feature registry
+
+The source for `vitrine init` / `vitrine add`. Each feature = a folder with `feature.json` (manifest) + `files/` (sources). On install the files are **copied** into the client repository (the client owns the code).
+
+`_index.json` is the registry manifest: the list of all features + the kit version.
+
+**Rule (spec §4, §13):** the registry holds only what varies per client (UI, sections, wiring). No critical logic — that lives in `@vitrine-kit/core`. A new feature must depend **only on the contracts**.
+
+**Typecheck in the monorepo:** `pnpm typecheck:registry` (components + lib) and `pnpm typecheck:registry-routes` (Next API route glue via `stubs/route-glue.d.ts`). Full Next/Payload pages are checked when the client is instantiated.

package/kit/registry/_index.json

@@ -0,0 +1,74 @@
+{
+  "$schema": "../schemas/registry-index.schema.json",
+  "kitVersion": "0.4.1",
+  "contracts": "1.0.0",
+  "features": {
+    "catalog": {
+      "title": "Product catalog",
+      "kitVersion": "0.4.1",
+      "tier": [
+        "catalog",
+        "simple-store",
+        "full-store"
+      ]
+    },
+    "product-page": {
+      "title": "Product page",
+      "kitVersion": "0.4.1",
+      "tier": [
+        "catalog",
+        "simple-store",
+        "full-store"
+      ]
+    },
+    "seo": {
+      "title": "SEO — metadata and JSON-LD",
+      "kitVersion": "0.4.1",
+      "tier": [
+        "catalog",
+        "simple-store",
+        "full-store"
+      ]
+    },
+    "cart": {
+      "title": "Cart",
+      "kitVersion": "0.4.1",
+      "tier": [
+        "simple-store",
+        "full-store"
+      ]
+    },
+    "checkout": {
+      "title": "Checkout",
+      "kitVersion": "0.4.1",
+      "tier": [
+        "simple-store",
+        "full-store"
+      ]
+    },
+    "checkout-stripe": {
+      "title": "Payment — Stripe",
+      "kitVersion": "0.4.1",
+      "tier": [
+        "simple-store",
+        "full-store"
+      ]
+    },
+    "checkout-paddle": {
+      "title": "Payment — Paddle",
+      "kitVersion": "0.4.1",
+      "tier": [
+        "simple-store",
+        "full-store"
+      ]
+    },
+    "checkout-yookassa": {
+      "title": "Payment — YooKassa",
+      "kitVersion": "0.4.1",
+      "tier": [
+        "simple-store",
+        "full-store"
+      ]
+    }
+  }
+}

package/kit/registry/cart/docs/cart.md

@@ -0,0 +1,13 @@
+# Feature: cart
+
+The cart for the `simple-store` / `full-store` tiers. Depends only on the contracts:
+data goes through `CommerceBackend`, the arithmetic lives in `@vitrine-kit/core` (critical logic).
+
+- **Components:** `CartView`, `CartLineItem`, `CartSummary` (hosts the `cart.summary` slot),
+  `AddToCart` (client component, `product.purchase` slot), `CartIndicator` (`global.header-actions` slot).
+- **Routes/API (Next glue):** `/cart` (page), `POST/PATCH/DELETE /api/cart`
+  (cart id in an httpOnly cookie, mutations via `CommerceBackend`).
+- **Slots:** `product.purchase` → `AddToCart`; `global.header-actions` → `CartIndicator`;
+  hosts `cart.summary` (where checkout-stripe places the checkout button).
+
+Styled with tokens; the AI design step doesn't touch behavior.

package/kit/registry/cart/feature.json

@@ -0,0 +1,51 @@
+{
+  "$schema": "../../schemas/feature.schema.json",
+  "name": "cart",
+  "title": "Cart",
+  "kitVersion": "0.4.1",
+  "requiresContracts": ">=1.0.0 <2.0.0",
+  "tier": [
+    "simple-store",
+    "full-store"
+  ],
+  "registryDependencies": [],
+  "corePackages": {
+    "@vitrine-kit/core": ">=0.1.0"
+  },
+  "npm": [],
+  "files": [
+    {
+      "from": "files/components/cart/",
+      "to": "components/cart/"
+    },
+    {
+      "from": "files/lib/cart/",
+      "to": "lib/cart/"
+    },
+    {
+      "from": "files/app/",
+      "to": "app/"
+    }
+  ],
+  "config": {
+    "set": {
+      "features.cart": true
+    }
+  },
+  "slots": [
+    {
+      "slot": "product.purchase",
+      "component": "AddToCart",
+      "order": 10
+    },
+    {
+      "slot": "global.header-actions",
+      "component": "CartIndicator",
+      "order": 20
+    }
+  ],
+  "env": [],
+  "claudeDoc": "docs/cart.md",
+  "conflicts": [],
+  "removable": true
+}

package/kit/registry/cart/files/app/(frontend)/cart/page.tsx

@@ -0,0 +1,21 @@
+// Cart page. The cart id is stored in a cookie; data comes via the CommerceBackend
+// contract (the backend adapter in lib/adapter). Not typechecked in the monorepo
+// (Next glue), verified when the client is instantiated.
+import { cookies } from 'next/headers';
+import { emptyCart } from '@vitrine-kit/core';
+import { getCommerceBackend } from '@/lib/adapter';
+import { CartView } from '@/components/cart/CartView';
+import { siteConfig } from '@/site.config';
+
+export default async function CartPage() {
+  const cartId = (await cookies()).get('vitrine_cart')?.value;
+  const commerce = await getCommerceBackend();
+  const cart = cartId ? await commerce.getCart(cartId) : null;
+
+  return (
+    <section className="flex flex-col gap-section">
+      <h1 className="font-heading text-fg">Cart</h1>
+      <CartView cart={cart ?? emptyCart('', siteConfig.i18n.currency)} />
+    </section>
+  );
+}

package/kit/registry/cart/files/app/api/cart/route.ts

@@ -0,0 +1,41 @@
+// Cart API: POST add, PATCH change quantity, DELETE remove a line.
+// Cart id in an httpOnly cookie. Mutations are delegated to CommerceBackend (lib/adapter),
+// the arithmetic lives in @vitrine-kit/core. Next glue, not typechecked in the monorepo.
+import { cookies } from 'next/headers';
+import { NextResponse } from 'next/server';
+import type { CommerceBackend } from '@vitrine-kit/contracts';
+import { getCommerceBackend } from '@/lib/adapter';
+
+const COOKIE = 'vitrine_cart';
+
+async function ensureCartId(commerce: CommerceBackend): Promise<string> {
+  const jar = await cookies();
+  const existing = jar.get(COOKIE)?.value;
+  if (existing) return existing;
+  const cart = await commerce.createCart();
+  jar.set(COOKIE, cart.id, { httpOnly: true, sameSite: 'lax', path: '/' });
+  return cart.id;
+}
+
+export async function POST(req: Request) {
+  const { variantId, quantity = 1 } = (await req.json()) as { variantId: string; quantity?: number };
+  const commerce = await getCommerceBackend();
+  const id = await ensureCartId(commerce);
+  return NextResponse.json(await commerce.addItem(id, variantId, quantity));
+}
+
+export async function PATCH(req: Request) {
+  const { lineId, quantity } = (await req.json()) as { lineId: string; quantity: number };
+  const id = (await cookies()).get(COOKIE)?.value;
+  if (!id) return NextResponse.json({ error: 'cart not found' }, { status: 400 });
+  const commerce = await getCommerceBackend();
+  return NextResponse.json(await commerce.updateItem(id, lineId, quantity));
+}
+
+export async function DELETE(req: Request) {
+  const { lineId } = (await req.json()) as { lineId: string };
+  const id = (await cookies()).get(COOKIE)?.value;
+  if (!id) return NextResponse.json({ error: 'cart not found' }, { status: 400 });
+  const commerce = await getCommerceBackend();
+  return NextResponse.json(await commerce.removeItem(id, lineId));
+}

package/kit/registry/cart/files/components/cart/AddToCart.tsx

@@ -0,0 +1,40 @@
+// "Add to cart" button — client component. Mounted into the product.purchase slot
+// (ProductView passes product). Mutation goes through POST /api/cart (the feature's route).
+'use client';
+import { useState } from 'react';
+import type { Product } from '@vitrine-kit/contracts';
+
+export interface AddToCartProps {
+  product: Product;
+}
+
+export function AddToCart({ product }: AddToCartProps) {
+  const [pending, setPending] = useState(false);
+  const variantId = product.variants[0]?.id;
+
+  async function add(): Promise<void> {
+    if (!variantId) return;
+    setPending(true);
+    try {
+      await fetch('/api/cart', {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ variantId, quantity: 1 }),
+      });
+      location.assign('/cart');
+    } finally {
+      setPending(false);
+    }
+  }
+
+  return (
+    <button
+      type="button"
+      onClick={add}
+      disabled={pending || !variantId}
+      className="vt-add-to-cart rounded-md bg-primary px-gutter py-unit text-primary-fg transition hover:opacity-90 disabled:opacity-50 focus-visible:outline-none focus-visible:ring-2 ring-ring"
+    >
+      {pending ? 'Adding…' : 'Add to cart'}
+    </button>
+  );
+}

package/kit/registry/cart/files/components/cart/CartIndicator.tsx

@@ -0,0 +1,11 @@
+// Header cart link (global.header-actions slot). Presentational.
+export function CartIndicator() {
+  return (
+    <a
+      href="/cart"
+      className="vt-cart-indicator text-fg transition hover:text-primary focus-visible:outline-none focus-visible:ring-2 ring-ring"
+    >
+      Cart
+    </a>
+  );
+}

package/kit/registry/cart/files/components/cart/CartLineItem.tsx

@@ -0,0 +1,27 @@
+// Cart line item — presentational.
+import type { CartLine } from '@vitrine-kit/contracts';
+import { formatMoney } from '../../lib/cart/data.js';
+
+export interface CartLineItemProps {
+  line: CartLine;
+  currency: string;
+}
+
+export function CartLineItem({ line, currency }: CartLineItemProps) {
+  return (
+    <li className="vt-cart-line flex items-center gap-gutter border-b border-border py-unit">
+      {line.image ? (
+        <img src={line.image} alt="" className="h-16 w-16 rounded-md object-cover" />
+      ) : (
+        <div className="h-16 w-16 rounded-md bg-muted" aria-hidden="true" />
+      )}
+      <div className="flex-1">
+        <p className="text-fg">{line.title}</p>
+        <p className="text-muted-fg">
+          {line.quantity} × {formatMoney(line.unitPrice, currency)}
+        </p>
+      </div>
+      <p className="text-price">{formatMoney(line.lineTotal, currency)}</p>
+    </li>
+  );
+}

package/kit/registry/cart/files/components/cart/CartSummary.tsx

@@ -0,0 +1,31 @@
+// Cart totals. Hosts the cart.summary slot (where checkout-stripe mounts the checkout
+// button) and passes it cartId.
+import type { Cart } from '@vitrine-kit/contracts';
+import { Slot } from '@vitrine-kit/core/react';
+import { formatMoney } from '../../lib/cart/data.js';
+
+export interface CartSummaryProps {
+  cart: Cart;
+}
+
+export function CartSummary({ cart }: CartSummaryProps) {
+  return (
+    <aside className="vt-cart-summary flex flex-col gap-unit rounded-md border border-border p-gutter">
+      <div className="flex justify-between text-muted-fg">
+        <span>Subtotal</span>
+        <span>{formatMoney(cart.subtotal, cart.currency)}</span>
+      </div>
+      {cart.discountTotal ? (
+        <div className="flex justify-between text-muted-fg">
+          <span>Discount</span>
+          <span>−{formatMoney(cart.discountTotal, cart.currency)}</span>
+        </div>
+      ) : null}
+      <div className="flex justify-between text-fg">
+        <span>Total</span>
+        <span className="text-price">{formatMoney(cart.total, cart.currency)}</span>
+      </div>
+      <Slot name="cart.summary" cartId={cart.id} />
+    </aside>
+  );
+}

package/kit/registry/cart/files/components/cart/CartView.tsx

@@ -0,0 +1,31 @@
+// Cart contents — presentational. Hosts the cart.items-bottom / cart.below slots.
+import type { Cart } from '@vitrine-kit/contracts';
+import { Slot } from '@vitrine-kit/core/react';
+import { CartLineItem } from './CartLineItem.js';
+import { CartSummary } from './CartSummary.js';
+
+export interface CartViewProps {
+  cart: Cart;
+}
+
+export function CartView({ cart }: CartViewProps) {
+  if (cart.lines.length === 0) {
+    return <p className="text-muted-fg">Your cart is empty.</p>;
+  }
+  return (
+    <div className="vt-cart grid gap-section md:grid-cols-[2fr_1fr]">
+      <div>
+        <ul role="list">
+          {cart.lines.map((line) => (
+            <CartLineItem key={line.id} line={line} currency={cart.currency} />
+          ))}
+        </ul>
+        <Slot name="cart.items-bottom" />
+      </div>
+      <div className="flex flex-col gap-gutter">
+        <CartSummary cart={cart} />
+        <Slot name="cart.below" />
+      </div>
+    </div>
+  );
+}

package/kit/registry/cart/files/lib/cart/data.ts

@@ -0,0 +1,12 @@
+// Cart access via the CommerceBackend contract + price formatting.
+// The cart arithmetic lives in @vitrine-kit/core (critical logic); a ready Cart arrives here.
+import type { Cart, CommerceBackend } from '@vitrine-kit/contracts';
+
+export async function loadCart(commerce: CommerceBackend, cartId: string): Promise<Cart | null> {
+  return commerce.getCart(cartId);
+}
+
+/** Money — minor units (e.g. cents); divide by 100 for 2-decimal currencies. */
+export function formatMoney(amount: number, currency: string, locale = 'en-US'): string {
+  return new Intl.NumberFormat(locale, { style: 'currency', currency }).format(amount / 100);
+}

package/kit/registry/cart/files/lib/cart/register.ts

@@ -0,0 +1,10 @@
+// Registers the cart feature's slots. The client calls this from lib/slots.ts.
+// AddToCart — on the product page (product.purchase), CartIndicator — in the header.
+import { registerSlot } from '@vitrine-kit/core';
+import { AddToCart } from '../../components/cart/AddToCart.js';
+import { CartIndicator } from '../../components/cart/CartIndicator.js';
+
+export function registerCartSlots(): void {
+  registerSlot({ slot: 'product.purchase', component: AddToCart, order: 10 });
+  registerSlot({ slot: 'global.header-actions', component: CartIndicator, order: 20 });
+}

package/kit/registry/catalog/docs/catalog.md

@@ -0,0 +1,18 @@
+# Feature: catalog
+
+Browsing the assortment: product grid, product card, category navigation.
+
+## Components
+- `components/catalog/ProductGrid` — grid (semantic list) of `ProductCard`s.
+- `components/catalog/ProductCard` — card (image, title, price).
+- `components/catalog/CategoryNav` — navigation; mounted into the `global.header-nav` slot.
+
+## Data
+- `lib/catalog/data` — `loadProducts`/`loadProduct`/`loadCategories` over the `CatalogSource` contract + `formatPrice` (price in minor units).
+- `lib/catalog/register` — registers the `global.header-nav` slot.
+
+## Styling
+All classes are token-based (`bg-surface`, `text-fg`, `text-price`, `rounded-md`, `gap-gutter`). The design step changes only token values, not structure/a11y.
+
+## Contracts
+Depends only on `@vitrine-kit/contracts` (types, `CatalogSource`) and `@vitrine-kit/core` (`registerSlot`). Portable between Payload and Vendure.

package/kit/registry/catalog/feature.json

@@ -0,0 +1,43 @@
+{
+  "$schema": "../../schemas/feature.schema.json",
+  "name": "catalog",
+  "title": "Product catalog",
+  "kitVersion": "0.4.1",
+  "requiresContracts": ">=1.0.0 <2.0.0",
+  "tier": [
+    "catalog",
+    "simple-store",
+    "full-store"
+  ],
+  "registryDependencies": [],
+  "corePackages": {
+    "@vitrine-kit/core": ">=0.1.0"
+  },
+  "npm": [],
+  "files": [
+    {
+      "from": "files/components/catalog/",
+      "to": "components/catalog/"
+    },
+    {
+      "from": "files/lib/catalog/",
+      "to": "lib/catalog/"
+    }
+  ],
+  "config": {
+    "set": {
+      "features.catalog": true
+    }
+  },
+  "slots": [
+    {
+      "slot": "global.header-nav",
+      "component": "CategoryNav",
+      "order": 10
+    }
+  ],
+  "env": [],
+  "claudeDoc": "docs/catalog.md",
+  "conflicts": [],
+  "removable": false
+}

package/kit/registry/catalog/files/components/catalog/CategoryNav.tsx

@@ -0,0 +1,26 @@
+// Category navigation — presentational. Data comes as a prop from the slot host
+// (<Slot name="global.header-nav" categories={…} />).
+import type { Category } from '@vitrine-kit/contracts';
+
+export interface CategoryNavProps {
+  categories: Category[];
+}
+
+export function CategoryNav({ categories }: CategoryNavProps) {
+  return (
+    <nav aria-label="Categories" className="vt-category-nav">
+      <ul role="list" className="flex flex-wrap gap-gutter">
+        {categories.map((category) => (
+          <li key={category.id}>
+            <a
+              href={`/categories/${category.slug}`}
+              className="text-fg transition hover:text-primary focus-visible:outline-none focus-visible:ring-2 ring-ring"
+            >
+              {category.title}
+            </a>
+          </li>
+        ))}
+      </ul>
+    </nav>
+  );
+}

package/kit/registry/catalog/files/components/catalog/ProductCard.tsx

@@ -0,0 +1,42 @@
+// Product card — presentational, visually neutral (classes → tokens).
+// The design step doesn't touch structure/a11y, only tokens.
+import type { Product } from '@vitrine-kit/contracts';
+import { formatPrice } from '../../lib/catalog/data.js';
+
+export interface ProductCardProps {
+  product: Product;
+}
+
+export function ProductCard({ product }: ProductCardProps) {
+  const price = product.priceRange?.min ?? product.variants[0]?.price;
+  const currency = product.priceRange?.currency ?? product.variants[0]?.currency ?? 'USD';
+  const image = product.images[0];
+
+  return (
+    <article className="vt-product-card rounded-md border border-border bg-surface text-surface-fg">
+      <a
+        href={`/products/${product.slug}`}
+        className="block focus-visible:outline-none focus-visible:ring-2 ring-ring"
+      >
+        {image ? (
+          <img
+            src={image.url}
+            alt={image.alt ?? product.title}
+            width={image.width}
+            height={image.height}
+            loading="lazy"
+            className="aspect-square w-full rounded-t-md object-cover"
+          />
+        ) : (
+          <div className="aspect-square w-full rounded-t-md bg-muted" aria-hidden="true" />
+        )}
+        <div className="p-gutter">
+          <h3 className="font-heading text-fg">{product.title}</h3>
+          {price != null ? (
+            <p className="text-price">{formatPrice(price, currency)}</p>
+          ) : null}
+        </div>
+      </a>
+    </article>
+  );
+}

package/kit/registry/catalog/files/components/catalog/ProductGrid.tsx

@@ -0,0 +1,25 @@
+// Product grid — presentational, semantic list.
+import type { Product } from '@vitrine-kit/contracts';
+import { ProductCard } from './ProductCard.js';
+
+export interface ProductGridProps {
+  products: Product[];
+}
+
+export function ProductGrid({ products }: ProductGridProps) {
+  if (products.length === 0) {
+    return <p className="text-muted-fg">No products found.</p>;
+  }
+  return (
+    <ul
+      role="list"
+      className="vt-product-grid grid grid-cols-2 gap-gutter md:grid-cols-3 lg:grid-cols-4"
+    >
+      {products.map((product) => (
+        <li key={product.id}>
+          <ProductCard product={product} />
+        </li>
+      ))}
+    </ul>
+  );
+}

package/kit/registry/catalog/files/lib/catalog/data.ts

@@ -0,0 +1,24 @@
+// Catalog access via the CatalogSource contract. The source (Payload*/Vendure*)
+// is resolved in the page data (template); a ready CatalogSource arrives here —
+// so the feature depends only on the contract and is portable across backends.
+import type { CatalogSource, Category, Product, ProductQuery } from '@vitrine-kit/contracts';
+
+export async function loadProducts(
+  source: CatalogSource,
+  query: ProductQuery = {},
+): Promise<Product[]> {
+  return source.listProducts(query);
+}
+
+export async function loadProduct(source: CatalogSource, slug: string): Promise<Product | null> {
+  return source.getProduct(slug);
+}
+
+export async function loadCategories(source: CatalogSource): Promise<Category[]> {
+  return source.listCategories();
+}
+
+/** Money — minor units (e.g. cents); divide by 100 for 2-decimal currencies. */
+export function formatPrice(amount: number, currency: string, locale = 'en-US'): string {
+  return new Intl.NumberFormat(locale, { style: 'currency', currency }).format(amount / 100);
+}

package/kit/registry/catalog/files/lib/catalog/register.ts

@@ -0,0 +1,8 @@
+// Registers the catalog feature's slots. The client calls this from lib/slots.ts.
+// CategoryNav receives categories from the slot host via <Slot> props.
+import { registerSlot } from '@vitrine-kit/core';
+import { CategoryNav } from '../../components/catalog/CategoryNav.js';
+
+export function registerCatalogSlots(): void {
+  registerSlot({ slot: 'global.header-nav', component: CategoryNav, order: 10 });
+}

package/kit/registry/checkout/docs/checkout.md

@@ -0,0 +1,17 @@
+# Feature: checkout
+
+A provider-agnostic checkout scaffold for `simple-store` / `full-store`. Depends on the
+`cart` feature. It does NOT process payments on its own — add one of the provider features:
+`checkout-stripe`, `checkout-paddle`, or `checkout-yookassa` (exactly one).
+
+- **Component:** `CheckoutButton` (client component) — `cart.summary` slot. Calls
+  `POST /api/checkout` and redirects to the provider URL. It knows nothing about the provider.
+- **API (Next glue):** `POST /api/checkout` — `CommerceBackend.startCheckout`
+  delegates to the active provider (`payments.resolve` by `integrations.payments`).
+- **Shared webhook code:** `lib/checkout/fulfill.ts` → `fulfillOrderFromEvent` —
+  idempotent order creation from a normalized event (used by all provider webhook
+  routes). The critical logic (dedup by `paymentRef`, order snapshot) lives in
+  `@vitrine-kit/core` (`shouldCreateOrder`, `buildOrderFromCart`).
+
+Flow: cart → `Checkout` → `POST /api/checkout` → redirect to the provider →
+provider webhook → `fulfillOrderFromEvent` → order in the admin, cart `converted`.

package/kit/registry/checkout/feature.json

@@ -0,0 +1,47 @@
+{
+  "$schema": "../../schemas/feature.schema.json",
+  "name": "checkout",
+  "title": "Checkout",
+  "kitVersion": "0.4.1",
+  "requiresContracts": ">=1.0.0 <2.0.0",
+  "tier": [
+    "simple-store",
+    "full-store"
+  ],
+  "registryDependencies": [
+    "cart"
+  ],
+  "corePackages": {
+    "@vitrine-kit/core": ">=0.1.0"
+  },
+  "npm": [],
+  "files": [
+    {
+      "from": "files/components/checkout/",
+      "to": "components/checkout/"
+    },
+    {
+      "from": "files/lib/checkout/",
+      "to": "lib/checkout/"
+    },
+    {
+      "from": "files/app/",
+      "to": "app/"
+    }
+  ],
+  "config": {
+    "set": {
+      "features.checkout": true
+    }
+  },
+  "slots": [
+    {
+      "slot": "cart.summary",
+      "component": "CheckoutButton",
+      "order": 10
+    }
+  ],
+  "claudeDoc": "docs/checkout.md",
+  "conflicts": [],
+  "removable": true
+}

package/kit/registry/checkout/files/app/api/checkout/route.ts

@@ -0,0 +1,14 @@
+// POST /api/checkout — creates a checkout session with the active payment provider for
+// the current cart (cookie) via CommerceBackend.startCheckout and returns the
+// redirect URL. Provider-agnostic: startCheckout delegates to payments.resolve. Next glue.
+import { cookies } from 'next/headers';
+import { NextResponse } from 'next/server';
+import { getCommerceBackend } from '@/lib/adapter';
+
+export async function POST() {
+  const cartId = (await cookies()).get('vitrine_cart')?.value;
+  if (!cartId) return NextResponse.json({ error: 'cart is empty' }, { status: 400 });
+  const commerce = await getCommerceBackend();
+  const { redirectUrl } = await commerce.startCheckout(cartId);
+  return NextResponse.json({ url: redirectUrl });
+}