Multi-Tenant Dashboard​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‌​‌‍‍‌‌‌​‌‍​‌‍‌‌​‍‍‌‍‌‌‌‍‍​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‌​‌‍‍‌‌‌​‌‍​‌‍‌‌​‍‍‌‍‌‌‌‍‍​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Overview​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‌‍‍‍​​‍‌‍​‌‌‍‌‍‌‍​‌‌‍‍‌‌‍‌​​‍​​‌​‌‍‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​​​‍​‌‍‌​‌‌‌​‌‌‍‌‍​‍‌​​​‌‍‌‌‌‍‌‍​‌‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‌‍‍‍​​‍‌‍​‌‌‍‌‍‌‍​‌‌‍‍‌‌‍‌​​‍​​‌​‌‍‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​​​‍​‌‍‌​‌‌‌​‌‌‍‌‍​‍‌​​​‌‍‌‌‌‍‌‍​‌‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

The Dashboard is a multi-tenant web application built with Next.js, designed to serve multiple organizations from a single application foundation. ​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍​‍​‌‍‍‌​‍​‌‍‌​​‍​​​‌‍‍‌​‌​‍‌‌‍‌‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​‌‍‌‌‍‍‌‌‍​‌‍‍‌‌‌‌‍​​‌​‍‌‌‍‍‌‍​‌‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍​‍​‌‍‍‌​‍​‌‍‌​​‍​​​‌‍‍‌​‌​‍‌‌‍‌‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​‌‍‌‌‍‍‌‌‍​‌‍‍‌‌‌‌‍​​‌​‍‌‌‍‍‌‍​‌‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Each organization operates within its own tenant context, with independently configurable identity, branding, and functionality — without requiring separate deployments or duplicated codebases.​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌​​​‌‌‍​​‍​​‍​‌‍‌​‌‍​‌‍​‌​‌‌​‌​​​‍‌‍‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​‌‍‌‌‍‍‌‌‍​‌‍‍‌‌‌‌‍​​‌​‍‌‌‍‍‌‍​‌‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌​​​‌‌‍​​‍​​‍​‌‍‌​‌‍​‌‍​‌​‌‌​‌​​​‍‌‍‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​‌‍‌‌‍‍‌‌‍​‌‍‍‌‌‌‌‍​​‌​‍‌‌‍‍‌‍​‌‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Each tenant can have its own: tenant identity and branding, theme configuration, enabled dashboard features, locale, user context, and analytics visualizations. For example, orgA and orgB can be configured with entirely different feature sets and visual themes, yet both are served by the same application. Tenant configuration is loaded from public/tenant.json with a strongly typed fallback to ensure safe defaults.​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​​​​​‌‍‍‌‍​‌‍‍‌‍‌‍‌‍‌‌‌‍‌​‌‍​‌‌‍‌‌‍​‌‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌​‍​‌‍‍​‌​​‌‌‌‍‍‌‌‍‌‍‌‍‌‍‌​‌‍‌​​​‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​​​​​‌‍‍‌‍​‌‍‍‌‍‌‍‌‍‌‌‌‍‌​‌‍​‌‌‍‌‌‍​‌‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌​‍​‌‍‍​‌​​‌‌‌‍‍‌‌‍‌‍‌‍‌‍‌​‌‍‌​​​‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Key Features​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‌‌​​‌‍‌​​​‌‌‌‌‍‍‌‌​‌‌‍‌‍‌‍‌‍‍‌‍​‌‌​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‌​‍​​‌‌‌‍‌‍​‌‌​‍​​​‍‌‍‌​‌​​​‌‍‍​‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‌‌​​‌‍‌​​​‌‌‌‌‍‍‌‌​‌‌‍‌‍‌‍‌‍‍‌‍​‌‌​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‌​‍​​‌‌‌‍‌‍​‌‌​‍​​​‍‌‍‌​‌​​​‌‍‍​‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Multi-Tenant Architecture​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌‍​​​​​‍‌‍‍‌‍‍‍​​​‌‍‌‍‌‍‍‌‌‍‌​‍‌‌‍‌​‌‍‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌‌‍‍‌‌‍‌‍​​‍‌‍​​‌​​‍‌‌‌‍​‌‌‌‍‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌‍​​​​​‍‌‍‍‌‍‍‍​​​‌‍‌‍‌‍‍‌‌‍‌​‍‌‌‍‌​‌‍‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌‌‍‍‌‌‍‌‍​​‍‌‍​​‌​​‍‌‌‌‍​‌‌‌‍‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Tenant-specific routes are implemented via Next.js dynamic routing using the pattern /{tenant}/{locale}. For example, /orgA/en-US and /orgB/en-US each resolve to their respective tenant contexts. The tenant layer is cleanly separated from the locale layer, allowing both dimensions to be configured independently.​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‌‍‍​‌​‌‌‌‍‍​‌‍‍‌​‌‌‍‍​​‍‌‌‍​‌​‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‍‌‌‌‍‌‌‌‍‌‍‍‌‍‌​​​‌‍​‌​‍​‌​‌‌‍​‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‌‍‍​‌​‌‌‌‍‍​‌‍‍‌​‌‌‍‍​​‍‌‌‍​‌​‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‍‌‌‌‍‌‌‌‍‌‍‍‌‍‌​​​‌‍​‌​‍​‌​‌‌‍​‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Tenant Configuration​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​‌‌​‍‌‍​​​‌‌‌‌‍‍​‌‍‍‌‍‌‌​‌‍‌​‍​​​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​​​‌‌‍‌‍‍‌‍‌‍‌‌​‌‍‌‍‌‍‍‌‌‌​‌‍‌‌‍‍‌‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​‌‌​‍‌‍​​​‌‌‌‌‍‍​‌‍‍‌‍‌‌​‌‍‌​‍​​​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​​​‌‌‍‌‍‍‌‍‌‍‌‌​‌‍‌‍‌‍‍‌‌‌​‌‍‌‌‍‍‌‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Each tenant is described by a strongly typed configuration object. The config includes the following fields: tenantId, tenantUserName, tenantName, defaultLocale, tenantEmail, isAdmin, logoUrl, theme, and features. Supported feature flags are: charts, integrations, notifications, and users.​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​​‍​‌‍‍‌‌‌‍‌‌​​‌‌‍‌‍​‌‌‍‍‌‍‌​‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​​‌‍​‌‍‌‌‌‍​‌‍​‌​‌‍‌‌‌‍‌‍​​​‌​‌‌‍‍‌‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​​‍​‌‍‍‌‌‌‍‌‌​​‌‌‍‌‍​‌‌‍‍‌‍‌​‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​​‌‍​‌‍‌‌‌‍​‌‍​‌​‌‍‌‌‌‍‌‍​​​‌​‌‌‍‍‌‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Analytics Visualizations​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌​​‍‌​​‌‍‌‌​​‌‍‌‌​​‌​‌‍‍‌‍​‌‍​‌​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‌‍‍‌‌​‍​‌‍​​‍‌‍‌​‍‌‌‍​‍​​‍‌‍‌​‌‍​‌‌‍‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌​​‍‌​​‌‍‌‌​​‌‍‌‌​​‌​‌‍‍‌‍​‌‍​‌​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‌‍‍‌‌​‍​‌‍​​‍‌‍‌​‍‌‌‍​‍​​‍‌‍‌​‌‍​‌‌‍‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Reusable chart components are built around Chart.js, including line charts, radar charts, and analytics chart compositions. Components are organized into atomic and molecular UI layers, making them easy to compose and extend across different tenant dashboards.​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍​‌‍‍​‌‍‍​‌‍‌‌‌‌‌‍‌​‌​‌‍​‌‌‍‌‍​‌‌‍‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌‌‌‌‌‍​‌‌‍‍‌​‍​‌​‌‍​‍‌​‌​​​​‌‌‍‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍​‌‍‍​‌‍‍​‌‍‌‌‌‌‌‍‌​‌​‌‍​‌‌‍‌‍​‌‌‍‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌‌‌‌‌‍​‌‌‍‍‌​‍​‌​‌‍​‍‌​‌​​​​‌‌‍‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Feature-Based Dashboard​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‌‍​‌‌​​​‍​‌​‌‍​‌​‌‍‌‌‍​‌​‌​‌‍‌‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​​‌‌​‌‌‍‌‍‌‍‌‍‍‍‌‍​‌‌‌‌‍‌‌‍​‍‌​‍​​‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‌‍​‌‌​​​‍​‌​‌‍​‌​‌‍‌‌‍​‌​‌​‌‍‌‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​​‌‌​‌‌‍‌‍‌‍‌‍‍‍‌‍​‌‌‌‌‍‌‌‍​‍‌​‍​​‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

