@tangle-network/starter-foundry 0.5.4 → 0.7.2

package/registry/layers/capability/routing/files/routing-notes.md

@@ -0,0 +1,33 @@
+# Routing
+
+`react-router-dom` v7. `createBrowserRouter` for SPA, `createMemoryRouter` for tests/Electron.
+
+## When to add a route
+
+1. Add an entry to the children array in `src/router.tsx`.
+2. If the route has dynamic params, use `:id` in the path + `useParams()` in the component.
+3. For nested layouts (tab shells, sidebars), nest children under a parent that renders `<Outlet />`.
+
+## Navigation
+
+- `<Link to="/foo">` — basic nav link.
+- `<NavLink to="/foo">` — auto-applies `isActive` class; use for nav bars.
+- `useNavigate()` — programmatic (after form submit, auth callback, etc.).
+- `useSearchParams()` — query-string state (e.g. `?tab=details`). Stays in URL, shareable.
+
+## Data
+
+Prefer loader/action route data hooks over global state for page-scoped fetches:
+
+```tsx
+{ path: 'proposals/:id', element: <ProposalPage />,
+  loader: ({ params }) => fetchProposal(params.id),
+}
+// in ProposalPage: const proposal = useLoaderData() as Proposal
+```
+
+## Gotchas
+
+- `react-router-dom` v7 merged with Remix. APIs stable from v6 but import paths shifted — if you see "no export named X" on a v6 import, check the v7 migration guide.
+- For Electron/Tauri: use `createHashRouter` instead of `createBrowserRouter` — file:// URLs don't play nice with history mode.
+- SSR needs explicit data loaders + `createStaticRouter`; this scaffold is SPA-only.

package/registry/layers/capability/routing/manifest.json

@@ -0,0 +1,66 @@
+{
+  "id": "routing",
+  "description": "Client-side routing for multi-page React apps via react-router-dom \u2014 pages, nested layouts, URL params, programmatic navigation. For any product that has more than a single view and lives in a non-framework (Vite) React setup. Next.js / Remix / SvelteKit have their own file-based routers and don't need this.",
+  "appliesTo": [
+    "react-vite-ts",
+    "electron-desktop-ts",
+    "electron-native-os",
+    "tauri-desktop",
+    "browser-extension-ts"
+  ],
+  "files": [
+    {
+      "source": "files/router.tsx",
+      "target": "src/router.tsx"
+    },
+    {
+      "source": "files/routing-notes.md",
+      "target": "docs/routing-notes.md"
+    }
+  ],
+  "packageDeps": {
+    "dependencies": {
+      "react-router-dom": "^7.1.0"
+    }
+  },
+  "keywords": [
+    "routing",
+    "routes",
+    "navigation",
+    "react router",
+    "multi-page",
+    "url params",
+    "nested layouts"
+  ],
+  "buildHints": {
+    "whenToUse": "Attach on react-vite-ts (or any non-framework React host) when the product has multiple pages \u2014 proposal list + detail, dashboard + settings, any /foo + /foo/:id pattern. Skip on Next.js / Remix / SvelteKit / Astro (they have file-based routers).",
+    "firstSteps": [
+      "Define routes in src/router.tsx (createBrowserRouter pattern)",
+      "Mount <RouterProvider /> in main.tsx instead of <App />",
+      "Use <Link>/<NavLink> for navigation \u2014 never <a href> for internal routes",
+      "useParams() in child routes for URL-driven state"
+    ],
+    "gotchas": [
+      "react-router-dom v7 merged with remix-run/react-router \u2014 APIs are stable but import paths shifted slightly from v6.",
+      "SSR + v7 needs explicit data loaders; client-only apps (Vite SPA) stay with createBrowserRouter."
+    ]
+  },
+  "tieredKeywords": {
+    "archetypes": [
+      "proposal list",
+      "proposal detail",
+      "list and detail",
+      "multi-page",
+      "nested routes",
+      "nested layouts",
+      "dashboard with pages",
+      "admin panel with pages",
+      "portal with multiple views",
+      "navigation menu",
+      "deep linking",
+      "route params",
+      "url params",
+      "tabs with pages"
+    ]
+  }
+}

package/registry/layers/capability/saas-billing/manifest.json

@@ -69,5 +69,10 @@
       "Stripe Customer Portal",
       "Stripe Webhooks"
     ]