The dashboard is composed of independently reusable modules: Charts, Users, Notifications, Integrations, and Tenant switching. Feature availability for each module is controlled through the tenant configuration, so each organization sees only the capabilities enabled for them.​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍​‌‍​‌‌​‍​​‌​​‌‍‍‍​​​​​‌‌​​‌‌‍‍‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‍​​‌‌‍‌‍‌‍‍‌‍‌‌‍‍‌​‌​​‌‍‌​​‌​‍​‌‍‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍​‌‍​‌‌​‍​​‌​​‌‍‍‍​​​​​‌‌​​‌‌‍‍‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‍​​‌‌‍‌‍‌‍‍‌‍‌‌‍‍‌​‌​​‌‍‌​​‌​‍​‌‍‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Internationalization​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​​‌‍‌‌‍​‌‍‌‌‌‍‌​‌‌‌‍‌‌‍​‌‍‍‌​​‌‍‌​‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‍‌‍​‍‌‍​‌‌‌​‌‌‍‍​​​‍​​‍‌‌‍​‌​‌​‌‍​‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​​‌‍‌‌‍​‌‍‌‌‌‍‌​‌‌‌‍‌‌‍​‌‍‍‌​​‌‍‌​‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‍‌‍​‍‌‍​‌‌‌​‌‌‍‍​​​‍​​‍‌‌‍​‌​‌​‌‍​‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Internationalization is implemented with Intlayer and next-intlayer. Supported locales are English (en) and Hindi (hi-IN), with English as the default locale.​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‌​‍‌‍​‌‍‌‌‍‍​​‍​‌‍‌‌‍‌‌‍‌‌‌​‌‍‍​​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌‌‌​‌‍‌‌‍​‌‍​‌‍​‌‍​‌‍‌​‌‌‌​‌‌​​​​‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‌​‍‌‍​‌‍‌‌‍‍​​‍​‌‍‌‌‍‌‌‍‌‌‌​‌‍‍​​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌‌‌​‌‍‌‌‍​‌‍​‌‍​‌‍​‌‍‌​‌‌‌​‌‌​​​​‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Reusable Component Architecture​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍​​​​‌‍​​​‌‌‌​‌‌​‍‌‍‍‌​‌‍‌‌‍‌‍‌‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌‍‌‍​‌​‌‌‌‍​‌‌‌​‍​‌‌‌‍​‌‌‍​‌‌‍‌‍‌‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍​​​​‌‍​​​‌‌‌​‌‌​‍‌‍‍‌​‌‍‌‌‍‌‍‌‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌‍‌‍​‌​‌‌‌‍​‌‌‌​‍​‌‌‌‍​‌‌‍​‌‌‍‌‍‌‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

The project follows a lightweight component hierarchy. Atoms include Card, LineChart, RadarChart, LocaleSwitcher, and Link. Molecules include Charts, Header, Integrations, LoginForm, Notifications, TenantDropdown, and Users. Translators handle locale-aware content rendering across all layers.​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍​​‍‌‍‍​‌‍​​‌‌‍‌‌‍‍‍‌‍‍‌‍​‌‍‌‍​​‌‌​‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌‌​‌‌‌‌‍‌‍​‌​‌​‌‌‌‌​‌‍‍‌‌‍‍‌‍‍‌‌‍‌‌‍‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍​​‍‌‍‍​‌‍​​‌‌‍‌‌‍‍‍‌‍‍‌‍​‌‍‌‍​​‌‌​‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌‌​‌‌‌‌‍‌‍​‌​‌​‌‌‌‌​‌‍‍‌‌‍‍‌‍‍‌‌‍‌‌‍‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Tech Stack​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌‌​​‍‌‍​‌​​‌‍​​‌‌‌‍‍‍‌‍​‌‍​​‌‌‍‍‌​​‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌​‍​​‌‍‌‍‍‌‌‌‍‌​‌‍‌​​‌‌‍​‍‌‍‌‍‌‌‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌‌​​‍‌‍​‌​​‌‍​​‌‌‌‍‍‍‌‍​‌‍​​‌‌‍‍‌​​‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌​‍​​‌‍‌‍‍‌‌‌‍‌​‌‍‌​​‌‌‍​‍‌‍‌‍‌‌‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

• Next.js 15​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‌‍‍‍‌‍‌‌‌‌‍‌‍​​​‍‌‍‌​‌‍‌‌​‌‌‍‌‍‍‌‍‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​​‌‌‌​‌​‌‍​‌​‌‌‍‍‌​‌‌‍‍‌‌‌‌​‌‍​‌‌‍​‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‌‍‍‍‌‍‌‌‌‌‍‌‍​​​‍‌‍‌​‌‍‌‌​‌‌‍‌‍‍‌‍‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​​‌‌‌​‌​‌‍​‌​‌‌‍‍‌​‌‌‍‍‌‌‌‌​‌‍​‌‌‍​‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌ — Application framework and routing​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‌‍‍‍‌‍‌‌‌‌‍‌‍​​​‍‌‍‌​‌‍‌‌​‌‌‍‌‍‍‌‍‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍​‌‍​​​‌‍‍‌​​‌‍‍​‌​‌‌‍‌​‍​‌‍‌‌​‌‍‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‌‍‍‍‌‍‌‌‌‌‍‌‍​​​‍‌‍‌​‌‍‌‌​‌‌‍‌‍‍‌‍‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍​‌‍​​​‌‍‍‌​​‌‍‍​‌​‌‌‍‌​‍​‌‍‌‌​‌‍‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌
• React 19​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‌​​‍‌‌‍​‌‍‌​​‍‌‌​‍‌‍‍‌‌​​‌​​​​‌‌‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​​‌​​‌​​‌‍‌‍‌​‍​​‌‌‍‌‌​‍​‌‍​​‍‌‌‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‌​​‍‌‌‍​‌‍‌​​‍‌‌​‍‌‍‍‌‌​​‌​​​​‌‌‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​​‌​​‌​​‌‍‌‍‌​‍​​‌‌‍‌‌​‍​‌‍​​‍‌‌‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌ — UI​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‌​​‍‌‌‍​‌‍‌​​‍‌‌​‍‌‍‍‌‌​​‌​​​​‌‌‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​‍‌‍‌​‌‍‍​‌‍‍‌‍‌‌​‍‌‍​‌‌​​​​​‍​‌‍‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‌​​‍‌‌‍​‌‍‌​​‍‌‌​‍‌‍‍‌‌​​‌​​​​‌‌‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​‍‌‍‌​‌‍‍​‌‍‍‌‍‌‌​‍‌‍​‌‌​​​​​‍​‌‍‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌
• TypeScript​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​‌‌‍‍‌‍‍‌‌‍‍​‌‍‍​‌‍‌‌​‍‌​‍‌‍‌​​‌‍‍​‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‌‌‌‌‍‌​‌‍​‍‌‌‌‍‍‌‌​​​‌‍‍‌‍​​‌‍‌‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​‌‌‍‍‌‍‍‌‌‍‍​‌‍‍​‌‍‌‌​‍‌​‍‌‍‌​​‌‍‍​‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‌‌‌‌‍‌​‌‍​‍‌‌‌‍‍‌‌​​​‌‍‍‌‍​​‌‍‌‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌ — Type safety​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​‌‌‍‍‌‍‍‌‌‍‍​‌‍‍​‌‍‌‌​‍‌​‍‌‍‌​​‌‍‍​‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍​‍‌‌‍​‍‌‍‍‌‍‍​‌‍​​​‌‌‍​‍‌‌​‌‍​‌‍​‌‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​‌‌‍‍‌‍‍‌‌‍‍​‌‍‍​‌‍‌‌​‍‌​‍‌‍‌​​‌‍‍​‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍​‍‌‌‍​‍‌‍‍‌‍‍​‌‍​​​‌‌‍​‍‌‌​‌‍​‌‍​‌‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌
• Tailwind CSS 4​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‌‍‍​‍‌‌​‍‌‍‍‌‍‍‌​​‌‍‍‌‌‍‍‌‍‌‌‍​‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​​‌‍‌​‌​‌‍‍‌‍‍​‌‍‌‍‍‌‍​​‌​‌‌‍​‌‍‌‍‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‌‍‍​‍‌‌​‍‌‍‍‌‍‍‌​​‌‍‍‌‌‍‍‌‍‌‌‍​‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​​‌‍‌​‌​‌‍‍‌‍‍​‌‍‌‍‍‌‍​​‌​‌‌‍​‌‍‌‍‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌ — Styling​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‌‍‍​‍‌‌​‍‌‍‍‌‍‍‌​​‌‍‍‌‌‍‍‌‍‌‌‍​‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​‍​​‌‌​‌‌‍‌‌‍‍‌‌‍‍‌‍‌‌‌​‍​‌‍‌‍‌‌‍‍​‌‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‌‍‍​‍‌‌​‍‌‍‍‌‍‍‌​​‌‍‍‌‌‍‍‌‍‌‌‍​‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​‍​​‌‌​‌‌‍‌‌‍‍‌‌‍‍‌‍‌‌‌​‍​‌‍‌‍‌‌‍‍​‌‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌
• Chart.js​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍​‌‍​‌‌‍‌​‍‌​‌​​‌​‌‍‍‍‌​​‌‍‍‌‍‌​‌‍‍​​‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌​​‍​‌‍‌‌‍​‍‌​‍‌‍‍​‌​​​​‌‌‌‍‍​​‌‌​​‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍​‌‍​‌‌‍‌​‍‌​‌​​‌​‌‍‍‍‌​​‌‍‍‌‍‌​‌‍‍​​‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌​​‍​‌‍‌‌‍​‍‌​‍‌‍‍​‌​​​​‌‌‌‍‍​​‌‌​​‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌ — Data visualization​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍​‌‍​‌‌‍‌​‍‌​‌​​‌​‌‍‍‍‌​​‌‍‍‌‍‌​‌‍‍​​‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​​‌​‍‌‍‍​‌‍‌‌​‌‍‌​‍​‌‍‍‌‍‌‌​‌‍‌‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍​‌‍​‌‌‍‌​‍‌​‌​​‌​‌‍‍‍‌​​‌‍‍‌‍‌​‌‍‍​​‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​​‌​‍‌‍‍​‌‍‌‌​‌‍‌​‍​‌‍‍‌‍‌‌​‌‍‌‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌
• Intlayer​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​‌‌‍‍‌‍‌‌‍​‌‍‍‌‍‍‌‍‍‌​‍‌‍‌‌‌‍‍‍‌‍‌​‌‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‌‍‍​‍​‌‍‍​​​‍‌​‌​‍‌‌‌​‌‌‍​​​‍‌‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​‌‌‍‍‌‍‌‌‍​‌‍‍‌‍‍‌‍‍‌​‍‌‍‌‌‌‍‍‍‌‍‌​‌‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‌‍‍​‍​‌‍‍​​​‍‌​‌​‍‌‌‌​‌‌‍​​​‍‌‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌ — Internationalization​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​‌‌‍‍‌‍‌‌‍​‌‍‍‌‍‍‌‍‍‌​‍‌‍‌‌‌‍‍‍‌‍‌​‌‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‌‌​​‍‌‍‌​‌‍‍‌‌‍​‌​​‌‍‌‍​‌​​‌‍‌‍​‍‌‍​‌‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​‌‌‍‍‌‍‌‌‍​‌‍‍‌‍‍‌‍‍‌​‍‌‍‌‌‌‍‍‍‌‍‌​‌‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‌‌​​‍‌‍‌​‌‍‍‌‌‍​‌​​‌‍‌‍​‌​​‌‍‌‍​‍‌‍​‌‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌
• next-intlayer​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‍​‌‍‌‍‍‍​​‍‌‌‌‍‌‍‌​‍​‌​‌‍‌‍​‌​‌‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌​‌​​‌‍‍‌​‌‍​‌‍‌‌‌​​​‍‌‌‍‍​‌‍‍​‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‍​‌‍‌‍‍‍​​‍‌‌‌‍‌‍‌​‍​‌​‌‍‌‍​‌​‌‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌​‌​​‌‍‍‌​‌‍​‌‍‌‌‌​​​‍‌‌‍‍​‌‍‍​‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌ — Next.js i18n integration​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‍​‌‍‌‍‍‍​​‍‌‌‌‍‌‍‌​‍​‌​‌‍‌‍​‌​‌‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‌‌​‍​​​‌‍​​​‌‌‍​‌​‌‍‍‌‍​‌‍‍‍‌‍‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‍​‌‍‌‍‍‍​​‍‌‌‌‍‌‍‌​‍​‌​‌‍‌‍​‌​‌‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‌‌​‍​​​‌‍​​​‌‌‍​‌​‌‍‍‌‍​‌‍‍‍‌‍‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌
• JWT​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‌‍‍​‍​​​‌‍‌​‌‍‌‍‌‍‌‍‌‍‌​​​‌​‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​‍​‌​‌‍​‍‌‍‍​‌‍‌​‌‍​‌‌‍‌‌‍‍‍​‍​‌‌​‌‌‍​​‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‌‍‍​‍​​​‌‍‌​‌‍‌‍‌‍‌‍‌‍‌​​​‌​‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​‍​‌​‌‍​‍‌‍‍​‌‍‌​‌‍​‌‌‍‌‌‍‍‍​‍​‌‌​‌‌‍​​‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌ — Authentication-related functionality​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‌‍‍​‍​​​‌‍‌​‌‍‌‍‌‍‌‍‌‍‌​​​‌​‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌‌‌‌‍​​‌‌‍‍‌​‍​‌‌‌‍‌​​‌‌‌‌‌‍‌‌‍‌‌‍​‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‌‍‍​‍​​​‌‍‌​‌‍‌‍‌‍‌‍‌‍‌​​​‌​‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌‌‌‌‍​​‌‌‍‍‌​‍​‌‌‌‍‌​​‌‌‌‌‌‍‌‌‍‌‌‍​‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌
• UUID​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​​‌‍​‌‌‍‌‌‍‍‍‌‌‌‌‍​‌‌‌‍‌‌‌​‌‌​​‍‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‍‌‌‍​​‍‌​‍‌‍​‌‍‍‌‍​‌‍‌​‌​‌​​‌‌‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​​‌‍​‌‌‍‌‌‍‍‍‌‌‌‌‍​‌‌‌‍‌‌‌​‌‌​​‍‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‍‌‌‍​​‍‌​‍‌‍​‌‍‍‌‍​‌‍‌​‌​‌​​‌‌‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌ — Tenant/user identifiers​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​​‌‍​‌‌‍‌‌‍‍‍‌‌‌‌‍​‌‌‌‍‌‌‌​‌‌​​‍‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌​​​‌‌‍‌​‌‍​‍​​​‌​‍​​‌‌‍‌‌​​​‍‌‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​​‌‍​‌‌‍‌‌‍‍‍‌‌‌‌‍​‌‌‌‍‌‌‌​‌‌​​‍‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌​​​‌‌‍‌​‌‍​‍​​​‌​‍​​‌‌‍‌‌​​​‍‌‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌
• ESLint​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‌‍​‌‌‌‍‍‌‍‍‌‌‌‌​‌​‌‍‌​​‍‌‍‍‌‍‌‌‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​‍‌‍‍‌​​‌‍‌‍​‌‌‌‍​‌‍‌‍​‌‍‍‌‍​‌‌​‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‌‍​‌‌‌‍‍‌‍‍‌‌‌‌​‌​‌‍‌​​‍‌‍‍‌‍‌‌‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​‍‌‍‍‌​​‌‍‌‍​‌‌‌‍​‌‍‌‍​‌‍‍‌‍​‌‌​‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌ — Code quality​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‌‍​‌‌‌‍‍‌‍‍‌‌‌‌​‌​‌‍‌​​‍‌‍‍‌‍‌‌‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‌‍‌‌​‌​​‍‌‍‍‌‌‍‌‌‌‍‌‍‌‍‍​‌‍‌‌‌‍​‌‌‍‌‌‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‌‍​‌‌‌‍‍‌‍‍‌‌‌‌​‌​‌‍‌​​‍‌‍‍‌‍‌‌‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‌‍‌‌​‌​​‍‌‍‍‌‌‍‌‌‌‍‌‍‌‍‍​‌‍‌‌‌‍​‌‌‍‌‌‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌
• Husky​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌‌​‌‌‌​‌‍‍‌​‍‌‍‌​​​‍​‌​‌‌‌​‌‌‍​‍‌‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‌​​‍​​​​​​‌‍​‌​‌‌‍‌​​‌​‍‌‍‍‍‌‍​​‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌‌​‌‌‌​‌‍‍‌​‍‌‍‌​​​‍​‌​‌‌‌​‌‌‍​‍‌‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‌​​‍​​​​​​‌‍​‌​‌‌‍‌​​‌​‍‌‍‍‍‌‍​​‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌ — Git hooks​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌‌​‌‌‌​‌‍‍‌​‍‌‍‌​​​‍​‌​‌‌‌​‌‌‍​‍‌‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍​‌​​​‌​‌‍​​‍​‌‌​‌‍‌‌​​‌‍​‍‌​‍‌‍‍‌‍‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌‌​‌‌‌​‌‍‍‌​‍‌‍‌​​​‍​‌​‌‌‌​‌‌‍​‍‌‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍​‌​​​‌​‌‍​​‍​‌‌​‌‍‌‌​​‌‍​‍‌​‍‌‍‍‌‍‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌
• lint-staged​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‌‌‌​‍‌​‌‍‌‍​‌‍​‌‌​​‌‍‌​​‌‌‍‍‌‌‍​​‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​​‌‍‌‌‌‌‌​‍​​‌‍‌‍‍‌‌‌‌‍‍‍‌‍‍‌‌‌​‍​‌‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‌‌‌​‍‌​‌‍‌‍​‌‍​‌‌​​‌‍‌​​‌‌‍‍‌‌‍​​‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​​‌‍‌‌‌‌‌​‍​​‌‍‌‍‍‌‌‌‌‍‍‍‌‍‍‌‌‌​‍​‌‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌ — Pre-commit checks​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‌‌‌​‍‌​‌‍‌‍​‌‍​‌‌​​‌‍‌​​‌‌‍‍‌‌‍​​‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‌‌​‍‌‍​‌‍‍​‍​‌‍‌‍​‌‍‍‍‌​​​​‌​‌‌‍‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‌‌‌​‍‌​‌‍‌‍​‌‍​‌‌​​‌‍‌​​‌‌‍‍‌‌‍​​‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‌‌​‍‌‍​‌‍‍​‍​‌‍‌‍​‌‍‍‍‌​​​​‌​‌‌‍‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