+  },
+  "packageDeps": {
+    "dependencies": {
+      "stripe": "^17.0.0"
+    }
   }
 }

package/registry/layers/capability/shadcn/files/breadcrumb.tsx

@@ -6,7 +6,7 @@ const Breadcrumb = React.forwardRef<HTMLElement, React.HTMLAttributes<HTMLElemen
 )
 Breadcrumb.displayName = "Breadcrumb"
 
-const BreadcrumbList = React.forwardRef<HTMLOListElement, React.OlistHTMLAttributes<HTMLOListElement>>(
+const BreadcrumbList = React.forwardRef<HTMLOListElement, React.OlHTMLAttributes<HTMLOListElement>>(
   ({ className, ...props }, ref) => (
     <ol ref={ref} className={cn("flex flex-wrap items-center gap-1.5 break-words text-sm text-muted-foreground sm:gap-2.5", className)} {...props} />
   )

package/registry/layers/capability/shadcn/files/collapsible.tsx

@@ -0,0 +1,50 @@
+import * as React from "react"
+
+type CollapsibleContextValue = { open: boolean; onOpenChange: (v: boolean) => void }
+const CollapsibleContext = React.createContext<CollapsibleContextValue>({ open: false, onOpenChange: () => {} })
+
+function Collapsible({
+  open: controlledOpen,
+  defaultOpen,
+  onOpenChange,
+  children,
+  ...props
+}: {
+  open?: boolean
+  defaultOpen?: boolean
+  onOpenChange?: (v: boolean) => void
+  children: React.ReactNode
+} & Omit<React.HTMLAttributes<HTMLDivElement>, "children">) {
+  const [internal, setInternal] = React.useState(defaultOpen ?? false)
+  const open = controlledOpen ?? internal
+  const setter = onOpenChange ?? setInternal
+  return (
+    <CollapsibleContext.Provider value={{ open, onOpenChange: setter }}>
+      <div data-state={open ? "open" : "closed"} {...props}>{children}</div>
+    </CollapsibleContext.Provider>
+  )
+}
+
+const CollapsibleTrigger = React.forwardRef<HTMLButtonElement, React.ButtonHTMLAttributes<HTMLButtonElement> & { asChild?: boolean }>(
+  ({ onClick, asChild, children, ...props }, ref) => {
+    const ctx = React.useContext(CollapsibleContext)
+    const handle = (e: React.MouseEvent<HTMLButtonElement>) => { ctx.onOpenChange(!ctx.open); onClick?.(e) }
+    if (asChild && React.isValidElement(children)) {
+      const child = children as React.ReactElement<{ onClick?: (e: React.MouseEvent<HTMLButtonElement>) => void; ref?: React.Ref<HTMLButtonElement> }>
+      return React.cloneElement(child, { onClick: handle, ref })
+    }
+    return <button ref={ref} type="button" onClick={handle} data-state={ctx.open ? "open" : "closed"} {...props}>{children}</button>
+  }
+)
+CollapsibleTrigger.displayName = "CollapsibleTrigger"
+
+const CollapsibleContent = React.forwardRef<HTMLDivElement, React.HTMLAttributes<HTMLDivElement>>(
+  ({ children, ...props }, ref) => {
+    const ctx = React.useContext(CollapsibleContext)
+    if (!ctx.open) return null
+    return <div ref={ref} data-state="open" {...props}>{children}</div>
+  }
+)
+CollapsibleContent.displayName = "CollapsibleContent"
+
+export { Collapsible, CollapsibleTrigger, CollapsibleContent }

package/registry/layers/capability/shadcn/files/popover.tsx

@@ -0,0 +1,54 @@
+import * as React from "react"
+import { cn } from "@/lib/utils"
+
+type PopoverContextValue = { open: boolean; onOpenChange: (v: boolean) => void }
+const PopoverContext = React.createContext<PopoverContextValue>({ open: false, onOpenChange: () => {} })
+
+function Popover({ open: controlledOpen, onOpenChange, children }: { open?: boolean; onOpenChange?: (v: boolean) => void; children: React.ReactNode }) {
+  const [internal, setInternal] = React.useState(false)
+  const open = controlledOpen ?? internal
+  const setter = onOpenChange ?? setInternal
+  return <PopoverContext.Provider value={{ open, onOpenChange: setter }}>{children}</PopoverContext.Provider>
+}
+
+const PopoverTrigger = React.forwardRef<HTMLButtonElement, React.ButtonHTMLAttributes<HTMLButtonElement> & { asChild?: boolean }>(
+  ({ onClick, asChild, children, ...props }, ref) => {
+    const ctx = React.useContext(PopoverContext)
+    const handle = (e: React.MouseEvent<HTMLButtonElement>) => { ctx.onOpenChange(!ctx.open); onClick?.(e) }
+    if (asChild && React.isValidElement(children)) {
+      const child = children as React.ReactElement<{ onClick?: (e: React.MouseEvent<HTMLButtonElement>) => void; ref?: React.Ref<HTMLButtonElement> }>
+      return React.cloneElement(child, { onClick: handle, ref })
+    }
+    return <button ref={ref} type="button" onClick={handle} {...props}>{children}</button>
+  }
+)
+PopoverTrigger.displayName = "PopoverTrigger"
+
+const PopoverContent = React.forwardRef<HTMLDivElement, React.HTMLAttributes<HTMLDivElement> & { align?: "start" | "center" | "end"; sideOffset?: number }>(
+  ({ className, align = "center", sideOffset: _sideOffset, children, ...props }, ref) => {
+    const ctx = React.useContext(PopoverContext)
+    if (!ctx.open) return null
+    const alignClass = align === "start" ? "left-0" : align === "end" ? "right-0" : "left-1/2 -translate-x-1/2"
+    return (
+      <>
+        <div className="fixed inset-0 z-40" onClick={() => ctx.onOpenChange(false)} />
+        <div
+          ref={ref}
+          className={cn(
+            "absolute z-50 mt-2 w-72 rounded-md border bg-popover p-4 text-popover-foreground shadow-md outline-none",
+            alignClass,
+            className,
+          )}
+          {...props}
+        >
+          {children}
+        </div>
+      </>
+    )
+  }
+)
+PopoverContent.displayName = "PopoverContent"
+
+const PopoverAnchor = ({ children }: { children?: React.ReactNode }) => <>{children}</>
+
+export { Popover, PopoverTrigger, PopoverContent, PopoverAnchor }

package/registry/layers/capability/shadcn/manifest.json

@@ -7,7 +7,9 @@
     "fullstack-ts",
     "remix-ts",
     "electron-desktop-ts",
-    "tauri-desktop"
+    "tauri-desktop",
+    "electron-native-os",
+    "multimodal-agent"
   ],
   "files": [
     {
@@ -46,6 +48,10 @@
       "source": "files/checkbox.tsx",
       "target": "src/components/ui/checkbox.tsx"
     },
+    {
+      "source": "files/collapsible.tsx",
+      "target": "src/components/ui/collapsible.tsx"
+    },
     {
       "source": "files/command.tsx",
       "target": "src/components/ui/command.tsx"
@@ -70,6 +76,10 @@
       "source": "files/label.tsx",
       "target": "src/components/ui/label.tsx"
     },
+    {
+      "source": "files/popover.tsx",
+      "target": "src/components/ui/popover.tsx"
+    },
     {
       "source": "files/progress.tsx",
       "target": "src/components/ui/progress.tsx"
@@ -167,5 +177,16 @@
       "Configure tsconfig.json paths: { '@/*': ['./src/*'] }",
       "Alternative to static component files: pnpm dlx shadcn@latest init --preset {{presetCode}}"
     ]
+  },
+  "packageDeps": {
+    "dependencies": {
+      "lucide-react": "^0.468.0",
+      "clsx": "^2.1.1",
+      "class-variance-authority": "^0.7.1",
+      "tailwind-merge": "^2.6.0",
+      "@radix-ui/react-slot": "^1.1.0",
+      "@radix-ui/react-dialog": "^1.1.0",
+      "@radix-ui/react-dropdown-menu": "^2.1.0"
+    }
   }
 }