The project uses Next.js 15.3.2, React 19, TypeScript 5, Tailwind CSS 4, Chart.js 4.4.9, and Intlayer 5.5.0.​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​‍​‌​‌‌​‌‍‌‍‌‍‌​‍‌​‌‌‍‌‍‌‍​‌​​‌‌‍‌‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍​‌‌‍‌‌​​‌‍‍‍‌‌​‌‌‌​​‌‌‍‍​‌​‌‍‍‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​‍​‌​‌‌​‌‍‌‍‌‍‌​‍‌​‌‌‍‌‍‌‍​‌​​‌‌‍‌‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍​‌‌‍‌‌​​‌‍‍‍‌‌​‌‌‌​​‌‌‍‍​‌​‌‍‍‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Architecture​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‍‌​​‌‍‍‌​‍‌​‍​​‌‌‍‌​‌‌​‌​‌‍‌‌‍​​‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​​​​​‌‍‍​‌‍‌​​‍‌‌​‌​‌​​‌‌‍‍‌‍‍​​‍‌‍‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‍‌​​‌‍‍‌​‍‌​‍​​‌‌‍‌​‌‌​‌​‌‍‌‌‍​​‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​​​​​‌‍‍​‌‍‌​​‍‌‌​‌​‌​​‌‌‍‍‌‍‍​​‍‌‍‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Incoming requests flow through tenant and locale-aware layers before reaching the UI. The Next.js App Router routes requests to /[tenant]/[locale], where three parallel concerns are resolved: Tenant Config (theme and logo), the i18n Layer (EN/HI), and Feature Flags (Charts, Users, Notifications, Integrations). These three layers converge to produce the Analytics UI rendered for that specific tenant and locale combination. Tenant configuration is loaded from public/tenant.json with a typed fallback to ensure safe defaults at every layer.​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​​​‍​‌​‌‍‍​‌‍‍‍​‌​‌‍‍​​​​​‌​‌‍‌​​​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌‌‌‌‍​‍‌​‌​‌‌‌‍‍‍‌‍‌​‌​‌‌‍‌​‌‍​‌‍​​‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​​​‍​‌​‌‍‍​‌‍‍‍​‌​‌‍‍​​​​​‌​‌‍‌​​​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌‌‌‌‍​‍‌​‌​‌‌‌‍‍‍‌‍‌​‌​‌‌‍‌​‌‍​‌‍​​‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Getting Started​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​‌‌‍​‌‍‍‍‌‍‌‌‍‌‌‌​​​‌​‌‍‍​​‌‌‌‍​‌​​‍‌‍‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍​‌‍​​‌‍‌‍‌​‍‌‍‍‌​‌‌‍‌‌‌‌‍‌‍‌​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​‌‌‍​‌‍‍‍‌‍‌‌‍‌‌‌​​​‌​‌‍‍​​‌‌‌‍​‌​​‍‌‍‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍​‌‍​​‌‍‌‍‌​‍‌‍‍‌​‌‌‍‌‌‌‌‍‌‍‌​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Prerequisites​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌​‌​‌‌‍‌​‍​‌​‌​​‌‌‍‌‍‌‍‌​​‍​‌‍‍‌​‍‌‌‍‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‍‌‍​‌‍‍​‌‌‌​‍​​‌‌‌‌‌‍‌‍‌‌‌‍‌‍​‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌​‌​‌‌‍‌​‍​‌​‌​​‌‌‍‌‍‌‍‌​​‍​‌‍‍‌​‍‌‌‍‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‍‌‍​‌‍‍​‌‌‌​‍​​‌‌‌‌‌‍‌‍‌‌‌‍‌‍​‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Node.js 18 or later and npm are required to run this project.​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‌​‍‌‌‌‌‍‌‍‌‍‌‌​‌‌‍‌‍​​‌‍‌​‍‌‍‍​‌‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‌‌​​‍​‌‍‍‌‍​‌‍​​‌‍‌‌‌‌​‌‌‌‌‍‌‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‌​‍‌‌‌‌‍‌‍‌‍‌‌​‌‌‍‌‍​​‌‍‌​‍‌‍‍​‌‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‌‌​​‍​‌‍‍‌‍​‌‍​​‌‍‌‌‌‌​‌‌‌‌‍‌‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Installation​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍​​‌‌‍​‌​‍​‌‍‌​‌​‌‌‌‌‍​‌‍​‍​​​​‌‍‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‌‌‌‍‍​‌‌‍‌​​‌‍‌‌‍‍‌‍‍‌​​‌‍‌​‌‌‌‍‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍​​‌‌‍​‌​‍​‌‍‌​‌​‌‌‌‌‍​‌‍​‍​​​​‌‍‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‌‌‌‍‍​‌‌‍‌​​‌‍‌‌‍‍‌‍‍‌​​‌‍‌​‌‌‌‍‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