package/registry/layers/capability/stripe-checkout-onetime/files/checkout.ts

@@ -0,0 +1,60 @@
+// Stripe Checkout helper — one-time purchases. For recurring subscriptions,
+// use saas-billing's subscription helpers instead.
+
+import Stripe from 'stripe'
+
+const stripe = new Stripe(process.env['STRIPE_SECRET_KEY'] ?? '', {
+  apiVersion: '2024-11-20.acacia' as Stripe.LatestApiVersion,
+})
+
+export interface OneTimeCheckoutParams {
+  productName: string
+  /** Amount in smallest currency unit (cents for USD). */
+  amount: number
+  currency: string
+  successUrl: string
+  cancelUrl: string
+  customerEmail?: string
+  /** Opaque metadata keyed to your internal order id. */
+  metadata?: Record<string, string>
+}
+
+/** Create a hosted Checkout session. Returns the URL to redirect the buyer to. */
+export async function createOneTimeCheckout(params: OneTimeCheckoutParams): Promise<{
+  sessionId: string
+  url: string
+}> {
+  const session = await stripe.checkout.sessions.create({
+    mode: 'payment',
+    payment_method_types: ['card'],
+    line_items: [
+      {
+        price_data: {
+          currency: params.currency,
+          product_data: { name: params.productName },
+          unit_amount: params.amount,
+        },
+        quantity: 1,
+      },
+    ],
+    success_url: params.successUrl,
+    cancel_url: params.cancelUrl,
+    customer_email: params.customerEmail,
+    metadata: params.metadata ?? {},
+  })
+
+  if (!session.url) throw new Error('Stripe returned a session with no URL')
+  return { sessionId: session.id, url: session.url }
+}
+
+/** Verify a checkout completed successfully. Call from your webhook handler. */
+export async function verifyCheckoutCompleted(sessionId: string): Promise<{
+  paid: boolean
+  metadata: Record<string, string>
+}> {
+  const session = await stripe.checkout.sessions.retrieve(sessionId)
+  return {
+    paid: session.payment_status === 'paid',
+    metadata: (session.metadata ?? {}) as Record<string, string>,
+  }
+}