• Clone the repository: git clone https://github.com/jatinrao/concentric-analytics-prototype.git​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​‌‌‌‌‍‌​​​‌‌‌‍‌‍‌‌‍​‍​​‍‌​​‌‌‌‍‌‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‌‌‌‍‍‍‌‍‍‌​​​‌‌‌​‍‌​​‌‍‌​‌‌‌‌‍​‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​‌‌‌‌‍‌​​​‌‌‌‍‌‍‌‌‍​‍​​‍‌​​‌‌‌‍‌‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‌‌‌‍‍‍‌‍‍‌​​​‌‌‌​‍‌​​‌‍‌​‌‌‌‌‍​‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌
• cd concentric-analytics-prototype​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‌​‌‍‌‍‌​‌‌‍‌‌‌‍​‍‌‍‍‌‍‌​‌‍‌​‌‍‌‌‍‌‍‍‌‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‌‍‌‌‍‍​‌‍‍‌‍‍‍‌​‍‌‍‍‌​‍‌‍‌‌‌‍​​​‌‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‌​‌‍‌‍‌​‌‌‍‌‌‌‍​‍‌‍‍‌‍‌​‌‍‌​‌‍‌‌‍‌‍‍‌‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‌‍‌‌‍‍​‌‍‍‌‍‍‍‌​‍‌‍‍‌​‍‌‍‌‌‌‍​​​‌‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌
• npm install​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‌‌​‌‍‍‌‍‌‌‌​‍​‌​‌‍‌‍‌​​‌‌‍‌‌‍‍​‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‌​‍​‌‍‌‌‌‍​‌​​​‌‌‌‍‍‍​‌‌‌‌‌‍​‌‍‍​‌‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‌‌​‌‍‍‌‍‌‌‌​‍​‌​‌‍‌‍‌​​‌‌‍‌‌‍‍​‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‌​‍​‌‍‌‌‌‍​‌​​​‌‌‌‍‍‍​‌‌‌‌‌‍​‌‍‍​‌‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Development​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌​‌​‌‌​‌‌‌‍‌‍‍‌‌‍‌‌‍‌​‌‌‌‍‌‌‌‌‌​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​‍‌‍​‍‌‍‍‍‌‍‍‌​‌‌‌‍‌‍​‌‍‌‌‍​‌‍​​‍​‌‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌​‌​‌‌​‌‌‌‍‌‍‍‌‌‍‌‌‍‌​‌‌‌‍‌‌‌‌‌​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​‍‌‍​‍‌‍‍‍‌‍‍‌​‌‌‌‍‌‍​‌‍‌‌‍​‌‍​​‍​‌‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Start the development server with npm run dev, then open http://localhost:3000 in your browser. The dev script starts Next.js with the Node.js inspector enabled, allowing you to debug server-side behavior directly.​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‌​‍‌‍‌‌‌‍‌‍‌‍‌‌​‌‌‍​‌‌‍‌‌​​‌‍‌‌‌‍‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‌‌‍‍​‌​‍‌‍​​‌‍​‌‌‌‌​​​‌‍‌​‍‌​​‌‍‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‌​‍‌‍‌‌‌‍‌‍‌‍‌‌​‌‌‍​‌‌‍‌‌​​‌‍‌‌‌‍‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‌‌‍‍​‌​‍‌‍​​‌‍​‌‌‌‌​​​‌‍‌​‍‌​​‌‍‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Production Build​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​​‍​‌‌‌‍‌‌‍‌‍‌​‌‍​‌‍‌‍‌‌‌‍​‍‌‍‌‌‍‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​​‌‌​​‍‌​‍‌‌‌‌​‍‌‌‍‌‌‍‌​‍‌‍‍​‌‍‍​‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​​‍​‌‌‌‍‌‌‍‌‍‌​‌‍​‌‍‌‍‌‌‌‍​‍‌‍‌‌‍‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​​‌‌​​‍‌​‍‌‌‌‌​‍‌‌‍‌‌‍‌​‍‌‍‍​‌‍‍​‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Create a production build with npm run build. Start the production server with npm run start.​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‍​​‌‌‍‍​‌‍‌​‌‌‌​‌​‌‌​‌‍​‌‍‌‌‍‌​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‌‍​‌‍‌‍​‌‌‍‌‌‍‍​‌​‍‌‍‌​‌‍​‌‌​‌‌‍‌‍‌‌‍‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‍​​‌‌‍‍​‌‍‌​‌‌‌​‌​‌‌​‌‍​‌‍‌‌‍‌​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‌‍​‌‍‌‍​‌‌‍‌‌‍‍​‌​‍‌‍‌​‌‍​‌‌​‌‌‍‌‍‌‌‍‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Linting​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‌‌​‌​‌‍‍‌​​‌‍‌​‌‌‌‍‌​‌​‍​‌‌‌​​‌‍‌‌‌​‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‍‌‌‍‌‌‍‍‌​​‌​​​‌‌‌‌‌​‌‌‌​‌‍​‌​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‌‌​‌​‌‍‍‌​​‌‍‌​‌‌‌‍‌​‌​‍​‌‌‌​​‌‍‌‌‌​‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‍‌‌‍‌‌‍‍‌​​‌​​​‌‌‌‌‌​‌‌‌​‌‍​‌​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Run npm run lint to check the codebase for linting issues.​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌​‌‍‌‌‌‍‌‌‍‌‍‌‍‌‌‍‍‌‍‍‌‌​‌‍‌‌‍​‍‌‌‌‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​​‌‌‍‍‌‌‍‍‍‌‍‌‌​‌‍​‌‌​‍‌​​​‍‌​​‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌​‌‍‌‌‌‍‌‌‍‌‍‌‍‌‌‍‍‌‍‍‌‌​‌‍‌‌‍​‍‌‌‌‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​​‌‌‍‍‌‌‍‍‍‌‍‌‌​‌‍​‌‌​‍‌​​​‍‌​​‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Working With Tenants​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​‍​​‍‌‍‌​​‌​‍‌​‍​‌‍​‍​‌​‌‌‍‍‌​​‌‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌‍‌‍‍​‌‍‌‌​​‍‌‌‍‍‌‌‍‍‍​‌‍‌‍‌‌‍‌‌​‌‌‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​‍​​‍‌‍‌​​‌​‍‌​‍​‌‍​‍​‌​‌‌‍‍‌​​‌‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌‍‌‍‍​‌‍‌‌​​‍‌‌‍‍‌‌‍‍‍​‌‍‌‍‌‌‍‌‌​‌‌‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Tenant definitions live in public/tenant.json. Each tenant object defines: tenantId, tenantUserName, tenantName, defaultLocale, logoUrl, a theme object (with primaryColor, secondaryColor, font, spacing, and radius), and a features array. A second tenant can expand the features array to include charts, users, and notifications. Tenant-specific functionality is entirely declarative — feature availability is defined in configuration, outside of the UI implementation.​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‌‌​‌‌‌​‌‍​‌‌‌‍‌​‍​‍‌‌​‌‌‌‍‍​‌‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‌‍‍‌‍‍‌‌​‌‍‍‌‍‌‌‍‌‍‌​‌‍‍‌‌‌‌‌‍​‌‌‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‌‌​‌‌‌​‌‍​‌‌‌‍‌​‍​‍‌‌​‌‌‌‍‍​‌‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‌‍‍‌‍‍‌‌​‌‍‍‌‍‌‌‍‌‍‌​‌‍‍‌‌‌‌‌‍​‌‌‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Adding a New Tenant​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‌‍‌‍‌‍‌‌‍‍‍‌​‍‌‍‍​​​‌‍‌‌‍‌‍‌‍‌‌‍‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‌‌‍‌‍‍​‌‌‍‍​​‌‌‍​‌‌‌‌‍‍‍​​‌‌​‌‌‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‌‍‌‍‌‍‌‌‍‍‍‌​‍‌‍‍​​​‌‍‌‌‍‌‍‌‍‌‌‍‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‌‌‍‌‍‍​‌‌‍‍​​‌‌‍​‌‌‌‌‍‍‍​​‌‌​‌‌‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