package/registry/layers/capability/stripe-checkout-onetime/manifest.json

@@ -0,0 +1,36 @@
+{
+  "id": "stripe-checkout-onetime",
+  "description": "Stripe Checkout for one-time purchases — hosted or embedded checkout session for single-purchase products (courses, digital downloads, event tickets, unlock fees). Not for subscriptions — use saas-billing for that.",
+  "appliesTo": [
+    "nextjs-ts",
+    "fullstack-ts",
+    "api-service",
+    "bun-http",
+    "deno-edge"
+  ],
+  "files": [
+    {
+      "source": "files/checkout.ts",
+      "target": "lib/stripe-checkout.ts"
+    }
+  ],
+  "packageDeps": {
+    "dependencies": {
+      "stripe": "^17.0.0"
+    }
+  },
+  "keywords": [
+    "stripe checkout",
+    "one-time purchase",
+    "single purchase",
+    "pay per item",
+    "digital download",
+    "course purchase",
+    "event tickets",
+    "unlock fee",
+    "one-time payment"
+  ],
+  "buildHints": {
+    "whenToUse": "Attach for products selling a single item or one-time unlock. Use hosted Checkout URL unless the UI needs to stay on-brand — then use embedded mode."
+  }
+}

package/registry/layers/capability/stripe-connect/files/connect-api.ts

@@ -0,0 +1,57 @@
+// Stripe Connect helpers — marketplace/platform payments. Each helper is
+// intentionally small so the agent can read + extend. Read Stripe's docs
+// (https://docs.stripe.com/connect) for the full API surface.
+
+import Stripe from 'stripe'
+import config from '../connect-config.json'
+
+const stripe = new Stripe(process.env['STRIPE_SECRET_KEY'] ?? '', {
+  apiVersion: '2024-11-20.acacia' as Stripe.LatestApiVersion,
+})
+
+/** Onboard a new connected account. Returns the URL the seller visits to finish KYC. */
+export async function createConnectedAccount(sellerEmail: string) {
+  const account = await stripe.accounts.create({
+    type: config.mode === 'express' ? 'express' : 'custom',
+    email: sellerEmail,
+    capabilities: {
+      card_payments: { requested: true },
+      transfers: { requested: true },
+    },
+  })
+
+  const link = await stripe.accountLinks.create({
+    account: account.id,
+    refresh_url: `${process.env['PUBLIC_URL'] ?? ''}${config.onboardingRefreshUrl}`,
+    return_url: `${process.env['PUBLIC_URL'] ?? ''}${config.onboardingReturnUrl}`,
+    type: 'account_onboarding',
+  })
+
+  return { accountId: account.id, onboardingUrl: link.url }
+}
+
+/** Charge a buyer, route most to the seller, take a platform fee. */
+export async function createDestinationCharge(params: {
+  amountCents: number
+  currency: string
+  buyerPaymentMethodId: string
+  sellerAccountId: string
+}) {
+  const feeCents = Math.floor((params.amountCents * config.platformFeeBps) / 10000)
+  return stripe.paymentIntents.create({
+    amount: params.amountCents,
+    currency: params.currency,
+    payment_method: params.buyerPaymentMethodId,
+    confirm: true,
+    application_fee_amount: feeCents,
+    transfer_data: {
+      destination: params.sellerAccountId,
+    },
+  })
+}
+
+/** Check whether a connected account has finished KYC and can receive transfers. */
+export async function isAccountReady(accountId: string): Promise<boolean> {
+  const account = await stripe.accounts.retrieve(accountId)
+  return account.charges_enabled === true && account.payouts_enabled === true
+}

package/registry/layers/capability/stripe-connect/files/connect-config.json

@@ -0,0 +1,8 @@
+{
+  "mode": "express",
+  "platformFeeBps": 1000,
+  "payoutSchedule": "daily",
+  "onboardingReturnUrl": "/connect/return",
+  "onboardingRefreshUrl": "/connect/refresh",
+  "docs": "https://docs.stripe.com/connect"
+}

package/registry/layers/capability/stripe-connect/manifest.json

@@ -0,0 +1,40 @@
+{
+  "id": "stripe-connect",
+  "description": "Stripe Connect — multi-party / marketplace payments. Onboard connected accounts (Express or Custom), route charges to sellers, handle platform fees and payouts. For marketplaces, gig platforms, creator economies, and multi-vendor stores.",
+  "appliesTo": [
+    "nextjs-ts",
+    "fullstack-ts",
+    "api-service",
+    "bun-http",
+    "deno-edge"
+  ],
+  "files": [
+    {
+      "source": "files/connect-config.json",
+      "target": "connect-config.json"
+    },
+    {
+      "source": "files/connect-api.ts",
+      "target": "lib/stripe-connect.ts"
+    }
+  ],
+  "packageDeps": {
+    "dependencies": {
+      "stripe": "^17.0.0"
+    }
+  },
+  "keywords": [
+    "stripe connect",
+    "marketplace payments",
+    "multi-party payments",
+    "platform fees",
+    "seller onboarding",
+    "split payments",
+    "connected accounts",
+    "payouts to sellers",
+    "creator economy payments"
+  ],
+  "buildHints": {
+    "whenToUse": "Attach for marketplace / platform products that take a cut of transactions. Use Express onboarding unless you specifically need Custom (you don't — Custom adds PCI/KYC obligation to you, not Stripe)."
+  }
+}

package/registry/layers/capability/stripe-metered/files/metered.ts

@@ -0,0 +1,43 @@
+// Stripe usage-based billing via Billing Meters. The meter aggregates events
+// server-side; you just report consumption events as they happen. The meter
+// definition (name, cadence, aggregation) lives in the Stripe Dashboard.
+
+import Stripe from 'stripe'
+
+const stripe = new Stripe(process.env['STRIPE_SECRET_KEY'] ?? '', {
+  apiVersion: '2024-11-20.acacia' as Stripe.LatestApiVersion,
+})
+
+/** Report a consumption event. `value` accumulates into the meter for the customer. */
+export async function reportUsage(params: {
+  eventName: string
+  customerId: string
+  value: number
+  timestamp?: number
+  /** Idempotency — events with the same identifier de-dupe on Stripe's side. */
+  identifier?: string
+}) {
+  return stripe.billing.meterEvents.create({
+    event_name: params.eventName,
+    timestamp: params.timestamp,
+    identifier: params.identifier,
+    payload: {
+      stripe_customer_id: params.customerId,
+      value: String(params.value),
+    },
+  })
+}
+
+/** Read the current aggregated usage for a customer. */
+export async function readUsageSummary(params: {
+  meterId: string
+  customerId: string
+  startTime: number
+  endTime: number
+}) {
+  return stripe.billing.meters.listEventSummaries(params.meterId, {
+    customer: params.customerId,
+    start_time: params.startTime,
+    end_time: params.endTime,
+  })
+}

package/registry/layers/capability/stripe-metered/manifest.json