• Open public/tenant.json​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‍‌‌‍‍​​‍​​‌‌‍‌‌‍​‍​‌‌‌‍‌​​‌‌‌‍​‌​​​‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​‌‍‌‌‌‍‍​​‌‌‍​‌‌‌​​​​‌‌‍​‌‌​‍‌‍‍​‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‍‌‌‍‍​​‍​​‌‌‍‌‌‍​‍​‌‌‌‍‌​​‌‌‌‍​‌​​​‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​‌‍‌‌‌‍‍​​‌‌‍​‌‌‌​​​​‌‌‍​‌‌​‍‌‍‍​‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌
• Add a new tenant configuration object to the array​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍​‍‌​‌‌‍‍​‌‍‌​​‌​‌‍‌‌‍​​​‍‌​​‌‍‍‍‌‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​‍‌‍​‍‌‍‌‌‍‍‌​‌‌‍‍​​​‌​‍‌‍‍‍‌‍‌‌‍‌‍‌‍‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍​‍‌​‌‌‍‍​‌‍‌​​‌​‌‍‌‌‍​​​‍‌​​‌‍‍‍‌‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​‍‌‍​‍‌‍‌‌‍‍‌​‌‌‍‍​​​‌​‍‌‍‍‍‌‍‌‌‍‌‍‌‍‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌
• Define the tenant identity and theme​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‌​‌​​‌‍​‍‌‍‌​‌‍‍‌‍‍‍‌‍‌‌​​​‌‍‌‍‌‍​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​‍‌‍‌​‍​‌‍‌‍​‌‍‍‍‌‍​‌‍‌‌​​‌‌‍​‌‌‍‍​​‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‌​‌​​‌‍​‍‌‍‌​‌‍‍‌‍‍‍‌‍‌‌​​​‌‍‌‍‌‍​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​‍‌‍‌​‍​‌‍‌‍​‌‍‍‍‌‍​‌‍‌‌​​‌‌‍​‌‌‍‍​​‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌
• Select the features available to that tenant​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‌‍‌​‍‌​​‌‌‍​‌‍‍‌‌‍​‍‌‍‍‌‍‌‌‌‍‍‌​​‌‍‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​‌‌‍​‌​​​​​‍​‌‍‌‍‍​‌‍​‍‌​‌‌‌‍​‌‍​‌‌‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‌‍‌​‍‌​​‌‌‍​‌‍‍‌‌‍​‍‌‍‍‌‍‌‌‌‍‍‌​​‌‍‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​‌‌‍​‌​​​​​‍​‌‍‌‍‍​‌‍​‍‌​‌‌‌‍​‌‍​‌‌‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌
• Start the application​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​‌‌‍​​​‍​​‌‌‍‍​‌‍​​‌‍‌‍‌​‌​‌‌​‍‌‌‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​‌​​‌‌‍‌‌‍​​​​‍​‌‌‌​​​‌​‌‍‍‍‌‍‍​‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​‌‌‍​​​‍​​‌‌‍‍​‌‍​​‌‍‌‍‌​‌​‌‌​‍‌‌‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​‌​​‌‌‍‌‌‍​​​​‍​‌‌‌​​​‌​‌‍‍‍‌‍‍​‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌
• Access the tenant through its dynamic route​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‍‌​‍‌‍‍‌‍‍​‌‌​​‌‍​‍​‌‍‌‍​‍‌‍​​‌‍‌‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​​​​​‌‌​‍​‌‍‍‌‍‌​‌‍‌​‌‍​‌​‌‌​‌‌‌‍‍‍‌‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‍‌​‍‌‍‍‌‍‍​‌‌​​‌‍​‍​‌‍‌‍​‍‌‍​​‌‍‌‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​​​​​‌‌​‍​‌‍‍‌‍‌​‌‍‌​‌‍​‌​‌‌​‌‌‌‍‍‍‌‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Adding a Locale​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‍​‌‍​‌‌‍​‌‌‌‍​‌​‌​‌‌‌‌​​​​​‌​‌​‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‌‍‌‍‌‍​‍‌‍‌‍‌‌‍‌‌‌‍‍‌‍‌‍‌‍​‌‌‍​‌‌‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‍​‌‍​‌‌‍​‌‌‌‍​‌​‌​‌‌‌‌​​​​​‌​‌​‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‌‍‌‍‌‍​‍‌‍‌‍‌‌‍‌‌‌‍‍‌‍‌‍‌‍​‌‌‍​‌‌‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Locales are configured centrally in intLayer.config.ts. The current configuration includes Locales.ENGLISH and Locales.HINDI_INDIA, with English as the default. To support another language, add the corresponding Intlayer locale constant to the config and provide the required localized content for that locale.​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​​‌​‍‌‍​‌‌‍‌‍‍‍‌‍‌‍‌​​‍‌‌‌‌‌​‍‌‍‍​​​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‌‌‌​‌‌‍‌‌‌‍‌‍‍​​‌​​‌‍‌‌‌‌‌​‍‌‍‌​​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​​‌​‍‌‍​‌‌‍‌‍‍‍‌‍‌‍‌​​‍‌‌‌‌‌​‍‌‍‍​​​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‌‌‌​‌‌‍‌‌‌‍‌‍‍​​‌​​‌‍‌‌‌‌‌​‍‌‍‌​​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Design & Engineering Decisions​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‌‍​​‌​‍‌​​​‌‌‌‍​‌‍‍​‌‍‍​‌‍​​‍‌‌‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‌‍‌‍​‌​‍​​‌‍‍​​‌‌​‌‍‌‌‌‍‍​​‌‍‌​‌‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‌‍​​‌​‍‌​​​‌‌‌‍​‌‍‍​‌‍‍​‌‍​​‍‌‌‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‌‍‌‍​‌​‍​​‌‍‍​​‌‌​‌‍‌‌‌‍‍​​‌‍‌​‌‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Configuration-driven multi-tenancy​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌‍‌‍​​‌‍​‍​​​‌‌‍‍‌‍‌‌‍‍‌‌‌‍‍​‌​‌‍​‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‌‍‍​‌‍‌‌‍‍​‌‍​‍​​​​‌‍‍‍‌‍‌‌‍​‌​‌‍‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌‍‌‍​​‌‍​‍​​​‌‌‍‍‌‍‌‌‍‍‌‌‌‍‍​‌​‌‍​‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‌‍‍​‌‍‌‌‍‍​‌‍​‍​​​​‌‍‍‍‌‍‌‌‍​‌​‌‍‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Rather than maintaining separate applications per organization, tenant differences are represented as configuration. Organizations can be added or modified without duplicating application code, keeping the codebase lean and maintainable as the number of tenants grows.​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‌​​‌‍‌‌‍‍‌‍‍‌‍‍‌‌‍​​‌‌‍‌‌‌‍​​​‌‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‌‍‌​​​‍‌‌‍‍​​‌‍‌​​‍‌‍‌‍​‌​​​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‌​​‌‍‌‌‍‍‌‍‍‌‍‍‌‌‍​​‌‌‍‌‌‌‍​​​‌‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‌‍‌​​​‍‌‌‍‍​​‌‍‌​​‍‌‍‌‍​‌​​​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Feature flags at the tenant level​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‌‌​‍‌‌‍‍​‌​​‌​‌‍‍‌​‌‌​‌‌​‍‌‌‌‌‍‍‌‌‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‌‌​​​‍​‌‍​​​​‌‍‌​‌‍‍‌‌‍‌‍‌‍‌‍‍‌‍‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‌‌​‍‌‌‍‍​‌​​‌​‌‍‍‌​‌‌​‌‌​‍‌‌‌‌‍‍‌‌‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‌‌​​​‍​‌‍​​​​‌‍‌​‌‍‍‌‌‍‌‍‌‍‌‍‍‌‍‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Feature availability is part of the tenant model as a features array. This provides a simple, declarative foundation for progressively enabling dashboard capabilities per organization, without requiring conditional logic scattered throughout the UI.​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‍‌‍​​​‍‌‍‍​‌‍‌​​‌‍‌‍‌‌‌‍‌‌‍‍‌‍‌​‍‌‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌‍‌‍​‌‍​‍​‌‌‌​‌‍‌​‌​‌‍‍‌‌‌‍‌‌‌‍​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‍‌‍​​​‍‌‍‍​‌‍‌​​‌‍‌‍‌‌‌‍‌‌‍‍‌‍‌​‍‌‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌‍‌‍​‌‍​‍​‌‌‌​‌‍‌​‌​‌‍‍‌‌‌‍‌‌‌‍​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Reusable UI primitives​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‌​​‌​‌​‌‍​‍‌‍​‌​‌‍​‌‍​‌‍‌‍‌‌‌​​‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‌‌‌​‌‍‍​​‍​‌‍​‌​​‌‌‍​​‌‌‌​‌‌​‌‍​​‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‌​​‌​‌​‌‍​‍‌‍​‌​‌‍​‌‍​‌‍‌‍‌‌‌​​‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‌‌‌​‌‍‍​​‍​‌‍​‌​​‌‌‍​​‌‌‌​‌‌​‌‍​​‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Charts, cards, links, locale switching, and other low-level components are separated from feature-level components. This makes it easier to extend individual primitives without coupling them to page-level or feature-level implementation details.​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‌​‌‌​​‌‍‌‍​‌‍‌‌​​​‌​​​‌‌​‌​​‌‌‌‌​‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​‌​​‌‌‍‌‍‌‍‌​​‌‍‌‍​‌‌​​‌‌‌​‍‌‌‌‌‍‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‌​‌‌​​‌‍‌‍​‌‍‌‌​​​‌​​​‌‌​‌​​‌‌‌‌​‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​‌​​‌‌‍‌‍‌‍‌​​‌‍‌‍​‌‌​​‌‌‌​‍‌‌‌‌‍‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Server/client boundary awareness​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​‌‍‍​​​​‌​‌‍‌‍‌‍​‌​​‌‌‌‌‌‍‍‌‍​‍‌‌‍​​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌​‌‍​‌‌​‍‌‌‍‌‌‍‌‍‍‌‍‌‍​​‍‌‍​‌‌‍‌‍‌‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​‌‍‍​​​​‌​‌‍‌‍‌‍​‌​​‌‌‌‌‌‍‍‌‍​‍‌‌‍​​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌​‌‍​‌‌​‍‌‌‍‌‌‍‌‍‍‌‍‌‍​​‍‌‍​‌‌‍‌‍‌‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Explicit handling is in place for packages that rely on Node.js APIs: fs, path, child_process, and esbuild. The Next.js configuration prevents these from being bundled into browser-side code, avoiding runtime errors in client components.​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‌‌‌‌‍‍‌‌‍‌​‌‍‌‍‌‍‍‍‌‍​​‌‌​‌‌‍‍‌‍​‍​​‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​‌‌​‌‌‍​​‌‌​​​‍‌‌‌‌‌‍‍​​‍‌‍‌‌‌‍‍‍​‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‌‌‌‌‍‍‌‌‍‌​‌‍‌‍‌‍‍‍‌‍​​‌‌​‌‌‍‍‌‍​‍​​‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​‌‌​‌‌‍​​‌‌​​​‍‌‌‌‌‌‍‍​​‍‌‍‌‌‌‍‍‍​‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Prototype Scope​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‍‌‌‍​‍‌‌​​​‌‌‍‌​‌‍‌​‌‌​‌‍​​​‌‍​‌‍‍‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌​‌‌‍‌‍‌‌‍‌‌‍‍‌‍‍​‌‌‌‍​‍‌‌‌​​‌‍​‌‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‍‌‌‍​‍‌‌​​​‌‌‍‌​‌‍‌​‌‌​‌‍​​​‌‍​‌‍‍‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌​‌‌‍‌‍‌‌‍‌‌‍‍‌‍‍​‌‌‌‍​‍‌‌‌​​‌‍​‌‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