@@ -0,0 +1,35 @@
+{
+  "id": "stripe-metered",
+  "description": "Stripe usage-based billing via Billing Meters — report events as they happen, Stripe aggregates and bills on your cadence. For AI products (tokens consumed), API businesses (requests), storage/compute products (GB-hours).",
+  "appliesTo": [
+    "nextjs-ts",
+    "fullstack-ts",
+    "api-service",
+    "bun-http",
+    "deno-edge"
+  ],
+  "files": [
+    {
+      "source": "files/metered.ts",
+      "target": "lib/stripe-metered.ts"
+    }
+  ],
+  "packageDeps": {
+    "dependencies": {
+      "stripe": "^17.0.0"
+    }
+  },
+  "keywords": [
+    "stripe metered",
+    "usage-based billing",
+    "per-token billing",
+    "per-request billing",
+    "billing meters",
+    "pay-as-you-go",
+    "consumption billing",
+    "metered usage"
+  ],
+  "buildHints": {
+    "whenToUse": "Attach for products that bill on consumption rather than flat tiers. Report events via stripe.billing.meterEvents.create — Stripe aggregates and bills on the cycle you configured in the meter definition."
+  }
+}

package/registry/layers/capability/tailwind/manifest.json

@@ -12,8 +12,20 @@
     "frontend-static",
     "browser-extension-ts",
     "electron-desktop-ts",
-    "tauri-desktop"
+    "tauri-desktop",
+    "electron-native-os",
+    "multimodal-agent",
+    "vision-first-agent",
+    "voice-first-agent",
+    "realtime-audio-ts",
+    "astro-static"
   ],
+  "packageDeps": {
+    "dependencies": {
+      "@tailwindcss/vite": "^4.0.0",
+      "tailwindcss": "^4.0.0"
+    }
+  },
   "files": [
     {
       "source": "files/tailwind-config.json",

package/registry/layers/capability/tangle-gpu-provider/files/gpu-config.json

@@ -0,0 +1,14 @@
+{
+  "required": {
+    "minVramGb": 16,
+    "minComputeCapability": "7.5",
+    "minGpuCount": 1,
+    "preferred": ["A100", "H100", "L40S", "A10"],
+    "fallbackAllowed": true
+  },
+  "notes": [
+    "Compute capability 7.5 = Turing (T4, RTX 20). 8.0+ = Ampere+ (A100, A10).",
+    "For bfloat16 models, require compute capability >= 8.0.",
+    "For fp8 training/inference, require H100/H200 (9.0+)."
+  ]
+}

package/registry/layers/capability/tangle-gpu-provider/manifest.json

@@ -0,0 +1,34 @@
+{
+  "id": "tangle-gpu-provider",
+  "description": "GPU blueprint capability — operators declare GPU resource requirements (CUDA compute capability, VRAM, count). Jobs run on GPU-enabled operators; non-GPU operators skip the job. Apply to tangle-blueprint for ML-inference, 3D rendering, video encoding, and scientific-compute blueprints.",
+  "appliesTo": ["tangle-blueprint"],
+  "files": [
+    {
+      "source": "files/gpu-config.json",
+      "target": "gpu-config.json"
+    }
+  ],
+  "keywords": [
+    "gpu blueprint",
+    "gpu operator",
+    "gpu-accelerated",
+    "gpu accelerated",
+    "cuda",
+    "h100",
+    "a100",
+    "l40s",
+    "ml inference",
+    "gpu job",
+    "hardware-accelerated",
+    "video encoding",
+    "rendering blueprint"
+  ],
+  "buildHints": {
+    "whenToUse": "Attach when the job requires GPU acceleration — inference serving, video encoding, rendering, physics simulation, scientific workloads.",
+    "firstSteps": [
+      "Declare required compute capability + VRAM in gpu-config.json",
+      "Operators advertise GPU capacity via their operator registration",
+      "Your job's execution matches on capacity at dispatch time"
+    ]
+  }
+}

package/registry/layers/capability/tangle-mpp/files/mpp-config.json

@@ -0,0 +1,18 @@
+{
+  "budget": {
+    "principalAddressEnv": "MPP_PRINCIPAL_ADDRESS",
+    "maxPerCallUsdCents": 25,
+    "maxPerDelegationUsdCents": 1000,
+    "delegationTtlSeconds": 3600
+  },
+  "delegation": {
+    "tokenScheme": "signed-jwt",
+    "publicKeyEnv": "MPP_PRINCIPAL_PUBLIC_KEY"
+  },
+  "attestation": {
+    "includeInResponse": true,
+    "fields": ["principal", "delegate", "amountUsdCents", "timestamp", "signature"]
+  },
+  "settlementChain": "base",
+  "stablecoin": "USDC"
+}