This repository is intentionally a prototype focused on demonstrating application architecture and frontend implementation patterns. It uses local configuration and mock data rather than a production database or external analytics provider. For a production deployment, natural extensions would include:​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​​‌‍‌‍‍​‌‍‍​‌‌‍​​‍​‌‍​​​‍​‌​‌‌‍‌‍​‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍​‌‌‍‌‍​​​​​​‌‍‌‌​‌‌​‌​​​‌​‌‌‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​​‌‍‌‍‍​‌‍‍​‌‌‍​​‍​‌‍​​​‍​‌​‌‌‍‌‍​‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍​‌‌‍‌‍​​​​​​‌‍‌‌​‌‌​‌​​​‌​‌‌‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

• Persistent tenant configuration​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‌‌‍‌​​‌​​‌‍​​​​‌‍‌‍‌‌‌‌​‌‌‌‍‍​‌‍‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍​‌​‌‍‍​‌‍‌‍‌​‌‌‍​‍‌‍‍‌‍‌‌‌​​‍​‌‍‍‌‍‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‌‌‍‌​​‌​​‌‍​​​​‌‍‌‍‌‌‌‌​‌‌‌‍‍​‌‍‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍​‌​‌‍‍​‌‍‌‍‌​‌‌‍​‍‌‍‍‌‍‌‌‌​​‍​‌‍‍‌‍‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌
• Database-backed users and organizations​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‍‌‌​‌‌‍‍‌​​‍‌‍‍‌‍‍‍‌‍​‌​​‌‍​‌‍‌​‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‌‌​‌‍​‌‍​‌‍‌‌‍​‌‌‌‌‌‌​​​‌‌‍‍‌‍‌​‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‍‌‌​‌‌‍‍‌​​‍‌‍‍‌‍‍‍‌‍​‌​​‌‍​‌‍‌​‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‌‌​‌‍​‌‍​‌‍‌‌‍​‌‌‌‌‌‌​​​‌‌‍‍‌‍‌​‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌
• Real authentication and authorization​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍​​‌​‌‍‌‌‌‍‌‌‍‌‌‌‌‌​​‌‍‍‌‍‍​​​​‌‍​‌‌‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‍‌‍‌‌‍​‌‍‌‌‌‍​​​‌‌‍‌​‌​‌‍​​​​‌​​‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍​​‌​‌‍‌‌‌‍‌‌‍‌‌‌‌‌​​‌‍‍‌‍‍​​​​‌‍​‌‌‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‍‌‍‌‌‍​‌‍‌‌‌‍​​​‌‌‍‌​‌​‌‍​​​​‌​​‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌
• Role-based access control​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‌‍‍​​‌​​‍​‌​‌‌​​​‌‌‌‌‍‌‌​‍​‌​‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌​​‌‌​‌‍‍‌‌‍‌‍‌‍​‌​​‌‍​‌‌‍​‍​​‍‌‍‍‌​‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‌‍‍​​‌​​‍​‌​‌‌​​​‌‌‌‌‍‌‌​‍​‌​‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌​​‌‌​‌‍‍‌‌‍‌‍‌‍​‌​​‌‍​‌‌‍​‍​​‍‌‍‍‌​‌​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌
• Production analytics/event ingestion​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‌‍‌‍​‌‌‍‍​‌‍‍‌‍​‍‌​‍‌‍​‌‍‌​‌‍‌‌‍‌‌‌‍‌​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌​‌‍‌‌‌​‍​​​‌‌‍‌‌‌‍‍‌‍‌‌‌‌‍‍​​‌‌‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‌‍‌‍​‌‌‍‍​‌‍‍‌‍​‍‌​‍‌‍​‌‍‌​‌‍‌‌‍‌‌‌‍‌​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌​‌‍‌‌‌​‍​​​‌‌‍‌‌‌‍‍‌‍‌‌‌‌‍‍​​‌‌‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌
• Persistent notification storage​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‍‌‍‌‌‍‍‍​​‍‌‍‌‍‌‍​​‌‌​​​‌‌​‌​‍​​​‌‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​‌​‌​​‍‌‌‍​​​‍‌‍​‌‌‌‌​​‌‌‍​‌​‌‍‌‌‌‌‍‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍‍‌‍‌‌‍‍‍​​‍‌‍‌‍‌‍​​‌‌​​​‌‌​‌​‍​​​‌‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​‌​‌​​‍‌‌‍​​​‍‌‍​‌‌‌‌​​‌‌‍​‌​‌‍‌‌‌‌‍‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌
• External integrations​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‍‌‍‍‌‌‍​‍‌​‌​​‌‌​‌‍​​​‍‌‍​‌‍‍‌‌​​‌‍‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌​‌‍‌‌‌‌‍‌‍‍‌​‍​​‌​​‍‌​‌‍​‌‍‍​‌‍‌​​​‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‍‌‍‍‌‌‍​‍‌​‌​​‌‌​‌‍​​​‍‌‍​‌‍‍‌‌​​‌‍‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌​‌‍‌‌‌‌‍‌‍‍‌​‍​​‌​​‍‌​‌‍​‌‍‍​‌‍‌​​​‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌
• Audit logging​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‌​‌‍‍‍​‌​‍‌‌‍‌​‍‌​​‍​‍‌​​​​​​‌‍​​‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‌‌‍‌‌‍‌​‍​‌‍‍​‌‍​‌‌‌​‌‍‍‌‍​‌‌‍​‍‌‍‌‌‌‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‌​‌‍‍‍​‌​‍‌‌‍‌​‍‌​​‍​‍‌​​​​​​‌‍​​‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‌‌‍‌‌‍‌​‍​‌‍‍​‌‍​‌‌‌​‌‍‍‌‍​‌‌‍​‍‌‍‌‌‌‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌
• Automated tests​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‌​‌‍‌​‌‍‌‍‌​‌‍‌‍‌‌‍‌‍​‌‍‍‍​​‍‌​‌‍‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‌‍‌‌​‌‌‌‌‌​‌​‌‍‌‍​‍‌‌‍​‌‍‌‌​​‌‌‍​‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‌​‌‍‌​‌‍‌‍‌​‌‍‌‍‌‌‍‌‍​‌‍‍‍​​‍‌​‌‍‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‌‍‌‌​‌‌‌‌‌​‌​‌‍‌‍​‍‌‌‍​‌‍‌‌​​‌‌‍​‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌
• CI/CD pipeline​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​​​​‌‍‌‌‌​‍‌‍​​‌​‌‍​‌‍‍‍‌‍​‌‌‍‌​‌‍‌‍​​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‌‌‌‍​‍‌​‍‌‍‍​‌‍​‌‍‍‌‌‍‍​‍‌‌‍‍‌‍‌‌‌‌‍​‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​​​​‌‍‌‌‌​‍‌‍​​‌​‌‍​‌‍‍‍‌‍​‌‌‍‌​‌‍‌‍​​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‌‌‌‍​‍‌​‍‌‍‍​‌‍​‌‍‍‌‌‍‍​‍‌‌‍‍‌‍‌‌‌‌‍​‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌
• Observability and error tracking​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​‍‌‍‌‍‌‌‍‌‌​‌‍‍‌‌‌‌‌‌‌​‌‍‍‌‍‍​‍‌‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​‌‍‍‌‍‍‍‌‍‌‌‌‌‍‍‍​‍‌‌‍‍‌​​‌‍‍​‌​​‌‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​‍‌‍‌‍‌‌‍‌‌​‌‍‍‌‌‌‌‌‌‌​‌‍‍‌‍‍​‍‌‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​‌‍‍‌‍‍‍‌‍‌‌‌‌‍‍‍​‍‌‌‍‍‌​​‌‍‍​‌​​‌‌‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌
• Secure tenant isolation at the API/data layer​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​‌​‌​‌‍‍‌‍‍‌‌​​‌‍‌‌‌‌‍‍​​‍‌‍‍‌‍‍‍​​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‍​​‌‍‌​‌​‌​​‌‌‌‍​‍‌​‌​‌‌‍‌‍​‌‌‍‌‌​‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​‌​‌​‌‍‍‌‍‍‌‌​​‌‍‌‌‌‌‍‍​​‍‌‍‍‌‍‍‍​​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‍​​‌‍‌​‌​‌​​‌‌‌‍​‍‌​‌​‌‌‍‌‍​‌‌‍‌‌​‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Deployment​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​​‌​‌‌‍​‍‌‍​‌‍‍‌​‌‍​‍​‌‍‌‍‍‌​‍​‌‌‍‌​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌‌‌​‍‌‍‍‌‌​‌‍​​‌‌​‍​​​​​‍‌‍‌‍‌‍​​‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​​‌​‌‌‍​‍‌‍​‌‍‍‌​‌‍​‍​‌‍‌‍‍‌​‍​‌‌‍‌​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌‌‌​‍‌‍‍‌‌​‌‍​​‌‌​‍​​​​​‍‌‍‌‍‌‍​​‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

This is a standard Next.js application deployable to any platform that supports Next.js. Build with npm run build and run with npm run start. For Vercel, connect the repository and use the standard Next.js build configuration — no additional setup is required.​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍​‌​‍‌‌​​‌‌​​‍‌‍​‌‍​‌​​‌‌​​‌​​‌‌‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‍​‌‍‍​‍‌‌‍‍‌​‍‌​​​‌​‍‌​​‌‍‌‌‍‍​​‍‌‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍​‌​‍‌‌​​‌‌​​‍‌‍​‌‍​‌​​‌‌​​‌​​‌‌‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‍​‌‍‍​‍‌‌‍‍‌​‍‌​​​‌​‍‌​​‌‍‌‌‍‍​​‍‌‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Why This Architecture?​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍​‌‌‍​‍‌​‌‍‌‍‌‍‍​‌‌‌‍‌‍‌‍‌‌‍‌‌‍‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‌‍‍​‌‌‌‍‌‌‌‌​‍‌‌‍‌‍‍‌‍‍‌‍​‌‍‌​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‍​‌‌‍​‍‌​‌‍‌‍‌‍‍​‌‌‌‍‌‍‌‍‌‌‍‌‌‍‍‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍​‌‍‍​‌‌‌‍‌‌‌‌​‍‌‌‍‌‍‍‌‍‍‌‍​‌‍‌​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

The prototype prioritizes separation of concerns and extensibility. The core idea flows as: Tenant → Configuration → Features + Theme + Locale → Reusable Components → Analytics Dashboard. This allows the same application foundation to serve different organizations while keeping all tenant-specific behavior configurable and isolated from the core UI implementation.​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​‌‍‍‍‌‍​‌‍‌‌​​‍‌‍‍‌‍​‌‍‌‍​‌‌​‌‍​‌​​‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌‍‌‌‌​​‌​‌‌​‌‍‌‍‌‍‌​‍‌‍‌‌‍‌‍​​‌​‌‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌​‌‍‍‍‌‍​‌‍‌‌​​‍‌‍‍‌‍​‌‍‌‍​‌‌​‌‍​‌​​‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​‌‍‌‌‌​​‌​‌‌​‌‍‌‍‌‍‌​‍‌‍‌‌‍‌‍​​‌​‌‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Status & License​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‌‌‍​‌‍‍​​‍​‌‌‍‌‍​‌‍‌‍‌‍‌‌‍‌​‌‍​‌‌‍​‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‌​​​‌‍​‍‌‌‌​‍​‌‍‌‌‌‍‌‍‍​​‍‌​‍‌‌‍‌‍‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‌‌‍​‌‍‍​​‍​‌‌‍‌‍​‌‍‌‍‌‍‌‌‍‌​‌‍​‌‌‍​‍​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‌​​​‌‍​‍‌‌‌​‍​‌‍‌‌‌‍‌‍‍​​‍‌​‍‌‌‍‌‍‍‌​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

Prototype / Assignment Submission. The repository demonstrates a working multi-tenant analytics dashboard architecture using Next.js App Router, typed tenant configuration, feature-based rendering, reusable visualization components, and internationalization.​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‍‌‍​‌​‍‌‌‌​​​​​‌​‍‌​‍​‌‍‌​‌‍​‌​​​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‌​​‌‌‌‍​‌‍​‍‌‍‌‍‌‍​​‌‌‌‌‌‍‌​​‍‌‌‍​‌​​‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‍‌‍‌‍​‌​‍‌‌‌​​​​​‌​‍‌​‍​‌‍‌​‌‍​‌​​​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‌​​‌‌‌‍​‌‍​‍‌‍‌‍‌‍​​‌‌‌‌‌‍‌​​‍‌‌‍​‌​​‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌

This project was created as a technical assignment/prototype and is provided for evaluation and portfolio purposes.​​​​‌‍​‍​‍‌‍‌​‍‌‍‍‌‌‍‌‌‍‍‌‌‍‍​‍​‍​‍‍​‍​‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌‍‍‌‌‍​‍​‍​‍​​‍​‍‌‍‍​‌​‍‌‍‌‌‌‍‌‍​‍​‍​‍‍​‍​‍‌‍‍​‌‌​‌‌​‌​​‌​​‍‍​‍​‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‍‌‌‍‍‌‌​‌‍‌‌‌‍‍‌‌​​‍‌‍‌‌‌‍‌​‌‍‍‌‌‌​​‍‌‍‌‌‍‌‍‌​‌‍‌‌​‌‌​​‌​‍‌‍‌‌‌​‌‍‌‌‌‍‍‌‌​‌‍​‌‌‌​‌‍‍‌‌‍‌‍‍​‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​​‌‍‌‌​‍‌‌‍​​​​‌‌‌​‍‌‍‌​‌​‌‍‍‍‌‍‌‍‌‍‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‌​‌‌‍​‍​‌‌‌‌‍​‌​‌‍​​‌‌‌‍​​​‍‌​‍‌​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‌‍​‍‌‍​‌‌​‌‍‌‌‌‌‌‌‌​‍‌‍​​‌‌‍‍​‌‌​‌‌​‌​​‌​​‍‌‌​​‌​​‌​‍‌‌​​‍‌​‌‍​‍‌‌​​‍‌​‌‍‌‍‍‍‌‍​‌‌‌​‌‍‍‌‌‍‍​‍‌‌‍‍‌‌‌‌‍‌‌‍​‌‌​‍​‍‍‌​‌‍​‌‌‍‍‌‍‍‌‌‌​‌‍‌​‍‍‌​‌‌​‌‌‌‌‍‌​‌‍‍‌‌‍​‍‌‍‌‍‍‌‌‍‌​​‌‌‍​‌‌‍​‍‌‍‌‍​‍‌‌‍​‌‍‌​​‌​​​‍‌​​‌​‌​‌‍‌​​​​​‍‌​‌​​​‌‌‍‌‍​‌​​‍‌‌‍​‌​‌‍​‌​‌‍​‍​‍‌‌‍‌‍‌‍​‍‌‍​‌‍‌‍​​‍​‌‍​‍‌​​‍​​​​​​​‍‌​‌‌​‍‌‍‌‌​‌‍‌‌​​‌‍‌‌​‌‌​​‌​‍‌‍‌‍‍‍‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍​‌‌‌​‌‍‍​​‌‌‍​‍‌‍‌‍‌​‌‍‌​‍‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍​​​‌‍‌‌​‍‌‌‍​​​​‌‌‌​‍‌‍‌​‌​‌‍‍‍‌‍‌‍‌‍‌‍​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‍​‌‍‍​‌‍‍‌‌‍​‌‍‌​‌​‍‌‍‌‌‌‍‍​‍‌‌​‌‌‌​​‍‌‌‌‍‍‌‍‌‌‌‍‌​‍‌‌​​‌​‌​​‍‌‌​​‌​‌​​‍‌‌​​‍​​‍‌‌​‌‌‍​‍​‌‌‌‌‍​‌​‌‍​​‌‌‌‍​​​‍‌​‍‌​​​‍‌‌​​‍​​‍​‍‌‌​‌‌‌​‌​​‍‍‌‌​‌‍‌‌‌‍​‌‌​​‍‌‍‌​​‌‍‌‌‌​‍‌​‌​​‌‍‌‌‌‍​‌‌​‌‍‍‌‌‌‍‌‍‌‌​‌‌​​‌‌‌‌‍​‍‌‍​‌‍‍‌‌​‌‍‍​‌‍‌‌‌‍‌​​‍​‍‌‌